多列转为一列的SQL语句查询并对获取数据解析

项目开发中，需要从数据库查询数据，在不使用数据库库函数的情况下对获取的数据解析，
这时就可以对查询的SQL语句操作，使其要查询的每一项通过连接符连接在一起成为一项查询，
这时通过查询获取的数据就是一列的数据--一个字符串，再对字符串操作获取对应的每一项数据。
在编程实现中，可以把对SQL语句的操作看着是对字符串的操作，获取的结果也是看做字符串解析。
下面是简单实现，
环境：linux，oracle数据库，OCILIB库

点击(此处)折叠或打开

1. 代码实现：
   
2. 
   
3. /*存放每一行数据的结构体*/
   
4. typedef struct _resultdata
   
5. {
   
6.     int num;
   
7.     int row_len;
   
8.     SB1 *row_data;
   
9.     struct _resultdata *next;
   
10. }ResultData;
    
11. 
    
12. /***********************************************************
    
13.  *function:rs_link_insert
    
14.  *description:
    
15.  * 查询数据链表插入，将新的查询数据放进链表中
    
16.  *input: head:链表头
    
17.  * pi: 将要插进的新结点
    
18.  *
    
19.  *output: ResultData * ：返回ResultData *指针，一般是链表
    
20.  *头结点
    
21.  * ********************************************************/
    
22.  ResultData *rs_link_insert(ResultData *head,ResultData *pi)
    
23. {
    
24.     ResultData *pb = NULL;
    
25. 
    
26.     pb = head;
    
27.     //链表为空时，创建链表
    
28.     if(NULL == pb)
    
29.     {
    
30.         pb = pi;
    
31.         pi->next = NULL;
    
32.         head = pb;
    
33.         
    
34.         //rs_tail = pi;
    
35.         return head;
    
36.     }
    
37.     //不为空时，找到尾结点，并判断是否为空，为空将新结点
    
38.     //插入当前尾结点后
    
39.     //然后将新节点作为尾结点
    
40.     while(pb->next)
    
41.     {
    
42.         //pf = pb;
    
43.         pb = pb->next;
    
44.     }
    
45.     pb->next = pi;
    
46.     pi->next = NULL;
    
47.     return head;
    
48.     
    
49. }
    
50. 
    
51. /***********************************
    
52.  *function: sql_format_deal
    
53.  *description:
    
54.  * 将源字符串中’,‘替换为“||chr(1)||”
    
55.  *input: source：源字符串
    
56.  * search：格式化后的字符串
    
57.  *
    
58.  *output: 列值
    
59.  * ********************************/
    
60.  int sql_format_deal(char* csource_ext,char *cresult)
    
61. {
    
62.     int iwork_bgn = 0;//单词标示
    
63.     int ibracket = 0;//括号标志
    
64.     int icol_cnt = 1;//列值
    
65.     char *csource = (char *)malloc(strlen(csource_ext) + 64);
    
66.     char *csrc = csource;
    
67.     char *cres = cresult;
    
68. 
    
69.     strcpy(csource, csource_ext);
    
70.     for(iwork_bgn=1,ibracket=0;*csrc;csrc++)
    
71.     {
    
72.         //如果到了from处，则不再替换
    
73.         if((!strncasecmp(csrc,"from",4))&&iwork_bgn)
    
74.         {
    
75.             if(csrc[4]==0 || strchr(" \t\r\n",csrc[4]))
    
76.             {
    
77.                 break;
    
78.             }
    
79.         }
    
80. 
    
81.         //将csrc中‘,’替换为“||chr(1)||”,注：括号内不处理
    
82.         if(!ibracket && *csrc == ',')
    
83.         {
    
84.             // 一个逗号则替换为||chr(1)||，两个逗号作为一个逗号（说明要单作为1列处理）
    
85.             if(csrc[1]==',')
    
86.             {
    
87.                 // 保存当前逗号，跳过pi[1]的逗号
    
88.                 *cres++ = *csrc++;
    
89.                 icol_cnt++;
    
90.             }
    
91.             else
    
92.             {
    
93.                 //strcpy(cres,"||chr(1)||");
    
94.                 strcpy(cres,"||chr(1)||");
    
95.                 cres += strlen(cres);//是"||chr(1)||"的长度
    
96.             }
    
97.         }
    
98.         else
    
99.         {
    
100.             *cres++ = *csrc;
     
101. 
     
102.             // 判断是否一个词的开始
     
103.             iwork_bgn = strchr(" \t\r\n",*csrc)?1:0;
     
104.             // 判断是否在括号内
     
105.             if('(' == *csrc)
     
106.             {
     
107.                 ibracket++;
     
108. 
     
109.             }
     
110.             if(')' == *csrc)
     
111.             {
     
112.                 ibracket--;
     
113.             }
     
114.         }
     
115. 
     
116. 
     
117.     }
     
118.     // from后面的内容全部拷贝
     
119.     for(;*csrc;csrc++)
     
120.     {
     
121.         *cres++ = *csrc;
     
122.     }
     
123. 
     
124.     *cres = '\0';
     
125. 
     
126.     FZS_FREE(csource);
     
127.     return icol_cnt;
     
128. }
     
129. /***********************************
     
130.  *function: db_select_data
     
131.  *description:
     
132.  * 查询SQL语句，获得查询数据，将数据存放在rs_data内
     
133.  *
     
134.  *
     
135.  *input: CN:数据路连接对象
     
136.  * SQL：SQL执行语句
     
137.  * *row_num：查询数据行数
     
138.  * rs_data：存放查询后的数据`
     
139.  *
     
140.  *output: >=0:sucess <0:fail
     
141.  *注意：开辟了rs_data及rs_link链表内存空间
     
142.  * 同时释放了sele_data及se_link链表内存空间
     
143.  * rs_data及rs_link内存空间由函数
     
144.  * db_get_le_data释放
     
145.  *
     
146.  * 开辟了format_sql空间，并在用完后释放
     
147.  * ********************************/
     
148.  int db_select_data(OCI_Connection *cn, char* sql,int *row_num,ResultData **rs_data)
     
149. {
     
150.     OCI_Statement *st = NULL;
     
151.     OCI_Resultset *rs = NULL;
     
152.     int icolmn_cnt = 0;
     
153.     int icnt = 0;
     
154.     ResultData *pb_data = NULL;
     
155. 
     
156.     ResultData *rs_head = NULL;
     
157.     ResultData *rs_node = NULL;
     
158.     int isql_len = 0;
     
159.     SB1 *format_sql = NULL;
     
160.     SB1 *ptemp = NULL;
     
161.     SB1 *p1temp = NULL;
     
162.     SB1 buf_data[MAX_ROW_LENGTH];
     
163.     SB1 *pbuf_data = NULL;
     
164.     int itemp1 = 0;
     
165.     //char *ptmp = 0;
     
166.     
     
167.     //对SQL语句断言
     
168.     assert(sql);
     
169.     //判断数据库连接对象是否为空
     
170.     if(NULL == cn)
     
171.     {
     
172.         zlog_error(fzs_lib_mod_log,"---no connect to oracle,please check connect");
     
173.         return -1;
     
174.     }
     
175. 
     
176.     pthread_mutex_lock(&mutex_cn);
     
177. 
     
178.     //zlog_error(fzs_lib_mod_log,"cn addr:%p",cn);
     
179.     //通过数据库连接对象获得SQL语句执行对象
     
180.     st = OCI_StatementCreate(cn);
     
181.     if(NULL == st)
     
182.     {
     
183.         //printf("file:%s---line:%d---OCI_StatementCreate---fail\r\n",POS_INFO);
     
184.         zlog_error(fzs_lib_mod_log,"---OCI_StatementCreate---fail");
     
185.         OCI_err_handler(OCI_GetLastError());
     
186. 
     
187.         pthread_mutex_unlock(&mutex_cn);
     
188.         return -1;
     
189.     }
     
190. 
     
191.     //sql格式化后的结构
     
192.     isql_len = strlen(sql)+1024;
     
193.     //分配内存空间
     
194.     format_sql = (SB1*)FZS_MALLOC(isql_len);
     
195.     memset(format_sql,0,isql_len);
     
196. 
     
197.     //格式化SQL语句
     
198.     icolmn_cnt = sql_format_deal(sql,format_sql);//多列的话目前没有处理
     
199. 
     
200.     //printf("file:%s---line:%d-format_sql=%s\r\n",POS_INFO,format_sql);
     
201.     zlog_debug(fzs_lib_mod_log,"-format_sql=%s",format_sql);
     
202.     //printf("file:%s---line:%d-icolmn_cnt=%d\r\n",POS_INFO,icolmn_cnt);
     
203.     zlog_debug(fzs_lib_mod_log,"-icolmn_cnt=%d",icolmn_cnt);
     
204. 
     
205.     //执行SQL语句
     
206.     if(!OCI_ExecuteStmt(st,format_sql))// format_sql 是格式化后的语句
     
207.     {
     
208.         zlog_error(fzs_lib_mod_log,"-OCI_ExecuteStmt---fail");
     
209.         OCI_err_handler(OCI_GetLastError());
     
210. 
     
211.         pthread_mutex_unlock(&mutex_cn);
     
212.         return -1;
     
213.     }
     
214.     
     
215.     //获取结果集对象
     
216.     zlog_debug(fzs_lib_mod_log,"-OCI_ExecuteStmt---OK!!!");
     
217.     rs = OCI_GetResultset(st);
     
218.     if(NULL == rs)
     
219.     {
     
220.         zlog_error(fzs_lib_mod_log,"OCI_ExecuteStmt---fail");
     
221.         OCI_err_handler(OCI_GetLastError());
     
222. 
     
223.         pthread_mutex_unlock(&mutex_cn);
     
224.         return -1;
     
225.     }
     
226. 
     
227.     //对rs结果集中的数据处理,将rs数据存到rs_link中，并获得每行数据长度
     
228.     while(OCI_FetchNext(rs))
     
229.     {
     
230.      icnt++;
     
231.         //每次获得数据前，清空buf内数据
     
232.         //printf("%s\n",OCI_GetString(rs,1));
     
233.         memset(buf_data,0,MAX_ROW_LENGTH);
     
234. 
     
235.         pbuf_data = buf_data;
     
236.         for(itemp1 = 0; itemp1 < icolmn_cnt; itemp1++)
     
237.         {
     
238.             pbuf_data += strlen(pbuf_data);
     
239.             if(itemp1 > 0)
     
240.                 *pbuf_data++ = 0x01;
     
241. 
     
242.          sprintf(pbuf_data, OCI_GetString(rs, itemp1 + 1));
     
243.         }
     
244. 
     
245.         //printf("file:%s--line:%d--buf_data=%s\r\n",POS_INFO,buf_data);
     
246.         zlog_debug(fzs_lib_mod_log,"--buf_data=%s",buf_data);
     
247.         //irow_len = strlen(buf_data)+1;
     
248.         //printf("file:%s--line:%d--*len=%d\r\n",POS_INFO,*len);
     
249.         //zlog_debug(fzs_lib_mod_log,"*len=%d",*len);
     
250.         //给pb_data分配内存空间
     
251.         pb_data = (ResultData*)malloc(sizeof(ResultData));
     
252.         
     
253.         //分配内存失败
     
254.         if(pb_data == NULL)
     
255.         {
     
256.         
     
257.             //printf("SelectData--pb_data malloc memory fail\r\n");
     
258.          zlog_error(fzs_lib_mod_log,"OCI_ExecuteStmt---fail");
     
259.          //释放返回集
     
260.             if(rs)
     
261.             {
     
262.                 OCI_ReleaseResultsets(st);
     
263.                 //printf("file:%s--line:%d--OCI_ReleaseResultsets(st) success\r\n",POS_INFO);
     
264.             }
     
265. 
     
266.             //清除声明
     
267.             if(st)
     
268.             {
     
269.                 OCI_StatementFree(st);
     
270.                 //printf("file:%s--line:%d--OCI_StatementFree(st) success\r\n",POS_INFO);
     
271.             }
     
272. 
     
273.             pthread_mutex_unlock(&mutex_cn);
     
274.             return -1;
     
275.         }
     
276. 
     
277.         pb_data->row_data = (SB1*)malloc((strlen(buf_data)+1));
     
278.         
     
279.         //分配内存失败
     
280.         if(pb_data->row_data == NULL)
     
281.         {
     
282.             //printf("SelectData--pb_data->row_data malloc memory fail\r\n");
     
283.             zlog_error(fzs_lib_mod_log,"SelectData--pb_data->row_data malloc memory fail");
     
284.             free(pb_data);
     
285.             //释放返回集
     
286.             if(rs)
     
287.             {
     
288.                 OCI_ReleaseResultsets(st);
     
289.                 //printf("file:%s--line:%d--OCI_ReleaseResultsets(st) success\r\n",POS_INFO);
     
290.             }
     
291. 
     
292.             //清除声明
     
293.             if(st)
     
294.             {
     
295.                 OCI_StatementFree(st);
     
296.                 //printf("file:%s--line:%d--OCI_StatementFree(st) success\r\n",POS_INFO);
     
297.             }
     
298. 
     
299.             pthread_mutex_unlock(&mutex_cn);
     
300.             return -1;
     
301.         }
     
302. 
     
303.         pb_data->num = icnt;
     
304.         pb_data->row_len = strlen(buf_data)+1;
     
305.         //数据全部Copy过来，不是地址赋值过来
     
306.         memcpy(pb_data->row_data,buf_data,strlen(buf_data)+1);//sizeof(rs)==4,forever
     
307.         pb_data->row_data[strlen(buf_data)] = '\0';
     
308.         //将每一行数据作为一个结点存放在链表中
     
309.         //printf("file:%s--line:%d--pb_data->row_data=%s\r\n",POS_INFO,pb_data->row_data);
     
310.         zlog_debug(fzs_lib_mod_log,"--pb_data->row_data=%s",pb_data->row_data);
     
311.         rs_head = rs_link_insert(rs_head,pb_data);
     
312.     }
     
313. 
     
314.     //总行数
     
315.     *row_num = icnt;
     
316. 
     
317.     *rs_data = rs_head;
     
318.     //将rs_head指向空指针
     
319.     rs_head = NULL;
     
320.         
     
321.     //rs_link_print(*rs_data);
     
322.  
     
323.     //将每行数据内的0x1替换为0x0
     
324.     for(rs_node=*rs_data;rs_node;rs_node=rs_node->next)
     
325.     {
     
326.         for(ptemp = rs_node->row_data,p1temp = ptemp+rs_node->row_len;ptemp < p1temp;ptemp++)
     
327.         {
     
328.             
     
329.             if(1 == *ptemp)
     
330.             {
     
331.                // printf("file:%s--line:%d--p=%c\r\n",POS_INFO,*p);
     
332.               // zlog_debug(fzs_lib_mod_log,"--p=%c",*p);
     
333.                 *ptemp = 0;
     
334.                // printf("file:%s--line:%d--p=%c\r\n",POS_INFO,*p);
     
335.               // zlog_debug(fzs_lib_mod_log,"--p=%c",*p);
     
336.             }
     
337.         }
     
338. 
     
339.         //printf("file:%s--line:%d--rs_node->row_data=%s\r\n",POS_INFO,rs_node->row_data);
     
340.         zlog_debug(fzs_lib_mod_log,"--rs_node->row_data=%s",rs_node->row_data);
     
341.     }
     
342. 
     
343.     //rs_link_print(*rs_data);
     
344.     //释放format_sql内存空间
     
345.     free(format_sql);
     
346. 
     
347.     //释放返回集
     
348.     if(rs)
     
349.     {
     
350.         OCI_ReleaseResultsets(st);
     
351.         //printf("file:%s--line:%d--OCI_ReleaseResultsets(st) success\r\n",POS_INFO);
     
352.     }
     
353.     //清除声明
     
354.     if(st)
     
355.     {
     
356.         OCI_StatementFree(st);
     
357.         //printf("file:%s--line:%d--OCI_StatementFree(st) success\r\n",POS_INFO);
     
358.     }
     
359. 
     
360.     #ifdef SWITCH_LOG
     
361.     if(1 == db_en_chs_flag)
     
362.     {
     
363.         zlog_info(fzs_lib_mod_log,"当前数据库查询花费时间%lu us",(end1_temp-st1_temp));
     
364.     }
     
365.     else
     
366.     {
     
367.         zlog_info(fzs_lib_mod_log,"The current database query cost time:%lu us",(end1_temp-st1_temp));
     
368.     }
     
369.     #endif
     
370. 
     
371.     pthread_mutex_unlock(&mutex_cn);
     
372.     return 0;
     
373.         
     
374. }
     
375. 
     
376. 本代码实现中，没有实现主函数，实现了具体处理SQL语句及对获取的数据处理（没有解析出针对每一列），是作为通用函数处理的。

总结：
1，在对oracle数据库开发中，使用oracle公司开发的OCILIB库开发，相比oci更简单，具体OCILIB库的好处和实现demo请查阅OCILIB库说明；
2，在不使用OCILIB库函数解析从数据库获取的数据时，可以把SQL语句当着字符串处理，通过连接符使多列转为一列SQL语句，这样查询获取的数据也是一列；
3，对OCILIB库函数也要使用得当，掌握基本使用函数和使用技巧。