在上一篇文章中，我们详细的分享了关于mysql如何进行远程登入以及在ubuntu上如何安装mysql。那么前期的工作基础，我们已经做好了，今天我们就来往数据库里面插入数据，同时又从数据读取数据,也就是查询数据库中的数据。

一、往数据库中插入数据：

1、在往数据库中插入数据之前，咋们要先做一些前期知识预备。在我们上面的图中，我们可以看到一个节点服务器（也就是我们代码实现业务的的地方，所以等下代码实现对数据库的插入，就是从这里开始操作的），然后我们要从这个节点服务器往数据库库服务器里面的数据库插入数据，那么我们这里就涉及一个概念叫做“数据库建模”，所谓的数据库建模说白了就是把所有数据通过sql语句（也就是数据库能够识别的语言），把某种数据格式存放到数据库中去（当然这里讲的不是很专业），也就是能够对数据库进行代码操作。

那么在之前呢，我们在mysql workbench里面进行创建一个数据库，并同时创建一个表格，以及进行插入数据：

$ Q2 x0 z0 E& j8 dCREATE DATABASE KING_DB;#创建一个数据库
. a: {9 m. j& r) a
/ j; |1 `1 t7 |$ ~SHOW DATABASES;
' J) S3 l. h3 Z3 Z, VUSE KING_DB; #使用数据库
3 `" l+ W- o8 V* B. ?' RCREATE TABLE TBL_USER (
. p6 O( q: {( T! ~U_ID INT PRIMARY KEY AUTO_INCREMENT,#创建一个主键
( p8 D6 g2 f1 l; G' u" @# I& [U_NAME VARCHAR(32),
" c- r* Z/ n; t3 G& RU_GENGDER VARCHAR(8)
);#这里可以养成一个好习惯，在创建用户前面加TBL，别人就知道这个是一个表
) o7 r9 u: H0 R$ N2 |0 J/ k+ y
SHOW TABLES; #显示table表
$ l8 W9 B$ K6 e- i+ Q+ M
  Z/ e0 Y$ K9 H8 a* _1 f7 Z( WSELECT * FROM TBL_USER;#显示表中的数据

INSERT TBL_USER(U_NAME,U_GENGDER) VALUES('King', 'man');#插入数据
$ P1 V% k3 y$ D& P. f, y7 j7 A
6 O5 ^" F& q1 B2 O

实际情景图：

注解：主键意思是唯一的。一个数据表中只能包含一个主键。你可以使用主键来查询数据

上面涉及到的VARCHAR的意思是：

创建表的语法格式：

插入数据语法格式：

2、代码操作设计到的api介绍：

(1)、在写代码操作之前这里要安装一个客户端程序，相当于链接库：

sudo apt-get install libmysqlclient-dev
txp@ubuntu:~$ sudo apt-get install libmysqlclient-dev
" `$ L% Y$ v  S2 C/ y& w& [[sudo] password for txp:
Reading package lists... Done
1 @$ M( m  D3 }, t8 Z! C5 _0 v* uBuilding dependency tree      
Reading state information... Done
The following extra packages will be installed:
9 N# z0 m! b. i+ o# b/ e" J  binutils cpp cpp-4.8 gcc gcc-4.8 libasan0 libatomic1 libc-dev-bin libc6
  Y) k3 u: I+ l' [" V+ c9 B% C  libc6-dev libcloog-isl4 libgcc-4.8-dev libgomp1 libisl10 libitm1 libmpc3
  libmpfr4 libquadmath0 libtsan0 linux-libc-dev manpages-dev zlib1g-dev
8 A* O5 t' D% t. y+ SSuggested packages:
$ ?( w% F# B6 A6 L) H& I0 p% E  binutils-doc cpp-doc gcc-4.8-locales gcc-multilib make autoconf automake1.9
  libtool flex bison gdb gcc-doc gcc-4.8-multilib gcc-4.8-doc libgcc1-dbg
  libgomp1-dbg libitm1-dbg libatomic1-dbg libasan0-dbg libtsan0-dbg
  libquadmath0-dbg glibc-doc
The following NEW packages will be installed:
  binutils cpp cpp-4.8 gcc gcc-4.8 libasan0 libatomic1 libc-dev-bin libc6-dev
( {0 q, U$ K3 [+ g- P" Y  libcloog-isl4 libgcc-4.8-dev libgomp1 libisl10 libitm1 libmpc3 libmpfr4
" A5 y9 Q+ V1 j7 C8 i+ q  libmysqlclient-dev libquadmath0 libtsan0 linux-libc-dev manpages-dev
  zlib1g-dev
5 _$ @0 k# }1 c' i, h- [1 y5 cThe following packages will be upgraded:
! {; A4 }; W+ B/ |  libc6
1 upgraded, 22 newly installed, 0 to remove and 49 not upgraded.
Need to get 24.7 MB of archives.
( M! M$ x; Q4 p0 }+ k0 X0 y6 kAfter this operation, 76.3 MB of additional disk space will be used.
, g: E1 p4 O4 \' `3 }. n) P1 u7 nDo you want to continue? [Y/n] y

(2)、api介绍：

(1)mysql_init()

(2)mysql_real_connect()

(3)mysql_real_query()

(4)mysql_close()

读者一看，这里函数操作跟c语言一样，没错，我们这里是用c语言来对mysql进行操作的，下面我们讲解一下每个api的作用（说明这些操作函数都来自头文件"mysql.h"）：

MYSQL *mysql_init(MYSQL *mysql)
0 D+ s. T2 P  |! K" j+ x

注解：获得或初始化一个MYSQL结构,返回值是一个被始化的MYSQL*句柄，  在内存不足的情况下，返回NULL

这里MYSQLMYSQL结构代表一个数据库连接句柄，包含有关服务器的连接状态的信息，几乎所有函数都是用到它：

typedef struct st_mysql
2 w7 X2 e' x% _( O: T{
3 e/ R7 ~; U- W( h' T  NET           net;                    /* Communication parameters */
  unsigned char *connector_fd;          /* ConnectorFd for SSL */
  char          *host,*user,*passwd,*unix_socket,*server_version,*host_info;
  char          *info, *db;
  struct charset_info_st *charset;
$ p$ x8 m/ ]8 e/ N) ]4 a0 e0 X- S  MYSQL_FIELD   *fields;
6 M/ J' `  O# z4 Q  MEM_ROOT      field_alloc;
  my_ulonglong affected_rows;
  my_ulonglong insert_id;               /* id if insert on table with NEXTNR */
  my_ulonglong extra_info;              /* Not used */
  unsigned long thread_id;              /* Id for connection in server */
4 t9 `5 k  V2 P% q9 G1 n) \  unsigned long packet_length;
( ?4 j2 X( D2 J- V5 w  unsigned int  port;
  unsigned long client_flag,server_capabilities;
) ?  {) M' n+ N1 t  unsigned int  protocol_version;
- ~% b2 ?9 V3 h3 W0 O  }# S1 p  unsigned int  field_count;
5 [: P5 a; J: Q( k$ b3 c  unsigned int  server_status;
  unsigned int  server_language;
  unsigned int  warning_count;
* s  d( G& f" E: ]5 r, S* }" t  struct st_mysql_options options;
& n& A7 ?3 N  Z: z, R! T0 }" P  enum mysql_status status;
; ~3 a' `, Q) L3 c' U  my_bool       free_me;                /* If free in mysql_close */
! u, M# }! ~! E  e$ \" c  my_bool       reconnect;              /* set to 1 if automatic reconnect */
* c$ `0 z( R+ j  t4 X8 D$ y
  /* session-wide random string */
4 }3 s7 t6 A8 [1 D: h  char          scramble[SCRAMBLE_LENGTH+1];
  my_bool unused1;
9 W- i. k# x$ c0 d6 n3 Q' q  void *unused2, *unused3, *unused4, *unused5;
7 I7 ~+ l' E- ~$ B
$ z  T* w0 T8 e$ A$ C  LIST  *stmts;                     /* list of all statements */
  const struct st_mysql_methods *methods;
% W3 X6 y  m) L1 Q3 X2 _  void *thd;
) i# \& V5 S8 E- y  /*
0 _1 ?4 W; Y2 Q; n+ x3 L" f7 ~    Points to boolean flag in MYSQL_RES  or MYSQL_STMT. We set this flag
    from mysql_stmt_close if close had to cancel result set of this object.
0 ]' X6 n2 B' h  */
2 h' D; b% T& Q  my_bool *unbuffered_fetch_owner;
6 k2 [" G; Q7 f  /* needed for embedded server - no net buffer to store the 'info' */
  char *info_buffer;
  void *extension;
} MYSQL;

然后是mysql_real_connect()：

MYSQL *mysql_real_connect(MYSQL *mysql,
const char *host,
const char *user,
const char *passwd,
" h  f9 m0 u  Q' T$ o1 v/ J& Uconst char *db,
unsigned int port,
const char *unix_socket,
unsigned int client_flag);

注解：

函数功能：连接一个MySQL服务器

host表示MYSQL服务器的主机名或IP

user表示登录的用户名

passwd表示登录的密码

db表示要连接的数据库

port表示MySQL服务器的TCP/IP端口

unix_socket表示连接类型

client_flag表示MySQL运行ODBC数据库的标记

函数返回值：如果连接成功，就返回非0，不成功，返回0.

接着是mysql_real_query()：

int mysql_query(MYSQL *mysql,const char *query，);

注解：我们这里的这个示例api跟mysql_real_query()，有一个差别，就是mysql_real_query()有三个参数，第三参数是就是第二个参数的长度（这里我们查看到这个函数具体原型）；同时，两者的真正差别在于，mysql_query()预期的查询为指定的、由Null终结的字符串，而myql_real_query()预期的是计数字符串。如果字符串包含二进制数据（其中可能包含Null字节），就必须使用mysql_real_squery()。

函数功能：对指定的连接进行查询，查询成功返回0，不成功就是非0了。

最后mysql_close()：

void mysql_close(MYSQL *mysql);
& A/ ?: a; u+ s8 S6 u

注解：函数功能是关闭一个服务器连接，并释放与连接相关的内存

二、实战演练：

上面我们已经介绍完了api，下面我们就来对数据库进行插入数据操作了：

1、数据插入：

#include <stdio.h>
3 Y1 s1 g9 E5 R& Z1 y( W#include <mysql.h>
#include <string.h>

: f; J: J2 I( t% q0 P#define KING_DB_SERVER_IP "192.168.40.154"
2 h" E: t. E4 Y& Y: E#define KING_DB_SERVER_PORT 3306
* h( U! z( F- h2 X/ y- K#define KING_DB_USERNAME "txp"
4 m& Q/ \, y1 c4 j4 D8 Q#define KING_DB_PASSWORD "1121518wo"
#define KING_DB_DEFAULTDB "KING_DB"
#define SQL_INSERT_TBL_USER "INSERT TBL_USER(U_NAME,U_GENGDER) VALUES('zttt', 'man');"
int main()
{

    MYSQL mysql ;
' |( I& O7 u8 O/ {   if(NULL== mysql_init(&mysql))
' _1 D$ b2 |% T  M   {
      printf("mysql_init : %s\n",mysql_error(&mysql));
      return -1;
   }
& M. l$ q- Z* N6 i) _$ q/ x' _7 `, M  if(!mysql_real_connect(&mysql,
8 S7 _8 I/ a1 ^' g  KING_DB_SERVER_IP,
  KING_DB_USERNAME,
  KING_DB_PASSWORD,
  KING_DB_DEFAULTDB,
' h- {( P' m2 L% V  KING_DB_SERVER_PORT,NULL,0))
  {
        printf("mysql_real_connect : %s\n",mysql_error(&mysql));
        return -2;
1 W: i$ @" b  C. f( E  }
# m5 u0 _' R2 |  //mysql
if( mysql_real_query(&mysql,SQL_INSERT_TBL_USER,strlen(SQL_INSERT_TBL_USER)))
1 c: v3 {" D* w0 g {
     printf("mysql_real_query : %s\n",mysql_error(&mysql));
* F5 O: I5 V' y. G      return -3;
' G( z0 E* H; [# {& x
4 j5 Z. p2 D* {; n0 x   }
  \, `$ ]7 q0 ~$ E/ d    mysql_close(&mysql);
    return 0;
}

4 u9 d) ], a8 j" ?. W
$ p2 E  U6 ]9 \

编译：

txp@ubuntu:~$ gcc -o mysql mysql.c -I /usr/include/mysql/ -lmysqlclient

; R* r- R$ n- |* K+ n- z& N

然后我们在mysql workbench里面查看原本数据库中表中有哪些数据：

我们可以看到有11行，现在我们来运行一下：

txp@ubuntu:~$ ./mysql
8 R. Q  {! z' g0 p' [9 ftxp@ubuntu:~$

0 |" f5 f! y! E

再次查看 mysql workbench这边的变化：

你会看到多了一个行数据出来，没错，这行数据就是我们刚刚运行写的代码插入到数据库中的数据。

2、数据查询：

这里数据查询的意思，就是说我们从数据库中把数据取到我们的应用程序当中去（也就是我们刚才的那个节点服务器中去）：具体实现步骤如下：

1、先发送sql语句

2、存储我们的结果

3、判断有多少行有多少列

4、最后就可以进行我们的数据抓取

#include <stdio.h>
#include <mysql.h>
1 o& q+ A" o* X0 g! `9 s#include <string.h>
( W( [& T: I; E, p; e% @) v
#define KING_DB_SERVER_IP "192.168.40.154"
#define KING_DB_SERVER_PORT 3306
* {8 N* G3 ^8 |' r#define KING_DB_USERNAME "txp"
#define KING_DB_PASSWORD "1121518wo"
8 h, Y) i  Q6 n8 D& O#define KING_DB_DEFAULTDB "KING_DB"
! F6 M5 G; o5 _( _! G4 M//#define SQL_INSERT_TBL_USER "INSERT TBL_USER(U_NAME,U_GENGDER) VALUES('zttt', 'man');"

& a9 {) s0 ]/ W# Y#define SQL_SELECT_TBL_USER "SELECT * FROM TBL_USER;"

! I/ k0 ~: b7 y% f9 r1 E- P' ]4 l  X//单独写个函数实现查询
int king_mysql_select(MYSQL *handle)
{
if( mysql_real_query(handle,SQL_SELECT_TBL_USER,strlen(SQL_SELECT_TBL_USER)))
{
2 ~1 f: I: e7 W1 B  j$ h7 A   printf("mysql_real_query : %s\n",mysql_error(handle));
   return -1;
1 @- s+ r  o: \* O }
; A1 B5 r2 ]$ ~  MYSQL_RES *res  = mysql_store_result(handle);
  if(NULL == res)
* }9 _: L2 P8 ^1 f   {
7 ~0 `' r) I5 ?, ]- t      printf(" mysql_store_result : %s\n",mysql_error(handle));
: S: c3 d8 Y6 L6 ~( n      return -2;
   }
  int rows =  mysql_num_rows(res);
  printf("rows: %d\n",rows);

' I7 u; P+ s' z+ N   int fields = mysql_num_fields(res);
   printf("fields: %d\n",fields);
, y: C7 T$ q8 ^1 d4 ~  h   MYSQL_ROW row;
   while(row = mysql_fetch_row(res))//查询每行每列中的数据
  {
, t* \* t* S4 k# {, H( g/ N# Q      int i =0;
      for(i=0;i<fields;i++)
6 {2 F8 m1 a( L: B% ?$ q  M      {
          printf("%s\t",row);//这个行就相当于一个数组操作一样
      }
      printf("\n");
  }
1 y' W: `1 {- J2 ]. t  mysql_free_result(res);

, P6 r9 e* l, s$ w  @, B; a  return 0;
  m5 ^2 H9 [" ^  x5 a. b}
9 J# R1 `: e9 B% O, k  u% K! oint main()
{

' d( t0 ]  B7 ^0 x/ k  \    MYSQL mysql ;
   if(NULL== mysql_init(&mysql))
   {
! M* m5 o+ b$ Z" E      printf("mysql_init : %s\n",mysql_error(&mysql));
( h: F9 B& |* `- r$ U      return -1;
9 ^8 C+ x: ~' g4 g   }
  if(!mysql_real_connect(&mysql,
: }" V- ~" A! X' Y- }* F  KING_DB_SERVER_IP,
  KING_DB_USERNAME,KING_DB_PASSWORD,
/ z# k9 C0 H* v/ X  KING_DB_DEFAULTDB,
  KING_DB_SERVER_PORT,NULL,0))
  {
        printf("mysql_real_connect : %s\n",mysql_error(&mysql));
        return -2;
( a9 {6 N8 O) \" u) ?   }
   king_mysql_select(&mysql);
$ P' s; m$ x; ~( M#if 0  
3 h- X+ T/ I4 X/ O  //mysql
if( mysql_real_query(&mysql,SQL_INSERT_TBL_USER,strlen(SQL_INSERT_TBL_USER)))
{
; }  e4 l) F+ F1 \) \     printf("mysql_real_query : %s\n",mysql_error(&mysql));
; c9 @  r' D4 r9 Z1 L- l      return -3;
% t7 j/ k8 ?7 S1 W& k& F! y4 K
# {. k$ Y) t% P  `' Q" e   }
#endif

  mysql_close(&mysql);
/ |0 A: ^4 U/ F, C, R    return 0;
}

: ]9 U' O, q$ U9 d

输出结果：

txp@ubuntu:~$ gcc -o mysql mysql-1.c -I /usr/include/mysql/ -lmysqlclient
txp@ubuntu:~$ ./mysql
( h2 o/ ?: h$ y* W) ?+ Brows: 12
fields: 3
1 txp man
2 txp man
3 txp man
3 J! q4 n: `: @, `: K8 v4 Txp man
5 Txp man
8 m; z( u* b3 P- k0 M& k2 W6 E6 Txp man
( c! e& e, ~0 O& M7 Txp man
8 Txp man
9 King man
8 Q6 H% S( H. I" x0 D; k10 King man
8 G2 [- o: z+ n" R11 zttt man
12 zttt man

注解：上面又有几个陌生的api，下面我们具体来看他们的原型和用法：

结构体MYSQL_RES，MYSQL_RES结构代表返回行的查询结果（SELECT、SHOW、DESCRIBE等），从数据库读取数据，最后就是从MYSQL_RES中读取数据。MYSQL_RES定义如下：

typedef struct st_mysql_res {  
0 N* Q- o0 {& E( Vmy_ulonglong  row_count;  
MYSQL_FIELD   *fields;  
( c# }& ]3 P3 W1 u' l& [8 q$ wMYSQL_DATA    *data;  
MYSQL_ROWS    *data_cursor;  
' l: |, T" D% q9 W. T4 Tunsigned long *lengths;               /* column lengths of current row */  
. A) @' w: l* X. BMYSQL         *handle;                /* for unbuffered reads */  
const struct st_mysql_methods *methods;  
MYSQL_ROW     row;                    /* If unbuffered read */  
6 V8 W- M5 {0 u/ x% }0 q8 k& zMYSQL_ROW     current_row;            /* buffer to current row */  
) \- U+ @3 p4 ?/ g" _  OMEM_ROOT      field_alloc;  
5 V7 r0 n8 l/ `. Q( bunsigned int  field_count, current_field;  
. }' a% m, n! c: I/ B9 T$ X) O* lmy_bool       eof;                    /* Used by mysql_fetch_row */  
/* mysql_stmt_close() had to cancel this result */  
my_bool       unbuffered_fetch_cancelled;   
void *extension;  
% `/ n# f/ ~4 f) _. n9 N} MYSQL_RES;
; N: F3 b3 F; S+ E1 m

结构体MYSQL_ROWS

typedef struct st_mysql_rows {
1 [$ q* X6 n3 E% c+ p  struct st_mysql_rows *next;           /* list of rows */
& [5 z5 Y" f8 m  MYSQL_ROW data;
+ V8 t/ F, o" V7 P& q  unsigned long length;
, v; J: y# j; b4 ]. r} MYSQL_ROWS;
8 ?1 O' j$ {2 [' v/ ^

然后接下来是mysql_store_result()函数：

MYSQL_RES *mysql_store_result(MYSQL *connection);
+ k5 I0 {6 T6 ]

注解：这是在成功调用mysql_query之后使用此函数，这个函数将立刻保存在客户端中返回的所有数据。它返回一个指向结果集结构的指针，如果失败返回NULL

然后接下来是 mysql_num_rows和mysql_num_fields函数

unsigned int mysql_num_rows(MYSQL_RES *result);
5 f7 |/ N% n, n: w  h4 Z* w
# X4 b5 J& m* ~. ?+ q* s' t& funsigned int mysql_num_fields(MYSQL_RES *res);

注解：第一个函数功能是结果集中行的数量。

第二个函数功能是返回指定结果集中列的数量

最后是 mysql_fetch_row函数和 mysql_free_result

MYSQL_ROW mysql_fetch_row(MYSQL_RES *resutl);
+ B1 t6 V0 q' m3 l8 z) d$ l
& p( X4 C$ H$ _, n* m9 I# kvoid mysql_free_result(MYSQL_RES *result);

注解：第一个函数检索结果集的下一行。在mysql_store_result()之后使用时，如果没有要检索的行，mysql_fetch_row()返回NULL。在mysql_use_result()之后使用时，如果没有要检索的行或出现了错误，mysql_fetch_row()返回NULL。如果行中保存了调用mysql_fetch_row()返回的值，将按照row[0]到row[mysql_num_fields(result)-1]，访问这些值的指针。行中的NULL值由NULL指针指明

第二个函数相当于释放内存

三、总结：

本期关于数据库的插入和查询，咋们就总结到这里了，我们下期再见。

+ w1 k# u$ t8 J4 f- F  o3 F