From cbc8869d565fa9ebcd9baac946c166f35ab18b0e Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Sat, 21 Dec 2019 07:58:56 -0500 Subject: [PATCH 01/14] Initial work on general insert --- .../org/mybatis/dynamic/sql/SqlBuilder.java | 32 +++++- .../dynamic/sql/insert/GeneralInsertDSL.java | 105 ++++++++++++++++++ .../sql/insert/GeneralInsertModel.java | 73 ++++++++++++ ...DefaultGeneralInsertStatementProvider.java | 63 +++++++++++ .../render/FieldAndValueAndParameters.java | 82 ++++++++++++++ .../FieldAndValueAndParametersCollector.java | 65 +++++++++++ .../insert/render/GeneralInsertRenderer.java | 84 ++++++++++++++ .../GeneralInsertStatementProvider.java | 24 ++++ .../GeneralInsertValuePhraseVisitor.java | 97 ++++++++++++++++ .../sql/util/BaseInsertMappingVisitor.java | 24 ++++ .../dynamic/sql/util/ConstantMapping.java | 9 +- .../sql/util/GeneralInsertMapping.java | 21 ++++ .../sql/util/GeneralInsertMappingVisitor.java | 22 ++++ .../sql/util/InsertMappingVisitor.java | 10 +- .../mybatis/dynamic/sql/util/NullMapping.java | 9 +- .../dynamic/sql/util/SelectMapping.java | 9 +- .../dynamic/sql/util/SqlProviderAdapter.java | 5 + .../sql/util/StringConstantMapping.java | 9 +- .../dynamic/sql/util/ValueMapping.java | 7 +- .../animal/data/AnimalDataMapper.java | 6 +- .../examples/animal/data/AnimalDataTest.java | 27 +++++ 21 files changed, 763 insertions(+), 20 deletions(-) create mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertDSL.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertModel.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultGeneralInsertStatementProvider.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParameters.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParametersCollector.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertStatementProvider.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/util/BaseInsertMappingVisitor.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMapping.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMappingVisitor.java diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java index eb4cbdfd5..2d0752e49 100644 --- a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java +++ b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java @@ -17,14 +17,18 @@ import java.util.Arrays; import java.util.Collection; +import java.util.Objects; import java.util.function.Supplier; import org.mybatis.dynamic.sql.delete.DeleteDSL; import org.mybatis.dynamic.sql.delete.DeleteModel; import org.mybatis.dynamic.sql.insert.BatchInsertDSL; +import org.mybatis.dynamic.sql.insert.GeneralInsertDSL; +import org.mybatis.dynamic.sql.insert.GeneralInsertDSL.SetClauseFinisher; import org.mybatis.dynamic.sql.insert.InsertDSL; import org.mybatis.dynamic.sql.insert.InsertSelectDSL; import org.mybatis.dynamic.sql.insert.MultiRowInsertDSL; +import org.mybatis.dynamic.sql.insert.InsertSelectDSL.SelectGatherer; import org.mybatis.dynamic.sql.select.CountDSL; import org.mybatis.dynamic.sql.select.QueryExpressionDSL.FromGatherer; import org.mybatis.dynamic.sql.select.SelectDSL; @@ -133,8 +137,8 @@ static MultiRowInsertDSL.IntoGatherer insertMultiple(Collection record return MultiRowInsertDSL.insert(records); } - static InsertSelectDSL.InsertColumnGatherer insertInto(SqlTable table) { - return InsertSelectDSL.insertInto(table); + static InsertIntoNextStep insertInto(SqlTable table) { + return new InsertIntoNextStep(table); } static FromGatherer select(BasicColumn...selectList) { @@ -636,4 +640,28 @@ static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(Colle static SortSpecification sortColumn(String name) { return SimpleSortSpecification.of(name); } + + public static class InsertIntoNextStep { + + private SqlTable table; + + private InsertIntoNextStep(SqlTable table) { + this.table = Objects.requireNonNull(table); + } + + public InsertSelectDSL withSelectStatement(Buildable selectModelBuilder) { + return InsertSelectDSL.insertInto(table) + .withSelectStatement(selectModelBuilder); + } + + public SelectGatherer withColumnList(SqlColumn...columns) { + return InsertSelectDSL.insertInto(table) + .withColumnList(columns); + } + + public SetClauseFinisher set(SqlColumn column) { + return GeneralInsertDSL.insertInto(table) + .set(column); + } + } } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertDSL.java b/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertDSL.java new file mode 100644 index 000000000..dadf6f763 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertDSL.java @@ -0,0 +1,105 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.insert; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.function.Supplier; + +import org.mybatis.dynamic.sql.SqlColumn; +import org.mybatis.dynamic.sql.SqlTable; +import org.mybatis.dynamic.sql.select.SelectModel; +import org.mybatis.dynamic.sql.util.Buildable; +import org.mybatis.dynamic.sql.util.ConstantMapping; +import org.mybatis.dynamic.sql.util.GeneralInsertMapping; +import org.mybatis.dynamic.sql.util.NullMapping; +import org.mybatis.dynamic.sql.util.SelectMapping; +import org.mybatis.dynamic.sql.util.StringConstantMapping; +import org.mybatis.dynamic.sql.util.ValueMapping; + +public class GeneralInsertDSL { + private List insertMappings = new ArrayList<>(); + private SqlTable table; + + private GeneralInsertDSL(SqlTable table) { + this.table = Objects.requireNonNull(table); + } + + public SetClauseFinisher set(SqlColumn column) { + return new SetClauseFinisher<>(column); + } + + public GeneralInsertModel build() { + return new GeneralInsertModel.Builder() + .withTable(table) + .withInsertMappings(insertMappings) + .build(); + } + + public static GeneralInsertDSL insertInto(SqlTable table) { + return new GeneralInsertDSL(table); + } + + public class SetClauseFinisher { + + private SqlColumn column; + + public SetClauseFinisher(SqlColumn column) { + this.column = column; + } + + public GeneralInsertDSL equalToNull() { + insertMappings.add(NullMapping.of(column)); + return GeneralInsertDSL.this; + } + + public GeneralInsertDSL equalToConstant(String constant) { + insertMappings.add(ConstantMapping.of(column, constant)); + return GeneralInsertDSL.this; + } + + public GeneralInsertDSL equalToStringConstant(String constant) { + insertMappings.add(StringConstantMapping.of(column, constant)); + return GeneralInsertDSL.this; + } + + public GeneralInsertDSL equalTo(T value) { + return equalTo(() -> value); + } + + public GeneralInsertDSL equalTo(Supplier valueSupplier) { + insertMappings.add(ValueMapping.of(column, valueSupplier)); + return GeneralInsertDSL.this; + } + + public GeneralInsertDSL equalTo(Buildable buildable) { + insertMappings.add(SelectMapping.of(column, buildable)); + return GeneralInsertDSL.this; + } + + public GeneralInsertDSL equalToWhenPresent(T value) { + return equalToWhenPresent(() -> value); + } + + public GeneralInsertDSL equalToWhenPresent(Supplier valueSupplier) { + if (valueSupplier.get() != null) { + insertMappings.add(ValueMapping.of(column, valueSupplier)); + } + return GeneralInsertDSL.this; + } + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertModel.java b/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertModel.java new file mode 100644 index 000000000..8f3aeaa0d --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertModel.java @@ -0,0 +1,73 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.insert; + +import java.util.ArrayList; +import java.util.List; +import java.util.Objects; +import java.util.function.Function; +import java.util.stream.Stream; + +import org.mybatis.dynamic.sql.SqlTable; +import org.mybatis.dynamic.sql.insert.render.GeneralInsertRenderer; +import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider; +import org.mybatis.dynamic.sql.render.RenderingStrategy; +import org.mybatis.dynamic.sql.util.GeneralInsertMapping; + +public class GeneralInsertModel { + + private SqlTable table; + private List insertMappings; + + private GeneralInsertModel(Builder builder) { + table = Objects.requireNonNull(builder.table); + insertMappings = builder.insertMappings; + } + + public Stream mapColumnMappings(Function mapper) { + return insertMappings.stream().map(mapper); + } + + public SqlTable table() { + return table; + } + + public GeneralInsertStatementProvider render(RenderingStrategy renderingStrategy) { + return GeneralInsertRenderer.withInsertModel(this) + .withRenderingStrategy(renderingStrategy) + .build() + .render(); + } + + public static class Builder { + private SqlTable table; + private List insertMappings = new ArrayList<>(); + + public Builder withTable(SqlTable table) { + this.table = table; + return this; + } + + public Builder withInsertMappings(List insertMappings) { + this.insertMappings.addAll(insertMappings); + return this; + } + + public GeneralInsertModel build() { + return new GeneralInsertModel(this); + } + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultGeneralInsertStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultGeneralInsertStatementProvider.java new file mode 100644 index 000000000..fc5675e28 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultGeneralInsertStatementProvider.java @@ -0,0 +1,63 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.insert.render; + +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +public class DefaultGeneralInsertStatementProvider implements GeneralInsertStatementProvider { + private String insertStatement; + private Map parameters = new HashMap<>(); + + private DefaultGeneralInsertStatementProvider(Builder builder) { + insertStatement = Objects.requireNonNull(builder.insertStatement); + parameters.putAll(builder.parameters); + } + + @Override + public Map getParameters() { + return parameters; + } + + @Override + public String getInsertStatement() { + return insertStatement; + } + + public static Builder withInsertStatement(String insertStatement) { + return new Builder().withInsertStatement(insertStatement); + } + + public static class Builder { + private String insertStatement; + private Map parameters = new HashMap<>(); + + public Builder withInsertStatement(String insertStatement) { + this.insertStatement = insertStatement; + return this; + } + + public Builder withParameters(Map parameters) { + this.parameters.putAll(parameters); + return this; + } + + public DefaultGeneralInsertStatementProvider build() { + return new DefaultGeneralInsertStatementProvider(this); + } + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParameters.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParameters.java new file mode 100644 index 000000000..80d2a24bb --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParameters.java @@ -0,0 +1,82 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.insert.render; + +import java.util.HashMap; +import java.util.Map; +import java.util.Objects; + +public class FieldAndValueAndParameters { + private String fieldName; + private String valuePhrase; + private Map parameters; + + private FieldAndValueAndParameters(Builder builder) { + fieldName = Objects.requireNonNull(builder.fieldName); + valuePhrase = Objects.requireNonNull(builder.valuePhrase); + parameters = builder.parameters; + } + + public String fieldName() { + return fieldName; + } + + public String valuePhrase() { + return valuePhrase; + } + + public String valuePhrase(int row) { + return String.format(valuePhrase, row); + } + + public Map parameters() { + return parameters; + } + + public static Builder withFieldName(String fieldName) { + return new Builder().withFieldName(fieldName); + } + + public static class Builder { + private String fieldName; + private String valuePhrase; + private Map parameters = new HashMap<>(); + + public Builder withFieldName(String fieldName) { + this.fieldName = fieldName; + return this; + } + + public Builder withValuePhrase(String valuePhrase) { + this.valuePhrase = valuePhrase; + return this; + } + + public Builder withParameter(String key, Object value) { + parameters.put(key, value); + return this; + } + + public Builder withParameters(Map parameters) { + this.parameters.putAll(parameters); + return this; + } + + public FieldAndValueAndParameters build() { + return new FieldAndValueAndParameters(this); + } + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParametersCollector.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParametersCollector.java new file mode 100644 index 000000000..79432d14d --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParametersCollector.java @@ -0,0 +1,65 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.insert.render; + +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.stream.Collector; +import java.util.stream.Collectors; + +public class FieldAndValueAndParametersCollector { + + private List fieldsAndValue = new ArrayList<>(); + + public FieldAndValueAndParametersCollector() { + super(); + } + + public void add(FieldAndValueAndParameters fieldAndValue) { + fieldsAndValue.add(fieldAndValue); + } + + public FieldAndValueAndParametersCollector merge(FieldAndValueAndParametersCollector other) { + fieldsAndValue.addAll(other.fieldsAndValue); + return this; + } + + public String columnsPhrase() { + return fieldsAndValue.stream() + .map(FieldAndValueAndParameters::fieldName) + .collect(Collectors.joining(", ", "(", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + } + + public String valuesPhrase() { + return fieldsAndValue.stream() + .map(FieldAndValueAndParameters::valuePhrase) + .collect(Collectors.joining(", ", "values (", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + } + + public Map parameters() { + return fieldsAndValue.stream() + .map(FieldAndValueAndParameters::parameters) + .collect(HashMap::new, HashMap::putAll, HashMap::putAll); + } + + public static Collector collect() { + return Collector.of(FieldAndValueAndParametersCollector::new, + FieldAndValueAndParametersCollector::add, + FieldAndValueAndParametersCollector::merge); + } +} \ No newline at end of file diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java new file mode 100644 index 000000000..bfef19092 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java @@ -0,0 +1,84 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.insert.render; + +import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; + +import java.util.Objects; +import java.util.function.Function; + +import org.mybatis.dynamic.sql.insert.GeneralInsertModel; +import org.mybatis.dynamic.sql.render.RenderingStrategy; +import org.mybatis.dynamic.sql.util.GeneralInsertMapping; + +public class GeneralInsertRenderer { + + private GeneralInsertModel model; + private RenderingStrategy renderingStrategy; + + private GeneralInsertRenderer(Builder builder) { + model = Objects.requireNonNull(builder.model); + renderingStrategy = Objects.requireNonNull(builder.renderingStrategy); + } + + public GeneralInsertStatementProvider render() { + GeneralInsertValuePhraseVisitor visitor = new GeneralInsertValuePhraseVisitor(renderingStrategy); + FieldAndValueAndParametersCollector collector = model.mapColumnMappings(toFieldAndValue(visitor)) + .collect(FieldAndValueAndParametersCollector.collect()); + + return DefaultGeneralInsertStatementProvider.withInsertStatement(calculateInsertStatement(collector)) + .withParameters(collector.parameters()) + .build(); + } + + private String calculateInsertStatement(FieldAndValueAndParametersCollector collector) { + return "insert into" //$NON-NLS-1$ + + spaceBefore(model.table().tableNameAtRuntime()) + + spaceBefore(collector.columnsPhrase()) + + spaceBefore(collector.valuesPhrase()); + } + + private Function toFieldAndValue(GeneralInsertValuePhraseVisitor visitor) { + return insertMapping -> toFieldAndValue(visitor, insertMapping); + } + + private FieldAndValueAndParameters toFieldAndValue(GeneralInsertValuePhraseVisitor visitor, GeneralInsertMapping insertMapping) { + return insertMapping.accept(visitor); + } + + public static Builder withInsertModel(GeneralInsertModel model) { + return new Builder().withInsertModel(model); + } + + public static class Builder { + private GeneralInsertModel model; + private RenderingStrategy renderingStrategy; + + public Builder withInsertModel(GeneralInsertModel model) { + this.model = model; + return this; + } + + public Builder withRenderingStrategy(RenderingStrategy renderingStrategy) { + this.renderingStrategy = renderingStrategy; + return this; + } + + public GeneralInsertRenderer build() { + return new GeneralInsertRenderer(this); + } + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertStatementProvider.java new file mode 100644 index 000000000..b3b73bc91 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertStatementProvider.java @@ -0,0 +1,24 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.insert.render; + +import java.util.Map; + +public interface GeneralInsertStatementProvider { + Map getParameters(); + + String getInsertStatement(); +} diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java new file mode 100644 index 000000000..89b9eefdb --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java @@ -0,0 +1,97 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.insert.render; + +import java.util.concurrent.atomic.AtomicInteger; +import java.util.function.Function; + +import org.mybatis.dynamic.sql.SqlColumn; +import org.mybatis.dynamic.sql.render.RenderingStrategy; +import org.mybatis.dynamic.sql.select.render.SelectRenderer; +import org.mybatis.dynamic.sql.select.render.SelectStatementProvider; +import org.mybatis.dynamic.sql.util.ConstantMapping; +import org.mybatis.dynamic.sql.util.GeneralInsertMappingVisitor; +import org.mybatis.dynamic.sql.util.NullMapping; +import org.mybatis.dynamic.sql.util.SelectMapping; +import org.mybatis.dynamic.sql.util.StringConstantMapping; +import org.mybatis.dynamic.sql.util.ValueMapping; + +public class GeneralInsertValuePhraseVisitor implements GeneralInsertMappingVisitor { + + protected RenderingStrategy renderingStrategy; + private AtomicInteger sequence = new AtomicInteger(1); + + public GeneralInsertValuePhraseVisitor(RenderingStrategy renderingStrategy) { + this.renderingStrategy = renderingStrategy; + } + + @Override + public FieldAndValueAndParameters visit(NullMapping mapping) { + return FieldAndValueAndParameters.withFieldName(mapping.mapColumn(SqlColumn::name)) + .withValuePhrase("null") //$NON-NLS-1$ + .build(); + } + + @Override + public FieldAndValueAndParameters visit(ConstantMapping mapping) { + return FieldAndValueAndParameters.withFieldName(mapping.mapColumn(SqlColumn::name)) + .withValuePhrase(mapping.constant()) + .build(); + } + + @Override + public FieldAndValueAndParameters visit(StringConstantMapping mapping) { + return FieldAndValueAndParameters.withFieldName(mapping.mapColumn(SqlColumn::name)) + .withValuePhrase("'" + mapping.constant() + "'") //$NON-NLS-1$ //$NON-NLS-2$ + .build(); + } + + @Override + public FieldAndValueAndParameters visit(ValueMapping mapping) { + String mapKey = RenderingStrategy.formatParameterMapKey(sequence); + + String jdbcPlaceholder = mapping.mapColumn(toJdbcPlaceholder(mapKey)); + + return FieldAndValueAndParameters.withFieldName(mapping.mapColumn(SqlColumn::name)) + .withValuePhrase(jdbcPlaceholder) + .withParameter(mapKey, mapping.value()) + .build(); + } + + @Override + public FieldAndValueAndParameters visit(SelectMapping mapping) { + SelectStatementProvider selectStatement = SelectRenderer.withSelectModel(mapping.selectModel()) + .withRenderingStrategy(renderingStrategy) + .withSequence(sequence) + .build() + .render(); + + String fragment = mapping.mapColumn(SqlColumn::name) + + " = (" //$NON-NLS-1$ + + selectStatement.getSelectStatement() + + ")"; //$NON-NLS-1$ + + return FieldAndValueAndParameters.withFieldName(mapping.mapColumn(SqlColumn::name)) + .withValuePhrase(fragment) + .withParameters(selectStatement.getParameters()) + .build(); + } + + private Function, String> toJdbcPlaceholder(String parameterName) { + return column -> renderingStrategy + .getFormattedJdbcPlaceholder(column, RenderingStrategy.DEFAULT_PARAMETER_PREFIX, parameterName); + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/BaseInsertMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/BaseInsertMappingVisitor.java new file mode 100644 index 000000000..561fa3a44 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/util/BaseInsertMappingVisitor.java @@ -0,0 +1,24 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.util; + +public interface BaseInsertMappingVisitor { + T visit(NullMapping mapping); + + T visit(ConstantMapping mapping); + + T visit(StringConstantMapping mapping); +} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java index 6e4b89f4c..714b97bc9 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2019 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. @@ -24,7 +24,7 @@ * @author Jeff Butler * */ -public class ConstantMapping extends AbstractColumnMapping implements InsertMapping, UpdateMapping { +public class ConstantMapping extends AbstractColumnMapping implements GeneralInsertMapping, InsertMapping, UpdateMapping { private String constant; private ConstantMapping(SqlColumn column) { @@ -50,4 +50,9 @@ public R accept(UpdateMappingVisitor visitor) { public R accept(InsertMappingVisitor visitor) { return visitor.visit(this); } + + @Override + public R accept(GeneralInsertMappingVisitor visitor) { + return visitor.visit(this); + } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMapping.java new file mode 100644 index 000000000..e44d03411 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMapping.java @@ -0,0 +1,21 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.util; + +@FunctionalInterface +public interface GeneralInsertMapping { + R accept(GeneralInsertMappingVisitor visitor); +} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMappingVisitor.java new file mode 100644 index 000000000..97801c95b --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMappingVisitor.java @@ -0,0 +1,22 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.util; + +public interface GeneralInsertMappingVisitor extends BaseInsertMappingVisitor { + T visit(ValueMapping mapping); + + T visit(SelectMapping mapping); +} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/InsertMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/InsertMappingVisitor.java index d0d919a98..c523fbf0c 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/InsertMappingVisitor.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/InsertMappingVisitor.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2019 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. @@ -15,12 +15,6 @@ */ package org.mybatis.dynamic.sql.util; -public interface InsertMappingVisitor { - T visit(NullMapping mapping); - - T visit(ConstantMapping mapping); - - T visit(StringConstantMapping mapping); - +public interface InsertMappingVisitor extends BaseInsertMappingVisitor { T visit(PropertyMapping mapping); } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java index 87426396d..4e3d6ee96 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2019 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. @@ -17,7 +17,7 @@ import org.mybatis.dynamic.sql.SqlColumn; -public class NullMapping extends AbstractColumnMapping implements InsertMapping, UpdateMapping { +public class NullMapping extends AbstractColumnMapping implements GeneralInsertMapping, InsertMapping, UpdateMapping { private NullMapping(SqlColumn column) { super(column); } @@ -35,4 +35,9 @@ public R accept(UpdateMappingVisitor visitor) { public R accept(InsertMappingVisitor visitor) { return visitor.visit(this); } + + @Override + public R accept(GeneralInsertMappingVisitor visitor) { + return visitor.visit(this); + } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java index 304540873..b2411bba2 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2018 the original author or authors. + * Copyright 2016-2019 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. @@ -18,7 +18,7 @@ import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.select.SelectModel; -public class SelectMapping extends AbstractColumnMapping implements UpdateMapping { +public class SelectMapping extends AbstractColumnMapping implements UpdateMapping, GeneralInsertMapping { private SelectModel selectModel; @@ -36,6 +36,11 @@ public R accept(UpdateMappingVisitor visitor) { return visitor.visit(this); } + @Override + public R accept(GeneralInsertMappingVisitor visitor) { + return visitor.visit(this); + } + public static SelectMapping of(SqlColumn column, Buildable selectModelBuilder) { return new SelectMapping(column, selectModelBuilder); } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/SqlProviderAdapter.java b/src/main/java/org/mybatis/dynamic/sql/util/SqlProviderAdapter.java index e645334d5..4f35ca29b 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/SqlProviderAdapter.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/SqlProviderAdapter.java @@ -16,6 +16,7 @@ package org.mybatis.dynamic.sql.util; import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider; +import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider; import org.mybatis.dynamic.sql.insert.render.InsertSelectStatementProvider; import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider; import org.mybatis.dynamic.sql.insert.render.MultiRowInsertStatementProvider; @@ -34,6 +35,10 @@ public String delete(DeleteStatementProvider deleteStatement) { return deleteStatement.getDeleteStatement(); } + public String generalInsert(GeneralInsertStatementProvider insertStatement) { + return insertStatement.getInsertStatement(); + } + public String insert(InsertStatementProvider insertStatement) { return insertStatement.getInsertStatement(); } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java index f213fdaa2..3061bec5a 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2019 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. @@ -24,7 +24,7 @@ * @author Jeff Butler * */ -public class StringConstantMapping extends AbstractColumnMapping implements InsertMapping, UpdateMapping { +public class StringConstantMapping extends AbstractColumnMapping implements GeneralInsertMapping, InsertMapping, UpdateMapping { private String constant; private StringConstantMapping(SqlColumn column) { @@ -50,4 +50,9 @@ public R accept(UpdateMappingVisitor visitor) { public R accept(InsertMappingVisitor visitor) { return visitor.visit(this); } + + @Override + public R accept(GeneralInsertMappingVisitor visitor) { + return visitor.visit(this); + } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java index 5b206eb01..a823045fd 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java @@ -19,7 +19,7 @@ import org.mybatis.dynamic.sql.SqlColumn; -public class ValueMapping extends AbstractColumnMapping implements UpdateMapping { +public class ValueMapping extends AbstractColumnMapping implements UpdateMapping, GeneralInsertMapping { private Supplier valueSupplier; @@ -37,6 +37,11 @@ public R accept(UpdateMappingVisitor visitor) { return visitor.visit(this); } + @Override + public R accept(GeneralInsertMappingVisitor visitor) { + return visitor.visit(this); + } + public static ValueMapping of(SqlColumn column, Supplier valueSupplier) { return new ValueMapping<>(column, valueSupplier); } diff --git a/src/test/java/examples/animal/data/AnimalDataMapper.java b/src/test/java/examples/animal/data/AnimalDataMapper.java index 25c9952d2..c452bb6f6 100644 --- a/src/test/java/examples/animal/data/AnimalDataMapper.java +++ b/src/test/java/examples/animal/data/AnimalDataMapper.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2018 the original author or authors. + * Copyright 2016-2019 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. @@ -28,6 +28,7 @@ import org.apache.ibatis.annotations.SelectProvider; import org.apache.ibatis.annotations.UpdateProvider; import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider; +import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider; import org.mybatis.dynamic.sql.insert.render.InsertSelectStatementProvider; import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider; import org.mybatis.dynamic.sql.select.render.SelectStatementProvider; @@ -68,6 +69,9 @@ public interface AnimalDataMapper { @InsertProvider(type=SqlProviderAdapter.class, method="insert") int insert(InsertStatementProvider insertStatement); + @InsertProvider(type=SqlProviderAdapter.class, method="generalInsert") + int generalInsert(GeneralInsertStatementProvider insertStatement); + @InsertProvider(type=SqlProviderAdapter.class, method="insertSelect") int insertSelect(InsertSelectStatementProvider insertSelectStatement); diff --git a/src/test/java/examples/animal/data/AnimalDataTest.java b/src/test/java/examples/animal/data/AnimalDataTest.java index 4245de788..d7de1187d 100644 --- a/src/test/java/examples/animal/data/AnimalDataTest.java +++ b/src/test/java/examples/animal/data/AnimalDataTest.java @@ -44,6 +44,7 @@ import org.mybatis.dynamic.sql.SqlTable; import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider; import org.mybatis.dynamic.sql.insert.render.BatchInsert; +import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider; import org.mybatis.dynamic.sql.insert.render.InsertSelectStatementProvider; import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider; import org.mybatis.dynamic.sql.render.RenderingStrategies; @@ -1736,6 +1737,32 @@ public void testInsertSelectWithoutColumnList() { } } + @Test + public void testGeneralInsert() { + try (SqlSession sqlSession = sqlSessionFactory.openSession()) { + AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class); + + GeneralInsertStatementProvider insertStatement = insertInto(animalData) + .set(id).equalTo(101) + .set(animalName).equalToStringConstant("Fred") + .set(brainWeight).equalToConstant("2.2") + .set(bodyWeight).equalTo(4.5) + .build() + .render(RenderingStrategies.MYBATIS3); + + String expected = "insert into AnimalData (id, animal_name, brain_weight, body_weight) " + + "values (#{parameters.p1,jdbcType=INTEGER}, 'Fred', 2.2, #{parameters.p2,jdbcType=DOUBLE})"; + + assertThat(insertStatement.getInsertStatement()).isEqualTo(expected); + assertThat(insertStatement.getParameters().size()).isEqualTo(2); + assertThat(insertStatement.getParameters().get("p1")).isEqualTo(101); + assertThat(insertStatement.getParameters().get("p2")).isEqualTo(4.5); + + int rows = mapper.generalInsert(insertStatement); + assertThat(rows).isEqualTo(1); + } + } + @Test public void testUpdateWithSelect() { try (SqlSession sqlSession = sqlSessionFactory.openSession()) { From 764e82fde2963ccb0bc10418f6abf5401bbd27a4 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Sun, 22 Dec 2019 17:07:41 -0500 Subject: [PATCH 02/14] Rearrange methods --- .../java/org/mybatis/dynamic/sql/util/ConstantMapping.java | 4 ++-- src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java | 4 ++-- src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java | 4 ++-- .../org/mybatis/dynamic/sql/util/StringConstantMapping.java | 4 ++-- src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java | 4 ++-- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java index 714b97bc9..122ca389b 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java @@ -42,7 +42,7 @@ public static ConstantMapping of(SqlColumn column, String constant) { } @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(GeneralInsertMappingVisitor visitor) { return visitor.visit(this); } @@ -52,7 +52,7 @@ public R accept(InsertMappingVisitor visitor) { } @Override - public R accept(GeneralInsertMappingVisitor visitor) { + public R accept(UpdateMappingVisitor visitor) { return visitor.visit(this); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java index 4e3d6ee96..5bc87950d 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java @@ -27,7 +27,7 @@ public static NullMapping of(SqlColumn column) { } @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(GeneralInsertMappingVisitor visitor) { return visitor.visit(this); } @@ -37,7 +37,7 @@ public R accept(InsertMappingVisitor visitor) { } @Override - public R accept(GeneralInsertMappingVisitor visitor) { + public R accept(UpdateMappingVisitor visitor) { return visitor.visit(this); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java index b2411bba2..12073bf5c 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java @@ -32,12 +32,12 @@ public SelectModel selectModel() { } @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(GeneralInsertMappingVisitor visitor) { return visitor.visit(this); } @Override - public R accept(GeneralInsertMappingVisitor visitor) { + public R accept(UpdateMappingVisitor visitor) { return visitor.visit(this); } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java index 3061bec5a..f43e72f0b 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java @@ -42,7 +42,7 @@ public static StringConstantMapping of(SqlColumn column, String constant) { } @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(GeneralInsertMappingVisitor visitor) { return visitor.visit(this); } @@ -52,7 +52,7 @@ public R accept(InsertMappingVisitor visitor) { } @Override - public R accept(GeneralInsertMappingVisitor visitor) { + public R accept(UpdateMappingVisitor visitor) { return visitor.visit(this); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java index a823045fd..2701a1bbd 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java @@ -33,12 +33,12 @@ public T value() { } @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(GeneralInsertMappingVisitor visitor) { return visitor.visit(this); } @Override - public R accept(GeneralInsertMappingVisitor visitor) { + public R accept(UpdateMappingVisitor visitor) { return visitor.visit(this); } From 22698556da7388f9d96bfe092c0795a16d0abfd9 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Sun, 22 Dec 2019 17:44:22 -0500 Subject: [PATCH 03/14] Simplify the hierarchy for column mappings. We now have a single visitor interface with default methods where appropriate. --- .../insert/AbstractMultiRowInsertModel.java | 10 ++-- .../dynamic/sql/insert/BatchInsertDSL.java | 4 +- .../dynamic/sql/insert/GeneralInsertDSL.java | 4 +- .../sql/insert/GeneralInsertModel.java | 10 ++-- .../mybatis/dynamic/sql/insert/InsertDSL.java | 6 +-- .../dynamic/sql/insert/InsertModel.java | 12 ++--- .../dynamic/sql/insert/MultiRowInsertDSL.java | 4 +- .../insert/render/GeneralInsertRenderer.java | 6 +-- .../GeneralInsertValuePhraseVisitor.java | 4 +- .../sql/insert/render/InsertRenderer.java | 6 +-- .../render/MultiRowRenderingUtilities.java | 6 +-- .../sql/insert/render/ValuePhraseVisitor.java | 4 +- .../mybatis/dynamic/sql/update/UpdateDSL.java | 8 +-- .../dynamic/sql/update/UpdateModel.java | 10 ++-- .../sql/update/render/SetPhraseVisitor.java | 8 +-- .../sql/update/render/UpdateRenderer.java | 6 +-- .../sql/util/AbstractColumnMapping.java | 4 +- .../sql/util/BaseInsertMappingVisitor.java | 24 --------- .../sql/util/ColumnMappingVisitor.java | 50 +++++++++++++++++++ ...apping.java => ColumnToColumnMapping.java} | 12 ++--- .../dynamic/sql/util/ConstantMapping.java | 14 +----- .../sql/util/GeneralInsertMapping.java | 21 -------- .../sql/util/GeneralInsertMappingVisitor.java | 22 -------- .../dynamic/sql/util/InsertMapping.java | 21 -------- .../sql/util/InsertMappingVisitor.java | 20 -------- .../mybatis/dynamic/sql/util/NullMapping.java | 14 +----- .../dynamic/sql/util/PropertyMapping.java | 6 +-- .../dynamic/sql/util/SelectMapping.java | 9 +--- .../sql/util/StringConstantMapping.java | 14 +----- .../dynamic/sql/util/UpdateMapping.java | 21 -------- .../sql/util/UpdateMappingVisitor.java | 30 ----------- .../dynamic/sql/util/ValueMapping.java | 9 +--- 32 files changed, 126 insertions(+), 273 deletions(-) delete mode 100644 src/main/java/org/mybatis/dynamic/sql/util/BaseInsertMappingVisitor.java create mode 100644 src/main/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitor.java rename src/main/java/org/mybatis/dynamic/sql/util/{ColumnMapping.java => ColumnToColumnMapping.java} (69%) delete mode 100644 src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMapping.java delete mode 100644 src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMappingVisitor.java delete mode 100644 src/main/java/org/mybatis/dynamic/sql/util/InsertMapping.java delete mode 100644 src/main/java/org/mybatis/dynamic/sql/util/InsertMappingVisitor.java delete mode 100644 src/main/java/org/mybatis/dynamic/sql/util/UpdateMapping.java delete mode 100644 src/main/java/org/mybatis/dynamic/sql/util/UpdateMappingVisitor.java diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/AbstractMultiRowInsertModel.java b/src/main/java/org/mybatis/dynamic/sql/insert/AbstractMultiRowInsertModel.java index 270b92609..10168e63b 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/AbstractMultiRowInsertModel.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/AbstractMultiRowInsertModel.java @@ -24,12 +24,12 @@ import java.util.stream.Stream; import org.mybatis.dynamic.sql.SqlTable; -import org.mybatis.dynamic.sql.util.InsertMapping; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; public abstract class AbstractMultiRowInsertModel { private SqlTable table; private List records; - private List columnMappings; + private List columnMappings; protected AbstractMultiRowInsertModel(AbstractBuilder builder) { table = Objects.requireNonNull(builder.table); @@ -37,7 +37,7 @@ protected AbstractMultiRowInsertModel(AbstractBuilder builder) { columnMappings = Objects.requireNonNull(builder.columnMappings); } - public Stream mapColumnMappings(Function mapper) { + public Stream mapColumnMappings(Function mapper) { return columnMappings.stream().map(mapper); } @@ -56,7 +56,7 @@ public int recordCount() { public abstract static class AbstractBuilder> { private SqlTable table; private List records = new ArrayList<>(); - private List columnMappings = new ArrayList<>(); + private List columnMappings = new ArrayList<>(); public S withTable(SqlTable table) { this.table = table; @@ -68,7 +68,7 @@ public S withRecords(Collection records) { return getThis(); } - public S withColumnMappings(List columnMappings) { + public S withColumnMappings(List columnMappings) { this.columnMappings.addAll(columnMappings); return getThis(); } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/BatchInsertDSL.java b/src/main/java/org/mybatis/dynamic/sql/insert/BatchInsertDSL.java index 1622856a3..b797fe2ba 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/BatchInsertDSL.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/BatchInsertDSL.java @@ -22,8 +22,8 @@ import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.SqlTable; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; import org.mybatis.dynamic.sql.util.ConstantMapping; -import org.mybatis.dynamic.sql.util.InsertMapping; import org.mybatis.dynamic.sql.util.NullMapping; import org.mybatis.dynamic.sql.util.PropertyMapping; import org.mybatis.dynamic.sql.util.StringConstantMapping; @@ -32,7 +32,7 @@ public class BatchInsertDSL { private Collection records; private SqlTable table; - private List columnMappings = new ArrayList<>(); + private List columnMappings = new ArrayList<>(); private BatchInsertDSL(Collection records, SqlTable table) { this.records = records; diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertDSL.java b/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertDSL.java index dadf6f763..889ad6932 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertDSL.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertDSL.java @@ -23,16 +23,16 @@ import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.SqlTable; import org.mybatis.dynamic.sql.select.SelectModel; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; import org.mybatis.dynamic.sql.util.Buildable; import org.mybatis.dynamic.sql.util.ConstantMapping; -import org.mybatis.dynamic.sql.util.GeneralInsertMapping; import org.mybatis.dynamic.sql.util.NullMapping; import org.mybatis.dynamic.sql.util.SelectMapping; import org.mybatis.dynamic.sql.util.StringConstantMapping; import org.mybatis.dynamic.sql.util.ValueMapping; public class GeneralInsertDSL { - private List insertMappings = new ArrayList<>(); + private List insertMappings = new ArrayList<>(); private SqlTable table; private GeneralInsertDSL(SqlTable table) { diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertModel.java b/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertModel.java index 8f3aeaa0d..e319516e5 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertModel.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/GeneralInsertModel.java @@ -25,19 +25,19 @@ import org.mybatis.dynamic.sql.insert.render.GeneralInsertRenderer; import org.mybatis.dynamic.sql.insert.render.GeneralInsertStatementProvider; import org.mybatis.dynamic.sql.render.RenderingStrategy; -import org.mybatis.dynamic.sql.util.GeneralInsertMapping; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; public class GeneralInsertModel { private SqlTable table; - private List insertMappings; + private List insertMappings; private GeneralInsertModel(Builder builder) { table = Objects.requireNonNull(builder.table); insertMappings = builder.insertMappings; } - public Stream mapColumnMappings(Function mapper) { + public Stream mapColumnMappings(Function mapper) { return insertMappings.stream().map(mapper); } @@ -54,14 +54,14 @@ public GeneralInsertStatementProvider render(RenderingStrategy renderingStrategy public static class Builder { private SqlTable table; - private List insertMappings = new ArrayList<>(); + private List insertMappings = new ArrayList<>(); public Builder withTable(SqlTable table) { this.table = table; return this; } - public Builder withInsertMappings(List insertMappings) { + public Builder withInsertMappings(List insertMappings) { this.insertMappings.addAll(insertMappings); return this; } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/InsertDSL.java b/src/main/java/org/mybatis/dynamic/sql/insert/InsertDSL.java index f8f329cae..2bb655344 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/InsertDSL.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/InsertDSL.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2019 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. @@ -21,8 +21,8 @@ import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.SqlTable; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; import org.mybatis.dynamic.sql.util.ConstantMapping; -import org.mybatis.dynamic.sql.util.InsertMapping; import org.mybatis.dynamic.sql.util.NullMapping; import org.mybatis.dynamic.sql.util.PropertyMapping; import org.mybatis.dynamic.sql.util.StringConstantMapping; @@ -31,7 +31,7 @@ public class InsertDSL { private T record; private SqlTable table; - private List columnMappings = new ArrayList<>(); + private List columnMappings = new ArrayList<>(); private InsertDSL(T record, SqlTable table) { this.record = record; diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/InsertModel.java b/src/main/java/org/mybatis/dynamic/sql/insert/InsertModel.java index 7f4c9bca8..502150e93 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/InsertModel.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/InsertModel.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2019 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. @@ -25,12 +25,12 @@ import org.mybatis.dynamic.sql.insert.render.InsertRenderer; import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider; import org.mybatis.dynamic.sql.render.RenderingStrategy; -import org.mybatis.dynamic.sql.util.InsertMapping; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; public class InsertModel { private SqlTable table; private T record; - private List columnMappings; + private List columnMappings; private InsertModel(Builder builder) { table = Objects.requireNonNull(builder.table); @@ -38,7 +38,7 @@ record = Objects.requireNonNull(builder.record); columnMappings = Objects.requireNonNull(builder.columnMappings); } - public Stream mapColumnMappings(Function mapper) { + public Stream mapColumnMappings(Function mapper) { return columnMappings.stream().map(mapper); } @@ -64,7 +64,7 @@ public static Builder withRecord(T record) { public static class Builder { private SqlTable table; private T record; - private List columnMappings = new ArrayList<>(); + private List columnMappings = new ArrayList<>(); public Builder withTable(SqlTable table) { this.table = table; @@ -76,7 +76,7 @@ public Builder withRecord(T record) { return this; } - public Builder withColumnMappings(List columnMappings) { + public Builder withColumnMappings(List columnMappings) { this.columnMappings.addAll(columnMappings); return this; } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/MultiRowInsertDSL.java b/src/main/java/org/mybatis/dynamic/sql/insert/MultiRowInsertDSL.java index 8b80bd913..1600c0b28 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/MultiRowInsertDSL.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/MultiRowInsertDSL.java @@ -22,8 +22,8 @@ import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.SqlTable; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; import org.mybatis.dynamic.sql.util.ConstantMapping; -import org.mybatis.dynamic.sql.util.InsertMapping; import org.mybatis.dynamic.sql.util.NullMapping; import org.mybatis.dynamic.sql.util.PropertyMapping; import org.mybatis.dynamic.sql.util.StringConstantMapping; @@ -32,7 +32,7 @@ public class MultiRowInsertDSL { private Collection records; private SqlTable table; - private List columnMappings = new ArrayList<>(); + private List columnMappings = new ArrayList<>(); private MultiRowInsertDSL(Collection records, SqlTable table) { this.records = records; diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java index bfef19092..f2fd489b0 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java @@ -22,7 +22,7 @@ import org.mybatis.dynamic.sql.insert.GeneralInsertModel; import org.mybatis.dynamic.sql.render.RenderingStrategy; -import org.mybatis.dynamic.sql.util.GeneralInsertMapping; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; public class GeneralInsertRenderer { @@ -51,11 +51,11 @@ private String calculateInsertStatement(FieldAndValueAndParametersCollector coll + spaceBefore(collector.valuesPhrase()); } - private Function toFieldAndValue(GeneralInsertValuePhraseVisitor visitor) { + private Function toFieldAndValue(GeneralInsertValuePhraseVisitor visitor) { return insertMapping -> toFieldAndValue(visitor, insertMapping); } - private FieldAndValueAndParameters toFieldAndValue(GeneralInsertValuePhraseVisitor visitor, GeneralInsertMapping insertMapping) { + private FieldAndValueAndParameters toFieldAndValue(GeneralInsertValuePhraseVisitor visitor, AbstractColumnMapping insertMapping) { return insertMapping.accept(visitor); } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java index 89b9eefdb..b4c0e97f0 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java @@ -22,14 +22,14 @@ import org.mybatis.dynamic.sql.render.RenderingStrategy; import org.mybatis.dynamic.sql.select.render.SelectRenderer; import org.mybatis.dynamic.sql.select.render.SelectStatementProvider; +import org.mybatis.dynamic.sql.util.ColumnMappingVisitor; import org.mybatis.dynamic.sql.util.ConstantMapping; -import org.mybatis.dynamic.sql.util.GeneralInsertMappingVisitor; import org.mybatis.dynamic.sql.util.NullMapping; import org.mybatis.dynamic.sql.util.SelectMapping; import org.mybatis.dynamic.sql.util.StringConstantMapping; import org.mybatis.dynamic.sql.util.ValueMapping; -public class GeneralInsertValuePhraseVisitor implements GeneralInsertMappingVisitor { +public class GeneralInsertValuePhraseVisitor implements ColumnMappingVisitor { protected RenderingStrategy renderingStrategy; private AtomicInteger sequence = new AtomicInteger(1); diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertRenderer.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertRenderer.java index 99d34f3a4..5b858c8b0 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertRenderer.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertRenderer.java @@ -22,7 +22,7 @@ import org.mybatis.dynamic.sql.insert.InsertModel; import org.mybatis.dynamic.sql.render.RenderingStrategy; -import org.mybatis.dynamic.sql.util.InsertMapping; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; public class InsertRenderer { @@ -51,11 +51,11 @@ private String calculateInsertStatement(FieldAndValueCollector collector) { + spaceBefore(collector.valuesPhrase()); } - private Function toFieldAndValue(ValuePhraseVisitor visitor) { + private Function toFieldAndValue(ValuePhraseVisitor visitor) { return insertMapping -> toFieldAndValue(visitor, insertMapping); } - private FieldAndValue toFieldAndValue(ValuePhraseVisitor visitor, InsertMapping insertMapping) { + private FieldAndValue toFieldAndValue(ValuePhraseVisitor visitor, AbstractColumnMapping insertMapping) { return insertMapping.accept(visitor); } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/MultiRowRenderingUtilities.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/MultiRowRenderingUtilities.java index 489b48d4d..bbb98cf46 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/MultiRowRenderingUtilities.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/MultiRowRenderingUtilities.java @@ -17,17 +17,17 @@ import java.util.function.Function; -import org.mybatis.dynamic.sql.util.InsertMapping; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; public class MultiRowRenderingUtilities { private MultiRowRenderingUtilities() {} - public static Function toFieldAndValue(ValuePhraseVisitor visitor) { + public static Function toFieldAndValue(ValuePhraseVisitor visitor) { return insertMapping -> MultiRowRenderingUtilities.toFieldAndValue(visitor, insertMapping); } - public static FieldAndValue toFieldAndValue(ValuePhraseVisitor visitor, InsertMapping insertMapping) { + public static FieldAndValue toFieldAndValue(ValuePhraseVisitor visitor, AbstractColumnMapping insertMapping) { return insertMapping.accept(visitor); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/ValuePhraseVisitor.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/ValuePhraseVisitor.java index 0e7235178..9f4b50e01 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/ValuePhraseVisitor.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/ValuePhraseVisitor.java @@ -19,13 +19,13 @@ import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.render.RenderingStrategy; +import org.mybatis.dynamic.sql.util.ColumnMappingVisitor; import org.mybatis.dynamic.sql.util.ConstantMapping; -import org.mybatis.dynamic.sql.util.InsertMappingVisitor; import org.mybatis.dynamic.sql.util.NullMapping; import org.mybatis.dynamic.sql.util.PropertyMapping; import org.mybatis.dynamic.sql.util.StringConstantMapping; -public class ValuePhraseVisitor implements InsertMappingVisitor { +public class ValuePhraseVisitor implements ColumnMappingVisitor { protected RenderingStrategy renderingStrategy; diff --git a/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java b/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java index 5216d1147..1d95f8b50 100644 --- a/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java +++ b/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java @@ -30,13 +30,13 @@ import org.mybatis.dynamic.sql.VisitableCondition; import org.mybatis.dynamic.sql.select.SelectModel; import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; import org.mybatis.dynamic.sql.util.Buildable; -import org.mybatis.dynamic.sql.util.ColumnMapping; +import org.mybatis.dynamic.sql.util.ColumnToColumnMapping; import org.mybatis.dynamic.sql.util.ConstantMapping; import org.mybatis.dynamic.sql.util.NullMapping; import org.mybatis.dynamic.sql.util.SelectMapping; import org.mybatis.dynamic.sql.util.StringConstantMapping; -import org.mybatis.dynamic.sql.util.UpdateMapping; import org.mybatis.dynamic.sql.util.ValueMapping; import org.mybatis.dynamic.sql.util.mybatis3.MyBatis3Utils; import org.mybatis.dynamic.sql.where.AbstractWhereDSL; @@ -46,7 +46,7 @@ public class UpdateDSL implements Buildable { private Function adapterFunction; - private List columnMappings = new ArrayList<>(); + private List columnMappings = new ArrayList<>(); private SqlTable table; private UpdateWhereBuilder whereBuilder = new UpdateWhereBuilder(); @@ -150,7 +150,7 @@ public UpdateDSL equalTo(Buildable buildable) { } public UpdateDSL equalTo(BasicColumn rightColumn) { - columnMappings.add(ColumnMapping.of(column, rightColumn)); + columnMappings.add(ColumnToColumnMapping.of(column, rightColumn)); return UpdateDSL.this; } diff --git a/src/main/java/org/mybatis/dynamic/sql/update/UpdateModel.java b/src/main/java/org/mybatis/dynamic/sql/update/UpdateModel.java index d006da8ca..f4f5e7124 100644 --- a/src/main/java/org/mybatis/dynamic/sql/update/UpdateModel.java +++ b/src/main/java/org/mybatis/dynamic/sql/update/UpdateModel.java @@ -27,13 +27,13 @@ import org.mybatis.dynamic.sql.render.RenderingStrategy; import org.mybatis.dynamic.sql.update.render.UpdateRenderer; import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider; -import org.mybatis.dynamic.sql.util.UpdateMapping; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; import org.mybatis.dynamic.sql.where.WhereModel; public class UpdateModel { private SqlTable table; private WhereModel whereModel; - private List columnMappings; + private List columnMappings; private UpdateModel(Builder builder) { table = Objects.requireNonNull(builder.table); @@ -49,7 +49,7 @@ public Optional whereModel() { return Optional.ofNullable(whereModel); } - public Stream mapColumnMappings(Function mapper) { + public Stream mapColumnMappings(Function mapper) { return columnMappings.stream().map(mapper); } @@ -68,14 +68,14 @@ public static Builder withTable(SqlTable table) { public static class Builder { private SqlTable table; private WhereModel whereModel; - private List columnMappings = new ArrayList<>(); + private List columnMappings = new ArrayList<>(); public Builder withTable(SqlTable table) { this.table = table; return this; } - public Builder withColumnMappings(List columnMappings) { + public Builder withColumnMappings(List columnMappings) { this.columnMappings.addAll(columnMappings); return this; } diff --git a/src/main/java/org/mybatis/dynamic/sql/update/render/SetPhraseVisitor.java b/src/main/java/org/mybatis/dynamic/sql/update/render/SetPhraseVisitor.java index abb3f4d69..a62ab2acd 100644 --- a/src/main/java/org/mybatis/dynamic/sql/update/render/SetPhraseVisitor.java +++ b/src/main/java/org/mybatis/dynamic/sql/update/render/SetPhraseVisitor.java @@ -24,16 +24,16 @@ import org.mybatis.dynamic.sql.render.TableAliasCalculator; import org.mybatis.dynamic.sql.select.render.SelectRenderer; import org.mybatis.dynamic.sql.select.render.SelectStatementProvider; -import org.mybatis.dynamic.sql.util.ColumnMapping; +import org.mybatis.dynamic.sql.util.ColumnToColumnMapping; +import org.mybatis.dynamic.sql.util.ColumnMappingVisitor; import org.mybatis.dynamic.sql.util.ConstantMapping; import org.mybatis.dynamic.sql.util.FragmentAndParameters; import org.mybatis.dynamic.sql.util.NullMapping; import org.mybatis.dynamic.sql.util.SelectMapping; import org.mybatis.dynamic.sql.util.StringConstantMapping; -import org.mybatis.dynamic.sql.util.UpdateMappingVisitor; import org.mybatis.dynamic.sql.util.ValueMapping; -public class SetPhraseVisitor implements UpdateMappingVisitor { +public class SetPhraseVisitor implements ColumnMappingVisitor { private AtomicInteger sequence; private RenderingStrategy renderingStrategy; @@ -100,7 +100,7 @@ public FragmentAndParameters visit(SelectMapping mapping) { } @Override - public FragmentAndParameters visit(ColumnMapping mapping) { + public FragmentAndParameters visit(ColumnToColumnMapping mapping) { String setPhrase = mapping.mapColumn(SqlColumn::name) + " = " //$NON-NLS-1$ + mapping.rightColumn().renderWithTableAlias(TableAliasCalculator.empty()); diff --git a/src/main/java/org/mybatis/dynamic/sql/update/render/UpdateRenderer.java b/src/main/java/org/mybatis/dynamic/sql/update/render/UpdateRenderer.java index 2bf75bb90..c9e6181c3 100644 --- a/src/main/java/org/mybatis/dynamic/sql/update/render/UpdateRenderer.java +++ b/src/main/java/org/mybatis/dynamic/sql/update/render/UpdateRenderer.java @@ -26,9 +26,9 @@ import org.mybatis.dynamic.sql.render.RenderingStrategy; import org.mybatis.dynamic.sql.render.TableAliasCalculator; import org.mybatis.dynamic.sql.update.UpdateModel; +import org.mybatis.dynamic.sql.util.AbstractColumnMapping; import org.mybatis.dynamic.sql.util.FragmentAndParameters; import org.mybatis.dynamic.sql.util.FragmentCollector; -import org.mybatis.dynamic.sql.util.UpdateMapping; import org.mybatis.dynamic.sql.where.WhereModel; import org.mybatis.dynamic.sql.where.render.WhereClauseProvider; import org.mybatis.dynamic.sql.where.render.WhereRenderer; @@ -98,11 +98,11 @@ private Optional renderWhereClause(WhereModel whereModel) { .render(); } - private Function toFragmentAndParameters(SetPhraseVisitor visitor) { + private Function toFragmentAndParameters(SetPhraseVisitor visitor) { return updateMapping -> toFragmentAndParameters(visitor, updateMapping); } - private FragmentAndParameters toFragmentAndParameters(SetPhraseVisitor visitor, UpdateMapping updateMapping) { + private FragmentAndParameters toFragmentAndParameters(SetPhraseVisitor visitor, AbstractColumnMapping updateMapping) { return updateMapping.accept(visitor); } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/AbstractColumnMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/AbstractColumnMapping.java index 1714e9d7e..59040ac80 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/AbstractColumnMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/AbstractColumnMapping.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2019 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. @@ -30,5 +30,7 @@ protected AbstractColumnMapping(SqlColumn column) { public R mapColumn(Function, R> mapper) { return mapper.apply(column); } + + public abstract R accept(ColumnMappingVisitor visitor); } \ No newline at end of file diff --git a/src/main/java/org/mybatis/dynamic/sql/util/BaseInsertMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/BaseInsertMappingVisitor.java deleted file mode 100644 index 561fa3a44..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/util/BaseInsertMappingVisitor.java +++ /dev/null @@ -1,24 +0,0 @@ -/** - * Copyright 2016-2019 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 - * - * http://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.dynamic.sql.util; - -public interface BaseInsertMappingVisitor { - T visit(NullMapping mapping); - - T visit(ConstantMapping mapping); - - T visit(StringConstantMapping mapping); -} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitor.java new file mode 100644 index 000000000..3f1dc261b --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitor.java @@ -0,0 +1,50 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.util; + +/** + * Visitor for all column mappings. Various column mappings are used by insert and update + * statements. Only the null and constant mappings are supported by all statements. Other mappings + * may or may not be supported. For example, it makes no sense to map a column to another column in + * an insert - so the ColumnToColumnMapping is only supported on update statements. + * + * @author Jeff Butler + * + * @param The type of object created by the visitor + */ +public interface ColumnMappingVisitor { + T visit(NullMapping mapping); + + T visit(ConstantMapping mapping); + + T visit(StringConstantMapping mapping); + + default T visit(ValueMapping mapping) { + return null; + } + + default T visit(SelectMapping mapping) { + return null; + } + + default T visit(PropertyMapping mapping) { + return null; + } + + default T visit(ColumnToColumnMapping columnMapping) { + return null; + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ColumnMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/ColumnToColumnMapping.java similarity index 69% rename from src/main/java/org/mybatis/dynamic/sql/util/ColumnMapping.java rename to src/main/java/org/mybatis/dynamic/sql/util/ColumnToColumnMapping.java index fbe668c7d..c7649a446 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/ColumnMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/ColumnToColumnMapping.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2018 the original author or authors. + * Copyright 2016-2019 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. @@ -18,11 +18,11 @@ import org.mybatis.dynamic.sql.BasicColumn; import org.mybatis.dynamic.sql.SqlColumn; -public class ColumnMapping extends AbstractColumnMapping implements UpdateMapping { +public class ColumnToColumnMapping extends AbstractColumnMapping { private BasicColumn rightColumn; - private ColumnMapping(SqlColumn column, BasicColumn rightColumn) { + private ColumnToColumnMapping(SqlColumn column, BasicColumn rightColumn) { super(column); this.rightColumn = rightColumn; } @@ -32,11 +32,11 @@ public BasicColumn rightColumn() { } @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(ColumnMappingVisitor visitor) { return visitor.visit(this); } - public static ColumnMapping of(SqlColumn column, BasicColumn rightColumn) { - return new ColumnMapping(column, rightColumn); + public static ColumnToColumnMapping of(SqlColumn column, BasicColumn rightColumn) { + return new ColumnToColumnMapping(column, rightColumn); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java index 122ca389b..f2942454c 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/ConstantMapping.java @@ -24,7 +24,7 @@ * @author Jeff Butler * */ -public class ConstantMapping extends AbstractColumnMapping implements GeneralInsertMapping, InsertMapping, UpdateMapping { +public class ConstantMapping extends AbstractColumnMapping { private String constant; private ConstantMapping(SqlColumn column) { @@ -42,17 +42,7 @@ public static ConstantMapping of(SqlColumn column, String constant) { } @Override - public R accept(GeneralInsertMappingVisitor visitor) { - return visitor.visit(this); - } - - @Override - public R accept(InsertMappingVisitor visitor) { - return visitor.visit(this); - } - - @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(ColumnMappingVisitor visitor) { return visitor.visit(this); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMapping.java deleted file mode 100644 index e44d03411..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMapping.java +++ /dev/null @@ -1,21 +0,0 @@ -/** - * Copyright 2016-2019 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 - * - * http://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.dynamic.sql.util; - -@FunctionalInterface -public interface GeneralInsertMapping { - R accept(GeneralInsertMappingVisitor visitor); -} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMappingVisitor.java deleted file mode 100644 index 97801c95b..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/util/GeneralInsertMappingVisitor.java +++ /dev/null @@ -1,22 +0,0 @@ -/** - * Copyright 2016-2019 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 - * - * http://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.dynamic.sql.util; - -public interface GeneralInsertMappingVisitor extends BaseInsertMappingVisitor { - T visit(ValueMapping mapping); - - T visit(SelectMapping mapping); -} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/InsertMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/InsertMapping.java deleted file mode 100644 index 4252111b8..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/util/InsertMapping.java +++ /dev/null @@ -1,21 +0,0 @@ -/** - * Copyright 2016-2019 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 - * - * http://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.dynamic.sql.util; - -@FunctionalInterface -public interface InsertMapping { - R accept(InsertMappingVisitor visitor); -} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/InsertMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/InsertMappingVisitor.java deleted file mode 100644 index c523fbf0c..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/util/InsertMappingVisitor.java +++ /dev/null @@ -1,20 +0,0 @@ -/** - * Copyright 2016-2019 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 - * - * http://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.dynamic.sql.util; - -public interface InsertMappingVisitor extends BaseInsertMappingVisitor { - T visit(PropertyMapping mapping); -} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java index 5bc87950d..c47041fa9 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/NullMapping.java @@ -17,7 +17,7 @@ import org.mybatis.dynamic.sql.SqlColumn; -public class NullMapping extends AbstractColumnMapping implements GeneralInsertMapping, InsertMapping, UpdateMapping { +public class NullMapping extends AbstractColumnMapping { private NullMapping(SqlColumn column) { super(column); } @@ -27,17 +27,7 @@ public static NullMapping of(SqlColumn column) { } @Override - public R accept(GeneralInsertMappingVisitor visitor) { - return visitor.visit(this); - } - - @Override - public R accept(InsertMappingVisitor visitor) { - return visitor.visit(this); - } - - @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(ColumnMappingVisitor visitor) { return visitor.visit(this); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/PropertyMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/PropertyMapping.java index a97f35274..9410fad55 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/PropertyMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/PropertyMapping.java @@ -1,5 +1,5 @@ /** - * Copyright 2016-2017 the original author or authors. + * Copyright 2016-2019 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. @@ -17,7 +17,7 @@ import org.mybatis.dynamic.sql.SqlColumn; -public class PropertyMapping extends AbstractColumnMapping implements InsertMapping { +public class PropertyMapping extends AbstractColumnMapping { private String property; private PropertyMapping(SqlColumn column) { @@ -29,7 +29,7 @@ public String property() { } @Override - public S accept(InsertMappingVisitor visitor) { + public R accept(ColumnMappingVisitor visitor) { return visitor.visit(this); } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java index 12073bf5c..7e43caf9a 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/SelectMapping.java @@ -18,7 +18,7 @@ import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.select.SelectModel; -public class SelectMapping extends AbstractColumnMapping implements UpdateMapping, GeneralInsertMapping { +public class SelectMapping extends AbstractColumnMapping { private SelectModel selectModel; @@ -32,12 +32,7 @@ public SelectModel selectModel() { } @Override - public R accept(GeneralInsertMappingVisitor visitor) { - return visitor.visit(this); - } - - @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(ColumnMappingVisitor visitor) { return visitor.visit(this); } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java index f43e72f0b..32904bb53 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/StringConstantMapping.java @@ -24,7 +24,7 @@ * @author Jeff Butler * */ -public class StringConstantMapping extends AbstractColumnMapping implements GeneralInsertMapping, InsertMapping, UpdateMapping { +public class StringConstantMapping extends AbstractColumnMapping { private String constant; private StringConstantMapping(SqlColumn column) { @@ -42,17 +42,7 @@ public static StringConstantMapping of(SqlColumn column, String constant) { } @Override - public R accept(GeneralInsertMappingVisitor visitor) { - return visitor.visit(this); - } - - @Override - public R accept(InsertMappingVisitor visitor) { - return visitor.visit(this); - } - - @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(ColumnMappingVisitor visitor) { return visitor.visit(this); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/UpdateMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/UpdateMapping.java deleted file mode 100644 index 66dfaa2da..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/util/UpdateMapping.java +++ /dev/null @@ -1,21 +0,0 @@ -/** - * Copyright 2016-2019 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 - * - * http://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.dynamic.sql.util; - -@FunctionalInterface -public interface UpdateMapping { - R accept(UpdateMappingVisitor visitor); -} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/UpdateMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/UpdateMappingVisitor.java deleted file mode 100644 index 18f43602d..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/util/UpdateMappingVisitor.java +++ /dev/null @@ -1,30 +0,0 @@ -/** - * Copyright 2016-2018 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 - * - * http://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.dynamic.sql.util; - -public interface UpdateMappingVisitor { - T visit(NullMapping mapping); - - T visit(ConstantMapping mapping); - - T visit(StringConstantMapping mapping); - - T visit(ValueMapping mapping); - - T visit(SelectMapping mapping); - - T visit(ColumnMapping columnMapping); -} diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java b/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java index 2701a1bbd..b8c7934c0 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/ValueMapping.java @@ -19,7 +19,7 @@ import org.mybatis.dynamic.sql.SqlColumn; -public class ValueMapping extends AbstractColumnMapping implements UpdateMapping, GeneralInsertMapping { +public class ValueMapping extends AbstractColumnMapping { private Supplier valueSupplier; @@ -33,12 +33,7 @@ public T value() { } @Override - public R accept(GeneralInsertMappingVisitor visitor) { - return visitor.visit(this); - } - - @Override - public R accept(UpdateMappingVisitor visitor) { + public R accept(ColumnMappingVisitor visitor) { return visitor.visit(this); } From 39f029c4b3457e03b5fa95ed3104a93803fed89e Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Mon, 23 Dec 2019 07:21:05 -0500 Subject: [PATCH 04/14] Coverage --- .../render/FieldAndValueAndParameters.java | 4 - .../sql/util/ColumnMappingVisitor.java | 8 +- .../sql/util/ColumnMappingVisitorTest.java | 91 +++++++++++++++++++ 3 files changed, 95 insertions(+), 8 deletions(-) create mode 100644 src/test/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitorTest.java diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParameters.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParameters.java index 80d2a24bb..ee904ed85 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParameters.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/FieldAndValueAndParameters.java @@ -38,10 +38,6 @@ public String valuePhrase() { return valuePhrase; } - public String valuePhrase(int row) { - return String.format(valuePhrase, row); - } - public Map parameters() { return parameters; } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitor.java b/src/main/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitor.java index 3f1dc261b..d8f712c0c 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitor.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitor.java @@ -33,18 +33,18 @@ public interface ColumnMappingVisitor { T visit(StringConstantMapping mapping); default T visit(ValueMapping mapping) { - return null; + throw new UnsupportedOperationException(); } default T visit(SelectMapping mapping) { - return null; + throw new UnsupportedOperationException(); } default T visit(PropertyMapping mapping) { - return null; + throw new UnsupportedOperationException(); } default T visit(ColumnToColumnMapping columnMapping) { - return null; + throw new UnsupportedOperationException(); } } diff --git a/src/test/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitorTest.java b/src/test/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitorTest.java new file mode 100644 index 000000000..bdfa096bc --- /dev/null +++ b/src/test/java/org/mybatis/dynamic/sql/util/ColumnMappingVisitorTest.java @@ -0,0 +1,91 @@ +/** + * Copyright 2016-2019 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 + * + * http://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.dynamic.sql.util; + +import static org.assertj.core.api.Assertions.assertThatExceptionOfType; + +import org.junit.jupiter.api.Test; +import org.mybatis.dynamic.sql.SqlBuilder; +import org.mybatis.dynamic.sql.SqlColumn; +import org.mybatis.dynamic.sql.SqlTable; + +public class ColumnMappingVisitorTest { + + @Test + public void testThatUnimplementedMethod1ThrowExceptions() { + TestTable table = new TestTable(); + TestVisitor tv = new TestVisitor(); + ColumnToColumnMapping mapping = ColumnToColumnMapping.of(table.id, table.description); + + assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> tv.visit(mapping)); + } + + @Test + public void testThatUnimplementedMethod2ThrowExceptions() { + TestTable table = new TestTable(); + TestVisitor tv = new TestVisitor(); + ValueMapping mapping = ValueMapping.of(table.id, () -> 3); + + assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> tv.visit(mapping)); + } + + @Test + public void testThatUnimplementedMethod3ThrowExceptions() { + TestTable table = new TestTable(); + TestVisitor tv = new TestVisitor(); + SelectMapping mapping = SelectMapping.of(table.id, SqlBuilder.select(table.id).from(table)); + + assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> tv.visit(mapping)); + } + + @Test + public void testThatUnimplementedMethod4ThrowExceptions() { + TestTable table = new TestTable(); + TestVisitor tv = new TestVisitor(); + PropertyMapping mapping = PropertyMapping.of(table.id, "id"); + + assertThatExceptionOfType(UnsupportedOperationException.class).isThrownBy(() -> tv.visit(mapping)); + } + + private static class TestTable extends SqlTable { + public SqlColumn id; + public SqlColumn description; + + public TestTable() { + super("Test"); + + id = column("id"); + description = column("description"); + } + } + + private static class TestVisitor implements ColumnMappingVisitor { + @Override + public String visit(NullMapping mapping) { + return "Null Mapping"; + } + + @Override + public String visit(ConstantMapping mapping) { + return "Constant Mapping"; + } + + @Override + public String visit(StringConstantMapping mapping) { + return "String Constant Mapping"; + } + } +} From d9174a171f82c323fb2e9758e74bc7927d4a7fce Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Mon, 23 Dec 2019 09:38:44 -0500 Subject: [PATCH 05/14] Reuse a default implementation --- ...DefaultGeneralInsertStatementProvider.java | 3 +- .../DefaultInsertSelectStatementProvider.java | 63 ------------------- .../insert/render/InsertSelectRenderer.java | 2 +- 3 files changed, 3 insertions(+), 65 deletions(-) delete mode 100644 src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertSelectStatementProvider.java diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultGeneralInsertStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultGeneralInsertStatementProvider.java index fc5675e28..d86719e6c 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultGeneralInsertStatementProvider.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultGeneralInsertStatementProvider.java @@ -19,7 +19,8 @@ import java.util.Map; import java.util.Objects; -public class DefaultGeneralInsertStatementProvider implements GeneralInsertStatementProvider { +public class DefaultGeneralInsertStatementProvider + implements GeneralInsertStatementProvider, InsertSelectStatementProvider { private String insertStatement; private Map parameters = new HashMap<>(); diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertSelectStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertSelectStatementProvider.java deleted file mode 100644 index f647a8160..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertSelectStatementProvider.java +++ /dev/null @@ -1,63 +0,0 @@ -/** - * Copyright 2016-2019 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 - * - * http://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.dynamic.sql.insert.render; - -import java.util.HashMap; -import java.util.Map; -import java.util.Objects; - -public class DefaultInsertSelectStatementProvider implements InsertSelectStatementProvider { - private String insertStatement; - private Map parameters; - - private DefaultInsertSelectStatementProvider(Builder builder) { - insertStatement = Objects.requireNonNull(builder.insertStatement); - parameters = Objects.requireNonNull(builder.parameters); - } - - @Override - public String getInsertStatement() { - return insertStatement; - } - - @Override - public Map getParameters() { - return parameters; - } - - public static Builder withInsertStatement(String insertStatement) { - return new Builder().withInsertStatement(insertStatement); - } - - public static class Builder { - private String insertStatement; - private Map parameters = new HashMap<>(); - - public Builder withInsertStatement(String insertStatement) { - this.insertStatement = insertStatement; - return this; - } - - public Builder withParameters(Map parameters) { - this.parameters.putAll(parameters); - return this; - } - - public DefaultInsertSelectStatementProvider build() { - return new DefaultInsertSelectStatementProvider(this); - } - } -} diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertSelectRenderer.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertSelectRenderer.java index 9c6c07cd8..6a65e2c03 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertSelectRenderer.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/InsertSelectRenderer.java @@ -40,7 +40,7 @@ private InsertSelectRenderer(Builder builder) { public InsertSelectStatementProvider render() { SelectStatementProvider selectStatement = model.selectModel().render(renderingStrategy); - return DefaultInsertSelectStatementProvider.withInsertStatement(calculateInsertStatement(selectStatement)) + return DefaultGeneralInsertStatementProvider.withInsertStatement(calculateInsertStatement(selectStatement)) .withParameters(selectStatement.getParameters()) .build(); } From 5e9eab3c91a1476d61d50944eaefbaa38be62950 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Mon, 23 Dec 2019 20:37:12 -0500 Subject: [PATCH 06/14] Coverage --- .../sql/insert/InsertStatementTest.java | 36 +++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/src/test/java/org/mybatis/dynamic/sql/insert/InsertStatementTest.java b/src/test/java/org/mybatis/dynamic/sql/insert/InsertStatementTest.java index 385fb972e..063beea6b 100644 --- a/src/test/java/org/mybatis/dynamic/sql/insert/InsertStatementTest.java +++ b/src/test/java/org/mybatis/dynamic/sql/insert/InsertStatementTest.java @@ -28,6 +28,8 @@ import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.SqlTable; import org.mybatis.dynamic.sql.insert.render.FieldAndValue; +import org.mybatis.dynamic.sql.insert.render.FieldAndValueAndParameters; +import org.mybatis.dynamic.sql.insert.render.FieldAndValueAndParametersCollector; import org.mybatis.dynamic.sql.insert.render.FieldAndValueCollector; import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider; import org.mybatis.dynamic.sql.render.RenderingStrategies; @@ -152,6 +154,40 @@ private FieldAndValue newFieldAndValue(String fieldName, String valuePhrase) { .build(); } + @Test + public void testParallelStreamWithParameters() { + + List mappings = new ArrayList<>(); + + mappings.add(newFieldAndValueAndParameter(id.name(), "{p1}", "p1", 1)); + mappings.add(newFieldAndValueAndParameter(firstName.name(), "{p2}", "p2", "Fred")); + mappings.add(newFieldAndValueAndParameter(lastName.name(), "{p3}", "p3", "Flintstone")); + mappings.add(newFieldAndValueAndParameter(occupation.name(), "{p4}", "p4", "Driver")); + + FieldAndValueAndParametersCollector collector = + mappings.parallelStream().collect(Collector.of( + FieldAndValueAndParametersCollector::new, + FieldAndValueAndParametersCollector::add, + FieldAndValueAndParametersCollector::merge)); + + String expectedColumnsPhrase = "(id, first_name, last_name, occupation)"; + String expectedValuesPhrase = "values ({p1}, {p2}, {p3}, {p4})"; + + assertAll( + () -> assertThat(collector.columnsPhrase()).isEqualTo(expectedColumnsPhrase), + () -> assertThat(collector.valuesPhrase()).isEqualTo(expectedValuesPhrase), + () -> assertThat(collector.parameters().size()).isEqualTo(4) + ); + } + + private FieldAndValueAndParameters newFieldAndValueAndParameter(String fieldName, String valuePhrase, String parameterName, + Object parameterValue) { + return FieldAndValueAndParameters.withFieldName(fieldName) + .withValuePhrase(valuePhrase) + .withParameter(parameterName, parameterValue) + .build(); + } + @Test public void testParallelStreamForMultiRecord() { From be24b8c2a9d83a58ba72db33c1c5773a89e49e07 Mon Sep 17 00:00:00 2001 From: Jeff Butler Date: Fri, 17 Jul 2020 10:17:37 -0400 Subject: [PATCH 07/14] Copyright and checkstyle --- pom.xml | 2 +- .../render/FieldAndValueAndParametersCollector.java | 5 +++-- .../dynamic/sql/insert/render/GeneralInsertRenderer.java | 8 +++++--- .../dynamic/sql/update/render/SetPhraseVisitor.java | 4 ++-- .../mybatis/dynamic/sql/update/render/UpdateRenderer.java | 5 +++-- src/test/java/examples/animal/data/AnimalDataTest.java | 2 +- 6 files changed, 15 insertions(+), 11 deletions(-) diff --git a/pom.xml b/pom.xml index b9d229ea0..6dbec2716 100644 --- a/pom.xml +++ b/pom.xml @@ -1,6 +1,6 @@