2209

Committed 11 May 2026 05:50PM UTC coverage: 91.84% (+0.01%) from 91.828%

Build # 2209

Build Type

Pull #1513

github

Committed by

web-flow

Commit Message

Merge 37252ae84 into 659a1ba63

Pull Request Pull Request #1513: Add Inferred Generated Key Plugin

Coverage Stats

2468 of 3166 branches covered (77.95%)

44 of 49 new or added lines in 5 files covered. (89.8%)

20 existing lines in 1 file now uncovered.

12076 of 13149 relevant lines covered (91.84%)

0.92 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

83.42

/core/mybatis-generator-core/src/main/java/org/mybatis/generator/config/TableConfiguration.java

/*
 *    Copyright 2006-2026 the original author or authors.
 *
 *    Licensed under the Apache License, Version 2.0 (the "License");
 *    you may not use this file except in compliance with the License.
 *    You may obtain a copy of the License at
 *
 *       https://www.apache.org/licenses/LICENSE-2.0
 *
 *    Unless required by applicable law or agreed to in writing, software
 *    distributed under the License is distributed on an "AS IS" BASIS,
 *    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *    See the License for the specific language governing permissions and
 *    limitations under the License.
 */
package org.mybatis.generator.config;

import static org.mybatis.generator.internal.util.StringUtility.composeFullyQualifiedTableName;
import static org.mybatis.generator.internal.util.StringUtility.isTrue;
import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Optional;
import java.util.Properties;

import org.jspecify.annotations.Nullable;
import org.mybatis.generator.api.IntrospectedColumn;
import org.mybatis.generator.api.KnownRuntime;
import org.mybatis.generator.exception.InvalidConfigurationException;
import org.mybatis.generator.internal.util.messages.Messages;

public class TableConfiguration extends PropertyHolder {
    private final boolean insertStatementEnabled;
    private final boolean selectByPrimaryKeyStatementEnabled;
    private final boolean selectByExampleStatementEnabled;
    private final boolean updateByPrimaryKeyStatementEnabled;
    private final boolean deleteByPrimaryKeyStatementEnabled;
    private final boolean deleteByExampleStatementEnabled;
    private final boolean countByExampleStatementEnabled;
    private final boolean updateByExampleStatementEnabled;
    private final List<ColumnOverride> columnOverrides;
    // this is a Map for validation purposes. Initially, all items will be FALSE. When accessed, an item will
    // be made TRUE. This allows us to generate warning for columns configured to be ignored but not found.
    private final Map<IgnoredColumn, Boolean> ignoredColumns;
    private @Nullable GeneratedKey generatedKey;
    private final @Nullable String catalog;
    private final @Nullable String schema;
    private final String tableName;
    private final @Nullable String domainObjectName;
    private final @Nullable String alias;
    private final @Nullable ModelType modelType;
    private final boolean wildcardEscapingEnabled;
    private final boolean delimitIdentifiers;
    private final @Nullable DomainObjectRenamingRule domainObjectRenamingRule;
    private final @Nullable ColumnRenamingRule columnRenamingRule;
    private final boolean isAllColumnDelimitingEnabled;
    private final @Nullable String mapperName;
    private final @Nullable String sqlProviderName;
    private final List<IgnoredColumnPattern> ignoredColumnPatterns;
    private final String fullyQualifiedName;

    protected TableConfiguration(Builder builder) {
        super(builder);

        catalog = builder.catalog;
        schema = builder.schema;
        tableName = Objects.requireNonNull(builder.tableName);
        domainObjectName = builder.domainObjectName;
        alias = builder.alias;
        modelType = builder.modelType;
        insertStatementEnabled = builder.insertStatementEnabled;
        selectByPrimaryKeyStatementEnabled = builder.selectByPrimaryKeyStatementEnabled;
        selectByExampleStatementEnabled = builder.selectByExampleStatementEnabled;
        updateByPrimaryKeyStatementEnabled = builder.updateByPrimaryKeyStatementEnabled;
        deleteByPrimaryKeyStatementEnabled = builder.deleteByPrimaryKeyStatementEnabled;
        deleteByExampleStatementEnabled = builder.deleteByExampleStatementEnabled;
        countByExampleStatementEnabled = builder.countByExampleStatementEnabled;
        updateByExampleStatementEnabled = builder.updateByExampleStatementEnabled;
        wildcardEscapingEnabled = builder.wildcardEscapingEnabled;
        delimitIdentifiers = builder.delimitIdentifiers;
        isAllColumnDelimitingEnabled = builder.isAllColumnDelimitingEnabled;
        mapperName = builder.mapperName;
        sqlProviderName = builder.sqlProviderName;
        columnOverrides = Collections.unmodifiableList(builder.columnOverrides);
        ignoredColumns = builder.ignoredColumns;
        generatedKey = builder.generatedKey;
        domainObjectRenamingRule = builder.domainObjectRenamingRule;
        columnRenamingRule = builder.columnRenamingRule;
        ignoredColumnPatterns = Collections.unmodifiableList(builder.ignoredColumnPatterns);
        fullyQualifiedName = composeFullyQualifiedTableName(catalog, schema, tableName, '.');
    }

    public boolean isDeleteByPrimaryKeyStatementEnabled() {
        return deleteByPrimaryKeyStatementEnabled;
    }

    public boolean isInsertStatementEnabled() {
        return insertStatementEnabled;
    }

    public boolean isSelectByPrimaryKeyStatementEnabled() {
        return selectByPrimaryKeyStatementEnabled;
    }

    public boolean isUpdateByPrimaryKeyStatementEnabled() {
        return updateByPrimaryKeyStatementEnabled;
    }

    public boolean isColumnIgnored(String columnName) {
        for (Map.Entry<IgnoredColumn, Boolean> entry : ignoredColumns.entrySet()) {
            if (entry.getKey().matches(columnName)) {
                entry.setValue(Boolean.TRUE);
                return true;
            }
        }

        for (IgnoredColumnPattern ignoredColumnPattern : ignoredColumnPatterns) {
            if (ignoredColumnPattern.matches(columnName)) {
                return true;
            }
        }

        return false;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (!(obj instanceof TableConfiguration other)) {
            return false;
        }

        return Objects.equals(this.catalog, other.catalog)
                && Objects.equals(this.schema, other.schema)
                && Objects.equals(this.tableName, other.tableName);
    }

    @Override
    public int hashCode() {
        return Objects.hash(catalog, schema, tableName);
    }

    public boolean isSelectByExampleStatementEnabled() {
        return selectByExampleStatementEnabled;
    }

    /**
     * May return null if the column has not been overridden.
     *
     * @param columnName
     *            the column name
     * @return the column override (if any) related to this column
     */
    public Optional<ColumnOverride> getColumnOverride(String columnName) {
        for (ColumnOverride co : columnOverrides) {
            if (co.isColumnNameDelimited()) {
                if (columnName.equals(co.getColumnName())) {
                    return Optional.of(co);
                }
            } else {
                if (columnName.equalsIgnoreCase(co.getColumnName())) {
                    return Optional.of(co);
                }
            }
        }

        return Optional.empty();
    }

    public Optional<GeneratedKey> getGeneratedKey() {
        return Optional.ofNullable(generatedKey);
    }

    public boolean isDeleteByExampleStatementEnabled() {
        return deleteByExampleStatementEnabled;
    }

    public boolean areAnyStatementsEnabled() {
        return selectByExampleStatementEnabled
                || selectByPrimaryKeyStatementEnabled || insertStatementEnabled
                || updateByPrimaryKeyStatementEnabled
                || deleteByExampleStatementEnabled
                || deleteByPrimaryKeyStatementEnabled
                || countByExampleStatementEnabled
                || updateByExampleStatementEnabled;
    }

    public @Nullable String getAlias() {
        return alias;
    }

    public @Nullable String getCatalog() {
        return catalog;
    }

    public @Nullable String getDomainObjectName() {
        return domainObjectName;
    }

    public @Nullable String getSchema() {
        return schema;
    }

    public String getTableName() {
        return tableName;
    }

    public String getFullyQualifiedName() {
        return fullyQualifiedName;
    }

    public List<ColumnOverride> getColumnOverrides() {
        return columnOverrides;
    }

    /**
     * Returns a List of Strings. The values are the columns
     * that were specified to be ignored in the table but do not exist in the
     * table.
     *
     * @return a List of Strings - the columns that were improperly configured
     *         as ignored columns
     */
    public List<String> getIgnoredColumnsInError() {
        List<String> answer = new ArrayList<>();

        for (Map.Entry<IgnoredColumn, Boolean> entry : ignoredColumns.entrySet()) {
            if (Boolean.FALSE.equals(entry.getValue())) {
                answer.add(entry.getKey().getColumnName());
            }
        }

        return answer;
    }

    public Optional<ModelType> getModelType() {
        return Optional.ofNullable(modelType);
    }

    public boolean isWildcardEscapingEnabled() {
        return wildcardEscapingEnabled;
    }

    @Override
    public String toString() {
        return fullyQualifiedName;
    }

    public boolean isDelimitIdentifiers() {
        return delimitIdentifiers;
    }

    public boolean isCountByExampleStatementEnabled() {
        return countByExampleStatementEnabled;
    }

    public boolean isUpdateByExampleStatementEnabled() {
        return updateByExampleStatementEnabled;
    }

    public void validate(List<String> errors, int listPosition, Context context, KnownRuntime knownRuntime) {
        if (!stringHasValue(tableName)) {
            errors.add(Messages.getString(
                    "ValidationError.6", Integer.toString(listPosition))); //$NON-NLS-1$
        }

        if (generatedKey != null) {
            errors.addAll(validateGeneratedKey(generatedKey, context, knownRuntime));
        }

        if (domainObjectRenamingRule != null) {
            domainObjectRenamingRule.validate(errors, fullyQualifiedName);
        }

        if (columnRenamingRule != null) {
            columnRenamingRule.validate(errors, fullyQualifiedName);
        }

        for (ColumnOverride columnOverride : columnOverrides) {
            columnOverride.validate(errors, fullyQualifiedName);
        }

        for (IgnoredColumn ignoredColumn : ignoredColumns.keySet()) {
            ignoredColumn.validate(errors, fullyQualifiedName);
        }

        for (IgnoredColumnPattern ignoredColumnPattern : ignoredColumnPatterns) {
            ignoredColumnPattern.validate(errors, fullyQualifiedName);
        }
    }

    private List<String> validateGeneratedKey(GeneratedKey generatedKey, Context context, KnownRuntime knownRuntime) {
        List<String> errors = new ArrayList<>();

        // if the model type is immutable or record, then we cannot have generated keys
        ModelType mt = getModelType().orElseGet(context::getDefaultModelType);
        if (mt == ModelType.RECORD) {
            errors.add(Messages.getString("ValidationError.30", fullyQualifiedName, context.getId(), //$NON-NLS-1$
                    "record")); //$NON-NLS-1$
        }

        // we're going to allow generated keys for Kotlin even if the rest of the model is immutable
        if (isImmutable(context) && knownRuntime != KnownRuntime.MYBATIS3_KOTLIN) {
            errors.add(Messages.getString("ValidationError.30", fullyQualifiedName, context.getId(), //$NON-NLS-1$
                    "immutable")); //$NON-NLS-1$
        }

        generatedKey.validate(errors, fullyQualifiedName, context.getId());

        return errors;

    }

    public void updateGeneratedKey(GeneratedKey generatedKey, IntrospectedColumn introspectedColumn, Context context,
                                   KnownRuntime knownRuntime)
            throws InvalidConfigurationException {
        List<String> errors = validateGeneratedKey(generatedKey, context, knownRuntime);

        if (errors.isEmpty()) {
            this.generatedKey = generatedKey;
            introspectedColumn.acceptGeneratedKey(generatedKey);
        } else {
            // TODO - externalize
            throw new InvalidConfigurationException("Updating the GeneratedKey would create an invalid configuration",
                    errors);
        }
    }

    public boolean isImmutable(Context context) {
        Properties properties;

        if (getProperties().containsKey(PropertyRegistry.ANY_IMMUTABLE)) {
            properties = getProperties();
        } else {
            properties = context.getModelGeneratorConfiguration().getProperties();
        }

        return isTrue(properties.getProperty(PropertyRegistry.ANY_IMMUTABLE));
    }

    public boolean generateKotlinV1Model(Context context) {
        Properties properties;

        if (getProperties().containsKey(PropertyRegistry.GENERATE_KOTLIN_V1_MODEL)) {
            properties = getProperties();
        } else {
            properties = context.getModelGeneratorConfiguration().getProperties();
        }

        return isTrue(properties.getProperty(PropertyRegistry.GENERATE_KOTLIN_V1_MODEL));
    }

    public @Nullable DomainObjectRenamingRule getDomainObjectRenamingRule() {
        return domainObjectRenamingRule;
    }

    public Optional<ColumnRenamingRule> getColumnRenamingRule() {
        return Optional.ofNullable(columnRenamingRule);
    }

    public boolean isAllColumnDelimitingEnabled() {
        return isAllColumnDelimitingEnabled;
    }

    public @Nullable String getMapperName() {
        return mapperName;
    }

    public @Nullable String getSqlProviderName() {
        return sqlProviderName;
    }

    public @Nullable String getDynamicSqlSupportClassName() {
        return getProperty(PropertyRegistry.TABLE_DYNAMIC_SQL_SUPPORT_CLASS_NAME);
    }

    public @Nullable String getDynamicSqlTableObjectName() {
        return getProperty(PropertyRegistry.TABLE_DYNAMIC_SQL_TABLE_OBJECT_NAME);
    }

    public static class Builder extends AbstractBuilder<Builder> {
        private @Nullable ModelType modelType;
        private @Nullable String catalog;
        private @Nullable String schema;
        private @Nullable String tableName;
        private @Nullable String domainObjectName;
        private @Nullable String alias;
        private boolean insertStatementEnabled = true;
        private boolean selectByPrimaryKeyStatementEnabled = true;
        private boolean selectByExampleStatementEnabled = true;
        private boolean updateByPrimaryKeyStatementEnabled = true;
        private boolean deleteByPrimaryKeyStatementEnabled = true;
        private boolean deleteByExampleStatementEnabled = true;
        private boolean countByExampleStatementEnabled = true;
        private boolean updateByExampleStatementEnabled = true;
        private boolean wildcardEscapingEnabled;
        private boolean delimitIdentifiers;
        private boolean isAllColumnDelimitingEnabled;
        private @Nullable String mapperName;
        private @Nullable String sqlProviderName;
        private @Nullable GeneratedKey generatedKey;
        private @Nullable DomainObjectRenamingRule domainObjectRenamingRule;
        private @Nullable ColumnRenamingRule columnRenamingRule;
        private final List<IgnoredColumnPattern> ignoredColumnPatterns = new ArrayList<>();
        private final List<ColumnOverride> columnOverrides = new ArrayList<>();
        private final Map<IgnoredColumn, Boolean> ignoredColumns = new HashMap<>();

        public TableConfiguration build() {
            return new TableConfiguration(this);
        }

        @Override
        protected Builder getThis() {
            return this;
        }

        public Builder withModelType(@Nullable String tableModelType) {
            this.modelType = tableModelType == null ? null : ModelType.getModelType(tableModelType);
            return getThis();
        }

        public Builder withCatalog(@Nullable String catalog) {
            this.catalog = catalog;
            return this;
        }

        public Builder withSchema(@Nullable String schema) {
            this.schema = schema;
            return this;
        }

        public Builder withTableName(@Nullable String tableName) {
            this.tableName = tableName;
            return this;
        }

        public Builder withDomainObjectName(@Nullable String domainObjectName) {
            this.domainObjectName = domainObjectName;
            return this;
        }

        public Builder withAlias(@Nullable String alias) {
            this.alias = alias;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withInsertStatementEnabled(boolean insertStatementEnabled) {
            this.insertStatementEnabled = insertStatementEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withSelectByPrimaryKeyStatementEnabled(boolean selectByPrimaryKeyStatementEnabled) {
            this.selectByPrimaryKeyStatementEnabled = selectByPrimaryKeyStatementEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withSelectByExampleStatementEnabled(boolean selectByExampleStatementEnabled) {
            this.selectByExampleStatementEnabled = selectByExampleStatementEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withUpdateByPrimaryKeyStatementEnabled(boolean updateByPrimaryKeyStatementEnabled) {
            this.updateByPrimaryKeyStatementEnabled = updateByPrimaryKeyStatementEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withDeleteByPrimaryKeyStatementEnabled(boolean deleteByPrimaryKeyStatementEnabled) {
            this.deleteByPrimaryKeyStatementEnabled = deleteByPrimaryKeyStatementEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withDeleteByExampleStatementEnabled(boolean deleteByExampleStatementEnabled) {
            this.deleteByExampleStatementEnabled = deleteByExampleStatementEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withCountByExampleStatementEnabled(boolean countByExampleStatementEnabled) {
            this.countByExampleStatementEnabled = countByExampleStatementEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withUpdateByExampleStatementEnabled(boolean updateByExampleStatementEnabled) {
            this.updateByExampleStatementEnabled = updateByExampleStatementEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withWildcardEscapingEnabled(boolean wildcardEscapingEnabled) {
            this.wildcardEscapingEnabled = wildcardEscapingEnabled;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withDelimitIdentifiers(boolean delimitIdentifiers) {
            this.delimitIdentifiers = delimitIdentifiers;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withAllColumnDelimitingEnabled(boolean isAllColumnDelimitingEnabled) {
            this.isAllColumnDelimitingEnabled = isAllColumnDelimitingEnabled;
            return this;
        }

        public Builder withMapperName(@Nullable String mapperName) {
            this.mapperName = mapperName;
            return this;
        }

        public Builder withSqlProviderName(@Nullable String sqlProviderName) {
            this.sqlProviderName = sqlProviderName;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withGeneratedKey(@Nullable GeneratedKey generatedKey) {
            this.generatedKey = generatedKey;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withDomainObjectRenamingRule(@Nullable DomainObjectRenamingRule domainObjectRenamingRule) {
            this.domainObjectRenamingRule = domainObjectRenamingRule;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withColumnRenamingRule(@Nullable ColumnRenamingRule columnRenamingRule) {
            this.columnRenamingRule = columnRenamingRule;
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withIgnoredColumnPattern(IgnoredColumnPattern ignoredColumnPattern) {
            this.ignoredColumnPatterns.add(ignoredColumnPattern);
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withIgnoredColumn(IgnoredColumn ignoredColumn) {
            this.ignoredColumns.put(ignoredColumn, Boolean.FALSE);
            return this;
        }

        @SuppressWarnings("UnusedReturnValue")
        public Builder withColumnOverride(ColumnOverride columnOverride) {
            this.columnOverrides.add(columnOverride);
            return this;
        }
    }
}

1	/*
2	* Copyright 2006-2026 the original author or authors.
3	*
4	* Licensed under the Apache License, Version 2.0 (the "License");
5	* you may not use this file except in compliance with the License.
6	* You may obtain a copy of the License at
7	*
8	* https://www.apache.org/licenses/LICENSE-2.0
9	*
10	* Unless required by applicable law or agreed to in writing, software
11	* distributed under the License is distributed on an "AS IS" BASIS,
12	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13	* See the License for the specific language governing permissions and
14	* limitations under the License.
15	*/
16	package org.mybatis.generator.config;
17
18	import static org.mybatis.generator.internal.util.StringUtility.composeFullyQualifiedTableName;
19	import static org.mybatis.generator.internal.util.StringUtility.isTrue;
20	import static org.mybatis.generator.internal.util.StringUtility.stringHasValue;
21
22	import java.util.ArrayList;
23	import java.util.Collections;
24	import java.util.HashMap;
25	import java.util.List;
26	import java.util.Map;
27	import java.util.Objects;
28	import java.util.Optional;
29	import java.util.Properties;
30
31	import org.jspecify.annotations.Nullable;
32	import org.mybatis.generator.api.IntrospectedColumn;
33	import org.mybatis.generator.api.KnownRuntime;
34	import org.mybatis.generator.exception.InvalidConfigurationException;
35	import org.mybatis.generator.internal.util.messages.Messages;
36
37	public class TableConfiguration extends PropertyHolder {
38	private final boolean insertStatementEnabled;
39	private final boolean selectByPrimaryKeyStatementEnabled;
40	private final boolean selectByExampleStatementEnabled;
41	private final boolean updateByPrimaryKeyStatementEnabled;
42	private final boolean deleteByPrimaryKeyStatementEnabled;
43	private final boolean deleteByExampleStatementEnabled;
44	private final boolean countByExampleStatementEnabled;
45	private final boolean updateByExampleStatementEnabled;
46	private final List<ColumnOverride> columnOverrides;
47	// this is a Map for validation purposes. Initially, all items will be FALSE. When accessed, an item will
48	// be made TRUE. This allows us to generate warning for columns configured to be ignored but not found.
49	private final Map<IgnoredColumn, Boolean> ignoredColumns;
50	private @Nullable GeneratedKey generatedKey;
51	private final @Nullable String catalog;
52	private final @Nullable String schema;
53	private final String tableName;
54	private final @Nullable String domainObjectName;
55	private final @Nullable String alias;
56	private final @Nullable ModelType modelType;
57	private final boolean wildcardEscapingEnabled;
58	private final boolean delimitIdentifiers;
59	private final @Nullable DomainObjectRenamingRule domainObjectRenamingRule;
60	private final @Nullable ColumnRenamingRule columnRenamingRule;
61	private final boolean isAllColumnDelimitingEnabled;
62	private final @Nullable String mapperName;
63	private final @Nullable String sqlProviderName;
64	private final List<IgnoredColumnPattern> ignoredColumnPatterns;
65	private final String fullyQualifiedName;
66
67	protected TableConfiguration(Builder builder) {
68	super(builder);	1✔
69
70	catalog = builder.catalog;	1✔
71	schema = builder.schema;	1✔
72	tableName = Objects.requireNonNull(builder.tableName);	1✔
73	domainObjectName = builder.domainObjectName;	1✔
74	alias = builder.alias;	1✔
75	modelType = builder.modelType;	1✔
76	insertStatementEnabled = builder.insertStatementEnabled;	1✔
77	selectByPrimaryKeyStatementEnabled = builder.selectByPrimaryKeyStatementEnabled;	1✔
78	selectByExampleStatementEnabled = builder.selectByExampleStatementEnabled;	1✔
79	updateByPrimaryKeyStatementEnabled = builder.updateByPrimaryKeyStatementEnabled;	1✔
80	deleteByPrimaryKeyStatementEnabled = builder.deleteByPrimaryKeyStatementEnabled;	1✔
81	deleteByExampleStatementEnabled = builder.deleteByExampleStatementEnabled;	1✔
82	countByExampleStatementEnabled = builder.countByExampleStatementEnabled;	1✔
83	updateByExampleStatementEnabled = builder.updateByExampleStatementEnabled;	1✔
84	wildcardEscapingEnabled = builder.wildcardEscapingEnabled;	1✔
85	delimitIdentifiers = builder.delimitIdentifiers;	1✔
86	isAllColumnDelimitingEnabled = builder.isAllColumnDelimitingEnabled;	1✔
87	mapperName = builder.mapperName;	1✔
88	sqlProviderName = builder.sqlProviderName;	1✔
89	columnOverrides = Collections.unmodifiableList(builder.columnOverrides);	1✔
90	ignoredColumns = builder.ignoredColumns;	1✔
91	generatedKey = builder.generatedKey;	1✔
92	domainObjectRenamingRule = builder.domainObjectRenamingRule;	1✔
93	columnRenamingRule = builder.columnRenamingRule;	1✔
94	ignoredColumnPatterns = Collections.unmodifiableList(builder.ignoredColumnPatterns);	1✔
95	fullyQualifiedName = composeFullyQualifiedTableName(catalog, schema, tableName, '.');	1✔
96	}	1✔
97
98	public boolean isDeleteByPrimaryKeyStatementEnabled() {
99	return deleteByPrimaryKeyStatementEnabled;	1✔
100	}
101
102	public boolean isInsertStatementEnabled() {
103	return insertStatementEnabled;	1✔
104	}
105
106	public boolean isSelectByPrimaryKeyStatementEnabled() {
107	return selectByPrimaryKeyStatementEnabled;	1✔
108	}
109
110	public boolean isUpdateByPrimaryKeyStatementEnabled() {
111	return updateByPrimaryKeyStatementEnabled;	1✔
112	}
113
114	public boolean isColumnIgnored(String columnName) {
115	for (Map.Entry<IgnoredColumn, Boolean> entry : ignoredColumns.entrySet()) {	1✔
116	if (entry.getKey().matches(columnName)) {	1✔
117	entry.setValue(Boolean.TRUE);	1✔
118	return true;	1✔
119	}
120	}	1✔
121
122	for (IgnoredColumnPattern ignoredColumnPattern : ignoredColumnPatterns) {	1✔
123	if (ignoredColumnPattern.matches(columnName)) {	1✔
124	return true;	1✔
125	}
126	}	1✔
127
128	return false;	1✔
129	}
130
131	@Override
132	public boolean equals(Object obj) {
133	if (this == obj) {	×
134	return true;	×
135	}
136
137	if (!(obj instanceof TableConfiguration other)) {	×
138	return false;	×
139	}
140
141	return Objects.equals(this.catalog, other.catalog)	×
142	&& Objects.equals(this.schema, other.schema)	×
143	&& Objects.equals(this.tableName, other.tableName);	×
144	}
145
146	@Override
147	public int hashCode() {
148	return Objects.hash(catalog, schema, tableName);	×
149	}
150
151	public boolean isSelectByExampleStatementEnabled() {
152	return selectByExampleStatementEnabled;	1✔
153	}
154
155	/**
156	* May return null if the column has not been overridden.
157	*
158	* @param columnName
159	* the column name
160	* @return the column override (if any) related to this column
161	*/
162	public Optional<ColumnOverride> getColumnOverride(String columnName) {
163	for (ColumnOverride co : columnOverrides) {	1✔
164	if (co.isColumnNameDelimited()) {	1✔
165	if (columnName.equals(co.getColumnName())) {	1✔
166	return Optional.of(co);	1✔
167	}
168	} else {
169	if (columnName.equalsIgnoreCase(co.getColumnName())) {	1✔
170	return Optional.of(co);	1✔
171	}
172	}
173	}	1✔
174
175	return Optional.empty();	1✔
176	}
177
178	public Optional<GeneratedKey> getGeneratedKey() {
179	return Optional.ofNullable(generatedKey);	1✔
180	}
181
182	public boolean isDeleteByExampleStatementEnabled() {
183	return deleteByExampleStatementEnabled;	1✔
184	}
185
186	public boolean areAnyStatementsEnabled() {
187	return selectByExampleStatementEnabled	1!
188	\|\| selectByPrimaryKeyStatementEnabled \|\| insertStatementEnabled
189	\|\| updateByPrimaryKeyStatementEnabled
190	\|\| deleteByExampleStatementEnabled
191	\|\| deleteByPrimaryKeyStatementEnabled
192	\|\| countByExampleStatementEnabled
193	\|\| updateByExampleStatementEnabled;
194	}
195
196	public @Nullable String getAlias() {
197	return alias;	1✔
198	}
199
200	public @Nullable String getCatalog() {
201	return catalog;	1✔
202	}
203
204	public @Nullable String getDomainObjectName() {
205	return domainObjectName;	1✔
206	}
207
208	public @Nullable String getSchema() {
209	return schema;	1✔
210	}
211
212	public String getTableName() {
213	return tableName;	1✔
214	}
215
216	public String getFullyQualifiedName() {
217	return fullyQualifiedName;	1✔
218	}
219
220	public List<ColumnOverride> getColumnOverrides() {
221	return columnOverrides;	1✔
222	}
223
224	/**
225	* Returns a List of Strings. The values are the columns
226	* that were specified to be ignored in the table but do not exist in the
227	* table.
228	*
229	* @return a List of Strings - the columns that were improperly configured
230	* as ignored columns
231	*/
232	public List<String> getIgnoredColumnsInError() {
233	List<String> answer = new ArrayList<>();	1✔
234
235	for (Map.Entry<IgnoredColumn, Boolean> entry : ignoredColumns.entrySet()) {	1✔
236	if (Boolean.FALSE.equals(entry.getValue())) {	1✔
237	answer.add(entry.getKey().getColumnName());	1✔
238	}
239	}	1✔
240
241	return answer;	1✔
242	}
243
244	public Optional<ModelType> getModelType() {
245	return Optional.ofNullable(modelType);	1✔
246	}
247
248	public boolean isWildcardEscapingEnabled() {
249	return wildcardEscapingEnabled;	1✔
250	}
251
252	@Override
253	public String toString() {
254	return fullyQualifiedName;	×
255	}
256
257	public boolean isDelimitIdentifiers() {
258	return delimitIdentifiers;	1✔
259	}
260
261	public boolean isCountByExampleStatementEnabled() {
262	return countByExampleStatementEnabled;	1✔
263	}
264
265	public boolean isUpdateByExampleStatementEnabled() {
266	return updateByExampleStatementEnabled;	1✔
267	}
268
269	public void validate(List<String> errors, int listPosition, Context context, KnownRuntime knownRuntime) {
270	if (!stringHasValue(tableName)) {	1!
271	errors.add(Messages.getString(	×
272	"ValidationError.6", Integer.toString(listPosition))); //$NON-NLS-1$	×
273	}
274
275	if (generatedKey != null) {	1✔
276	errors.addAll(validateGeneratedKey(generatedKey, context, knownRuntime));	1✔
277	}
278
279	if (domainObjectRenamingRule != null) {	1✔
280	domainObjectRenamingRule.validate(errors, fullyQualifiedName);	1✔
281	}
282
283	if (columnRenamingRule != null) {	1✔
284	columnRenamingRule.validate(errors, fullyQualifiedName);	1✔
285	}
286
287	for (ColumnOverride columnOverride : columnOverrides) {	1✔
288	columnOverride.validate(errors, fullyQualifiedName);	1✔
289	}	1✔
290
291	for (IgnoredColumn ignoredColumn : ignoredColumns.keySet()) {	1✔
292	ignoredColumn.validate(errors, fullyQualifiedName);	1✔
293	}	1✔
294
295	for (IgnoredColumnPattern ignoredColumnPattern : ignoredColumnPatterns) {	1✔
296	ignoredColumnPattern.validate(errors, fullyQualifiedName);	1✔
297	}	1✔
298	}	1✔
299
300	private List<String> validateGeneratedKey(GeneratedKey generatedKey, Context context, KnownRuntime knownRuntime) {
301	List<String> errors = new ArrayList<>();	1✔
302
303	// if the model type is immutable or record, then we cannot have generated keys
304	ModelType mt = getModelType().orElseGet(context::getDefaultModelType);	1✔
305	if (mt == ModelType.RECORD) {	1✔
306	errors.add(Messages.getString("ValidationError.30", fullyQualifiedName, context.getId(), //$NON-NLS-1$	1✔
307	"record")); //$NON-NLS-1$
308	}
309
310	// we're going to allow generated keys for Kotlin even if the rest of the model is immutable
311	if (isImmutable(context) && knownRuntime != KnownRuntime.MYBATIS3_KOTLIN) {	1!
312	errors.add(Messages.getString("ValidationError.30", fullyQualifiedName, context.getId(), //$NON-NLS-1$	1✔
313	"immutable")); //$NON-NLS-1$
314	}
315
316	generatedKey.validate(errors, fullyQualifiedName, context.getId());	1✔
317
318	return errors;	1✔
319
320	}
321
322	public void updateGeneratedKey(GeneratedKey generatedKey, IntrospectedColumn introspectedColumn, Context context,
323	KnownRuntime knownRuntime)
324	throws InvalidConfigurationException {
325	List<String> errors = validateGeneratedKey(generatedKey, context, knownRuntime);	1✔
326
327	if (errors.isEmpty()) {	1!
328	this.generatedKey = generatedKey;	1✔
329	introspectedColumn.acceptGeneratedKey(generatedKey);	1✔
330	} else {
331	// TODO - externalize
NEW 332	throw new InvalidConfigurationException("Updating the GeneratedKey would create an invalid configuration",	×
333	errors);
334	}
335	}	1✔
336
337	public boolean isImmutable(Context context) {
338	Properties properties;
339
340	if (getProperties().containsKey(PropertyRegistry.ANY_IMMUTABLE)) {	1✔
341	properties = getProperties();	1✔
342	} else {
343	properties = context.getModelGeneratorConfiguration().getProperties();	1✔
344	}
345
346	return isTrue(properties.getProperty(PropertyRegistry.ANY_IMMUTABLE));	1✔
347	}
348
349	public boolean generateKotlinV1Model(Context context) {
350	Properties properties;
351
352	if (getProperties().containsKey(PropertyRegistry.GENERATE_KOTLIN_V1_MODEL)) {	1✔
353	properties = getProperties();	1✔
354	} else {
355	properties = context.getModelGeneratorConfiguration().getProperties();	1✔
356	}
357
358	return isTrue(properties.getProperty(PropertyRegistry.GENERATE_KOTLIN_V1_MODEL));	1✔
359	}
360
361	public @Nullable DomainObjectRenamingRule getDomainObjectRenamingRule() {
362	return domainObjectRenamingRule;	1✔
363	}
364
365	public Optional<ColumnRenamingRule> getColumnRenamingRule() {
366	return Optional.ofNullable(columnRenamingRule);	1✔
367	}
368
369	public boolean isAllColumnDelimitingEnabled() {
370	return isAllColumnDelimitingEnabled;	1✔
371	}
372
373	public @Nullable String getMapperName() {
374	return mapperName;	1✔
375	}
376
377	public @Nullable String getSqlProviderName() {
378	return sqlProviderName;	1✔
379	}
380
381	public @Nullable String getDynamicSqlSupportClassName() {
382	return getProperty(PropertyRegistry.TABLE_DYNAMIC_SQL_SUPPORT_CLASS_NAME);	1✔
383	}
384
385	public @Nullable String getDynamicSqlTableObjectName() {
386	return getProperty(PropertyRegistry.TABLE_DYNAMIC_SQL_TABLE_OBJECT_NAME);	1✔
387	}
388
389	public static class Builder extends AbstractBuilder<Builder> {	1✔
390	private @Nullable ModelType modelType;
391	private @Nullable String catalog;
392	private @Nullable String schema;
393	private @Nullable String tableName;
394	private @Nullable String domainObjectName;
395	private @Nullable String alias;
396	private boolean insertStatementEnabled = true;	1✔
397	private boolean selectByPrimaryKeyStatementEnabled = true;	1✔
398	private boolean selectByExampleStatementEnabled = true;	1✔
399	private boolean updateByPrimaryKeyStatementEnabled = true;	1✔
400	private boolean deleteByPrimaryKeyStatementEnabled = true;	1✔
401	private boolean deleteByExampleStatementEnabled = true;	1✔
402	private boolean countByExampleStatementEnabled = true;	1✔
403	private boolean updateByExampleStatementEnabled = true;	1✔
404	private boolean wildcardEscapingEnabled;
405	private boolean delimitIdentifiers;
406	private boolean isAllColumnDelimitingEnabled;
407	private @Nullable String mapperName;
408	private @Nullable String sqlProviderName;
409	private @Nullable GeneratedKey generatedKey;
410	private @Nullable DomainObjectRenamingRule domainObjectRenamingRule;
411	private @Nullable ColumnRenamingRule columnRenamingRule;
412	private final List<IgnoredColumnPattern> ignoredColumnPatterns = new ArrayList<>();	1✔
413	private final List<ColumnOverride> columnOverrides = new ArrayList<>();	1✔
414	private final Map<IgnoredColumn, Boolean> ignoredColumns = new HashMap<>();	1✔
415
416	public TableConfiguration build() {
417	return new TableConfiguration(this);	1✔
418	}
419
420	@Override
421	protected Builder getThis() {
422	return this;	1✔
423	}
424
425	public Builder withModelType(@Nullable String tableModelType) {
426	this.modelType = tableModelType == null ? null : ModelType.getModelType(tableModelType);	1✔
427	return getThis();	1✔
428	}
429
430	public Builder withCatalog(@Nullable String catalog) {
431	this.catalog = catalog;	1✔
432	return this;	1✔
433	}
434
435	public Builder withSchema(@Nullable String schema) {
436	this.schema = schema;	1✔
437	return this;	1✔
438	}
439
440	public Builder withTableName(@Nullable String tableName) {
441	this.tableName = tableName;	1✔
442	return this;	1✔
443	}
444
445	public Builder withDomainObjectName(@Nullable String domainObjectName) {
446	this.domainObjectName = domainObjectName;	1✔
447	return this;	1✔
448	}
449
450	public Builder withAlias(@Nullable String alias) {
451	this.alias = alias;	1✔
452	return this;	1✔
453	}
454
455	@SuppressWarnings("UnusedReturnValue")
456	public Builder withInsertStatementEnabled(boolean insertStatementEnabled) {
UNCOV 457	this.insertStatementEnabled = insertStatementEnabled;	×
UNCOV 458	return this;	×
459	}
460
461	@SuppressWarnings("UnusedReturnValue")
462	public Builder withSelectByPrimaryKeyStatementEnabled(boolean selectByPrimaryKeyStatementEnabled) {
UNCOV 463	this.selectByPrimaryKeyStatementEnabled = selectByPrimaryKeyStatementEnabled;	×
UNCOV 464	return this;	×
465	}
466
467	@SuppressWarnings("UnusedReturnValue")
468	public Builder withSelectByExampleStatementEnabled(boolean selectByExampleStatementEnabled) {
469	this.selectByExampleStatementEnabled = selectByExampleStatementEnabled;	1✔
470	return this;	1✔
471	}
472
473	@SuppressWarnings("UnusedReturnValue")
474	public Builder withUpdateByPrimaryKeyStatementEnabled(boolean updateByPrimaryKeyStatementEnabled) {
UNCOV 475	this.updateByPrimaryKeyStatementEnabled = updateByPrimaryKeyStatementEnabled;	×
UNCOV 476	return this;	×
477	}
478
479	@SuppressWarnings("UnusedReturnValue")
480	public Builder withDeleteByPrimaryKeyStatementEnabled(boolean deleteByPrimaryKeyStatementEnabled) {
UNCOV 481	this.deleteByPrimaryKeyStatementEnabled = deleteByPrimaryKeyStatementEnabled;	×
UNCOV 482	return this;	×
483	}
484
485	@SuppressWarnings("UnusedReturnValue")
486	public Builder withDeleteByExampleStatementEnabled(boolean deleteByExampleStatementEnabled) {
UNCOV 487	this.deleteByExampleStatementEnabled = deleteByExampleStatementEnabled;	×
UNCOV 488	return this;	×
489	}
490
491	@SuppressWarnings("UnusedReturnValue")
492	public Builder withCountByExampleStatementEnabled(boolean countByExampleStatementEnabled) {
UNCOV 493	this.countByExampleStatementEnabled = countByExampleStatementEnabled;	×
UNCOV 494	return this;	×
495	}
496
497	@SuppressWarnings("UnusedReturnValue")
498	public Builder withUpdateByExampleStatementEnabled(boolean updateByExampleStatementEnabled) {
UNCOV 499	this.updateByExampleStatementEnabled = updateByExampleStatementEnabled;	×
UNCOV 500	return this;	×
501	}
502
503	@SuppressWarnings("UnusedReturnValue")
504	public Builder withWildcardEscapingEnabled(boolean wildcardEscapingEnabled) {
UNCOV 505	this.wildcardEscapingEnabled = wildcardEscapingEnabled;	×
UNCOV 506	return this;	×
507	}
508
509	@SuppressWarnings("UnusedReturnValue")
510	public Builder withDelimitIdentifiers(boolean delimitIdentifiers) {
UNCOV 511	this.delimitIdentifiers = delimitIdentifiers;	×
UNCOV 512	return this;	×
513	}
514
515	@SuppressWarnings("UnusedReturnValue")
516	public Builder withAllColumnDelimitingEnabled(boolean isAllColumnDelimitingEnabled) {
UNCOV 517	this.isAllColumnDelimitingEnabled = isAllColumnDelimitingEnabled;	×
UNCOV 518	return this;	×
519	}
520
521	public Builder withMapperName(@Nullable String mapperName) {
522	this.mapperName = mapperName;	1✔
523	return this;	1✔
524	}
525
526	public Builder withSqlProviderName(@Nullable String sqlProviderName) {
527	this.sqlProviderName = sqlProviderName;	1✔
528	return this;	1✔
529	}
530
531	@SuppressWarnings("UnusedReturnValue")
532	public Builder withGeneratedKey(@Nullable GeneratedKey generatedKey) {
533	this.generatedKey = generatedKey;	1✔
534	return this;	1✔
535	}
536
537	@SuppressWarnings("UnusedReturnValue")
538	public Builder withDomainObjectRenamingRule(@Nullable DomainObjectRenamingRule domainObjectRenamingRule) {
539	this.domainObjectRenamingRule = domainObjectRenamingRule;	1✔
540	return this;	1✔
541	}
542
543	@SuppressWarnings("UnusedReturnValue")
544	public Builder withColumnRenamingRule(@Nullable ColumnRenamingRule columnRenamingRule) {
545	this.columnRenamingRule = columnRenamingRule;	1✔
546	return this;	1✔
547	}
548
549	@SuppressWarnings("UnusedReturnValue")
550	public Builder withIgnoredColumnPattern(IgnoredColumnPattern ignoredColumnPattern) {
551	this.ignoredColumnPatterns.add(ignoredColumnPattern);	1✔
552	return this;	1✔
553	}
554
555	@SuppressWarnings("UnusedReturnValue")
556	public Builder withIgnoredColumn(IgnoredColumn ignoredColumn) {
557	this.ignoredColumns.put(ignoredColumn, Boolean.FALSE);	1✔
558	return this;	1✔
559	}
560
561	@SuppressWarnings("UnusedReturnValue")
562	public Builder withColumnOverride(ColumnOverride columnOverride) {
563	this.columnOverrides.add(columnOverride);	1✔
564	return this;	1✔
565	}
566	}
567	}

mybatis / generator / 2209

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous