001/*
002 * Copyright (c) 2009 The openGion Project.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 *     http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
013 * either express or implied. See the License for the specific language
014 * governing permissions and limitations under the License.
015 */
016package org.opengion.hayabusa.taglib;
017
018import org.opengion.hayabusa.common.HybsSystem;
019import org.opengion.hayabusa.common.HybsSystemException;
020import org.opengion.hayabusa.db.DBColumn;
021import org.opengion.hayabusa.db.DBTableModel;
022import org.opengion.hayabusa.db.DBTableModelUtil;
023import org.opengion.fukurou.system.OgBuilder ;                                  // 6.4.4.1 (2016/03/18)
024import org.opengion.fukurou.util.StringUtil;
025import org.opengion.fukurou.util.ToString;                                              // 6.1.1.0 (2015/01/17)
026import org.opengion.fukurou.util.ArraySet;                                              // 6.4.3.4 (2016/03/11)
027
028import static org.opengion.fukurou.util.StringUtil.nval ;
029
030import java.util.Set;                                                                                   // 6.4.3.4 (2016/03/11)
031import java.util.Map;
032import java.util.LinkedHashMap;
033import java.util.Locale ;
034import java.util.List;
035import java.util.ArrayList;
036
037/**
038 * 2つの DBTableModel の 集合処理を行うタグです。
039 *
040 * マスタとスレーブのそれぞれの DBTableModel を取得し、マージ、差分、排他などの
041 * データ処理を行います。結果を、指定の tableId と scope に書き出します。
042 * マスタテーブルは、masterTableId と masterScope より取り出します。スレーブテーブルは、
043 * slaveTableId と slaveScope より取り出します。
044 * 取り出された DBTableModel は、マスタテーブルに対して、スレーブテーブル情報を参照する形で行われ、
045 * 結果はマスタテーブルに上書きされる形で行われます。
046 * 指定できるアクションは、全体集合(UNION_ALL)、和集合(UNION)、積集合(INTERSECT)、
047 * 差集合(MINUS)、差分集合(DIFFERENCE)、列合成(UNION_CLM)、 列追加(ADD_CLM)、 グループ(GROUP)です。
048 * 列合成と列追加、グループ以外の処理では、カラム順とカラム数は同数でなければなりません。
049 * primaryKeys や unionClms などの指定のキー名は、マスタテーブルに存在する必要があります。
050 * マスタテーブルと同じカラム番号でスレーブテーブルよりデータを読み出します。
051 * (カラム名や属性は、異なってもかまいませんが、マスタテーブルに準拠します。)
052 * また、単独(マスタテーブルのみ)で、和集合と同等の、グループ(GROUP)を使用すると、指定の
053 * カラムでのユニーク化を行うことが可能になります。グループ処理では、先行優先とし、
054 * 2回目に現れた情報を削除することになります。グループ が指定された場合は、
055 * スレーブテーブルは無視されます。いずれの処理においても、集合処理を行う主キーで
056 * 一旦グループ化されます。全体集合(UNION_ALL)で処理する場合でも、主キーがユニークで
057 * ない場合は、マスター、スレーブの各テーブルで一旦グループ化された後で、マージされます。
058 * (マージ後には、同一主キーを持つ行は存在します。)
059 * 全体集合(UNION_ALL)の場合のみ、mergeKeys を指定する必要はありません。その場合は、
060 * キーなしのため、マスターとスレーブのテーブルを単に合成するだけになります。
061 *
062 * 6.9.1.0 (2018/02/26)
063 *   UNION_VAL は、スレーブテーブルの縦列を横列に割り当てるUNION_CLMの特殊版です。
064 *   処理としては、そのまま割り当てるのではなく、スレーブテーブルの縦列の値と
065 *   ヘッダーとして指定する、unionClms の値を比較して、下限値の最大値を割り当てます。
066 *   つまり、ヘッダーの値と同じか、それ以下で、最も近い値を割り当てることになります。
067 *   これは、時間的な推移を表現することになります。
068 *     masterKeys:マスタとスレーブを関連付ける共通のキーとなるカラム
069 *     slaveKeys :スレーブの縦列を横列にするための、キーと値のカラム
070 *     unionClms :横列にするカラム名。この値とスレーブのキーと比較してセットするかどうかを決めます。
071 *
072 * 処理前後でのDBTableModelの件数は、以下の変数で取得することが可能です。
073 *  処理前のマスターテーブル : {@DB.MASTER_COUNT}
074 *  処理前のスレーブテーブル : {@DB.SLAVE_COUNT}
075 *  処理後                   : {@DB.COUNT}
076 *
077 * @og.formSample
078 * ●形式:
079 *       ・<og:tableMerge
080 *             action        = "UNION_ALL|UNION|INTERSECT|MINUS|DIFFERENCE|UNION_CLM|UNION_VAL|ADD_CLM|GROUP|UNION_SELROW|CDKH|TABLE_REMOVE"
081 *             tableId       = "DEFAULT"        出力テーブルの tableId
082 *             scope         = "session"        出力テーブルの scope
083 *             masterTableId = "DEFAULT"        マスタテーブルの tableId
084 *             masterScope   = "session"        マスタテーブルの scope
085 *             slaveTableId  = "DEFAULT"        スレーブテーブルの tableId
086 *             slaveScope    = "request"        スレーブテーブルの scope
087 *             masterKeys    = "AA,BB,CC"       マスタテーブルの集合処理を行う主キー
088 *             slaveKeys     = "AA,BB,CC"       スレーブテーブルの集合処理を行う主キー(null時=masterKeys)
089 *             diffKeys      = "DD,EE"          マスタテーブルのDIFFERENCE時の差分カラム名
090 *             unionClms     = "DD,EE"          UNION_CLM,ADD_CLM時にスレーブからマスタへ追加するカラム名
091 *             unionLbls     = "dd,ee"          UNION_CLM,ADD_CLM時にスレーブからマスタへ追加するカラムのラベル名 6.9.1.0 (2018/02/26)
092 *             modifyClms    = "FF,GG"          DIFFERENCE,CDKH時にスレーブからマスタへ値を更新するカラム名
093 *             noSideEffect  = "false"          テーブルモデルに対する副作用(true:ない/false:ある)
094 *             useDiffData   = "true"           DIFFERENCE時に差分のスレーブデータを追加するかどうか
095 *             useCheckOnly  = "false"          マスタテーブルの選択行のデータのみを対象に処理を行うかどうか
096 *             groupAddClms  = "FF,GG"          masterKeysで集合処理するときに、相違データをCSV連結して残すカラム名
097 *             display       = "true"           処理概要を表示するかどうか
098 *         />
099 * ●body:なし
100 *
101 * ●Tag定義:
102 *   <og:tableMerge
103 *       command            【TAG】コマンド (NEW,RENEW)をセットします(初期値:NEW)
104 *       action             【TAG】アクションを指定します(UNION_ALL|UNION|INTERSECT|MINUS|DIFFERENCE|UNION_CLM|UNION_VAL|ADD_CLM|GROUP|UNION_SELROW|CDKH|TABLE_REMOVE)
105 *       tableId            【TAG】出力先のtableIdを指定します (初期値:HybsSystem#TBL_MDL_KEY[=h_tblmdl])
106 *       scope              【TAG】出力先のscopeを指定します(初期値:session)
107 *       masterTableId      【TAG】マスタテーブルのtableIdを指定します (初期値:HybsSystem#TBL_MDL_KEY[=h_tblmdl])
108 *       masterScope        【TAG】マスタテーブルのscopeを指定します(初期値:session)
109 *       slaveTableId       【TAG】スレーブテーブルのtableIdを指定します (初期値:HybsSystem#TBL_MDL_KEY[=h_tblmdl])
110 *       slaveScope         【TAG】スレーブテーブルのscopeを指定します(初期値:session)
111 *       masterKeys         【TAG】マスタテーブルの集合処理を行う主キーを指定します
112 *       slaveKeys          【TAG】スレーブテーブルの集合処理を行う主キーを指定します
113 *       diffKeys           【TAG】マスタテーブルのDIFFERENCE時の差分カラム名を(CSV形式)指定します
114 *       unionClms          【TAG】スレーブからマスタへ追加するカラム名をCSV形式で指定します
115 *       unionLbls          【TAG】スレーブからマスタへ追加するラベルをCSV形式で指定します   6.9.1.0 (2018/02/26)
116 *       nullDelClms        【TAG】指定の値がすべてnull(空文字列)の場合、レコードを削除するカラムをCSV形式で指定します
117 *       useSlaveLoop       【TAG】scope="request" のスレーブテーブルを、ループ処理して使用します(action="TABLE_REMOVE" と、"UNION_CLM" で、利用します)
118 *       modifyClms         【TAG】DIFFERENCE,CDKH時にスレーブからマスタへ値を更新するカラム名をCSV形式で指定します
119 *       groupAddClms       【TAG】集合処理するときに、相違データをCSV連結して残すカラム名をCSV形式で指定します
120 *       noSideEffect       【TAG】テーブルモデルに対する副作用の有無[true:ない/false:ある]を指定します(初期値:false:ある)
121 *       useDiffData        【TAG】差分のスレーブデータを結果テーブルに追加するかどうかを指定します(初期値:true)
122 *       useCheckOnly       【TAG】マスタテーブルの選択行のデータのみを対象に処理を行うかどうかを指定します(初期値:false)
123 *       stopZero           【TAG】検索結果が0件のとき処理を続行するかどうか[true/false]を指定します(初期値:false[続行する])
124 *       display            【TAG】マージの結果を表示するかどうかを指定します(初期値:true)
125 *       mainTrans          【TAG】(通常は使いません)タグで処理される処理がメインとなるトランザクション処理かどうかを指定します(初期値:false)
126 *       caseKey            【TAG】このタグ自体を利用するかどうかの条件キーを指定します(初期値:null)
127 *       caseVal            【TAG】このタグ自体を利用するかどうかの条件値を指定します(初期値:null)
128 *       caseNN             【TAG】指定の値が、null/ゼロ文字列 でない場合(Not Null=NN)は、このタグは使用されます(初期値:判定しない)
129 *       caseNull           【TAG】指定の値が、null/ゼロ文字列 の場合は、このタグは使用されます(初期値:判定しない)
130 *       caseIf             【TAG】指定の値が、true/TRUE文字列の場合は、このタグは使用されます(初期値:判定しない)
131 *       separator          【TAG】groupAddClmsで文字列を連結する項目区切り文字をセットします(初期値:",")
132 *       debug              【TAG】デバッグ情報を出力するかどうか[true/false]を指定します(初期値:false)
133 *   />
134 *
135 * ●使用例
136 *     例1)デフォルト以外に必要な属性のみ指定するサンプル
137 *     <og:tableMerge action="UNION"
138 *           slaveScope = "request" masterKeys = "AA,BB,CC"
139 *     />
140 *
141 *         ・出力先、マスターともに初期値は、tableId="DEFAULT" scope="session" です。
142 *           スレーブは、tableId か scope をける必要がある為、scope="request" を指定しています。
143 *           比較するカラム名は、マスタ、スレーブ同じであれば、マスタのみ指定でかまいません。
144 *
145 *     例2)マスタ、スレーブともメモリに残らないように request で作成します。
146 *     <og:tableMerge action="INTERSECT"
147 *           masterScope  = "request"
148 *           slaveScope   = "request"
149 *           slaveTableId = "SLAVE"
150 *           masterKeys   = "AA,BB,CC"
151 *     />
152 *
153 *         ・マスタ、スレーブともメモリに残らないように request で作成した場合は、
154 *           どちらかの TableId を変える必要があります。
155 *           出力先は初期値の、tableId="DEFAULT" scope="session" です。
156 *
157 * @og.rev 3.8.0.9 (2005/10/17) 新規追加
158 * @og.group DB登録
159 *
160 * @version  0.9.0      2000/10/17
161 * @author       Kazuhiko Hasegawa
162 * @since    JDK5.0,
163 */
164public class TableMergeTag extends CommonTagSupport {
165        /** このプログラムのVERSION文字列を設定します。   {@value} */
166        private static final String VERSION = "6.9.1.0 (2018/02/26)" ;
167        private static final long serialVersionUID = 691020180226L ;
168
169        /** action 引数に渡す事の出来る アクションコマンド  全体集合 {@value} */
170        public static final String ACT_UNION_ALL        = "UNION_ALL" ;
171        /** action 引数に渡す事の出来る アクションコマンド  和集合 {@value} */
172        public static final String ACT_UNION            = "UNION" ;
173        /** action 引数に渡す事の出来る アクションコマンド  積集合 {@value} */
174        public static final String ACT_INTERSECT        = "INTERSECT" ;
175        /** action 引数に渡す事の出来る アクションコマンド  差集合{@value} */
176        public static final String ACT_MINUS            = "MINUS" ;
177        /** action 引数に渡す事の出来る アクションコマンド  差分集合{@value} */
178        public static final String ACT_DIFFERENCE       = "DIFFERENCE" ;
179        /** action 引数に渡す事の出来る アクションコマンド  列合成{@value} */
180        public static final String ACT_UNION_CLM        = "UNION_CLM" ;
181        /** action 引数に渡す事の出来る アクションコマンド  列合成{@value} */
182        public static final String ACT_UNION_VAL        = "UNION_VAL" ;                                 // 6.9.1.0 (2018/02/26)
183        /** action 引数に渡す事の出来る アクションコマンド  列合成{@value} */
184        public static final String ACT_ADD_CLM          = "ADD_CLM" ;
185        /** action 引数に渡す事の出来る アクションコマンド  グループ {@value} */
186        public static final String ACT_GROUP            = "GROUP" ;
187        /** action 引数に渡す事の出来る アクションコマンド  グループ {@value} */
188        public static final String ACT_UNION_SELROW     = "UNION_SELROW" ;                              // 4.3.2.0 (2008/09/11)
189        /** action 引数に渡す事の出来る アクションコマンド  改廃コード {@value} */
190        public static final String ACT_CDKH                     = "CDKH" ;                                              // 6.3.1.1 (2015/07/10)
191        /** action 引数に渡す事の出来る アクションコマンド  DBTableModelの削除 {@value} */
192        public static final String ACT_TABLE_REMOVE     = "TABLE_REMOVE" ;                              // 6.7.3.0 (2017/01/27)
193
194        // 6.4.3.4 (2016/03/11) String配列 から、Setに置き換えます。
195        private static final Set<String> ACTION_SET = new ArraySet<>( ACT_UNION_ALL , ACT_UNION , ACT_INTERSECT , ACT_MINUS , ACT_DIFFERENCE , ACT_UNION_CLM , ACT_UNION_VAL , 
196                                                                                                                                  ACT_ADD_CLM , ACT_GROUP , ACT_UNION_SELROW , ACT_CDKH , ACT_TABLE_REMOVE );
197
198        /** command 引数に渡す事の出来る コマンド  新規 {@value} */
199        public static final String CMD_NEW       = "NEW" ;
200        /** command 引数に渡す事の出来る コマンド  再検索 {@value} */
201        public static final String CMD_RENEW = "RENEW" ;
202        // 6.4.3.4 (2016/03/11) String配列 から、Setに置き換えます。
203        private static final Set<String> COMMAND_SET = new ArraySet<>( CMD_NEW , CMD_RENEW );
204
205        private String  command         = CMD_NEW;
206
207        private String  action          ;
208        private String  tableId         = HybsSystem.TBL_MDL_KEY;               // 出力先の tableId
209        private String  scope           = "session";                                    // 出力先の scope
210
211        private String  masterTableId   = HybsSystem.TBL_MDL_KEY;       // マスタテーブルの tableId
212        private String  masterScope             = "session";                            // マスタテーブルの scope
213        private String  slaveTableId    = HybsSystem.TBL_MDL_KEY;       // スレーブテーブルの tableId
214        private String  slaveScope              = "request";                            // スレーブテーブルの scope
215        private String  masterKeys              ;                                                       // マスタテーブルの集合処理を行う主キー
216        private String  slaveKeys               ;                                                       // スレーブテーブルの集合処理を行う主キー(null時=masterKeys)
217        private String  diffKeys                ;                                                       // マスタテーブルのDIFFERENCE時の差分カラム名
218        private String  unionClms               ;                                                       // 6.7.3.0 (2017/01/27) 値がnull時にレコードを削除
219        private String  unionLbls               ;                                                       // 6.9.1.0 (2018/02/26) 追加
220        private String  nullDelClms             ;                                                       // UNION_CLM時にスレーブからマスタへ追加するカラム名
221        private String  modifyClms              ;                                                       // DIFFERENCE,CDKH時にスレーブからマスタへ値を更新するカラム名
222        private String  groupAddClms    ;                                                       // 5.1.4.0 (2010/03/01) masterKeysで集合処理するときに、相違データをCSV連結して残すカラム名
223        private boolean noSideEffect    ;                                                       // テーブルモデルに対する副作用(true:ない/false:ある)
224        private boolean useDiffData             = true;                                         // DIFFERENCE時に差分のスレーブデータを追加するかどうか
225        private boolean useCheckOnly    ;                                                       // マスタテーブルの選択行のデータのみを対象に処理を行うかどうか
226        private boolean display                 = true;         
227        private boolean isMainTrans             = true;                                         // 5.1.6.0 (2010/05/01) DBLastSqlの処理の見直し
228        private String  separator               = ",";                                          // 5.3.1.0 (2011/01/01) groupAddClmnsで結合する際の区切り文字
229        private boolean stopZero                ;                                                       // 5.7.6.2 (2014/05/16) stopZero属性追加
230        private boolean useSlaveLoop    ;                                                       // 6.7.3.0 (2017/01/27) useSlaveLoop属性追加
231
232        /**
233         * デフォルトコンストラクター
234         *
235         * @og.rev 6.4.2.0 (2016/01/29) PMD refactoring. Each class should declare at least one constructor.
236         */
237        public TableMergeTag() { super(); }             // これも、自動的に呼ばれるが、空のメソッドを作成すると警告されるので、明示的にしておきます。
238
239        /**
240         * Taglibの終了タグが見つかったときに処理する doEndTag() を オーバーライドします。
241         *
242         * @og.rev 4.3.2.0 (2008/09/11) UNION_SELROWアクション対応
243         * @og.rev 4.3.3.0 (2008/10/01) 処理前後のテーブル件数を取得できるようにする
244         * @og.rev 4.3.3.1 (2008/10/08) スレーブのnullチェック追加
245         * @og.rev 5.1.6.0 (2010/05/01) DBLastSqlの処理は、DBTableModelが新規作成された処理でのみ行う。
246         * @og.rev 5.2.2.0 (2010/11/01) caseKey 、caseVal 属性対応
247         * @og.rev 5.7.6.2 (2014/05/16) stopZero属性、DB.COUNT キーで検索件数をリクエストにセットする。
248         * @og.rev 6.3.1.1 (2015/07/10) Map作成時に、DBTableModel のグループ化を行うかどうか指定できるようにする。
249         * @og.rev 6.3.1.1 (2015/07/10) 改廃コードを設定する CDKH アクションを追加
250         * @og.rev 6.3.4.0 (2015/08/01) Arrays.toString から String.join に置き換え。
251         * @og.rev 6.4.3.4 (2016/03/11) String配列 から、Setに置き換えます。
252         * @og.rev 6.4.4.1 (2016/03/18) StringBuilderの代わりに、OgBuilderを使用する。
253         * @og.rev 6.7.3.0 (2017/01/27) useSlaveLoop,nullDelClms属性追加と、action="TABLE_REMOVE" の追加
254         * @og.rev 6.9.1.0 (2018/02/26) ACT_UNION_VAL追加
255         *
256         * @return      後続処理の指示
257         */
258        @Override
259        public int doEndTag() {
260                debugPrint();           // 4.0.0 (2005/02/28)
261                // 5.2.2.0 (2010/11/01) caseKey 、caseVal 属性対応
262                if( !useTag() || ! check( command, COMMAND_SET ) ) { return EVAL_PAGE ; }
263
264                // 整合性チェック:アクションリストとの存在チェック
265                if( !check( action, ACTION_SET ) ) {
266                        final String errMsg = "指定のアクションは実行できません。アクションエラー"       + CR
267                                                        + "action=[" + action + "] "                                                            + CR
268                                                        + "指定可能なアクション:"
269                                                        + String.join( ", " , ACTION_SET ) ;
270                        throw new HybsSystemException( errMsg );
271                }
272
273                // 6.7.3.0 (2017/01/27) action="TABLE_REMOVE" で、DBTableModel を無条件で、削除します。
274                if( ACT_TABLE_REMOVE.equalsIgnoreCase( action ) ) {
275                        super.setScope( masterScope );
276                        removeObject( masterTableId );
277                        return EVAL_PAGE ;
278                }
279
280                // スレーブテーブルの集合処理を行う主キー(null時=masterKeys)
281                if( slaveKeys == null ) { slaveKeys = masterKeys; }
282
283                super.setScope( masterScope );
284                DBTableModel masterTable = (DBTableModel)getObject( masterTableId );
285
286                // 6.7.3.0 (2017/01/27) useSlaveLoop属性追加と、action="TABLE_REMOVE" の追加
287                if( useSlaveLoop ) {
288                        // 初っ端はDBTableModel が存在しないはずなので、slave のテーブルを、マスターに登録しなおす。(処理は、これだけで終了)
289                        if( masterTable == null ) {
290                                // slave の scope と、tableId から取り出した DBTableModel を、master に登録する。
291                                super.setScope( slaveScope );
292                                masterTable = (DBTableModel)getObject( slaveTableId );
293                                if( masterTable != null && masterTable.getRowCount() > 0 ) {
294                                        super.setScope( masterScope );
295                                        setObject( masterTableId , masterTable );
296                                }
297                                return EVAL_PAGE ;
298                        }
299                }
300
301                // 整合性チェック:マスタテーブルは必須
302                if( masterTable == null ) {
303                        final String errMsg = "マスタテーブルは必須です。"
304                                                + CR
305                                                + "action=[" + action + "] "
306                                                + "masterTableId=[" + masterTableId + "] "
307                                                + "masterScope=[" + masterScope + "] " ;
308                        throw new HybsSystemException( errMsg );
309                }
310                if( noSideEffect ) { masterTable = cloneTable( masterTable ); }
311                // 6.3.1.1 (2015/07/10) Map作成時に、DBTableModel のグループ化を行うかどうか指定できるようにする。
312                final Map<String,Integer> masterMap = makeKeyMap( masterTable,masterKeys,useCheckOnly,true );   // useGroup=true(行う) なので、masterTable は副作用が発生する。
313
314                DBTableModel slaveTable = null;
315                Map<String,Integer> slaveMap = null;
316
317                // 整合性チェック:action="GROUP" と "ADD_CLM" 以外では、スレーブテーブルは必須
318                // 6.9.1.0 (2018/02/26) ACT_UNION_VAL追加
319                if( ! ACT_GROUP.equalsIgnoreCase( action ) && !ACT_ADD_CLM.equalsIgnoreCase( action ) ) {
320                        super.setScope( slaveScope );
321                        slaveTable = (DBTableModel)getObject( slaveTableId );
322
323                        if( slaveTable == null ) {
324                                final String errMsg = "action=[" + action + "] 時には、スレーブテーブルが必要です。"
325                                                        + CR
326                                                        + "slaveTableId=[" + slaveTableId + "] "
327                                                        + "slaveScope=[" + slaveScope + "] " ;
328                                throw new HybsSystemException( errMsg );
329                        }
330                        if( noSideEffect ) { slaveTable = cloneTable( slaveTable ); }
331                        // 6.3.1.1 (2015/07/10) Map作成時に、DBTableModel のグループ化を行うかどうか指定できるようにする。
332                        slaveMap = makeKeyMap( slaveTable,slaveKeys,false,false );      // スレーブはuseCheckOnlyしない、グループ化しない。
333
334                        // その場合、マスタとスレーブが同一メモリ上のテーブル(物理的に同じ)でない事。
335                        if( slaveTable == masterTable ) {
336                                final String errMsg = "マスタとスレーブが同一メモリになっています。"
337                                                        + "通常、検索結果は tableId と scope を別々に指定するか、noSideEffect=true(副作用なし)を、指定してください。"
338                                                        + CR
339                                                        + "action=[" + action + "] "
340                                                        + "masterTableId=[" + masterTableId + "] "
341                                                        + "slaveTableId=[" + slaveTableId + "] "
342                                                        + "masterScope=[" + masterScope + "] "
343                                                        + "slaveScope=[" + slaveScope + "] " ;
344                                throw new HybsSystemException( errMsg );
345                        }
346                }
347
348                super.setScope( scope );
349                useMainTrans( isMainTrans );                    // 5.1.6.0 (2010/05/01) DBLastSqlの処理の見直し
350                startQueryTransaction( tableId );               // 3.6.0.8 (2004/11/19)
351
352                // 設定値の整合性チェック
353                // 整合性チェック:action="UNION_ALL" と "UNION_VAL" と "GROUP"と "ADD_CLM"と "UNION_CLM" 以外では、masterKeys が必須
354                // 6.9.1.0 (2018/02/26) ACT_UNION_VAL追加
355                if( ! ACT_UNION_ALL.equalsIgnoreCase( action )
356                        && !ACT_UNION_VAL.equalsIgnoreCase( action )    // 6.9.1.0 (2018/02/26)
357                        && !ACT_UNION_SELROW.equalsIgnoreCase( action ) // 4.3.2.0 (2008/09/11)
358                        && !ACT_GROUP.equalsIgnoreCase( action )
359                        && !ACT_ADD_CLM.equalsIgnoreCase( action )
360                        && !ACT_UNION_CLM.equalsIgnoreCase( action )
361                        && masterKeys == null ) {
362                                final String errMsg = "action=\"" + action + "\" 時には、masterKeys が必須です。"
363                                                        + CR
364                                                        + "masterKeys=[" + masterKeys + "] ";
365                                throw new HybsSystemException( errMsg );
366                }
367
368                // 設定値の整合性チェック
369                // 整合性チェック:action="DIFFERENCE" では、diffKeys が必須
370                if( ACT_DIFFERENCE.equalsIgnoreCase( action ) && diffKeys == null ) {
371                        final String errMsg = "action=\"" + action + "\" 時には、diffKeys が必須です。"
372                                                + CR
373                                                + "diffKeys=[" + diffKeys + "] ";
374                        throw new HybsSystemException( errMsg );
375                }
376
377                // 設定値の整合性チェック
378                // 整合性チェック:列合成(UNION_CLM) と 値列合成(UNION_VAL) と グループ(GROUP) と 列追加(ADD_CLM) と 積集合(INTERSECT) と 差集合(MINUS) 以外では、
379                //                 テーブルカラム数が同じである必要がある。
380                // 6.9.1.0 (2018/02/26) ACT_UNION_VAL追加
381                if( ! ACT_UNION_CLM.equalsIgnoreCase( action )
382                         && !ACT_UNION_VAL.equalsIgnoreCase( action )           // 6.9.1.0 (2018/02/26)
383                         && !ACT_GROUP.equalsIgnoreCase( action )
384                         && !ACT_ADD_CLM.equalsIgnoreCase( action )
385                         && !ACT_INTERSECT.equalsIgnoreCase( action )           // 6.3.1.1 (2015/07/10) INTERSECT と MINUS を条件に追加
386                         && !ACT_MINUS.equalsIgnoreCase( action ) ) {           // 6.3.1.1 (2015/07/10) INTERSECT と MINUS を条件に追加
387                        final int mClmSize = masterTable.getColumnCount();
388                        final int sClmSize = slaveTable.getColumnCount();
389
390                        if( mClmSize != sClmSize ) {
391                                final String errMsg = "action=\"" + action + "\" 時には、テーブルカラム数が異なってはいけません。"
392                                                        + CR
393                                                        + "Master=" + mClmSize + " ,["
394                                                        + StringUtil.array2csv( masterTable.getNames() ) + "]"
395                                                        + CR
396                                                        + "Slave =" + sClmSize + " ,["
397                                                        + StringUtil.array2csv( slaveTable.getNames() ) + "]";
398                                throw new HybsSystemException( errMsg );
399                        }
400                }
401
402                // 6.4.4.1 (2016/03/18) display == true 時の出力を後ろにします。
403                final String MST_CNT = String.valueOf( masterTable.getRowCount() );
404                final String SLV_CNT = slaveTable == null ? null : String.valueOf( slaveTable.getRowCount() );
405
406                setRequestAttribute( "DB.MASTER_COUNT"   , MST_CNT );
407                if( SLV_CNT != null ) {
408                        setRequestAttribute( "DB.SLAVE_COUNT", SLV_CNT );
409                }
410
411                DBTableModel table = null;
412                if( ACT_UNION_ALL.equalsIgnoreCase( action ) ) {                        // 全体集合
413                        table = makeUnionAll( masterTable,slaveTable );
414                }
415                else if( ACT_UNION_SELROW.equalsIgnoreCase( action ) ) {        // 4.3.2.0 (2008/09/11) 全体集合(slave表をmaster表のチェック行から追加)
416                        table = makeUnionSelrow( masterTable,slaveTable );
417                }
418                else if( ACT_UNION.equalsIgnoreCase( action ) ) {                       // 和集合
419                        table = makeUnion( masterTable,masterMap,slaveTable,slaveMap );
420                }
421                else if( ACT_INTERSECT.equalsIgnoreCase( action ) ) {           // 積集合
422                        table = makeIntersect( masterTable,masterMap,slaveMap );
423                }
424                else if( ACT_MINUS.equalsIgnoreCase( action ) ) {                       // 差集合
425                        table = makeMinus( masterTable,masterMap,slaveMap );
426                }
427                else if( ACT_DIFFERENCE.equalsIgnoreCase( action ) ) {          // 差分集合
428                        table = makeDifference( masterTable,masterMap,slaveTable,slaveMap );
429                }
430                else if( ACT_UNION_CLM.equalsIgnoreCase( action ) ) {           // 列合成
431                        if( unionClms == null ) {
432                                final String errMsg = "action=\"UNION_CLM\" 時には、unionClms が必須です。" ;
433                                throw new HybsSystemException( errMsg );
434                        }
435
436                        table = makeUnionClm( masterTable,slaveKeys,slaveTable,slaveMap );
437                }
438                // 6.9.1.0 (2018/02/26) ACT_UNION_VAL追加
439                else if( ACT_UNION_VAL.equalsIgnoreCase( action ) ) {           // 値列合成
440                        if( unionClms == null ) {
441                                final String errMsg = "action=\"UNION_VAL\" 時には、unionClms が必須です。" ;
442                                throw new HybsSystemException( errMsg );
443                        }
444
445                        table = makeUnionVal( masterTable,masterKeys,slaveTable,slaveKeys );
446                }
447                else if( ACT_ADD_CLM.equalsIgnoreCase( action ) ) {             // 列追加
448                        if( unionClms == null ) {
449                                final String errMsg = "action=\"ADD_CLM\" 時には、unionClms が必須です。" ;
450                                throw new HybsSystemException( errMsg );
451                        }
452
453                        table = makeAddClm( masterTable );
454                }
455                else if( ACT_GROUP.equalsIgnoreCase( action ) ) {                       // グループ化は、先のレコードが残ります。
456                        table = makeGroup( masterTable );
457
458                        // 6.7.3.0 (2017/01/27) nullDelClmsで、値がnull時にレコードを削除
459                        if( nullDelClms != null && !nullDelClms.isEmpty() ) {
460                                table = deleteRows( table,nullDelClms );
461                        }
462                }
463                else if( ACT_CDKH.equalsIgnoreCase( action ) ) {                        // 6.3.1.1 (2015/07/10) CDKH
464                        table = makeCdkh(  masterTable,masterMap,slaveTable,slaveMap );
465                }
466
467                // 6.0.2.4 (2014/10/17) NP:null 値を利用している可能性があります。 
468                if( table == null ) {
469                        final String errMsg = "テーブルデータを作成できませんでした。action=[" + action + "]" ;
470                        throw new HybsSystemException( errMsg );
471                }
472
473                // 3.6.0.8 (2004/11/19) トランザクションチェックを行います。
474                super.setScope( scope );
475                if( ! commitTableObject( tableId, table ) ) {
476                        return SKIP_PAGE ;
477                }
478
479                // 5.7.6.2 (2014/05/16) マージした結果の DBTableModel のデータ件数
480                final int rowCnt = table.getRowCount();
481
482                // 6.4.4.1 (2016/03/18) display == true 時の出力を後ろにします。
483                // 6.4.4.1 (2016/03/18) StringBuilderの代わりに、OgBuilderを使用する。
484                if( display ) {
485                        final OgBuilder buf = new OgBuilder()
486                                .append( action , "( M[" , MST_CNT , "]" )
487                                .appendIf( SLV_CNT != null
488                                                                , ",S["  , SLV_CNT , "]" )
489                                .append( " ) = [" , String.valueOf( rowCnt ) , "]" );
490
491                        jspPrint( buf.toString() );
492                }
493
494                // 5.7.6.2 (2014/05/16) 検索結果の件数を、"DB.COUNT" キーでリクエストにセットする。
495                setRequestAttribute( "DB.COUNT" , String.valueOf( rowCnt ) );
496
497                // 5.7.6.2 (2014/05/16) 件数0件かつ stopZero = true
498                // 6.4.1.1 (2016/01/16) PMD refactoring. A method should have only one exit point, and that should be the last statement in the method
499                return rowCnt == 0 && stopZero
500                                        ? SKIP_PAGE
501                                        : EVAL_PAGE ;           // ページの残りを評価する。
502        }
503
504        /**
505         * タグリブオブジェクトをリリースします。
506         * キャッシュされて再利用されるので、フィールドの初期設定を行います。
507         *
508         * @og.rev 5.1.4.0 (2010/03/01) groupAddClms 追加
509         * @og.rev 5.1.6.0 (2010/05/01) DBLastSqlの処理は、DBTableModelが新規作成された処理でのみ行う。
510         * @og.rev 5.3.1.0 (2011/01/01) separator追加
511         * @og.rev 5.7.6.2 (2014/05/16) stopZero属性追加
512         * @og.rev 6.7.3.0 (2017/01/27) useSlaveLoop,nullDelClms属性追加
513         */
514        @Override
515        protected void release2() {
516                super.release2();
517                command                 = CMD_NEW;
518                action                  = null;
519                tableId                 = HybsSystem.TBL_MDL_KEY;       // 出力先の tableId
520                scope                   = "session";                            // 出力先の scope
521                masterTableId   = HybsSystem.TBL_MDL_KEY;       // マスタテーブルの tableId
522                masterScope             = "session";                            // マスタテーブルの scope
523                slaveTableId    = HybsSystem.TBL_MDL_KEY;       // スレーブテーブルの tableId
524                slaveScope              = "request";                            // スレーブテーブルの scope
525                masterKeys              = null;                                         // マスタテーブルの集合処理を行う主キー
526                slaveKeys               = null;                                         // スレーブテーブルの集合処理を行う主キー(null時=masterKeys)
527                diffKeys                = null;                                         // マスタテーブルのDIFFERENCE時の差分カラム名
528                unionClms               = null;                                         // スレーブからマスタへ追加するカラム名
529                unionLbls               = null;                                         // 6.9.1.0 (2018/02/26) スレーブからマスタへ追加するラベル名
530                nullDelClms             = null;                                         // 6.7.3.0 (2017/01/27) 値がnull時にレコードを削除
531                modifyClms              = null;                                         // DIFFERENCE,CDKH時にスレーブからマスタへ値を更新するカラム名
532                groupAddClms    = null;                                         // 5.1.4.0 (2010/03/01) masterKeysで集合処理するときに、相違データをCSV連結して残すカラム名
533                noSideEffect    = false;                                        // テーブルモデルに対する副作用(true:ない/false:ある)
534                useDiffData             = true;                                         // DIFFERENCE時に差分のスレーブデータを追加するかどうか
535                useCheckOnly    = false;                                        // マスタテーブルの選択行のデータのみを対象に処理を行うかどうか
536                display                 = true;
537                stopZero                = false;                                        // 5.7.6.2 (2014/05/16) stopZero属性追加
538                useSlaveLoop    = false;                                        // 6.7.3.0 (2017/01/27) useSlaveLoop属性追加
539                isMainTrans             = true;                                         // 5.1.6.0 (2010/05/01) DBLastSqlの処理の見直し
540                separator               = ",";
541        }
542
543        /**
544         * 指定のテーブルの指定のカラム(CSV)より、行番号をマップ化します。
545         * なお、引数のテーブルについては、useGroup属性に応じて、主キーによるグループ処理を
546         * 行うかどうか決定します。(グループ化処理を行うと、副作用が発生します。)
547         *
548         * @og.rev 4.3.2.0 (2008/09/11) マスタキー未指定時は何もしない
549         * @og.rev 5.1.4.0 (2010/03/01) groupAddClms 追加
550         * @og.rev 5.3.1.0 (2011/01/01) groupAddClms の separator指定対応
551         * @og.rev 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
552         * @og.rev 6.3.1.1 (2015/07/10) Map作成時に、DBTableModel のグループ化を行うかどうか指定できるようにする。
553         *
554         * @param       table   マップ作成元のデータテーブル(副作用あり)
555         * @param       keys    マップ作成の主キー(CSV形式)
556         * @param       useCheckOnly    チェック行のみ対象 [true:する/false:しない]
557         * @param       useGroup                主キーによるグループ処理 [true:する/false:しない]
558         *
559         * @return マップ化された主キーと行番号
560         */
561        private Map<String,Integer> makeKeyMap( final DBTableModel table, final String keys, final boolean useCheckOnly, final boolean useGroup ) {
562
563                // カラム名をカラム番号に変換します。
564                final int[] clmNo = makeColumnNo( table,keys );
565                final int   clmSize = clmNo.length;
566                if( clmSize == 0 ) {    // マスタキー未指定時には全カラムを使用します。
567                        return null;            // 4.3.2.0 (2008/09/11)
568                }
569
570                // groupAddClms をカラム番号に変換します。
571                final int[] grpClmNo = makeColumnNo( table,groupAddClms );
572                final int   grpClmSize = grpClmNo.length;
573
574                final Map<String,Integer> tempMap = new LinkedHashMap<>();
575
576                // 注意:GROUP化の過程で テーブル件数が動的に変化します。
577                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );                   // 6.1.0.0 (2014/12/26) refactoring
578                for( int row=0; row<table.getRowCount(); row++ ) {
579                        if( useCheckOnly && table.getModifyType( row ).isEmpty() ) {
580                                continue;
581                        }
582
583                        buf.setLength(0);                                                                                                       // 6.1.0.0 (2014/12/26) refactoring
584                        for( int i=0; i<clmSize; i++ ) {
585                                buf.append( table.getValue( row,clmNo[i] ) ).append( '|' );             // 6.0.2.5 (2014/10/31) char を append する。
586                        }
587                        // 主キー連結文字列
588                        final String key = buf.toString().toUpperCase(Locale.JAPAN);            // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
589                        if( tempMap.containsKey( key ) ) {
590                                // 6.3.1.1 (2015/07/10) Map作成時に、DBTableModel のグループ化を行うかどうか指定できるようにする。
591                                if( useGroup ) {
592                                        // 5.1.4.0 (2010/03/01) groupAddClms 追加
593                                        final int orgRow = tempMap.get( key ).intValue() ;                              // 追加済みの行番号を取得
594                                        for( int i=0; i<grpClmSize; i++ ) {
595                                                final int clm    = grpClmNo[i];
596                                                final String val1 = table.getValue( orgRow,clm ) ;                      // 既存の行・カラムのデータ
597                                                final String val2 = table.getValue( row,clm ) ;                         // 削除する行・カラムのデータ
598                                                // 5.3.1.0 (2011/01/01)
599                                                table.setValueAt( val1 + separator + val2,orgRow,clm );         // CSV 連結、データを戻す。
600                                        }
601                                        table.removeValue( row );
602                                        row-- ;
603                                }
604                        }
605                        else {                                                  // まだ、未登録の場合
606                                tempMap.put( key,Integer.valueOf( row ) );
607                        }
608                }
609
610                return tempMap;
611        }
612
613        /**
614         * 指定のテーブルの指定のカラム(CSV)より、行番号をマップ化します。
615         * なお、引数のテーブルについては、useGroup属性に応じて、主キーによるグループ処理を
616         * 行うかどうか決定します。(グループ化処理を行うと、副作用が発生します。)
617         *
618         * @og.rev 6.9.1.0 (2018/02/26) 新規追加
619         *
620         * @param       table   マップ作成元のデータテーブル(副作用なし) 通常は、スレーブテーブル
621         * @param       keys    マップ作成の主キー(CSV形式)  通常は、マスターキー(スレーブとマッチングさせるためのキー)
622         * @param       valClm  値の配列リストに設定するカラム列(CSV形式)  キーカラムと値カラム
623         *
624         * @return マップ化された主キーと値の配列リスト
625         */
626        private Map<String,List<String[]>> makeValMap( final DBTableModel table, final String keys, final String valClm ) {
627                // カラム名をカラム番号に変換します。
628                final int[] clmNo = makeColumnNo( table,keys );                 // キーとなるカラムのCSV形式
629                final int[] valNo = makeColumnNo( table,valClm );               // 値のカラムのCSV形式
630                final int   clmSize = clmNo.length;
631                if( clmSize == 0 ) {    // マスタキー未指定時には全カラムを使用します。
632                        return null;
633                }
634
635                final Map<String,List<String[]>> tempMap = new LinkedHashMap<>();
636
637                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
638                for( int row=0; row<table.getRowCount(); row++ ) {
639                        buf.setLength(0);
640                        for( int i=0; i<clmSize; i++ ) {
641                                buf.append( table.getValue( row,clmNo[i] ) ).append( '|' );
642                        }
643                        // 値の取得
644                        final String[] vals = new String[valNo.length];
645                        for( int i=0; i<valNo.length; i++ ) {
646                                vals[i] = table.getValue( row,valNo[i] );
647                        }
648
649                        // 主キー連結文字列
650                        final String key = buf.toString().toUpperCase(Locale.JAPAN);            // 大文字・小文字を区別しない。
651                        tempMap.computeIfAbsent( key , k -> new ArrayList<String[]>() ).add( vals );
652                }
653
654                return tempMap;
655        }
656
657        /**
658         * 指定のマスタ,スレーブテーブルを使用して 全体集合 処理を実行します。
659         *
660         * @param       masterTbl       マスターテーブルモデル
661         * @param       slaveTbl        スレーブテーブルモデル
662         *
663         * @return      処理結果のテーブルモデル
664         */
665        private DBTableModel makeUnionAll( final DBTableModel masterTbl,final DBTableModel slaveTbl ) {
666                final DBTableModel table = masterTbl;
667
668                for( int row=0; row<slaveTbl.getRowCount(); row++ ) {
669                        final String[] vals = slaveTbl.getValues( row );
670                        table.addColumnValues( vals );
671                }
672
673                return table;
674        }
675
676        /**
677         * 指定のマスタ,スレーブテーブルを使用して 全体集合 処理を実行します。
678         * スレーブ表は、マスタ表のチェックされた行を起点として登録されます。
679         * チェックされていない場合は、スレーブ表は先頭から追加されます。
680         *
681         * @og.rev 4.3.2.0 (2008/09/11) 新規作成
682         *
683         * @param       masterTbl       マスターテーブルモデル
684         * @param       slaveTbl        スレーブテーブルモデル
685         *
686         * @return      処理結果のテーブルモデル
687         */
688        private DBTableModel makeUnionSelrow( final DBTableModel masterTbl,final DBTableModel slaveTbl ) {
689                final DBTableModel table = masterTbl;
690
691                final int insRowNo = getParameterRows().length > 0 ? getParameterRows()[0] + 1 : 0 ;
692                for( int row=0; row<slaveTbl.getRowCount(); row++ ) {
693                        final String[] vals = slaveTbl.getValues( row );
694                        table.addValues( vals, insRowNo + row, false );
695                }
696
697                return table;
698        }
699
700        /**
701         * 指定のマスタ,スレーブテーブルを使用して 和集合 処理を実行します。
702         *
703         * @og.rev 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
704         *
705         * @param       masterTbl       マスターテーブルモデル
706         * @param       masterMap       マスターテーブルの主キーマップ
707         * @param       slaveTbl        スレーブテーブルモデル
708         * @param       slaveMap        スレーブテーブルの主キーマップ
709         *
710         * @return      処理結果のテーブルモデル
711         */
712        private DBTableModel makeUnion( final DBTableModel masterTbl,final Map<String,Integer> masterMap,
713                                                                        final DBTableModel slaveTbl,final Map<String,Integer> slaveMap ) {
714                final DBTableModel table = masterTbl;
715
716                @SuppressWarnings("rawtypes")
717                final Map.Entry[] entry = slaveMap.entrySet().toArray( new Map.Entry[slaveMap.size()] );
718
719                final int size = entry.length;
720                for( int i=0; i<size; i++ ) {
721                        String key  = (String)entry[i].getKey();
722                        if( key != null ) { key = key.toUpperCase(Locale.JAPAN); }              // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
723                        if( ! masterMap.containsKey( key ) ) {          // マスタにスレーブデータが存在しない
724                                final int row =  ((Integer)entry[i].getValue()).intValue();
725                                final String[] vals = slaveTbl.getValues( row );
726                                table.addColumnValues( vals );
727                        }
728                }
729                return table;
730        }
731
732        /**
733         * 指定のマスタ,スレーブテーブルを使用して 積集合 処理を実行します。
734         *
735         * @og.rev 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
736         * @og.rev 6.2.5.1 (2015/06/12) Modify情報が書かれていると、DELETE状況が再セットされないため、削除されなかった。
737         *
738         * @param       masterTbl       マスターテーブルモデル
739         * @param       masterMap       マスターテーブルの主キーマップ
740         * @param       slaveMap        スレーブテーブルの主キーマップ
741         *
742         * @return      処理結果のテーブルモデル
743         */
744        private DBTableModel makeIntersect( final DBTableModel masterTbl,final Map<String,Integer> masterMap, final Map<String,Integer> slaveMap ) {
745                final DBTableModel table = masterTbl;
746
747                @SuppressWarnings("rawtypes")
748                final Map.Entry[] entry = masterMap.entrySet().toArray( new Map.Entry[masterMap.size()] );
749
750                // 6.2.5.1 (2015/06/12) 削除する行番号を記憶しておく。
751                final List<Integer> rowList = new ArrayList<>();
752
753                // table.resetModify();         // 6.2.5.1 (2015/06/12) Modify情報をリセットしておく必要があった。
754
755                final int size = entry.length;
756                for( int i=0; i<size; i++ ) {
757                        String key  = (String)entry[i].getKey();
758                        if( key != null ) { key = key.toUpperCase(Locale.JAPAN); }              // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
759                        if( ! slaveMap.containsKey( key ) ) {           // スレーブにマスタが存在しない
760                                rowList.add( (Integer)entry[i].getValue() );    // 6.2.5.1 (2015/06/12) rowをセット
761                        }
762                }
763
764                // 行番号が変わらないように逆順削除します。
765                // 6.2.5.1 (2015/06/12) rowを削除
766                for( int i=rowList.size()-1 ; i>=0; i-- ) {
767                        table.removeValue( rowList.get(i) );
768                }
769
770                return table;
771        }
772
773        /**
774         * 指定のマスタ,スレーブテーブルを使用して 差集合 処理を実行します。
775         *
776         * @og.rev 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
777         * @og.rev 6.2.5.1 (2015/06/12) Modify情報が書かれていると、DELETE状況が再セットされないため、削除されなかった。
778         *
779         * @param       masterTbl       マスターテーブルモデル
780         * @param       masterMap       マスターテーブルの主キーマップ
781         * @param       slaveMap        スレーブテーブルの主キーマップ
782         *
783         * @return      処理結果のテーブルモデル
784         */
785        private DBTableModel makeMinus( final DBTableModel masterTbl,final Map<String,Integer> masterMap,
786                                                                        final Map<String,Integer> slaveMap ) {
787                final DBTableModel table = masterTbl;
788
789                @SuppressWarnings("rawtypes")
790                final Map.Entry[] entry = masterMap.entrySet().toArray( new Map.Entry[masterMap.size()] );
791
792                // 6.2.5.1 (2015/06/12) 削除する行番号を記憶しておく。
793                final List<Integer> rowList = new ArrayList<>();
794
795                // table.resetModify();         // 6.2.5.1 (2015/06/12) Modify情報をリセットしておく必要があった。
796
797                final int size = entry.length;
798                for( int i=0; i<size; i++ ) {
799                        String key  = (String)entry[i].getKey();
800                        if( key != null ) { key = key.toUpperCase(Locale.JAPAN); }              // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
801                        if( slaveMap.containsKey( key ) ) {             // スレーブにマスタが存在する
802                                rowList.add( (Integer)entry[i].getValue() );    // 6.2.5.1 (2015/06/12) rowをセット
803                        }
804                }
805
806                // 行番号が変わらないように逆順削除します。
807                // 6.2.5.1 (2015/06/12) rowを削除
808                for( int i=rowList.size()-1 ; i>=0; i-- ) {
809                        table.removeValue( rowList.get(i) );
810                }
811
812                return table;
813        }
814
815        /**
816         * 指定のマスタ,スレーブテーブルを使用して 差分集合 処理を実行します。
817         *
818         * @og.rev 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
819         *
820         * @param       masterTbl       マスターテーブルモデル
821         * @param       masterMap       マスターテーブルの主キーマップ
822         * @param       slaveTbl        スレーブテーブルモデル
823         * @param       slaveMap        スレーブテーブルの主キーマップ
824         *
825         * @return      処理結果のテーブルモデル
826         */
827        private DBTableModel makeDifference( final DBTableModel masterTbl,final Map<String,Integer> masterMap,
828                                                                                 final DBTableModel slaveTbl ,final Map<String,Integer> slaveMap ) {
829                final DBTableModel table = masterTbl;
830
831                // テーブルの差分属性のカラム番号を求めます。(マスタ、スレーブ共通)
832                final int[] diffClmNo = makeColumnNo( table,diffKeys );
833                final int diffClmSize = diffClmNo.length;
834
835                // スレーブからマスタへ値の再セットを行うカラム番号を求めます。(マスタ、スレーブ共通)
836                final int[] modClmNo = makeColumnNo( table,modifyClms );
837                final int modClmSize = modClmNo.length;
838
839                final int clmSize = table.getColumnCount();
840                final DBTableModel newTable = DBTableModelUtil.newDBTable();
841                newTable.init( clmSize );
842
843                // テーブルの全カラムを新たに作成するテーブルにコピーします。
844                for( int i=0; i<clmSize; i++ ) {
845                        newTable.setDBColumn( i,table.getDBColumn( i ) );
846                }
847
848                // スレーブの先頭カラムが、WRITABLE かどうか
849                final boolean writeFlag = "WRITABLE".equalsIgnoreCase( slaveTbl.getColumnName(0) );
850
851                @SuppressWarnings("rawtypes")
852                final Map.Entry[] entry = masterMap.entrySet().toArray( new Map.Entry[masterMap.size()] );
853
854                final int size = entry.length;
855                for( int i=0; i<size; i++ ) {
856                        String key  = (String)entry[i].getKey();
857                        if( key != null ) { key = key.toUpperCase(Locale.JAPAN); }              // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
858                        if( slaveMap.containsKey( key ) ) {             // スレーブにマスタが存在する
859                                final int mrow =  ((Integer)entry[i].getValue()).intValue();
860                                final int srow =  slaveMap.get( key ).intValue();
861                                boolean unmatched = false;
862                                for( int j=0; j<diffClmSize; j++ ) {
863                                        final String mval = table.getValue( mrow,diffClmNo[j] );
864                                        final String sval = slaveTbl.getValue( srow,diffClmNo[j] );
865                                        if( mval != null && !mval.equalsIgnoreCase( sval ) ) { unmatched = true; break; }               // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
866                                }
867
868                                if( unmatched ) {               // 属性情報が異なる場合のみ処理
869                                        // データのコピー
870                                        String[] mvals = new String[clmSize];
871                                        System.arraycopy( table.getValues( mrow ),0,mvals,0 ,clmSize );
872
873                                        // スレーブの値をマスタの値にセットする。
874                                        for( int j=0; j<modClmSize; j++ ) {
875                                                final String val = slaveTbl.getValue( srow,modClmNo[j] );
876                                                mvals[modClmNo[j]] = val;
877                                        }
878                                        newTable.addColumnValues( mvals );
879
880                                        if( useDiffData ) {
881                                                // データのコピー
882                                                String[] svals = new String[clmSize];
883                                                System.arraycopy( slaveTbl.getValues( srow ),0,svals,0 ,clmSize );
884                                                if( writeFlag ) { svals[0] = "0"; }     // 書き込み不許可
885                                                for( int j=0; j<diffClmSize; j++ ) {
886                                                        final int dclmNo = diffClmNo[j];
887                                                        final String mval = mvals[dclmNo];
888                                                        final String sval = svals[dclmNo];
889                                                        if( mval != null && !mval.equalsIgnoreCase( sval ) ) {          // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
890                                                                svals[dclmNo] = "<span class=\"unmatched\">" + sval + "</span>" ;
891                                                        }
892                                                }
893                                                newTable.addColumnValues( svals );
894                                        }
895                                }
896                        }
897                }
898                return newTable;
899        }
900
901        /**
902         * 指定のマスタ,スレーブテーブルを使用して 値列合成 処理を実行します。
903         *
904         *   UNION_VAL は、スレーブテーブルの縦列を横列に割り当てるUNION_CLMの特殊版です。
905         *   処理としては、そのまま割り当てるのではなく、スレーブテーブルの縦列の値と
906         *   ヘッダーとして指定する、unionClms の値を比較して、下限値の最大値を割り当てます。
907         *   つまり、ヘッダーの値と同じか、それ以下で、最も近い値を割り当てることになります。
908         *   これは、時間的な推移を表現することになります。
909         *     masterKeys:マスタとスレーブを関連付ける共通のキーとなるカラム
910         *     slaveKeys :スレーブの縦列を横列にするための、キーと値のカラム
911         *     unionClms :横列にするカラム名。この値とスレーブのキーと比較してセットするかどうかを決めます。
912         *
913         * @og.rev 6.9.1.0 (2018/02/26) 新規追加
914         *
915         * @param       masterTbl       マスターテーブルモデル
916         * @param       mstrKeys        マスターキー
917         * @param       slaveTbl        スレーブテーブルモデル
918         * @param       slaveKeys       スレーブキー
919         *
920         * @return      処理結果のテーブルモデル
921         */
922        private DBTableModel makeUnionVal( final DBTableModel masterTbl , final String mstrKeys , final DBTableModel slaveTbl , final String slaveKeys ) {
923
924                final Map<String,List<String[]>> slvMap = makeValMap( slaveTbl,mstrKeys,slaveKeys );
925
926                final DBTableModel table = makeAddClm( masterTbl );
927
928                // カラム名をカラム番号に変換します。
929                final int[] keyClmNo = makeColumnNo( table,mstrKeys );
930
931                final int[] mClmNo = makeColumnNo( table   ,unionClms );
932//              final int   addSize = mClmNo.length;            // unionClms の個数なので、マスタ、スレーブは同一
933
934                final String[] valClms = StringUtil.csv2Array( unionClms );             // 
935
936                // 突合せを行い、マッチするカラムについて、値をセットし直します。
937                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );
938                for( int row=0; row<table.getRowCount(); row++ ) {
939                        final String[] mvals = table.getValues( row );
940                        buf.setLength(0);
941                        for( int i=0; i<keyClmNo.length; i++ ) {
942                                buf.append( mvals[keyClmNo[i]] ).append( '|' );
943                        }
944                        // 主キー連結文字列
945                        final String key = buf.toString().toUpperCase(Locale.JAPAN);            // 大文字・小文字を区別しない。
946                        final List<String[]> slvVals = slvMap.get( key );
947                        if( slvVals != null ) {
948                                for( int j=0; j<valClms.length; j++ ) {                 // テーブルのヘッダー列
949                                        for( final String[] svals : slvVals ) {         // 値の配列 [0]=比較キー [1]=設定値
950                                                if( svals[0].compareTo( valClms[j] ) <= 0 ) {
951                                                        table.setValueAt( svals[1] , row , mClmNo[j] );
952                                                }
953                                                else {
954                                                        break;          // 値が超えれば、終了
955                                                }
956                                        }
957                                }
958                        }
959                }
960                table.resetModify();
961
962                return table;
963        }
964
965        /**
966         * 指定のマスタ,スレーブテーブルを使用して 列合成 処理を実行します。
967         *
968         * すでに、マスタ にカラムが存在している場合は、値の書き換えを、
969         * カラムが存在しなければ、カラムを追加します。
970         * マスタとスレーブのデータ突合せ時のキーは、slaveKeys になります。
971         * これは、masterMap を使用しないことを意味します。(masterKeys 指定によるGROUP化は
972         * 行います。masterKeys を指定しない場合は、サマライズなしで処理します。)
973         * 具体的には、マスタテーブルの複数の行に対して、スレーブデータの値が設定
974         * される可能性があることを意味します。
975         *
976         * @og.rev 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
977         *
978         * @param       masterTbl       マスターテーブルモデル
979         * @param       slaveKeys       スレーブキー
980         * @param       slaveTbl        スレーブテーブルモデル
981         * @param       slaveMap        スレーブテーブルの主キーマップ
982         *
983         * @return      処理結果のテーブルモデル
984         */
985        private DBTableModel makeUnionClm( final DBTableModel masterTbl ,final String slaveKeys ,
986                                                                                final DBTableModel slaveTbl ,final Map<String,Integer> slaveMap ) {
987
988                final DBTableModel table = makeAddClm( masterTbl );
989
990                // カラム名をカラム番号に変換します。
991                final int[] keyClmNo = makeColumnNo( table,slaveKeys );
992
993                final int[] mClmNo = makeColumnNo( table   ,unionClms );
994                final int[] sClmNo = makeColumnNo( slaveTbl,unionClms );
995                final int   addSize = mClmNo.length;            // unionClms の個数なので、マスタ、スレーブは同一
996
997                // 突合せを行い、マッチするカラムについて、値をセットし直します。
998                final StringBuilder buf = new StringBuilder( BUFFER_MIDDLE );   // 6.1.0.0 (2014/12/26) refactoring
999                for( int row=0; row<table.getRowCount(); row++ ) {
1000                        final String[] mvals = table.getValues( row );
1001                        buf.setLength(0);                                                                               // 6.1.0.0 (2014/12/26) refactoring
1002                        for( int i=0; i<keyClmNo.length; i++ ) {
1003                                buf.append( mvals[keyClmNo[i]] ).append( '|' );         // 6.0.2.5 (2014/10/31) char を append する。
1004                        }
1005                        // 主キー連結文字列
1006                        final String key = buf.toString().toUpperCase(Locale.JAPAN);            // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
1007                        if( slaveMap.containsKey( key ) ) {             // スレーブにマスタに対応するデータが存在する
1008                                final int slvRow = slaveMap.get( key ).intValue();
1009                                final String[] svals = slaveTbl.getValues( slvRow );            // スレーブの行番号
1010                                for( int j=0; j<addSize; j++ ) {
1011                                        mvals[mClmNo[j]] = svals[sClmNo[j]];
1012                                }
1013                                table.setValues( mvals,row );
1014                        }
1015                }
1016                table.resetModify();
1017
1018                return table;
1019        }
1020
1021        /**
1022         * 指定のマスタテーブルに 列追加 処理を実行します。
1023         *
1024         * すでに、マスタ にカラムが存在している場合は、値の書き換えを、
1025         * カラムが存在しなければ、カラムを追加します。
1026         *
1027         * @og.rev 6.9.1.0 (2018/02/26) unionLbls追加
1028         *
1029         * @param       masterTbl       マスターテーブルモデル
1030         *
1031         * @return      処理結果のテーブルモデル
1032         */
1033        private DBTableModel makeAddClm( final DBTableModel masterTbl ) {
1034                final String[]  addClms  = StringUtil.csv2Array( unionClms );
1035                final int       addClmSize = addClms.length;
1036                boolean[] useAdd         = new boolean[addClmSize];
1037                int addSize = 0;
1038                for( int i=0; i<addClmSize; i++ ) {
1039                        if( masterTbl.getColumnNo( addClms[i],false ) < 0 ) {   // 存在しなければ -1
1040                                useAdd[i] = true;
1041                                addSize++ ;
1042                        }
1043                        else {
1044                                useAdd[i] = false;              // マスタに存在すれば、追加不要
1045                        }
1046                }
1047
1048                final int mstrClmSize = masterTbl.getColumnCount();
1049                final int clmSize = mstrClmSize + addSize;
1050
1051                final DBTableModel table = DBTableModelUtil.newDBTable();
1052                table.init( clmSize );
1053                int clmNo = 0;
1054                // マスタテーブルの全カラムを新たに作成するテーブルにコピーします。
1055                for( int i=0; i<mstrClmSize; i++ ) {
1056                        table.setDBColumn( clmNo++,masterTbl.getDBColumn( i ) );
1057                }
1058
1059                // 6.9.1.0 (2018/02/26) unionLbls追加
1060                final String[]  addLbls  = StringUtil.csv2Array( unionLbls , ',' , addClmSize );        // 無くてもaddClmSize 個の配列を作る。
1061
1062                // 追加するカラムを新たに作成するテーブルに追加します。
1063                String[] addClmVal = new String[addSize];       // 追加分のみ
1064                int addCnt = 0;
1065                for( int i=0; i<addClmSize; i++ ) {
1066                        if( useAdd[i] ) {
1067//                              final DBColumn column = getDBColumn( addClms[i] );
1068                                final DBColumn column = getResource().makeDBColumn( addClms[i] , addLbls[i] );  // 6.9.1.0 (2018/02/26)
1069                                addClmVal[addCnt++] = nval( column.getDefault(),"" );
1070                                table.setDBColumn( clmNo++,column );
1071                        }
1072                }
1073                // 一旦、すべてのマスタデータを新テーブルにコピーします。
1074                for( int row=0; row<masterTbl.getRowCount(); row++ ) {
1075                        final String[] vals = new String[clmSize];
1076                        System.arraycopy( masterTbl.getValues( row ),0,vals,0 ,mstrClmSize );   // マスタデータのコピー
1077                        System.arraycopy( addClmVal,0,vals,mstrClmSize ,addSize );                              // 追加列情報の初期値
1078                        table.addColumnValues( vals );
1079                }
1080
1081                return table;
1082        }
1083
1084        /**
1085         * 指定のマスタテーブルを使用して グループ 処理を実行します。
1086         *
1087         * @param       masterTbl       マスターテーブルモデル
1088         *
1089         * @return      処理結果のテーブルモデル
1090         */
1091        private DBTableModel makeGroup( final DBTableModel masterTbl ) {
1092                return masterTbl ;
1093        }
1094
1095        /**
1096         * 指定のマスタ,スレーブテーブルを使用して、改廃コード(A,C)を設定します。
1097         * スレーブにデータがあれば、"C" を、なければ、"A" をセットします。
1098         * "D" は、設定できません。
1099         *
1100         * @og.rev 6.3.1.1 (2015/07/10) 改廃コードを設定する CDKH アクションを追加
1101         *
1102         * @param       masterTbl       マスターテーブルモデル
1103         * @param       masterMap       マスターテーブルの主キーマップ
1104         * @param       slaveTbl        スレーブテーブルモデル
1105         * @param       slaveMap        スレーブテーブルの主キーマップ
1106         *
1107         * @return      処理結果のテーブルモデル
1108         */
1109        private DBTableModel makeCdkh( final DBTableModel masterTbl,final Map<String,Integer> masterMap,
1110                                                                                 final DBTableModel slaveTbl ,final Map<String,Integer> slaveMap ) {
1111                final DBTableModel table = masterTbl;
1112
1113                // スレーブからマスタへ値の再セットを行うカラム番号を求めます。(マスタ、スレーブ共通)
1114                final int[] modClmNo = makeColumnNo( table,modifyClms );
1115                final int modClmSize = modClmNo.length;
1116
1117                @SuppressWarnings("rawtypes")
1118                final Map.Entry[] entry = masterMap.entrySet().toArray( new Map.Entry[masterMap.size()] );
1119
1120                table.resetModify();            // リセットしておきます。
1121
1122                final int size = entry.length;
1123                for( int i=0; i<size; i++ ) {
1124                        String key  = (String)entry[i].getKey();
1125                        if( key != null ) { key = key.toUpperCase(Locale.JAPAN); }              // 5.5.8.5 (2012/11/27) 大文字・小文字を区別しない。
1126                        if( slaveMap.containsKey( key ) ) {                             // スレーブにマスタが存在する
1127                                final int mrow =  ((Integer)entry[i].getValue()).intValue();
1128                                table.setModifyType( mrow , "C" );                      // 一致すれば、C:変更タイプ
1129
1130                                // スレーブの値をマスタの値にセットする。
1131                                final int srow = slaveMap.get( key ).intValue();
1132                                for( int j=0; j<modClmSize; j++ ) {
1133                                        final String val = slaveTbl.getValue( srow,modClmNo[j] );       // スレーブから取り出して
1134                                        table.setValueAt( val,mrow,modClmNo[j] );                                       // マスタにセットする。
1135                                }
1136                        }
1137                }
1138
1139                for( int row=0; row<table.getRowCount(); row++ ) {
1140                        if( table.getModifyType( row ).isEmpty() ) {
1141                                table.setModifyType( row , "A" );                       // 残りを、A:追加タイプ
1142                        }
1143                }
1144
1145                return table;
1146        }
1147
1148        /**
1149         * 指定の値がすべてnull(空文字列)の場合、レコードを削除します。
1150         *
1151         * @og.rev 6.7.3.0 (2017/01/27) 指定の値がすべてnull(空文字列)の場合、レコードを削除します。
1152         *
1153         * @param       table   マップ作成元のデータテーブル(副作用あり)
1154         * @param       delClms null(空文字列)判定を行うカラム列(CSV形式)
1155         *
1156         * @return レコードが削除されたテーブル
1157         */
1158        private DBTableModel deleteRows( final DBTableModel table, final String delClms ) {
1159
1160                // カラム名をカラム番号に変換します。
1161                final int[] clmNo = makeColumnNo( table,delClms );
1162                final int   clmSize = clmNo.length;
1163                if( clmSize == 0 ) {    // マスタキー未指定時には全カラムを使用します。
1164                        return table;
1165                }
1166
1167                // レコードの削除なので逆順に処理します。
1168                for( int row=table.getRowCount()-1; row>=0; row-- ) {
1169                        boolean isNull = true;
1170                        for( int i=0; i<clmSize; i++ ) {
1171                                if( !StringUtil.isNull( table.getValue( row,clmNo[i] ) ) ) {
1172                                        isNull = false;
1173                                        break;
1174                                }
1175                        }
1176
1177                        if( isNull ) { table.removeValue( row ); }
1178                }
1179
1180                return table;
1181        }
1182
1183        /**
1184         * 指定のテーブルと同じテーブルを別オブジェクトとして作成します。
1185         *
1186         * @param       tbl     コピー元テーブルモデル
1187         *
1188         * @return      コピーされた新テーブルモデル
1189         */
1190        private DBTableModel cloneTable( final DBTableModel tbl ) {
1191                final int clmSize = tbl.getColumnCount();
1192
1193                final DBTableModel table = DBTableModelUtil.newDBTable();
1194                table.init( clmSize );
1195
1196                // テーブルの全カラムを新たに作成するテーブルにコピーします。
1197                for( int i=0; i<clmSize; i++ ) {
1198                        table.setDBColumn( i,tbl.getDBColumn( i ) );
1199                }
1200                // すべてのデータを新テーブルにコピーします。
1201                for( int row=0; row<tbl.getRowCount(); row++ ) {
1202                        final String[] vals = new String[clmSize];
1203                        System.arraycopy( tbl.getValues( row ),0,vals,0 ,clmSize );     // データのコピー
1204                        table.addColumnValues( vals );
1205                }
1206                return table;
1207        }
1208
1209        /**
1210         * 指定のテーブルより、カラム列名に対応するカラム番号配列を作成します。
1211         *
1212         * カラム名のCSVデータが 指定されない場合(clmcsv == null)は、長さ0の配列を返します。
1213         *
1214         * @param       table   テーブルモデル
1215         * @param       clmcsv  カラム名のCSVデータ
1216         *
1217         * @return      カラム名に対応する、列番号配列(なければ、長さ0配列)
1218         */
1219        private int[] makeColumnNo( final DBTableModel table,final String clmcsv ) {
1220
1221                // マスタテーブルの差分属性のカラム番号を求めます。
1222                final String[] clms = StringUtil.csv2Array( clmcsv );
1223                int[] clmNo = new int[clms.length];
1224
1225                // カラム名をカラム番号に変換します。
1226                for( int i=0; i<clms.length; i++ ) {
1227                        clmNo[i] = table.getColumnNo( clms[i] );
1228                }
1229
1230                return clmNo;
1231        }
1232
1233        /**
1234         * 【TAG】コマンド (NEW,RENEW)をセットします(初期値:NEW)。
1235         *
1236         * @og.tag
1237         * コマンドは,HTMLから(get/post)指定されますので,CMD_xxx で設定される
1238         * フィールド定数値のいづれかを、指定できます。
1239         * 初期値は NEW です。
1240         *
1241         * @param       cmd     コマンド (public static final 宣言されている文字列)
1242         * @see         <a href="../../../../constant-values.html#org.opengion.hayabusa.taglib.TableMergeTag.CMD_NEW">コマンド定数</a>
1243         */
1244        public void setCommand( final String cmd ) {
1245                final String cmd2 = getRequestParameter( cmd );
1246                if( cmd2 != null && cmd2.length() > 0 ) { command = cmd2.toUpperCase(Locale.JAPAN); }
1247        }
1248
1249        /**
1250         * 【TAG】アクションを指定します[UNION_ALL/UNION/INTERSECT/MINUS/DIFFERENCE/UNION_CLM/UNION_VAL/ADD_CLM/GROUP/UNION_SELROW/CDKH/TABLE_REMOVE]。
1251         *
1252         * @og.tag
1253         * 指定できるアクションは、全体集合(UNION_ALL)、全体集合(挿入位置指定)(UNION_SELROW)、和集合(UNION)
1254         * 、積集合(INTERSECT)、差集合(MINUS)、差分集合(DIFFERENCE)、列合成(UNION_CLM)、値列合成(UNION_VAL)、列追加(ADD_CLM)、 グループ(GROUP)です。
1255         * 列合成とグループ以外の処理では、カラム順とカラム数は同数でなければなりません。
1256         * primaryKeys や unionClms などの指定のキー名は、マスタテーブルに存在する必要があります。
1257         * マスタテーブルと同じカラム番号でスレーブテーブルよりデータを読み出します。
1258         * (カラム名や属性は、異なってもかまいませんが、マスタテーブルに準拠します。)
1259         * また、単独(マスタテーブルのみ)で、和集合と同等の、グループ(GROUP)を使用すると、指定の
1260         * カラムでのユニーク化を行うことが可能になります。グループ処理では、先行優先とし、
1261         * 2回目に現れた情報を削除することになります。グループ が指定された場合は、
1262         * スレーブテーブルは無視されます。いずれの処理においても、集合処理を行う主キーで
1263         * 一旦グループ化されます。全体集合(UNION_ALL)で処理する場合でも、主キーがユニークで
1264         * ない場合は、マスター、スレーブの各テーブルで一旦グループ化された後で、マージされます。
1265         * (マージ後には、同一主キーを持つ行は存在します。)
1266         * 全体集合(UNION_ALL)の場合のみ、mergeKeys を指定する必要はありません。その場合は、
1267         * キーなしのため、マスターとスレーブのテーブルを単に合成するだけになります。
1268         *
1269         * <table border="1" frame="box" rules="all" >
1270         *   <caption>アクションの説明</caption>
1271         *   <tr><th>action      </th><th>名称    </th><th>処理概要                                                                                                   </th><th>1</th><th>2</th><th>3</th><th>4</th><tr>
1272         *   <tr><td>UNION_ALL   </td><td>全体集合</td><td>マスタとスレーブを合成                                                                      </td><td>○</td><td>○</td><td> </td><td> </td><tr>
1273         *   <tr><td>UNION       </td><td>和集合  </td><td>マスタとスレーブのユニーク部のみ合成                                              </td><td>○</td><td>○</td><td> </td><td> </td><tr>
1274         *   <tr><td>INTERSECT   </td><td>積集合  </td><td>マスタとスレーブのユニーク部が一致するマスタのみ選択              </td><td>○</td><td>○</td><td> </td><td> </td><tr>
1275         *   <tr><td>MINUS       </td><td>差集合  </td><td>マスタからスレーブに存在するユニーク部を削除した残り              </td><td>○</td><td>○</td><td> </td><td> </td><tr>
1276         *   <tr><td>DIFFERENCE  </td><td>差分集合</td><td>ユニーク部が一致し、差分カラムが異なるマスタのみ選択               </td><td>○</td><td>○</td><td> </td><td>○</td><tr>
1277         *   <tr><td>UNION_CLM   </td><td>列合成  </td><td>マスタとキー一致するスレーブのカラム情報を追加                 </td><td>○</td><td>○</td><td>○</td><td> </td><tr>
1278         *   <tr><td>UNION_VAL   </td><td>値列合成</td><td>マスタとキー一致するスレーブの縦列をカラムに追加                 </td><td>○</td><td>○</td><td>○</td><td> </td><tr>
1279         *   <tr><td>ADD_CLM     </td><td>列追加  </td><td>UNION_CLMとの違いは、カラムのみ追加することです。           </td><td> </td><td> </td><td>○</td><td> </td><tr>
1280         *   <tr><td>GROUP       </td><td>グループ</td><td>マスタのユニーク部化                                                                               </td><td> </td><td> </td><td> </td><td> </td><tr>
1281         *   <tr><td>UNION_SELROW</td><td>全体集合</td><td>マスタとスレーブを合成(マスタ表のチェック行を起点に追加     </td><td>○</td><td> </td><td> </td><td> </td><tr>
1282         *   <tr><td>CDKH        </td><td>改廃CD  </td><td>改廃コードを設定                                                                                       </td><td>○</td><td>○</td><td> </td><td>○</td><tr>
1283         *   <tr><td>TABLE_REMOVE</td><td>TBL削除 </td><td>マスタテーブルオブジェクトを無条件で、削除します                       </td><td> </td><td> </td><td> </td><td> </td><tr>
1284         * </table>
1285         *
1286         * ※:マスタテーブルオブジェクトは、常に必須
1287         * 1:スレーブテーブルオブジェクト必須
1288         * 2:masterKeys 属性必須
1289         * 3:unionClms 属性必須(スレーブテーブルのカラム名または追加するカラム名)
1290         * 4:diffKeys 属性必須(DIFFERENCE時の差分カラム名)、modifyClms 属性使用可能
1291         *
1292         * @param       action アクション [UNION_ALL/UNION/INTERSECT/MINUS/DIFFERENCE/UNION_CLM/ADD_CLM/GROUP/UNION_SELROW/CDKH]
1293         */
1294        public void setAction( final String action ) {
1295                this.action = nval( getRequestParameter( action ),this.action );
1296        }
1297
1298        /**
1299         * 【TAG】出力先のtableIdを指定します
1300         *              (初期値:HybsSystem#TBL_MDL_KEY[={@og.value HybsSystem#TBL_MDL_KEY}])。
1301         *
1302         * @og.tag
1303         * 集合処理結果の DBTableModel をメモリにセットする場合のキー(tableId)を指定します。
1304         * (初期値:HybsSystem#TBL_MDL_KEY[={@og.value HybsSystem#TBL_MDL_KEY}])。
1305         *
1306         * @param       id テーブルID (sessionに登録する時のID)
1307         * @see         org.opengion.hayabusa.common.HybsSystem#TBL_MDL_KEY
1308         */
1309        public void setTableId( final String id ) {
1310                tableId = nval( getRequestParameter( id ),tableId );
1311        }
1312
1313        /**
1314         * 【TAG】出力先のscopeを指定します(初期値:session)。
1315         *
1316         * @og.tag
1317         * 集合処理結果の DBTableModel をメモリにセットする場合のスコープを指定します。
1318         * ここでは、マスタやスレーブのスコープ設定が必要な為、superクラスのメソッドを
1319         * オーバーライドしてこのオブジェクト内でキープしています。
1320         * 初期値は、session です。
1321         *
1322         * @param       scope   出力先のscope
1323         */
1324        @Override
1325        public void setScope( final String scope ) {
1326                this.scope = nval( getRequestParameter( scope ),this.scope );
1327        }
1328
1329        /**
1330         * 【TAG】マスタテーブルのtableIdを指定します
1331         *              (初期値:HybsSystem#TBL_MDL_KEY[={@og.value HybsSystem#TBL_MDL_KEY}])。
1332         *
1333         * @og.tag
1334         * 集合処理のマスタとなる DBTableModel をメモリから取り出す場合のキー(tableId)を指定します。
1335         * (初期値:HybsSystem#TBL_MDL_KEY[={@og.value HybsSystem#TBL_MDL_KEY}])。
1336         *
1337         * @param       masterTableId   マスタテーブルID
1338         * @see         org.opengion.hayabusa.common.HybsSystem#TBL_MDL_KEY
1339         */
1340        public void setMasterTableId( final String masterTableId ) {
1341                this.masterTableId = nval( getRequestParameter( masterTableId ),this.masterTableId );
1342        }
1343
1344        /**
1345         * 【TAG】マスタテーブルのscopeを指定します(初期値:session)。
1346         *
1347         * @og.tag
1348         * 集合処理のマスタとなる DBTableModel をメモリから取り出す場合のスコープを指定します。
1349         * 初期値は、session です。
1350         *
1351         * @param       masterScope     マスタスコープ
1352         */
1353        public void setMasterScope( final String masterScope ) {
1354                this.masterScope = nval( getRequestParameter( masterScope ),this.masterScope );
1355        }
1356
1357        /**
1358         * 【TAG】マスタテーブルの集合処理を行う主キーを指定します。
1359         *
1360         * @og.tag
1361         * 集合処理を行う場合の、カラム名を、CSV形式(CSV形式)で指定します。
1362         * このキーの組み合わせを元に、集合処理の突合せを行います。
1363         * なお、アクションがグループ(GROUP)以外の処理では、マスタとスレーブのカラム数と
1364         * 並び順は、同じでなければなりません。カラム名は、各々別々でもかまいません。
1365         * アクションが全体集合(UNION_ALL)以外の場合は、必須属性になります。
1366         *
1367         * @param       masterKeys      マスタテーブル主キー (CSV形式)
1368         */
1369        public void setMasterKeys( final String masterKeys ) {
1370                this.masterKeys = nval( getRequestParameter( masterKeys ),this.masterKeys );
1371        }
1372
1373        /**
1374         * 【TAG】スレーブテーブルの集合処理を行う主キーを指定します。
1375         *
1376         * @og.tag
1377         * 集合処理を行う場合の、カラム名を、CSV形式(CSV形式)で指定します。
1378         * このキーの組み合わせを元に、集合処理の突合せを行います。
1379         * なお、アクションがグループ(GROUP)以外の処理では、マスタとスレーブのカラム数と
1380         * 並び順は、同じでなければなりません。カラム名は、各々別々でもかまいません。
1381         * null の場合は、masterKeys と同じとします。
1382         *
1383         * @param       slaveKeys       スレーブ主キー (CSV形式)
1384         */
1385        public void setSlaveKeys( final String slaveKeys ) {
1386                this.slaveKeys = nval( getRequestParameter( slaveKeys ),this.slaveKeys );
1387        }
1388
1389        /**
1390         * 【TAG】マスタテーブルのDIFFERENCE時の差分カラム名を(CSV形式)指定します。
1391         *
1392         * @og.tag
1393         * アクションが差分処理(DIFFERENCE)の場合に、差分チェックを行うカラム名を、
1394         * CSV形式(CSV形式)で指定します。
1395         * 差分処理とは、masterKeys で指定されたキーでは、マスタ、スレーブともに存在し
1396         * かつ、このキー(diffKeys)で指定されたキーの値が異なるマスタレコードを
1397         * 抜き出します。
1398         * つまり、主キーは存在し、属性が異なる情報のピックアップになりますので、
1399         * データ更新(UPDATE)対象を見つける場合に使用できます。
1400         * アクションが差分処理(DIFFERENCE)の場合は、必須属性になります。
1401         *
1402         * @param       diffKeys        差分カラム名 (CSV形式)
1403         * @see         #setMasterKeys( String )
1404         */
1405        public void setDiffKeys( final String diffKeys ) {
1406                this.diffKeys = nval( getRequestParameter( diffKeys ),this.diffKeys );
1407        }
1408
1409        /**
1410         * 【TAG】スレーブテーブルのtableIdを指定します
1411         *              (初期値:HybsSystem#TBL_MDL_KEY[={@og.value HybsSystem#TBL_MDL_KEY}])。
1412         *
1413         * @og.tag
1414         * 集合処理のスレーブとなる DBTableModel をメモリから取り出す場合のキー(tableId)を指定します。
1415         * なお、アクションがグループ(GROUP)の場合は、スレーブテーブルは使用されません。
1416         * (初期値:HybsSystem#TBL_MDL_KEY[={@og.value HybsSystem#TBL_MDL_KEY}])。
1417         *
1418         * @param       slaveTableId    スレーブテーブルID
1419         * @see         org.opengion.hayabusa.common.HybsSystem#TBL_MDL_KEY
1420         */
1421        public void setSlaveTableId( final String slaveTableId ) {
1422                this.slaveTableId = nval( getRequestParameter( slaveTableId ),this.slaveTableId );
1423        }
1424
1425        /**
1426         * 【TAG】スレーブテーブルのscopeを指定します(初期値:session)。
1427         *
1428         * @og.tag
1429         * 集合処理のスレーブとなる DBTableModel をメモリから取り出す場合のスコープを指定します。
1430         * なお、アクションがグループ(GROUP)の場合は、スレーブテーブルは使用されません。
1431         * 初期値は、session です。
1432         *
1433         * @param       slaveScope      スレーブスコープ
1434         */
1435        public void setSlaveScope( final String slaveScope ) {
1436                this.slaveScope = nval( getRequestParameter( slaveScope ),this.slaveScope );
1437        }
1438
1439        /**
1440         * 【TAG】スレーブからマスタへ追加するカラム名をCSV形式で指定します。
1441         *
1442         * @og.tag
1443         * アクションが列合成(UNION_CLM)、値列合成(UNION_VAL)または列追加(ADD_CLM)の場合に使用されます。
1444         * 列合成(UNION_CLM)は、マスタとスレーブの主キーに対して、ここで指定のスレーブの
1445         * カラム列名を、マスタの列に追加します。主キーがマッチしない行に関しては、
1446         * カラムの初期値が適用されたデータを作成します。
1447         * 列追加(ADD_CLM)は、マスタテーブルに指定のカラムを追加するだけです、スレーブテーブルは
1448         * 参照しません。よって、主キーも指定不要です。
1449         *
1450         * @param       unionClms       列合成カラム名 (CSV形式)
1451         */
1452        public void setUnionClms( final String unionClms ) {
1453                this.unionClms = nval( getRequestParameter( unionClms ),this.unionClms );
1454        }
1455
1456        /**
1457         * 【TAG】スレーブからマスタへ追加するラベルをCSV形式で指定します。
1458         *
1459         * @og.tag
1460         * アクションが列合成(UNION_CLM)、値列合成(UNION_VAL)または列追加(ADD_CLM)の場合に、
1461         * unionClmsと共に使用されます。
1462         * 
1463         * 特に、値列合成(UNION_VAL)時のカラムは、縦列の値からカラムを作成する関係で、
1464         * 通常カラムリソースに存在しません。
1465         * そこで、キーをそのままヘッダーに表示する場合に、不都合が発生する場合があるため、
1466         * ラベルを置き換える機能を用意します。
1467         *
1468         * @og.rev 6.9.1.0 (2018/02/26) unionLbls属性追加
1469         *
1470         * @param       unionLbls       列合成カラム名 (CSV形式)
1471         */
1472        public void setUnionLbls( final String unionLbls ) {
1473                this.unionLbls = nval( getRequestParameter( unionLbls ),this.unionLbls );
1474        }
1475
1476        /**
1477         * 【TAG】指定の値がすべてnull(空文字列)の場合、レコードを削除するカラムをCSV形式で指定します。
1478         *
1479         * @og.tag
1480         * アクションが(GROUP)で、指定のカラム列の値が、すべてnull(空文字列)の場合は、
1481         * そのレコード自身を削除します。
1482         *
1483         * @og.rev 6.7.3.0 (2017/01/27) nullDelClms属性追加
1484         *
1485         * @param       nullDelClms     null(空文字列)の場合、レコードを削除するカラムをCSV形式で指定
1486         */
1487        public void setNullDelClms( final String nullDelClms ) {
1488                this.nullDelClms = nval( getRequestParameter( nullDelClms ),this.nullDelClms );
1489        }
1490
1491        /**
1492         * 【TAG】スレーブからマスタへ値を更新するカラム名をCSV形式で指定します。
1493         *
1494         * @og.tag
1495         * アクションが差分処理(DIFFERENCE)、改廃CD(CDKH)の場合に、結果にマスタテーブルが抜き出されますが、
1496         * 更新する場合に、スレーブ特有のユニークキー(例:UNIQ)を用いて更新する場合、
1497         * 指定のカラム値は、スレーブの値にセットしておきたい場合があります。
1498         * ここでは、指定のカラムについて、値だけスレーブからマスタへセットします。
1499         * なお、値の更新については、マスタとスレーブが同一キーという制約があります。
1500         *
1501         * @param       modifyClms      値更新カラム名 (CSV形式)
1502         */
1503        public void setModifyClms( final String modifyClms ) {
1504                this.modifyClms = nval( getRequestParameter( modifyClms ),this.modifyClms );
1505        }
1506
1507        /**
1508         * 【TAG】集合処理するときに、相違データをCSV連結して残すカラム名をCSV形式で指定します。
1509         *
1510         * @og.tag
1511         * masterKeysで集合処理するときに、通常、最初に見つかった行データのみ残りますが、
1512         * ここに指定したカラムについては、発生都度、自分自身の情報に、CSV形式で連結して
1513         * いきます。
1514         * この操作により、本来削除された情報が、1行のCSV形式で取得できる効果が得られます。
1515         * これは、value タグの action="APPEND" を、DBTableModel に対して実施するような感じです。
1516         *
1517         * @og.rev 5.1.4.0 (2010/03/01) 新規追加
1518         *
1519         * @param       groupAddClms    相違データCSV連結 (CSV形式)
1520         */
1521        public void setGroupAddClms( final String groupAddClms ) {
1522                this.groupAddClms = nval( getRequestParameter( groupAddClms ),this.groupAddClms );
1523        }
1524
1525        /**
1526         * 【TAG】テーブルモデルに対する副作用の有無[true:ない/false:ある]を指定します(初期値:false:ある)。
1527         *
1528         * @og.tag
1529         * すべての処理で、DBTableModel に対して、ユニーク化やグループ化などの集合処理を
1530         * 行う過程で、マスタテーブルに対して直接処理を行うと、副作用が発生します。
1531         * 同様に、スレーブテーブルにおいても、一旦キー列でグループ化されるため、副作用が
1532         * 発生します。これは、無駄なメモリ領域の確保と、テーブル(マスタ、スレーブとも)の
1533         * コピー処理時間の節約になります。初期値の設定も副作用がある状態になっています。
1534         * ところが、都合によっては、色々な action を連続して行いたい場合など、毎回、
1535         * データベースを検索するよりもメモリ上でコピーしたほうが都合がよいケースでは、
1536         * 副作用が出ないように、noSideEffect="true" に設定します。
1537         * ただし、マスタ、スレーブともテーブルをコピーを行い、結果のテーブルも派生する為、
1538         * 通常、2つの領域(マスタと結果は同じテーブルに書かれる)で良い所を、5つの領域が
1539         * 作成されます。
1540         * 初期値は、副作用がある(noSideEffect="false")です。
1541         *
1542         * @param       noSideEffect    処理結果副作用 [true:ない/false:ある]
1543         */
1544        public void setNoSideEffect( final String noSideEffect ) {
1545                this.noSideEffect = nval( getRequestParameter( noSideEffect ),this.noSideEffect );
1546        }
1547
1548        /**
1549         * 【TAG】差分のスレーブデータを結果テーブルに追加するかどうかを指定します(初期値:true)。
1550         *
1551         * @og.tag
1552         * アクションが差分処理(DIFFERENCE)の場合に、結果にマスタテーブルが抜き出されますが、
1553         * 差分対象のスレーブデータと比較したい場合があります。
1554         * このフラグを true にセットすると、書込み禁止属性が付いた状態で、スレーブデータが
1555         * 結果テーブルに追加されます。
1556         * なお、この処理では、通常と異なり、マスタテーブルにはグループ化の副作用は発生しますが、
1557         * 結果テーブルは新規に作成され、先頭行に必ず WRITABLE カラムが付加されます。
1558         * 初期値は、true:追加する です。
1559         *
1560         * @param       flag    差分追加 [true:追加する/false:追加しない]
1561         */
1562        public void setUseDiffData( final String flag ) {
1563                useDiffData = nval( getRequestParameter( flag ),useDiffData );
1564        }
1565
1566        /**
1567         * 【TAG】マスタテーブルの選択行のデータのみを対象に処理を行うかどうか[true:する/false:しない]を指定します(初期値:false)。
1568         *
1569         * @og.tag
1570         * 処理対象のマスタテーブルについて、選択行が指定された場合に、選択行のみを処理対象に
1571         * するか、全件を対象にするかを指定します。
1572         * 積集合や差分集合など通常は、全件を対象にすることになりますが、列合成や列追加など、
1573         * マスタテーブルに対してのみ作用を及ぼす処理では、選択行のみを対象に処理を行う事が
1574         * 考えられます。その場合、初期グループ化と同じで、対象とする行が選択行のみになります。
1575         * 初期値は、false:全件対象 です。
1576         *
1577         * @param       flag    選択行のみ対象 [true:選択行のみ/false:全件]
1578         */
1579        public void setUseCheckOnly( final String flag ) {
1580                useCheckOnly = nval( getRequestParameter( flag ),useCheckOnly );
1581        }
1582
1583        /**
1584         * 【TAG】マージの結果を表示するかどうか[true:する/false:しない]を指定します(初期値:true)。
1585         *
1586         * @og.tag
1587         * true で、マージ結果を表示します。 false では、何も表示しません(初期値:true)
1588         * マスタテーブルの件数は、通常、キーでグループ化されるため、入力件数と異なります。
1589         * 同様に、スレーブ件数も異なります。結果の件数は、処理結果が現実的かどうかの
1590         * 判断に使用されます。
1591         * 初期値は、true:表示する です。
1592         *
1593         * @param       flag    結果表示 [true:する/false:しない]
1594         */
1595        public void setDisplay( final String flag ) {
1596                display = nval( getRequestParameter( flag ),display );
1597        }
1598
1599        /**
1600         * 【TAG】検索結果が0件のとき処理を停止するかどうか[true/false]を指定します(初期値:false[続行する])。
1601         *
1602         * @og.tag
1603         * 初期値は、false(続行する)です。
1604         *
1605         * @og.rev 5.7.6.2 (2014/05/16) 新規追加
1606         *
1607         * @param  flag 0件時停止 [true:処理を中止する/false:続行する]
1608         */
1609        public void setStopZero( final String flag ) {
1610                stopZero = nval( getRequestParameter( flag ),stopZero );
1611        }
1612
1613        /**
1614         * 【TAG】scope="request" のスレーブテーブルをループして使用するかどうか[true/false]を指定します(初期値:false[使用しない])。
1615         *
1616         * action="UNION_CLM" では、カラムを動的に追加していきます。これを、繰り返すことで、特定の処理結果を、
1617         * カラム列にコピーしていく処理が可能になります。(クロステーブル的な処理です。)
1618         * 内容的には、scope="request" の同一の DBTableModel を、初回に、scope="session" にコピーすることで、
1619         * 以後、マスターテーブルとして処理を続けるというものです。
1620         * 初回かどうかを判別するのは、scope="session" の DBTableModel が存在しない場合は、scope="request" のDBTableModel を
1621         * scope="session" に移すだけの処理を行います。
1622         * 以降は、scope="session" に、DBTableModel が存在するはずなので、これを、マスターテーブルとして使用します。
1623         * scope="session" の DBTableModel を消すのは、action="TABLE_REMOVE" です。
1624         *
1625         * @og.tag
1626         * 初期値は、false(使用しない)です。
1627         *
1628         * @og.rev 6.7.3.0 (2017/01/27) useSlaveLoop属性追加
1629         *
1630         * @param  flag スレーブテーブルをループして使用するかどうか [true:使用する/false:使用しない]
1631         */
1632        public void setUseSlaveLoop( final String flag ) {
1633                useSlaveLoop = nval( getRequestParameter( flag ),useSlaveLoop );
1634        }
1635
1636        /**
1637         * 【TAG】(通常は使いません)タグで処理される処理がメインとなるトランザクション処理かどうかを指定します(初期値:true)。
1638         *
1639         * @og.tag
1640         * この値は、ファイルダウンロード処理に影響します。この値がtrueに指定された時にcommitされたDBTableModelが
1641         * ファイルダウンロードの対象の表になります。
1642         *
1643         * このパラメーターは、通常、各タグにより実装され、ユーザーが指定する必要はありません。
1644         * 但し、1つのJSP内でDBTableModelが複数生成される場合に、前に処理したDBTableModelについてファイルダウンロードをさせたい
1645         * 場合は、後ろでDBTableModelを生成するタグで、明示的にこの値をfalseに指定することで、ファイルダウンロード処理の対象から
1646         * 除外することができます。
1647         *
1648         * @og.rev 5.1.6.0 (2010/05/01) 新規作成
1649         *
1650         * @param  flag メイントランザクションかどうか [true:メイン/false:その他]
1651         */
1652        public void setMainTrans( final String flag ) {
1653                isMainTrans = nval( getRequestParameter( flag ),isMainTrans );
1654        }
1655
1656        /**
1657         * 【TAG】groupAddClmsで文字列を連結する項目区切り文字をセットします(初期値:",")。
1658         *
1659         * @og.tag
1660         * groupAddClmsで文字列を連結する項目区切り文字をセットします(初期値:",")。
1661         * 初期値は、"," に設定されています。
1662         *
1663         * @og.rev 5.3.1.0 (2011/01/01)
1664         *
1665         * @param   sepa        項目区切り文字 (初期値:",")
1666         */
1667        public void setSeparator( final String sepa ) {
1668                separator = nval( getRequestParameter( sepa ),separator );
1669        }
1670
1671        /**
1672         * このオブジェクトの文字列表現を返します。
1673         * 基本的にデバッグ目的に使用します。
1674         *
1675         * @return このクラスの文字列表現
1676         * @og.rtnNotNull
1677         */
1678        @Override
1679        public String toString() {
1680                return ToString.title( this.getClass().getName() )
1681                                .println( "VERSION"                     ,VERSION                )
1682                                .println( "action"                      ,action                 )
1683                                .println( "tableId"                     ,tableId                )
1684                                .println( "scope"                       ,scope                  )
1685                                .println( "masterTableId"       ,masterTableId  )
1686                                .println( "masterScope"         ,masterScope    )
1687                                .println( "slaveTableId"        ,slaveTableId   )
1688                                .println( "slaveScope"          ,slaveScope             )
1689                                .println( "masterKeys"          ,masterKeys             )
1690                                .println( "diffKeys"            ,diffKeys               )
1691                                .println( "unionClms"           ,unionClms              )
1692                                .println( "nullDelClms"         ,nullDelClms    )
1693                                .println( "modifyClms"          ,modifyClms             )
1694                                .println( "noSideEffect"        ,noSideEffect   )
1695                                .println( "useDiffData"         ,useDiffData    )
1696                                .println( "useCheckOnly"        ,useCheckOnly   )
1697                                .println( "display"                     ,display                )
1698                                .println( "ACTION_LIST"         ,ACTION_SET             )
1699                                .println( "Other..."    ,getAttributes().getAttribute() )                       // 6.4.3.4 (2016/03/11)
1700                                .fixForm().toString() ;
1701        }
1702}