db2 数据转json v0.03

DB2 SQL客户端API详解
最新推荐文章于 2025-07-04 16:34:13 发布
原创 最新推荐文章于 2025-07-04 16:34:13 发布 · 1.5k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#json #db2 #sql #buffer #null #header

本文介绍了一套针对IBM DB2数据库的SQL客户端API，包括客户端句柄的创建与销毁、执行SQL语句（带与不带结果集）、错误处理等功能。通过这些API可以方便地进行数据库连接管理和SQL查询操作。 
#ifndef DB2_CLI_H_
#define DB2_CLI_H_
#ifdef __cplusplus
extern "C"{
#endif
	struct sql_client_information_tag;
	typedef struct sql_client_information_tag* sql_client_handle;
	/**
	 *  函数:   create_sql_handle
	 *          生成一个sql查询客户端句柄
	 *  参数: 
	 *          const char * const db_name  数据库名称
	 *          const char * const u_name   数据库用户名
	 *          const char * const u_pass   数据库密码	 
	 *  返回值:
	 *          NULL 创建失败
	 *          其他 创建成功
	 *  版本号：1.0
	 */
	sql_client_handle create_sql_handle(const char*const db_name,const char*const u_name,const char*const u_pass);
	/**
	 *  函数:   sql_excute_no_result
	            执行一个没有返回值的sql语句，比如表创建，表插入，表删除等动作
	 *  参数: 
	 *          sql_client_handle h   sql查询客户端句柄
	 *          const char * const sql_statement sql语句 
	 *  返回值:
	 *          0   执行成功
	 *			非0 执行失败
	 *  版本号：1.0
	 */
	int sql_excute_no_result(sql_client_handle h, const char*const sql_statement);
	/**
	 *  函数:   sql_excute_with_result
	 *          执行一个有返回值的sql语句，比如select操作
	 *  参数: 
	 *          sql_client_handle h  sql查询客户端句柄
	 *          const char*const sql_statment  sql查询语句
	 *          char * const result  sql查询结果缓存
	 *          int *len			 [in]sql查询结果缓存大小
	 *								 [out]查询结果的json字符流大小
	 *  返回值:
	 *         0  执行成功
	 *		   非0 执行失败
	 *  版本号：1.0
	 *
	 */
	int sql_excute_with_result(sql_client_handle h ,const char*const sql_statment,char*const result,int *len);
	/**
	 *  函数:   destroy_sql_handle
	 *          关闭sql查询句柄
	 *  参数: 
	 *          sql_client_handle h sql查询句柄 
	 *  返回值:
	 *          无
	 *  版本号：1.0
	 *
	 */
	void destroy_sql_handle(sql_client_handle h);
#ifdef __cplusplus
};
#endif
#endif //DB2_CLI_H_

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <memory.h>
#include <sqlcli1.h>
#include <db2_cli.h>
#ifndef _countof
#define _countof(x) (sizeof(x)/sizeof(x[0]))
#endif
#define hints printf
#define errors printf
#define SQL_STATE_LEN 256
#define SQL_ERROR_MSG 256
#define SQL_DBNAME_LEN 256 
#define SQL_USER_NAME_LEN 64
#define SQL_USER_PASS_LEN 64
#define SQL_STATEMENT_LEN 1024


typedef struct  sql_client_information_tag
{
	SQLHENV env_handle;
	SQLHDBC dbc_handle;
}sql_client_information;

typedef int (*fetch_row)(sql_client_handle h,SQLHSTMT stmt,char* buffer,int* len);
typedef struct sql_fetch_row_info_tag
{
	char* buffer;
	int*  length;
	fetch_row fetch;
}sql_fetch_row_info,*sql_fetch_row_handle;

static int fetch_sql(sql_client_handle h,SQLHSTMT stmt,char* buffer,int *len);
static void sql_error(sql_client_handle h,SQLHSTMT stm_handle);
static int clean_statement(sql_client_handle h,SQLHSTMT stmt,SQLRETURN frc);
static int sql_excute(sql_client_handle h,const char*const sql,sql_fetch_row_handle fh);
void destroy_sql_handle(sql_client_handle h);



sql_client_handle create_sql_handle(const char*const db_name,const char*const u_name,const char*const u_pass){
	SQLCHAR DBName[SQL_MAX_DSN_LENGTH + 1] = {0};
	SQLCHAR USRName[SQL_USER_NAME_LEN] = {0};
	SQLCHAR USRPass[SQL_USER_PASS_LEN] = {0};
	sql_client_handle ret = malloc(sizeof(sql_client_information));
	if(NULL == ret){
		return NULL;
	}
	memset(ret , 0 , sizeof(sql_client_information));
	do {
		SQLRETURN  rc = SQLAllocEnv(&ret->env_handle);
		if(rc != SQL_SUCCESS) break;
		rc = SQLAllocConnect(ret->env_handle,&ret->dbc_handle);
		if(rc != SQL_SUCCESS) break;
		strncpy((char*)DBName,db_name,sizeof(DBName) - 1);
		strncpy((char*)USRName,u_name,sizeof(USRName) - 1);
		strncpy((char*)USRPass,u_pass,sizeof(USRPass) - 1);
		rc = SQLConnect(ret->dbc_handle,DBName,SQL_NTS,USRName,SQL_NTS,USRPass,SQL_NTS);
		if(rc != SQL_SUCCESS) break;
		return ret;
	} while (0);
	sql_error(ret,SQL_NULL_HSTMT);
	destroy_sql_handle(ret);
	return NULL;	
}

void destroy_sql_handle(sql_client_handle h){
	do 
	{
		if(SQL_NULL_HDBC != h->dbc_handle){
			if(SQL_SUCCESS != SQLDisconnect(h->dbc_handle)) break;
			if(SQL_SUCCESS != SQLFreeConnect(h->dbc_handle)) break;
			h->dbc_handle = SQL_NULL_HDBC;
		}
		if (SQL_NULL_HENV != h->env_handle)
		{
			if(SQL_SUCCESS != SQLFreeEnv(h->env_handle)) break;
			h->env_handle = SQL_NULL_HENV;
		}
		free(h);
		return;
	} while (0);
	sql_error(h,SQL_NULL_HSTMT);
	free(h);
}

int sql_excute_no_result(sql_client_handle h, const char*const sql_statement){
	return sql_excute(h,sql_statement,NULL);
}


int sql_excute_with_result(sql_client_handle h ,const char*const sql_statment,char*const result,int *len){
	sql_fetch_row_info fetch_row = {result,len,fetch_sql};
	return sql_excute(h,sql_statment,&fetch_row);
}

static void sql_error(sql_client_handle h,SQLHSTMT stm_handle){
	SQLCHAR  sql_state[SQL_SQLSTATE_SIZE + 1] = {0};
	SQLCHAR  sql_error[SQL_MAX_MESSAGE_LENGTH + 1] = {0};
	SQLINTEGER native_error = 0;
	SQLSMALLINT pcb_error = 0;
	SQLRETURN  rc = SQLError(h->env_handle,h->dbc_handle,stm_handle,
		sql_state,&native_error,sql_error,sizeof(sql_error),&pcb_error);
	if(rc == SQL_NO_DATA_FOUND){
		return;
	}
	errors("sql state : %s\n",sql_state);
	errors("sql error : %s\n",sql_error);
}

static int clean_statement(sql_client_handle h,SQLHSTMT stmt,SQLRETURN frc){
	sql_error(h,stmt);
	switch(frc){
	case SQL_SUCCESS: 
	case SQL_SUCCESS_WITH_INFO:break;
	case SQL_ERROR:
	case SQL_INVALID_HANDLE:
	default:
		SQLTransact(h->env_handle,h->dbc_handle,SQL_ROLLBACK);
		return frc;
	}
	return SQL_SUCCESS; 
}


static int sql_excute(sql_client_handle h,const char*const sql,sql_fetch_row_handle fh){
	SQLCHAR SQLState[SQL_STATEMENT_LEN] = {0};
	SQLHSTMT stmt = SQL_NULL_HSTMT;
	SQLRETURN rc = SQLAllocStmt(h->dbc_handle,&stmt);
	do 
	{
		if(SQL_SUCCESS != rc) break;
		strncpy((char*)SQLState,sql,sizeof(SQLState) - 1);
		rc = SQLExecDirect(stmt,SQLState,SQL_NTS);
		if(SQL_SUCCESS != rc) break;
		if(NULL != fh){
			if(SQL_SUCCESS != fh->fetch(h,stmt,fh->buffer,fh->length)) break;
		}
		rc = SQLTransact(h->env_handle,h->dbc_handle,SQL_COMMIT);
		if(SQL_SUCCESS != rc) break;
		SQLFreeStmt(stmt,SQL_DROP);
		return 0;
	} while (0);
	if(SQL_NULL_HSTMT != stmt){
		SQLFreeStmt(stmt,SQL_DROP);
		stmt = SQL_NULL_HSTMT;
	}
	return clean_statement(h,stmt,rc);
}





typedef struct record_set_header_tag{
	SQLCHAR Name[SQL_MAX_COLUMN_NAME_LEN];
	SQLUINTEGER Define;
	SQLSMALLINT Type;
	SQLSMALLINT Scale;
	SQLSMALLINT IsNUll;
}record_set_header,*record_set_header_handle;


typedef struct record_set_tag{
	record_set_header headers[SQL_MAX_COLUMNS_IN_TABLE];
	int  col_counts;
	int  row_counts;
	int  buffer_length;
	int  data_size;
	char data_buffer[];
}record_set,*record_set_handle;

#define record_data_buffer(h) (&h->data_buffer[h->data_size])
#define record_data_space(h) (h->buffer_length - h->data_size)


static int fetch_record_set_header(record_set_handle h,SQLHSTMT stmt){
	record_set_header* rs_header = h->headers;
	SQLSMALLINT SQLColCount = 0,NameLen = 0, i = 0;
	SQLRETURN rc = SQLNumResultCols(stmt,&SQLColCount);
	if (SQL_SUCCESS != rc){
		errors("%s: SQLNumResultCols = %d\n",__FUNCTION__,rc);
		return rc;
	}
	for (i = 0 ; i < SQLColCount && i < SQL_MAX_COLUMNS_IN_TABLE; ++i,++rs_header)
	{
		rc = SQLDescribeCol(stmt,i + 1,rs_header->Name,sizeof(rs_header->Name),&NameLen,
			&rs_header->Type,&rs_header->Define,&rs_header->Scale,&rs_header->IsNUll);
		if(SQL_SUCCESS != rc){
			errors("%s : SQLDescribeCol = %d\n",__FUNCTION__,rc);
			return rc;
		}
	}
	h->col_counts = i;
	return SQL_SUCCESS;
}


static int fetch_row_data(record_set_handle h, SQLHSTMT stmt){
	SQLCHAR char_buffer[SQL_MAX_MESSAGE_LENGTH] = {0};
	SQLINTEGER buffer_len = 0;
	int i = 0;
	for(i = 0; i < h->col_counts; ++i){
		SQLRETURN rc = SQLGetData(stmt,i + 1,SQL_CHAR,char_buffer,sizeof(char_buffer),&buffer_len);
		if(SQL_SUCCESS != rc){
			errors("%s : SQLGetData = %d\n",__FUNCTION__,rc);
			return rc;
		}
		if((buffer_len + 4) > record_data_space(h)){
			errors("%s : buffer_len = %d, free_len = %d\n",buffer_len,h->buffer_length);
			break;
		}
		h->data_size += snprintf(record_data_buffer(h),record_data_space(h),"%4d",buffer_len);
		memcpy(record_data_buffer(h),char_buffer,buffer_len);
		h->data_size += buffer_len;
	}
	return SQL_SUCCESS;
}

static int fetch_sql_data(record_set_handle h, SQLHSTMT stmt){
	int ret = 0;
	for (h->row_counts = 0;h->data_size < h->buffer_length;++h->row_counts){
		if(SQL_NO_DATA == SQLFetch(stmt)){
			break;
		}
		ret = fetch_row_data(h,stmt);
		if(ret < 0){
			errors("%s : ret = %d",__FUNCTION__,ret);
			return ret;
		}
	}
	return SQL_SUCCESS;
}

void destroy_record_set(record_set_handle h){
	free(h);
}

record_set_handle create_record_set(SQLHSTMT stmt,int buffer_size){
	record_set_handle ret = malloc(sizeof(record_set) + buffer_size);
	if (NULL == ret || SQL_NULL_HSTMT == stmt){
		return NULL;
	}
	memset(ret , 0 , sizeof(record_set) + buffer_size);
	ret->buffer_length = buffer_size;
	do 
	{
		if (SQL_SUCCESS != fetch_record_set_header(ret,stmt)) break;
		if (SQL_SUCCESS != fetch_sql_data(ret,stmt)) break;
		return ret;
	}while(0);
	destroy_record_set(ret);
	return NULL;
}







typedef struct json_convertor_tag{
	const char* data_buffer;
	char* json_buffer;
	int buffer_length;
	int json_size;
	int data_offset;
}json_convertor,*json_convertor_handle;

#define item_len_lable 4
#define header_size (SQL_MAX_COLUMN_NAME_LEN + 4)
#define data_sapce(h) (h->data_buffer + h->data_offset)
#define json_space(h) (h->json_buffer + h->json_size)
#define space_leng(h) ((h->buffer_length  > h->json_size) ? (h->buffer_length - h->json_size) : 0)

static int get_item_length(json_convertor_handle h){
	char str_len[item_len_lable + 1] = {0};
	int offset = 0;
	strncpy(str_len,data_sapce(h),item_len_lable);
	offset = atoi(str_len);
	if ((offset + h->json_size + header_size) > h->buffer_length){
		errors("json buffer not space : offset = %d,buffer_length = %d,json_size = %d\n",
			offset,h->buffer_length,h->json_size);
		return -1;
	}
	h->data_offset += item_len_lable;
	return offset;
}

static int set_json_number(json_convertor_handle h, const char* item_name){
	int  offset = get_item_length(h);
	if(offset < 0){
		return offset;
	}
	h->json_size += snprintf(json_space(h),space_leng(h),"\"%s\":",item_name);
	if(0 == offset){
		const char*const null_str = "null";
		offset = strlen(null_str);
		strncpy(json_space(h),null_str,offset);
	}else{
		strncpy(json_space(h),data_sapce(h),offset);
		h->data_offset += offset;
	}
	h->json_size += offset;
	h->json_size += snprintf(json_space(h),space_leng(h),",");
	return offset;
}

static int convert_json_string(const char*const src,char* dst,int len){
	const char*const head = dst;
	int i = 0;
	for (i = 0; i < len ; ++i)
	{
		switch(src[i]){
		case '\\':
			{
				*dst++ = '\\';
				*dst++ = '\\';
				break;
			}
		case '"':
			{
				*dst++ = '\\';
				*dst++ = '"';
				break;
			}
		default:
			{
				*dst++ = src[i];
				break;
			}
		}
	}
	return (int)(dst - head);
}

static int set_json_string(json_convertor_handle h,const char* item_name){
	int offset = get_item_length(h);
	if (offset < 0){
		return offset;
	}
	if( 0 == offset){
		h->json_size += snprintf(json_space(h),space_leng(h),"\"%s\":null,",item_name);
		h->data_offset += offset;
		return offset;
	}
	h->json_size += snprintf(json_space(h),space_leng(h),"\"%s\":\"",item_name);
	h->json_size += convert_json_string(data_sapce(h),json_space(h),offset);
	h->json_size += snprintf(json_space(h),space_leng(h),"\",");
	h->data_offset += offset;
	return offset;

}

static int format_row_2_json(json_convertor_handle h,record_set_handle rs){
	int i = 0;
	for(i = 0; i < rs->col_counts; ++i){
		switch(rs->headers[i].Type){
		case SQL_NUMERIC:
		case SQL_DECIMAL:
		case SQL_INTEGER:
		case SQL_SMALLINT:
		case SQL_FLOAT:
		case SQL_REAL:
		case SQL_DOUBLE:
		case SQL_DATETIME:
			{
				set_json_number(h,(const char*)rs->headers[i].Name);
				break;
			}
		default:
			{
				 set_json_string(h,(const char*)rs->headers[i].Name);
				 break;
			}
		}
	}
	return i;
}

static int format_2_json(json_convertor_handle h,const record_set_handle rs){
	int i = 0;
	if( 0 == rs->row_counts){
		h->json_size += snprintf(json_space(h),space_leng(h),"[]");
		return h->json_size;
	}
	h->json_size += snprintf(json_space(h),space_leng(h),"[\n");
	for (i = 0; i < rs->row_counts; ++i){
		h->json_size += snprintf(json_space(h),space_leng(h),"{");
		format_row_2_json(h,rs);
		h->json_size += snprintf(json_space(h) - 1,space_leng(h) + 1,"},\n") - 1;
	}
	h->json_size += snprintf(json_space(h) - 2,space_leng(h) + 2,"\n]") - 2;
	return h->json_size;
}

static int fetch_sql(sql_client_handle h,SQLHSTMT stmt,char* buffer,int *len){
	json_convertor json = {0};
	record_set_handle rsh = create_record_set(stmt,*len);
	if (NULL == rsh){
		return SQL_ERROR;
	}
	json.data_buffer = rsh->data_buffer;
	json.json_buffer = buffer;
	json.buffer_length = *len;
	*len = format_2_json(&json,rsh);
	destroy_record_set(rsh);
	return (*len >= 0) ? SQL_SUCCESS : SQL_ERROR;
}



#ifdef db2_json_test
static char result[1024 * 1024 * 4];
int main(int argc, char* argv[])
{
	char cmd[1024];
	if(argc < 4){
		hints("usage : %s db_name db_user db_pass\n",argv[0]);
		return -1;
	}
	sql_client_handle h = create_sql_handle(argv[1],argv[2],argv[3]);
	if (NULL == h){
		return -1;
	}
	for (gets(cmd);strcmp(cmd,"q") != 0;gets(cmd)){
		int len = sizeof(result);
		int ret = 0;
		memset(result , 0 , sizeof(result));
		hints("cmd = %s\n",cmd);
		ret = sql_excute_with_result(h,cmd,result,&len);
		if(ret < 0) {
			errors("sql_excute_with_result = %d\n",ret);
			break;
		}
		hints("%s : %d\n",result,len);
		hints("next command\n");
	}
	destroy_sql_handle(h);
	return 0;
}
#endif







                

        

    


  



    



                



	

		

			

				
					
玩转DB2之SQL篇：从json格式字段中提取long型日期

				
			

			

				

					
				

				

					07-14
					
					3328
					
				

			

		

		

			
				
从json格式字段中提取long型日期因数据统计的需求，笔者需要编写一条sql，用于在tbl_user_info表中某个json数据格式字段中提取姓名、时间等信息，该字段名为data_json，json数据格式如下：
id－自增编号
name－字符串
createdate－long型时间戳  数据示例：{“id”:12859701,”name”:”小编”,”createdate”:132014009

			
		

	



                

            
              



	

		

			

				
					
一文读懂大数据领域数据架构的底层逻辑

					
最新发布

				
			

			

				

					小程序开发
				

				

					08-17
					
					1407
					
				

			

		

		

			
				
数据架构（Data Architecture）是指对数据资产的组织、存储、处理、流转与使用进行系统性设计的框架。它不是单一的技术或工具，而是一套指导数据全生命周期管理的原则、策略与技术选型的集合。应用架构：关注业务功能的实现（如电商系统、CRM系统）基础设施架构：关注计算、网络、存储等底层资源的管理数据架构：关注数据的产生、存储、流转与价值提取。

			
		

	



              


  
              

                


	

		

			

				
					
db2 数据转json v0.04

				
			

			

				

					FlyAnyWhere的专栏
				

				

					12-28
					
					1866
					
				

			

		

		

			
				
#ifndef DB2_CLI_H_
#define DB2_CLI_H_
#ifdef __cplusplus
extern "C"{
#endif
	struct sql_client_information_tag;
	typedef struct sql_client_information_tag* sql_client_handle;
	/**
	 *  函数:   create_sq

			
		

	





	

		

			

				
					
DB2 NoSQL JSON 功能，第 1 部分: DB2 NoSQL JSON 介绍

				
			

			

				

					敬诚为之
				

				

					10-22
					
					2124
					
				

			

		

		

			
				
Ref: http://www.ibm.com/developerworks/cn/data/library/techarticle/dm-1306nosqlforjson1/index.html
快速变化的应用程序环境需要一种灵活的机制来存储数据，并在不同应用程序层之间传递数据。事实证明，JSON
 (Java™ Script Object Notation) 是一种用于移动、交互式应用程序

			
		

	



		

			
		



	

		

			

				
					
DB2查询结果表拼接JSON字符串

				
			

			

				

					jiahao_1996的博客
				

				

					11-02
					
					1996
					
				

			

		

		

			
				
DB2查询结果表拼接JSON字符串

			
		

	





	

		

			

				
					
db2 数据转json v0.02

				
			

			

				

					FlyAnyWhere的专栏
				

				

					11-11
					
					1323
					
				

			

		

		

			
				
#include 
#include 
#include 
#include 
#include 
#ifndef _countof
#define _countof(x) (sizeof(x)/sizeof(x[0]))
#endif
#define hints printf
#define errors printf
#define SQL_STATE_LEN 256
#define SQL_

			
		

	





	

		

			

				
					
大数据开发之Hive篇-Hive数据定义语言

				
			

			

				

					xinghaoyan的专栏
				

				

					07-04
					
					743
					
				

			

		

		

			
				
Hive数据模型与DDL操作摘要 Hive采用关系型数据模型，包含数据库、表、分区和桶四级结构。数据库提供命名空间，表在HDFS中以目录存储，分区通过物理目录优化查询，桶通过哈希重新组织数据。 Hive DDL主要操作包括： 数据库操作：CREATE/DROP/SHOW等命令管理数据库 表操作：支持管理表/外部表、永久表/临时表，可设置分区和分桶 表维护：ALTER命令可实现重命名、修改属性、增删列、管理分区等功能 关键特性： 外部表删除仅影响元数据 临时表仅会话有效 分区优化查询性能 分桶支持高效连接和抽

			
		

	





	

		

			

				
					
基于 Hadoop 数据仓库的搭建

				
			

			

				

					qu6zhi
				

				

					03-17
					
					1927
					
				

			

		

		

			
				
基于 Hadoop 的数据仓库


			
		

	





	

		

			

				
					
数据简化社区2018年全球数据库总结及18种主流数据库介绍(公号回复“数据库2018”下载典藏版PDF报告)

				
			

			

				

					数据简化DataSimp社区
				

				

					08-16
					
					9968
					
				

			

		

		

			
				
数据简化社区2018年全球数据库总结及18种主流数据库介绍(公号回复“数据库2018”下载典藏版PDF报告)

秦陇纪  数据简化DataSimp  今天

数据简化DataSimp导读：Google搜索量最大的DB-Engines数据库排名，介绍前几名数据库特点、云AI区块链等数据库服务；展望2018年数据库发展趋势，本文合计40k字详读约需36分钟。最近群里说国内可以重新使用谷歌搜索、谷歌学术...

			
		

	





	

		

			

				
					
ecw2c理解元数据：使用BigQuery k-means将4,000个堆栈溢出标签聚类

					
热门推荐

				
			

			

				

					cunehu1722的博客
				

				

					07-24
					
					6万+
					
				

			

		

		

			
				
您如何将超过4,000个活动的Stack Overflow标签分组为有意义的组？ 对于无监督学习和k均值聚类来说，这是一项完美的任务-现在您可以在BigQuery中完成所有这些工作。 让我们找出方法。






Visualizing a universe of clustered tags.





Felipe Hoffais a Developer Advocate fo...

			
		

	





	

		

			

				
					
db2_数据类型_详细解析

				
			

			

				

					05-17
				

			

		

		

			
				
本文讲解了DB2的各种数据类型 希望对你有所帮助

			
		

	





	

		

			

				
					
ibm db2 58009_IBM DB2 for i：JSON存储技术预览

				
			

			

				

					cusi77914的博客
				

				

					06-29
					
					2585
					
				

			

		

		

			
				
最新的DB2程序临时修订（PTF）组（用于7.1的SF99701和用于7.2的SF99702）在与IBM i 7.1的Technology Refresh 10和IBM i 7.2的Technology Refresh 2相同的日期发布，其中包括JSON Store Technology Preview。 这项新功能允许使用DB2 for i数据库表存储和检索JSON文档。 此功能增加了JSO...

			
		

	





	

		

			

				
					
db2 数据转json v0.01

				
			

			

				

					FlyAnyWhere的专栏
				

				

					11-10
					
					1508
					
				

			

		

		

			
				
直接上代码



#include 
#include 
#include 
#include 
#include 
#ifndef _countof
#define _countof(x) (sizeof(x)/sizeof(x[0]))
#endif
#define hints printf
#define errors printf
#define SQL_STATE_LEN 256

			
		

	





	

		

			

				
					
Android学习系列(20)--App数据格式之解析Json

				
			

			

				

					weixin_33889245的博客
				

				

					03-27
					
					114
					
				

			

		

		

			
				
JSON数据格式，在Android中被广泛运用于客户端和网络(或者说服务器)通信，非常有必要系统的了解学习。     恰逢本人最近对json做了一个简单的学习，特此总结一下，以飨各位。     为了文章简明清晰，尽量多列点，少废话。     参考文档：http://www.ietf.org/rfc/rfc4627.txt?number=46271.JSON解析     (1).解析Object之一...

			
		

	





	

		

			

				
					
DB2数据库自定义json_value函数，获取json字符串中指定字段的值

				
			

			

				

					weixin_51858505的博客
				

				

					10-15
					
					475
					
				

			

		

		

			
				
因DB2数据库版本的关系，目前的SQL语句以存储过程中，均不能使用DB2自带的json_value函数，因此写了一个自定义函数，用来获取json字符串中指定字段的值。

			
		

	





	

		

			

				
					
解析json字符串函数

				
			

			

				

					data eudemon
				

				

					12-18
					
					1292
					
				

			

		

		

			
				
CREATE FUNCTION [dbo].[Parsejson](@JSON NVARCHAR(MAX))
RETURNS @hierarchy TABLE (
  element_id  INT IDENTITY(1, 1) NOT NULL,/* internal surrogate primary key gives the order of parsing and the list or...

			
		

	





	

		

			

				
					
构建pureXML和JSON应用程序，第1部分，使用DB2 pureXML存储和查询JSON

				
			

			

				

					cuyi7076的博客
				

				

					06-27
					
					206
					
				

			

		

		

			
				
存档日期：2019年5月14日 | 上次更新时间：2010年4月27日 | 首次发布：2009年10月13日 
 JavaScript对象表示法（JSON）是Web 2.0中一种流行的文本表示法，用于在客户端和服务器交换信息时将对象（或数据结构）表示为序列化文本。 某些应用程序受益于持久化JSON对象以维护会话之间的状态。 在本文中，了解采用简单的JSON到XML映射时DB2®pureXML®...

			
		

	





	

		

			

				
					
（转）数据库函数解析JSON字符串

				
			

			

				

					vvull的博客
				

				

					10-25
					
					272
					
				

			

		

		

			
				
一、返回单行单列
二、返回表
三、SQL206版本开始支持

SELECT * FROM OPENJSON(@JsonStr)



			
		

	





	

		

			

				
					
Json解析详细教程

				
			

			

				

					andyyung202的博客
				

				

					05-14
					
					757
					
				

			

		

		

			
				
1、JSON(JavaScript Object Notation) 定义：
 
　　　一种轻量级的数据交换格式，具有良好的可读和便于快速编写的特性。业内主流技术为其提供了完整的解决方案（有点类似于正则表达式，获得了当今大部分语言的支持），从而可以在不同平台间进行数据交换。JSON采用兼容性很高的文本格式，同时也具备类似于C语言体系的行为。 – Json.org
　　　 
2、JSON的结

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

  

	
    

      

      

      

        
        

          
          

            

              成就一亿技术人!
            

            

              拼手气红包6.0元
            

          

        

        

          

            还能输入1000个字符
          

          

             
          

          

            

              红包
              添加红包
            

            

              表情包
              插入表情
              

                

              

            

            

              表情包
              代码片
              

                
              

            

            

              
              
              
              
              
              
              
            

          

        

      

    

		

			

			

			

					 条评论被折叠 查看
			

			

				
			

		

	

	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值