2211

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

Build # 2211

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #1513 from jeffgbutler/inferred-generated-key-plugin

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%)

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 {
            throw new InvalidConfigurationException(Messages.getString("ValidationError.35"), errors); //$NON-NLS-1$
        }
    }

    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 {
NEW 331	throw new InvalidConfigurationException(Messages.getString("ValidationError.35"), errors); //$NON-NLS-1$	×
332	}
333	}	1✔
334
335	public boolean isImmutable(Context context) {
336	Properties properties;
337
338	if (getProperties().containsKey(PropertyRegistry.ANY_IMMUTABLE)) {	1✔
339	properties = getProperties();	1✔
340	} else {
341	properties = context.getModelGeneratorConfiguration().getProperties();	1✔
342	}
343
344	return isTrue(properties.getProperty(PropertyRegistry.ANY_IMMUTABLE));	1✔
345	}
346
347	public boolean generateKotlinV1Model(Context context) {
348	Properties properties;
349
350	if (getProperties().containsKey(PropertyRegistry.GENERATE_KOTLIN_V1_MODEL)) {	1✔
351	properties = getProperties();	1✔
352	} else {
353	properties = context.getModelGeneratorConfiguration().getProperties();	1✔
354	}
355
356	return isTrue(properties.getProperty(PropertyRegistry.GENERATE_KOTLIN_V1_MODEL));	1✔
357	}
358
359	public @Nullable DomainObjectRenamingRule getDomainObjectRenamingRule() {
360	return domainObjectRenamingRule;	1✔
361	}
362
363	public Optional<ColumnRenamingRule> getColumnRenamingRule() {
364	return Optional.ofNullable(columnRenamingRule);	1✔
365	}
366
367	public boolean isAllColumnDelimitingEnabled() {
368	return isAllColumnDelimitingEnabled;	1✔
369	}
370
371	public @Nullable String getMapperName() {
372	return mapperName;	1✔
373	}
374
375	public @Nullable String getSqlProviderName() {
376	return sqlProviderName;	1✔
377	}
378
379	public @Nullable String getDynamicSqlSupportClassName() {
380	return getProperty(PropertyRegistry.TABLE_DYNAMIC_SQL_SUPPORT_CLASS_NAME);	1✔
381	}
382
383	public @Nullable String getDynamicSqlTableObjectName() {
384	return getProperty(PropertyRegistry.TABLE_DYNAMIC_SQL_TABLE_OBJECT_NAME);	1✔
385	}
386
387	public static class Builder extends AbstractBuilder<Builder> {	1✔
388	private @Nullable ModelType modelType;
389	private @Nullable String catalog;
390	private @Nullable String schema;
391	private @Nullable String tableName;
392	private @Nullable String domainObjectName;
393	private @Nullable String alias;
394	private boolean insertStatementEnabled = true;	1✔
395	private boolean selectByPrimaryKeyStatementEnabled = true;	1✔
396	private boolean selectByExampleStatementEnabled = true;	1✔
397	private boolean updateByPrimaryKeyStatementEnabled = true;	1✔
398	private boolean deleteByPrimaryKeyStatementEnabled = true;	1✔
399	private boolean deleteByExampleStatementEnabled = true;	1✔
400	private boolean countByExampleStatementEnabled = true;	1✔
401	private boolean updateByExampleStatementEnabled = true;	1✔
402	private boolean wildcardEscapingEnabled;
403	private boolean delimitIdentifiers;
404	private boolean isAllColumnDelimitingEnabled;
405	private @Nullable String mapperName;
406	private @Nullable String sqlProviderName;
407	private @Nullable GeneratedKey generatedKey;
408	private @Nullable DomainObjectRenamingRule domainObjectRenamingRule;
409	private @Nullable ColumnRenamingRule columnRenamingRule;
410	private final List<IgnoredColumnPattern> ignoredColumnPatterns = new ArrayList<>();	1✔
411	private final List<ColumnOverride> columnOverrides = new ArrayList<>();	1✔
412	private final Map<IgnoredColumn, Boolean> ignoredColumns = new HashMap<>();	1✔
413
414	public TableConfiguration build() {
415	return new TableConfiguration(this);	1✔
416	}
417
418	@Override
419	protected Builder getThis() {
420	return this;	1✔
421	}
422
423	public Builder withModelType(@Nullable String tableModelType) {
424	this.modelType = tableModelType == null ? null : ModelType.getModelType(tableModelType);	1✔
425	return getThis();	1✔
426	}
427
428	public Builder withCatalog(@Nullable String catalog) {
429	this.catalog = catalog;	1✔
430	return this;	1✔
431	}
432
433	public Builder withSchema(@Nullable String schema) {
434	this.schema = schema;	1✔
435	return this;	1✔
436	}
437
438	public Builder withTableName(@Nullable String tableName) {
439	this.tableName = tableName;	1✔
440	return this;	1✔
441	}
442
443	public Builder withDomainObjectName(@Nullable String domainObjectName) {
444	this.domainObjectName = domainObjectName;	1✔
445	return this;	1✔
446	}
447
448	public Builder withAlias(@Nullable String alias) {
449	this.alias = alias;	1✔
450	return this;	1✔
451	}
452
453	@SuppressWarnings("UnusedReturnValue")
454	public Builder withInsertStatementEnabled(boolean insertStatementEnabled) {
455	this.insertStatementEnabled = insertStatementEnabled;	×
456	return this;	×
457	}
458
459	@SuppressWarnings("UnusedReturnValue")
460	public Builder withSelectByPrimaryKeyStatementEnabled(boolean selectByPrimaryKeyStatementEnabled) {
461	this.selectByPrimaryKeyStatementEnabled = selectByPrimaryKeyStatementEnabled;	×
462	return this;	×
463	}
464
465	@SuppressWarnings("UnusedReturnValue")
466	public Builder withSelectByExampleStatementEnabled(boolean selectByExampleStatementEnabled) {
467	this.selectByExampleStatementEnabled = selectByExampleStatementEnabled;	1✔
468	return this;	1✔
469	}
470
471	@SuppressWarnings("UnusedReturnValue")
472	public Builder withUpdateByPrimaryKeyStatementEnabled(boolean updateByPrimaryKeyStatementEnabled) {
473	this.updateByPrimaryKeyStatementEnabled = updateByPrimaryKeyStatementEnabled;	×
474	return this;	×
475	}
476
477	@SuppressWarnings("UnusedReturnValue")
478	public Builder withDeleteByPrimaryKeyStatementEnabled(boolean deleteByPrimaryKeyStatementEnabled) {
479	this.deleteByPrimaryKeyStatementEnabled = deleteByPrimaryKeyStatementEnabled;	×
480	return this;	×
481	}
482
483	@SuppressWarnings("UnusedReturnValue")
484	public Builder withDeleteByExampleStatementEnabled(boolean deleteByExampleStatementEnabled) {
485	this.deleteByExampleStatementEnabled = deleteByExampleStatementEnabled;	×
486	return this;	×
487	}
488
489	@SuppressWarnings("UnusedReturnValue")
490	public Builder withCountByExampleStatementEnabled(boolean countByExampleStatementEnabled) {
491	this.countByExampleStatementEnabled = countByExampleStatementEnabled;	×
492	return this;	×
493	}
494
495	@SuppressWarnings("UnusedReturnValue")
496	public Builder withUpdateByExampleStatementEnabled(boolean updateByExampleStatementEnabled) {
497	this.updateByExampleStatementEnabled = updateByExampleStatementEnabled;	×
498	return this;	×
499	}
500
501	@SuppressWarnings("UnusedReturnValue")
502	public Builder withWildcardEscapingEnabled(boolean wildcardEscapingEnabled) {
503	this.wildcardEscapingEnabled = wildcardEscapingEnabled;	×
504	return this;	×
505	}
506
507	@SuppressWarnings("UnusedReturnValue")
508	public Builder withDelimitIdentifiers(boolean delimitIdentifiers) {
509	this.delimitIdentifiers = delimitIdentifiers;	×
510	return this;	×
511	}
512
513	@SuppressWarnings("UnusedReturnValue")
514	public Builder withAllColumnDelimitingEnabled(boolean isAllColumnDelimitingEnabled) {
515	this.isAllColumnDelimitingEnabled = isAllColumnDelimitingEnabled;	×
516	return this;	×
517	}
518
519	public Builder withMapperName(@Nullable String mapperName) {
520	this.mapperName = mapperName;	1✔
521	return this;	1✔
522	}
523
524	public Builder withSqlProviderName(@Nullable String sqlProviderName) {
525	this.sqlProviderName = sqlProviderName;	1✔
526	return this;	1✔
527	}
528
529	@SuppressWarnings("UnusedReturnValue")
530	public Builder withGeneratedKey(@Nullable GeneratedKey generatedKey) {
531	this.generatedKey = generatedKey;	1✔
532	return this;	1✔
533	}
534
535	@SuppressWarnings("UnusedReturnValue")
536	public Builder withDomainObjectRenamingRule(@Nullable DomainObjectRenamingRule domainObjectRenamingRule) {
537	this.domainObjectRenamingRule = domainObjectRenamingRule;	1✔
538	return this;	1✔
539	}
540
541	@SuppressWarnings("UnusedReturnValue")
542	public Builder withColumnRenamingRule(@Nullable ColumnRenamingRule columnRenamingRule) {
543	this.columnRenamingRule = columnRenamingRule;	1✔
544	return this;	1✔
545	}
546
547	@SuppressWarnings("UnusedReturnValue")
548	public Builder withIgnoredColumnPattern(IgnoredColumnPattern ignoredColumnPattern) {
549	this.ignoredColumnPatterns.add(ignoredColumnPattern);	1✔
550	return this;	1✔
551	}
552
553	@SuppressWarnings("UnusedReturnValue")
554	public Builder withIgnoredColumn(IgnoredColumn ignoredColumn) {
555	this.ignoredColumns.put(ignoredColumn, Boolean.FALSE);	1✔
556	return this;	1✔
557	}
558
559	@SuppressWarnings("UnusedReturnValue")
560	public Builder withColumnOverride(ColumnOverride columnOverride) {
561	this.columnOverrides.add(columnOverride);	1✔
562	return this;	1✔
563	}
564	}
565	}

mybatis / generator / 2211

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