Chinaunix首页 | 论坛 | 博客

魂之火

首页　| 　博文目录　| 　关于我

lidongwei26

  • 博客访问： 61678
  • 博文数量： 24
  • 博客积分： 0
  • 博客等级： 民兵
  • 技术积分： 215
  • 用 户 组： 普通用户
  • 注册时间： 2015-02-10 09:58
个人简介

专业提供linux应用软件开发、oracle数据库底层开发，服务器开发及相关技术支持服务

文章分类

全部博文（24）

文章存档

2015年（24）

我的朋友
最近访客
推荐博文
相关博文
多列转为一列的SQL语句查询并对获取数据解析

分类： 数据库开发技术

2015-02-28 10:20:46

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


点击(此处)折叠或打开

  1. 代码实现：

  3. /*存放每一行数据的结构体*/
  4. typedef struct _resultdata
  5. {
  6.     int num;
  7.     int row_len;
  8.     SB1 *row_data;
  9.     struct _resultdata *next;
  10. }ResultData;

  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;

  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. }

  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;

  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.         }

  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;

  102.             // 判断是否一个词的开始
  103.             iwork_bgn = strchr(" \t\r\n",*csrc)?1:0;
  104.             // 判断是否在括号内
  105.             if('(' == *csrc)
  106.             {
  107.                 ibracket++;

  109.             }
  110.             if(')' == *csrc)
  111.             {
  112.                 ibracket--;
  113.             }
  114.         }


  117.     }
  118.     // from后面的内容全部拷贝
  119.     for(;*csrc;csrc++)
  120.     {
  121.         *cres++ = *csrc;
  122.     }

  124.     *cres = '\0';

  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;

  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.     }

  176.     pthread_mutex_lock(&mutex_cn);

  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());

  187.         pthread_mutex_unlock(&mutex_cn);
  188.         return -1;
  189.     }

  191.     //sql格式化后的结构
  192.     isql_len = strlen(sql)+1024;
  193.     //分配内存空间
  194.     format_sql = (SB1*)FZS_MALLOC(isql_len);
  195.     memset(format_sql,0,isql_len);

  197.     //格式化SQL语句
  198.     icolmn_cnt = sql_format_deal(sql,format_sql);//多列的话目前没有处理

  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);

  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());

  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());

  223.         pthread_mutex_unlock(&mutex_cn);
  224.         return -1;
  225.     }

  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);

  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;

  242.          sprintf(pbuf_data, OCI_GetString(rs, itemp1 + 1));
  243.         }

  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.             }

  266.             //清除声明
  267.             if(st)
  268.             {
  269.                 OCI_StatementFree(st);
  270.                 //printf("file:%s--line:%d--OCI_StatementFree(st) success\r\n",POS_INFO);
  271.             }

  273.             pthread_mutex_unlock(&mutex_cn);
  274.             return -1;
  275.         }

  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.             }

  292.             //清除声明
  293.             if(st)
  294.             {
  295.                 OCI_StatementFree(st);
  296.                 //printf("file:%s--line:%d--OCI_StatementFree(st) success\r\n",POS_INFO);
  297.             }

  299.             pthread_mutex_unlock(&mutex_cn);
  300.             return -1;
  301.         }

  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.     }

  314.     //总行数
  315.     *row_num = icnt;

  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.         }

  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.     }

  343.     //rs_link_print(*rs_data);
  344.     //释放format_sql内存空间
  345.     free(format_sql);

  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.     }

  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

  371.     pthread_mutex_unlock(&mutex_cn);
  372.     return 0;
  373.         
  374. }

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

阅读(1027) | 评论(0) | 转发(0) |
0

上一篇：oracle redo log 内容概述

下一篇：Memcache知识点梳理

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6