C语言与sqlserver数据库

1.使用C语言来操作sql SERVER数据库,采用ODBC开放式数据库连接进行数据的添加,修改,删除,查询等操作。
 step1:启动sqlSERVER服务,例如:HNHJ,开始菜单 ->运行 ->net start mssqlserver
 step2:打开企业管理器,建立数据库test,在test库中建立test表(a varchar(200),b varchar(200))
 step3:建立系统DSN,开始菜单 ->运行 ->odbcad32,
  添加->sql SERVER
 名称：csql,服务器：HNHJ
 使用用户使用登录ID和密码的sqlSERVER验证,登录ID:sa,密码:
  更改默认的数据库为:test
 ...
 测试数据源，测试成功，即DNS添加成功。

2.cpp文件完整代码

//##########################save.cpp##########################

C代码

1. #include <stdio.h>      
2. #include <string.h>      
3. #include <windows.h>      
4. #include <sql.h>      
5. #include <sqlext.h>      
6. #include <sqltypes.h>      
7. #include <odbcss.h>      
8.   
9. sqlHENV henv = sql_NULL_HENV;      
10. sqlHDBC hdbc1 = sql_NULL_HDBC;      
11. sqlHSTMT hstmt1 = sql_NULL_HSTMT;      
12.   
13. /*  
14.     cpp文件功能说明：  
15.     1.数据库操作中的添加，修改，删除，主要体现在sql语句上  
16.     2.采用直接执行方式和参数预编译执行方式两种  
17. */  
18. int main(){      
19.     RETCODE retcode;      
20.     UCHAR   szDSN[sql_MAX_DSN_LENGTH+1]   =   "csql",      
21.             szUID[MAXNAME]   =   "sa",      
22.             szAuthStr[MAXNAME]   =   "";     
23.     //sql语句   
24.         //直接sql语句   
25.     UCHAR   sql[37] = "insert into test values('aaa','100')";   
26.         //预编译sql语句   
27.     UCHAR   pre_sql[29] = "insert into test values(?,?)";   
28.     //1.连接数据源   
29.         //1.环境句柄   
30.     retcode   =   sqlAllocHandle   (sql_HANDLE_ENV,   NULL,   &henv);      
31.     retcode   =   sqlSetEnvAttr(henv,   sql_ATTR_ODBC_VERSION,      
32.                   (sqlPOINTER)sql_OV_ODBC3,      
33.                   sql_IS_INTEGER);      
34.         //2.连接句柄     
35.     retcode   =   sqlAllocHandle(sql_HANDLE_DBC,   henv,   &hdbc1);      
36.     retcode   =   sqlConnect(hdbc1,   szDSN,   4,   szUID,   2,   szAuthStr,   0);       
37.     //判断连接是否成功   
38.     if   (   (retcode   !=   sql_SUCCESS)   &&   (retcode   !=   sql_SUCCESS_WITH_INFO)   )   {        
39.         printf("连接失败!/n");   
40.     }   else   {      
41.         //2.创建并执行一条或多条sql语句   
42.         /*  
43.         1.分配一个语句句柄(statement handle)  
44.         2.创建sql语句  
45.         3.执行语句  
46.         4.销毁语句  
47.         */  
48.         retcode   =   sqlAllocHandle(sql_HANDLE_STMT,   hdbc1,   &hstmt1);      
49.         //第一种方式   
50.         //直接执行   
51.         //添加操作   
52.         //sqlExecDirect (hstmt1,sql,37);   
53.            
54.         //第二种方式   
55.         //绑定参数方式   
56.         char a[200]="bbb";   
57.         char b[200]="200";   
58.         sqlINTEGER   p   =   sql_NTS;   
59.         //1预编译   
60.         sqlPrepare(hstmt1,pre_sql,29); //第三个参数与数组大小相同，而不是数据库列相同   
61.         //2绑定参数值   
62.         sqlBindParameter(hstmt1,1,sql_ParaM_INPUT,sql_C_CHAR,sql_CHAR,200,&a,&p);   
63.         sqlBindParameter(hstmt1,2,&b,&p);   
64.         //3 执行   
65.         sqlExecute(hstmt1);   
66.            
67.         printf("操作成功!");   
68.         //释放语句句柄   
69.         sqlCloseCursor (hstmt1);   
70.         sqlFreeHandle (sql_HANDLE_STMT, hstmt1);   
71.        
72.     }      
73.     //3.断开数据源   
74.     /*  
75.      1.断开与数据源的连接.  
76.      2.释放连接句柄.  
77.      3.释放环境句柄 (如果不再需要在这个环境中作更多连接)  
78.     */  
79.     sqldisconnect(hdbc1);       
80.     sqlFreeHandle(sql_HANDLE_DBC, hdbc1);      
81.     sqlFreeHandle(sql_HANDLE_ENV, henv);      
82.     return(0);      
83. }     

#include <stdio.h>   
#include <string.h>   
#include <windows.h>   
#include <sql.h>   
#include <sqlext.h>   
#include <sqltypes.h>   
#include <odbcss.h>   

sqlHENV henv = sql_NULL_HENV;   
sqlHDBC hdbc1 = sql_NULL_HDBC;   
sqlHSTMT hstmt1 = sql_NULL_HSTMT;   

/*
	cpp文件功能说明：
	1.数据库操作中的添加，修改，删除，主要体现在sql语句上
	2.采用直接执行方式和参数预编译执行方式两种
*/
int main(){   
	RETCODE retcode;   
	UCHAR	szDSN[sql_MAX_DSN_LENGTH+1]   =   "csql",szUID[MAXNAME]   =   "sa",szAuthStr[MAXNAME]   =   "";  
	//sql语句
		//直接sql语句
	UCHAR	sql[37] = "insert into test values('aaa','100')";
		//预编译sql语句
	UCHAR	pre_sql[29] = "insert into test values(?,?)";
	//1.连接数据源
		//1.环境句柄
	retcode   =   sqlAllocHandle   (sql_HANDLE_ENV,NULL,&henv);   
	retcode   =   sqlSetEnvAttr(henv,sql_ATTR_ODBC_VERSION,(sqlPOINTER)sql_OV_ODBC3,sql_IS_INTEGER);   
		//2.连接句柄  
	retcode   =   sqlAllocHandle(sql_HANDLE_DBC,henv,&hdbc1);   
	retcode   =   sqlConnect(hdbc1,szDSN,4,szUID,szAuthStr,0);    
	//判断连接是否成功
	if   (   (retcode   !=   sql_SUCCESS)   &&   (retcode   !=   sql_SUCCESS_WITH_INFO)   )   {     
		printf("连接失败!/n");
	}   else   {   
		//2.创建并执行一条或多条sql语句
		/*
		1.分配一个语句句柄(statement handle)
		2.创建sql语句
		3.执行语句
		4.销毁语句
		*/
		retcode   =   sqlAllocHandle(sql_HANDLE_STMT,hdbc1,&hstmt1);   
		//第一种方式
		//直接执行
		//添加操作
		//sqlExecDirect (hstmt1,37);
		
		//第二种方式
		//绑定参数方式
		char a[200]="bbb";
		char b[200]="200";
		sqlINTEGER   p   =   sql_NTS;
		//1预编译
		sqlPrepare(hstmt1,29); //第三个参数与数组大小相同，而不是数据库列相同
		//2绑定参数值
		sqlBindParameter(hstmt1,&p);
		sqlBindParameter(hstmt1,&p);
		//3 执行
		sqlExecute(hstmt1);
		
		printf("操作成功!");
		//释放语句句柄
		sqlCloseCursor (hstmt1);
		sqlFreeHandle (sql_HANDLE_STMT,hstmt1);
	
	}   
	//3.断开数据源
	/*
     1.断开与数据源的连接.
	 2.释放连接句柄.
	 3.释放环境句柄 (如果不再需要在这个环境中作更多连接)
    */
	sqldisconnect(hdbc1);    
	sqlFreeHandle(sql_HANDLE_DBC,hdbc1);   
	sqlFreeHandle(sql_HANDLE_ENV,henv);   
	return(0);   
}   

 

//##########################list.cpp##########################

C代码

1. #include <stdio.h>      
2. #include <string.h>      
3. #include <windows.h>      
4. #include <sql.h>      
5. #include <sqlext.h>      
6. #include <sqltypes.h>      
7. #include <odbcss.h>      
8.   
9. sqlHENV henv = sql_NULL_HENV;      
10. sqlHDBC hdbc1 = sql_NULL_HDBC;      
11. sqlHSTMT hstmt1 = sql_NULL_HSTMT;      
12.   
13. /*  
14.     查询sqlSERVER数据库,1.条件查询,2.直接查询全部  
15. */  
16. int main(){      
17.     RETCODE retcode;      
18.     UCHAR   szDSN[sql_MAX_DSN_LENGTH+1]   =   "csql",      
19.             szAuthStr[MAXNAME]   =   "";     
20.     UCHAR   sql1[39] = "select b from test where a = 'aaa'";   
21.     UCHAR   sql2[35] = "select b from test where a = ? ";   
22.     UCHAR   sql3[19] = "select b from test";   
23.        
24.     retcode   =   sqlAllocHandle   (sql_HANDLE_ENV,      
25.                   sql_IS_INTEGER);       
26.     retcode   =   sqlAllocHandle(sql_HANDLE_DBC,   &hdbc1);      
27.     //1.连接数据源   
28.     retcode   =   sqlConnect(hdbc1,   0);       
29.     if   (   (retcode   !=   sql_SUCCESS)   &&   (retcode   !=   sql_SUCCESS_WITH_INFO)   )   {      
30.         printf("连接失败!");   
31.     }   else   {      
32.         //2.创建并执行一条或多条sql语句   
33.         /*  
34.         1.分配一个语句句柄(statement handle)  
35.         2.创建sql语句  
36.         3.执行语句  
37.         4.销毁语句  
38.         */  
39.         retcode   =   sqlAllocHandle(sql_HANDLE_STMT,   &hstmt1);      
40.         //第一种方式   
41.         /*  
42.         //直接执行  
43.         sqlExecDirect (hstmt1,sql1,39);  
44.         char list[5];  
45.         sqlBindCol(hstmt1, 1, sql_C_CHAR, list, 5, 0);  
46.         sqlFetch(hstmt1);  
47.         printf("%s/n",list);  
48.         */  
49.            
50.         //第二种方式   
51.         /*  
52.         //绑定参数方式  
53.         char a[200]="aaa";  
54.         sqlINTEGER   p   =   sql_NTS;  
55.         //1.预编译  
56.         sqlPrepare(hstmt1,sql2,35); //第三个参数与数组大小相同，而不是数据库列相同  
57.         //2.绑定参数值  
58.         sqlBindParameter(hstmt1,&p);  
59.         //3.执行  
60.         sqlExecute(hstmt1);  
61.         char list[5];  
62.         sqlBindCol(hstmt1,list);  
63.         */  
64.   
65.         //第三种方式全部输出   
66.         /*  
67.         1.确认一个结果集是否可用。  
68.         2.将结果集的列绑定在适当的变量上。  
69.         3.取得行  
70.         */  
71.         //3.检查结果记录(如果有的话)   
72.         sqlExecDirect (hstmt1,sql3,19);   
73.         char list[5];   
74.         sqlBindCol(hstmt1, 0);   
75.         do{   
76.             retcode = sqlFetch(hstmt1);   
77.             if(retcode == sql_NO_DATA){   
78.                 break;   
79.             }   
80.             printf("%s/n",list);   
81.         }while(1);   
82.            
83.         //释放语句句柄   
84.         sqlCloseCursor (hstmt1);   
85.         sqlFreeHandle (sql_HANDLE_STMT, hstmt1);   
86.        
87.     }      
88.     
89.     //4.断开数据源   
90.     /*  
91.      1.断开与数据源的连接.  
92.      2.释放连接句柄.  
93.      3.释放环境句柄 (如果不再需要在这个环境中作更多连接)  
94.     */  
95.     sqldisconnect(hdbc1);       
96.     sqlFreeHandle(sql_HANDLE_DBC, henv);      
97.     return(0);      
98. }    

#include <stdio.h>   
#include <string.h>   
#include <windows.h>   
#include <sql.h>   
#include <sqlext.h>   
#include <sqltypes.h>   
#include <odbcss.h>   

sqlHENV henv = sql_NULL_HENV;   
sqlHDBC hdbc1 = sql_NULL_HDBC;   
sqlHSTMT hstmt1 = sql_NULL_HSTMT;   

/*
	查询sqlSERVER数据库,2.直接查询全部
*/
int main(){   
	RETCODE retcode;   
	UCHAR   szDSN[sql_MAX_DSN_LENGTH+1]   =   "csql",szAuthStr[MAXNAME]   =   "";  
    UCHAR	sql1[39] = "select b from test where a = 'aaa'";
	UCHAR	sql2[35] = "select b from test where a = ? ";
	UCHAR	sql3[19] = "select b from test";
	
	retcode   =   sqlAllocHandle   (sql_HANDLE_ENV,sql_IS_INTEGER);    
	retcode   =   sqlAllocHandle(sql_HANDLE_DBC,&hdbc1);   
	//1.连接数据源
	retcode   =   sqlConnect(hdbc1,0);    
	if   (   (retcode   !=   sql_SUCCESS)   &&   (retcode   !=   sql_SUCCESS_WITH_INFO)   )   {   
		printf("连接失败!");
	}   else   {   
		//2.创建并执行一条或多条sql语句
		/*
		1.分配一个语句句柄(statement handle)
		2.创建sql语句
		3.执行语句
		4.销毁语句
		*/
		retcode   =   sqlAllocHandle(sql_HANDLE_STMT,&hstmt1);   
		//第一种方式
		/*
		//直接执行
		sqlExecDirect (hstmt1,39);
		char list[5];
		sqlBindCol(hstmt1,list,5,0);
		sqlFetch(hstmt1);
		printf("%s/n",list);
		*/
		
		//第二种方式
		/*
		//绑定参数方式
		char a[200]="aaa";
		sqlINTEGER   p   =   sql_NTS;
		//1.预编译
		sqlPrepare(hstmt1,35); //第三个参数与数组大小相同，而不是数据库列相同
		//2.绑定参数值
		sqlBindParameter(hstmt1,&p);
		//3.执行
		sqlExecute(hstmt1);
		char list[5];
		sqlBindCol(hstmt1,list);
		*/

		//第三种方式全部输出
		/*
		1.确认一个结果集是否可用。
		2.将结果集的列绑定在适当的变量上。
		3.取得行
		*/
		//3.检查结果记录(如果有的话)
		sqlExecDirect (hstmt1,19);
		char list[5];
		sqlBindCol(hstmt1,0);
		do{
			retcode = sqlFetch(hstmt1);
			if(retcode == sql_NO_DATA){
				break;
			}
			printf("%s/n",list);
		}while(1);
		
		//释放语句句柄
		sqlCloseCursor (hstmt1);
		sqlFreeHandle (sql_HANDLE_STMT,hstmt1);
	
	}   
 
	//4.断开数据源
	/*
     1.断开与数据源的连接.
	 2.释放连接句柄.
	 3.释放环境句柄 (如果不再需要在这个环境中作更多连接)
    */
	sqldisconnect(hdbc1);    
	sqlFreeHandle(sql_HANDLE_DBC,henv);   
	return(0);   
}  

 

3.总结：ODBC数据库操作与JDBC步骤上类似，可以融汇贯通来学习

本文来自于http://simpledev.javaeye.com/blog/339537