KR20140052459A - Ｏｄｂｃ프로그램 자동 코딩 방법 - Google Patents

Ｏｄｂｃ프로그램 자동 코딩 방법 Download PDF

Info

Publication number
KR20140052459A
KR20140052459A KR1020120118563A KR20120118563A KR20140052459A KR 20140052459 A KR20140052459 A KR 20140052459A KR 1020120118563 A KR1020120118563 A KR 1020120118563A KR 20120118563 A KR20120118563 A KR 20120118563A KR 20140052459 A KR20140052459 A KR 20140052459A
Authority
KR
South Korea
Prior art keywords
file
coding
int
query
sql
Prior art date
Application number
KR1020120118563A
Other languages
English (en)
Inventor
이원일
Original Assignee
삼성에스디에스 주식회사
Priority date (The priority date is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the date listed.)
Filing date
Publication date
Application filed by 삼성에스디에스 주식회사 filed Critical 삼성에스디에스 주식회사
Priority to KR1020120118563A priority Critical patent/KR20140052459A/ko
Publication of KR20140052459A publication Critical patent/KR20140052459A/ko

Links

Images

Classifications

    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/30—Creation or generation of source code
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/20—Information retrieval; Database structures therefor; File system structures therefor of structured data, e.g. relational data
    • G06F16/24—Querying
    • G06F16/245—Query processing
    • G06F16/2458—Special types of queries, e.g. statistical queries, fuzzy queries or distributed queries
    • G06F16/2462—Approximate or statistical queries
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
    • G06F16/30—Information retrieval; Database structures therefor; File system structures therefor of unstructured textual data
    • G06F16/33—Querying
    • G06F16/338—Presentation of query results
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F8/00—Arrangements for software engineering
    • G06F8/40—Transformation of program code
    • G06F8/41—Compilation
    • G06F8/44—Encoding
    • G06F8/443—Optimisation
    • G06F8/4441—Reducing the execution time required by the program code
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/30—Arrangements for executing machine instructions, e.g. instruction decode
    • G06F9/3017—Runtime instruction translation, e.g. macros
    • G—PHYSICS
    • G06—COMPUTING; CALCULATING OR COUNTING
    • G06F—ELECTRIC DIGITAL DATA PROCESSING
    • G06F9/00—Arrangements for program control, e.g. control units
    • G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
    • G06F9/44—Arrangements for executing specific programs
    • G06F9/455—Emulation; Interpretation; Software simulation, e.g. virtualisation or emulation of application or operating system execution engines
    • G06F9/45504—Abstract machines for programme code execution, e.g. Java virtual machine [JVM], interpreters, emulators
    • G06F9/45516—Runtime code conversion or optimisation
    • G06F9/45525—Optimisation or modification within the same instruction set architecture, e.g. HP Dynamo

Landscapes

  • Engineering & Computer Science (AREA)
  • Theoretical Computer Science (AREA)
  • Software Systems (AREA)
  • Physics & Mathematics (AREA)
  • General Engineering & Computer Science (AREA)
  • General Physics & Mathematics (AREA)
  • Probability & Statistics with Applications (AREA)
  • Computational Linguistics (AREA)
  • Data Mining & Analysis (AREA)
  • Databases & Information Systems (AREA)
  • Fuzzy Systems (AREA)
  • Mathematical Physics (AREA)
  • Information Retrieval, Db Structures And Fs Structures Therefor (AREA)

Abstract

본 발명에 따른 ODBC(Open Database Connectivity) 프로그램 자동 코딩 방법은, 데이터베이스에 저장할 데이터의 타입과 길이를 선언하기 위한 헤더 파일을 코딩하는 데이터베이스 테이블 구조체 선언 코딩단계; 상기 데이터베이스 테이블 구조체 선언 코딩한 파일을 입력 파일로 하여 코딩 자동화를 위한 선언문을 쉽게 작성하기 위한 소스 코드 파일을 생성하는 제1 코딩 자동화 단계; 상기 생성된 소스 코드 파일을 이용하여 2차 코딩 자동화를 위한 선언문 파일을 작성하는 단계; 상기 작성된 선언문 파일들을 입력 파일들로 하여 새로운 코딩 자동화를 위한 결과 파일들을 실행하는 제2 코딩 자동화 단계를 포함하는 것으로서, 본 발명은 코딩의 자동화로 인하여 구조체의 선언과 코딩 자동화를 위한 선언문 파일만 코딩하면 되기 때문에 코딩양의 감소, 코딩의 자동화로 인하여 코딩양이 감소하여 코딩에 소요되는 시간 감소, 코딩의 자동화로 인하여 자동화 부분에 대하여 실수로 인한 코딩에러가 없기 때문에 에러 발생율 감소, 에러 발생시 구조체와 코딩 자동화를 위한 선언문 파일만 확인하면 되기 때문에 에러 보완에 걸리는 시간이 감소될 수 있는 것이다.

Description

ＯＤＢＣ프로그램 자동 코딩 방법{Method for coding automatically ODBC program}
본 발명은 ODBC(Open Database Connectivity) 프로그램 자동 코딩 방법에 관한 것이다.
일반적으로, ODBC(Open Database Connectivity)란 다양한 데이터 베이스에 접근하여 원하는 데이터를 가져오는데 이용되는 DB 커넥터를 의미한다. 즉, ODBC는 데이터베이스를 액세스 하기 위한 표준 개방형 응용프로그램 인터페이스를 의미하는 것으로, 기본적으로 ODBC를 통하면, 접속하려는 DB 계정만 알면 누구나 접근하여 데이터를 가져 올 수가 있다. 이렇게 ODBC ENGINE을 이용하여 데이터를 가져오는 프로그램을 ODBC 이용한 쿼리 프로그램이라고 하는데 다양한 DB에 연결할 수 있는 ODBC 특성상 종래의 쿼리 프로그램은 DB 자체 보안에만 의지할 뿐 쿼리 소프트웨어 내에서는 보안 사항이 적용된 예가 없으며, 일반적인 쿼리 소프트웨어를 설치한 모든 사용자는 DB에 접근하여 정보를 활용할 수 있다.
또한, ODBC를 사용하는 특성상 DB 의 ID/PASSWORD를 접근 자에게 알려줘야 하고, 사용자들이 DB에 접근해서 어떠한 자료를 조회하였는지에 대한 로그를 남기지 않게 되는 것이다.
한편, 일반적인 ODBC는 DB에 연결후 사용자가 접속을 종료하기 전까지 모든 세션이 열려 있어 DB 서버에 많은 부담을 주고, 일반적으로 Standalone 형태로 만들어져 쿼리 사용자간의 정보교류를 할 수가 없으며, 소프트웨어 자동 업데이트 기능이 없는 문제점이 있었다.
이러한 문제점들을 해결하기 위하여 종래에는 데이터베이스 액세스를 위해 ODBC 프로그램 코딩 과정을 수행하게 되는게 이러한 종래 기술에 따른 ODBC 프로그램 코딩 과정에 대하여 첨부한 도 1을 참조하여 설명해 보자.
도 1은 종래 기술에 따른 ODBC 프로그램 코딩 과정을 나타낸 플로우챠트이다.
도 1에 도시된 바와 같이 ODBC 프로그램 코딩은 먼저, 데이터 베이스 테이블 구조체 선어 코딩을 수행하게 되는데 이는 데이터 베이스에 저장할 데이터의 타입과 길이를 선언하기 위한 헤더 파일을 코딩하는 것이다(S101). 여기서, 데이터 베이스 테이블 구조체 선어 코딩의 일예는 다음과 같다.
typedef struct DB_TABLE
{
　　　　char 　　　　　　　　　　　a[10];
　　　　int 　　　　　　　　　　　　b;
　　　　short 　　　　　　　　　　c;
　　　　int 　　　　　　　　　　　　d;
　　　　short 　　　　　　　　　　e;
　　　　int 　　　　　　　　　　　　f;
　　　　short 　　　　　　　　　　g;
　　　　int 　　　　　　　　　　　　h;
} _DBDb_Table;
이어, 데이터베이스 테이블 인디케이터 구조체 선언 코딩을 수행하는데 이는 데이터베이스 엑세스시에 입력값, 결과값의 길이를 저장하는 구조체를 선언하기 위한 코딩이다(S102). 여기서, 인디케이터 구조체 코딩의 일예는 다음과 같다.
typedef struct
{
　　　　int 　　　　　　　　　　a;
　　　　int 　　　　　　　　　　b;
　　　　int 　　　　　　　　　　c;
　　　　int 　　　　　　　　　　d;
　　　　int 　　　　　　　　　　e;
　　　　int 　　　　　　　　　　f;
　　　　int 　　　　　　　　　　g;
　　　　int 　　　　　　　　　　h;
} _Ln_Db_Table;
이어, 명령문 핸들 할당 코딩을 수행하는데, 이는 데이터베이스 엑세스시에 SQL QUERY문 1개당 1개의 명령문 핸들을 할당하기 위한 코딩이다(S103). 여기서, 명령문 할당 코딩의 일예는 다음과 같다.
#define ST_HANDLE_MAX 　100
typedef enum
{
　　ST_DB_INSERT = 0,
　　ST_DB_DELETE,
　　ST_DB_SEARCH
} _ST_HANDLE_TYPE;
이어, SQLPrepare ODBC 함수를 사용하여 PREPARE 함수를 코딩하게 되고(S104), SQL QUERY문을 선언하기 위해 SQL QUERY문 코딩을 수행한다(S105).여기서, PREPARE 함수를 코딩하는 일예는 다음과 같다.
int alloc_all_stmt(int tN, int ndX)
{
　　　　PrintLog(4, "[T%d] ======= alloc_all_stmt === ndX[%d]====￦n", tN, ndX);
　　　　if (R_Prepare_ST_DB_INSERT (tN, ST_DB_INSERT, ndX) != 1)
　　　　{
　　　　　　　　return -1;
　　　　}
　　　　if (R_Prepare_ST_DB_DELETE (tN, ST_DB_DELETE, ndX) != 1)
　　　　{
　　　　　　　　return -1;
　　　　}
　　　　if (R_Prepare_ST_DB_SEARCH (tN, ST_DB_SEARCH, ndX) != 1)
　　　　{
　　　　　　　　return -1;
　　　　}
　　　　return 1;
}　
int R_Prepare_ST_DB_INSERT(int tN, int sndX, int ndX)
{
　　　　PrintLog(1, "[T%d] ------- 　　R_Prepare_""ST_DB_INSERT"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if (SQLAllocHandle(3, dB[tN].DBc[ndX], &dB[tN].STh[sndX][ndX]) != 0)
　　　　{
　　　　　　　　PrintLog(4, "[T%d] SQLAllocStmt ERROR [%s][%d]!!￦n", tN, t_Query[sndX].name, ndX);
　　　　　　　　return -1;
　　　　}
　　　　PrintLog(1, "[T%d] t_Query[%d].name 　= [%s]￦n", tN, sndX, t_Query[sndX].name);
　　　　PrintLog(1, "[T%d] t_Query[%d].query = [%s]￦n", tN, sndX, t_Query[sndX].query);
　　　　if (SQLPrepare(dB[tN].STh[sndX][ndX], (unsigned char*)t_Query[sndX].query, (-3)) != 0)
　　　　{
　　　　　　　　R_SQL_err(tN, dB[tN].DBc[ndX], dB[tN].STh[sndX][ndX], t_Query[sndX].query);
　　　　　　　　return -1;
　　　　}
　　　　if (R_Bind_ST_DB_INSERT(tN, sndX, ndX) == -1)
　　　　{
　　　　　　　　R_SQL_err(tN, dB[tN].DBc[ndX], dB[tN].STh[sndX][ndX], t_Query[sndX].query);
　　　　　　　　return -1;
　　　　}
　　　　return 1;
}
　
int R_Prepare_ST_DB_DELETE(int tN, int sndX, int ndX)
{
　　　　PrintLog(1, "[T%d] ------- 　　R_Prepare_""ST_DB_DELETE"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if (SQLAllocHandle(3, dB[tN].DBc[ndX], &dB[tN].STh[sndX][ndX]) != 0)
　　　　{
　　　　　　　　PrintLog(4, "[T%d] SQLAllocStmt ERROR [%s][%d]!!￦n", tN, t_Query[sndX].name, ndX);
　　　　　　　　return -1;
　　　　}
　　　　PrintLog(1, "[T%d] t_Query[%d].name 　= [%s]￦n", tN, sndX, t_Query[sndX].name);
　　　　PrintLog(1, "[T%d] t_Query[%d].query = [%s]￦n", tN, sndX, t_Query[sndX].query);
　　　　if (SQLPrepare(dB[tN].STh[sndX][ndX], (unsigned char*)t_Query[sndX].query, (-3)) != 0)
　　　　{
　　　　　　　　R_SQL_err(tN, dB[tN].DBc[ndX], dB[tN].STh[sndX][ndX], t_Query[sndX].query);
　　　　　　　　return -1;
　　　　}
　　　　if (R_Bind_ST_DB_DELETE(tN, sndX, ndX) == -1)
　　　　{
　　　　　　　　R_SQL_err(tN, dB[tN].DBc[ndX], dB[tN].STh[sndX][ndX], t_Query[sndX].query);
　　　　　　　　return -1;
　　　　}
　　　　return 1;
}
　
int R_Prepare_ST_DB_SEARCH(int tN, int sndX, int ndX)
{
　　　　PrintLog(1, "[T%d] ------- 　　R_Prepare_""ST_DB_SEARCH"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if (SQLAllocHandle(3, dB[tN].DBc[ndX], &dB[tN].STh[sndX][ndX]) != 0)
　　　　{
　　　　　　　　PrintLog(4, "[T%d] SQLAllocStmt ERROR [%s][%d]!!￦n", tN, t_Query[sndX].name, ndX);
　　　　　　　　return -1;
　　　　}
　　　　PrintLog(1, "[T%d] t_Query[%d].name 　= [%s]￦n", tN, sndX, t_Query[sndX].name);
PrintLog(1, "[T%d] t_Query[%d].query = [%s]￦n", tN, sndX, t_Query[sndX].query);
　　　　if (SQLPrepare(dB[tN].STh[sndX][ndX], (unsigned char*)t_Query[sndX].query, (-3)) != 0)
　　　　{
　　　　　　　　R_SQL_err(tN, dB[tN].DBc[ndX], dB[tN].STh[sndX][ndX], t_Query[sndX].query);
　　　　　　　　return -1;
　　　　}
　　　　if (R_Bind_ST_DB_SEARCH(tN, sndX, ndX) == -1)
　　　　{
　　　　　　　　R_SQL_err(tN, dB[tN].DBc[ndX], dB[tN].STh[sndX][ndX], t_Query[sndX].query);
　　　　　　　　return -1;
　　　　}
　　　　return 1;
}
그리고, SQL QUERY문 코딩의 일예는 다음과 같다.
int R_Define_Query()
{
　　　　int i;
　　　　PrintLog(4, "[M] ======= R_Define_Query ======￦n");
　　　　bD.STh_Cnt = 0;
　
　　　　sprintf(t_Query[ST_DB_INSERT].name, "ST_DB_INSERT");
　　　　sprintf(t_Query[ST_DB_INSERT].query,
　　　　　　　　　　　　"INSERT INTO DB_TABLE VALUES("
　　　　　　　　　　　　"?,"
　　　　　　　　　　　　"?,"
*　　　　　　　　　　　　"?,"
　　　　　　　　　　　　"?,"
　　　　　　　　　　　　"?,"
　　　　　　　　　　　　"?,"
　　　　　　　　　　　　"?,"
　　　　　　　　　　　　"?"
　　　　　　　　　　　　")"
　　　　　　　　　　　);
　　　　bD.STh_Cnt ++;
　
　　　　sprintf(t_Query[ST_DB_DELETE].name, "ST_DB_DELETE");
　　　　sprintf(t_Query[ST_DB_DELETE].query,
　　　　　　　　　　　　"DELETE FROM DB_TABLE WHERE "
　　　　　　　　　　　　"a=?"
　　　　　　　　　　　　"　AND "
　　　　　　　　　　　　"b=?"
　　　　　　　　　　　);
　　　　bD.STh_Cnt ++;
　
　　　　sprintf(t_Query[ST_DB_SEARCH].name, "ST_DB_SEARCH");
　　　　sprintf(t_Query[ST_DB_SEARCH].query,
　　　　　　　　　　　　"SELECT "
　　　　　　　　　　　　"a,"
　　　　　　　　　　　　"b,"
　　　　　　　　　　　　"c,"
　　　　　　　　　　　　"d,"
　　　　　　　　　　　　"e,"
　　　　　　　　　　　　"f,"
　　　　　　　　　　　　"g,"
　　　　　　　　　　　　"h"
　　　　　　　　　　　　"　FROM DB_TABLE WHERE "
　　　　　　　　　　　　"a=?"
　　　　　　　　　　　　"　AND "
　　　　　　　　　　　　"b=?"
　　　　　　　　　　　);
　　　　bD.STh_Cnt ++;
　
　　　　PrintLog(1, "[MT] Query bD.STh_Cnt[%d]￦n", bD.STh_Cnt);
　　　　for (i = 0 ; i <　bD.STh_Cnt ; i++)
　　　　{
　　　　　　　　PrintLog(1, "[MT] t_Query[%d].name 　= [%s]￦n", i, t_Query[i].name);
　　　　　　　　PrintLog(1, "[MT] t_Query[%d].query = [%s]￦n", i, t_Query[i].query);
　　　　}
　　　　return 1;
}
이어, BIND 관련 함수 코딩을 수행하게 되는데, 이는 SQLBindParameter, SQLBindCol ODBC 함수를 사용하여 코딩하게 되고(S106), 이어 SQLExecute ODBC 함수를 사용하여 EXECUTE 관련 함수 코딩을 수행한다(S107). 여기서, BIND 관련 함수 코딩의 일예는 다음과 같다.
int R_Bind_ST_DB_INSERT (int tN, int sndX, int ndX)
{
　　　　int Pseq, Cseq;
　　　　Pseq = 1;
　　　　Cseq = 1;
　　　　PrintLog(4, "[T%d] ------- R_Bind_""ST_DB_INSERT"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, 1, 12, sizeof(rB[tN].DB.a)-1, 0, rB[tN].DB.a, sizeof(rB[tN].DB.a), &rB[tN].i_DB.a) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.a");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (4 +(-20)), 4, 0, 0, &rB[tN].DB.b, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.b");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (5 +(-20)), 5, 0, 0, &rB[tN].DB.c, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.c");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (4 +(-20)), 4, 0, 0, &rB[tN].DB.d, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.d");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (5 +(-20)), 5, 0, 0, &rB[tN].DB.e, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.e");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (4 +(-20)), 4, 0, 0, &rB[tN].DB.f, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.f");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (5 +(-20)), 5, 0, 0, &rB[tN].DB.g, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.g");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (4 +(-20)), 4, 0, 0, &rB[tN].DB.h, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.h");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　return 1;
}
int R_Bind_ST_DB_DELETE (int tN, int sndX, int ndX)
{
　　　　int Pseq, Cseq;
　　　　Pseq = 1;
　　　　Cseq = 1;
　　　　PrintLog(4, "[T%d] ------- R_Bind_""ST_DB_DELETE"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, 1, 12, sizeof(rB[tN].DB.a)-1, 0, rB[tN].DB.a, sizeof(rB[tN].DB.a), &rB[tN].i_DB.a) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.a");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (4 +(-20)), 4, 0, 0, &rB[tN].DB.b, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.b");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　return 1;
}
int R_Bind_ST_DB_SEARCH (int tN, int sndX, int ndX)
{
　　　　int Pseq, Cseq;
　　　　Pseq = 1;
　　　　Cseq = 1;
　　　　PrintLog(4, "[T%d] ------- R_Bind_""ST_DB_SEARCH"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, 1, aB[tN].DB.a, sizeof(aB[tN].DB.a), &aB[tN].i_DB.a) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.a");
　　　　　　　　return -1;
　　　　}
　　　　Cseq++;
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, (4 +(-20)), &aB[tN].DB.b, 0, &aB[tN].i_DB.b) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.b");
　　　　　　　　return -1;
　　　　}
　　　　Cseq++;
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, (5 +(-20)), &aB[tN].DB.c, 0, &aB[tN].i_DB.c) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.c");
　　　　　　　　return -1;
　　　　}
　　　　Cseq++;
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, (4 +(-20)), &aB[tN].DB.d, 0, &aB[tN].i_DB.d) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.d");
　　　　　　　　return -1;
　　　　}
　　　　Cseq++;
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, (5 +(-20)), &aB[tN].DB.e, 0, &aB[tN].i_DB.e) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.e");
　　　　　　　　return -1;
　　　　}
　　　　Cseq++;
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, (4 +(-20)), &aB[tN].DB.f, 0, &aB[tN].i_DB.f) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.f");
　　　　　　　　return -1;
　　　　}
　　　　Cseq++;
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, (5 +(-20)), &aB[tN].DB.g, 0, &aB[tN].i_DB.g) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.g");
　　　　　　　　return -1;
　　　　}
　　　　Cseq++;
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, (4 +(-20)), &aB[tN].DB.h, 0, &aB[tN].i_DB.h) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.h");
　　　　　　　　return -1;
　　　　}
　　　　Cseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, 1, 12, sizeof(rB[tN].DB.a)-1, 0, rB[tN].DB.a, sizeof(rB[tN].DB.a), &rB[tN].i_DB.a) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.a");
　　　　　　　　return -1;
　　　　}
　　　　Pseq++;
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, 1, (4 +(-20)), 4, 0, 0, &rB[tN].DB.b, 0, ((void *)0)) != 0)
　　　　{
　　　　　　　　PrintLog(3, "[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, "DB.b");
　　　　　　　　return -1;
　　　　}
Pseq++;
　　　　return 1;
}
그리고, EXECUTE 관련 함수 코딩의 일예는 다음과 같다.
int R_Execute_ST_DB_INSERT(int tN, int sndX, int ndX)
{
　　　　PrintLog(3, "[T%d] ------- R_Execute_""ST_DB_INSERT"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　R_ExPrint_ST_DB_INSERT(tN);
　　　　int ret;
　　　　SQLFreeStmt(dB[tN].STh[sndX][ndX], 0);
　　　　ret = SQLExecute(dB[tN].STh[sndX][ndX]);
　　　　PrintLog(3, "[T%d] SQLExecute [%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if ((ret == 0) || (ret == 1))
　　　　{
　　　　　　　　return 1;
　　　　}
　　　　else if (ret == 100)
　　　　{
　　　　　　　　return -5;
　　　　}
　　　　else
　　　　{
　　　　　　　　return -1;
　　　　}
　　　　return 1;
}
　
int R_Execute_ST_DB_DELETE(int tN, int sndX, int ndX)
{
　　　　PrintLog(3, "[T%d] ------- R_Execute_""ST_DB_DELETE"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　R_ExPrint_ST_DB_DELETE(tN);
　　　　int ret;
　　　　SQLFreeStmt(dB[tN].STh[sndX][ndX], 0);
　　　　ret = SQLExecute(dB[tN].STh[sndX][ndX]);
　　　　PrintLog(3, "[T%d] SQLExecute [%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if ((ret == 0) || (ret == 1))
　　　　{
　　　　　　　　return 1;
　　　　}
　　　　else if (ret == 100)
　　　　{
　　　　　　　　return -5;
　　　　}
　　　　else
　　　　{
　　　　　　　　return -1;
　　　　}
　　　　return 1;
}
　
int R_Execute_ST_DB_SEARCH(int tN, int sndX, int ndX)
{
　　　　PrintLog(3, "[T%d] ------- R_Execute_""ST_DB_SEARCH"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　R_ExPrint_ST_DB_SEARCH(tN);
　　　　int ret;
　　　　SQLFreeStmt(dB[tN].STh[sndX][ndX], 0);
　　　　ret = SQLExecute(dB[tN].STh[sndX][ndX]);
　　　　PrintLog(3, "[T%d] SQLExecute [%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　if ((ret == 0) || (ret == 1))
　　　　{
　　　　　　　　return 1;
　　　　}
　　　　else if (ret == 100)
　　　　{
　　　　　　　　return -5;
　　　　}
　　　　else
　　　　{
　　　　　　　　return -1;
　　　　}
　　　　return 1;
}
이어, SQLFetch ODBC 함수를 사용하여 FETCH 관련 함수 코딩을 수행하고(S108), SQL QUERY문에서 사용되는 입력값을 출력하기 위해 QUERY 입력값 PRINT 함수 코딩을 수행한다(S109). 여기서, FETCH 관련 함수 코딩의 일예는 다음과 같다.
int R_Fetch_ST_DB_INSERT (int tN, int sndX, int ndX)
{
　　　　PrintLog(4, "[T%d] ------- R_Fetch_""ST_DB_INSERT"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　return SQLFetch(dB[tN].STh[sndX][ndX]);
}
　
int R_Fetch_ST_DB_DELETE (int tN, int sndX, int ndX)
{
　　　　PrintLog(4, "[T%d] ------- R_Fetch_""ST_DB_DELETE"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　return SQLFetch(dB[tN].STh[sndX][ndX]);
}
　
int R_Fetch_ST_DB_SEARCH (int tN, int sndX, int ndX)
{
　　　　PrintLog(4, "[T%d] ------- R_Fetch_""ST_DB_SEARCH"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　aB[tN].DB.a[0] = '￦0';
　　　　return SQLFetch(dB[tN].STh[sndX][ndX]);
}
그리고, QUERY 입력값 PRINT 함수 코딩의 일예는 다음과 같다.
int R_ExPrint_ST_DB_INSERT (int tN)
{　
　　　　PrintLog(4, "[T%d] %-30s = [%s][%d]￦n", tN, "DB.a", rB[tN].DB.a, *&rB[tN].i_DB.a);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.b", *&rB[tN].DB.b);;
　　　　PrintLog(4, "[T%d] %-30s = [%d]￦n", tN, "DB.c", *&rB[tN].DB.c);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.d", *&rB[tN].DB.d);;
　　　　PrintLog(4, "[T%d] %-30s = [%d]￦n", tN, "DB.e", *&rB[tN].DB.e);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.f", *&rB[tN].DB.f);;
　　　　PrintLog(4, "[T%d] %-30s = [%d]￦n", tN, "DB.g", *&rB[tN].DB.g);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.h", *&rB[tN].DB.h);;
　　　　return 1;
}　
int R_ExPrint_ST_DB_DELETE (int tN)
{
　　　　　PrintLog(4, "[T%d] %-30s = [%s][%d]￦n", tN, "DB.a", rB[tN].DB.a, *&rB[tN].i_DB.a);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.b", *&rB[tN].DB.b);;
　　　　return 1;
}
　int R_ExPrint_ST_DB_SEARCH (int tN)
{
　　　　　PrintLog(4, "[T%d] %-30s = [%s][%d]￦n", tN, "DB.a", rB[tN].DB.a, *&rB[tN].i_DB.a);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.b", *&rB[tN].DB.b);;
　　　　return 1;
}
그리고, SQL QUERY 결과 값을 출력하기 위해 QUERY 결과값 PRINT 함수 코딩을 수행하고(S110), 함수 선언 코딩을 수행하는데 이는 사용되는 함수들을 선언하기 위한 헤더파일 코딩을 수행함으로서 이루어지게 되는 것이다(S111).
여기서, QUERY 결과값 PRINT 함수 코딩에 대한 일예는 다음과 같다.
int R_Print_ST_DB_INSERT (int tN, int sndX, int ndX)
{
　　　　PrintLog(4, "[T%d] ------- R_Print_""ST_DB_INSERT"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　return 1;
}　
int R_Print_ST_DB_DELETE (int tN, int sndX, int ndX)
{
　　　　PrintLog(4, "[T%d] ------- R_Print_""ST_DB_DELETE"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　return 1;
}　
int R_Print_ST_DB_SEARCH (int tN, int sndX, int ndX)
{
　　　　PrintLog(4, "[T%d] ------- R_Print_""ST_DB_SEARCH"" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　　　　PrintLog(4, "[T%d] %-30s = [%s][%d]￦n", tN, "DB.a", aB[tN].DB.a, *&aB[tN].i_DB.a);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.b", *&aB[tN].DB.b);;
　　　　PrintLog(4, "[T%d] %-30s = [%d]￦n", tN, "DB.c", *&aB[tN].DB.c);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.d", *&aB[tN].DB.d);;
　　　　PrintLog(4, "[T%d] %-30s = [%d]￦n", tN, "DB.e", *&aB[tN].DB.e);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.f", *&aB[tN].DB.f);;
　　　　PrintLog(4, "[T%d] %-30s = [%d]￦n", tN, "DB.g", *&aB[tN].DB.g);;
　　　　PrintLog(4, "[T%d] %-30s = [%ld]￦n", tN, "DB.h", *&aB[tN].DB.h);;
　　　　return 1;
}
그리고, 함수 선언 코딩의 일예는 다음과 같다.
int R_Execute_ST_DB_INSERT(int, int, int);
int R_Prepare_ST_DB_INSERT(int, int, int);
int R_Print_ST_DB_INSERT(int, int, int);
int R_ExPrint_ST_DB_INSERT(int);
int R_Bind_ST_DB_INSERT(int, int, int);
int R_Fetch_ST_DB_INSERT(int, int, int);
int R_Execute_ST_DB_DELETE(int, int, int);
*int R_Prepare_ST_DB_DELETE(int, int, int);
int R_Print_ST_DB_DELETE(int, int, int);
int R_ExPrint_ST_DB_DELETE(int);
int R_Bind_ST_DB_DELETE(int, int, int);
int R_Fetch_ST_DB_DELETE(int, int, int);
int R_Execute_ST_DB_SEARCH(int, int, int);
int R_Prepare_ST_DB_SEARCH(int, int, int);
int R_Print_ST_DB_SEARCH(int, int, int);
int R_ExPrint_ST_DB_SEARCH(int);
int R_Bind_ST_DB_SEARCH(int, int, int);
int R_Fetch_ST_DB_SEARCH(int, int, int);
이와 같은 데이터베이스 엑세스를 위한 ODBC프로그래밍 코딩 과정은 데이터베이스의 구조와 SQL QUERY문의 내용에 따라 아래의 모든 코딩 과정이 수작업으로 이루어 지게 되는데 상기한 코딩 과정을 정리해 보면 다음과 같다.
a. 데이터베이스 테이블 구조체 선언 코딩
b. 데이터베이스 테이블 인디케이터 구조체 선언 코딩
c. 명령문 핸들 할당 코딩
d. PREPARE 함수 코딩
e. SQL QUERY문 코딩
f. BIND 관련 함수 코딩
g. EXECUTE 관련 함수 코딩
h. FETCH 관련 함수 코딩
i. QUERY 입력값 PRINT 함수 코딩
j. QUERY 결과값 PRINT 함수 코딩
j. 함수 선언 코딩
이와 같은 종래 기술에 따른 ODBC 프로그램 코딩 과정 모두는 수작업으로 이루어지기 때문에 먼저, ODBC 프로그래밍의 코딩이 복잡해지는 문제점과, ODBC 프로그래밍의 코딩에 많은 시간이 소요되는 문제점을 안고 있다.
그리고, ODBC 프로그래밍의 코딩시 실수로 인한 오류가 발생할 가능성이 높으며, ODBC 프로그래밍의 코딩 오류시 오류 발생 부분을 찾기가 어려운 문제점을 가지고 있는 것이다.
따라서, 본 발명은 상기한 종래 기술에 따른 문제점을 해결하기 위한 것으로, 본 발명의 목적은 ODBC 프로그래밍시, 데이터베이스의 구조체와 SQL쿼리문을 사용하여 ODBC 프로래밍 코딩과정을 자동화하는 방식을 통하여 코딩 시간을 줄여 개발기간을 단축하고, 코딩시 오류의 발생을 방지할 수 있도록 한 ODBC 프로그램 자동 코딩 방법을 제공함에 있다.
상기한 목적을 달성하기 위한 본 발명에 따른 ODBC 프로그램 자동 코딩 방법의 일 측면에 따르면, ODBC(Open Database Connectivity) 프로그램 자동 코딩 방법에 있어서, 데이터베이스에 저장할 데이터의 타입과 길이를 선언하기 위한 헤더 파일을 코딩하는 데이터베이스 테이블 구조체 선언 코딩단계; 상기 데이터베이스 테이블 구조체 선언 코딩한 파일을 입력 파일로 하여 코딩 자동화를 위한 선언문을 쉽게 작성하기 위한 소스 코드 파일을 생성하는 제1 코딩 자동화 단계; 상기 생성된 소스 코드 파일을 이용하여 2차 코딩 자동화를 위한 선언문 파일을 작성하는 단계; 상기 작성된 선언문 파일들을 입력 파일들로 하여 새로운 코딩 자동화를 위한 결과 파일들을 실행하는 제2 코딩 자동화 단계를 포함할 수 있다.
상기 제1 코딩 자동화 단계는, 원본파일을 결과 파일로 복사한 후, 정규식 대체 기능을 사용하여 결과 파일의 내용을 변경하는 방식을 사용한다.
상기 정규식 대체 기능은 Perl, Python을 사용하여 구현한다.
상기 정규식 대체 기능은 매크로 치환 기능을 사용한다.
상기 선언문 파일을 작성하는 단계는 한개의 SQL QUERY당 한개의 명령어 핸들러를 사용한다.
상기 제2 코딩 자동화 단계에서의 입력 파일은 코딩 자동화를 위한 선언문 파일, BIND 관련 함수 파일, PREPARE 함수 파일, 데이터베이스 테이블 구조체 선언 코딩한 파일중 적어도 하나 이상의 파일이다.
상기 제2 코딩 자동화 단계에서의 결과 파일은 명령문 핸들 할당 파일, SQLPrepare, SQLExcute 함수 파일, SQL QUERY문 파일, SQLBindParameter, SQLBindCol 관련 함수 파일, QUERY 입력값 PRINT 함수 파일, QUERY 결과값 PRINT 함수 파일, SQLFetch 관련 함수 파일, 함수 선언 파일, 데이터베이스 테이블 인디케이터 구조체 선언 파일 중 적어도 하나 이상의 파일이다.
상기 제2 코딩 자동화 단계는 원본파일을 결과 파일로 복사한 후, 정규식 대체 기능을 사용하여 결과 파일의 내용을 변경하는 방식을 사용한다. ,
상기 정규식 대체 기능은 Perl, Python을 사용하여 구현할 수 있으며, 상기 정규식 대체 기능은 매크로 치환 기능을 사용한다.
본 발명에 따른 ODBC(Open Database Connectivity) 프로그램 자동 코딩 방법은 코딩의 자동화로 인하여 구조체의 선언과 코딩 자동화를 위한 선언문 파일만 코딩하면 되기 때문에 코딩양이 감소할 수 있으며, 코딩의 자동화로 인하여 코딩양이 감소하여 코딩에 소요되는 시간이 감소하는 것이다.
또한, 코딩의 자동화로 인하여 자동화 부분에 대하여 실수로 인한 코딩에러가 없기 때문에 에러 발생율이 감소되며, 에러 발생시 구조체와 코딩 자동화를 위한 선언문 파일만 확인하면 되기 때문에 에러 보완에 걸리는 시간이 감소될 수 있는 것이다.
도 1은 종래 기술에 따른 ODBC 프로그램 코딩 과정을 나타낸 플오우챠트이다.
도 2는 본 발명에 따른 ODBC 프로그램 자동 코딩 방법에 대한 과정을 나타낸 플로우챠트를 나타낸 도면이다.
이라, 본 발명에 따른 ODBC 프로그램 자동 코딩 방법에 대하여 첨부한 도면을 참조하여 상세하게 설명해 보도록 하자.
도 2는 본 발명에 따른 ODBC 프로그램 자동 코딩 방법에 대한 그 과정을 나타낸 플로우챠트이다.
도 2에 도시된 바와 같이 본 발명에 따른 ODBC 프로그램 자동 코딩 방법은 데이터베이스 테이블 구조체 선언 코딩(S201), 코딩 자동화 1단계 실행(S202), 코딩 자동화를 위한 선언문 작성(S203), 코딩 자동화 2단계 실행(S204)으로 그 코딩과정이 이루어지게 된다.
먼저, 데이터베이스에 저장할 데이터의 타입과 길이를 선언하기 위한 헤더파일 코딩을 수행하는 데이터베이스 테이블 구조체 선언 코딩과정을 수행한다(S201).
여기서, 데이터베이스 테이블 구조체 선언 파일에 대한 코딩예는 아래와 같다.
typedef struct DB_TABLE
{
　　　　char 　　　　　　　　　　　a[10];
　　　　int 　　　　　　　　　　　　b;
　　　　short 　　　　　　　　　　c;
　　　　int 　　　　　　　　　　　　d;
　　　　short 　　　　　　　　　　e;
　　　　int 　　　　　　　　　　　　f;
　　　　short 　　　　　　　　　　g;
　　　　int 　　　　　　　　　　　　h;
} _DBDb_Table;
이어, 본원발명에서의 코딩 자동화 1단계를 수행하게 되는데, 이는 코딩 자동화를 위한 선언문을 쉽게 작성하기 위한 소스코드파일을 데이터베이스 테이블 구조체 파일로부터 자동으로 생성하는 것이다(S202).
이러한 코딩 자동화 1단계에서의 실행 파일 즉, 입력 파일과 출력 파일은 다음 아래의 표 1과 같다.
입력파일 출력파일
데이터베이스 테이블 구조체 선언 코딩한 파일 코딩 자동화를 위한 선언문을 쉽게 작성하기 위한 소스 코드 파일 생성
상기한 코딩 자동화 1단계 파일의 실행은 원본파일을 결과파일로 복사한 후에, 정규식 대체기능을 사용하여 결과파일의 내용을 변경하는 방식을 사용한다. 정규식 대체기능은 Perl, Python 등을 사용하여 구현할 수 있다. 또한 매크로의 치환기능을 사용할 수도 있다. 본 발명의 코딩 자동화 1단계 실행 방법의 예는 Perl을 사용하여 구현하였으며, 여기서, 코딩 자동화를 위한 선언문을 윕게 작성하기 위한 소스 코드 파일의 코딩에는 다음과 같다.
typedef struct DB_TABLE
{
_QRY_BIND_C("a,", SQL_C_CHAR, "DB.a")
_QRY_BIND_C("b,", SQL_C_SLONG, "DB.b")
_QRY_BIND_C("c,", SQL_C_SSHORT, "DB.c")
_QRY_BIND_C("d,", SQL_C_SLONG, "DB.d")
_QRY_BIND_C("e,", SQL_C_SSHORT, "DB.e")
_QRY_BIND_C("f,", SQL_C_SLONG, "DB.f")
_QRY_BIND_C("g,", SQL_C_SSHORT, "DB.g")
_QRY_BIND_C("h,", SQL_C_SLONG, "DB.h")
} t_Db_Table;
그리고, 코딩 자동화 진행을 위한 변경내용에 대한 일예는 아래의 표 2와 같다.
코딩 자동화 진행 코딩 자동화를 위한 변경 내용 일예

데이터베이스 테이블 구조체 선언 파일
=>
코딩 자동화를 위한 선언문을 쉽게 작성하기 위한 소스코드파일
 ▲　TAB을 space로 변경
　　perl -pi -e 's/￦t/ /g' $결과파일
▲　배열([])제거
　　perl -pi -e 's/￦[.*￦]//g' $결과파일
▲　주석 제거
　　perl -pi -e 's/￦/￦/.*$//g' $결과파일
　　perl -pi -e 's/￦/￦*.*￦*￦///g' $결과파일
▲　char => _QRY_BIND_C, SQL_C_CHAR 구문으로 변경
　　perl -pi -e 's/[ ]*char[ ]*([^ ]*)[ ]*;/_QRY_BIND_C￦(￦"￦1,￦", SQL_C_CHAR, ￦"DB￦.￦1￦"￦)/g' $결과파일
▲　unsigned short => _QRY_BIND_C, SQL_C_USHORT 구문으로 변경
　　perl -pi -e 's/[ ]*unsigned[ ]*short[ ]*([^ ]*)[ ]*;/_QRY_BIND_C￦(￦"￦1,￦", SQL_C_USHORT, ￦"DB￦.￦1￦"￦)/g' $결과파일
▲　short => _QRY_BIND_C, SQL_C_SSHORT 구문으로 변경
　　perl -pi -e 's/[ ]*short[ ]*([^ ]*)[ ]*;/_QRY_BIND_C￦(￦"￦1,￦", SQL_C_SSHORT, ￦"DB￦.￦1￦"￦)/g' $결과파일
▲　unsigned long long int => _QRY_BIND_C, SQL_C_UBIGINT 구문으로 변경
　　perl -pi -e 's/[ ]*unsigned[ ]*long[ ]*long[ ]*int[ ]*([^ ]*)[ ]*;/_QRY_BIND_C￦(￦"￦1,￦", SQL_C_UBIGINT, ￦"DB￦.￦1￦"￦)/g' $결과파일
▲　long long int => _QRY_BIND_C, SQL_C_SBIGINT 구문으로 변경
　　perl -pi -e 's/[ ]*long[ ]*long[ ]*int[ ]*([^ ]*)[ ]*;/_QRY_BIND_C￦(￦"￦1,￦", SQL_C_SBIGINT, ￦"DB￦.￦1￦"￦)/g' $결과파일
▲　unsigned int => _QRY_BIND_C, SQL_C_ULONG 구문으로 변경
　　perl -pi -e 's/[ ]*unsigned[ ]*int[ ]*([^ ]*)[ ]*;/_QRY_BIND_C￦(￦"￦1,￦", SQL_C_ULONG, ￦"DB￦.￦1￦"￦)/g' $결과파일
▲　int => _QRY_BIND_C, SQL_C_SLONG 구문으로 변경
　　perl -pi -e 's/[ ]*int[ ]*([^ ]*)[ ]*;/_QRY_BIND_C￦(￦"￦1,￦", SQL_C_SLONG, ￦"DB￦.￦1￦"￦)/g' $결과파일
▲　기타
이어, 상기한 코딩 자동화 1단계에서의 실행 파일을 이용하여 아래의 코딩 자동화를 위한 선언문 파일을 작성하게 되는 것이다(S203). 여기서, 작성되는 선언문 파일의 일예는 다음과 같다.
_SQL_DEF_START 　　//선언문 시작　
_STMT_DEF_START:ST_DB_INSERT 　　　　　　　//첫번째 SQL QUERY에 대한 선언시작, 명령문 핸들러 선언
#define ST_DB_INSERT 　　　　　　　　　　　　　　　//ctag를 위한 명령문 핸들러 선언
_QUERY_CONT:"INSERT INTO DB_TABLE VALUES(" 　　　　　　　　//SQL QUERY문 정의
_QRY_BIND_P("?,", SQL_C_CHAR, "DB.a") 　　　　　　　　　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_QRY_BIND_P("?,", SQL_C_SLONG, "DB.b") 　　　　　　　　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_QRY_BIND_P("?,", SQL_C_SSHORT, "DB.c") 　　　　　　　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_QRY_BIND_P("?,", SQL_C_SLONG, "DB.d") 　　　　　　　　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_QRY_BIND_P("?,", SQL_C_SSHORT, "DB.e") 　　　　　　　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
*_QRY_BIND_P("?,", SQL_C_SLONG, "DB.f") 　　　　　　　　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_QRY_BIND_P("?,", SQL_C_SSHORT, "DB.g") 　　　　　　　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_QRY_BIND_P("?", SQL_C_SLONG, "DB.h") 　　　　　　　　　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_QUERY_CONT:")" 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//SQL QUERY문 정의
_BIND_END 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//SQL QUERY문 선언 종료　
_STMT_DEF_CONT:ST_DB_DELETE 　　　　　　　　　//두번째~마지막이전 SQL QUERY에 대한 선언, 명령문 핸들러 선언
#define ST_DB_DELETE 　　　　　　　　　　　　　　　　//ctag를 위한 명령문 핸들러 선언
_QUERY_CONT:"DELETE FROM DB_TABLE WHERE "　　　　//SQL QUERY문 정의
_QRY_BIND_P("a=?", SQL_C_CHAR, "DB.a") 　　　　　　//SQL QUERY문 정의,
SQLBindParameter를 위한 정의
_QUERY_CONT:" AND "　　　　　　　　　　　　　　　　　　　　　　　　　　//SQL QUERY문 정의
_QRY_BIND_P("b=?", SQL_C_SLONG, "DB.b") 　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_BIND_END 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//SQL QUERY문 선언 종료　
_STMT_DEF_END:ST_DB_SEARCH 　　　　　　　　　　//마지막 SQL QUERY에 대한 선언, 명령문 핸들러 선언
#define ST_DB_SEARCH 　　　　　　　　　　　　　　　　//ctag를 위한 명령문 핸들러 선언
_QUERY_CONT:"SELECT "　　　　　　　　　　　　　　　　　　　//SQL QUERY문 정의
_QRY_BIND_C("a,", SQL_C_CHAR, "DB.a") 　　//SQL QUERY문 정의 , SQLBindCol 위한 정의
_QRY_BIND_C("b,", SQL_C_SLONG, "DB.b") 　　　　　//SQL QUERY문 정의, SQLBindCol 위한 정의
_QRY_BIND_C("c,", SQL_C_SSHORT, "DB.c") 　　　　//SQL QUERY문 정의, SQLBindCol 위한 정의
_QRY_BIND_C("d,", SQL_C_SLONG, "DB.d") 　　　　　//SQL QUERY문 정의, SQLBindCol 위한 정의
_QRY_BIND_C("e,", SQL_C_SSHORT, "DB.e") 　　　　//SQL QUERY문 정의, SQLBindCol 위한 정의
_QRY_BIND_C("f,", SQL_C_SLONG, "DB.f") 　　　　　//SQL QUERY문 정의, SQLBindCol 위한 정의
_QRY_BIND_C("g,", SQL_C_SSHORT, "DB.g") 　　　　//SQL QUERY문 정의, SQLBindCol 위한 정의
_QRY_BIND_C("h", SQL_C_SLONG, "DB.h") 　　　　　　//SQL QUERY문 정의, SQLBindCol 위한 정의
_QUERY_CONT:" FROM DB_TABLE WHERE "　　　　　　　　　//SQL QUERY문 정의
_QRY_BIND_P("a=?", SQL_C_CHAR, "DB.a") 　　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_QUERY_CONT:" AND "　　　　　　　　　　　　　　　　　　　　　　　　　//SQL QUERY문 정의
_QRY_BIND_P("b=?", SQL_C_SLONG, "DB.b") 　　　　//SQL QUERY문 정의, SQLBindParameter를 위한 정의
_BIND_END 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//SQL QUERY문 선언 종료
　_SQL_DEF_END 　　//선언문 종료
이어, 코딩 자동화 2단계 파일을 실행하게 된다(S204).여기서, 코딩 자동화 2단계 파일 실행은 원본파일을 결과파일로 복사한 후에, 정규식 대체기능을 사용하여 결과파일의 내용을 변경하는 방식을 사용한다. 정규식 대체기능은 Perl, Python 등을 사용하여 구현할 수 있다. 또한 매크로의 치환기능을 사용할 수도 있다. 본 발명의 코딩 자동화 2단계 실행 방법의 일예는 Perl을 사용하여 구현하였다.또한 매크로의 치환기능도 사용하였다.
여기서, 2단계 코딩 자동화를 위한 변경 내용에 대해서는 아래의 표 3과 R같다.
코딩 자동화 진행 코딩 자동화를 위한 변경내용의 일예
코딩 자동화를 위한 선언문 파일
⇒ 명령문 핸들 할당 파일 		perl -pi -e 's/.*￦/￦/.*$//g' $결과파일
perl -pi -e 's/.*#define.*ST_.*//g' $결과파일
perl -pi -e 's/_SQL_DEF_START/#define ST_HANDLE_MAX 　100￦ntypedef enum￦n￦{￦n/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_START[^:]*:(.*)/￦1 = 0,/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_CONT[^:]*:(.*)/￦1,/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_END[^:]*:(.*)/￦1/g' $결과파일
perl -pi -e 's/.*_QUERY_CONT.*//g' $결과파일
perl -pi -e 's/.*_QRY_BIND_P.*//g' $결과파일
perl -pi -e 's/.*_QRY_BIND_C.*//g' $결과파일
perl -pi -e 's/.*_BIND_END.*//g' $결과파일
perl -pi -e 's/_SQL_DEF_END/￦} _ST_HANDLE_TYPE;/g' $결과파일
perl -pi -e 's/.*_PREPARE_CODE.*//g' $결과파일
코딩 자동화를 위한 선언문 파일
⇒SQLPrepare, SQLExecute 함수 파일		 perl -pi -e 's/.*￦/￦/.*$//g' $결과파일
perl -pi -e 's/.*#define.*ST_.*//g' $결과파일
perl -pi -e 's/_SQL_DEF_START/#include ￦"block￦.h￦"￦nextern 　struct 　block_data bD;￦nextern 　struct 　odbc_db_data 　　　dB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　request_db_data rB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　answer_db_data 　aB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　call_reference 　cR￦[MAX_THREAD_CNT￦];￦nextern 　_QUERY_PARAMETER 　　　　　t_Query￦[ST_HANDLE_MAX￦];￦n￦nint alloc_all_stmt￦(int tN, int ndX￦)￦n￦{￦nPRINT3￦(￦"￦[T%d￦] ======= alloc_all_stmt === ￦ndX￦[%d￦]====￦￦n￦", tN, ndX￦);￦n￦n/g' $결과파일
perl -pi -e 's/.*_QUERY_CONT.*//g' $결과파일
perl -pi -e 's/.*_QRY_BIND_P.*//g' $결과파일
perl -pi -e 's/.*_QRY_BIND_C.*//g' $결과파일
perl -pi -e 's/.*_BIND_END.*//g' $결과파일
perl -pi -e 's/.*_STMT_DEF_START[^:]*:(.*)/_R_PREPARE_CALL￦(￦1 ￦)/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_CONT[^:]*:(.*)/_R_PREPARE_CALL￦(￦1 ￦)/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_END[^:]*:(.*)/_R_PREPARE_CALL￦(￦1 ￦)/g' $결과파일
perl -pi -e 's/_SQL_DEF_END/return HSS_SUCCESS;￦n￦}/g' $결과파일
perl -pi -e 's/.*_PREPARE_CODE[^:]*:(.*)/￦1/g' $결과파일
코딩 자동화를 위한 선언문 파일
⇒SQL QUERY문 파일		 perl -pi -e 's/.*￦/￦/.*$//g' $결과파일
perl -pi -e 's/.*#define.*ST_.*//g' $결과파일
perl -pi -e 's/_SQL_DEF_START/#include ￦"block￦.h￦"￦nextern 　struct block_data 　　　　　bD;￦nextern 　struct 　odbc_db_data dB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　request_db_data rB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　answer_db_data 　aB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　call_reference 　cR￦[MAX_THREAD_CNT￦];￦nextern 　_QUERY_PARAMETER 　　　　　t_Query￦[ST_HANDLE_MAX￦];￦n￦nint R_Define_Query￦(￦)￦n￦{￦nint i;￦nPRINT3￦(￦"￦[M￦] ======= R_Define_Query ======￦￦n￦"￦);￦n￦nbD￦.STh_Cnt = 0;￦n￦n￦n/g' $결과파일
perl -pi -e 's/.*_QUERY_CONT[^:]*:(.*)/￦1/g' $결과파일
perl -pi -e 's/^.*_QRY_BIND_P[^￦(]*￦((.*),[^,]*,[^,)]*￦).*$/￦1/g' $결과파일
perl -pi -e 's/^.*_QRY_BIND_C[^￦(]*￦((.*),[^,]*,[^,)]*￦).*$/￦1/g' $결과파일
perl -pi -e 's/.*_BIND_END.*/￦);￦nbD￦.STh_Cnt ++;￦n￦n￦n/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_START[^:]*:(.*)/sprintf￦(t_Query￦[￦1￦]￦.name, ￦"￦1￦"￦);￦nsprintf￦(t_Query￦[￦1￦]￦.query,￦n/g' $결과파
일
perl -pi -e 's/.*_STMT_DEF_CONT[^:]*:(.*)/sprintf￦(t_Query￦[￦1￦]￦.name, ￦"￦1￦"￦);￦nsprintf￦(t_Query￦[￦1￦]￦.query,￦n/g' $결과파>일
perl -pi -e 's/.*_STMT_DEF_END[^:]*:(.*)/sprintf￦(t_Query￦[￦1￦]￦.name, ￦"￦1￦"￦);￦nsprintf￦(t_Query￦[￦1￦]￦.query,￦n/g' $결과파일perl -pi -e 's/_SQL_DEF_END/￦n￦n￦nPRINT0￦(￦"￦[MT￦] Query bD￦.STh_Cnt￦[%d￦]￦￦n￦", bD￦.STh_Cnt￦);￦n￦nfor ￦(i = 0 ; i ￦< bD￦.STh_Cnt ; i++￦)￦n￦n￦{￦nPRINT0￦(￦"￦[MT￦] t_Query￦[%d￦]￦.name 　= ￦[%s￦]￦￦n￦", i, t_Query￦[i￦]￦.name￦);￦nPRINT0￦(￦"￦[MT￦] t_Query￦[%d￦]￦.query = ￦[%s￦]￦￦n￦", i, t_Query￦[i￦]￦.query￦);￦n￦n￦}￦nreturn HSS_SUCCESS;￦n￦}/g' $결과파일
perl -pi -e 's/.*_PREPARE_CODE.*//g' $결과파일
코딩 자동화를 위한 선언문 파일
⇒SQLBindParameter, SQLBindCol 관련 함수 파일		 perl -pi -e 's/.*￦/￦/.*$//g' $결과파일
perl -pi -e 's/.*#define.*ST_.*//g' $결과파일
perl -pi -e 's/_SQL_DEF_START/#include ￦"block￦.h￦"￦nextern 　struct 　block_data 　　　　　bD;￦nextern 　struct 　odbc_db_data 　　　dB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　request_db_data rB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　answer_db_data 　aB￦[MAX_THREAD_CNT￦];￦nextern 　struct 　call_reference 　cR￦[MAX_THREAD_CNT￦];￦nextern 　_QUERY_PARAMETER 　　　　　t_Query￦[ST_HANDLE_MAX￦];￦n￦n￦n/g' $결과>파일
perl -pi -e 's/.*_QUERY_CONT.*//g' $결과파일
perl -pi -e 's/^.*_QRY_BIND_P[^￦(]*￦(.*,([^,]*),([^,)]*)￦).*$/_BIND_P￦(￦2,￦1￦)/g' $결과파일
perl -pi -e 's/^.*_QRY_BIND_C[^￦(]*￦(.*,([^,]*),([^,)]*)￦).*$/_BIND_C￦(￦2,￦1￦)/g' $결과파일
perl -pi -e 's/.*_BIND_END.*/_BIND_END￦n￦}/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_START[^:]*:(.*)/￦/￦/￦1￦n_R_EXECUTE_DEFINE￦(￦1￦)￦n_R_PREPARE_DEFINE￦(￦1￦)￦n_R_BIND_DEFINE￦(￦1￦)￦n￦{￦n_BIND_START￦(￦1￦)￦n/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_CONT[^:]*:(.*)/￦/￦/￦1￦n_R_EXECUTE_DEFINE￦(￦1￦)￦n_R_PREPARE_DE
FINE￦(￦1￦)￦n_R_BIND_DEFINE￦(￦1￦)￦n￦{￦n_BIND_START￦(￦1￦)￦n/g' $결과파일
perl -pi -e 's/.*_STMT_DEF_END[^:]*:(.*)/￦/￦/￦1￦n_R_EXECUTE_DEFINE￦(￦1￦)￦n_R_PREPARE_DEFINE￦(￦1￦)￦n_R_BIND_DEFINE￦(￦1￦)￦n￦{￦n_BIND_START￦(￦1￦)￦n/g' $결과파일
perl -pi -e 's/_SQL_DEF_END//g' $결과파일
perl -pi -e 's/.*_PREPARE_CODE.*//g' $결과파일
perl -pi -e 's/^.*_BIND_P(.*)￦"([^￦"]*)￦"(.*)(SQL_C_CHAR).*$/_BIND_P￦1￦"￦2￦"￦3￦4, SQL_VARCHAR, sizeof￦(rB￦[tN￦]￦.￦2￦)-1, rB￦[tN￦]￦.￦2, sizeof￦(rB￦[tN￦]￦.￦2￦), ￦&rB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_P(.*)￦"([^￦"]*)￦"(.*)(SQL_C_BINARY).*$/_BIND_P￦1￦"￦2￦"￦3￦4, SQL_BINARY, ￦(sizeof￦(rB￦[tN￦]￦.￦2￦)-1￦)￦/2, rB￦[tN￦]￦.￦2, sizeof￦(rB￦[tN￦]￦.￦2￦), ￦&rB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_P(.*)￦"([^￦"]*)￦"(.*)(SQL_C_SLONG).*$/_BIND_P￦1￦"￦2￦"￦3￦4, SQL_INTEGER, 0, ￦&rB￦[tN￦]￦.￦2, 0, NULL￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_P(.*)￦"([^￦"]*)￦"(.*)(SQL_C_SSHORT).*$/_BIND_P￦1￦"￦2￦"￦3￦4, SQL_SMALLINT, 0, ￦&rB￦[tN￦]￦.￦2, 0, NULL￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_P(.*)￦"([^￦"]*)￦"(.*)(SQL_C_SBIGINT).*$/_BIND_P￦1￦"￦2￦"￦3￦4, SQL_BIGINT, 0, ￦&rB￦[tN￦]￦.￦2, 0, NULL￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_P(.*)￦"([^￦"]*)￦"(.*)(SQL_C_ULONG).*$/_BIND_P￦1￦"￦2￦"￦3￦4, SQL_INTEGER, 0, ￦&rB￦[tN￦]￦.￦2, 0, NULL￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_P(.*)￦"([^￦"]*)￦"(.*)(SQL_C_USHORT).*$/_BIND_P￦1￦"￦2￦"￦3￦4, SQL_SMALLINT, 0, ￦&rB￦[tN￦]￦.￦2, 0, NULL￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_P(.*)￦"([^￦"]*)￦"(.*)(SQL_C_UBIGINT).*$/_BIND_P￦1￦"￦2￦"￦3￦4, SQL_BIGINT, 0, ￦&rB￦[tN￦]￦.￦2, 0, NULL￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_C(.*)￦"([^￦"]*)￦"(.*)(SQL_C_CHAR).*$/_BIND_C￦1￦"￦2￦"￦3￦4, SQL_VARCHAR, 0, aB￦[tN￦]￦.￦2, sizeof￦(aB￦[tN￦]￦.￦2￦), ￦&aB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_C(.*)￦"([^￦"]*)￦"(.*)(SQL_C_BINARY).*$/_BIND_C￦1￦"￦2￦"￦3￦4, SQL_BINARY, 0, aB￦[tN￦]￦.￦2, sizeof￦(aB￦[tN￦]￦.￦2￦), ￦&aB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_C(.*)￦"([^￦"]*)￦"(.*)(SQL_C_SLONG).*$/_BIND_C￦1￦"￦2￦"￦3￦4, SQL_INTEGER, 0, ￦&aB￦[tN￦]￦.￦2, 0, ￦&aB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_C(.*)￦"([^￦"]*)￦"(.*)(SQL_C_SSHORT).*$/_BIND_C￦1￦"￦2￦"￦3￦4, SQL_SMALLINT, 0, ￦&aB￦[tN￦]￦.￦2, 0, ￦&aB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_C(.*)￦"([^￦"]*)￦"(.*)(SQL_C_SBIGINT).*$/_BIND_C￦1￦"￦2￦"￦3￦4, SQL_BIGINT, 0, ￦&aB￦[tN￦]￦.￦2, 0, ￦&aB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_C(.*)￦"([^￦"]*)￦"(.*)(SQL_C_ULONG).*$/_BIND_C￦1￦"￦2￦"￦3￦4, SQL_INTEGER, 0, ￦&aB￦[tN￦]￦.￦2, 0, ￦&aB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_C(.*)￦"([^￦"]*)￦"(.*)(SQL_C_USHORT).*$/_BIND_C￦1￦"￦2￦"￦3￦4, SQL_SMALLINT, 0, ￦&aB￦[tN￦]￦.￦2, 0, ￦&aB￦[tN￦]￦.i_￦2￦)/g' $결과파일
perl -pi -e 's/^.*_BIND_C(.*)￦"([^￦"]*)￦"(.*)(SQL_C_UBIGINT).*$/_BIND_C￦1￦"￦2￦"￦3￦4, SQL_BIGINT, 0, ￦&aB￦[tN￦]￦.￦2, 0, ￦&aB￦[tN￦]￦.i_￦2￦)/g' $결과파일
BIND 관련 함수 파일
=> QUERY 입력값 PRINT 함수 파일		 perl -pi -e 's/.*￦/￦/.*$//g' $결과파일
perl -pi -e 's/^.*_BIND_P.*//g' $결과파일
perl -pi -e 's/_R_EXECUTE_DEFINE/￦/￦//g' $결과파일
perl -pi -e 's/_R_PREPARE_DEFINE/￦/￦//g' $결과파일
perl -pi -e 's/_BIND_/_PRINT_/g' $결과파일
BIND 관련 함수 파일
=> QUERY 결과값 PRINT 함수 파일		 perl -pi -e 's/.*￦/￦/.*$//g' $결과파일
perl -pi -e 's/^.*_BIND_C.*//g' $결과파일
perl -pi -e 's/_R_EXECUTE_DEFINE/￦/￦//g' $결과파일
perl -pi -e 's/_R_PREPARE_DEFINE/￦/￦//g' $결과파일
perl -pi -e 's/_BIND_/_EXPRINT_/g' $결과파일
BIND 관련 함수 파일
=> SQLFetch 관련 함수 파일
 perl -pi -e 's/.*￦/￦/.*$//g' $결과파일
perl -pi -e 's/^.*_BIND_P.*//g' $결과파일
perl -pi -e 's/^.*SQL_SMALLINT.*//g' $결과파일
perl -pi -e 's/^.*SQL_INTEGER.*//g' $결과파일
perl -pi -e 's/^.*SQL_BIGINT.*//g' $결과파일
perl -pi -e 's/_R_EXECUTE_DEFINE/￦/￦//g' $결과파일
perl -pi -e 's/_R_PREPARE_DEFINE/￦/￦//g' $결과파일
perl -pi -e 's/_BIND_/_FETCH_/g' $결과파일
PREPARE 함수 파일
=> 함수 선언 파일		 perl -pi -e 's/.*￦/￦/.*$//g' $결과파일
perl -pi -e 's/_R_PREPARE_CALL/_FDEF/g' $결과파일
perl -pi -e 's/return HSS_SUCCESS;//g' $결과파일
perl -pi -e 's/￦}//g' $결과파일
perl -pi -e 's/￦{//g' $결과파일
perl -pi -e 's/PRINT.*$//g' $결과파일
perl -pi -e 's/int.*$//g' $결과파일
perl -pi -e 's/extern.*$//g' $결과파일
perl -pi -e 's/#include.*$//g' $결과파일
perl -pi -e 's/^.*SLF_Function.*$//g' $결과파
데이터베이스 테이블 구조체 선언 코딩한 파일 => 데이터베이스 테이블 인디케이터 구조체 선언 파일 perl -pi -e 's/ char / int /g' $file2
perl -pi -e 's/ short / int /g' $file2
perl -pi -e 's/ unsigned long long int / int /g' $file2
perl -pi -e 's/ unsigned int / int /g' $file2
perl -pi -e 's/ long long int / int /g' $file2
perl -pi -e 's/typedef[ ]*struct[ ]*.*$/￦ntypedef struct/g' $file2
perl -pi -e 's/^.*￦}.*_DB(.*;)/￦} _Ln_￦1/g' $file2
상기 2단계 코딩 자동화 단계에서, 모든 결과 파일에 적용되는 매크로는 다음과 같다.
#define _R_BIND_DEFINE(aa) ￦
　　　　int R_Bind_##aa (int tN, int sndX, int ndX)
　
#define _BIND_START(aa) ￦
　　　　int Pseq, Cseq;￦
Pseq = 1;￦
Cseq = 1;￦
PRINT3("[T%d] ------- R_Bind_"#aa" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);￦
　
#define _BIND_P(aa,bb,cc,dd,ee,ff,gg) ￦
　　　　if (SQLBindParameter(dB[tN].STh[sndX][ndX], Pseq, SQL_PARAM_INPUT, bb, cc, dd, 0, ee, ff, gg) != SQL_SUCCESS)￦
{￦
　　　　PRINT2("[T%d] SQLBindParameter ERROR [%s][%s]￦n", tN, t_Query[sndX].name, aa); ￦
　　　　return HSS_FAIL;￦
} Pseq++;
　
#define _BIND_C(aa,bb,cc,dd,ee,ff,gg) ￦
　　　　if (SQLBindCol(dB[tN].STh[sndX][ndX], Cseq, bb, ee, ff, gg) != SQL_SUCCESS)￦
{￦
　　　　PRINT2("[T%d] SQLBindCol ERROR [%s][%s]￦n", tN, t_Query[sndX].name, aa); ￦
　　　　return HSS_FAIL;￦
} Cseq++;
　
#define _BIND_END return HSS_SUCCESS;
　
#define _R_PREPARE_CALL(aa) ￦
　　　　if (R_Prepare_##aa (tN, aa, ndX) != HSS_SUCCESS) { return HSS_FAIL; }
　
#define R_Execute_DB(aa,bb,cc) ￦
　　　　R_Execute_##bb(aa,bb,cc)
　
#define _R_PREPARE_DEFINE(aa)￦
　　　　int R_Prepare_##aa(int tN, int sndX, int ndX)￦
{￦
　　　　PRINT0("[T%d] ------- 　　R_Prepare_"#aa" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);￦
　　　　if (SQLAllocHandle(SQL_HANDLE_STMT, dB[tN].DBc[ndX], &dB[tN].STh[sndX][ndX]) != SQL_SUCCESS)￦
　　　　{￦
　　　　　　　　PRINT3("[T%d] SQLAllocStmt ERROR [%s][%d]!!￦n", tN, t_Query[sndX].name, ndX);￦
　　　　　　　　return HSS_FAIL;￦
　　　　}￦
　　　　PRINT0("[T%d] t_Query[%d].name 　= [%s]￦n", tN, sndX, t_Query[sndX].name);￦
　　　　PRINT0("[T%d] t_Query[%d].query = [%s]￦n", tN, sndX, t_Query[sndX].query);￦
　　　　if (SQLPrepare(dB[tN].STh[sndX][ndX], (unsigned char *)t_Query[sndX].query, SQL_NTS) != SQL_SUCCESS)￦
　　　　{￦
　　　　　　　　R_SQL_err(tN, dB[tN].DBc[ndX], dB[tN].STh[sndX][ndX], t_Query[sndX].query);￦
　　　　　　　　return HSS_FAIL;￦
　　　　}￦
　　　　return HSS_SUCCESS;￦
}
　
#define _R_EXECUTE_DEFINE(aa)￦
　　　　int R_Execute_##aa(int tN, int sndX, int ndX)￦
{￦
　　　　PRINT2("[T%d] ------- R_Execute_"#aa" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);￦
R_ExPrint_DB(tN, aa, dB[tN].ndx);￦
　　　　int ret;￦
　　　　if (R_Bind_##aa(tN, sndX, ndX) == HSS_FAIL)￦
　　　　{￦
　　　　　　　　return HSS_FAIL;￦
　　　　}￦
　　　　SQLFreeStmt(dB[tN].STh[sndX][ndX], SQL_CLOSE);￦
　　　　ret = SQLExecute(dB[tN].STh[sndX][ndX]);￦
　　　　PRINT2("[T%d] SQLExecute [%s][%d]￦n", tN, t_Query[sndX].name, ndX);￦
　　　　if ((ret == SQL_SUCCESS) || (ret == SQL_SUCCESS_WITH_INFO))￦
　　　　{ return HSS_SUCCESS; }￦
　　　　else if (ret == SQL_NO_DATA_FOUND) { return HSS_NONE; }￦
　　　　else { return HSS_FAIL; }￦
　　　　return HSS_SUCCESS;￦
}
　
#define R_Print_DB(aa,bb,cc) ￦
　　　　R_Print_##bb(aa,bb,cc)
　
#define _R_PRINT_DEFINE(aa) int R_Print_ ##aa (int tN, int sndX, int ndX)
　
#define _PRINT_START(aa)
#define _PRINT_C(aa,bb,cc,dd,ee,ff,gg)
#define _PRINT_P(aa,bb,cc,dd,ee,ff,gg)
　
#define _PRINT_END ￦
　　　　return HSS_SUCCESS;
　
#define R_ExPrint_DB(aa,bb,cc) ￦
　　　　R_ExPrint_##bb(aa)
　
#define _R_EXPRINT_DEFINE(aa) int R_ExPrint_ ##aa (int tN)
　
#define _EXPRINT_START(aa)
　
#define _EXPRINT_C(aa,bb,cc,dd,ee,ff,gg)
　
#define _EXPRINT_P(aa,bb,cc,dd,ee,ff,gg) ￦
　　　　R_Print_##bb (aa, ee, gg);
　
#define _EXPRINT_END ￦
　　　　return HSS_SUCCESS;
#define R_Print_SQL_C_SLONG(aa,bb,cc) ￦
　　　　PrintLog(DBG_LEVEL3, "[T%d] %-30s = [%ld]￦n", tN, 　aa, *bb);
　
#define R_Print_SQL_C_ULONG(aa,bb,cc) ￦
　　　　PrintLog(DBG_LEVEL3, "[T%d] %-30s = [%ld]￦n", tN, 　aa, *bb);
　
#define R_Print_SQL_C_SSHORT(aa,bb,cc) ￦
　　　　PrintLog(DBG_LEVEL3, "[T%d] %-30s = [%d]￦n", tN, 　aa, *bb);
　
#define R_Print_SQL_C_USHORT(aa,bb,cc) ￦
　　　　PrintLog(DBG_LEVEL3, "[T%d] %-30s = [%d]￦n", tN, 　aa, *bb);
　
#define R_Print_SQL_C_SBIGINT(aa,bb,cc) ￦
　　　　PrintLog(DBG_LEVEL3, "[T%d] %-30s = [%ld]￦n", tN, 　aa, *bb);
　
#define R_Print_SQL_C_UBIGINT(aa,bb,cc) ￦
　　　　PrintLog(DBG_LEVEL3, "[T%d] %-30s = [%ld]￦n", tN, 　aa, *bb);
　
#define R_Print_SQL_C_CHAR(aa,bb,cc) ￦
　　　　PrintLog(DBG_LEVEL3, "[T%d] %-30s = [%s][%d]￦n", tN, 　aa, bb, *cc);
　
#define R_Print_SQL_C_BINARY(aa,bb,cc) ￦
　　　　if (*cc >　0) ￦
hexadump(aa, bb, *cc);
　
#define _FDEF(aa)￦
　　　　int R_Execute_##aa(int, int, int);￦
int R_Prepare_##aa(int, int, int);￦
int R_Print_##aa(int, int, int);￦
int R_ExPrint_##aa(int);￦
int R_Bind_##aa(int, int, int);￦
int R_Fetch_##aa(int, int, int);
　
#define R_Fetch_DB(aa,bb,cc) ￦
　　　　R_Fetch_##bb(aa,bb,cc)
　
#define _R_FETCH_DEFINE(aa) int R_Fetch_ ##aa (int tN, int sndX, int ndX)
　
#define _FETCH_START(aa) ￦
　　　　PRINT3("[T%d] ------- R_Fetch_"#aa" -------[%s][%d]￦n", tN, t_Query[sndX].name, ndX);
　
#define _FETCH_C(aa,bb,cc,dd,ee,ff,gg) ￦
　　　　ee[0] = '￦0';
#define _FETCH_END ￦
　　　　return 　SQLFetch(dB[tN].STh[sndX][ndX]);
상기한 바와 같은 본 발명에 따른 ODBC(Open Database Connectivity) 프로그램 자동 코딩 방법은 코딩의 자동화로 인하여 구조체의 선언과 코딩 자동화를 위한 선언문 파일만 코딩하면 되기 때문에 코딩양이 감소할 수 있으며, 코딩의 자동화로 인하여 코딩양이 감소하여 코딩에 소요되는 시간이 감소하는 것이다.
또한, 코딩의 자동화로 인하여 자동화 부분에 대하여 실수로 인한 코딩에러가 없기 때문에 에러 발생율이 감소되며, 에러 발생시 구조체와 코딩 자동화를 위한 선언문 파일만 확인하면 되기 때문에 에러 보완에 걸리는 시간이 감소될 수 있는 것이다.

Claims (10)

  1. ODBC(Open Database Connectivity) 프로그램 자동 코딩 방법에 있어서,
    데이터베이스에 저장할 데이터의 타입과 길이를 선언하기 위한 헤더 파일을 코딩하는 데이터베이스 테이블 구조체 선언 코딩단계;
    상기 데이터베이스 테이블 구조체 선언 코딩한 파일을 입력 파일로 하여 코딩 자동화를 위한 선언문을 쉽게 작성하기 위한 소스 코드 파일을 생성하는 제1 코딩 자동화 단계;
    상기 생성된 소스 코드 파일을 이용하여 2차 코딩 자동화를 위한 선언문 파일을 작성하는 단계;
    상기 작성된 선언문 파일들을 입력 파일들로 하여 새로운 코딩 자동화를 위한 결과 파일들을 실행하는 제2 코딩 자동화 단계를 포함하는 ODBC 프로그램 자동 코딩 방법
  2. 제1항에 있어서,
    상기 제1 코딩 자동화 단계는, 원본파일을 결과 파일로 복사한 후, 정규식 대체 기능을 사용하여 결과 파일의 내용을 변경하는 방식을 사용하는 ODBC 프로그램 자동 코딩 방법.
  3. 제2항에 있어서,
    상기 정규식 대체 기능은 Perl, Python을 사용하여 구현하는 ODBC 프로그램 자동 코딩 방법.
  4. 제2항에 있어서,
    상기 정규식 대체 기능은 매크로 치환 기능을 사용하는 ODBC 프로그램 자동 코딩 방법.
  5. 제1항에 있어서,
    상기 선언문 파일을 작성하는 단계는 한개의 SQL QUERY당 한개의 명령어 핸들러를 사용하는 ODBC 프로그램 자동 코딩 방법.
  6. 제1항에 있어서,
    상기 제2 코딩 자동화 단계에서의 입력 파일은 코딩 자동화를 위한 선언문 파일, BIND 관련 함수 파일, PREPARE 함수 파일, 데이터베이스 테이블 구조체 선언 코딩한 파일중 적어도 하나 이상의 파일인 ODBC 프로그램 자동 코딩 방법.
  7. 제1항에 있어서,
    상기 제2 코딩 자동화 단계에서의 결과 파일은 명령문 핸들 할당 파일, SQLPrepare, SQLExcute 함수 파일, SQL QUERY문 파일, SQLBindParameter, SQLBindCol 관련 함수 파일, QUERY 입력값 PRINT 함수 파일, QUERY 결과값 PRINT 함수 파일, SQLFetch 관련 함수 파일, 함수 선언 파일, 데이터베이스 테이블 인디케이터 구조체 선언 파일 중 적어도 하나 이상의 파일인 ODBC 프로그램 자동 코딩 방법.
  8. 제1항에 있어서,
    상기 제2 코딩 자동화 단계는 원본파일을 결과 파일로 복사한 후, 정규식 대체 기능을 사용하여 결과 파일의 내용을 변경하는 방식을 사용하는 ODBC 프로그램 자동 코딩 방법.
  9. 제8항에 있어서,
    상기 정규식 대체 기능은 Perl, Python을 사용하여 구현하는 ODBC 프로그램 자동 코딩 방법.
  10. 제8항에 있어서,
    상기 정규식 대체 기능은 매크로 치환 기능을 사용하는 ODBC 프로그램 자동 코딩 방법.
KR1020120118563A 2012-10-24 2012-10-24 Ｏｄｂｃ프로그램 자동 코딩 방법 KR20140052459A (ko)

Priority Applications (1)

Application Number Priority Date Filing Date Title
KR1020120118563A KR20140052459A (ko) 2012-10-24 2012-10-24 Ｏｄｂｃ프로그램 자동 코딩 방법

Applications Claiming Priority (1)

Application Number Priority Date Filing Date Title
KR1020120118563A KR20140052459A (ko) 2012-10-24 2012-10-24 Ｏｄｂｃ프로그램 자동 코딩 방법

Publications (1)

Publication Number Publication Date
KR20140052459A true KR20140052459A (ko) 2014-05-07

Family

ID=50885689

Family Applications (1)

Application Number Title Priority Date Filing Date
KR1020120118563A KR20140052459A (ko) 2012-10-24 2012-10-24 Ｏｄｂｃ프로그램 자동 코딩 방법

Country Status (1)

Country Link
KR (1) KR20140052459A (ko)

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR102237877B1 (ko) 2019-12-06 2021-04-09 주식회사 오픈드래프트 실시간 협업지원 지능형 소프트웨어 자동 개발 시스템 및 그 방법

Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2005004737A (ja) * 2003-06-10 2005-01-06 Microsoft Corp 動的ランタイム環境でタグ付き型を用いるシステム及び方法
JP2005158030A (ja) * 2003-08-28 2005-06-16 Ricoh Co Ltd プログラムコード自動生成方法および装置、並びにコンピュータ可読媒体
KR20080072768A (ko) * 2006-12-29 2008-08-07 엘에스산전 주식회사 계량기 프로그램 설계 방법
KR100908889B1 (ko) * 2009-03-03 2009-07-23 (주) 바인젠 네트워크 상의 텍스트 메시지를 처리하는 소스 코드 생성 방법 및 그 장치

Patent Citations (4)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
JP2005004737A (ja) * 2003-06-10 2005-01-06 Microsoft Corp 動的ランタイム環境でタグ付き型を用いるシステム及び方法
JP2005158030A (ja) * 2003-08-28 2005-06-16 Ricoh Co Ltd プログラムコード自動生成方法および装置、並びにコンピュータ可読媒体
KR20080072768A (ko) * 2006-12-29 2008-08-07 엘에스산전 주식회사 계량기 프로그램 설계 방법
KR100908889B1 (ko) * 2009-03-03 2009-07-23 (주) 바인젠 네트워크 상의 텍스트 메시지를 처리하는 소스 코드 생성 방법 및 그 장치

Cited By (1)

* Cited by examiner, † Cited by third party
Publication number Priority date Publication date Assignee Title
KR102237877B1 (ko) 2019-12-06 2021-04-09 주식회사 오픈드래프트 실시간 협업지원 지능형 소프트웨어 자동 개발 시스템 및 그 방법

Similar Documents

Publication Publication Date Title
CN102521254B (zh) 异构数据库的统一访问方法
US8239369B2 (en) Method and apparatus for enhancing performance of database and environment thereof
US20100280990A1 (en) Etl for process data warehouse
US8856738B2 (en) System and method for transplanting source code
US8463818B2 (en) Single command data warehouse table update
CN105677323A (zh) 一种自动生成数据库操作层代码的方法
US8346773B2 (en) Product classification system
WO2017041578A1 (zh) 一种获取数据库变更信息的方法和装置
CN111966738A (zh) 一种通过选择前端配置自动实现后端编程的系统
EP2251802A1 (en) Method and program for generating a subset of data from a database
CN109271199B (zh) 一种用于数据库持续集成与脚本文件管理的方法及系统
CN111125067A (zh) 数据维护方法及装置
KR20140052459A (ko) Ｏｄｂｃ프로그램 자동 코딩 방법
CN104636471A (zh) 一种程序代码的查找方法及装置
CN115114325B (zh) 数据查询方法、装置、电子设备以及存储介质
CN114153461A (zh) 一种脚本处理方法、装置、电子设备及存储介质
US6925630B1 (en) Method for generating code for processing a database
CN112631567A (zh) 一种生成数据库操作文件的方法及装置
CN109241158B (zh) 用于规则管理的数据源自定义方法以及装置
CN112632177A (zh) 一种数据装载作业的生成方法
CN111723104A (zh) 一种数据处理系统中语法分析的方法、装置及系统
US20130218875A1 (en) Table-driven enterprise-wide data integration
CN110851533A (zh) 跨异构数据库的数据同步方法、装置、介质及电子设备
CN114356302B (zh) 一种基于Gremlin语言的持久层优化方法
KR20130119393A (ko) 관계형 데이터베이스에서 익스프레스 무결성 제약조건 확인 방법

Legal Events

Date Code Title Description
N231 Notification of change of applicant
A201 Request for examination
E902 Notification of reason for refusal
E601 Decision to refuse application