Examples with DfClassificationJdbcCloser org.dbflute.properties.assistant.classification.coins.DfClassificationJdbcCloser used on opensource projects

Example 1 with DfClassificationJdbcCloser

use of org.dbflute.properties.assistant.classification.coins.DfClassificationJdbcCloser in project dbflute-core by dbflute.

the class DfClsTableClassificationArranger method selectTableClassification.

// ===================================================================================
// Select Table Classification
// ===========================
protected void selectTableClassification(DfClassificationTop classificationTop, List<DfClassificationElement> elementList, DfClassificationElement metaElement, Set<String> exceptCodeSet, Connection conn, String sql) {
    final String classificationName = classificationTop.getClassificationName();
    final String[] sisters = metaElement.getSisters();
    final Map<String, Object> subItemPropMap = metaElement.getSubItemMap();
    Statement st = null;
    ResultSet rs = null;
    try {
        st = conn.createStatement();
        _log.info("...Selecting for " + classificationName + " classification" + ln() + sql);
        rs = st.executeQuery(sql);
        final Set<String> duplicateCheckSet = StringSet.createAsCaseInsensitive();
        while (rs.next()) {
            final String code = rs.getString("cls_code");
            final String name = rs.getString("cls_name");
            final String alias = rs.getString("cls_alias");
            final String comment = rs.getString("cls_comment");
            if (exceptCodeSet.contains(code)) {
                _log.info("  exceptd: " + code);
                continue;
            }
            if (duplicateCheckSet.contains(code)) {
                _log.info("  duplicate: " + code);
                continue;
            } else {
                duplicateCheckSet.add(code);
            }
            final Map<String, Object> selectedMap = new LinkedHashMap<>();
            selectedMap.put(DfClassificationElement.KEY_CODE, code);
            selectedMap.put(DfClassificationElement.KEY_NAME, filterTableClassificationName(classificationTop, name));
            selectedMap.put(DfClassificationElement.KEY_ALIAS, filterTableClassificationLiteralOutput(alias));
            if (Srl.is_NotNull_and_NotTrimmedEmpty(comment)) {
                // because of not required
                selectedMap.put(DfClassificationElement.KEY_COMMENT, comment);
            }
            if (sisters != null && sisters.length > 0) {
                final String sisterValue = rs.getString("cls_sister");
                selectedMap.put(DfClassificationElement.KEY_SISTER_CODE, sisterValue);
            }
            if (subItemPropMap != null && !subItemPropMap.isEmpty()) {
                final Map<String, Object> subItemMap = new LinkedHashMap<String, Object>();
                for (String subItemKey : subItemPropMap.keySet()) {
                    final String clsKey = "cls_" + subItemKey;
                    final String subItemValue = rs.getString(clsKey);
                    final String subItemVeloFriendlyValue;
                    if (subItemValue != null) {
                        subItemVeloFriendlyValue = filterTableClassificationLiteralOutput(subItemValue);
                    } else {
                        // for determination in templates
                        subItemVeloFriendlyValue = "null";
                    }
                    subItemMap.put(subItemKey, subItemVeloFriendlyValue);
                }
                selectedMap.put(DfClassificationElement.KEY_SUB_ITEM_MAP, subItemMap);
            }
            final DfClassificationElement element = new DfClassificationElement();
            element.setClassificationName(classificationName);
            element.acceptBasicItemMap(selectedMap);
            elementList.add(element);
        }
    } catch (SQLException e) {
        throwTableClassificationSelectSQLFailureException(classificationName, sql, e);
        throw new SQLFailureException("Failed to execute the SQL:" + ln() + sql, e);
    } finally {
        new DfClassificationJdbcCloser().closeStatement(st, rs);
    }
}

Example 2 with DfClassificationJdbcCloser

use of org.dbflute.properties.assistant.classification.coins.DfClassificationJdbcCloser in project dbflute-core by dbflute.

the class DfClassificationProperties method getClassificationDefinitionMap.

// -----------------------------------------------------
// Native Definition
// -----------------
/**
 * Get the map of classification definition.
 * @return The map of classification definition. (NotNull)
 */
protected Map<String, DfClassificationTop> getClassificationDefinitionMap() {
    if (_classificationTopMap != null) {
        return _classificationTopMap;
    }
    _classificationTopMap = newLinkedHashMap();
    final Map<String, Object> plainDefinitionMap;
    {
        final String mapName = KEY_classificationDefinitionMap;
        final String propKey = "torque." + mapName;
        plainDefinitionMap = resolveSplit(mapName, mapProp(propKey, DEFAULT_EMPTY_MAP));
    }
    final DfClsElementLiteralArranger literalArranger = new DfClsElementLiteralArranger();
    String allInOneSql = null;
    Connection conn = null;
    try {
        for (Entry<String, Object> entry : plainDefinitionMap.entrySet()) {
            final String classificationName = entry.getKey();
            final Object objValue = entry.getValue();
            // handle special elements
            if (classificationName.equalsIgnoreCase("$$SQL$$")) {
                allInOneSql = (String) objValue;
                continue;
            }
            // check duplicate classification
            if (_classificationTopMap.containsKey(classificationName)) {
                String msg = "Duplicate classification: " + classificationName;
                throw new DfIllegalPropertySettingException(msg);
            }
            final DfClassificationTop classificationTop = new DfClassificationTop(classificationName);
            _classificationTopMap.put(classificationName, classificationTop);
            // handle classification elements
            if (!(objValue instanceof List<?>)) {
                throwClassificationMapValueIllegalListTypeException(objValue);
            }
            final List<?> plainList = (List<?>) objValue;
            final List<DfClassificationElement> elementList = new ArrayList<DfClassificationElement>();
            boolean tableClassification = false;
            for (Object element : plainList) {
                if (!(element instanceof Map<?, ?>)) {
                    throwClassificationListElementIllegalMapTypeException(element);
                }
                @SuppressWarnings("unchecked") final Map<String, Object> elementMap = (Map<String, Object>) element;
                // from table
                final String table = (String) elementMap.get(DfClassificationElement.KEY_TABLE);
                if (Srl.is_NotNull_and_NotTrimmedEmpty(table)) {
                    tableClassification = true;
                    if (conn == null) {
                        // on demand
                        conn = createMainSchemaConnection();
                    }
                    arrangeTableClassification(classificationTop, elementMap, table, elementList, conn);
                    continue;
                }
                // from literal
                if (isElementMapClassificationTop(elementMap)) {
                    // top definition
                    arrangeClassificationTopFromLiteral(classificationTop, elementMap);
                } else {
                    literalArranger.arrange(classificationName, elementMap);
                    final DfClassificationElement classificationElement = new DfClassificationElement();
                    classificationElement.setClassificationName(classificationName);
                    classificationElement.acceptBasicItemMap(elementMap);
                    elementList.add(classificationElement);
                }
            }
            // adjust classification top
            classificationTop.addClassificationElementAll(elementList);
            classificationTop.setTableClassification(tableClassification);
            _classificationTopMap.put(classificationName, classificationTop);
        }
        if (allInOneSql != null) {
            if (conn == null) {
                // on demand
                conn = createMainSchemaConnection();
            }
            arrangeAllInOneTableClassification(conn, allInOneSql);
        }
        // *Classification Resource Point!
        reflectClassificationResourceToDefinition();
        filterUseDocumentOnly();
        verifyClassificationConstraintsIfNeeds();
        prepareSuppressedDBAccessClassTableSet();
    } finally {
        new DfClassificationJdbcCloser().closeConnection(conn);
    }
    return _classificationTopMap;
}

Example 3 with DfClassificationJdbcCloser

use of org.dbflute.properties.assistant.classification.coins.DfClassificationJdbcCloser in project dbflute-core by dbflute.

the class DfClassificationAllInOneSqlExecutor method executeAllInOneSql.

// ===================================================================================
// Execute
// =======
public List<Map<String, String>> executeAllInOneSql(Connection conn, String sql) {
    Statement st = null;
    ResultSet rs = null;
    final List<Map<String, String>> elementList = new ArrayList<Map<String, String>>();
    try {
        st = conn.createStatement();
        _log.debug("/ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -");
        _log.debug("The classification sql: " + sql);
        rs = st.executeQuery(sql);
        while (rs.next()) {
            final String tmpClassificationNameValue = rs.getString("classificationName");
            final String tmpCodeValue = rs.getString(DfClassificationElement.KEY_CODE);
            assertCodeExists(sql, tmpCodeValue);
            String tmpNameValue = rs.getString(DfClassificationElement.KEY_NAME);
            if (tmpNameValue == null) {
                tmpNameValue = tmpCodeValue;
            }
            String tmpAliasValue = rs.getString(DfClassificationElement.KEY_ALIAS);
            if (tmpAliasValue == null) {
                tmpAliasValue = tmpNameValue;
            }
            final String tmpCommentValue = rs.getString(DfClassificationElement.KEY_COMMENT);
            final String tmpTopCommentValue = rs.getString(DfClassificationTop.KEY_TOP_COMMENT);
            final Map<String, String> selectedTmpMap = new LinkedHashMap<String, String>();
            selectedTmpMap.put("classificationName", tmpClassificationNameValue);
            selectedTmpMap.put(DfClassificationElement.KEY_CODE, tmpCodeValue);
            selectedTmpMap.put(DfClassificationElement.KEY_NAME, tmpNameValue);
            selectedTmpMap.put(DfClassificationElement.KEY_ALIAS, tmpAliasValue);
            if (tmpCommentValue != null) {
                selectedTmpMap.put(DfClassificationElement.KEY_COMMENT, tmpCommentValue);
            }
            if (tmpTopCommentValue != null) {
                selectedTmpMap.put(DfClassificationTop.KEY_TOP_COMMENT, tmpTopCommentValue);
            }
            elementList.add(selectedTmpMap);
        }
        _log.debug("- - - - - - - - /");
    } catch (SQLException e) {
        throw new SQLFailureException("Failed to execute the SQL:" + ln() + sql, e);
    } finally {
        new DfClassificationJdbcCloser().closeStatement(st, rs);
    }
    return elementList;
}