问题
I got confused with the manual , should i work like this:
{
QSqlDatabase db = QSqlDatabase::addDatabase (...);
QSqlQuery query (db);
query.exec (...);
}
QSqlDatabase::removeDatabase (...);
As the document points out, query
or db
will be deconstructed automatically.
But is that efficient ?
Well , if i cache db
inside a class , like the following:
class Dummy {
Dummy() {
db = QSqlDatabase::addDatabase (...);
}
~Dummy() {
db.close();
}
bool run() {
QSqlQuery query (db);
bool retval = query.exec (...);
blabla ...
}
private:
QSqlDatabase db;
};
Sometimes i could see warnings like:
QSqlDatabasePrivate::removeDatabase: connection 'BLABLA' is still in use, all queries will cease to work.
Even if i didn't call run()
.
回答1:
When you create a QSqlDatabase
object with addDatabase
or when you call removeDatabase
, you are merely associating or disassociating a tuple (driver, hostname:port, database name, username/password) to a name (or to the default connection name if you don't specify a connection name).
The SQL driver is instantiated, but the database will only be opened when you call QSqlDatabase::open
.
That connection name is defined application-wide. So if you call addDatabase
in each of the objects that use it, you are changing all QSqlDatabase
objects that uses the same connection name and invalidating all queries that were active on them.
The first code example you cited shows how to correctly disassociate the connection name, by ensuring that:
- all
QSqlQuery
are detached from theQSqlDatabase
before closing the database by callingQSqlQuery::finish()
, which is automatic when theQSqlQuery
object goes out of scope, - all
QSqlDatabase
with the same connection name areclose()
d when you callQSqlDatabase::removeDatabase
(close()
is also called automatically when theQSqlDatabase
object goes out of scope).
When you create the QSqlDatabase, depending on whether you want the connection to stay open for the application lifetime (1) or just when needed (2), you can:
keep a single
QSqlDatabase
instance in one single class (for example, in your mainwindow), and use it in other objects that needs it either by passing theQSqlDatabase
directly or just the connection name that you pass toQSqlDatabase::database
to get theQSqlDatabase
instance back.QSqlDatabase::database
usesQHash
to retrieve aQSqlDatabase
from its name, so it is probably negligibly slower than passing theQSqlDatabase
object directly between objects and functions, and if you you use the default connection, you don't even have to pass anything anywhere, just callQSqlDatabase::database()
without any parameter.// In an object that has the same lifetime as your application // (or as a global variable, since it has almost the same goal here) QSqlDatabase db; // In the constructor or initialization function of that object db = QSqlDatabase::addDatabase("QSQLDRIVER", "connection-name"); db.setHostname(...); // ... if(!this->db.open()) // open it and keep it opened { // Error handling... } // -------- // Anywhere you need it, you can use the "global" db object // or get the database connection from the connection name QSqlDatabase db = QSqlDatabase::database("connection-name"); QSqlQuery query(db);
configure the
QSqlDatabase
once, open it to test that the parameters are correct, and ditch the instance. The connection name, will still be accessible anywhere, but the database will have to be reopened:{ // Allocated on the stack QSqlDatabase db = QSqlDatabase::addDatabase("QSQLDRIVER", "connection-name"); db.setHostname(...); // ... if(!this->db.open()) // test the connection { // Error handling } // db is closed when it goes out of scope } { // Same thing as for (1), but by default database() opens // the connection if it isn't already opened QSqlDatabase db = QSqlDatabase::database("connection-name"); QSqlQuery query(db); // if there is no other connection open with that connection name, // the connection is closed when db goes out of scope }
In that case, note that you shouldn't close the database explicitly, because you can have multiple objects using the same database connection in a reentrant manner (for example, if a function A use the connection and calls B which also use the connection. If B closes the connection before returning control to A, the connection will also be closed for A, which is probably a bad thing).
回答2:
QSqlDatabase and QSqlQuery are lightweight wrappers around concrete implementations, so your first example is fine. If you provide a name when adding the connection, or use the default database, then simply writing 'QSqlDatabase db(name)' gives you the database object with very little overhead.
removeDatabase is equivalent to closing the file (for sqlite) or the connection (for ODBC/MySql/Postgres), so that's typically something you would do at program termination. As the warning says, you must ensure all database and query objects which refer to that database, have already been destroyed, or bad things can happen.
回答3:
I find that the instructions have to be run exactly in the order it is below or else you have issues, either with the database connection or query. This works in Qt5.
QSqlQueryModel *model = new QSqlQueryModel;
db = QSqlDatabase::addDatabase("QSQLITE");
db.setDatabaseName(fileName);
if (db.isValid())
{
db.open();
if (db.isOpen())
{
QSqlQuery searchQuery(db);
searchQuery.prepare("SELECT * FROM myTable");
searchQuery.exec();
if(searchQuery.isActive())
{
model->setQuery(searchQuery);
sui->DBDisplay->setModel(model);
db.close();
} else {
qDebug() << "query is not active";
}
} else {
qDebug() << "DB is not open";
}
} else {
qDebug() << "DB is not valid";
}
来源:https://stackoverflow.com/questions/7669987/what-is-the-correct-way-of-qsqldatabase-qsqlquery