Class GlueJdbcNativeRun

java.lang.Object
com.poscoict.glueframework.biz.activity.GlueActivity<GlueContext>
com.poscoict.glueframework.biz.activity.GlueJdbcNativeRun

public class GlueJdbcNativeRun extends GlueActivity<GlueContext>
dao를 통해서 PL/SQL를 실행하거나, SQL을 실행하는 Activity. 본 Activity에서는 주어진 정보(table name 또는 procedure name)를 이용해서 실행하고자 하는 문장을 만든다.
- {call procedure_name(:arg,:arg)} 형태의 프로시저 실행 문장
- select * from table_name where constraint_column=? 형태의 sql 문장
 Activity Property
 
 - dao : (필수) applicationContext.xml의 DAO id.

 - sql-key : (필수) xxx-query.glue_sql의 query id
        유형에 맞는 query를 지정해야 하며, query 실행결과에 따라 Statement 실행 구문이 만들어짐.
        sql은 named query여야 하며, :table_name, :object_name, :package_name, :owner만 named parameter로 사용한다.
        ex) oracle 의 경우 다음 3가지 유형에 맞는 SQL를 생성하는데 사용됨.
            1. procedure 실행
                -> {call package.procedure(:arg, :arg, ...)}
            2. package 실행
                -> {call procedure(:arg, :arg, ...)}
            3. table 정의 정보에 기반한 sql 실행
                -> select * from table where column_pk = ? and ...
                -> insert into table(column, ...) values (?, ...)
                -> delete from table where column_pk = ? and ...
                -> update talbe set column=?, ... where column_pk = ? and ...

 - procedure-name : (필수) 실행하고자 하는 PL/SQL 프로시저 또는 패키지 이름. table-name 과 같이 사용할 수 없음.
             sql-key에 해당하는 query를 실행한 결과항목(oracle.procedure.arguments, oracle.package.arguments 참고)
              - 필수 : NAME, DATA_TYPE, IN_OUT 항목을 포함해야함.
              - 선택 : SECOND_NAME 항목은 name을 가공한 값임.
             sql상의 :package_name 과 :object_name 의 값으로 사용됨.
              - aaa.bbb 형태일경우 경우 :package_name으로 aaa 를 :object_name에는 bbb 를 그 값으로 bind함.
              - ccc 형태일 경우 :object_name 에 ccc 를 그 값으로 bind함.
             실행결과는 IN/OUT 과 OUT 유형에 대해.. {argument_name}_result 로 GlueContext에 담김.

 - table-name : (필수) table 명. procedure-name 과 같이 사용할 수 없음.
             sql-key에 해당하는 query를 실행한 결과 항목(oracle.table.primary.key 참고)
               - 필수 NAME, DATA_TYPE, CONSTRAINT_TYPE 을 포함해야함.
               - 선택 : NULLABLE 항목은 sql 실행시 bind되는 값의 null check해당 항목인지 판단함..
             sql상의 :table_name 의 값으로 사용됨.

 - table-sql : (선택) sql 처리 유형. default는 select임.
             - select : PK(UK)를 조건으로 select 수행. 조회 결과는 {table-name}_resultList 으로 GlueContext에 담김.
             - insert : insert 수행. 등록 결과는 {table-name}_result 로 GlueContext에 담김.
             - update : PK(UK)를 조건으로 update 수행. 수정 결과는 {table-name}_result 로 GlueContext에 담김.
             - delete : PK(UK)를 조건으로 delete 수행. 삭제 결과는 {table-name}_result 로 GlueContext에 담김.
             - save : PK(UK)를 조건으로 select 수행하고 그 결과 따라 insert or update 수행. 저장 결과는 {table-name}_result 로 GlueContext에 담김.
             - desert : delete and insert 수행. 등록 결과는 {table-name}_result 로 GlueContext에 담김.

 - owner : (선택) : owner 정보..
             oarcle 사용시 sql-key에 해당하는 query에서
             user_arguments가 아닌 all_arguments를 사용할 경우 owner 정보를 지정할 수 있음.
             sql상의 :owner 의 값으로 사용됨.

 - name-bindings : (선택) mapping 정보로 name=ctxKey[|name=ctxKey...] 형태임.
            parocedure-name이 사용된 경우는 argumentName=ctxKey|argumentName=ctxKey 의미로 사용함
            table-name이 사용된 경우는 columnName=ctxKey|columnName=ctxKey 의미로 사용함.

 - name-values : (선택) mapping 정보로 name=constants[|name=constants...] 형태임.
            parocedure-name이 사용된 경우는 argumentName=constant|argumentName=constant 의미로 사용함
            table-name이 사용된 경우는 columnName=constants|columnName=constants 의미로 사용함.
            - null 값일 경우 'name' 만 입력 할 것
            - empty string 일 경우 'name=' 만 입력 할 것
            - space 일 경우 'name= ' 만 입력 할 것
                 ==>  'a|b=|c= |d=value' 형태가 될 것임.
            name-bindings와 name-values의 우선순위는 name-values 를 우선으로 함.

 - chk-name : (선택) 화면의 CheckBox ID(HttpRequest의 parameter name).
            String[] 형태의 data로 index 값을 갖는다.

 - list-key : (선택) Binding 할 Data Context Key.
            List<Map<String>, <Object>> 형태의 data.
 


 예제
 
 사용 예# 1
 - oracle procedure 실행 : {call proc1( )}

     <activity name="RunProcedure" class="com.poscoict.glueframework.biz.activity.GlueJdbcNativeRun">
         <property name="dao" value="testdao" />
         <property name="sql-key" value="oracle.procedure.arguments" />
         <property name="procedure-name" value="proc1" />
         <transition name="success" value="end" />
     </activity>


 사용 예# 2
 - oracle procedure 실행 : {call proc2( :P_INPUT1,:P_INPUT2 )}

     <activity name="RunProcedure" class="com.poscoict.glueframework.biz.activity.GlueJdbcNativeRun">
         <property name="dao" value="testdao" />
         <property name="sql-key" value="oracle.procedure.arguments" />
         <property name="procedure-name" value="proc2" />
         <transition name="success" value="end" />
     </activity>


 사용 예# 3
 - oracle package 실행 : {call biz1.sub1( )}

     <activity name="RunPackage" class="com.poscoict.glueframework.biz.activity.GlueJdbcNativeRun">
         <property name="dao" value="testdao" />
         <property name="sql-key" value="oracle.package.arguments" />
         <property name="procedure-name" value="biz1.sub1" />
         <transition name="success" value="end" />
     </activity>


 사용 예# 4
 - oracle package 실행 : {call biz1.sub2( :P_INPUT1,:P_INPUT2 )}

     <activity name="RunPackage" class="com.poscoict.glueframework.biz.activity.GlueJdbcNativeRun">
         <property name="dao" value="testdao" />
         <property name="sql-key" value="oracle.package.arguments" />
         <property name="procedure-name" value="biz1.sub2" />
         <transition name="success" value="end" />
     </activity>


 사용 예# 5
 - oracle package 실행 : {call biz1.sub2( :P_INPUT1,:P_OUTPUT )}

     <activity name="RunPackage" class="com.poscoict.glueframework.biz.activity.GlueJdbcNativeRun">
         <property name="dao" value="testdao" />
         <property name="sql-key" value="oracle.package.arguments" />
         <property name="procedure-name" value="biz1.sub2" />
         <property name="name-bindings" value="P_INPUT1=a|P_OUTPUT=result" />
         <transition name="success" value="end" />
     </activity>



 참고 : {name}-query.glue_sql

     <query id="oracle.procedure.arguments" desc="" resultType="" isNamed="true">
         <![CDATA[
     select a.OBJECT_ID, b.ARGUMENT_NAME as NAME, b.DATA_TYPE, b.IN_OUT, b.ARGUMENT_NAME||'abc' as SECOND_NAME
     from (select OBJECT_ID
           from USER_OBJECTS
           where OBJECT_NAME=:object_name ) a
     left outer join (select OBJECT_ID, ARGUMENT_NAME, DATA_TYPE, IN_OUT, SEQUENCE
                      from USER_ARGUMENTS
                      where PACKAGE_NAME is null and OBJECT_NAME=:object_name ) b on a.OBJECT_ID=b.OBJECT_ID
     order by SEQUENCE
         ]]>
     </query>
     <query id="oracle.package.arguments" desc="" resultType="" isNamed="true">
         <![CDATA[
     select ARGUMENT_NAME as NAME, DATA_TYPE, IN_OUT
     from USER_ARGUMENTS
     where PACKAGE_NAME=:package_name
       and OBJECT_NAME=:object_name
     order by SEQUENCE
         ]]>
     </query>
     <query id="oracle.table.primary.key" desc="" resultType="" isNamed="true">
         <![CDATA[
     select A.COLUMN_NAME as NAME, A.DATA_TYPE, B.CONSTRAINT_TYPE, C.CONSTRAINT_TYPE as NULLABLE
     from ( select COLUMN_NAME, DATA_TYPE, COLUMN_ID
            from USER_TAB_COLUMNS
            where TABLE_NAME=:table_name ) A
     left outer join ( select B1.COLUMN_NAME, B2.CONSTRAINT_TYPE
                       from ( select COLUMN_NAME, CONSTRAINT_NAME
                              from USER_CONS_COLUMNS
                              where TABLE_NAME=:table_name ) B1
                       inner join (select CONSTRAINT_NAME, CONSTRAINT_TYPE
                                   from USER_CONSTRAINTS
                                   where TABLE_NAME=:table_name
                                     and CONSTRAINT_TYPE='P' ) B2
                       on B1.CONSTRAINT_NAME=B2.CONSTRAINT_NAME ) B
     on A.COLUMN_NAME = B.COLUMN_NAME
     left outer join ( select C1.COLUMN_NAME, C2.CONSTRAINT_TYPE
                       from ( select COLUMN_NAME, CONSTRAINT_NAME
                              from USER_CONS_COLUMNS
                              where TABLE_NAME=:table_name ) C1
                       inner join (select CONSTRAINT_NAME, CONSTRAINT_TYPE
                                   from USER_CONSTRAINTS
                                   where TABLE_NAME=:table_name
                                     and CONSTRAINT_TYPE='C' ) C2
                       on C1.CONSTRAINT_NAME=C2.CONSTRAINT_NAME ) C
     on A.COLUMN_NAME = C.COLUMN_NAME
         ]]>
     </query>


 참고 : 'oracle.procedure.arguments' 실행결과

     --------------------------------------------------
     |OBJECT_ID|NAME     |DATA_TYPE|IN_OUT|SECOND_NAME|
     |{proc1}  |         |         |IN    |           |
     |{proc2}  |P_INPUT1 |VARCHAR2 |IN    |INPUT1     |
     |{proc2}  |P_INPUT2 |NUMBER   |IN/OUT|INPUT2     |
     |{proc2}  |P_OUTPUT |NUMBER   |OUT   |OUTPUT     |
     --------------------------------------------------


 참고 : 'oracle.package.arguments' 실행결과

     ----------------------------------------------------
     |OBJECT_ID  |NAME     |DATA_TYPE|IN_OUT|SECOND_NAME|
     |{biz1.sub1}|         |         |IN    |           |
     |{biz1.sub2}|P_INPUT1 |VARCHAR2 |IN    |INPUT1     |
     |{biz1.sub2}|P_INPUT2 |NUMBER   |IN/OUT|INPUT2     |
     |{biz1.sub2}|P_OUTPUT |NUMBER   |OUT   |OUTPUT     |
     ----------------------------------------------------


 참고 : Java Code (Custom)

     List<Map<String, Object>> dataList = new ArrayList<Map<String, Object>>();
     Map<String, Object> data1 = new HashMap<String, Object>();
     data1.put("EMPNO","1111");
     data1.put("ENAME","name1");
     data1.put("SAL","1000");
     dataList.add(data1);
     Map<String, Object> data2 = new HashMap<String, Object>();
     data2.put("EMPNO","1112");
     data2.put("ENAME","name2");
     data2.put("SAL","1100");
     dataList.add(data2);
     ctx.put("dataList",dataList);
 
  • Constructor Details

    • GlueJdbcNativeRun

      public GlueJdbcNativeRun()
  • Method Details

    • runActivity

      public String runActivity(GlueContext ctx)
      Description copied from class: GlueActivity
      Sub Class에서 반드시 구현하여야 하는 Abstract Method 이며 이 Method는 F/W에서 호출한다. 결과 값은 GlueContext에 담아서 다음 Activity 또는 F/W에 전달하게 된다. 필요한 모든 Data는 GlueContext에서 호출하여 사용하게 된다.
      
       예)
       <transition name="success" value="BizLogic"/>
       <transition name="failure" value="ErrorHandle"/>
       ==> return "success"이면 BizLogic Activity 를 실행함.
       
      Specified by:
      runActivity in class GlueActivity<GlueContext>
      Parameters:
      ctx - GlueContext
      Returns:
      String 정상적이면 "success"를 Return 하고 비정상 처리를 원하면 "failure"를 Return 한다.
    • main

      public static void main(String[] args)