간단한 SQL 툴입니다.

 

하지만 어느정도 SQL을 사용할 수 있는 개발자가 되어야 쓸테니 SQL_ADVANCE로 프로그램명을 적었습니다.
용도는 개발자가 test/ibatis/c#용 쿼리를 만들때 시간을 단축하거나 insert 문 형태로 쿼리문 백업,
DB tool 이 없는 환경에서 간단한 작업용 입니다.

 

 아래의 스크린샷과 간단한 기능 설명을 참고 하여 사용 하시면 됩니다.
당연히 프리웨어 이며,다른 곳에 포스팅 하실때에는 출처 표시만 하면 됩니다.

 

It is a simple SQL tool.


However, I gave the name of the program to SQL_ADVANCE developers that use
SQL to some extent because write necessary.
reduce the time when the developers to
create a query of test / ibatis / c #, in an environment not query statement, backup,
and DB tool in the form of insert statements, applications, is a simple task.


It is referred to a simple function describes the screen shot below, please use.
Is a freeware of course.

 

 

SQL_ADVANCE.exe

 

 

Open connect String : load saved database server connect string (데이터 베이스 서버 연결 문자열을 불러옵니다.)
Open select SQL : load saved select query string  (이전에 저장한 select 쿼리를 불러옵니다.)
Open result SQL : load result query string (이전에 저장한 결과 표시부분의 쿼리를 불러옵니다.)
Save connect String : save database server connect string ( 데이터 베이스 연결 문자열을 저장합니다.)
Save connect String : save select query string
Save connect String : save result query string
Hide checkbox : Server connect string hide/show
select button : select query excute
connect Type : Connection type select (OLE/MSSQL)
Don't show grid checkbox : not drowing grid table. save drowing time.
ConvertSQLType : select query result to selected query type (insert/update/delete)
Convert Line : converted range
first - fist line only
select - first line selected (requirement grid table)
multi selected - multi selected (requirement grid table)
allrows - select query result all rows.
Last - last line only
convert button - select query result convert
excute button - result area querys excute

 

 

 

by Tomoya 2013.08.05 14:54

C# 로 AES 알고리즘 함수 암.복호화 작성후
CLR 로 덮어 씌워 DB에서 실행.

데이터베이스 권한 수준 안전에서도 잘 돌아간다.

AES 알고리즘 부분은 구글에서 검색시 여러가지 방법으로 구현한 것들이 많고(ex: http://bullpeng.tistory.com/61)
.net framework 3.5 이상버전(VS2008이상)에서 System.Security.Cryptography 에 라이브러리가 잘 정의되어 있다.

CLR 사용해서 키를 정해두고 중요개인정보는 암호화해서 저장해두면 웹서버/디비서버 다 털지 않는한 DB만 가져가선 볼 수 없다.
by Tomoya 2011.12.08 17:00

참 오랜만에 글 쓰는듯..
7월엔 놀고 8월엔 공부하고,9월엔 공부하면서 "슬슬 결과물을 하나는 내보자." 생각하면서 추석뒤에 1차로 뽑아낸 결과물입니다.

아직 초기 테스트 버전이기에 정말 심플합니다.

기능중 일부만 소개 할 것 이기에 2가지만 넣었습니다.

*이 프로그램을 테스트하기 위해선 MS SQL SERVER 2005 EXPRESS 버전 이상이 필요합니다.
필자의 개발환경및 테스트 환경은 SQL SERVER 2008 R2 EXPRESS 32bit(winxp)/64bit(win7) 이었습니다.

먼저 이 부분은 CLR 설정 부분입니다.
*CLR을 활성화 하신분이면 넘어가셔도 됩니다.
*따로 적거나 하지 않으셔도 아래 첨부된 sql 파일에 주석까지 다 달려 있으니 그대로 해보시면 됩니다.

--CLR을 활성화 하는 설정입니다.
SP_CONFIGURE 'CLR ENABLED',1
RECONFIGURE WITH OVERRIDE
GO

--CLR을 활성화 합니다.
SP_CONFIGURE
GO

 아랫 부분은 프로그램 등록 및 테스트 입니다.
*편의상 C드라이브 루트 밑에 위치시켰고 편한쪽에 위치 시키시면 됩니다.

 --현재 DB에 어셈블리로 등록합니다.
CREATE ASSEMBLY ASM_GetDBSystemInfo FROM 'C:\GetDBSystemInfo.dll'
WITH PERMISSION_SET = UNSAFE
go

--등록된 어셈블리중 시스템정보표시 프로시저(현재하드디스크용량만 표시)를 등록합니다
CREATE PROC usp_clr_GetSysInfo
AS EXTERNAL NAME ASM_GetDBSystemInfo.StoredProcedures.usp_clr_GetSysInfo
GO

--등록된 시스템정보 표시 프로시저를 호출합니다.(테스트)
EXEC usp_clr_GetSysInfo
GO

--DB 시스템에 커맨드 명령을 날리고 결과를 반환하는 테이블 반환 함수를 지정합니다.
CREATE FUNCTION usp_command(@input NVARCHAR(512))
RETURNS TABLE
(cammand_Result NVARCHAR(512))
AS
EXTERNAL NAME ASM_GetDBSystemInfo.StoredProcedures.usp_command
GO

--DB 시스템에 커맨드 명령을 날려 IP정보를 확인 합니다.
SELECT * FROM usp_command('ipconfig /all');

간단하죠?
이제 usp_command('커맨드') 를 이용해서 간단히 DB시스템을 확인하고 제어 할수 있게 되었습니다.
작성 하실때 CREATE FUNCTION usp_command 부분에서 이름을 다르게 정하시면 그 이름으로도 사용 가능합니다.
또한 매니지먼트 스튜디오에서 DB->프로그래밍기능->어셈블리/함수 쪽에서 유저권한같은 세밀한 설정도 가능합니다.


* 이 프로그램은 프리웨어이며 상업적 이용도 가능합니다. 단 컨텐츠 무단 변경/재배포는 불가능 합니다.
또한 이 프로그램을 사용함으로서 발생 할 수 있는 문제에 대해서 책임지지 않습니다.

10.5일 추가사항.
현재 dll파일이 인증서 없이 제작 되어 있어 SYSADMIN 관리자 권한하에 TRUSTWORTHY ON 설정이
어셈블리 등록전에 필요합니다.
ALTER DATABASE ASNS SET TRUSTWORTHY ON;
를 사용하면 사용가능합니다.(인증서는 향후 추가 해보겠습니다)

by Tomoya 2011.09.23 13:45

TB_A 의 데이터는 약 500만건
조건 테스트시 사용한 대상 건수는 10만건~60만건 이었습니다.
테스트 DB 용량은 5GB입니다.
대상 DB는 SQL2005 STD SP4 입니다.

결과는 보시다시피 RANK사용시는 미세한 차이를 보이고
ROW_NUMBER 사용시는 10배 가얀 차이를 보입니다.
가장 최근 결과가 필요하기에 ID DESC를 넣어야 했기에
ID ASC 시 ROW_NUMBER가 효율이 좋지만
RANK로 처리했습니다.
또한 현재는 rank_num을 매김에도 불구하고 bottom 값을 추가로 가져올 방법이 적당히 안보여
카운트를 추가로 처리하고 있습니다.(실제 카운트를 넣어도 0.1초 정도만 추가되는걸 확인 했습니다만..)
상황에 따라 행 번호가 필요한 부분 에서는 rank_num 매기는 서브쿼리 부분을 테이블 x로 처리해서
rank_num을 넘겨 처리하고 있습니다.

기본 쿼리 형태

select 데이터
FROM TB_A  a, tb_B b
where a.id in (
 select a.id from
  (select a.ID,ROW_NUMBER() OVER (ORDER BY a.ID) as rowsnum
   FROM TB_A a
   where 검색조건 ) a
 where a.rowsnum between 10 and 20)
 and 테이블조인조건

위의 상태에서 정렬 방법 변경 테스트

1번 ROW_NUMBER() OVER (ORDER BY a.ID)

(11개 행이 영향을 받음)
테이블 'TB_B'. 검색 수 0, 논리적 읽기 수 22, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.
테이블 'TB_A'. 검색 수 1, 논리적 읽기 수 14829, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.

(12개 행이 영향을 받음)

SQL Server 실행 시간:
   CPU 시간 = 422ms, 경과 시간 = 435ms.

2번 ROW_NUMBER() OVER (ORDER BY a.ID DESC)

(11개 행이 영향을 받음)
테이블 'TB_B'. 검색 수 0, 논리적 읽기 수 22, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.
테이블 'TB_A'. 검색 수 1, 논리적 읽기 수 143214, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.

(12개 행이 영향을 받음)

SQL Server 실행 시간:
   CPU 시간 = 5219ms, 경과 시간 = 5209ms.

3번 RANK() OVER (ORDER BY a.ID)

(11개 행이 영향을 받음)
테이블 'TB_B'. 검색 수 1, 논리적 읽기 수 2, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.
테이블 'TB_A'. 검색 수 5, 논리적 읽기 수 3091, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.
테이블 'Worktable'. 검색 수 0, 논리적 읽기 수 0, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.
테이블 'Worktable'. 검색 수 0, 논리적 읽기 수 0, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.

(16개 행이 영향을 받음)

SQL Server 실행 시간:
   CPU 시간 = 1281ms, 경과 시간 = 819ms.

4번 RANK() OVER (ORDER BY a.ID DESC)

(11개 행이 영향을 받음)
테이블 'TB_B'. 검색 수 1, 논리적 읽기 수 2, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.
테이블 'TB_A'. 검색 수 5, 논리적 읽기 수 3091, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.
테이블 'Worktable'. 검색 수 0, 논리적 읽기 수 0, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.
테이블 'Worktable'. 검색 수 0, 논리적 읽기 수 0, 물리적 읽기 수 0, 미리 읽기 수 0, LOB 논리적 읽기 수 0, LOB 물리적 읽기 수 0, LOB 미리 읽기 수 0.

(16개 행이 영향을 받음)

SQL Server 실행 시간:
   CPU 시간 = 1343ms, 경과 시간 = 848ms.

현재 사용 쿼리

SELECT 데이터,전체카운트  
FROM tb_A a (NOLOCK) LEFT OUTER JOIN tb_E e (NOLOCK) on (a.E_id = e.E_id ) 
,tb_C c (NOLOCK)  ,tb_B b (NOLOCK),tb_D d (NOLOCK) ,
( SELECT count(*) as cnt   FROM TB_A
WHERE 조건) y 
WHERE a.id in (
 SELECT x.id
 FROM  (
  SELECT ID,RANK() OVER (ORDER BY ID DESC) as rank_num 
  FROM TB_A
  WHERE 조건
 ) x 
 WHERE x.rank_num BETWEEN (20*0)+1 AND (20*1) -- 페이징 부분

AND 조인조건
ORDER BY a.id DESC

트위터 @ 성대중(SQL SERVER MVP) 님의 조언을 받아 TOP TOP 방식으로 변경해 보았다.

변경 쿼리

SELECT 데이터

FROM 대상테이블s , 대상카운트 ,

(SELECT TOP 표시수 x.id

         FROM  (

                  SELECT TOP 표시수*(페이지번호+1) ID 

                  FROM 대상테이블

                  WHERE 조건

                  ORDER BY ID DESC

         ) x  ORDER BY ID) z

WHERE a.id = z.id

AND 조인조건

ORDER BY a.id DESC

비용 비교
RANK
CPU 시간 = 63ms, 경과 시간 = 76ms.
CPU 시간 = 63ms, 경과 시간 = 76ms.
CPU 시간 = 62ms, 경과 시간 = 76ms.

CPU 시간 = 672ms, 경과 시간 = 500ms.
CPU 시간 = 703ms, 경과 시간 = 457ms.
CPU 시간 = 751ms, 경과 시간 = 477ms.

TOP TOP
CPU 시간 = 15ms, 경과 시간 = 19ms.
CPU 시간 = 15ms, 경과 시간 = 18ms
CPU 시간 = 16ms, 경과 시간 = 17ms.


CPU 시간 = 297ms, 경과 시간 = 475ms.
CPU 시간 = 375ms, 경과 시간 = 468ms.
CPU 시간 = 343ms, 경과 시간 = 486ms.

 ..서브트리 코스트에선 36대 0.8로 1/50로 줄어 든것을 확인 했는데..10만건 테스트 시 시피유,I/O 타임이 생각보다 줄지 않았다.
왜 일까..한번 고민해봐야 할듯..그리고 대상건을 30만건으로 늘려 비교시엔 타임이 오히려 RANK가 더 좋게
나오는 현상도 원인을 찾아 봐야 할듯..

by Tomoya 2011.06.08 09:44
회사에서 제작하다 좀 안 맞는 부분이 있어 버려진 프로그램..
항상 켜져 있어야 되는 프로그램이 있을 경우 사용 하면 된다.
항상 죽이고 싶은 프로세스가 있다면 die로 두고 꺼도 좋지만..그런 경우 있으려나..;
작업 추가로 등록하고 해당 작업 명 더블클릭시 수정/삭제 가능

작업추가로 등록하고 윈도우 시작시 감시 프로그램을 자동으로 시작하게 하고 싶으면 서비스 등록해두고
서비스 삭제하면 윈도우즈 시작시 자동 실행하지 않는다.

종료시 트레이에서 우클릭 종료해야 꺼짐.(전체화면에서 종료 버튼 누를시 트레이 최소화)

DB체크 기능이나 이상시 이메일 발송기능은 제외 되었음.
이이콘은 5분도 안들여 직접 만들었기에..보기 싫음..
(따로 만들어서 원하시는 분 있으면 넣어 드릴수도..)

프리웨어로 누구나 사용가능합니다.



by Tomoya 2011.06.07 09:06

Datetime에 Null이 제대로 안 들어가다보니 생각 난 꽁수..
그렇다고 매개변수 주고 SQL에 이름넣지 않아도 에러 나고..

날짜 부분 체크 여부에 따라 기존처럼
DAO.MSSQL_Excute_Query(DataControl.GetConnstr(), sql, names)로 처리하려하면
무려 16개의 케이스를 제작해서 작성해야 하지만..

bool[] pass 하나 더 만들어 처리부에 if(!pass[i]) sc.Parameters.AddWithValue(names[i], values[i]); 로 바꿔 버렸다..
16번 노가다 귀찮으니 별 꽁수를 다 부리는 듯..;

그냥 다음에는 DAO.MSSQL_Excute_Query(DataControl.GetConnstr(), sql, names, values);
names,values를 ArratList[]로 처리하고
아래와 같이 ((Bool값)?A:B) 같은 처리로 SQL문 처리한후 command변경후 일괄 한큐 정리 메소드도 만들어 둬야 겠다.

 object[] values = new object[15];
                values[0] = a;
                values[1] = b;
...
values[5] = null;
                if (DELIVERY_DATE_checkBox.Checked)
                {
                    values[5] = DELIVERY_DATE_dateTimePicker.Value;
                }
                values[6] = null;
                if (EXCUTE_DATE_checkBox.Checked)
                {
                    values[6] = EXCUTE_DATE_dateTimePicker.Value;
                }
                values[7] = null;
                if (TASK_START_DATE_checkBox.Checked)
                {
                    values[7] = TASK_START_DATE_dateTimePicker.Value;
                }
                values[8] = null;
                if (TASK_END_DATE_checkBox.Checked)
                {
                    values[8] = TASK_END_DATE_dateTimePicker.Value;
                }
...

string[] names = new string[]
                    {
                        "@A", "@B"...                    };

bool[] pass = new bool[15];
                for (int i = 0; i < 15; i++)
                {
                    if (i < 5)
                    {
                        pass[i] = false;
                    }
                    else if (i > 5)
                    {
                        pass[i] = false;
                    }
                    else
                    {
                        if (i == 5) pass[i] = !DELIVERY_DATE_checkBox.Checked;
                        else if (i == 6) pass[i] = !EXCUTE_DATE_checkBox.Checked;
                        else if (i == 7) pass[i] = !TASK_START_DATE_checkBox.Checked;
                        else if (i == 8) pass[i] = !TASK_END_DATE_checkBox.Checked;
                    }

                }

string sql = "...,"+
                   (DELIVERY_DATE_checkBox.Checked?"DELIVERY_DATE = @DELIVERY_DATE,":"")+
                   (EXCUTE_DATE_checkBox.Checked?"EXCUTE_DATE = @EXCUTE_DATE,":"") +
                   (TASK_START_DATE_checkBox.Checked?"TASK_START_DATE = @TASK_START_DATE,":"")+
                   (TASK_END_DATE_checkBox.Checked?"TASK_END_DATE = @TASK_END_DATE,":"")+
                   "...";

state = DAO.MSSQL_Excute_Query(DataControl.GetConnstr(), sql, names, values,pass);

'공부 > MS' 카테고리의 다른 글

현재 고민중인 페이징 쿼리(추가)  (0) 2011.06.08
프로세스 감시  (3) 2011.06.07
날이 갈수록 늘어나는 잔 머리..;  (0) 2010.03.03
C# 에서 파일을 리소스에 넣어 처리하기.  (0) 2010.02.08
최근 작성한 C#2.0 DAO  (0) 2009.07.20
PC 데이터 단위 변환  (2) 2009.07.18
by Tomoya 2010.03.03 10:53

가끔 아이콘들을 DLL에 집어 넣어 처리하길 요구 할 수가 있다.
EXE야 간단하게 컴파일시 프로젝트매니저에서 설정하면 그만이지만
DLL에 집어넣은걸 불러 오는 것은 몇 라인을 추가해서 불러 와야 한다.
아래 리소스파일은 기본 리소스파일을 작성할때 기준이다.
만일 그냥 프로젝트에서 리소스 파일을 추가한다면
<프로젝트명>.Properties.Resources 대신 <프로젝트명>.<리소스파일명>으로 작성해야 한다.

<이미지(PNG)파일을 BitmapImage로 처리>
ResourceManager rm = new ResourceManager("<프로젝트명>.Properties.Resources", System.Reflection.Assembly.GetExecutingAssembly());
            Bitmap bitmapimg = (Bitmap)rm.GetObject("이미지명");
//예를들어 Myimg.png를 읽어 리소스 매니저에서Myimg1이 되었다면 Myimg1을 적어야 한다.

            Image img = (Image)bitmapimg;
            MemoryStream ms = new MemoryStream();
            img.Save(ms, System.Drawing.Imaging.ImageFormat.Png);

BitmapImage largeImage = new BitmapImage();
            largeImage.BeginInit();
            largeImage.DecodePixelHeight = 32;//사이즈를 지정해 주고 싶다면 셋팅한다
            largeImage.DecodePixelWidth = 32;//사이즈를 지정해 주고 싶다면 셋팅한다
            largeImage.StreamSource = ms;//uriImage; //urisourse로 불어온다면 간단하지만 리소스를 불러 올때는
//위와같은 단계가 필요하다.
            largeImage.EndInit();

<아이콘(ICO) 파일 처리>
ResourceManager rm = new ResourceManager("ConvertWallType.Properties.Resources", System.Reflection.Assembly.GetExecutingAssembly());
                    Icon iconimg = (Icon)rm.GetObject("logo");
                    ui.Icon = iconimg;

'공부 > MS' 카테고리의 다른 글

프로세스 감시  (3) 2011.06.07
날이 갈수록 늘어나는 잔 머리..;  (0) 2010.03.03
C# 에서 파일을 리소스에 넣어 처리하기.  (0) 2010.02.08
최근 작성한 C#2.0 DAO  (0) 2009.07.20
PC 데이터 단위 변환  (2) 2009.07.18
C# 2.0 개선형 DB 데이터 받아오기  (0) 2009.04.13
by Tomoya 2010.02.08 13:36


내부DB(Inner DB)는 MS ACCESS 파일(.mdb)
외부DB(External DB)는  MS SQL 2005 SERVER EXPRESS 를 기준으로 작성한 파일이다.
내부 DB를 사용 하기 위해선 파라미터의 names부분을 (:이름) 배열 형태로 작성하면 되고,
외부 DB를 사용 하기 위해선 파라미터의 names부분을 (@이름) 배열 형태로 작성하면 된다.

내부DB는 오피스 2003 이상 버전이 있다면 DB생성 및 편집이 가능하고,
외부DB는 상업적 이용도 무료다.(단, EXPRESS 에디션은 기능에 약간의 제한이 있긴하다.그러나 테스트 구축이나
작은 사이트를 운영하는데는 큰 무리 없다고 생각 된다.)

각각 constr과 ext_constr에 컨넥션 부분의 기본정보를 작성하고,
테이블이 필요 하다면 gettable,ext_gettable을 사용하고,
데이터만 필요 하다면 GetDatas,Ext_GetDatas를 사용하면 된다.



using System;
using System.Collections.Generic;
using System.Text;
using System.Data.OleDb;
using System.Data.Odbc;
using System.Data.Sql;
using System.Data.SqlClient;
using System.Data;
using System.IO;
using System.Collections;

namespace DUAL_DAO
{
    class DAO
    {
        static string constr = @"Provider=Microsoft.Jet.OLEDB.4.0;Data Source=(accessDB경로);Persist Security Info=True";

        static OleDbDataReader rd;

        static OleDbDataAdapter da;

        static SqlDataReader sdr;

        static SqlDataAdapter sda;

        static string ext_constr = @"Data Source=(DB서버URL);User ID=(ID);Password=(PASSWORD)";

        DAO()
        {
           
        }

        public static bool connect_test()
        {
            bool state = false;
            SqlConnection conn = new SqlConnection(ext_constr);
            try
            {
                conn.Open();
                state = true;
                conn.Close();
            }
            catch (Exception)
            {
                state = false;
                if (conn.State == ConnectionState.Open) conn.Close();
            }
            return state;
        }

        public static DataTable gettable(string sql)
        {
            DataSet ds = new DataSet();

            da = new OleDbDataAdapter(sql,new OleDbConnection(constr));

            da.Fill(ds);

            return ds.Tables[0];
        }

        public static DataTable Ext_gettable(string sql)
        {
            DataSet ds = new DataSet();

            sda = new SqlDataAdapter(sql, new SqlConnection(ext_constr));

            sda.Fill(ds);

            return ds.Tables[0];
        }

        public static DataTable gettable(string sql,string[] names, object[] values)
        {
            DataSet ds = new DataSet();

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    odc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            odc.Connection.Open();

            da = new OleDbDataAdapter(odc);

            da.Fill(ds);

            return ds.Tables[0];
        }

        public static DataTable Ext_gettable(string sql, string[] names, object[] values)
        {
            DataSet ds = new DataSet();

            SqlCommand sc = new SqlCommand(sql, new SqlConnection(ext_constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    sc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            sc.Connection.Open();

            sda = new SqlDataAdapter(sc);

            sda.Fill(ds);

            return ds.Tables[0];
        }

        public static DataTable ExtGetTable(string sql,string[] cnames)
        {
            DataTable dt = new DataTable();

            string[][] datas = null;

            SaveLogs(sql, cnames);

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            odc.Connection.Open();

            rd = odc.ExecuteReader();

            try
            {
                if (rd.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = rd.FieldCount;

                    int k = 0;
                    //ArrayList temparr = new ArrayList();
                    for (int i = 0; i < cnames.Length; i++)
                    {
                        dt.Columns.Add(cnames[i]);
                    }

                    ArrayList temparr = new ArrayList();
                    while (rd.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(Convert.ToString(rd[j]));//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = (string)temparr[(i * dt_cols_count) + j];
                        }
                    }

                    for (int i = 0; i < dt_cols_count; i++)
                    {
                        dt.Rows.Add(datas[i]);
                    }
                }
                else
                {
                    dt = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                odc.Dispose();
            }

            return dt;
        }

        public static string[][] GetDatas(string sql, string[] names, object[] values)
        {
            string[][] datas = null;

            SaveLogs(sql, values);

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    odc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            odc.Connection.Open();

            rd = odc.ExecuteReader();

            try
            {
                if (rd.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = rd.FieldCount;

                    int k = 0;
                    ArrayList temparr = new ArrayList();
                    while (rd.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(Convert.ToString(rd[j]));//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    datas = new string[temparr.Count / dt_cols_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = (string)temparr[(i * dt_cols_count) + j];
                        }
                    }
                }
                else
                {
                    datas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                //if(odc != null) odc.Dispose();
            }

            return datas;
        }

        public static object[][] Get_Inner_Datas(string sql, string[] names, object[] values)
        {
            object[][] datas = null;

            SaveLogs(sql, values);

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    odc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            odc.Connection.Open();

            rd = odc.ExecuteReader();

            try
            {
                if (rd.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = rd.FieldCount;

                    int k = 0;
                    ArrayList temparr = new ArrayList();
                    while (rd.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(rd[j]);//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    datas = new string[temparr.Count / dt_cols_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = temparr[(i * dt_cols_count) + j];
                        }
                    }
                }
                else
                {
                    datas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                //if(odc != null) odc.Dispose();
            }

            return datas;
        }

        public static string[][] Ext_GetDatas(string sql, string[] names, object[] values)
        {
            string[][] datas = null;

            Ext_SaveLogs(sql, values);

            //OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(ext_constr));
            SqlCommand sc = new SqlCommand(sql, new SqlConnection(ext_constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    sc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            sc.Connection.Open();

            sdr = sc.ExecuteReader();

            try
            {
                if (sdr.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = sdr.FieldCount;

                    int k = 0;
                    ArrayList temparr = new ArrayList();
                    while (sdr.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(sdr[j]);//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    datas = new string[temparr.Count / dt_cols_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        datas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = temparr[(i * dt_cols_count) + j].ToString();
                        }
                    }
                }
                else
                {
                    datas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                Ext_Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (sc.Connection.State == ConnectionState.Open)
                {
                    sc.Connection.Close();
                }
                //if(odc != null) odc.Dispose();
            }

            return datas;
        }

        public static int ExcuteQuery(string sql, string[] names, object[] values)
        {
            int state = 0;

            SaveLogs(sql, values);

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    odc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            try
            {
                odc.Connection.Open();

                state = odc.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                odc.Dispose();
            }

            return state;
        }

        public static int Ext_ExcuteQuery(string sql, string[] names,object[] values)
        {
            int state = 0;

            Ext_SaveLogs(sql, values);

            SqlCommand idc = new SqlCommand(sql, new SqlConnection(ext_constr));

            if (values != null)
            {
                for (int i = 0; i < values.Length; i++)
                {
                    idc.Parameters.AddWithValue(names[i], values[i]);
                }
            }

            try
            {
                idc.Connection.Open();

                state = idc.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                Ext_Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (idc.Connection.State == ConnectionState.Open)
                {
                    idc.Connection.Close();
                }
                idc.Dispose();
            }

            return state;
        }

        public static bool SaveLogs(string sql, object[] values)
        {
            bool state = false;

            try
            {
                using (StreamWriter sw = new StreamWriter("./querylogs.txt", true))
                {
                    sw.WriteLine("---------------------------------");
                    sw.WriteLine(DateTime.Now.ToString());
                    sw.WriteLine(sql);
                    if (values != null)
                    {
                        foreach (object i in values)
                        {
                            sw.Write(i.ToString() + ", ");
                        }
                        sw.WriteLine();
                    }
                    sw.WriteLine("---------------------------------");
                }
                state = true;
            }
            catch (Exception ex)
            {
                state = false;
                Save_Error_Logs(ex.Message);
            }

            return state;
        }

        public static bool Ext_SaveLogs(string sql, object[] values)
        {
            bool state = false;

            try
            {
                using (StreamWriter sw = new StreamWriter("./Ext_querylogs.txt", true))
                {
                    sw.WriteLine("---------------------------------");
                    sw.WriteLine(DateTime.Now.ToString());
                    sw.WriteLine(sql);
                    if (values != null)
                    {
                        foreach (object i in values)
                        {
                            sw.Write(i.ToString() + ", ");
                        }
                        sw.WriteLine();
                    }
                    sw.WriteLine("---------------------------------");
                }
                state = true;
            }
            catch (Exception ex)
            {
                state = false;
                Save_Error_Logs(ex.Message);
            }

            return state;
        }

        public static int ExcuteQuery(string sql)
        {
            int state = 0;

            OleDbCommand odc = new OleDbCommand(sql, new OleDbConnection(constr));

            try
            {
                odc.Connection.Open();

                state = odc.ExecuteNonQuery();
            }
            catch (Exception ex)
            {
                Save_Error_Logs(ex.Message);
            }
            finally
            {
                if (odc.Connection.State == ConnectionState.Open)
                {
                    odc.Connection.Close();
                }
                odc.Dispose();
            }

            return state;
        }

        public static int Updating_External_Servers(string logfile)
        {
            int state = 0;

            return state;
        }

        public static bool Save_Error_Logs(string errormesage)
        {
            bool state = false;

            try
            {
                using (StreamWriter sw = new StreamWriter("./errorlogs.txt", true))
                {
                    sw.WriteLine("---------------------------------");
                    sw.WriteLine(DateTime.Now.ToString());
                    sw.WriteLine(errormesage);
                    sw.WriteLine("---------------------------------");
                }
                state = true;
            }
            catch (Exception)
            {
                state = false;
            }

            return state;
        }

        public static bool Ext_Save_Error_Logs(string errormesage)
        {
            bool state = false;

            try
            {
                using (StreamWriter sw = new StreamWriter("./Ext_errorlogs.txt", true))
                {
                    sw.WriteLine("---------------------------------");
                    sw.WriteLine(DateTime.Now.ToString());
                    sw.WriteLine(errormesage);
                    sw.WriteLine("---------------------------------");
                }
                state = true;
            }
            catch (Exception)
            {
                state = false;
            }

            return state;
        }
    }
}



by Tomoya 2009.07.20 11:49
 그냥 찾는 거 보이길래 ..
20분도 안 걸리게다 싶어서 만든 프로그램..
소스 100줄도 안 됨




by Tomoya 2009.07.18 18:17

아래 개선형 DB 긁기 (C# 2.0)
처리속도도 빠르고 역시 모든 SQL형태에 대응 할수 있다.
컨넥션 얻어 오는 것은 아래 글 참조

using System.IO;
using System.Data.Sql;
using System.Data;
using System.Data.OracleClient;
using Oracle.DataAccess;

----------------------------------
OracleCommand cmd = new OracleCommand(sql, DbConn.GetConn());

            OracleDataReader rd;

            Find = null;//길 찾기 배열 초기화

            cmd.Parameters.AddWithValue(":SID", startbstop);
            cmd.Parameters.AddWithValue(":EID", endbstop);

            cmd.Connection.Open();

            rd = cmd.ExecuteReader();
            Find = GetOraDatas(rd);
--------------------------------------------------

//오라클 데이터 받아오기
        public static string[][] GetOraDatas(OracleDataReader rd)
        {
            string[][] datas = null;

            try
            {
                if (rd.HasRows)//데이터 테이블의 크기가 0보다 크다면
                {
                    int dt_cols_count = rd.FieldCount;

                    int k = 0;
                    ArrayList temparr = new ArrayList();
                    while(rd.Read())
                    {
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            temparr.Add(Convert.ToString(rd[j]));//데이터를 생성한 배열에 저장
                        }
                        k++;
                    }

                    bisdatas = new string[temparr.Count/dt_cols_count][];//행만큼의 2차원 배열 생성
                    for (int i = 0; i < temparr.Count / dt_cols_count; i++)
                    {
                        bisdatas[i] = new string[dt_cols_count];//해당 행만큼 세부 1차원 배열 생성
                        for (int j = 0; j < dt_cols_count; j++)
                        {
                            datas[i][j] = (string)temparr[(i * dt_cols_count) + j];
                        }
                    }
                }
                else
                {
                    bisdatas = null;//0보다 작다면 null값 설정
                }
            }
            catch (Exception ex)
            {
                using (StreamWriter sw = new StreamWriter("./sqlerror.txt"))
                {
                    //string message = "can not read file";
                    sw.WriteLine(ex.Message);//오류 발생시 sql에러로 저장
                }
            }
            finally
            {
               
            }

            return datas;//해당 sql문의 쿼리 결과를 2차원 문자열 배열로 전송
        }

by Tomoya 2009.04.13 17:56
| 1 2 |