pro*c 倒出数据库数据

最近项目要做对数据库，大数据量的倒数，打算用pro*c倒出。然后再用sqlload倒入别的库中

    ANSI动态sql

 

   

/* sqlcheck=full */
/* userid=scott/password@exam */
/* mode=ansi */

/* 包含C头文件 */
#include <stdio.h>
#include <string.h>

/* 包含SQLCA头文件 */
#include <sqlca.h>

/* 定义选择列表项名的最大长度 */
#define MAX_NAME_LEN	31

/* 定义绑定变量值和选择列表项值的最大长度 */
#define MAX_VAR_LEN		200

/* 定义宿主变量 */
exec sql begin declare section;
	char sql_stat[100];
	char current_date[20];
exec sql end declare section;

void connect();
void sql_error();
void process_input();
void process_output();

int main()
{
	/* 安装错误处理句柄 */
	exec sql whenever sqlerror do sql_error();

	/* 连接到数据库 */
	connect();

	/* 分配输入描述区和输出描述区 */
	exec sql allocate descriptor 'input_descriptor';
	exec sql allocate descriptor 'output_descriptor';

	for( ; ; )
	{
		printf("\n请输入动态SQL语句(EXIT:退出):\n");
		gets(sql_stat);

		/* EXIT(exit)->退出 */
		if(0 == strncmp(sql_stat , "EXIT" , 4) || 0 == strncmp(sql_stat , "exit" , 4))
			break;

		/* 准备动态SQL语句 */
		exec sql prepare s from :sql_stat;

		/* 定义游标 */
		exec sql declare c cursor for s;

		/* 处理绑定变量 */
		process_input();

		/* 打开游标
		 * select语句：处理查询结果
		 * 其他SQL语句：执行
		*/
		exec sql open c using descriptor 'input_descriptor';
		if(0 == strncmp(sql_stat , "SELECT" , 6) , 0 == strncmp(sql_stat , "select" , 6))
		{
		exec sql SELECT to_char(sysdate,'YYYYMMDD HH24:MI:SS') INTO :current_date FROM dual;
        	printf("当前时间为%s\n",current_date);
			process_output();
        exec sql SELECT to_char(sysdate,'YYYYMMDD HH24:MI:SS') INTO :current_date FROM dual;
		   printf("当前时间为%s\n",current_date);
        }
		/* 关闭游标 */
		exec sql close c;
	}

	/* 释放输入描述区和输出描述区 */
	exec sql deallocate descriptor 'input_descriptor';
	exec sql deallocate descriptor 'output_descriptor';

	/* 提交事务，断开连接 */
	exec sql commit work release;
	puts("谢谢使用ANSI动态SQL!\n");

	return 0;
}

void connect()/*数据库连接-本地数据库，不添加server*/
{
  EXEC SQL BEGIN DECLARE SECTION;
  VARCHAR oraCN[30];
  EXEC SQL END DECLARE SECTION;
  strcpy(oraCN.arr,"scott/tiger@TEST_dist");
  EXEC SQL CONNECT :oraCN;
}

void sql_error()
{
	/* 显示SQL错误 */
	printf("%.*s\n" , sqlca.sqlerrm.sqlerrml , sqlca.sqlerrm.sqlerrmc);
}

void process_input()
{
	int i;

	/* 定义宿主变量 */
	exec sql begin declare section;
		int input_count;
		int input_type ;
		int input_len;
		char input_buffer[MAX_VAR_LEN];
		char name[MAX_NAME_LEN];
		int occurs;
	exec sql end declare section;

	/* 绑定变量->输入描述区 */
	exec sql describe input s using descriptor 'input_descriptor';

	/* 取得绑定变量个数 */
	exec sql get descriptor 'input_descriptor' :input_count = count;

	/* 循环处理绑定变量名 */
	for(i = 0 ; i != input_count ; ++i)
	{
		occurs = i + 1;

		/* 取得绑定变量名 */
		exec sql get descriptor 'input_descriptor' value :occurs :name = name;
		printf("请输入%s的值：" , name);
		gets(input_buffer);

		/* 以NULL结尾 */
		input_len = strlen(input_buffer);
		input_buffer[input_len] = '\0';

		/* 设置绑定变量类型、长度和值 */
		input_type = 12;
		exec sql set descriptor 'input_descriptor' value :occurs 
			type = :input_type , length = :input_len , data = :input_buffer;
	}
}

void process_output()
{
	int i;

	/* 定义宿主变量 */
	exec sql begin declare section;
		int output_count;
		int output_type;
		int output_len;
		char output_buffer[MAX_VAR_LEN];
		short output_indicator;
		char name[MAX_NAME_LEN];
		int occurs;
	exec sql end declare section;

	FILE *fp;
  
    if((fp=fopen("c:\\test.txt","wt+"))==NULL)//读写打开或建立一个文本文件，允许读写   
    {   
       printf("Cannot open file strike any key exit!");   
  
    } 

	/* 选择列表项->输出描述区 */
	exec sql describe output s using descriptor 'output_descriptor';

	/* 取得选择列表项个数 */
	exec sql get descriptor 'output_descriptor' :output_count = count;

	/* 循环处理选择列表项 */
	for(i = 0 ; i != output_count ; ++i)
	{
		occurs = i + 1;
		output_type = 12;
		output_len = MAX_VAR_LEN;
	
		/* 设置选择列表项的类型和长度 */
		exec sql set descriptor 'output_descriptor' value :occurs 
			type = :output_type , length = :output_len;

		/* 取得选择列表项的名称并输出 */
		exec sql get descriptor 'output_descriptor' value :occurs :name = name;
		printf("\t%s" , name);
	}
	printf("\n");

	/* 提取数据完毕->退出循环 */
	exec sql whenever not found do break;

	/* 循环处理选择列表项数据 */
	for( ; ; )
	{
		/* 行数据->输出描述区 */
		exec sql fetch c into descriptor 'output_descriptor';
       
		/* 循环处理每列数据 */
		for(i = 0 ; i != output_count ; ++i)
		{
			occurs = i +1;

			/* 取得列数据和指示变量值 */
			exec sql get descriptor 'output_descriptor' value :occurs
				:output_buffer = data , :output_indicator = indicator;

			/* 输出列数据 */
			if(-1 == output_indicator)
			    if(i!=0){
				   //printf(" || NULL");
				   fprintf(fp," || %s","null");   
				}else{
			    //	printf("NULL");
				   fprintf(fp,"%s","null");  
				}			
			else
			   if(i!=0){
			    // printf(" || %s" , output_buffer);
                   fprintf(fp," || %s",output_buffer);   
			   }else{
			  // printf("%s" , output_buffer);
			      fprintf(fp,"%s",output_buffer); 
			   }
				
		}
		 // printf("\n");
          fprintf(fp,"%s","\n"); 
	}
	fclose(fp);
}

 

  

  

   oracle 动态sql4 

/* 包含C头文件 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <setjmp.h>
#include <sqlcpr.h>

/* 包含SQLDA和SQLCA结构 */
#include <sqlda.h>
#include <sqlca.h>

/* 定义绑定变量和选择列表项的最大个数 */
#define MAX_ITEMS		40

/* 定义绑定变量和选择列表项名称的最大长度 */
#define MAX_VNAME_LEN	30

/* 定义指示变量名称的最大长度 */
#define MAX_INAME_LEN	30

void connect();
void sql_error();
void alloc_descriptors(int , int , int);
void dealloc_descriptors();
void set_bind_variables();
void process_select_list();

/* 定义绑定描述区和选择描述区 */
SQLDA* bind_dp;
SQLDA* select_dp;

/* 定义输入宿主变量：存放动态SQL语句 */
char sql_stat[100]; 
char current_date[20];   

int main()
{
	/* 安装错误处理句柄 */
	exec sql whenever sqlerror do sql_error();

	/* 连接到数据库 */
	connect();

	/* 分配绑定描述区和选择描述区 */
	alloc_descriptors(MAX_ITEMS , MAX_VNAME_LEN , MAX_INAME_LEN);

	for( ; ; )
	{
		printf("请输入动态SQL语句(exit:退出):");
		gets(sql_stat);

		/* EXIT(exit):退出 */
		if(0 == strncmp(sql_stat , "exit" , 4) || 0 == strncmp(sql_stat , "EXIT" , 4))
			break;

		/* 准备动态SQL语句 */
		exec sql prepare s from :sql_stat;

		/* 定义游标 */
		exec sql declare c cursor for s;

		/* 出错，继续下一循环 */
		if(0 != sqlca.sqlcode)
			continue;

		/* 设置绑定变量 */
		set_bind_variables();

		/*
		 * 打开游标
		 * select语句：生成结果集
		 * 其他SQL语句：执行语句
		 */
		exec sql open c using descriptor bind_dp;

		/*
		 * select语句
		 */
		if(0 == strncmp(sql_stat , "select" , 6) || 0 == strncmp(sql_stat , "SELECT" , 6)){
			/* 处理select语句输出结果 */
			exec sql SELECT to_char(sysdate,'YYYYMMDD HH24:MI:SS') INTO :current_date FROM dual; 
			printf("当前时间为%s\n",current_date);     
			process_select_list();
			exec sql SELECT to_char(sysdate,'YYYYMMDD HH24:MI:SS') INTO :current_date FROM dual;   
            printf("当前时间为%s\n",current_date);   
        }
		/* 关闭游标 */
		exec sql close c;
	}

	/* 释放选择描述区和选择描述区 */
	dealloc_descriptors();

	/* 提交事务，断开连接 */
	exec sql commit work release;
	puts("谢谢使用Oracle动态SQL方法四!\n");

	return 0;
}
void connect()/*数据库连接-本地数据库，不添加server*/  
{   
  EXEC SQL BEGIN DECLARE SECTION;   
  VARCHAR oraCN[30];   
  EXEC SQL END DECLARE SECTION;   
  strcpy(oraCN.arr,"scott/tiger@TEST_dist");   
  EXEC SQL CONNECT :oraCN;   
}   
  
void connect2()
{
	/* 定义宿主变量 */
	char username[20] , password[20] , server[20];

	/* 输入用户名、口令和网络服务名 */
	printf("输入用户名：");
	gets(username);

	printf("输入口令：");
	gets(password);

	printf("输入网络服务名：");
	gets(server);

	/* 连接到数据库 */
	exec sql connect :username identified by :password using :server;
}

void sql_error()
{
	/* 显示SQL错误信息 */
	printf("%.*s\n" , sqlca.sqlerrm.sqlerrml , sqlca.sqlerrm.sqlerrmc);
}

void alloc_descriptors(int size , int max_vname_len , int max_iname_len)
{
	
	int i;

	/* 分配绑定描述区和选择描述区 */
	bind_dp = SQLSQLDAAlloc(0 , size , MAX_VNAME_LEN , MAX_INAME_LEN);
	select_dp = SQLSQLDAAlloc(0 , size , MAX_VNAME_LEN , MAX_INAME_LEN);


	/* 为指示变量、绑定变量和选择列表项分配内存 */
	for(i = 0 ; i != MAX_ITEMS ; ++i)
	{
		bind_dp->I[i] = (short*)malloc(sizeof(short));
		select_dp->I[i] = (short*)malloc(sizeof(short));

		bind_dp->V[i] = (char*)malloc(1);
		select_dp->V[i] = (char*)malloc(1);
	}
}

void dealloc_descriptors()
{
	int i;

	/* 释放指示变量、绑定变量和选择列表项占用的内存 */
	for(i = 0 ; i != MAX_ITEMS ; ++i)
	{
		if(bind_dp->V[i] != (char*)0)
			free(bind_dp->V[i]);
		free(bind_dp->I[i]);

		if(select_dp->V[i] != (char*)0)
			free(select_dp->V[i]);
		free(select_dp->I[i]);
	}

	/* 释放绑定描述区和选择描述区 */
	SQLSQLDAFree(0 , bind_dp);
	SQLSQLDAFree(0 , select_dp);
}

void set_bind_variables()
{
	int i;
	char bind_var[64];

	/* 设置绑定变量最大个数 */
	bind_dp->N = MAX_ITEMS;

	/* 绑定变量名称->绑定描述区 */
	exec sql describe bind variables for s into bind_dp;

	/* 设置绑定变量实际个数 */
	bind_dp->N = bind_dp->F;

	/* 循环处理绑定变量 */
	for(i = 0 ; i != bind_dp->F ; ++i)
	{
		/* 显示绑定变量名 */
		printf("请输入绑定变量%.*s的值：" , (int)bind_dp->C[i] , bind_dp->S[i]);

		/* 输入绑定变量的值 */
		gets(bind_var);

		/* 设置绑定变量的长度成员 */
		bind_dp->L[i] = strlen(bind_var);

		/* 为绑定变量数据缓冲区重新分配内存(多一位，留给'\0') */
		bind_dp->V[i] = (char*)realloc(bind_dp->V[i] , bind_dp->L[i] + 1);

		/* 绑定变量数据->数据缓冲区 */
		strcpy(bind_dp->V[i] , bind_var);

		/* 设置指示变量，处理NULL */
		if(0 == strncmp(bind_var , "NULL" , 4) || 0 == strncmp(bind_var , "null" , 4))
			*bind_dp->I[i] = -1;
		else
			*bind_dp->I[i] = 0;

		/* 设置数据缓冲区数据类型代码->char */
		bind_dp->T[i] = 1;
	}
}

void process_select_list()
{
	int i , null_ok , precision , scale;
	char title[MAX_VNAME_LEN];

	/* 设置选择列表项的最大个数 */
	select_dp->N = MAX_ITEMS;

	/* 选择列表项->选择描述区 */
	exec sql describe select list for s into select_dp;

	/* 设置选择列表项的实际个数 */
	select_dp->N = select_dp->F;

	/* 循环处理选择列表项 */
	for(i = 0 ; i != select_dp->F ; ++i)
	{
		/* 清除select_dp->T[i]的高位->null */
		SQLColumnNullCheck(0 , (unsigned short*)&select_dp->T[i]
			, (unsigned short*)&select_dp->T[i] , &null_ok);

		/* 根据内部数据类型确定外部类型数据长度(显示长度) */
		switch(select_dp->T[i])
		{
		case 2:
			/* number类型，取得精度与标度 */
			SQLNumberPrecV6(0 , (unsigned short*)&select_dp->T[i] , &precision , &scale);
			if(scale > 0)
				/* float */
				select_dp->L[i] = sizeof(float);
			else
				/* int */
				select_dp->L[i] = sizeof(int);
			break;
		case 12:
			/* DATA数据类型(DD-MON-YY) */
			select_dp->L[i] = 9;
			break;
		}

		/* 根据变量长度，重新为选择列表项数据缓冲区分配内存 */
		if(2 != select_dp->T[i])
			/* 其他类型 */
			select_dp->V[i] = (char*)realloc(select_dp->V[i] , select_dp->L[i] + 1);
		else
			/* number类型 */
			select_dp->V[i] = (char*)realloc(select_dp->V[i] , select_dp->L[i]);

		/* 初始化title */
		memset(title , ' ' , MAX_VNAME_LEN);

		/* 选择列表项名称->title */
		strncpy(title , select_dp->S[i] , select_dp->C[i]);

		/* 显示列名 */
		if(2 == select_dp->T[i])
			if(scale > 0)
				printf("\t%.*s" , select_dp->L[i] + 3, title);
			else
				printf("\t%.*s" , select_dp->L[i] , title);
		else
			printf("\t%-.*s" , select_dp->L[i] , title);

		/* 根据Oracle内部类型确定外部数据类型(显示类型) */
		if( 2 == select_dp->T[i])
		{
			/* number 类型*/
			if(scale > 0)
				/* float */
				select_dp->T[i] = 4;
			else
				/* int */
				select_dp->T[i] = 3;
		}
		else
			/* char */
			select_dp->T[i] = 1;
	}

	printf("\n");

	/* 提取数据完毕->结束循环 */
	exec sql whenever not found do break;

	/* 循环处理选择列表数据 */
	for( ; ; )
	{
		/* 数据->选择描述区 */
		exec sql fetch c using descriptor select_dp;

		/* 显示数据 */
		for( i = 0 ; i != select_dp->F ; ++i)
		{
			if(*select_dp->I[i] < 0){
				/* 处理NULL */
				printf("\tNULL");
			}else{
				if(3 == select_dp->T[i]){
					/* int */
					printf("\t%d" , *(int*)select_dp->V[i]);
				}else if(4 == select_dp->T[i]){
					/* float */
					printf("\t%8.2f" , *(float*)select_dp->V[i]);
				}else{
					/* char */
					printf("\t%.*s" , select_dp->L[i] , select_dp->V[i]);
				}
				}
		}
		printf("\n");
	}
}