1. Início
  2. Docs
  3. DBManager
  4. Cabeçalho
  5. [ Classe ] DBManager

[ Classe ] DBManager

Classe singleton derivada de QSqlDatabase que gerencia uma conexão única da aplicação com o banco de dados.

Métodos herdados

A DBManager herda diversos métodos da classe QSqlDatabase. Não se esqueça de dar uma olhada na documentação do Qt também!

Estes são alguns dos métodos herdados mais úteis/importantes

Retorno Nome do método
bool open()
bool isOpen()
bool isValid()
void close()
QSqlError lastError()

Métodos estáticos

Retorno Nome do método
DBManager * [ static ] getInstance(const DBData &data = DBData())
QVariant [ static ] pixmapToVariant(const QPixmap &pixmap)
QPixmap [ static ] variantToPixmap(const QVariant &variant)
QString [ static ] getUniqueConnectionName(const QString &partname = "")

Métodos de classe

Retorno Nome do método
bool removeInstance()
bool createTable(const QString &tableName, const QStringList &columns)
bool insertRow(const QString &tableName, const QStringList &columnName, const QVariantList &data)
bool updateRow(const QString &tableName, const QString &columnNameCond, const QVariant &condition, const QStringList &columnName, const QVariantList &data, const QString &operation = "=")
bool updateRow(const QString &tableName, const QStringList &columnNameCond, const QVariantList &condition, const QStringList &columnName, const QVariantList &data, const QString &operation = "=")
bool removeRow(const QString &tableName, const QString &columnNameCond, const QVariant &condition, const QString &operation = "=")
bool removeRow(const QString &tableName, const QStringList &columnNameCond, const QVariantList &condition, const QString &operation = "=")
bool rowExists(const QString &tableName, const QString &columnNameCond, const QVariant &data, const QString &operation = "=")
bool rowExists(const QString &tableName, const QStringList &columnNameCond, const QVariantList &data, const QString &operation = "=")
QVariantList retrieveRow(const QString &tableName, const QString &columnNameCond, const QVariant &condition, const QString &operation = "=")
QVariantList retrieveRow(const QString &tableName, const QStringList &columnNameCond, const QVariantList &condition, const QString &operation = "=")
QVariantList retrieveRow(const QString &tableName, const QStringList &columnNameCond, const QVariantList &condition, QStringList columnName, const QString &operation = "=")
QList< QVariantList > retrieveAll(const QString &tableName, const QStringList &columns = QStringList(), const QStringList &groupby = QStringList(), const QStringList &orderby = QStringList())
QList< QVariantList > retrieveAllCond(const QString &tableName, const QString &columnCondition, const QVariant &condition, const QString &operation = "=", const QStringList &orderby = QStringList())
QList< QVariantList > retrieveAllCond(const QString &tableName, const QStringList &columnCondition, const QVariantList &condition, const QString &operation = "=", const QStringList &orderby = QStringList())
QList< QVariantList > retrieveAllCond(const QString &tableName, const QStringList &columnName, const QString &columnCondition, const QVariant &condition, const QString &operation = "=", const QStringList &groupby = QStringList(), const QStringList &orderby = QStringList())
QList< QVariantList > retrieveAllCond(const QString &tableName, const QStringList &columnName, const QStringList &columnCondition, const QVariantList &condition, const QString &operation = "=", const QStringList &groupby = QStringList(), const QStringList &orderby = QStringList())
int rowsCount(const QString &tableName)
int rowsCountCond(const QString &tableName, const QString &columnCondition, const QVariant &condition, const QString &operation = "=")
int rowsCountCond(const QString &tableName, const QStringList &columnCondition, const QVariantList &condition, const QString &operation = "=")
bool clearTable(const QString &tableName)
bool dropTable(const QString &tableName)
QSqlQuery createCustomQuery(const QString &query = "")
bool setConnectionType(DBConnectionType cType)
DBConnectionType connectionType()
bool setConnectionName(const QString &cName)
QString currentConnectionName()
bool setDBPrefix(const QString &prefix)
QString dbPrefix()
bool setDatabaseData(const DBManager::DBData &dbData)
DBManager::DBData databaseData()

open()

Inicia a conexão com o banco de dados (de acordo com o nome da conexão). Retorna true caso haja sucesso, ou false, caso contrário.

Veja a documentação em: http://doc.qt.io/qt-5/qsqldatabase.html#open.

if (myDB->open()){
    // ... Do something ...
}

isOpen()

Returna true caso a conexão atual estiver aberta.

Veja a documentação em: http://doc.qt.io/qt-5/qsqldatabase.html#isOpen.

bool isOpen = myDB->isOpen();

isValid()

Retorna true caso o banco de dados tenha um driver válido.

Veja a documentação em: http://doc.qt.io/qt-5/qsqldatabase.html#isValid.


close()

Encerra a conexão atual com o banco de dados.

Veja a documentação em: http://doc.qt.io/qt-5/qsqldatabase.html#close.

myDB->closeDB();

lastError()

Este método retorna a causa do último erro com relação à manipulação do banco de dados, como por exemplo, sintaxe da requisição, posição ou tipo inválido, etc.

Veja a documentação em: https://doc.qt.io/qt-5/qsqldatabase.html#lastError.
Veja a documentação em [QSqlError]: http://doc.qt.io/qt-5/qsqlerror.html.

myDB->lastError();

[ static ] getInstance(const DBData &data = DBData())

Método singleton que constrói e retorna um objeto com as propriedades definidas na classe DBManager::DBData, incluindo o nome da tabela, host, usuário, senha, etc.

Vale notar que a conexão não é aberta assim que o construtor é executado, ou seja, a chamada do método "openDB()" deve ser feita para que a conexão seja estabelecida.

Caso os dados estejam inconsistentes, o construtor (privado) disparará uma excessão, que será repassada ao método "getInstance" e o objeto não será criado.

DBManager::DBData myData;
myData.setHostName("127.0.0.1");
myData.setPort(3306);
myData.setDatabaseName("test");
myData.setUserName("root");
myData.setPassword("");
myData.setDatabaseConnectionType(DBManager::MYSQL);
myData.setTablePrefix("mtt_");
myData.setConnectionName(DBManager::getUniqueConnectionName("sqlite_c_"));

DBManager *myDB;
try {
    //If the database name is not empty or the database type is undefined
    //The new instance is not built and an exception is thrown
    myDB = DBManager::getInstance(myData);
} catch (std::invalid_argument e){
    qDebug() << e.what();
}

[ static ] pixmapToVariant(const QPixmap &pixmap)

Este método retorna um QVariant gerado a partir do QPixmap fornecido como parâmetro. Ele é útil ao armazenar imagens no banco de dados.

QPixmap randomImage;
randomImage.load(QDir::homePath() + "/Pictures/Nintersoft/ns-logo.png");
QVariant imageVariant = DBManager::pixmapToVariant(randomImage);
myDB->insertRow("testImageTable", QStringList() << "IMAGE", QList<QVariant>() << imageVariant);

[ static ] variantToPixmap(const QVariant &variant)

Este método retorna um uma imagem gerada a partir do QVariant fornecido como parâmetro. Ele é útil para recuperar imagens do banco de dados.

QPixmap retrievedImage = DBManager::variantToPixmap(myDB->retrieveRow("testImageTable", QStringList() << "ID", QList<QVariant>() << 1, QStringList() << "IMAGE").at(0));

Caso haja uma entrada inválida, um QPixmap nulo é retornado.


[ static ] getUniqueConnectionName(const QString &partname = "")

Este método retorna uma QString única, que pode ser utilizada como nome de conexão para o banco de dados (evita que conexões com mesmo nome possam ser interrompidas). O parâmetro partName é usado como prefixo.

QString connection = DBManager::getUniqueConnectionName("test");

removeInstance()

Este método tenta remover a instância atual do DBManager (que terá de ser reiniciado, caso haja necessidade). Retorna true caso consiga, ou false caso haja alguma falha ou impedimento.


createTable(const QString &tableName, const QStringList &columns)

Este método cria novas tabelas no banco de dados, onde o primeiro parâmetro é o nome da tabela e o segundo é a lista de strings contendo o nome da coluna e o tipo de dado que será armazenado nela.

myDB->createTable("testTable", QStringList() << "ID INTEGER PRIMARY KEY" << "NAME TEXT NOT NULL"
<< "PARENT TEXT NOT NULL" << "AGE INTEGER NOT NULL"); // SQLite Implementation

myDB->createTable("testTable" , QStringList() << "ID INTEGER(64) UNSIGNED AUTO_INCREMENT PRIMARY KEY" << "NAME TEXT NOT NULL"
<< "PARENT TEXT NOT NULL" << "AGE INTEGER NOT NULL"); // MySQL Implementation

Retorna true caso consiga executar a requisição, ou false, caso contrário.


insertRow(const QString &tableName, const QStringList &columnName, const QVariantList &data)

Este método insere dados na tabela já existente (recebida como primeiro parâmetro), onde o segundo parâmetro é o nome das colunas e o terceiro são os dados correspondentes às colunas.

myDB->insertRow("testTable", QStringList() << "NAME" << "PARENT" << "AGE",
               QList<QVariant>() << "Mauro Mascarenhas" << "Paulo Francisco" << 20);

Retorna true caso consiga executar a requisição, ou false, caso contrário.


updateRow(const QString &tableName, const QString &columnNameCond, const QVariant &condition, const QStringList &columnName, const QVariantList &data, const QString &operation = "=")

Este método atualiza os valores da tabela fornecida no primeiro parâmetro. Os novos valores são fornecidos no quinto parâmetro e suas respectivas colunas no quarto parâmetro.

Por fim, o segundo e o terceiro parâmetro fornecem as condições das colunas cuja tupla será atualizada. A operação de comparação a ser realizada na condição de coluna é fornecida no sexto parâmetro (a operação é de igualdade, por padrão).

myDB->updateRow("testTable", "NAME", "Mauro Mascarenhas",
                      QStringList() << "NAME" << "PARENT",
                      QList<QVariant>() << "Mauro Mascarenhas de Araújo" << "Ana Cláudia Mascarenhas");

Retorna true caso consiga executar a requisição, ou false, caso contrário.


updateRow(const QString &tableName, const QStringList &columnNameCond, const QVariantList &condition, const QStringList &columnName, const QVariantList &data, const QString &operation = "=")

Este método é uma sobrecarga, onde é possível fornecer mais de uma coluna e valores para comparação do condicional.

myDB->updateRow("testTable", QStringList() << "NAME" << "PARENT",
                      QList<QVariant>() << "Fábio Francisco" << "Paulo Francisco",
                      QStringList() << "NAME" << "AGE",
                      QList<QVariant>() << "Fábio Francisco de Araújo" << 19);

Retorna true caso consiga executar a requisição, ou false, caso contrário.


removeRow(const QString &tableName, const QString &columnNameCond, const QVariant &condition, const QString &operation = "=")

Este método remove da tabela (indicada no primeiro parâmetro da chamada) todas as ocorrências de tuplas que satisfazem a condição imposta pela operação sobre as colunas e valores fornecidos.

myDB->removeRow("testTable", "NAME", "Mauro Mascarenhas");

Retorna true caso consiga executar a requisição, ou false, caso contrário.


removeRow(const QString &tableName, const QStringList &columnNameCond, const QVariantList &condition, const QString &operation = "=")

Este método é uma sobrecarga, onde é possível fornecer mais de uma coluna e valores para comparação do condicional.

myDB->removeRow("testTable", QStringList() << "NAME" << "AGE",
                      QList<QVariant>() << "Fábio Francisco de Araújo" << 19);

Retorna true caso consiga executar a requisição, ou false, caso contrário.


rowExists(const QString &tableName, const QString &columnNameCond, const QVariant &data, const QString &operation = "=")

Este método verifica se há alguma tupla da relação onde as colunas assumem os valores dos dados definidos de acordo com a operação requisitada. Ele retorna true caso exista, ou false caso não exista ou haja algum erro na sintaxe da coluna ou do dado fornecido.

myDB->rowExists("testTable", QStringList() << "NAME" << "AGE",
                     QList<QVariant>() << "Fábio Francisco de Araújo" << 19);

rowExists(const QString &tableName, const QStringList &columnNameCond, const QVariantList &data, const QString &operation = "=")

Este método é uma sobrecarga, onde é possível fornecer mais de uma coluna e valores para comparação do condicional.

myDB->rowExists("testTable", "NAME", "Mauro Mascarenhas de Araújo");

Ele retorna true caso exista, ou false caso não exista ou haja algum erro na sintaxe da coluna ou do dado fornecido.


retrieveRow(const QString &tableName, const QString &columnNameCond, const QVariant &condition, const QString &operation = "=")

Este método é similar ao "rowExists". Porém, ao invés de apenas informar se existe alguma tupla ou não, este método retorna a primeira ocorrência por completo, isto é, os dados de todas as colunas correspondentes ao resultado dos termos de busca.

myDB->retrieveRow("testTable", "NAME", "Mauro Mascarenhas de Araújo");

Retorna uma lista vazia caso não haja resultado de requisição ou se houver algum erro (de sintaxe ou tamanho) nos parâmetros.


retrieveRow(const QString &tableName, const QStringList &columnNameCond, const QVariantList &condition, const QString &operation = "=")

Este método é uma sobrecarga, onde é possível fornecer mais de uma coluna e valores para comparação do condicional.

myDB->retrieveRow("testTable", QStringList() << "NAME" << "AGE",
                        QList<QVariant>() << "Fábio Francisco de Araújo" << 19);

Retorna uma lista vazia caso não haja resultado de requisição ou se houver algum erro (de sintaxe ou tamanho) nos parâmetros.


retrieveRow(const QString &tableName, const QStringList &columnNameCond, const QVariantList &condition, QStringList columnName, const QString &operation = "=")

Este método é uma sobrecarga, onde é possível fornecer mais de uma coluna e valores para comparação do condicional. Também é possível especificar quais colunas deverão constar na lista retornada.

myDB->retrieveRow("testTable", QStringList() << "NAME" << "AGE",
                              QList<QVariant>() << "Fábio Francisco de Araújo" << 19,
                              QStringList() << "AGE");

Retorna uma lista vazia caso não haja resultado de requisição ou se houver algum erro (de sintaxe ou tamanho) nos parâmetros.


retrieveAll(const QString &tableName, const QStringList &columns = QStringList(), const QStringList &groupby = QStringList(), const QStringList &orderby = QStringList())

Este método é similar ao "retrieveRow", porém, ao invés de retornar apenas a primeira ocorrência, ele retorna todas elas (por isso é utilizado uma lista de lista de QVariant).

myDB->retrieveAll("testTable");

Retorna uma lista vazia caso não haja resultado de requisição ou se houver algum erro (de sintaxe ou tamanho) nos parâmetros.


retrieveAllCond(const QString &tableName, const QString &columnCondition, const QVariant &condition, const QString &operation = "=", const QStringList &orderby = QStringList())

Este método é similar ao "retrieveAll", porém, ele retorna todas as linhas da tabela onde as colunas assumem os valores dos dados definidos de acordo com a operação requisitada.

myDB->retrieveAllCond("testTable", "NAME", "%Fábio%", "LIKE");

Retorna uma lista vazia caso não haja resultado de requisição ou se houver algum erro (de sintaxe ou tamanho) nos parâmetros.


retrieveAllCond(const QString &tableName, const QStringList &columnCondition, const QVariantList &condition, const QString &operation = "=", const QStringList &orderby = QStringList())

Este método é uma sobrecarga, onde é possível fornecer mais de uma coluna e valores para comparação do condicional.

myDB->retrieveAllCond("testTable", QStringList() << "NAME" << "AGE",
                            QList<QVariant>() << "Fábio Francisco de Araújo" << 19);

Retorna uma lista vazia caso não haja resultado de requisição ou se houver algum erro (de sintaxe ou tamanho) nos parâmetros.


retrieveAllCond(const QString &tableName, const QStringList &columnName, const QString &columnCondition, const QVariant &condition, const QString &operation = "=", const QStringList &groupby = QStringList(), const QStringList &orderby = QStringList())

Este método é uma sobrecarga, onde também é possível especificar quais colunas deverão constar na lista retornada.

myDB->retrieveAllCond("testTable", QStringList() << "NAME" << "AGE",
                                                  QStringList() << "NAME" << "AGE",
QList<QVariant>() << "Fábio Francisco de Araújo" << 19)

Retorna uma lista vazia caso não haja resultado de requisição ou se houver algum erro (de sintaxe ou tamanho) nos parâmetros.


retrieveAllCond(const QString &tableName, const QStringList &columnName, const QStringList &columnCondition, const QVariantList &condition, const QString &operation = "=", const QStringList &groupby = QStringList(), const QStringList &orderby = QStringList())

Este método é uma sobrecarga, onde é possível fornecer mais de uma coluna e valores para comparação do condicional. Também é possível especificar quais colunas deverão constar na lista retornada.

myDB->retrieveAllCond("testTable", QStringList() << "SUM(AGE)",
                                                  QStringList() << "NAME" << "AGE",
                                                  QList<QVariant>() << "Fábio Francisco de Araújo" << 19,
                                                  "=",
QStringList(), QStringList() << "ID ASC")

Retorna uma lista vazia caso não haja resultado de requisição ou se houver algum erro (de sintaxe ou tamanho) nos parâmetros.


rowsCount(const QString &tableName)

Este método retorna a quantidade de tuplas na relação.

int rows = myDB->rowsCount("testTable");

Retorna -1 caso haja algum erro.


rowsCountCond(const QString &tableName, const QString &columnCondition, const QVariant &condition, const QString &operation = "=")

Este método retorna a quantidade de linhas da tabela que satisfazem a condição especificada no quarto parâmetro.

Os valores e colunas a serem comparados devem ser fornecidos no segundo e terceiro parâmetro.

int rows = myDB->rowsCountCond("testTable", "NAME", "Mauro Mascarenhas de Araújo");

Retorna -1 caso haja algum erro.


rowsCountCond(const QString &tableName, const QStringList &columnCondition, const QVariantList &condition, const QString &operation = "=")

Este método é uma sobrecarga, onde é possível fornecer mais de uma coluna e valores para comparação do condicional.

myDB->rowsCountCond("testTable", QStringList() << "NAME" << "AGE",
                         QList<QVariant>() << "Fábio Francisco de Araújo" << 19);

Retorna -1 caso haja algum erro.


clearTable(const QString &tableName)

Este método limpa a tabela especificada como parâmetro, mas não a exclui.

myDB->clearTable("testTable");

Retorna true caso consiga executar a requisição, ou false, caso contrário.


dropTable(const QString &tableName)

Este método exclui a tabela especificada como parâmetro.

myDB->dropTable("testTableDrop");

Retorna true caso consiga executar a requisição, ou false, caso contrário.


createCustomQuery(const QString &query = "")

Retorna um objeto QSqlQuery construído com base na conexão ao banco de dados atual. Com este objeto, o desenvolvedor estará hábil a executar qualquer comando SQL desejado.

QSqlQuery testC = myDB->createCustomQuery();
testC.prepare("DROP TABLE mtt_testTableDrop1");
testC.exec();

setConnectionType(DBConnectionType cType)

Troca o tipo de banco de dados ao qual o DBManager deverá conectar-se.

if (myDB->setConnectionType(DBManager::MYSQL)) /* Do something */;

Retorna true caso seja possível defini-lo ou false, caso contrário (note que não é possível trocar o tipo de banco de dados enquanto a conexão estiver ativa).


connectionType()

Retorna o tipo de banco de dados atualmente configurado.

switch (myDB->connectionType()){
    case DBManager::MYSQL :
        //....
    break;
    default:
        //....
    break;
}

setConnectionName(const QString &cName)

Define um novo nome para a conexão ao banco de dados.

if (myDB->setConnectionName(DBManager::getUniqueConnectionName("test_"))) /* Do something */;

Retorna true caso seja possível defini-lo ou false, caso contrário (note que não é possível trocar o nome da conexão enquanto ela estiver ativa).


currentConnectionName()

Retorna o nome atual da conexão.

QString connection = myDB->currentConnectionName();

setDBPrefix(const QString &prefix)

Define um novo prefixo padrão para as tabelas da conexão do banco de dados.

myDB->setDBPrefix("lol_");

Retorna true caso seja possível defini-lo ou false, caso contrário (note que não é possível trocar o prefixo das tabelas enquanto a conexão estiver ativa).


dbPrefix()

Retorna o prefixo atual do banco de dados.

QString prefix = myDB->dbPrefix();

setDatabaseData(const DBManager::DBData &dbData)

Define uma nova configuração para a conexão ao banco de dados.

if (myDB->setDatabaseData(myData)) /* Do something */;

Retorna true caso seja possível defini-lo ou false, caso contrário (note que não é possível trocar as configurações enquanto a conexão estiver ativa).


databaseData()

Retorna as configurações atuais do banco de dados.

const DBManager::DBData temp = myDB->databaseData();