QSqlDatabase

La classe QSqlDatabase représente une connexion à une base de données. Plus d'informations...

 #include <QSqlDatabase>

Description détaillée

La classe QSqlDatabase représente une connexion à une base de données.

La classe QSqlDatabase fournit une interface pour accéder à une base de données par l'intermédiaire d'une connexion. Une instance de QSqlDatabase représente la connexion. La connexion fournit un accès à la base de données via l'un des pilotes de base de données supportés, qui sont dérivés de QSqlDriver. D'autre part, vous pouvez dériver votre propre pilote de QSqlDriver. Voir Comment créer votre propre pilote de base de données pour plus d'informations.

Créez une connexion (c'est-à-dire une instance de QSqlDatabase) en appelant l'une des fonctions statiques addDatabase(), où vous spécifiez le pilote ou le type de pilote à utiliser (c'est-à-dire à quel type de base de données allez vous accéder) et un nom de connexion. Une connexion est connue grâce à son propre nom et non pas celui de la base de données à laquelle elle se connecte. Vous pouvez avoir plusieurs connexions à la même base de données. QSqlDatabase supporte également le concept d'une connexion par défaut, qui est la connexion sans nom. Pour créer la connexion par défaut, ne passez pas l'argument name quand vous appelez la fonction addDatabase(). Par la suite, quand vous appelez n'importe quelle fonction statique membre qui prend en paramètre le nom de la connexion, si vous ne passez pas cet argument, la connexion par défaut est utilisée. L'extrait suivant montre comment créer et ouvrir une connexion par défaut à une base de données PostgreSQL :

     QSqlDatabase db = QSqlDatabase::addDatabase("QPSQL");
     db.setHostName("acidalia");
     db.setDatabaseName("customdb");
     db.setUserName("mojito");
     db.setPassword("J0a1m8");
     bool ok = db.open();

Une fois que l'objet QSqlDatabase a été créé, définissez les paramètres de connexion grâce à setDatabaseName(), setUserName(), setPassword(), setHostName(), setPort() et setConnectOptions(). Puis appelez open() pour activer la connexion physique à la base de données. La connexion est inutilisable tant que vous ne l'avez pas ouverte.

La connexion définie plus haut sera la connexion par défaut, parce que nous n'avons pas donné de nom de connexion à addDatabase(). Par la suite, vous pouvez récupérer la connexion par défaut en appelant database() sans l'argument de nom de connexion :

QSqlDatabase db = QSqlDatabase::database();

QSqlDatabase est une classe valeur. Des modifications apportées à une connexion à une base de données par l'intermédiaire d'une instance de QSqlDatabase affecteront les autres instances de QSqlDatabase qui représentent la même connexion. Utilisez la fonction cloneDatabase() pour créer une connexion indépendante basée sur une connexion préexistante.

Si vous créez plusieurs connexions différentes, spécifiez un nom unique de connexion pour chacune d'entre elles quand vous appelez addDatabase(). Utilisez database() avec un nom de connexion pour récupérer cette connexion. Utilisez removeDatabase() avec un nom de connexion pour supprimer une connexion. QSqlDatabase affiche un avertissement si vous essayez de supprimer une connexion référencée par d'autres objets QSqlDatabase. Utilisez contains() pour voir si un nom de connexion donné est dans la liste des connexions.

Une fois qu'une connexion est établie, vous pouvez appeler tables() pour récupérer la liste des tables de la base de données, primaryIndex() pour récupérer l'index primaire de la table et record() pour récupérer les méta-informations à propos des champs de la table (par exemple le nom des champs).

Note : QSqlDatabase::exec() est déprécié. Utilisez QSqlQuery::exec() à la place.

Si le pilote gère les transactions, utilisez transaction() pour démarrer une transaction et commit() ou rollback() pour la terminer. Utilisez hasFeature() pour savoir si le pilote gère les transactions. Note : quand vous utilisez des transactions, vous devez commencer la transaction avant de créer votre requête.

En cas d'erreur, lastError() renverra les informations sur celle-ci.

Récupérez les noms des pilotes SQL disponibles grâce à drivers(). Vérifiez la présence d'un pilote en particulier avec isDriverAvailable(). Si vous avez créé votre propre pilote personnalisé, vous devez l'enregistrer avec registerSqlDriver().

Voir aussi QSqlDriver, QSqlQuery, le module QtSql et les threads et le module SQL.

Fonctions membres

QSqlDatabase::QSqlDatabase ()

Crée un objet QSqlDatabase vide et invalide. Utilisez addDatabase(), removeDatabase() et database() pour récupérer des objets QSqlDatabase valides.

QSqlDatabase::QSqlDatabase ( const QSqlDatabase & other )

Crée une copie de other.

QSqlDatabase::QSqlDatabase ( const QString & type ) [protected]

Il s'agit d'une fonction surchargée.

Crée une connexion à une QSqlDatabase en utilisant le pilote indiqué par le type. Si le type n'est pas reconnu, la connexion à la base de données n'aura aucune fonctionnalité.

Les types de drivers disponibles pour l'instant sont :

Des pilotes tiers, y compris vos propres pilotes, peuvent être chargés dynamiquement.

Voir aussi SQL Database Drivers, registerSqlDriver() et drivers().

QSqlDatabase::QSqlDatabase ( QSqlDriver * driver ) [protected]

Il s'agit d'une fonction surchargée.

Crée une connexion à la base de données en utilisant le driver donné.

QSqlDatabase::~QSqlDatabase ()

Détruit l'objet et libère toutes les ressources allouées.

S'il s'agit du dernier objet QSqlDatabase utilisant une certaine connexion à une base de données, celle-ci est automatiquement fermée.

Voir aussi close().

QSqlDatabase QSqlDatabase::addDatabase ( const QString & type, const QString & connectionName = QLatin1String( defaultConnection ) ) [static]

Ajoute une base de données à la liste des connexions en utilisant le pilote type et le nom de connexion connectionName. S'il existe déjà une connexion portant le nom connectionName, cette connexion est supprimée.

Le nom connectionName identifie la connexion. La nouvelle connexion à la base de données est renvoyée.

Si le pilote type n'est pas disponible ou ne peut être chargé, isValid() renvoie false.

Si l'argument connectionName n'est pas spécifié, la nouvelle connexion devient la connexion par défaut de l'application et tout appel ultérieur à la fonction database(), sans spécifier le nom de connexion, renverra la connexion par défaut. Si en revanche vous fournissez le nom de connexion connectionName, vous utiliserez database(connectionName) pour retrouver cette connexion.

Attention : si vous ajoutez une connexion avec le même nom qu'une connexion existante, la nouvelle connexion remplacera l'ancienne. Si vous appelez cette fonction plus d'une fois sans spécifier de nom de connexion, la connexion par défaut sera remplacée.

Avant d'utiliser la connexion, elle doit être initialisée. Pour cela appelez certaines, voire toutes les fonctions suivantes : setDatabaseName(), setUserName(), setPassword(), setHostName(), setPort() et setConnectOptions(), puis, pour finir, appelez la fonction open().

Note : cette fonction est thread-safe.

Voir aussi database(), removeDatabase() et les threads et le module SQL.

QSqlDatabase QSqlDatabase::addDatabase ( QSqlDriver * driver, const QString & connectionName = QLatin1String( defaultConnection ) ) [static]

Cette fonction surchargée est utile quand vous créez une connexion avec un driver que vous avez instancié vous même. Cela peut être votre propre pilote de base de données, ou vous pouvez avoir besoin d'instancier vous-même l'un des pilotes de Qt. Si vous faites cela, il est recommandé d'incorporer le code du pilote dans votre application. Par exemple, vous créez une connexion PostgreSQL avec votre propre pilote QPSQL comme ceci :

 #include "qtdir/src/sql/drivers/psql/qsql_psql.cpp"
 
 PGconn *con = PQconnectdb("host=server user=bart password=simpson dbname=springfield");
 QPSQLDriver *drv =  new QPSQLDriver(con);
 QSqlDatabase db = QSqlDatabase::addDatabase(drv); // devient la nouvelle connexion par défaut
 QSqlQuery query;
 query.exec("SELECT NAME, ID FROM STAFF");
 ...

Le code précédent configure une connexion PostgreSQL et instancie un objet QPSQLDriver. Ensuite, la fonction addDatabase() est appelée pour ajouter la connexion à la liste des connexions connues pour que les classes SQL de Qt puissent l'utiliser. Quand un pilote est instancié avec un identificateur de connexion (ou un ensemble d'identificateurs), Qt suppose que vous avez déjà ouvert la connexion avec la base.

Note : on suppose que Qt est installé dans le répertoire qtdir. Le code nécessaire pour utiliser le client PostgreSQL et instancier un objet QPSQLDriver sera extrait, à condition que les en-têtes PostgreSQL soient dans vos chemins de recherche des fichiers à inclure.

Souvenez-vous que vous devez lier votre application avec la bibliothèque cliente de la base. Assurez-vous que la bibliothèque cliente se trouve dans le chemin de recherche de l'éditeur de liens et ajoutez des lignes de ce type dans votre fichier .pro :

 unix:LIBS += -lpq
 win32:LIBS += libpqdll.lib

La méthode décrite fonctionne pour tous les pilotes fournis. Les seules différences sont les arguments du constructeur de pilotes. Voici une table des pilotes fournis avec Qt, leurs fichiers source et les arguments des constructeurs :

Le hostName (ou nom de service) est requis à la construction du pilote QTDSDriver pour la création de nouvelles connexions pour des requêtes internes. Ceci permet d'éviter des blocages lorsque plusieurs objets QSqlQuery sont utilisés simultanément.

Attention : l'ajout d'une connexion à une base avec le même nom qu'une connexion existante remplace l'ancienne connexion par la nouvelle.

Attention : le framework SQL devient propriétaire de driver. Il ne doit pas être détruit. Pour supprimer la connexion, utilisez removeDatabase().

Voir aussi drivers().

QSqlDatabase QSqlDatabase::cloneDatabase ( const QSqlDatabase & other, const QString & connectionName ) [static]

Clone la connexion à la base other et l'enregistre sous le nom connectionName. Tous les paramètres de la base d'origine, par exemple databaseName(), hostName(), etc, sont copiés. La fonction ne fait rien si other est une base invalide. Renvoie la nouvelle connexion.

Note : la nouvelle connexion n'est pas ouverte. Avant de l'utiliser, vous devez appeler open().

void QSqlDatabase::close ()

Ferme la connexion à la base, libérant les ressources acquises et invalidant tout objet QSqlQuery utilisé sur cette base.

La fermeture affecte aussi les copies de l'objet QSqlDatabase.

Voir aussi removeDatabase().

bool QSqlDatabase::commit ()

Effectue un commit de la transaction si le pilote gère les transactions et qu'une transaction() est en cours. Renvoie true si l'opération a réussi, sinon renvoie false.

Note : pour certaines bases, le commit échouera et renverra false si une requête active utilise la base pour un SELECT. Rendez la requête inactive avant le commit.

Appelez lastError() pour obtenir des informations sur les erreurs.

Voir aussi QSqlQuery::isActive(), QSqlDriver::hasFeature() et rollback().

QString QSqlDatabase::connectOptions () const

Renvoie la chaîne d'options de connexion utilisée pour cette connexion. La chaîne peut être vide.

Voir aussi setConnectOptions().

QString QSqlDatabase::connectionName () const

Renvoie le nom de la connexion, qui peut être vide. Note : le nom de la connexion n'est pas le nom de la base.

Cette fonction a été introduite dans Qt 4.4.

Voir aussi addDatabase().

QStringList QSqlDatabase::connectionNames () [static]

Renvoie une liste contenant les noms de toutes les connexions.

Note : cette fonction est thread-safe.

Voir aussi contains(), database() et les threads et le module SQL.

bool QSqlDatabase::contains ( const QString & connectionName = QLatin1String( defaultConnection ) ) [static]

Renvoie vrai si la liste des connexions à la base contient connectionName ; sinon, renvoie faux.

Note : cette fonction est thread-safe.

Voir aussi connectionNames(), database() et les threads et le module SQL.

QSqlDatabase QSqlDatabase::database ( const QString & connectionName = QLatin1String( defaultConnection ), bool open = true ) [static]

Renvoie la connexion nommée connectionName. La connexion doit avoir été ajoutée par addDatabase(). Si open est vrai (la valeur par défaut) et que la connexion n'est pas déjà ouverte elle sera ouverte. Si connectionName n'est pas spécifié c'est la connexion par défaut qui sera utilisée. Si connectionName n'existe pas dans la liste des bases, la fonction renvoie une connexion invalide.

Note : cette fonction est thread-safe.

Voir aussi isOpen() et les threads et le module SQL.

QString QSqlDatabase::databaseName () const

Renvoie le nom de la base de la connexion, qui peut être vide. Note : le nom de la base n'est pas le nom de la connexion.

Voir aussi setDatabaseName().

QSqlDriver * QSqlDatabase::driver () const

Renvoie le pilote utilisé pour accéder à la base.

Voir aussi addDatabase() et drivers().

QString QSqlDatabase::driverName () const

Renvoie le nom du pilote de la connexion.

Voir aussi addDatabase() et driver().

QStringList QSqlDatabase::drivers () [static]

Renvoie une liste de tous les pilotes disponibles.

Voir aussi registerSqlDriver().

QSqlQuery QSqlDatabase::exec ( const QString & query = QString() ) const

Exécute un ordre SQL sur la base et renvoie un objet QSqlQuery. Utilisez lastError() pour obtenir des informations d'erreur. Si query est vide, une QSqlQuery vide et invalide est renvoyée et lastError() n'est pas affecté.

Voir aussi QSqlQuery et lastError().

QString QSqlDatabase::hostName () const

Renvoie le nom d'hôte de la connexion ; il peut être vide.

Voir aussi setHostName().

bool QSqlDatabase::isDriverAvailable ( const QString & name ) [static]

Renvoie vrai si un pilote appelé name est disponible ; sinon renvoie faux.

Voir aussi drivers().

bool QSqlDatabase::isOpen () const

Renvoie vrai si la connexion à la base est actuellement ouverte ; sinon renvoie faux.

bool QSqlDatabase::isOpenError () const

Renvoie vrai si une erreur s'est produite à l'ouverture de la connexion à la base ; sinon renvoie faux. Utilisez la fonction lastError() pour obtenir des informations sur l'erreur.

bool QSqlDatabase::isValid () const

Renvoie vrai si le QSqlDatabase possède un pilote valide.

Exemple :

 QSqlDatabase db;
 qDebug() << db.isValid();    // Retourne false
 
 db = QSqlDatabase::database("sales");
 qDebug() << db.isValid();    // Retourne true si la connexion "sales" existe
 
 QSqlDatabase::removeDatabase("sales");
 qDebug() << db.isValid();    // Retourne false

QSqlError QSqlDatabase::lastError () const

Renvoie des informations sur la dernière erreur qui s'est produite dans la base.

Les échecs qui se produisent en conjonction avec une requête individuelle sont rapportés par QSqlQuery::lastError().

Voir aussi QSqlError et QSqlQuery::lastError().

QSql::NumericalPrecisionPolicy QSqlDatabase::numericalPrecisionPolicy () const

Renvoie la règle actuellement appliquée par défaut pour la précision numérique pour cette connexion.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi QSql::NumericalPrecisionPolicy, setNumericalPrecisionPolicy(), QSqlQuery::numericalPrecisionPolicy() et QSqlQuery::setNumericalPrecisionPolicy().

bool QSqlDatabase::open ()

Ouvre la connexion à la base en utilisant les valeurs de connexion courantes. Renvoie vrai en cas de succès, faux sinon. Utilisez lastError() pour obtenir des informations d'erreur.

Voir aussi lastError(), setDatabaseName(), setUserName(), setPassword(), setHostName(), setPort() et setConnectOptions().

bool QSqlDatabase::open ( const QString & user, const QString & password )

Il s'agit d'une fonction surchargée.

Ouvre la connexion à la base en utilisant les user (utilisateur) et password (mots de passe) donnés. Renvoie vrai en cas de succès, faux sinon. Utilisez lastError() pour obtenir des informations d'erreur.

Cette fonction ne stocke pas le mot de passe qu'on lui donne. Le mot de passe est transmis directement au pilote pour l'ouverture de la connexion et ensuite détruit.

Voir aussi lastError().

QString QSqlDatabase::password () const

Renvoie le mot de passe de la connexion. Si le mot de passe n'a pas été fixé par setPassword() et qu'il a été donné par un appel à open() ou aucun mot de passe n'est utilisé, la fonction renvoie une chaîne vide.

Voir aussi setPassword().

int QSqlDatabase::port () const

Renvoie le numéro de port de la connexion. La valeur est indéfinie si le numéro de port n'a pas été fixé.

Voir aussi setPort().

QSqlIndex QSqlDatabase::primaryIndex ( const QString & tablename ) const

Renvoie l'index primaire de la table tablename. Si l'index primaire n'existe pas la fonction renvoie QSqlIndex.

Voir aussi tables() et record().

QSqlRecord QSqlDatabase::record ( const QString & tablename ) const

Renvoie un QSqlRecord peuplé des noms de tous les champs de la table (ou de la vue) nommée tablename. L'ordre dans lequel les champs apparaissent dans l'enregistrement est indéfini. Si aucune table (ou vue) n'existe à ce nom, la fonction renvoie un enregistrement vide.

void QSqlDatabase::registerSqlDriver ( const QString & name, QSqlDriverCreatorBase * creator ) [static]

Cette fonction enregistre un nouveau pilote SQL appelé name dans le framework SQL. Cela vous permet d'utiliser un pilote SQL personnalisé que vous ne voulez pas compiler sous forme de plugin.

Exemple:

 QSqlDatabase::registerSqlDriver("MYDRIVER",
                                 new QSqlDriverCreator<MyDatabaseDriver>);
 QSqlDatabase db = QSqlDatabase::addDatabase("MYDRIVER");

QSqlDatabase devient propriétaire du pointeur creator, donc vous ne devez pas le détruire vous-même.

Voir aussi drivers().

void QSqlDatabase::removeDatabase ( const QString & connectionName ) [static]

Retire la connexion nommée connectionName de la liste des connexions.

Attention : il ne doit pas y avoir de requêtes ouvertes sur la connexion lorsque cette fonction est appelée, sinon l'appel provoque une fuite de ressources.

Exemple:

 // INCORRECT
 QSqlDatabase db = QSqlDatabase::database("sales");
 QSqlQuery query("SELECT NAME, DOB FROM EMPLOYEES", db);
 QSqlDatabase::removeDatabase("sales"); // affichera un avertissement sur la sortie standard
 
 // "db" est maintenant une connexion invalide,
 // "query" un ensemble de résultats invalides

La façon correcte de faire :

 {
     QSqlDatabase db = QSqlDatabase::database("sales");
     QSqlQuery query("SELECT NAME, DOB FROM EMPLOYEES", db);
 }
 // À la fois "db" et "query" sont détruits étant donné qu'ils sont maintenant hors de portée
 QSqlDatabase::removeDatabase("sales"); // correct

Pour supprimer la connexion par défaut, qui peut avoir été créée par un appel à addDatabase() sans nom de connexion, vous pouvez retrouver le nom de la connexion par défaut avec un appel à connectionName() sur la base renvoyée par database(). Notez que si la base par défaut n'a pas été créée la fonction renverra une base invalide.

Note : cette fonction est thread-safe.

Voir aussi database(), connectionName() et les threads et le module SQL.

bool QSqlDatabase::rollback ()

Effectue un roll back (annulation) d'une transaction si le pilote gère les transactions et qu'une transaction() est en cours. Renvoie true si l'opération a réussi, sinon renvoie false.

Note : pour certaines bases, le roll back échouera et renverra false si une requête active utilise la base pour un SELECT. Rendez la requête inactive avant le commit.

Appelez lastError() pour obtenir des informations sur les erreurs.

Voir aussi QSqlQuery::isActive(), QSqlDriver::hasFeature() et commit().

void QSqlDatabase::setConnectOptions ( const QString & options = QString() )

Fixe les options spécifiques à la base. Cette appel doit être fait avant l'ouverture de la connexion, sinon il n'aura pas d'effet (vous pouvez aussi fermer la connexion, appeler cette fonction et ouvrir de nouveau la connexion).

Le format de la chaîne options est une liste de noms d'options ou de paires option=valeur séparés par des points-virgules. Les options dépendent du client de base de données utilisé :

ODBC 

• SQL_ATTR_ACCESS_MODE
• SQL_ATTR_LOGIN_TIMEOUT
• SQL_ATTR_CONNECTION_TIMEOUT
• SQL_ATTR_CURRENT_CATALOG
• SQL_ATTR_METADATA_ID
• SQL_ATTR_PACKET_SIZE
• SQL_ATTR_TRACEFILE
• SQL_ATTR_TRACE
• SQL_ATTR_CONNECTION_POOLING
• SQL_ATTR_ODBC_VERSION

MySQL

• CLIENT_COMPRESS
• CLIENT_FOUND_ROWS
• CLIENT_IGNORE_SPACE
• CLIENT_SSL
• CLIENT_ODBC
• CLIENT_NO_SCHEMA
• CLIENT_INTERACTIVE
• UNIX_SOCKET
• MYSQL_OPT_RECONNECT

PostgreSQL

• connect_timeout
• options
• tty
• requiressl
• service

DB2

• SQL_ATTR_ACCESS_MODE
• SQL_ATTR_LOGIN_TIMEOUT

OCI

• OCI_ATTR_PREFETCH_ROWS
• OCI_ATTR_PREFETCH_MEMORY

TDS 

• none

SQLite

• QSQLITE_BUSY_TIMEOUT
• QSQLITE_OPEN_READONLY
• QSQLITE_ENABLE_SHARED_CACHE

Interbase

• ISC_DPB_LC_CTYPE
• ISC_DPB_SQL_ROLE_NAME

Exemples :

 ...
 // Connexion MySQL
 db.setConnectOptions("CLIENT_SSL=1;CLIENT_IGNORE_SPACE=1"); // utilise une connexion SSL au serveur
 if (!db.open()) {
     db.setConnectOptions(); // vide la chaîne de caractères contenant les options de connexion
     ...
 }
 ...
 // Connexion PostgreSQL
 db.setConnectOptions("requiressl=1"); // active les connexions SSL avec PostgreSQL 
 if (!db.open()) {
     db.setConnectOptions(); // vide les options
     ...
 }
 ...
 // Connexion ODBC
 db.setConnectOptions("SQL_ATTR_ACCESS_MODE=SQL_MODE_READ_ONLY;SQL_ATTR_TRACE=SQL_OPT_TRACE_ON"); // définit les options ODBC
 if (!db.open()) {
     db.setConnectOptions(); // n'essayez pas de définir cette option
     ...
 }

Référez-vous à la documentation de la bibliothèque cliente pour plus d'informations sur les différentes options.

Voir aussi connectOptions().

void QSqlDatabase::setDatabaseName ( const QString & name )

Affecte la valeur name au nom de base de la connexion. Pour avoir un effet, l'affectation doit avoir lieu avant que la connexion soit ouverte. Sinon, vous pouvez fermer la connexion, changer le nom de base et rappeler open(). Note : le nom debase n'est pas le nom de connexion. Le nom de connexion doit être fourni à addDatabase() au moment de la création de l'objet connexion.

Pour le pilote QOCI (Oracle), le nom de base est le nom de service TNS.

Pour le pilote QODBC, name peut être soit un DSN, soit un nom de fichier DSN filename (auquel cas le fichier doit avoir une extension .dsn) ou une chaîne de connexion.

Par exemple, les utilisateurs de Microsoft Access peuvent utiliser la chaîne de connexion suivante pour ouvrir directement un fichier .mdb, au lieu d'avoir à créer une entrée DSN dans le gestionnaire ODBC :

 ...
 db = QSqlDatabase::addDatabase("QODBC");
 db.setDatabaseName("DRIVER={Microsoft Access Driver (*.mdb)};FIL={MS Access};DBQ=myaccessfile.mdb");
 if (db.open()) {
     // success!
 }
 ...

Il n'y a pas de valeur par défaut.

Voir aussi databaseName(), setUserName(), setPassword(), setHostName(), setPort(), setConnectOptions() et open().

void QSqlDatabase::setHostName ( const QString & host )

Affecte la valeur host au nom d'hôte de la connexion. Pour avoir un effet, l'affectation doit avoir lieu avant que la connexion soit ouverte. Sinon, vous pouvez fermer la connexion, affecter le nom d'hôte et rappeler open().

Il n'y a pas de valeur par défaut.

Voir aussi hostName(), setUserName(), setPassword(), setDatabaseName(), setPort(), setConnectOptions() et open().

void QSqlDatabase::setNumericalPrecisionPolicy ( QSql::NumericalPrecisionPolicy precisionPolicy )

Fixe la règle de précision numérique par défaut utilisée par les requêtes créées sur cette connexion à precisionPolicy.

Note : les pilotes qui ne gèrent pas la lecture de valeurs numériques en basse précision ignoreront la règle de précision. Vous pouvez utiliser QSqlDriver::hasFeature() pour savoir si un pilote gère cette fonction.

Note : changer la règle de précision n'affecte pas les requêtes actives au moment de l'appel.

Cette fonction a été introduite dans Qt 4.6.

Voir aussi QSql::NumericalPrecisionPolicy, numericalPrecisionPolicy(), QSqlQuery::setNumericalPrecisionPolicy() et QSqlQuery::numericalPrecisionPolicy().

void QSqlDatabase::setPassword ( const QString & password )

Affecte la valeur password au mot de passe de la connexion. Pour avoir un effet, l'affectation doit avoir lieu avant que la connexion soit ouverte. Sinon, vous pouvez fermer la connexion, affecter le mot de passe et rappeler open().

Il n'y a pas de valeur par défaut.

Attention : cette fonction enregistre le mot de passe en clair dans Qt. Utilisez l'appel open() qui prend un mot de passe en paramètre pour éviter ce comportement.

Voir aussi password(), setUserName(), setDatabaseName(), setHostName(), setPort(), setConnectOptions() et open().

void QSqlDatabase::setPort ( int port )

Affecte la valeur port au numéro de port de la connexion. Pour avoir un effet, l'affectation doit avoir lieu avant que la connexion soit ouverte. Sinon, vous pouvez fermer la connexion, affecter le numéro de port et rappeler open().

Il n'y a pas de valeur par défaut.

Voir aussi port(), setUserName(), setPassword(), setHostName(), setDatabaseName(), setConnectOptions() et open().

void QSqlDatabase::setUserName ( const QString & name )

Affecte la valeur name au nom d'utilisateur de la connexion. Pour avoir un effet, l'affectation doit avoir lieu avant que la connexion soit ouverte. Sinon, vous pouvez fermer la connexion, affecter le nom et rappeler open().

Il n'y a pas de valeur par défaut.

Voir aussi userName(), setDatabaseName(), setPassword(), setHostName(), setPort(), setConnectOptions() et open().

QStringList QSqlDatabase::tables ( QSql::TableType type = QSql::Tables ) const

Renvoie une liste des tables, tables système ou des vues, suivant ce qui est spécifié par le paramètre type.

Voir aussi primaryIndex() et record().

bool QSqlDatabase::transaction ()

Commence une transaction sur la base si le pilote gère les transactions. Renvoie true si l'opération a réussi, sinon false.

Voir aussi QSqlDriver::hasFeature(), commit() et rollback().

QString QSqlDatabase::userName () const

Renvoie le nom d'utilisateur de la connexion. Il peut être vide.

Voir aussi setUserName().

QSqlDatabase & QSqlDatabase::operator= ( const QSqlDatabase & other )

Affecte other à cet objet.

Remerciements

Merci à Nicolas Carion et Ilya Diallo pour la traduction ainsi qu'à Jonathan Courtois et Jacques Thery pour leur relecture !