Tae

private void checkNoBatchTarget() throws Exception {

        IDatabaseConnection postgreConn = null; // DB POSTGRESQL

        try {

            // DTB_CATEGORY

            postgreConn = getPostgreConnection();
            IDataSet dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_cat);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            int result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            IDataSet expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_cat);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE : dtb_category
             * RETURN : deliv_id, time_id, deliv_time
             */
            QueryDataSet queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_CATEGORY,
                            "SELECT category_id, category_name, parent_category_id, parent_category_id, level, rank, disp_flg, del_flg, create_date  FROM "
                                    + DESTINATION_DTB_CATEGORY);
            IDataSet databaseDataSet = queryDataSet;

            ITable expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_CATEGORY, "category_id");
            ITable actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_CATEGORY, "category_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] { "category_id",
                    "category_name", "parent_category_id", "level", "rank", "disp_flg", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_CLASS COMBINATION

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_class_combination);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_class_combination);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_class_combination RETURN : class_combination_id,
             * parent_class_combination_id, classcategory_id, join_flg, level, bo_size, level, del_flg
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_CLASS_COMBINATION,
                            "SELECT class_combination_id, parent_class_combination_id, classcategory_id, join_flg, level, bo_size, level, del_flg, create_date  FROM "
                                    + DESTINATION_DTB_CLASS_COMBINATION);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_CLASS_COMBINATION, "class_combination_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_CLASS_COMBINATION, "class_combination_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "class_combination_id", "parent_class_combination_id", "classcategory_id", "join_flg", "bo_size",
                    "level", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_CLASS

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_class);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_class);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_class_ RETURN : class_id, name, rank, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_CLASS,
                            "SELECT class_id, name, rank, del_flg, create_date  FROM "
                                    + DESTINATION_DTB_CLASS);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_CLASS, "class_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_CLASS, "class_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "class_id", "name", "rank", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_CLASS_CATEGORY

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_class_category);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_class_category);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_classcategory RETURN : classcategory_id, class_id, class_code, name, rank, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_CLASSCATEGORY,
                            "SELECT classcategory_id, class_id, class_code, name, rank, del_flg, create_date  FROM "
                                    + DESTINATION_DTB_CLASSCATEGORY);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_CLASSCATEGORY, "classcategory_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_CLASSCATEGORY, "classcategory_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "classcategory_id", "class_id", "class_code", "name", "rank", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_DELIVTIME

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_delivtime);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_delivtime);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_delivtime RETURN : deliv_id, time_id, deliv_time, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_DELIVTIME,
                            "SELECT deliv_id, time_id, deliv_time, del_flg, create_date  FROM "
                                    + DESTINATION_DTB_DELIVTIME);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_DELIVTIME, "deliv_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_DELIVTIME, "deliv_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "deliv_id", "time_id", "deliv_id", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_FILTER_ITEMS

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_filter_items);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_filter_items);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_filter_items RETURN : filter_item_id, category_id, filter_type, filter_item_name, option01, rank, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_FILTER_ITEMS,
                            "SELECT filter_item_id, category_id, filter_type, filter_item_name, option01, rank, del_flg create_date  FROM "
                                    + DESTINATION_DTB_FILTER_ITEMS);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_FILTER_ITEMS, "filter_item_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_FILTER_ITEMS, "filter_item_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "filter_item_id", "category_id", "filter_type", "filter_item_name", "option01", "rank", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_FILTER

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_filter);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_filter);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_filter RETURN : filter_id, category_id, filter_type, filter_name, rank, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_FILTER,
                            "SELECT filter_id, category_id, filter_type, filter_name, rank, del_flg create_date  FROM "
                                    + DESTINATION_DTB_FILTER);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_FILTER, "filter_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_FILTER, "filter_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "filter_id", "category_id", "filter_type", "filter_name", "rank", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_PRODUCTS_MATRIX

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_prdmtrx);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_prdmtrx);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_products_matrix RETURN : uid, products_matrix_id, rank, matrix_name, is_vartical, class_id, class_category_id, dummy_flg, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_PRODUCTS_MATRIX,
                            "SELECT uid, products_matrix_id, rank, matrix_name, is_vartical, class_id, class_category_id, dummy_flg, del_flg create_date  FROM "
                                    + DESTINATION_DTB_PRODUCTS_MATRIX);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_PRODUCTS_MATRIX, "uid");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_PRODUCTS_MATRIX, "uid");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "uid", "products_matrix_id", "rank", "matrix_name", "is_vartical", "class_id", "class_category_id", "dummy_flg", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_REPAIR_COMPONENTS

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_repcom);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_repcom);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_repair_components RETURN : repair_components_id, goods_code, repair_item_code, item_name, two_item_num, repair_disp_name, repair_alias_name, input_flame_rank, rank, repair_code, use_class, need_unit_value, inout_flg, hemtype_flg, invoice_summary_info_id, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_REPAIR_COMPONENTS,
                            "SELECT repair_components_id, goods_code, repair_item_code, item_name, two_item_num, repair_disp_name, repair_alias_name, input_flame_rank, rank, repair_code, use_class, need_unit_value, inout_flg, hemtype_flg, invoice_summary_info_id, del_flg create_date  FROM "
                                    + DESTINATION_DTB_REPAIR_COMPONENTS);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_REPAIR_COMPONENTS, "repair_components_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_REPAIR_COMPONENTS, "repair_components_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "repair_components_id", "goods_code", "repair_item_code", "item_name", "two_item_num", "repair_disp_name", "repair_alias_name", "input_flame_rank", "rank", "repair_code", "use_class", "need_unit_value", "inout_flg", "hemtype_flg", "invoice_summary_info_id", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_SIZE

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_size);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_size);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_size RETURN : size_id, size_code, bo_size_code, class_combination_id, class_id1, class_name1, classcategory_id1, classcategory_code1, classcategory_name1, size_join_flg, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_SIZE,
                            "SELECT size_id, size_code, bo_size_code, class_combination_id, class_id1, class_name1, classcategory_id1, classcategory_code1, classcategory_name1, size_join_flg, del_flg create_date  FROM "
                                    + DESTINATION_DTB_SIZE);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_SIZE, "size_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_SIZE, "size_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "size_id", "size_code", "bo_size_code", "class_combination_id", "class_id1", "class_name1", "classcategory_id1", "classcategory_code1", "classcategory_name1", "size_join_flg", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

            // DTB_STORE

            postgreConn = getPostgreConnection();
            dataSet_ec_cat = getDataSetFromFile(this.importFileName_dtb_store);
            DatabaseOperation.CLEAN_INSERT.execute(postgreConn, dataSet_ec_cat);

            // テスト実施
            result = super.batchStart(args);
            assertEquals("0", String.valueOf(result));
            System.out.println(result);
            // 戻り値チェック

            // DBテーブルチェック
            // 期待されるデータを取得
            expectedDataSet = getDataSetFromFile(this.resultFileName_dtb_store);

            /***
             * SELECT DESIRED COLUMNS ONLY FOR TESTING TABLE :
             * dtb_store RETURN : store_id, store_cd, area_block_code, store_name, zip01, zip02, pref, addr01, addr02, tel, status, detail_url, location_x, location_y, area_id, store_stock_order, store_delivery_flg, del_flg, create_date
             */
            queryDataSet = new QueryDataSet(postgreConn);
            queryDataSet
                    .addTable(
                            DESTINATION_DTB_STORE,
                            "SELECT store_id, store_cd, area_block_code, store_name, zip01, zip02, pref, addr01, addr02, tel, status, detail_url, location_x, location_y, area_id, store_stock_order, store_delivery_flg, del_flg create_date  FROM "
                                    + DESTINATION_DTB_STORE);
            databaseDataSet = queryDataSet;

            expectedTableOrd = sortTable(expectedDataSet, DESTINATION_DTB_STORE, "store_id");
            actualTableOrd = sortTable(databaseDataSet, DESTINATION_DTB_STORE, "store_id");

            // REMOVE UNNECESSARY COLUMNS FOR TESTING
            expectedTableOrd = DefaultColumnFilter.includedColumnsTable(expectedTableOrd, new String[] {
                    "store_id", "store_cd", "area_block_code", "store_name", "zip01", "zip02", "pref", "addr01", "addr02", "tel", "status", "detail_url", "location_x", "location_y", "area_id", "store_stock_order", "store_delivery_flg", "del_flg", "create_date" });

            // 更新されていることを確認
            Assertion.assertEquals(expectedTableOrd, actualTableOrd);

        } catch (Exception e) {
            e.printStackTrace();
            fail(e.getMessage());
        } finally {

            // 出力先にファイルが存在する場合は退避させる
            if (super.isBatchFile()) {
                super.moveToBackup();
            }

            try {

                if (postgreConn != null) {
                    postgreConn.close();
                }
            } catch (SQLException e) {

            }
        }
    }