<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
<head>
<meta name="generator" content="HTML Tidy, see www.w3.org">
<!-- this stylesheet will later on be added by lfparser automatically: -->
<style type="text/css">
<!--
pre { font-family:monospace,Courier }
pre.code { font-family:monospace,Courier;background-color:#aedbe8;border-color:#aedbe8 }
p.code { width:80%; alignment:center; background-color:#aedbe8;
border-style:none; border-width:medium; border-color:#aedbe8;
padding:0.1cm ; text-align:left }
-->
</style>
<title></title>
</head>
<body>
<h1>API MySQL C</h1>
<h4>ArticleCategory:</h4>
SoftwareDevelopment
<h4>AuthorImage:</h4>
<img src="../../common/images/OzcanGungor.jpg" alt=
"Ozcan Gungor" width="114" height="147">
<h4>TranslationInfo:</h4>
<p>original in tr<a href=
"mailto:ozcangungor(at)netscape.net">Özcan
Güngör</a><br>
tr to en <a href=
"mailto:ozcangungor(at)netscape.net">Özcan
Güngör</a></p>
<p>en to pl <a href= "mailto:sp3fxc(at)linuxfocus.org">Mariusz Kozlowski</a></p>
<h4>AboutTheAuthor:</h4>
Używam Linux'a od 1997 roku. Wolność, możliwości i opensource.
To właśnie lubię.
<h4>Abstract:</h4>
W tym artykule nauczymy się jak używać C API
(Application Programming Interfaces) dostarczone z MySQL. Aby zrozumieć zawartość tego artykułu potrzebna będzie wiedza z zakresu:
<ul>
<li>Zmienne w C</li>
<li>Funkcje w C</li>
<li>Wskaźniki w C</li>
</ul>
<h4>ArticleIllustration:</h4>
<img src="../../common/images/illustartion304.gif" hspace="10" alt="mysql logo" width="348" height="150">
<h4>ArticleBody:</h4>
<h2>Introduction</h2>
C APIs są rozprowadzane wraz ze źródłem MySQL i zawarte w <i>mysqlclient</i> bibliotece. Są używane do połączenia się z bazą danych
i wykonywania zapytań. Są również przykłady użycia C API w katalogu <i>clients</i> drzewa kodu źródłowego MySQL.
<h2>Typy zmiennych MySQL C</h2>
Następujące typy zmiennych są zdefiniowane w bibliotece MySQL.
Potrzebujemy tych zmiennych aby używać funkcji MySQL.
Zmienne są opisane szczegółowo jednakże te szczegóły nie są tak istotne aby napisać kod.
<p><b>MYSQL</b><br>
Następująca struktura jest komunikacyjnym "pośrednikiem" używanym do połączenia się z bazą danych.</p>
<pre class="code">
typedef struct st_mysql {
NET net; /* Communication parameters */
gptr connector_fd; /* ConnectorFd for SSL */
char *host,*user,*passwd,*unix_socket,
*server_version,*host_info,*info,*db;
unsigned int port,client_flag,server_capabilities;
unsigned int protocol_version;
unsigned int field_count;
unsigned int server_status;
unsigned long thread_id; /* Id for connection in server */
my_ulonglong affected_rows;
my_ulonglong insert_id; /* id if insert on table with NEXTNR */
my_ulonglong extra_info; /* Used by mysqlshow */
unsigned long packet_length;
enum mysql_status status;
MYSQL_FIELD *fields;
MEM_ROOT field_alloc;
my_bool free_me; /* If free in mysql_close */
my_bool reconnect; /* set to 1 if automatic reconnect */
struct st_mysql_options options;
char scramble_buff[9];
struct charset_info_st *charset;
unsigned int server_language;
} MYSQL;
</pre>
<br>
<br>
<p><b>MYSQL_RES</b><br>
Ta struktura reprezentuje rezultaty zapytania, które zwraca krotki. Zwrócony zestaw danych zwany jest: result-set.</p>
<pre class="code">
typedef struct st_mysql_res {
my_ulonglong row_count;
unsigned int field_count, current_field;
MYSQL_FIELD *fields;
MYSQL_DATA *data;
MYSQL_ROWS *data_cursor;
MEM_ROOT field_alloc;
MYSQL_ROW row; /* If unbuffered read */
MYSQL_ROW current_row; /* buffer to current row */
unsigned long *lengths; /* column lengths of current row */
MYSQL *handle; /* for unbuffered reads */
my_bool eof; /* Used my mysql_fetch_row */
} MYSQL_RES;
</pre>
<br>
<br>
<p><b>MYSQL_ROW</b><br>
Ta struktura to typ bezpiecznej reprezentacji danych w krotce.
Nie możesz używać tego jako string, ktróry kończy się znakiem NULL ponieważ dane w tym stringu mogą być typu
binarnego i mogą zawierać właśnie znak NULL.</p>
<pre class="code">
typedef struct st_mysql_field {
char *name; /* Name of column */
char *table; /* Table of column if column was a field */
char *def; /* Default value (set by mysql_list_fields) */
enum enum_field_types type; /* Type of field. Se mysql_com.h for types */
unsigned int length; /* Width of column */
unsigned int max_length; /* Max width of selected set */
unsigned int flags; /* Div flags */
unsigned int decimals; /* Number of decimals in field */
} MYSQL_FIELD;
</pre>
<br>
<br>
<p><b>my_ulonglong</b><br>
Jest to typ użytwany dla liczby krotek i dla
mysql_affected_rows(), mysql_num_rows(), and mysql_insert_id().
Typ ten dostarcza zakres od 0 do 1.84e19. W niektórych systemach próba wypisania wartości my_ulonglong nie powiedzie się.
Aby wypisać taką watość należy ją przekonwertować do unsigned long i użyć formatu %lu (printf). Przykład:<br>
printf(Number of rows: %lu\n", (unsigned long)
mysql_num_rows(result));</p>
<p class="code">typedef unsigned long my_ulonglong;</p>
<h2>Podłączanie się do MySQL i zapytania</h2>
Teraz zakładam, że MySQL jest zainstalowane, a uzytkownik i tabela w badzie danych są stworzeni.
W razie jakich kolwiek problemów informacji można zasięgnąć tutaj <a href="http://www.mysql.com">www.mysql.com</a>.
<p>Jak wcześniej powiedziałem biblioteki MySQL są w bibliotece mysqlclient.
Więc podczas kompilacji programu korzystającego z MySQL konieczne jest dodanie flagi kompilatora <i>-lmysqlclient</i>.
Pliki nagłówkowe MySQL można znaleźć w /usr/include/mysql (może to zależeć od dystrybucji Linux'a).
Nagłówek twojego programu powinien wyglądać tak:</p>
<p class="code">#include <mysql/mysql.h></p>
<p>Zmienne typy i funkcje MySQL są zawarte w tym pliku nagłówkowym.</p>
<p>Następnie musimy stworzyć zmienną, która będzie używana do połączenia się z bazą danych. Jest to bardzo prosto robione poprzez:</p>
<p class="code">MYSQL *mysql;</p>
<p>Przed połączeniem z bazą danycg musimy wywołać następującą funkcję aby zainicjować zmienną mysql:</p>
<p class="code">mysql_init(MYSQL *mysql)</p>
<p>Następnie</p>
<pre class="code">
MYSQL * STDCALL mysql_real_connect(MYSQL *mysql,
const char *host,
const char *user,
const char *passwd,
const char *db,
unsigned int port,
const char *unix_socket,
unsigned int clientflag);
</pre>
<p>Funkcja ta jest wołana aby połączyć się z bazą danych. host to nazwa serwera MySQL.
user to użytkownik, jako który chcemy się do niej podłączyć. passwd ot hasło.
db to baza danych do jakiej chcemy się podłączyć. port to numer portu TCP/IP serwera MySQL.
unix_socket to typ połączenia. clientflag to flaga powodująca pracę MySQL jako ODBC. W tym artykule jest ona ustawiona na 0.
Funkcja ta zwraca 0 gdy połączenie zostanie ustanowione.</p>
<p>Teraz łączymy się z bazą danych i robimy zapytanie:</p>
<pre class="code">
char *query;
</pre>
<p>Używając tego stringu możemy skonstruować jakie kolwiek zdania SQL i robić zapytania. Funkcja wykonująca zapytanie to:</p>
<pre class="code">
int STDCALL mysql_real_query(MYSQL *mysql,
const char *q,
unsigned int length);
</pre>
mysql to zmienna jakjiej użyliśmy powyżej. q to łańcuch zapytania SQL. length to dłogość tego łańcucha.
Jeśli zapytanie zakończy się bez błędów funkcja zwróci 0.
<p>Po zrobieniu zapytania potrzebujemy zmiennej w MYSQL_RES aby móc użyć wyników zapytania.
Następująca linia tworzy tą zmienną:</p>
<pre class="code">
MYSQL_RES *res;
</pre>
Następnie
<pre class="code">
mysql_use_result(MYSQL *query)
</pre>
Ta funkcja jest używana do odczytania rezultatów.
<p>Jakoże można robić zapytania bardzo łatwo, potrzebujemy nowych funkcji aby użyć rezultatów tych zapytań. Pierwsza to:</p>
<pre class="code">
MYSQL_ROW STDCALL mysql_fetch_row(MYSQL_RES *result);
</pre>
Funkcja ta konwertuje rezultaty w krotki. Jak można zauważyć, funkcja zwraca zmienną typu MYSQL_ROW.
Następująca linia tworzy taką zmienną:
<pre class="code">
MYSQL_ROW row;
</pre>
Jak wyjaśniłem powyżej zmienna row to tablica łańcuchów.
To znaczy, że row[0] jest pierwszą kolumną pierwszego rzędu, row[1]
jest drugą kolumną pierwszego rzędu.... Gdy używamy mysql_fetch_row wtedy do zmiennej row są zapisywane dane następnej krotki jako rezultat.
Gdy dotrzemy do końca rezultatu zapytania funkcja zwraca wartość ujemną.
Na koniec zamykamy połączenie:
<pre class="code">
mysql_close(MYSQL *mysql)
</pre>
<h2>Niektóre użyteczne funkcje</h2>
Zobaczmy jak otrzymać ilość atrybutów w tabeli. Następująca funkcja jest za to odpowiedzialna:
<pre class="code">
unsigned int STDCALL mysql_num_fields(MYSQL *mysql);
</pre>
Ta funkcja zwraca ilość atrybutów w tabeli.
<p>Aby uzyskać ilość krotek zapytania należy użyć:</p>
<p class="code">my_ulonglong STDCALL mysql_num_rows(MYSQL_RES
*res);</p>
<p class="code">my_ulonglong STDCALL mysql_affected_rows(MYSQL
*mysql);</p>
Funkcja ta jest używana aby sprawdzić ilość krotek biorących udział przy wywoływaniu zapytań typu: INSERT, DELETE, UPDATE.
Zauważ, że funkcja ta zwraca typ my_ulonglong.
<p>Na koniec przykładowy kod:</p>
<pre class="code">
#include <mysql/mysql.h>
#include <stdio.h>
void main(){
MYSQL *mysql;
MYSQL_RES *res;
MYSQL_ROW row;
char *query;
int t,r;
mysql_init(mysql);
if (!mysql_real_connect(mysql,"localhost","mysql",
"mysql","deneme",0,NULL,0))
{
printf( "Error connecting to database: %s\n",mysql_error(mysql));
}
else printf("Connected...\n");
query="select * from Deneme";
t=mysql_real_query(mysql,query,(unsigned int) strlen(query));
if (t)
{
printf("Error making query: %s\n",
mysql_error(mysql));
}
else printf("Query made...\n");
res=mysql_use_result(mysql);
for(r=0;r<=mysql_field_count(mysql);r++){
row=mysql_fetch_row(res);
if(row<0) break;
for(t=0;t<mysql_num_fields(res);t++){
printf("%s ",row[t]);
}
printf("\n");
}
mysql_close(mysql);
}
</pre>
<h2>Warto przeczytać</h2>
<ul>
<li>Strona MySQL: <a href=
"http://www.mysql.com">www.mysql.com</a></li>
<li>Dokumentacja dostrczona wraz ze źródłami MySQL. (Przypuszczalnie w katalogu /usr/doc)</li>
</ul>
</body>
</html>