Explication détaillée de l'interface MySQL en langage C

Introduire une interface MySQL au langage C

mysql_character_set_name()

const char* mysql_character_set_name(MYSQL* mysql)
Renvoie le jeu de caractères par défaut pour la connexion actuelle
Valeur de retour : le jeu de caractères par défaut

mysql_close()

annuler mysql_close (MYSQL * mysql)
Description : ferme la connexion précédemment ouverte, si le handle a été automatiquement alloué par mysql_init() ou mysql_connect(), mysql_close() désallouera également le handle de connexion pointé par mysql.

mysql_data_seek()

void mysql_data_seek (résultat MYSQL_RES *, décalage my_ulonglong)
Recherchez n'importe quelle ligne dans le jeu de résultats de la requête. La valeur de décalage est le numéro de ligne, allant de 0 à mysql_num_rows(result) -1 .
Cette fonction nécessite que la structure du jeu de résultats contienne tous les résultats de la requête. Par conséquent, mysql_data_seek() ne doit être utilisé qu'avec mysql_store_result(), et non mysql_use_result().

mysql_errno()

int non signé mysql_errno(MYSQL* mysql)
Pour la connexion spécifiée par mysql, mysql_errno() renvoie le code d'erreur de la fonction API la plus récemment appelée, qui peut ou non avoir réussi.
Une valeur de retour de "0" indique qu'aucune erreur ne s'est produite.
En cas d'échec, renvoie le code d'erreur du dernier appel mysql_xxx().

mysql_error()

const char* mysql_error(MYSQL* mysql)
Pour la connexion spécifiée par mysql, mysql_error() renvoie une chaîne terminée par NULL contenant le message d'erreur pour la fonction API la plus récemment appelée qui a échoué.
Si la fonction n'échoue pas, la valeur de retour de mysql_error() peut être l'erreur précédente, ou une chaîne vide indiquant qu'il n'y a pas d'erreur.

mysql_fetch_field()

MYSQL_FIELD* mysql_fetch_field (résultat MYSQL_RES*)
Renvoie les colonnes du jeu de résultats dans la structure MYSQL_FIELD. Appelez cette fonction à plusieurs reprises pour récupérer des informations sur toutes les colonnes du jeu de résultats. Lorsqu'il ne reste aucun champ, mysql_fetch_field() renvoie NULL.
Chaque fois qu'une nouvelle requête SELECT est exécutée, mysql_fetch_field() est réinitialisé pour renvoyer des informations sur le premier champ.
Les appels à mysql_field_seek() affectent également les champs renvoyés par mysql_fetch_field().
Structure MYSQL_FIELD pour la colonne actuelle. Renvoie NULL s'il ne reste aucune colonne.
Remarque : Si mysql_query() est appelé pour effectuer un SELECT sur une table, mais que mysql_store_result() n'est pas appelé, si mysql_fetch_field() est appelé pour demander la longueur d'un champ BLOB, MYSQL renverra la longueur de blob par défaut (8 Ko).

Champ MYSQL_FIELD* ;
while(field = mysql_fetch_field(result))
printf("field name %s
",field->name); //Affiche le nom du champ de chaque colonne

mysql_fetch_fields()

MYSQL_FIELD* mysql_fetch_fields (résultat MYSQL_RES*)
Pour un jeu de résultats, renvoie un tableau de toutes les structures MYSQL_FIELD. Chaque structure fournit des définitions de champ pour 1 colonne dans le jeu de résultats

Valeur de retour : un tableau de structures MYSQL_FIELD pour toutes les colonnes du jeu de résultats.

unsigned int num_fields;
unsigned int i;
MYSQL_FIELD* fields;

num_fields = mysql_num_fields(res);
fields = mysql_fetch_field(res);
for (i = 0; i < num_fields; ++i)
	printf("Field %u is %s

", je, champs[je].nom);

mysql_fetch_lengths()

long* non signé mysql_fetch_lengths (résultat MYSQL_RES*)
Renvoie la longueur des colonnes de la ligne actuelle du jeu de résultats.
Si le jeu de résultats contient des données binaires, cette fonction doit être utilisée pour déterminer la taille des données car strlen() renverra des résultats incorrects pour tout champ contenant des caractères NULL.

Valeur de retour : tableau d'entiers longs non signés représentant la taille de chaque colonne (sans aucun caractère NULL de fin). S'il y a une erreur, retourne NULL

MYSQL_ROW row;
unsigned long *lengths;
unsigned int num_fields;
unsigned int i;

mysql_data_seek(res, 1);

row = mysql_fetch_row(res);
if (row)
{
	num_fields = mysql_num_fields(res);
	lengths = mysql_fetch_lengths(res);

	for (i = 0; i < num_fields; ++i)
		printf("Column %u is %lu bytes in length.

", je, longueurs[i]);
}

mysql_fetch_row()

MYSQL_ROW mysql_fetch_row (résultat MYSQL_RES*)
Récupère la ligne suivante du jeu de résultats. Lorsqu'il est utilisé après mysql_store_result(), mysql_fetch_row() renvoie NULL s'il n'y a pas de lignes à récupérer
Le nombre de valeurs inline est donné par mysql_num_fields(result). Si la ligne contient des valeurs renvoyées par un appel à mysql_fetch_row(), les pointeurs vers ces valeurs sont accessibles en tant que ligne[0] à ligne[mysql_num_fields(result)-1]. Une valeur NULL dans une ligne est indiquée par un pointeur NULL.
Les longueurs des valeurs de champ dans une ligne peuvent être obtenues en appelant mysql_fetch_lengths(). Pour les champs vides et les champs contenant NULL, la longueur est 0. En examinant le pointeur vers la valeur du champ, ils peuvent être distingués. Si le pointeur est NULL, le champ est NULL, sinon le champ est vide.
Valeur de retour : structure MYSQL_ROW pour la ligne suivante, ou NULL s'il n'y a plus de lignes à récupérer ou si une erreur s'est produite.

ligne MYSQL_ROW ;
entier non signé num_fields ;
entier non signé i ;

num_fields = mysql_num_fields(result);
while(row = mysql_fetch_row(result))
{ unsigned long * lengths; longueurs = mysql_fetch_lengths(result); for(i = 0;i < num_fields; ++i) printf("[%.*s] ",(int)lengths[i], row[i] ? row[i] : "NULL"); printf( ” "); }

mysql_field_count()

entier non signé mysql_field_count(MYSQL* mysql)
Renvoie le nombre de colonnes de la requête la plus récente agissant sur la jointure
L'utilisation normale de cette fonction est lorsque mysql_store_result() renvoie NULL (et donc pas de pointeur d'ensemble de résultats). Dans ce cas, mysql_field_count() peut être appelé pour déterminer si mysql_store_result() doit produire un résultat non nul. De cette façon, le client peut prendre l'action appropriée sans savoir si la requête est une instruction SELECT (ou de type SELECT).

mysql_field_seek()

MYSQL_FIELD_OFFSET mysql_field_seek (résultat MYSQL_RES*, décalage MYSQL_FIELD_OFFSET)
Définissez le curseur de champ sur le décalage donné. Le prochain appel à mysql_fetch_field() récupérera la définition de colonne associée à ce décalage.
Pour trouver le début de la ligne, passez un décalage de 0.
Valeur de retour : La valeur précédente du curseur de champ.

mysql_field_tell()

MYSQL_FIELD_OFFSET mysql_field_tell (résultat MYSQL_RES*)
Renvoie le décalage actuel du curseur

mysql_free_result()

Libère la mémoire allouée au jeu de résultats. Après avoir terminé l'opération sur le jeu de résultats, vous devez appeler mysql_free_result() pour libérer la mémoire utilisée par le jeu de résultats.
N'essayez pas d'accéder au jeu de résultats une fois la publication terminée

mysql_get_character_set_info()

annuler mysql_get_character_set_info(MYSQL* mysql, MY_CHARSET_INFO* cs)
Cette fonction fournit des informations sur le jeu de caractères client par défaut. Le jeu de caractères par défaut peut être modifié à l'aide de la fonction mysql_set_character_set().

mysql_init()

MYSQL* mysql_init(MYSQL* mysql)
Allouez ou initialisez un objet MYSQL approprié pour mysql_real_connect(). Si mysql est un pointeur NULL, cette fonction allouera, initialisera et renverra le nouvel objet. Sinon, l'objet est initialisé et l'adresse de l'objet est renvoyée.
Si mysql_init() a alloué un nouvel objet, lorsque mysql_close() est appelé pour fermer la connexion. L'objet sera libéré.
Valeur de retour : Le handle MYSQL* initialisé. Renvoie NULL s'il n'y a pas assez de mémoire pour allouer le nouvel objet.

mysql_list_dbs()

MYSQL_RES* mysql_list_dbs(MYSQL_mysql,const char_wild)
Renvoie un jeu de résultats composé de noms de bases de données sur un serveur qui correspond à une expression régulière simple spécifiée par un paramètre générique. Les paramètres génériques peuvent contenir "%" ou "_", ou peuvent être NULL pour que toutes les bases de données correspondent.
La méthode d'appel de mysql_list_dbs() est similaire à l'exécution d'une requête SHOW bases de données
Le jeu de résultats doit être libéré avec mysql_free_result()
Valeur de retour : renvoie le jeu de résultats MYSQL_RES après un succès. Renvoie NULL en cas d'erreur.

mysql_list_fields()

MYSQL_RES* mysql_list_fields(MYSQL* mysql,const char* table,const char* wild)
Renvoie un jeu de résultats composé de noms de champs de la table donnée qui correspond à l'expression régulière simple spécifiée par l'argument générique. Les paramètres génériques peuvent contenir des caractères génériques "%" ou "_", ou un pointeur NULL pour correspondre à tous les champs.
L'appel de la méthode mysql_list_fields() est similaire à l'exécution de la requête SHOW COLUMNS FROM tal_name.
Valeur renvoyée : en cas de succès, renvoie le jeu de résultats MYSQL_RES. Renvoie NULL en cas d'erreur.

mysql_list_tables()

MYSQL_RES* mysql_list_tables(MYSQL_mysql,const char_wild)
Valeur de retour : renvoie un ensemble de résultats composé de noms de table dans la base de données actuelle qui correspond à l'expression régulière simple spécifiée par le paramètre générique. Les arguments génériques peuvent contenir des caractères génériques "%" ou "_", ou un pointeur NULL pour correspondre à toutes les autres tables.
La méthode d'appel de mysql_list_tables() est similaire à l'exécution de la requête SHOW tables ;
Valeur renvoyée : en cas de succès, renvoie le jeu de résultats MYSQL_RES. Renvoie NULL en cas d'erreur.

mysql_num_rows()

my_ulonglong mysql_num_rows (résultat MYSQL_RES*)
Renvoie le nombre de lignes dans le jeu de résultats
Si mysql_store_result() est utilisé, mysql_num_rows() peut être appelé immédiatement.
Si mysql_use_result() est utilisé, mysql_num_rows() ne renvoie pas la valeur correcte tant que toutes les lignes du jeu de résultats n'ont pas été récupérées.
Valeur de retour : le nombre de lignes dans le jeu de résultats.

mysql_options()

int mysql_options (MYSQL * mysql, option enum mysql_option, const char * arg)
Peut être utilisé pour définir des options de connexion supplémentaires et affecter le comportement de la connexion. Cette fonction peut être appelée plusieurs fois pour définir plusieurs options.
mysql_options() doit être appelé après mysql_init() et avant mysql_connect() ou mysql_real_connect()
Le paramètre option fait référence à l'option que vous avez l'intention de définir et le paramètre Arg est la valeur de l'option. Si l'option est un entier, alors arg doit pointer vers la valeur de l'entier.
Je ne liste pas les valeurs d'options possibles ici, vous pouvez Baidu par vous-même.
Valeur de retour : 0 en cas de succès, différent de zéro si des options inconnues sont utilisées.

mysql_ping()

int mysql_ping(MYSQL*mysql)
Vérifiez que la connexion au serveur fonctionne. Si le travail est perdu, une reconnexion sera automatiquement tentée.
Cette fonction peut être utilisée par les clients inactifs depuis longtemps pour vérifier si le serveur a coupé la connexion et se reconnecter si nécessaire.
Valeur de retour : Retourne 0 si la connexion au serveur est valide, non nulle en cas d'erreur. La valeur non nulle renvoyée n'indique pas si le serveur MYSQL a été fermé et la connexion peut être interrompue pour d'autres raisons, telles que des problèmes de réseau.

mysql_query()

int mysql_query (MYSQL * mysql, const char * requête)
Exécutez la requête SQL pointée par la requête "chaîne terminée par NULL". Normalement, la chaîne doit contenir une instruction SQL et aucun point-virgule ";" ou "g" ne doit être ajouté à l'instruction.
mysql_query() ne peut pas être utilisé pour les requêtes contenant des données binaires, mysql_real_query() doit être utilisé à la place, car les données binaires peuvent contenir le caractère "", que mysql_query() interprète comme la fin de la chaîne de requête.
Renvoie 0 si la requête aboutit, et différent de zéro en cas d'erreur.

mysql_real_connect()

MYSQL* mysql_real_connect(MYSQL* mysql,const char* host,const char* user,const char* passwd,const char* db,const char* unix_socket,unsigned long client_flag)
mysql_real_connect() tente d'établir une connexion avec le moteur de base de données MYSQL exécuté sur l'hôte. mysql_real_connect() doit se terminer avec succès avant que vous puissiez exécuter toute autre fonction API nécessitant un mécanisme de gestion de connexion MYSQL valide.
Le premier paramètre doit être l'adresse d'une structure MYSQL existante. Appelez mysql_init() pour initialiser la structure MYSQL.
La valeur du second paramètre host doit être le nom d'hôte ou l'adresse IP. Si host est NULL ou la chaîne "localhost", la connexion sera traitée comme une connexion à localhost. Si le système d'exploitation supporte les sockets Unix ou ces canaux nommés Windows, ils seront utilisés à la place de TCP/IP pour se connecter au serveur.
Le troisième paramètre utilisateur contient l'ID de connexion MYSQL de l'utilisateur. Si l'utilisateur est NULL ou la chaîne vide, l'utilisateur sera considéré comme l'utilisateur actuel. Dans un environnement UNIX, il s'agit du nom de connexion actuel. Sous Windows, le nom d'utilisateur courant doit être spécifié.
Le paramètre passwd contient le mot de passe de l'utilisateur. Si passwd est NULL, seules les entrées de la table des utilisateurs (avec un champ de mot de passe vide) pour cet utilisateur sont vérifiées pour une correspondance. De cette manière, l'administrateur de la base de données peut définir le système d'autorisation MYSQL d'une manière spécifique, selon que l'utilisateur possède ou non le mot de passe spécifié, l'utilisateur obtiendra des autorisations différentes.
Remarque : N'essayez pas de chiffrer le mot de passe avant d'appeler mysql_real_connect(), le chiffrement du mot de passe sera géré automatiquement par l'API client.
"db" est le nom de la base de données, si db est NULL, la connexion définira la base de données par défaut sur cette valeur.
Si port n'est pas 0, sa valeur sera utilisée comme numéro de port pour les connexions TCP/IP. Notez que le paramètre host détermine le type de connexion.
Si unix_socket n'est pas NULL, cette chaîne décrit quelle socket ou quel canal nommé doit être utilisé. Remarque : Le paramètre "host" détermine le type de connexion.
La valeur de client_flag est généralement 0, cependant, des drapeaux peuvent également être définis. Je ne vais pas le présenter, juste Google vous-même.
Valeur de retour : si la connexion réussit, renvoie le descripteur de connexion MYSQL*. Renvoie NULL si la connexion échoue. Pour une connexion réussie, la valeur de retour est la même que la valeur du premier paramètre.

mysql_real_query()

int mysql_real_query(MYSQL* mysql,const char* query,longueur non signée)
Exécutez la requête SQL pointée par "query", qui doit être l'octet de longueur de chaîne "long". Normalement, la chaîne doit contenir une instruction SQL et aucun ";" ou "g" ne doit être ajouté à l'instruction.
Pour les requêtes qui contiennent des données binaires, vous devez utiliser mysql_real_query() au lieu de mysql_query() car les données binaires peuvent contenir des caractères "". De plus, mysql_real_query() est plus rapide que mysql_query() car il n'appelle pas strlen() sur la chaîne de requête.
Renvoie 0 si la requête aboutit. Si une erreur se produit, une valeur différente de zéro est renvoyée.

mysql_row_seek()

MYSQL_ROW_OFFSET mysql_row_seek (résultat MYSQL_RES*, décalage MYSQL_ROW_OFFSET)
Place les coordonnées de ligne sur n'importe quelle ligne du jeu de résultats de la requête. offset est le décalage de la ligne, qui devrait être la valeur renvoyée par mysql_row_tell() ou mysql_row_seek(). La valeur n'est pas un numéro de ligne, utilisez mysql_data_seek() si vous avez l'intention d'interroger les lignes du jeu de résultats par numéro
Cette fonction nécessite les résultats complets de la requête dans le jeu de résultats, donc mysql_row_seek() ne doit être utilisé qu'avec mysql_store_result(), pas avec mysql_use_result().
La valeur précédente de la coordonnée de la ligne qui peut être transmise aux utilisations ultérieures de mysql_row_seek().

mysql_row_tell()

MYSQL_ROW_OFFSET mysql_row_tell (résultat MYSQL_RES*)
Pour la précédente mysql_fetch_row(), renvoie la position actuelle du curseur. Cette valeur peut être utilisée comme argument pour mysql_row_seek().
Ne peut être utilisé qu'après mysql_store_result(), pas après mysql_use_result().
Valeur de retour : le décalage actuel des coordonnées de la ligne

mysql_set_character_set()

int mysql_set_character_set(MYSQL* mysql, char* csname)
Cette fonction est utilisée pour définir le jeu de caractères par défaut pour la connexion en cours. La chaîne csname spécifie un nom de jeu de caractères valide. Le classement de connexion devient le classement par défaut pour le jeu de caractères.
Valeur de retour : 0 signifie succès, une valeur différente de zéro signifie une erreur

if(!mysql_set_charset_name(&mysql,“utf8”))
{ printf("Nouveau jeu de caractères client : %s ", mysql_character_set_name(&mysql)); }

mysql_shutdown()

int mysql_shutdown(MYSQL* mysql, enum enum_shutdown_level shutdown_level)
Demander l'arrêt du serveur de base de données. Pour s'assurer que l'utilisateur connecté doit avoir l'autorité SHUTDOWN.
Valeur de retour : 0 en cas de succès, différent de zéro en cas d'erreur.

mysql_store_result()

MYSQL_RES* mysql_store_result(MYSQL*mysql)
Pour chaque requête (SELECT, SHOW, DESCRIBE, EXPLAIN, CHECK TABLE, etc.) qui récupère avec succès des données, mysql_store_result() ou mysql_use_store() doit être appelée.
mysql_store_result() lit les résultats complets de la requête au client, alloue une structure MYSQL_RES et place les résultats dans cette structure.
mysql_store_result() renvoie un pointeur NULL si la requête ne renvoie pas de jeu de résultats
Si la lecture du jeu de résultats échoue, mysql_store_result() renvoie également un pointeur NULL. Vous pouvez vérifier si une erreur s'est produite en vérifiant si mysql_error() renvoie une chaîne non vide et mysql_errno() renvoie une valeur non nulle.
Si aucune ligne n'est renvoyée, un jeu de résultats vide sera renvoyé. (Le paramètre de jeu de résultats vide est différent du pointeur nul comme valeur de retour)
Une fois que vous appelez mysql_store_result() et obtenez un résultat qui n'est pas un pointeur NULL, vous pouvez appeler mysql_num_rows() pour connaître le nombre de lignes dans le jeu de résultats.
Vous pouvez appeler mysql_fetch_row() pour obtenir une ligne dans le jeu de résultats, ou mysql_row_seek() ou mysql_row_tell() pour obtenir ou définir la position actuelle de la ligne dans le jeu de résultats.
Une fois l'opération sur le jeu de résultats terminée, mysql_free_result() doit être appelé.
Valeur de retour : collection de résultats MYSQL_RES avec plusieurs résultats. Renvoie NULL en cas d'erreur.

mysql_use_result()

MYSQL_RES* mysql_use_result(MYSQL* mysql)
mysql_use_result initialisera la récupération du jeu de résultats, mais ne lira pas réellement le jeu de résultats au client comme le fait mysql_store_result(). Il doit récupérer chaque ligne individuellement via un appel à mysql_fetch_row(). Cela lira le résultat directement depuis le serveur sans l'enregistrer dans une table temporaire ou un tampon local, ce qui est plus rapide et utilise moins de mémoire que mysql_store_result(). Le client alloue de la mémoire uniquement pour la ligne actuelle et les tampons de communication.
Si mysql_use_result() est utilisé, cela lie le serveur et empêche les autres threads de mettre à jour les tables.
Lors de l'utilisation de mysql_use_result(), mysql_fetch_row() doit être exécuté jusqu'à ce qu'une valeur NULL soit renvoyée, sinon les lignes non récupérées seront renvoyées lors de la prochaine récupération.
mysql_data_seek(), mysql_row_seek(), mysql_row_tell(), mysql_num_row() ne doivent pas être utilisés avec les résultats renvoyés par mysql_use_result(), et aucune autre requête ne doit être émise jusqu'à ce que mysql_use_result() se termine.
Une fois l'opération sur le jeu de résultats terminée, mysql_free_result() doit être appelé.

Il y a aussi quelques interfaces que je n'ai pas utilisées dans mon développement pour le moment, je les mettrai à jour plus tard si elles sont utiles.