Ce chapitre décrit les interfaces fournies par plusieurs langages pour MySQL, où les obtenir, et comment les utiliser. L'interface C est la plus abordée dans ce chapitre, puisqu'elle a été développée par l'équipe de MySQL, et qu'elle sert de base à toutes les autres interfaces.
PHP est un langage côté serveur, qui peut être utilisé pour créer des pages web dynamiques. Il fournit un support d'accès à plusieurs systèmes de bases de données, dont MySQL fait partie. PHP peut être utilisé en tant que programme séparé, ou être compilé en tant que module pour le serveur web Apache.
La distribution et documentation sont disponibles sur le site web de PHP (http://www.php.net/).
-lz à la fin lors de la liaison avec -lmysqlclient.
Cette section documente l'interface DBI de Perl. L'ancienne interface s'appelait
mysqlperl. DBI/DBD est maintenant l'interface recommandée avec Perl
et donc mysqlperl est obsolète et n'est pas documentée ici.
DBI avec DBD::mysql
DBI est une interface générique à plusieurs systèmes de bases de
données. Cela signifie que vous pouvez écrire un script qui fonctionne
parfaitement avec plusieurs systèmes différents sans y apporter aucun
changement. Vous avez besoin de définir un pilote de base de données
(DataBase Driver : DBD) pour chaque système. Pour MySQL, ce pilote se
nomme DBD::mysql.
Pour plus d'informations sur le module DBI de Perl5, visitez la page web
de DBI et lisez la documentation :
http://dbi.perl.org/
Pour plus d'informations sur la programmation orientée objets (OOP) comme la définie Perl5, voyez la page OOP de Perl :
http://language.perl.com/info/documentation.html
Notez que si vous voulez utiliser les transactions avec Perl, vous avez besoin
d'avoir au moins la version 1.2216 de Msql-Mysql-modules.
Le module Perl recommandé est DBD-mysql-2.1022 ou plus récent.
Les instructions pour l'installation du support Perl de MySQL sont données dans section 2.7 Commentaires sur l'installation de Perl.
Si vous avez le module MySQL installé, vous pouvez trouver des informations à propos des fonctionnalités spécifiques de MySQL avec l'une de ces commandes :
shell>perldoc DBD/mysqlshell>perldoc mysql
DBIMéthodes portables
| Méthode | Description |
connect | Etablit une connexion à un serveur de bases de données. |
disconnect | Déconnecte du serveur de bases de données. |
prepare | Prépare une commande SQL pour l'exécution. |
execute | Exécute les requêtes préparées. |
do | Prépare et exécute une commande SQL. |
quote | Echappe une chaîne ou une valeur BLOB avant insertion.
|
fetchrow_array | Récupère la ligne suivante en tant que tableau de champs. |
fetchrow_arrayref | Récupère la ligne suivante comme une référence de tableau de champs. |
fetchrow_hashref | Récupère la ligne suivante en tant que référence pour un tableau associatif. |
fetchall_arrayref | Récupère toutes les données comme un tableau de tableaux. |
finish | Termine une requête et permet au système de libérer les ressources. |
rows | Retourne le nombre de lignes affectées. |
data_sources | Retourne un tableau de bases de données disponibles sur le serveur local. |
ChopBlanks | Contrôle la suppression des espaces avec fetchrow_*.
|
NUM_OF_PARAMS | Nombre de marqueurs dans la requête préparée. |
NULLABLE | Les colonnes qui peuvent être NULL.
|
trace | Performe un traçage pour les corrections. |
Méthodes spécifiques à MySQL
| Méthode | Description |
insertid | La denière valeur AUTO_INCREMENT.
|
is_blob | Est-ce une valeur BLOB ?
|
is_key | Est-ce une clef ? |
is_num | Est-ce une colonne numérique ? |
is_pri_key | Quelles colonnes sont des clefs primaires ? |
is_not_null | Quelles colonnes NE peuvent PAS être NULL. Voir NULLABLE.
|
length | Taille maximale possible pour la colonne. |
max_length | Taille maximale des colonnes actuellement présentes dans le résultat. |
NAME | Noms des colonnes. |
NUM_OF_FIELDS | Nombre de Number of fields returned. |
table | Noms des tables dans le résultat. |
type | Tout les types de colonnes. |
Les méthodes Perl sont décrites dans les sections suivantes. Les variables utilisée pour les valeurs de retour des méthodes ont les significations suivantes :
$dbh
$sth
$rc
$rv
Méthodes DBI portables
connect($data_source, $username, $password)
connect pour crée une connexion de base
de données à la source. La valeur doit commencer par DBI:nom_pilote:.
Exemples d'utilisation de connect avec le pilote DBD::mysql :
$dbh = DBI->connect("DBI:mysql:$database", $user, $password);
$dbh = DBI->connect("DBI:mysql:$database:$hostname",
$user, $password);
$dbh = DBI->connect("DBI:mysql:$database:$hostname:$port",
$user, $password);
Si le nom d'utilisateur et/ou le mot de passe ne sont pas définis, DBI utilises la
valeur des variables d'environnements DBI_USER et DBI_PASS, respectivement.
Si vous ne spécifiez pas un nom d'hôte, il est à 'localhost' par défaut. Si vous ne
spécifiez pas un numéro de port, il est mit par défaut au port par défaut de MySQL
(3306).
Depuis la version 1.2009 de Msql-Mysql-modules, la valeur de $data_source
accepte certains modificateurs :
mysql_read_default_file=nom_du_fichier
mysql_read_default_group=nom_du_groupe
[client]. En spécifiant l'option mysql_read_default_group, le groupe par
défaut devient le groupe [nom_du_groupe].
mysql_compression=1
mysql_socket=/path/to/socket
DBI, vous pouvez le prendre du fichier utilisateur d'options `~/.my.cnf'
en écrivant votre appel à connect de la façon suivante :
$dbh = DBI->connect("DBI:mysql:$database"
. ";mysql_read_default_file=$ENV{HOME}/.my.cnf",
$user, $password);
Cet appel lira les options définies pour le groupe [client] dans le fichier
d'options. Si vous voulez le faire aussi pour le groupe [perl] par exemple,
vous pouvez utiliser ce qui suit :
$dbh = DBI->connect("DBI:mysql:$database"
. ";mysql_read_default_file=$ENV{HOME}/.my.cnf"
. ";mysql_read_default_group=perl",
$user, $password);
disconnect
disconnect déconnecte le gestionnaire de base de données
du serveur.
On y fait appel avant de terminer le programme.
Exemple :
$rc = $dbh->disconnect;
prepare($statement)
($sth), que vous pouvez utiliser
pour invoquer la méthode execute.
Le plus souvent, vous gérez les requêtes SELECT (et ceux qui s'en rapprochent, comme SHOW,
DESCRIBE, et EXPLAIN) à l'aide de prepare et execute.
Exemple :
$sth = $dbh->prepare($statement)
or die "Impossible de préparer $statement: $dbh->errstr\n";
execute
execute exécute une requête préparée. Pour les commandes
qui ne se rapprochent pas de SELECT, execute retourne le nombre
de lignes affectées. Si aucune ligne ne l'est, execute retourne "0E0",
que Perl traite comme zéro mais considère comme vrai (true). Si une erreur survient,
execute retourne undef. Pour les requêtes SELECT,
execute ne fait que démarrer la requête SQL dans la base de données; vous avez
besoin d'utiliser une des méthodes fetch_* décrites ici pour récupérer les données.
Exemple :
$rv = $sth->execute
or die "ne peut exécuter la requête : $sth->errstr;
do($statement)
do prépare et exécute une requête SQL et retourne le nombre de lignes
affectées. Si aucune ne l'est, do retourne "0E0", que Perl traite comme
zéro mais considère comme vrai (true). Cette méthode est généralement utilisée pour les
requêtes qui ne se rapprochent pas de SELECT qui ne peuvent être préparées à
l'avance (à cause d'une limitation du pilote) ou qui n'ont pas besoin d'être exécutées
plus d'une fois (insertions, suppressions, etc.).
Exemple :
$rv = $dbh->do($statement)
or die "Ne peut exécuter la commande $statement: $dbh- >errstr\n";
Généralement, la commande 'do' est plus rapide (et préférable) à
prepare/execute pour les requêtes ne contenant pas de paramètres.
quote($string)
quote est utilisée pour protéger les caractères spéciaux contenus
dans la chaîne et ajouter les guillemets externes requis.
Exemple :
$sql = $dbh->quote($string)
fetchrow_array
while(@row = $sth->fetchrow_array) {
print qw($row[0]\t$row[1]\t$row[2]\n);
}
fetchrow_arrayref
while($row_ref = $sth->fetchrow_arrayref) {
print qw($row_ref->[0]\t$row_ref->[1]\t$row_ref->[2]\n);
}
fetchrow_hashref
while($hash_ref = $sth->fetchrow_hashref) {
print qw($hash_ref->{firstname}\t$hash_ref->{lastname}\t\
$hash_ref- > title}\n);
}
fetchall_arrayref
my $table = $sth->fetchall_arrayref
or die "$sth->errstr\n";
my($i, $j);
for $i ( 0 .. $#{$table} ) {
for $j ( 0 .. $#{$table->[$i]} ) {
print "$table->[$i][$j]\t";
}
print "\n";
}
finish
$rc = $sth->finish;
rows
SELECT exécutées
avec la méthode execute.
Exemple :
$rv = $sth->rows;
NULLABLE
NULL.
Les valeurs possibles pour chaque élément sont 0 ou la chaîne vide si la
colonne ne peut être NULL, 1 si elle peut, et 2 si l'état NULL
de la colonne est inconnu.
Exemple :
$null_possible = $sth->{NULLABLE};
NUM_OF_FIELDS
SELECT ou SHOW FIELDS. Vous pouvez l'utiliser pour savoir
si une requête a retourné un résultat : une valeur nulle indique que la requête
n'est pas une sélection, comme INSERT, DELETE, ou UPDATE.
Exemple :
$nr_of_fields = $sth->{NUM_OF_FIELDS};
data_sources($driver_name)
'localhost'.
Exemple :
@dbs = DBI->data_sources("mysql");
ChopBlanks
fetchrow_* enlèvent les caractères
blancs au début et à la fin des valeurs retournées.
Exemple :
$sth->{'ChopBlanks'} =1;
trace($trace_level)
trace($trace_level, $trace_filename)
trace active ou désactive le traçage. Lorsqu'elle est invoquée
en tant que méthode de la classe DBI, elle affecte le traçage à tout les gestionnaire.
Lorsqu'elle est invoquée comme un gestionnaire de base de données ou de requête, elle n'affecte
le traçage que pour le gestionnaire donné (et tout ses descendants). Mettre $trace_level
à 2 fournit des informations détaillées de traçage. Le mettre à 0 désactive le traçage.
Les sorties de traçages vont dans la sortie d'erreurs standards par défaut.
Si $trace_filename est spécifié, le fichier est ouvert et le pointeur de fichier est placé
à la fin de celui-ci et les sorties de tout les gestionnaires tracés sont écrits dans ce
fichier.
Exemple :
DBI->trace(2); # trace tout
DBI->trace(2,"/tmp/dbi.out"); # trace tout dans
# /tmp/dbi.out
$dth->trace(2); # trace ce gestionnaire de base de données
$sth->trace(2); # trace ce gestionnaire de requête
Vous pouvez aussi activer le traçage DBI en définissant la variable
d'environnement DBI_TRACE. La définir en tant que valeur numérique revient
à appeler DBI->(value). La définir en tant que chemin revient à appeler
DBI->(2,value).
Méthodes spécifiques à MySQL
Les méthodes montrées ici sont spécifiques à MySQL et ne font pas partie du
standard DBI. Beaucoup d'entre-elles sont aujourd'hui désapprouvées :
is_blob, is_key, is_num, is_pri_key,
is_not_null, length, max_length, et table.
Lorsque des alternatives utilisant le standard DBI existent, elles sont
mentionnées ici :
insertid
AUTO_INCREMENT de MySQL, la nouvelle
valeur auto-incrémentée sera stockée ici.
Exemple :
$new_id = $sth->{insertid};
Vous pouvez, en alternative, utiliser $dbh->{'mysql_insertid'}.
is_blob
BLOB.
Exemple :
$keys = $sth->{is_blob};
is_key
$keys = $sth->{is_key};
is_num
$nums = $sth->{is_num};
is_pri_key
$pri_keys = $sth->{is_pri_key};
is_not_null
NULL
values.
Exemple :
$not_nulls = $sth->{is_not_null};
is_not_null est désapprouvé; il est préférable d'utiliser l'attribut
NULLABLE (décrit plus haut), car c'est un standard DBI.
length
max_length
length indique les tailles maximales de colonnes (comme déclarés lors
de la création de la table). Le tableau max_length indique la plus grande taille
occupée jusqu'à présent dans les colonnes de la table.
Exemple :
$lengths = $sth->{length};
$max_lengths = $sth->{max_length};
NAME
$names = $sth->{NAME};
table
$tables = $sth->{table};
type
$types = $sth->{type};
DBI/DBD
Vous pouvez utiliser la commande perldoc pour obtenir plus d'informations à
propos de DBI.
perldoc DBI perldoc DBI::FAQ perldoc DBD::mysql
Vous pouvez aussi utiliser les outils pod2man, pod2html, etc., pour traduire
en différents formats.
Vous pouvez trouver les dernières informations relatives à DBI à l'adresse suivante :
http://dbi.perl.org/.
MySQL fournit un support de ODBC via le programme MyODBC.
Ce chapitre vous apprendra à installer MyODBC, et à l'utiliser.
Vous trouverez aussi une liste de programmes connus pour leur utilisation
de MyODBC.
MyODBC 2.50 est un pilote 32-bit ODBC 2.50 avec un niveau de spécification
0 (avec le niveau 1 et 2 de proposés) pour connecter une application compatible
ODBC à MySQL. MyODBC fonctionne sur Windows 9x/Me/NT/2000/XP et la plupart
des plate-formes Unix.
MyODBC 3.51 est une version améliorée avec les spécifications de niveau 1
de ODBC 3.5x (API noyau complète + fonctionnalités du niveau 2).
MyODBC est Open Source, et vous pouvez trouver la version
la plus récente sur http://www.mysql.com/downloads/api-myodbc.html.
Notez que les version 2.50.x sont licencées LGPL tandis que les
versions 3.51.x sont licencées GPL.
Si vous avez des problèmes avec MyODBC et que votre programme fonctionne
aussi avec OLEDB, essayez le pilote OLEDB.
Normalement, vous n'avez besoin d'installer MyODBC que sur les machines
Windows.
Vous avez besoin d'installer MyODBC sous Unix si vous avez un programme
tel que ColdFusion qui fonctionne sur les machines Unix et utilise ODBC pour
se connecter aux bases de données.
Si vous voulez installer MyODBC sur un ordinateur Unix, vous aurez aussi
besoin d'un gestionnaire ODBC. MyODBC est connu pour fonctionner
avec la plupart des gestionnaires ODBC d'Unix.
Pour installer MyODBC sur Windows, vous devez télécharger le fichier
`.zip' de MyODBC approprié, le décompresser avec WinZIP
ou un programme similaire et exécuter le fichier `SETUP.EXE'.
Sur Windows/NT/XP vous pouvez obtenir l'erreur suivante durant l'installation
de MyODBC :
An error occurred while copying C:\WINDOWS\SYSTEM\MFC30.DLL. Restart Windows and try installing again (before running any applications which use ODBC)
Le problème dans ce cas est qu'un autre programme utilise ODBC et du fait
de l'architecture Windows, vous ne pouvez pas installer de nouveau pilote
ODBC avec le programme d'installation de Microsoft ODBC. Dans la plupart
des cas, vous pouvez continuer en clickant juste sur Ignore pour
copier le reste des fichiers MyODBC et l'installation finale devrait
fonctionner. Si ce n'est pas le cas, la solution est de redémarrer votre
machine en mode ``safe mode`` (faites le en appuyant sur F8 juste avant que
votre machine ne démarre Windows), installez MyODBC, et redémarrez en
mode normal.
MyODBC sur l'ordinateur Windows.
GRANT. See section 4.3.1 Syntaxe de GRANT et REVOKE.
Notez que d'autres options de configuration sont présentes dans l'écran de MySQL (traçage, se connecter automatiquement, etc.), vous pouvez les essayer en cas de problèmes.
Il y a trois possibilités pour indiquer le nom du serveur sous Windows95 :
ip nomhotePour exemple :
194.216.84.21 mon_nom_hote
Exemple de valeurs dans l'installation ODBC :
Windows DSN name: test Description: Ceci est ma base de données MySql Database: test Server: 194.216.84.21 User: monty Password: mon_pass Port:
La valeur du champ Windows DSN name est n'importe quel nom qui est unique pour
votre installation de ODBC sur Windows.
Vous n'avez pas besoin de spécifier des valeurs pour les champs Server, User,
Password, et Port dans l'écran d'installation d'ODBC.
Toutefois, si vous le faites, ces valeurs seront celles utilisées par défaut par la suite
lorsque vous tenterez d'établir une connexion. Vous pourrez changez les options à ce moment là.
Si le numéro du port n'est pas donné, le port par défaut (3306) est utilisé.
Si vous spécifiez l'option Read options from C:\my.cnf, les groupes
client et odbc seront lus à partir du fichier `C:\my.cnf'.
Vous pouvez utiliser toutes les options utilisables par mysql_options().
See section 8.4.3.39 mysql_options().
Il est possible de spécifier les paramètres suivants à MyODBC
dans la section [Servername] du fichier `ODBC.INI' ou bien,
avec l'argument InConnectionString dans l'appel de
SQLDriverConnect().
| Paramètre | Valeur par défaut | Commentaire |
| user | ODBC (sous Windows) | Le nom d'utilisateur utilisé pour se connecter à MySQL. |
| server | localhost | Le nom d'hôte du serveur MySQL. |
| database | La base de données par défaut. | |
| option | 0 | Un entier avec lequel vous spécifier le mode de fonctionnement de MyODBC. Voir ci-dessous.
|
| port | 3306 | Le port TCP/IP à utiliser si le server n'est pas localhost.
|
| stmt | Une commande qui sera exécutée au moment de la connexion à MySQL.
| |
| password | Le mot de passe pour le serveur server, et l'utilisateur user.
| |
| socket | La socket ou le pipe Windows à utiliser. |
L'argument option est utilisé pour indiquer à MyODBC que le client
n'est pas 100% compatible avec ODBC. Sous Windows, il est possible de configurer
cette option en activant les options dans l'écran de connexion, mais il est
aussi possible de le configurer dans ce paramètre.
Les options suivantes sont listées dans l'ordre dans lequel elles apparaissent
dans l'écran MyODBC :
| Bit | Description |
| 1 | Le client ne peut gérer le fait que MyODBC retourne la taille réelle de la colonne.
|
| 2 | Le client ne peut gérer que MySQL retourne le nombre de ligne affecté. Si cette option est activée, alors MySQL retourne 'found rows' à la place. Il faut avoir MySQL 3.21.14 ou plus récent pour profiter de cette fonctionnalité. |
| 4 | Ecrit un fichier de débogage dans c:\myodbc.log. Cela revient au même que le code MYSQL_DEBUG=d:t:O,c::\myodbc.log dans le fichier `AUTOEXEC.BAT'
|
| 8 | Ne limite pas les paquets pour les résultats et les paramètres. |
| 16 | Ne pas poser de questions, même si le pilote le veut. |
| 32 | Simule un pilote ODBC 1.0 dans certains contexte. |
| 64 | Ignore l'utilisation du nom de base de données dans la syntaxe 'base.table.colonne'. |
| 128 | Force l'utilisation du gestionnaire de curseur ODBC (expérimental). |
| 256 | Désactive l'utilisation de la lecture étendue (expérimental). |
| 512 | Complète les champs CHAR jusqu'à contenance. |
| 1024 | SQLDescribeCol() retourne les noms de colonnes complets. |
| 2048 | Utilise le protocole de communication client/serveur |
| 4096 | Indique au serveur qu'il doit ignorer les espaces après les noms de fonction, et avant le '(' (nécessaire pour PowerBuilder). Cela va faire de tous les noms de fonctions des mots clés.
|
| 8192 | Connexion, avec les pipes nommés, à mysqld sur un machine NT.
|
| 16384 | Change les colonnes LONGLONG en colonne INT (certaines applications ne peuvent pas gérer les LONGLONG). |
| 32768 | Retourne 'user' comme Table_qualifier et Table_owner dans les tables SQLTables (expérimental) |
| 65536 | Lit les paramètres des groupes client et odbc dans `my.cnf'
|
| 131072 | Ajoute des vérifications de sécurité (ne devrait pas être nécessaire, mais...) |
Si vous voulez combiner des options, vous devez additionner les options ci-dessus. Par exemple, activer l'option 12 (4+8), active le déboggage sans limite de paquets.
La librairie par défaut `MYODBC.DLL' est compilée pour des performances
optimales. Si vous voulez déboguer MyODBC (par exemple, pour activer le
traçage), vous devriez utiliser `MYODBCD.DLL'. Pour installer ce ficher,
copiez `MYODBCD.DLL' à la place de la librairie isntallé `MYODBC.DLL'.
MyODBC a été testé avec Access, Admndemo.exe, C++-Builder,
Borland Builder 4, Centura Team Developer (formerly Gupta SQL/Windows),
ColdFusion (on Solaris and NT with svc pack 5), Crystal Reports,
DataJunction, Delphi, ERwin, Excel, iHTML, FileMaker Pro, FoxPro, Notes
4.5/4.6, SBSS, Perl DBD-ODBC, Paradox, Powerbuilder, Powerdesigner 32
bit, VC++, et Visual Basic.
Si vous avez connaissance de n'importe quelle autre application qui utilise
MyODBC, merci d'envoyer un mail à myodbc@lists.mysql.com à ce propos !
Avec quelques programmes, vous pouvez avoir l'erreur suivante :
Another user has modifies the record that you have modified. Dans la plupart
des cas, le problème peut être résolu en suivant l'une des méthodes suivantes :
Si ce qui précède ne vous aide pas, vous devez tracer MyODBC et essayer de
voir pourquoi les choses vont de travers.
La majorité des programmes devraient fonctionner avec MyODBC, mais tous
ceux que nous avons listés ici sont ceux que nous avons testé nous même, ou dont
nous avons reçu la confirmation de la part d'utilisateurs :
Microsoft Data Access
Components) (version 2.6 ou plus récente) depuis http://www.microsoft.com/data/.
Cela va corriger le bug suivant d'Access : lorsque vous exportez des données
vers MySQL, les noms de la table et des colonnes ne sont pas spécifiés.
Un autre moyen de pallier à ce bug est de passer en
MyODBC version 2.50.33 et MySQL version
3.23.x, qui, ensemble, forment un correctif à ce bug!
Vous devriez aussi installer le Microsoft Jet 4.0 Service Pack 5 (SP5)
disponible à http://support.microsoft.com/support/kb/articles/Q 239/1/14.ASP.
Cela va corriger certains cas ou les colonnes étaient marquées comme effacées (#deleted#)
dans Access.
Notez que si vous utilisez MySQL version 3.22, vous devez appliquer le patch
MDAC et utiliser MyODBC 2.50.32 ou 2.50.34 et plus récent pour corriger ce bug.
Return matching rows. Pour Access 2.0, vous devez aussi activer
Simulate ODBC 1.0.
TIMESTAMP(14) ou un simple TIMESTAMP
est recommandé au lieu de TIMESTAMP(X).
#DELETED#.
DOUBLE. Access échoue lors des comparaisons
entre les champs en simple précision. Le symptôme est généralement que les nouvelles
lignes ou les lignes modifiées sont marquées comme effacées (#DELETED#), ou
que vous ne pouvez plus trouver les nouvelles lignes ou les lignes modifiées.
BIGINT,
les résultats sont affichés comme effacés (#DELETED). La solution
est :
TIMESTAMP comme type de données, et
de préférence TIMESTAMP(14).
'Change BIGINT columns to INT' dans l'administrateur
ODBC DSN.
#DELETED#, mais les
nouvelles lignes seront affichées correctement.
Another user has changed your data après
avoir ajouté une colonne TIMESTAMP, le truc suivant peut vous aider :
N'utilisez pas la vue de table au format tableur. A la place, créez un formulaire
avec les champs que vous souhaitez, et utilisez ce formulaire comme vue de la table.
Vous devez utiliser la propriété DefaultValue pour la colonne TIMESTAMP,
avec la valeur NOW(). C'est une bonne idée de cacher la colonne TIMESTAMP
à vos utilisateurs, pour qu'ils ne soient pas perturbés.
"Query|SQLSpecific|Pass-Through" dans le menu Access.
BLOB sont des OLE OBJECTS. Si
vous voulez avoir des colonnes de type MEMO à la place, vous devez changer le type
de la colonne en TEXT avec ALTER TABLE.
DATE. Sis vous avez des
problèmes avec, changez ces colonnes en type DATETIME.
BYTE, Access va essayer
de l'exporter sous la forme d'un TINYINT au lieu d'un TINYINT UNSIGNED.
Cela va vous donner des problèmes si vous avez des valeurs supérieures à 127!
MyODBC vous devez faire attention
aux propriétés par défaut qui ne sont pas supportées par MySQL. Par exemple,
utiliser la propriété CursorLocation Property comme adUseServer va
retourner des valeurs de -1 pour RecordCount Property. Pour avoir la véritable
valeur, vous devez utiliser la valeur adUseClient, comme dans le code VB ci-contre :
Dim myconn As New ADODB.Connection Dim myrs As New Recordset Dim mySQL As String Dim myrows As Long myconn.Open "DSN=MyODBCsample" mySQL = "SELECT * from user" myrs.Source = mySQL Set myrs.ActiveConnection = myconn myrs.CursorLocation = adUseClient myrs.Open myrows = myrs.RecordCount myrs.Close myconn.CloseUn autre palliatif est d'utiliser la commande
SELECT COUNT(*),
pour connaître le nombre exact de lignes.
Return matching rows.
Don't optimize column widths et Return matching rows.
Active ou utiliser la méthode Open. Notez que Active
va commencer en générant automatiquement une requête SELECT * FROM ... qui
peut ne pas être pratique avec de grosses tables!
MyODBC pour les
serveurs MySQL. Allaire a vérifié que MyODBC version 2.50.26
fonctionne avec MySQL version 3.22.27 et ColdFusion pour Linux. (toute nouvelle
version doit aussi fonctionner). Vous pouvez télécharger MyODBC à
http://www.mysql.com/downloads/api-myodbc.html
ColdFusion version 4.5.1 vous permet d'utiliser l'administrateur ColdFusion
pour ajouter des serveurs MySQL. Toutefois, le pilote n'est pas inclus dans
ColdFusion version 4.5.1. Auparavant, le pilote MySQL était disponible dans
le menu déroulant. Vous devez compiler et copier le pilote MyODBC dans
`/opt/coldfusion/lib/libmyodbc.so'.
Le dossier Contrib contient le programme `mydsn-xxx.zip' qui vous permet
de compiler et supprimer des fichiers d'enregistrement DSN pour MyODBC sur les
applications Coldfusion.
VARCHAR plutôt que des ENUM,
car il exporte ces derniers d'une manière qui pose des problèmes à MySQL.
CONCAT(). Par exemple :
select CONCAT(rise_time), CONCAT(set_time)
from sunrise_sunset;
Les valeurs lues sous forme de chaînes seront correctement relues par
Excel97.
Le but de la fonction CONCAT() est de faire croire à ODBC que cette colonne
est de type ``string''. Sans la fonction CONCAT(), ODBC sait que la colonne
est de type heure, et Excel ne le comprendra pas.
Notez qu'il y a un bug dans Excel, car il convertit automatiquement une chaîne
en heure. Cela serait bien si la source était un fichier texte, mais c'est
totalement idiot si la source est une connexion ODBC qui fournit les types
exacts.
MyODBC et l'aide Add-in Microsoft Query.
Par exemple, pour créer une base de données avec une table contenant 2 colonnes
de type texte :
mysql.
Don't optimize column width lors de la connexion à MySQL.
De plus, voici un code Delphi pratique, pour configurer une entrée ODBC et
une entrée BDE pour MyODBC (l'entrée BDE requiert le BDE
Alias Editor qui est gratuit sur les pages "Delphi Super Page" près de chez
vous. (Merci à Bryan Brunton bryan@flesherfab.com pour cela ) :
fReg:= TRegistry.Create;
fReg.OpenKey('\Software\ODBC\ODBC.INI\DocumentsFab', True);
fReg.WriteString('Database', 'Documents');
fReg.WriteString('Description', ' ');
fReg.WriteString('Driver', 'C:\WINNT\System32\myodbc.dll');
fReg.WriteString('Flag', '1');
fReg.WriteString('Password', '');
fReg.WriteString('Port', ' ');
fReg.WriteString('Server', 'xmark');
fReg.WriteString('User', 'winuser');
fReg.OpenKey('\Software\ODBC\ODBC.INI\ODBC Data Sources', True);
fReg.WriteString('DocumentsFab', 'MySQL');
fReg.CloseKey;
fReg.Free;
Memo1.Lines.Add('DATABASE NAME=');
Memo1.Lines.Add('USER NAME=');
Memo1.Lines.Add('ODBC DSN=DocumentsFab');
Memo1.Lines.Add('OPEN MODE=READ/WRITE');
Memo1.Lines.Add('BATCH COUNT=200');
Memo1.Lines.Add('LANGDRIVER=');
Memo1.Lines.Add('MAX ROWS=-1');
Memo1.Lines.Add('SCHEMA CACHE DIR=');
Memo1.Lines.Add('SCHEMA CACHE SIZE=8');
Memo1.Lines.Add('SCHEMA CACHE TIME=-1');
Memo1.Lines.Add('SQLPASSTHRU MODE=SHARED AUTOCOMMIT');
Memo1.Lines.Add('SQLQRYMODE=');
Memo1.Lines.Add('ENABLE SCHEMA CACHE=FALSE');
Memo1.Lines.Add('ENABLE BCD=FALSE');
Memo1.Lines.Add('ROWSET SIZE=20');
Memo1.Lines.Add('BLOBS TO CACHE=64');
Memo1.Lines.Add('BLOB SIZE=32');
AliasEditor.Add('DocumentsFab','MySQL',Memo1.Lines);
Return matching rows.
SHOW PROCESSLIST ne vont pas fonctionner correctement. Le
correctif consiste à ajouter l'option OPTION=16834 dans la chaîne de connexion
ODBC pour d'utiliser l'option Change BIGINT columns to INT de MyODBC.
Vous pouvez aussi utiliser l'option Return matching rows.
[Microsoft][ODBC Driver Manager] Driver does
not support this parameter, la raison est que vous avez un grand entier
BIGINT dans votre résultat. Essayez d'utiliser l'option Change BIGINT
columns to INT de MyODBC.
Don't optimize column widths.
AUTO_INCREMENT avec ODBC
Un problème récurrent est d'obtenir la dernière valeur générée automatiquement par
une commande INSERT. Avec ODBC, vous pouvez procéder de cette façon (en supposons
que auto est un champ AUTO_INCREMENT):
INSERT INTO foo (auto,text) VALUES(NULL,'text'); SELECT LAST_INSERT_ID();
Ou, si vous voulez juste insérer cette valeur dans une autre table :
INSERT INTO foo (auto,text) VALUES(NULL,'text'); INSERT INTO foo2 (id,text) VALUES(LAST_INSERT_ID(),'text');
See section 8.4.12.3 Comment obtenir l'identifiant unique du dernier enregistrement inséré ?.
Pour quelques applications utilisant ODBC (du moins Delphi et Access), la requête suivante peut être utilisée pour trouver une ligne insérée dernièrement :
SELECT * FROM nom_de_table WHERE auto IS NULL;
Si vous rencontrez des difficultés avec MyODBC, commencez par
faire un fichier de log avec le gestionnaire ODBC (le fichier de log que vous
obtenez en demande les logs de ODBCADMIN) et un log MyODBC.
Pour obtenir un fichier de log MyODBC, vous devez faire ceci :
MyODBC.
Le fichier de log sera écrit dans le fichier `C:\myodbc.log'.
Si l'option de trace n'est pas recommandée lorsque vous retournez dans l'écran
précédent, cela signifie que vous n'utilisez pas myodbcd.dll (voir ci-dessus).
Vérifiez le fichier de trace MyODBC, pour essayer de comprendre ce qui
ne va pas. Vous devriez être capable de trouver les requêtes émises en recherchant
la chaîne >mysql_real_query dans le fichier `myodbc.log'.
Vous devriez aussi essayer de dupiquer la requête dans le client mysql
ou admndemo pour voir si le problème vient de MyODBC ou MySQL.
Si vous trouvez quelques chose d'incorrect, n'envoyez que les lignes pertinentes (maximum, 40 lignes) à myodbc@lists.mysql.com. N'envoyez jamais le fichier de log MyODBC ou ODBC complet!
Si vous êtes incapables de trouver une erreur, la dernière option est de faire une archive (tar ou zip) qui contienne le fichier de trace MyODBC, le fichie de log ODBC, et un fichier README qui contienne une description du problème. Vous pouvez envoyer le tout à ftp://support.mysql.com/pub/mysql/secret/. Seuls nous, à MYSQL AB, pourront accéder à ces fichiers, et nous seront très diligents avec vos données.
Si vous pouvez créer un problème qui reproduit le problème, essayez de l'uploader aussi!
Si le programem fonctionne avec d'autres serveurs SQL, vous devriez faire un log ODBC où vous faîtes exactement la même chose sur les autres serveurs SQL.
N'oubliez jamais que plus vous nous fournissez d'explication, plus nous pourront vous aider!
The C API code is distributed with MySQL. It is included in the
mysqlclient library and allows C programs to access a database.
Many of the clients in the MySQL source distribution are
written in C. If you are looking for examples that demonstrate how to
use the C API, take a look at these clients. You can find these in the
clients directory in the MySQL source distribution.
Most of the other client APIs (all except Java) use the mysqlclient
library to communicate with the MySQL server. This means that, for
example, you can take advantage of many of the same environment variables
that are used by other client programs, because they are referenced from the
library. See section 4.8 MySQL Scripts clients et utilitaires, for a list of these variables.
The client has a maximum communication buffer size. The size of the buffer that is allocated initially (16K bytes) is automatically increased up to the maximum size (the maximum is 16M). Because buffer sizes are increased only as demand warrants, simply increasing the default maximum limit does not in itself cause more resources to be used. This size check is mostly a check for erroneous queries and communication packets.
The communication buffer must be large enough to contain a single SQL
statement (for client-to-server traffic) and one row of returned data (for
server-to-client traffic). Each thread's communication buffer is dynamically
enlarged to handle any query or row up to the maximum limit. For example, if
you have BLOB values that contain up to 16M of data, you must have a
communication buffer limit of at least 16M (in both server and client). The
client's default maximum is 16M, but the default maximum in the server is
1M. You can increase this by changing the value of the
max_allowed_packet parameter when the server is started. See section 5.5.2 Réglage des paramètres du serveur.
The MySQL server shrinks each communication buffer to
net_buffer_length bytes after each query. For clients, the size of
the buffer associated with a connection is not decreased until the connection
is closed, at which time client memory is reclaimed.
For programming with threads, see section 8.4.14 Comment faire un client MySQL threadé. For creating a stand-alone application which includes the "server" and "client" in the same program (and does not communicate with an external MySQL server), see section 8.4.15 libmysqld, la librairie du serveur embarqué MySQL.
MYSQL
MYSQL_RES
SELECT, SHOW, DESCRIBE, EXPLAIN). L'information
retournée par une requête est appelée jeu de résultats dans le reste de
cette section.
MYSQL_ROW
mysql_fetch_row().
MYSQL_FIELD
MYSQL_FIELD pour chaque champ en
appelant plusieurs fois mysql_fetch_field(). Les valeurs des champs ne
font pas partie de la structure; elles sont contenues dans une structure
MYSQL_ROW.
MYSQL_FIELD_OFFSET
mysql_field_seek().) Les index sont des
numéros de champs, dans une ligne, commençant à zéro.
my_ulonglong
mysql_affected_rows(),
mysql_num_rows(), et mysql_insert_id(). Ce type fournit une echelle
allant de 0 à 1.84e19.
Sur quelques systèmes, essayer d'écrire la valeur d'un type my_ulonglong
ne fonctionnera pas. Pour écrire une telle valeur, convertissez là en unsigned long
et utilisez un format d'impression %lu. Exemple :
printf ("Nombre de lignes : %lu\n", (unsigned long) mysql_num_rows(result));
La structure MYSQL_FIELD contient les membres listés ici :
char * name
char * table
table est une chaîne vide.
char * def
mysql_list_fields().
enum enum_field_types type
type peut être l'une des suivantes :
| Valeur de type | Description du type |
FIELD_TYPE_TINY | Champ TINYINT
|
FIELD_TYPE_SHORT | Champ SMALLINT
|
FIELD_TYPE_LONG | Champ INTEGER
|
FIELD_TYPE_INT24 | Champ MEDIUMINT
|
FIELD_TYPE_LONGLONG | Champ BIGINT
|
FIELD_TYPE_DECIMAL | Champ DECIMAL ou NUMERIC
|
FIELD_TYPE_FLOAT | Champ FLOAT
|
FIELD_TYPE_DOUBLE | Champ DOUBLE ou REAL
|
FIELD_TYPE_TIMESTAMP | Champ TIMESTAMP
|
FIELD_TYPE_DATE | Champ DATE
|
FIELD_TYPE_TIME | Champ TIME
|
FIELD_TYPE_DATETIME | Champ DATETIME
|
FIELD_TYPE_YEAR | Champ YEAR
|
FIELD_TYPE_STRING | Champ chaîne de caractères (CHAR ou VARCHAR)
|
FIELD_TYPE_BLOB | Champ BLOB ou TEXT (utilisez max_length pour déterminer la taille maximale)
|
FIELD_TYPE_SET | Champ SET
|
FIELD_TYPE_ENUM | Champ ENUM
|
FIELD_TYPE_NULL | Champ de type NULL
|
FIELD_TYPE_CHAR | Désapprouvé, utilisez FIELD_TYPE_TINY à la place
|
IS_NUM() pour tester si un champ est
de type numérique ou non. Passez la valeur de type à IS_NUM()
et elle sera évaluée à TRUE si le champ est numérique :
if (IS_NUM(field->type))
printf("Le champ est numérique\n");
unsigned int length
unsigned int max_length
mysql_store_result() ou mysql_list_fields(), cela contient la longueur
maximale pour le champ. Si vous utilisez mysql_use_result(), la valeur de cette
variable est zéro.
unsigned int flags
flags peut avoir zéro
ou plusieurs de ces bits suivants activés :
| Valeur d'attribut | Description d'attribut |
NOT_NULL_FLAG | Le champ ne peut être NULL
|
PRI_KEY_FLAG | Le champ fait parti d'une clef primaire |
UNIQUE_KEY_FLAG | Le champ fait parti d'une clef unique |
MULTIPLE_KEY_FLAG | Le champ fait parti d'une clef non-unique |
UNSIGNED_FLAG | Le champ possède l'attribut UNSIGNED
|
ZEROFILL_FLAG | Le champ possède l'attribut ZEROFILL
|
BINARY_FLAG | Le champ possède l'attribut BINARY
|
AUTO_INCREMENT_FLAG | Le champ possède l'attribut AUTO_INCREMENT
|
ENUM_FLAG | Le champ est un ENUM (désapprouvé)
|
SET_FLAG | Le champ est un SET (désapprouvé)
|
BLOB_FLAG | Le champ est un BLOB ou TEXT (désapprouvé)
|
TIMESTAMP_FLAG | Le champ est un TIMESTAMP (désapprouvé)
|
BLOB_FLAG, ENUM_FLAG, SET_FLAG, et
TIMESTAMP_FLAG est désapprouvé car ils indiquent un type de champ plutôt
qu'un attribut de type de champ. Il est préférable de tester field->type
avec FIELD_TYPE_BLOB, FIELD_TYPE_ENUM, FIELD_TYPE_SET, ou
FIELD_TYPE_TIMESTAMP à la place.
L'exemple suivant illustre une utilisation typique de la valeur de flags :
if (field->flags & NOT_NULL_FLAG)
printf("Le champ ne peut être nul\n");
Vous pouvez utiliser les différentes macros ci-dessous pour déterminer le status
booléen de la valeur de l'attribut :
| Status de l'attribut | Description |
IS_NOT_NULL(flags) | Vrai si le champ est défini en tant que NOT NULL
|
IS_PRI_KEY(flags) | Vrai si le champ est une clef primaire |
IS_BLOB(flags) | Vrai si le champ est un BLOB ou TEXT (désapprouvé; tester plutôt field->type)
|
unsigned int decimals
Les fonctions disponibles dans l'API C sont listées ici et décrites en plus de détails dans la section suivante. See section 8.4.3 Description des fonctions de l'API C.
| Fonction | Description |
| mysql_affected_rows() |
Retourne le nombre de lignes changées/effacées/insérés par le dernier UPDATE,
DELETE, ou INSERT.
|
| mysql_change_user() | Change l'utilisateur et la base de données pour une connexion ouverte. |
| mysql_character_set_name() | Retourne le nom du jeu de caractère de la connexion. |
| mysql_close() | Ferme une connexion au serveur. |
| mysql_connect() |
Connecte à un serveur MySQL. Cette fonction est désapprouvée; utilisez
mysql_real_connect() à la place.
|
| mysql_create_db() |
Crée une base de données. Cette fonction est désapprouvée, utilisez
plutôt la commande SQL CREATE DATABASE.
|
| mysql_data_seek() | Déplace le pointeur vers une ligne arbitraire dans le jeu de résultats de la requête. |
| mysql_debug() |
Effectue un DBUG_PUSH avec la chaîne donnée.
|
| mysql_drop_db() |
Supprime une base de données. Cette fonction est désapprouvée, utilisez
plutôt la commande SQL DROP DATABASE.
|
| mysql_dump_debug_info() | Demande au serveur d'écrire les informations de débogage dans un fichier de log. |
| mysql_eof() |
Détermine si la dernière ligne du jeu de résultats a été lue ou non.
Cette fonction est désapprouvée, vous pouvez utiliser mysql_errno() ou mysql_error()
à la place.
|
| mysql_errno() | Retourne le numéro de l'erreur de la fonction appelée en dernier. |
| mysql_error() | Retourne le message d'erreur de la dernière fonction MySQL appelée. |
| mysql_escape_string() | Protège une chaîne en échappant les caractères spéciaux. |
| mysql_fetch_field() | Retourne le type du champ suivant dans la table. |
| mysql_fetch_field_direct() | Retourne le type d'une colonne, étant donné un numéro de champ. |
| mysql_fetch_fields() | Retourne un tableau avec toutes les structures de champs. |
| mysql_fetch_lengths() | Retourne la longueur de toutes les colonnes dans la ligne suivante. |
| mysql_fetch_row() | Récupère la ligne suivante dans le jeu de résultats. |
| mysql_field_seek() | Place le curseur de colonne sur une colonne précise. |
| mysql_field_count() | Retourne le nombre de colonnes dans le résultat pour la requête la plus récente. |
| mysql_field_tell() |
Retourne la position du curseur de champs utilisé pour le dernier appel à
mysql_fetch_field().
|
| mysql_free_result() | Libère la mémoire utilisée par un jeu de résultats. |
| mysql_get_client_info() | Retourne la version du client. |
| mysql_get_host_info() | Retourne une chaîne décrivant la connexion. |
| mysql_get_server_version() | Retourne le numŽro de version du serveur sous forme d'entier (nouveau en 4.1). |
| mysql_get_proto_info() | Retourne la version du protocole utilisé par la connexion. |
| mysql_get_server_info() | Retourne la version du serveur. |
| mysql_info() | Retourne des informations à propos de la requête la plus récente. |
| mysql_init() |
Récupère ou initialise une structure MYSQL.
|
| mysql_insert_id() |
Retourne l'identifié généré pour une colonne AUTO_INCREMENT par la dernière requête.
|
| mysql_kill() | Termine un processus donné. |
| mysql_list_dbs() | Retourne les noms des bases de données répondant à une expression régulière simple. |
| mysql_list_fields() | Retourne les noms des champs répondants à une expression régulière simple. |
| mysql_list_processes() | Retourne une liste des processus courants du serveur. |
| mysql_list_tables() | Retourne les noms des tables répondants à une expression régulière simple. |
| mysql_num_fields() | Retourne le nombre de colonnes dans un jeu de résultats. |
| mysql_num_rows() | Retourne le nombre de lignes dans le jeu de résultats. |
| mysql_options() |
Configure les options de connexion pour mysql_connect().
|
| mysql_ping() | Vérifie si la connexion au serveur a toujours lieu. Reconnecte si besoin. |
| mysql_query() | Exécute une requête SQL spécifée en tant que chaîne terminée par un caractère nul. |
| mysql_real_connect() | Connecte à un serveur MySQL. |
| mysql_real_escape_string() | Protège les caractères spéciaux dans une chaîne utilisable dans une requête SQL, en prenant en compte le jeu de caractères courant de la connexion. |
| mysql_real_query() | Exécute une requête SQL spécifiée en tant que chaîne comptée. |
| mysql_reload() | Demande au serveur de recharger la table des droits. |
| mysql_row_seek() |
Déplace le pointeur vers un ligne dans le jeu de résultats, en utilisant une valeur
retournée par mysql_row_tell().
|
| mysql_row_tell() | Retourne la position du curseur de lignes. |
| mysql_select_db() | Sélectionne une base de données. |
| mysql_shutdown() | Termine le serveur de base de données. |
| mysql_stat() | Retourne le statut du serveur dans une chaîne. |
| mysql_store_result() | Récupère le jeu de résulats complet dans le client. |
| mysql_thread_id() | Retourne l'identifiant du thread courant. |
| mysql_thread_safe() | Retourne 1 si le client est compilé en tant que thread-safe. |
| mysql_use_result() | Initialise une récupération ligne par ligne des résultats. |
| mysql_commit() | Valide une transaction (nouveau en 4.1). |
| mysql_rollback() | Annule une transaction (nouveau en 4.1). |
| mysql_autocommit() | Active et dŽsactive le mode d'auto validation (nouveau en 4.1). |
| mysql_more_results() | VŽrifie si il n'y a plus de rŽsultats (nouveau en 4.1). |
| mysql_next_result() | Retourne/initie le prochain rŽsultat dans une commande multi-requte (nouveau en 4.1). |
Pour vous connecter au serveur, appelez mysql_init() pour initialiser
un gestionnaire de connexion, puis appelez mysql_real_connect() avec
ce gestionnaire (avec d'autres informations tel que l'hôte, l'utilisateur et
le mot de passe). Lors de la connexion, mysql_real_connect() définit
l'option reconnect (quit fait partie de la structure MYSQL) à 1.
Cette option indique, dans le cas où une requête ne peut être exécutée à cause
d'une perte de connexion, d'essayer de se reconnecter au serveur avant d'abandonner.
Lorsque vous n'avez plus besoin de la connexion, appelez mysql_close()
pour la clore.
Tant qu'une connexion est active, le client envoi des requêtes SQL au serveur
à l'aide de mysql_query() ou mysql_real_query(). La différence entre
les deux est que mysql_query() s'attend à ce que la requête soit spécifiée
en tant que chaîne terminée par la chaîne nulle, tandis que mysql_real_query()
attend une chaîne de longueur connue. Si la chaîne contient des données binaires
(incluant l'octet nul), vous devez utiliser mysql_real_query().
Pour chaque requête non-sélective (par exemple, INSERT, UPDATE,
DELETE), vous pouvez trouver combien de lignes ont été mises à jour (affectées)
en appelant mysql_affected_rows().
Pour les requêtes SELECT, vous récupérez les lignes sélectionnées dans un
jeu de résultat. (Notez que quelques commandes ont le même comportement que SELECT,
dans le sens où elle renvoient des lignes. Cela inclut SHOW, DESCRIBE,
et EXPLAIN. Elles doivent être traitées de la même façon que les requêtes
SELECT.)
Il y a deux façons pour un client de gérer les jeux de résultats. Une méthode consiste
à récupérer le jeu de résultat en entier et en une seule fois en appelant
mysql_store_result(). Cette fonction obtient toutes les lignes retournées
par la requête et les stocke dans le client. La seconde méthode consiste à
initialiser une récupération ligne-par-ligne du jeu de résultats en appelant
mysql_use_result(). Cette fonction initie la récupération, mais ne récupère
actuellement aucune ligne à partir du serveur.
Dans les deux cas, vous accédez aux ligne en appelant mysql_fetch_row().
Avec mysql_store_result(), mysql_fetch_row() accède aux lignes qui
ont déjà été récupérées à partir du serveur. Avec mysql_use_result(),
mysql_fetch_row() récupère actuellement la ligne à partir du serveur.
Les informations à propos de la taille des données dans chaque ligne est disponible
en appelant mysql_fetch_lengths().
Après avoir fini de traiter le jeu de résultats, appelez mysql_free_result()
pour libérer la mémoire utilisée.
Les deux mécanismes de récupération sont complémentaires. Les programmes clients doivent
utiliser l'approche qui leur convient le mieux. En pratique, les clients tendent plus
à utiliser mysql_store_result().
Un avantage de mysql_store_result() est que puisque toutes les lignes ont
été récupérées dans le client, vous ne pouvez pas que accéder aux lignes séquentiellement,
vous pouvez revenir en arrière ou avancer dans le jeu de résultats en utilisant
mysql_data_seek() ou mysql_row_seek() pour changer la position de la ligne
courante dans le jeu de résultats. Vous pouvez aussi trouver le nombre total des lignes
en appelant mysql_num_rows(). D'un autre côté, les besoins en mémoire de
mysql_store_result() peuvent être très grands pour les grands jeux de résultats
et vous aurez des chances de rencontrer des conditions out-of-memory.
Un avantage de mysql_use_result() est que le client a besoinde moins de
mémoire pour le jeu de résultats car il utilise une ligne à la fois (et puisque
il y a moins de pertes de mémoire, mysql_use_result() peut être plus rapide).
Les inconvénients sont que vous devez récupérer chaque ligne rapidement pour éviter
de bloquer le serveur, vous n'avez pas d'accès aléatoires aux lignes dans le jeu de
résultats (vous ne pouvez accéder aux lignes que séquentiellement), et vous ne savez
pas combien de lignes comporte le jeu de résultats tant que vous ne les avez pas
toutes récupérées. De plus, vous devez récupérer toutes les lignes même
si vous trouvez entre-temps l'informations que vous cherchiez.
L'API permet aux clients de gérer correctement les requêtes (récupérant les lignes seulement en cas
de besoin) sans savoir si la requête était un SELECT ou non. Vous pouvez faire cela en appelant
mysql_store_result() après chaque mysql_query() (ou mysql_real_query()).
Si l'appel au jeu de résultats réussi, la requête
était un SELECT et vous pouvez lire les lignes. Sinon, appelez
mysql_field_count() pour vérifier si un résultat aurait du être
retourné. Si mysql_field_count() retourne zéro, la requête n'a
pas retourné de données (cela indique que c'était un INSERT,
UPDATE, DELETE, etc.), et ne devait pas retourner de lignes.
Si mysql_field_count() est non-nul, la requête aurait du retourner
des lignes, mais ne l'a pas fait. Cela indique que la requête était un
SELECT qui a échoué. Reportez vous à la description de
mysql_field_count() pour un exemple d'utilisation.
mysql_store_result() et mysql_use_result() vous permettent d'obtenir
des informations à propos des champs qui constituent le jeu de résultat (le nombre de
champs, leurs noms et types, etc.). Vous pouvez accéder aux informations du champ
séquentiellement dans une ligne en appelant plusieurs fois mysql_fetch_field(),
ou avec le numéro du champ dans la ligne en appelant mysql_fetch_field_direct().
La position courante du pointeur de champ peut être changée en appelant
mysql_field_seek(). Changer le pointeur de champ affecte les appels suivants
à mysql_fetch_field(). Vous pouvez aussi obtenir en une seule fois
les informations sur les champs en appelant mysql_fetch_fields().
Pour détecter les erreurs, MySQL fournit un accès aux informations des erreurs
via les fonctions mysql_errno() et mysql_error().
Elles retournent le code de l'erreur et le message pour la dernière fonction invoquée
qui aurait pu réussir ou échouer, vous permettant ainsi de déterminer les erreurs
et leurs causes.
Dans les descriptions suivantes, un paramètre ou retour de fonction NULL correspond
au NULL dans le sens C du terme, et non dans le sens de la valeur NULL de MySQL.
Les fonctions qui retournent une valeur retournent la plupart du temps un pointeur
ou un entier.
Sauf en cas d'indications contraires, les fonctions retournant un pointeur
retournent une valeur non-NULL pour indiquer un succès ou une valeur
NULL pour indiquer une erreur, les fonctions retournant un entier
retournent zéro pour indiquer un succès et une valeur non-nulle en cas d'erreur.
Notez que ``non-nulle'' ne signifie rien de plus que cela.
Sauf si la description de la fonction le dit, ne testez pas avec une valeur différente de zéro :
if (result) /* correct */
... erreur ...
if (result < 0) /* incorrect */
... erreur ...
if (result == -1) /* incorrect */
... erreur ...
Lorsqu'une fonction retourne une erreur, la section Erreurs du descriptif
de la fonction liste les types d'erreurs possibles. Vous pouvez trouver celle qui
est arrivée en appelant mysql_errno().
Une chaîne de caractères représentant l'erreur peut être obtenue en appelant
mysql_error().
mysql_affected_rows()
my_ulonglong mysql_affected_rows(MYSQL *mysql)
Retourne le nombre de lignes modifiées par la dernière commande UPDATE,
supprimées par la dernière commande DELETE ou insérée par la dernière
commande INSERT. Peut être appelée immédiatement après mysql_query() pour
les commandes UPDATE, DELETE, ou INSERT. Pour la commande SELECT,
mysql_affected_rows() fonctionne comme mysql_num_rows().
Un entier supérieur à zéro indique le nombre de lignes affectées ou sélectionnées.
Zéro indique qu'aucun enregistrement n'a été mis à jour pour une requête UPDATE,
qu'aucune lignes n'a correspondu à la clause WHERE dans la requête ou que celle ci
n'a pas encore été exécutée. -1 indique que la requête a renvoyé une erreur ou que, pour
une requête SELECT, mysql_affected_rows() a été appelée avant mysql_store_result().
Aucune.
mysql_query(&mysql,"UPDATE products SET cost=cost*1.25 WHERE group=10");
printf("%ld produits mis à jour",(long) mysql_affected_rows(&mysql));
Si on spécifie l'option CLIENT_FOUND_ROWS en se connectant à mysqld,
mysql_affected_rows() retournera le nombre d'enregistrements correspondants
à la clause WHERE pour une requête UPDATE.
Notez que quand on utilise une commande REPLACE, mysql_affected_rows()
retournera 2 si le nouvel enregistrement en a remplacé un ancien. 2 en retour car dans
ce cas, l'ancienne ligne a été supprimé puis la nouvelle insérée.
mysql_change_user()
my_bool mysql_change_user(MYSQL *mysql, const char *user, const
char *password, const char *db)
Change l'utilisateur et définit la base de données spécifiée par db
en tant que base de données par défaut (courante) dans la connexion spécifiée
par mysql. Pour les requêtes suivantes, cette base de données sera celle
utilisée pour les références aux tables ne spécifiant pas explicitement une
base de données.
Cette fonction a été introduite à la version 3.23.3 de MySQL.
mysql_change_user() échoue si l'utilisateur ne peut être authentifié ou
s'il n'a pas le droit d'utiliser cette base de données. Dans ce cas, l'utilisateur
et la base de données ne sont pas changés.
Le paramètre db peut être mis à NULL si vous ne voulez pas avoir
de base de données par défaut.
Zéro en cas de succès. Différent de zéro si une erreur se produit.
Les mêmes que vous pouvez obtenir avec mysql_real_connect().
CR_COMMANDS_OUT_OF_SYNC
CR_SERVER_GONE_ERROR
CR_SERVER_LOST
CR_UNKNOWN_ERROR
ER_UNKNOWN_COM_ERROR
ER_ACCESS_DENIED_ERROR
ER_BAD_DB_ERROR
ER_DBACCESS_DENIED_ERROR
ER_WRONG_DB_NAME
if (mysql_change_user(&mysql, "user", "password", "new_database"))
{
fprintf(stderr, "Impossible de changer d'utilisateur. Erreur : %s\n",
mysql_error(&mysql));
}
mysql_character_set_name()
const char *mysql_character_set_name(MYSQL *mysql)
Retourne le jeu de caractères par défaut de la connexion courante.
Le jeu de caractères par défaut
Aucune.
mysql_close()
void mysql_close(MYSQL *mysql)
Ferme la connexion ouverte précédemment. mysql_close() désalloue aussi le
pointeur de connexion pointé par mysql, si celui ci avait été alloué dynamiquement
par mysql_init() ou mysql_connect().
Aucune.
Aucune.
mysql_connect()
MYSQL *mysql_connect(MYSQL *mysql, const char *host, const char *user, const char *passwd)
Cette fonction est désapprouvée. Il est préférable d'utiliser mysql_real_connect()
à la place.
mysql_connect() essaye d'établir une connexion à un serveur MySQL
lancé sur host. mysql_connect() doit s'achever avec succès avant
que vous ne puissiez exécuter l'une des autres fonctions de l'API, à l'exception
de mysql_get_client_info().
La signification des paramètres est la même que pour ceux de la fonction
mysql_real_connect() à la différence que le paramètre de connexion
peut être NULL. Dans ce cas, l'API C alloue automatiquement une mémoire
pour la structure de connexion et la libère quand vous appelez mysql_close().
Le désavantage de cette approche est que vous ne pouvez pas récupérer les messages
d'erreur si la connexion échoue. (Pour obtenir des informations sur les erreurs
à partir de mysql_errno() ou mysql_error(), vous devez fournir un
pointeur MYSQL valide.)
La même que pour mysql_real_connect().
Les mêmes que pour mysql_real_connect().
mysql_create_db()
int mysql_create_db(MYSQL *mysql, const char *db)
Crée la base de données nommée avec le paramètre db.
Cette fonction est désapprouvée. Il est préférable d'utiliser mysql_query()
pour générer une requête SQL CREATE DATABASE à la place.
Zéro si la base à été crée avec succès. Différente de zéro si une erreur est survenue.
CR_COMMANDS_OUT_OF_SYNC
CR_SERVER_GONE_ERROR
CR_SERVER_LOST
CR_UNKNOWN_ERROR
if(mysql_create_db(&mysql, "ma_base"))
{
fprintf(stderr, "Impossible de créer une nouvelle base de données. Erreur : %s\n",
mysql_error(&mysql));
}
mysql_data_seek()
void mysql_data_seek(MYSQL_RES *result, my_ulonglong offset)
Se déplace vers une ligne arbitraire d'un jeu de résultat de requête.
Cela nécessite que la structure du jeu de résultat contienne la totalité
du résultat de la requête, de ce fait mysql_data_seek() peut être
utilisée en conjonction avec mysql_store_result(), mais pas avec
mysql_use_result().
L'index de la ligne doit être compris entre 0 et mysql_num_rows(result)-1.
Aucune.
Aucune.
mysql_debug()
void mysql_debug(const char *debug)
Provoque un DBUG_PUSH avec la chaîne donnée. mysql_debug() utilises
la librairie de débogage Fred Fish. Pour utiliser cette fonction vous devez compiler
la librairie client avec le support débogage.
See section D.1 Déboguer un serveur MySQL. See section D.2 Débogage un client MySQL.
Aucune.
Aucune.
L'appel montré ici fais générer à la librairie du client un fichier de trace dans `/tmp/client.trace' sur la machine du client :
mysql_debug("d:t:O,/tmp/client.trace");
mysql_drop_db()
int mysql_drop_db(MYSQL *mysql, const char *db)
Supprime la base de données nommée avec le paramètre db.
Cette fonction est désapprouvée. Il est préférable d'utiliser mysql_query()
pour générer une requête SQL DROP DATABASE à la place.
Zéro si la base à été effacée avec succès. Différente de zéro si une erreur est survenue.
CR_COMMANDS_OUT_OF_SYNC
CR_SERVER_GONE_ERROR
CR_SERVER_LOST
CR_UNKNOWN_ERROR
if(mysql_drop_db(&mysql, "ma_base"))
fprintf(stderr, "Impossible de supprimer la base de données. Erreur : %s\n",
mysql_error(&mysql));
mysql_dump_debug_info()
int mysql_dump_debug_info(MYSQL *mysql)
Demande au serveur d'écrire quelques informations de débogage dans le log.
Pour que cela fonctionne, il faut que l'utilisateur ait le droit SUPER.
Zéro si la commande a été effectuée avec succès. Différente de zéro si une erreur est survenue.
CR_COMMANDS_OUT_OF_SYNC
CR_SERVER_GONE_ERROR
CR_SERVER_LOST
CR_UNKNOWN_ERROR
mysql_eof()
my_bool mysql_eof(MYSQL_RES *result)
Cette fonction est désapprouvée. Vous pouvez utiliser mysql_errno() ou
mysql_error() à la place.
mysql_eof() détermine si la dernière ligne d'un jeu de résultats a été
lue.
Si vous obtenez un jeu de résultats suite à un appel à mysql_store_result(),
le client reçois le jeu entier en une seule opération. Dans ce cas, un retour NULL
de la fonction mysql_fetch_row() signifie toujours que la fin du jeu de résultat a
été atteinte et il n'est donc pas nécessaire d'appeler mysql_eof(). Lors d'une
utilisation avec mysql_store_result(), mysql_eof() retournera toujours
true.
D'un autre côté, si vous utilisez mysql_use_result() pour initialiser la
récupération d'un jeu de résultats, les lignes sont obtenues du serveur une par
une lors des appels successifs de mysql_fetch_row(). Puisque une erreur
peut survenir à la connexion durant ce processus, une valeur de retour NULL
de la part de mysql_fetch_row() ne signifie pas nécessairement que la fin
du jeu de résultats a été atteinte normalement. Dans ce cas, vous pouvez utiliser
mysql_eof() pour déterminer ce qui est arrivé. mysql_eof() retourne
une valeur non-nulle si la fin du jeu de résultats a été atteinte et zéro en cas
d'erreur.
Historiquement, mysql_eof() a vu le jour avant les fonctions d'erreurs standards
de MySQL mysql_errno() et mysql_error(). Puisque ces fonctions fournissent
les mêmes informations, leur utilisation est préférée à mysql_eof(), qui est
maintenant désapprouvée. (En fait, elles fournissent plus d'informations, car
mysql_eof() ne retourne que des valeurs booléennes alors que les fonctions
d'erreurs indiquent les raisons des erreurs lorsqu'elles surviennent.)
Zéro si aucune erreur n'est survenue. Autre chose dans le cas contraire.
Aucune.
L'exemple suivant vous montre comment vous devez utiliser mysql_eof():
mysql_query(&mysql,"SELECT * FROM une_table");
result = mysql_use_result(&mysql);
while((row = mysql_fetch_row(result)))
{
// traite les données
}
if(!mysql_eof(result)) // mysql_fetch_row() failed due to an error
{
fprintf(stderr, "Erreur : %s\n", mysql_error(&mysql));
}
Vous pouvez reproduire la même chose avec les fonctions d'erreurs de MySQL :
mysql_query(&mysql,"SELECT * FROM une_table");
result = mysql_use_result(&mysql);
while((row = mysql_fetch_row(result)))
{
// traite les données
}
if(mysql_errno(&mysql)) // mysql_fetch_row() ne marche pas à cause d'une erreur
{
fprintf(stderr, "Erreur : %s\n", mysql_error(&mysql));
}
mysql_errno()
unsigned int mysql_errno(MYSQL *mysql)
Pour la connexion spécifiée par mysql, mysql_errno() retourne
le code de l'erreur pour l'appel le plus récent à une fonction de l'API qui
peut réussir ou échouer. Un zéro en valeur de retour signifie qu'aucune erreur
ne s'est produite. Les codes erreur du client sont listés dans le fichier d'entête
MySQL (`errmsg.h').
Les codes erreur du serveur sont listés dans le fichier `mysqld_error.h'.
Dans les sources de la distribution MySQL vous pouvez trouver la liste complète
des messages d'erreur et le code qui leur est associé dans le fichier `Docs/mysqld_error.txt'.
Un code d'erreur. Zéro si aucune erreur n'est survenue.
Aucune.
mysql_error()
char *mysql_error(MYSQL *mysql)
Pour la connexion spécifiée par mysql, mysql_error() retourne
le message d'erreur pour l'appel le plus récent à une fonction de l'API qui
peut réussir ou échouer. Une chaîne vide ("") est retournée si aucune
erreur n'est survenue.
Cela signifie que les deux tests suivants sont équivalents :
if(mysql_errno(&mysql))
{
// une erreur est survenue
}
if(mysql_error(&mysql)[0] != '\0')
{
// une erreur est survenue
}
La langue des messages d'erreurs peut être changée en recompilant la librairie du client MySQL. Actuellement, vous pouvez choisir les messages d'erreur parmi un choix de plusieurs langues. See section 4.6.2 Langue des messages d'erreurs.
Une chaîne de caractères qui décrit l'erreur. Une chaîne vide si aucune erreur n'est survenue.
Aucune.
mysql_escape_string()
Vous devez utiliser la fonction mysql_real_escape_string() à la place de celle ci !
Cette fonction est identique à mysql_real_escape_string() à l'exception faite que
mysql_real_escape_string() prends deux identifiants de connexion comme premiers
arguments et échappe la chaîne en se basant que le jeu de caractères courant.
mysql_escape_string() ne prends pas d'identifiant de connexion et ne respecte
pas le jeu de caractères courant.
mysql_fetch_field()
MYSQL_FIELD *mysql_fetch_field(MYSQL_RES *result)
Retourne la définition d'une colonne d'un jeu de résultats en tant que structure
MYSQL_FIELD. Appelez cette fonction plusieurs fois pour obtenir des informations
à propos de toutes les colonnes dans le jeu de résultat. mysql_fetch_field()
retourne NULL quand il ne reste plus de champs.
mysql_fetch_field() est mis à zéro pour retourner des informations à propos
du premier champ à chaque fois que vous exécutez une nouvelle requête SELECT.
Le champ retourné par mysql_fetch_field() est aussi affecté par les appels à
mysql_field_seek().
Si vous avez appelé mysql_query() pour exécuter un SELECT sur une table
mais n'avez pas appelé mysql_store_result(), MySQL retourne la longueur par
défaut du blob (8K octets) si vous avez appelé mysql_fetch_field() pour obtenir
la longueur d'un champ BLOB. (La taille 8K est choisie car MySQL ne connaît pas
la longueur maximale du BLOB. Cela devrait être un jour configurable.)
Une fois que vous avez récupéré le jeu de résultats, field->max_length contient
la longueur de la plus grande valeur de cette colonne dans la requête spécifiée.
La structure MYSQL_FIELD de la colonne courante. NULL s'il ne
reste plus de colonnes.
Aucune.
MYSQL_FIELD *field;
while((field = mysql_fetch_field(result)))
{
printf("nom du champ : %s\n", field->name);
}
mysql_fetch_fields()
MYSQL_FIELD *mysql_fetch_fields(MYSQL_RES *result)
Retourne un tableau de toutes les structures MYSQL_FIELD dans un jeu
de résultats. Chaque structure fournit la définition de champ d'une colonne
dans le jeu de résultats.
Un tableau de structures MYSQL_FIELD pour toutes les colonnes dans le jeu
de résultat.
Aucune.
unsigned int num_fields;
unsigned int i;
MYSQL_FIELD *fields;
num_fields = mysql_num_fields(result);
fields = mysql_fetch_fields(result);
for(i = 0; i < num_fields; i++)
{
printf("Le champ %u est %s\n", i, fields[i].name);
}
mysql_fetch_field_direct()
MYSQL_FIELD *mysql_fetch_field_direct(MYSQL_RES *result, unsigned int fieldnr)
Etant donné un numéro de champ fieldnr pour une colonne dans un jeu de
résultats, cette fonction retourne la définition de ce champ en tant que structure
MYSQL_FIELD. Vous pouvez utiliser cette fonction pour obtenir la définition
d'une colonne choisie arbitrairement. La valeur de fieldnr doit varier entre
0 et mysql_num_fields(result)-1.
La structure MYSQL_FIELD pour la colonne spécifiée.
Aucune.
unsigned int num_fields;
unsigned int i;
MYSQL_FIELD *field;
num_fields = mysql_num_fields(result);
for(i = 0; i < num_fields; i++)
{
field = mysql_fetch_field_direct(result, i);
printf("La champ %u est %s\n", i, field->name);
}
mysql_fetch_lengths()
unsigned long *mysql_fetch_lengths(MYSQL_RES *result)
Retourne les longueurs des colonnes de la ligne courante dans le jeu de résultats.
Si vous voulez copier les valeurs des champs, cette information sur la longueur est
très utile pour l'optimisation, car vous pouvez éviter les appels à strlen().
De plus, si le jeu de résultat contient des données binaires, vous devez
cette fonction pour déterminer la longueur des données, car strlen() retourne
des résultats incorrects pour les champs contenant des caractères nuls.
La longueur des colonnes vides et des colonnes contenant la valeur NULL est zéro.
Pour savoir comment distinguer ces cas, voyez la description de mysql_fetch_row().
Un tableau d'entiers longs non-signés représentant la taille de chaque colonne
(n'incluant pas la caractère nul de terminaison).
NULL si une erreur se produit.
mysql_fetch_lengths() n'st valide que pour la ligne courante du jeu de résultats.
Cette fonction retourne NULL si vous l'appelez avant d'appeler mysql_fetch_row()
ou après avoir récupéré toutes les lignes du résultat.
MYSQL_ROW row;
unsigned long *lengths;
unsigned int num_fields;
unsigned int i;
row = mysql_fetch_row(result);
if (row)
{
num_fields = mysql_num_fields(result);
lengths = mysql_fetch_lengths(result);
for(i = 0; i < num_fields; i++)
{
printf("La colonne %u a %l octets de longueur.\n", i, lengths[i]);
}
}
mysql_fetch_row()
MYSQL_ROW mysql_fetch_row(MYSQL_RES *result)
Récupère la ligne suivante d'un jeu de résultats. Lorsqu'elle est utilisée après
mysql_store_result(), mysql_fetch_row() retourne NULL
quand il n'y a plus de lignes a récupérer. Lorsqu'elle est utilisée après
mysql_use_result(), mysql_fetch_row() retourne NULL quand il
n'y a plus de lignes a récupérer ou qu'une erreur est rencontrée.
Le nombre de valeurs dans la ligne est donné par mysql_num_fields(result).
Si row contient la valeur de retour d'un appel à mysql_fetch_row(),
les pointeurs sur les valeurs sont accédées de row[0] à
row[mysql_num_fields(result)-1]. Les valeurs NULL de la ligne sont
indiquées par des pointeurs NULL.
La longueur de la valeur du champ dans la ligne peut être obtenue en appelant
mysql_fetch_lengths(). Les champs vides et les champs contenant NULL
ont tous deux une longueur égale à zéro; vous pouvez les distinguer en vérifiant
le pointeur sur la valeur du champ. Si le pointeur est NULL, le champ est
NULL; sinon, le champ est vide.
Une structure MYSQL_ROW pour la prochaine ligne. NULL s'il n'y a
plus de lignes a récupérer ou qu'une erreur survient.
CR_SERVER_LOST
CR_UNKNOWN_ERROR
MYSQL_ROW row;
unsigned int num_fields;
unsigned int i;
num_fields = mysql_num_fields(result);
while ((row = mysql_fetch_row(result)))
{
unsigned long *lengths;
lengths = mysql_fetch_lengths(result);
for(i = 0; i < num_fields; i++)
{
printf("[%.*s] ", (int) lengths[i], row[i] ? row[i] : "NULL");
}
printf("\n");
}
mysql_field_count()
unsigned int mysql_field_count(MYSQL *mysql)
Si vous utilisez une version de MySQL plus ancienne que la 3.22.24, vous
devez utiliser unsigned int mysql_num_fields(MYSQL *mysql).
Retourne le nombre de colonnes pour la requête la plus récente de la connexion.
L'utilisation normale de cette fonction est lorsque mysql_store_result()
a retourné NULL (et que vous n'avez donc pas de pointeur sur jeu de résultats).
Dans ce cas, vous pouvez appeler mysql_field_count() pour déterminer si
mysql_store_result() aurait dû produire un résultat non-vide. Cela permet au
programme client d'entreprendre les bonnes actions sans savoir si la requête était
un SELECT (ou équivalent). L'exemple suivant illustre comment cela peut être fait.
Un entier non-signé représentant le nombre de champs dans un jeu de résultats.
Aucune.
MYSQL_RES *result;
unsigned int num_fields;
unsigned int num_rows;
if (mysql_query(&mysql,query_string))
{
// erreur
}
else // requête bonne, traitons les données qu'elle renvoit
{
result = mysql_store_result(&mysql);
if (result) // il y a des lignes
{
num_fields = mysql_num_fields(result);
// récupère les lignes, puis appele mysql_free_result(result)
}
else // mysql_store_result() n'a rien retourné; est-ce normal ?
{
if(mysql_field_count(&mysql) == 0)
{
// la requête ne retourne aucune donnée
// (ce n'était pas un SELECT)
num_rows = mysql_affected_rows(&mysql);
}
else // mysql_store_result() aurait du retourner des données
{
fprintf(stderr, "Erreur : %s\n", mysql_error(&mysql));
}
}
}
Une alternative est de remplacer l'appel à mysql_field_count(&mysql) par
mysql_errno(&mysql). Dans ce cas, vous vérifiez directement les erreurs
à partir de mysql_store_result() plutôt qu'à partir de mysql_field_count()
si la requête était un SELECT.
mysql_field_seek()
MYSQL_FIELD_OFFSET mysql_field_seek(MYSQL_RES *result, MYSQL_FIELD_OFFSET offset)
Place le pointeur de champs à la position donnée. Le prochain appel à mysql_fetch_field()
récupérera la définition du champ de la colonne associée à cet index.
Pour vous placer au début d'une ligne, passez 0 comme valeur d'offset.
La dernière valeur de l'index de champ.
Aucune.
mysql_field_tell()
MYSQL_FIELD_OFFSET mysql_field_tell(MYSQL_RES *result)
Retourne la position du curseur de champ utilisé pour le dernier appel à
mysql_fetch_field(). Cette valeur peut être utilisée en argument de
mysql_field_seek().
L'indice courant du curseur de champ.
Aucune.
mysql_free_result()
void mysql_free_result(MYSQL_RES *result)
Libère la mémoire alloué à un résultat avec mysql_store_result(),
mysql_use_result(), mysql_list_dbs(), etc. Quand vous n'avez
plus besoin d'un jeu de résultat, vous devez libérer la mémoire qu'il occupe
en appelant mysql_free_result().
Aucune.
Aucune.
mysql_get_client_info()
char *mysql_get_client_info(void)
Retourne une chaîne représentant la version de la librairie du client.
Une chaîne de caractères représentant la version de la librairie du client.
Aucune.
mysql_get_server_version()
unsigned long mysql_get_server_version(MYSQL *mysql)
Retourne le numéro de version du serveur, sous la forme d'un entier (nouveau en 4.1).
Un nombre, qui représente le numéro de version du serveur MySQL, au format suivant :
main_version*10000 + minor_version *100 + sub_version
Par exemple, 4.1.0 est retournée comme ceci : 40100.
Ceci est pratique pour déterminer rapidement le numéro de version d'un serveur, dans un client, et connaitre ainsi ses fonctionnalités.
Aucune.
mysql_get_host_info()
char *mysql_get_host_info(MYSQL *mysql)
Retourne une chaîne de caractères décrivant le type de connexion actuellement utilisé, incluant le nom du serveur.
Une chaîne de caractères représentant le nom du serveur et le type de connexion.
Aucune.
mysql_get_proto_info()
unsigned int mysql_get_proto_info(MYSQL *mysql)
Retourne la version du protocole utilisé par la connexion courante.
Un entier non signé représentant la version du protocole utilisé par la connexion courante.
Aucune.
mysql_get_server_info()
char *mysql_get_server_info(MYSQL *mysql)
Retourne une chaîne représentant le numéro de version du serveur.
Une chaîne de caractères représentant le numéro de version du serveur.
Aucune.
mysql_info()
char *mysql_info(MYSQL *mysql)
Récupère une chaîne de caractères fournissant des informations à propos de
la requête exécutée le plus récemment, mais seulement pour celles listées ici.
Pour les autres requêtes, mysql_info() retournera NULL.
Le format de la chaîne varie selon le type de requête, comme décrit ici.
Les nombres présentés sont des exemples; la chaîne retournée contiendra les informations
correspondantes à vos requêtes.
INSERT INTO ... SELECT ...
Records: 100 Duplicates: 0 Warnings: 0
INSERT INTO ... VALUES (...),(...),(...)...
Records: 3 Duplicates: 0 Warnings: 0
LOAD DATA INFILE ...
Records: 1 Deleted: 0 Skipped: 0 Warnings: 0
ALTER TABLE
Records: 3 Duplicates: 0 Warnings: 0
UPDATE
Rows matched: 40 Changed: 40 Warnings: 0
Notez que mysql_info() retourne une valeur non-nulle (NULL) pour les requêtes
INSERT ... VALUES seulement si une liste de valeurs multiples est fournie à la requête.
Une chaîne de caractères représentant des informations additionnelles à propos
de la dernière requête exécutée. NULL si aucune information n'est disponible
pour la requête.
Aucune.
mysql_init()
MYSQL *mysql_init(MYSQL *mysql)
Alloue ou initialise un objet MYSQL convenable pour mysql_real_connect().
Si mysql est un pointeur NULL, la fonction alloue, initialise et retourne
un nouvel objet. Sinon, l'objet est initialisé et son adresse est retournée. Si
mysql_init() alloue un nouvel objet, il sera libéré quand mysql_close()
sera appelée pour clore la connexion.
Un gestionnaire MYSQL* initialisé. NULL s'i