diff --git a/src/main/java/org/mybatis/dynamic/sql/delete/render/DefaultDeleteStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/delete/render/DefaultDeleteStatementProvider.java index 93aa36a7d..0be446fe8 100644 --- a/src/main/java/org/mybatis/dynamic/sql/delete/render/DefaultDeleteStatementProvider.java +++ b/src/main/java/org/mybatis/dynamic/sql/delete/render/DefaultDeleteStatementProvider.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. @@ -15,23 +15,16 @@ */ package org.mybatis.dynamic.sql.delete.render; -import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; - import java.util.HashMap; import java.util.Map; import java.util.Objects; -import java.util.Optional; - -import org.mybatis.dynamic.sql.where.render.WhereClauseProvider; public class DefaultDeleteStatementProvider implements DeleteStatementProvider { - private String tableName; - private Optional whereClause; + private String deleteStatement; private Map parameters; private DefaultDeleteStatementProvider(Builder builder) { - tableName = Objects.requireNonNull(builder.tableName); - whereClause = Optional.ofNullable(builder.whereClause); + deleteStatement = Objects.requireNonNull(builder.deleteStatement); parameters = Objects.requireNonNull(builder.parameters); } @@ -42,30 +35,24 @@ public Map getParameters() { @Override public String getDeleteStatement() { - return "delete from" //$NON-NLS-1$ - + spaceBefore(tableName) - + spaceBefore(whereClause); + return deleteStatement; } - public static Builder withTableName(String tableName) { - return new Builder().withTableName(tableName); + public static Builder withDeleteStatement(String deleteStatement) { + return new Builder().withDeleteStatement(deleteStatement); } public static class Builder { - private String tableName; - private String whereClause; + private String deleteStatement; private Map parameters = new HashMap<>(); - public Builder withTableName(String tableName) { - this.tableName = tableName; + public Builder withDeleteStatement(String deleteStatement) { + this.deleteStatement = deleteStatement; return this; } - public Builder withWhereClause(Optional whereClauseProvider) { - whereClauseProvider.ifPresent(wcp -> { - whereClause = wcp.getWhereClause(); - parameters.putAll(wcp.getParameters()); - }); + public Builder withParameters(Map parameters) { + this.parameters.putAll(parameters); return this; } diff --git a/src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteRenderer.java b/src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteRenderer.java index 78ed1e1ff..2987e186e 100644 --- a/src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteRenderer.java +++ b/src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteRenderer.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. @@ -15,6 +15,10 @@ */ package org.mybatis.dynamic.sql.delete.render; +import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; + +import java.util.Collections; +import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.concurrent.atomic.AtomicInteger; @@ -36,11 +40,13 @@ private DeleteRenderer(Builder builder) { } public DeleteStatementProvider render() { - return DefaultDeleteStatementProvider.withTableName(deleteModel.table().name()) - .withWhereClause(deleteModel.whereModel().flatMap(this::renderWhereClause)) + Optional whereClause = deleteModel.whereModel().flatMap(this::renderWhereClause); + + return DefaultDeleteStatementProvider.withDeleteStatement(calculateDeleteStatement(whereClause)) + .withParameters(calculateParameters(whereClause)) .build(); } - + private Optional renderWhereClause(WhereModel whereModel) { return WhereRenderer.withWhereModel(whereModel) .withRenderingStrategy(renderingStrategy) @@ -50,6 +56,18 @@ private Optional renderWhereClause(WhereModel whereModel) { .render(); } + private String calculateDeleteStatement(Optional whereClause) { + return "delete from" //$NON-NLS-1$ + + spaceBefore(deleteModel.table().name()) + + spaceBefore(whereClause.map(WhereClauseProvider::getWhereClause)); + } + + private Map calculateParameters(Optional whereClause) { + return whereClause + .map(WhereClauseProvider::getParameters) + .orElse(Collections.emptyMap()); + } + public static Builder withDeleteModel(DeleteModel deleteModel) { return new Builder().withDeleteModel(deleteModel); } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectDSL.java b/src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectDSL.java index 787189d65..1441cfbca 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectDSL.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectDSL.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,6 @@ import java.util.Arrays; import java.util.List; import java.util.Objects; -import java.util.Optional; import org.mybatis.dynamic.sql.SqlColumn; import org.mybatis.dynamic.sql.SqlTable; @@ -43,7 +42,7 @@ private InsertSelectDSL(SqlTable table, SelectModel selectModel) { public InsertSelectModel build() { return InsertSelectModel.withTable(table) - .withColumnList(Optional.ofNullable(columnList)) + .withColumnList(columnList) .withSelectModel(selectModel) .build(); } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectModel.java b/src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectModel.java index 2610fe15b..ef875605e 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectModel.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectModel.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. @@ -26,12 +26,12 @@ public class InsertSelectModel { private SqlTable table; - private Optional columnList; + private InsertColumnListModel columnList; private SelectModel selectModel; private InsertSelectModel(Builder builder) { table = Objects.requireNonNull(builder.table); - columnList = Objects.requireNonNull(builder.columnList); + columnList = builder.columnList; selectModel = Objects.requireNonNull(builder.selectModel); } @@ -44,7 +44,7 @@ public SelectModel selectModel() { } public Optional columnList() { - return columnList; + return Optional.ofNullable(columnList); } public InsertSelectStatementProvider render(RenderingStrategy renderingStrategy) { @@ -60,7 +60,7 @@ public static Builder withTable(SqlTable table) { public static class Builder { private SqlTable table; - private Optional columnList = Optional.empty(); + private InsertColumnListModel columnList; private SelectModel selectModel; public Builder withTable(SqlTable table) { @@ -68,7 +68,7 @@ public Builder withTable(SqlTable table) { return this; } - public Builder withColumnList(Optional columnList) { + public Builder withColumnList(InsertColumnListModel columnList) { this.columnList = columnList; return this; } diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsert.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsert.java index 05e6b3fd6..d3344b999 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsert.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsert.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. @@ -15,8 +15,6 @@ */ package org.mybatis.dynamic.sql.insert.render; -import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; - import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -24,15 +22,11 @@ import java.util.stream.Collectors; public class BatchInsert { - private String tableName; - private String columnsPhrase; - private String valuesPhrase; + private String insertStatement; private List records; private BatchInsert(Builder builder) { - tableName = Objects.requireNonNull(builder.tableName); - columnsPhrase = Objects.requireNonNull(builder.columnsPhrase); - valuesPhrase = Objects.requireNonNull(builder.valuesPhrase); + insertStatement = Objects.requireNonNull(builder.insertStatement); records = Collections.unmodifiableList(Objects.requireNonNull(builder.records)); } @@ -49,9 +43,7 @@ public List> insertStatements() { private InsertStatementProvider toInsertStatement(T record) { return DefaultInsertStatementProvider.withRecord(record) - .withTableName(tableName) - .withColumnsPhrase(columnsPhrase) - .withValuesPhrase(valuesPhrase) + .withInsertStatement(insertStatement) .build(); } @@ -61,10 +53,7 @@ private InsertStatementProvider toInsertStatement(T record) { * @return the generated INSERT statement */ public String getInsertStatementSQL() { - return "insert into" //$NON-NLS-1$ - + spaceBefore(tableName) - + spaceBefore(columnsPhrase) - + spaceBefore(valuesPhrase); + return insertStatement; } public static Builder withRecords(List records) { @@ -72,26 +61,14 @@ public static Builder withRecords(List records) { } public static class Builder { - private String tableName; - private String columnsPhrase; - private String valuesPhrase; + private String insertStatement; private List records = new ArrayList<>(); - public Builder withTableName(String tableName) { - this.tableName = tableName; + public Builder withInsertStatement(String insertStatement) { + this.insertStatement = insertStatement; return this; } - public Builder withColumnsPhrase(String columnsPhrase) { - this.columnsPhrase = columnsPhrase; - return this; - } - - public Builder withValuesPhrase(String valuesPhrase) { - this.valuesPhrase = valuesPhrase; - return this; - } - public Builder withRecords(List records) { this.records.addAll(records); return this; diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsertRenderer.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsertRenderer.java index f5af6dc3f..de904779e 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsertRenderer.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/BatchInsertRenderer.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,6 +15,8 @@ */ 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; @@ -36,10 +38,9 @@ public BatchInsert render() { ValuePhraseVisitor visitor = new ValuePhraseVisitor(renderingStrategy); FieldAndValueCollector collector = model.mapColumnMappings(toFieldAndValue(visitor)) .collect(FieldAndValueCollector.collect()); + return BatchInsert.withRecords(model.records()) - .withTableName(model.table().name()) - .withColumnsPhrase(collector.columnsPhrase()) - .withValuesPhrase(collector.valuesPhrase()) + .withInsertStatement(calculateInsertStatement(collector)) .build(); } @@ -50,6 +51,13 @@ private Function toFieldAndValue(ValuePhraseVisito private FieldAndValue toFieldAndValue(ValuePhraseVisitor visitor, InsertMapping insertMapping) { return insertMapping.accept(visitor); } + + private String calculateInsertStatement(FieldAndValueCollector collector) { + return "insert into" //$NON-NLS-1$ + + spaceBefore(model.table().name()) + + spaceBefore(collector.columnsPhrase()) + + spaceBefore(collector.valuesPhrase()); + } public static Builder withBatchInsertModel(BatchInsertModel model) { return new Builder().withBatchInsertModel(model); 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 index 59ed8beeb..f647a8160 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertSelectStatementProvider.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertSelectStatementProvider.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. @@ -15,32 +15,22 @@ */ package org.mybatis.dynamic.sql.insert.render; -import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; - import java.util.HashMap; import java.util.Map; import java.util.Objects; -import java.util.Optional; public class DefaultInsertSelectStatementProvider implements InsertSelectStatementProvider { - private String tableName; - private Optional columnsPhrase; - private String selectStatement; + private String insertStatement; private Map parameters; private DefaultInsertSelectStatementProvider(Builder builder) { - tableName = Objects.requireNonNull(builder.tableName); - columnsPhrase = Objects.requireNonNull(builder.columnsPhrase); - selectStatement = Objects.requireNonNull(builder.selectStatement); + insertStatement = Objects.requireNonNull(builder.insertStatement); parameters = Objects.requireNonNull(builder.parameters); } @Override public String getInsertStatement() { - return "insert into" //$NON-NLS-1$ - + spaceBefore(tableName) - + spaceBefore(columnsPhrase) - + spaceBefore(selectStatement); + return insertStatement; } @Override @@ -48,31 +38,19 @@ public Map getParameters() { return parameters; } - public static Builder withTableName(String tableName) { - return new Builder().withTableName(tableName); + public static Builder withInsertStatement(String insertStatement) { + return new Builder().withInsertStatement(insertStatement); } public static class Builder { - private String tableName; - private Optional columnsPhrase; - private String selectStatement; + private String insertStatement; private Map parameters = new HashMap<>(); - public Builder withTableName(String tableName) { - this.tableName = tableName; + public Builder withInsertStatement(String insertStatement) { + this.insertStatement = insertStatement; return this; } - public Builder withColumnsPhrase(Optional columnsPhrase) { - this.columnsPhrase = columnsPhrase; - return this; - } - - public Builder withSelectStatement(String selectStatement) { - this.selectStatement = selectStatement; - return this; - } - public Builder withParameters(Map parameters) { this.parameters.putAll(parameters); return this; diff --git a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertStatementProvider.java index cf99ea15f..b75e59e2a 100644 --- a/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertStatementProvider.java +++ b/src/main/java/org/mybatis/dynamic/sql/insert/render/DefaultInsertStatementProvider.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. @@ -15,20 +15,14 @@ */ package org.mybatis.dynamic.sql.insert.render; -import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; - import java.util.Objects; public class DefaultInsertStatementProvider implements InsertStatementProvider { - private String tableName; - private String columnsPhrase; - private String valuesPhrase; + private String insertStatement; private T record; private DefaultInsertStatementProvider(Builder builder) { - tableName = Objects.requireNonNull(builder.tableName); - columnsPhrase = Objects.requireNonNull(builder.columnsPhrase); - valuesPhrase = Objects.requireNonNull(builder.valuesPhrase); + insertStatement = Objects.requireNonNull(builder.insertStatement); record = Objects.requireNonNull(builder.record); } @@ -39,10 +33,7 @@ public T getRecord() { @Override public String getInsertStatement() { - return "insert into" //$NON-NLS-1$ - + spaceBefore(tableName) - + spaceBefore(columnsPhrase) - + spaceBefore(valuesPhrase); + return insertStatement; } public static Builder withRecord(T record) { @@ -50,26 +41,14 @@ public static Builder withRecord(T record) { } public static class Builder { - private String tableName; - private String columnsPhrase; - private String valuesPhrase; + private String insertStatement; private T record; - public Builder withTableName(String tableName) { - this.tableName = tableName; + public Builder withInsertStatement(String insertStatement) { + this.insertStatement = insertStatement; return this; } - public Builder withColumnsPhrase(String columnsPhrase) { - this.columnsPhrase = columnsPhrase; - return this; - } - - public Builder withValuesPhrase(String valuesPhrase) { - this.valuesPhrase = valuesPhrase; - return this; - } - public Builder withRecord(T record) { this.record = record; return this; 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 4a8b43fc4..d9f26bd56 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 @@ -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. @@ -15,6 +15,8 @@ */ 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; @@ -36,13 +38,19 @@ public InsertStatementProvider render() { ValuePhraseVisitor visitor = new ValuePhraseVisitor(renderingStrategy); FieldAndValueCollector collector = model.mapColumnMappings(toFieldAndValue(visitor)) .collect(FieldAndValueCollector.collect()); + return DefaultInsertStatementProvider.withRecord(model.record()) - .withTableName(model.table().name()) - .withColumnsPhrase(collector.columnsPhrase()) - .withValuesPhrase(collector.valuesPhrase()) + .withInsertStatement(calculateInsertStatement(collector)) .build(); } + private String calculateInsertStatement(FieldAndValueCollector collector) { + return "insert into" //$NON-NLS-1$ + + spaceBefore(model.table().name()) + + spaceBefore(collector.columnsPhrase()) + + spaceBefore(collector.valuesPhrase()); + } + private Function toFieldAndValue(ValuePhraseVisitor visitor) { return insertMapping -> toFieldAndValue(visitor, insertMapping); } 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 0ebe364a7..5e109c8c0 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 @@ -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. @@ -15,6 +15,8 @@ */ package org.mybatis.dynamic.sql.insert.render; +import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; + import java.util.Objects; import java.util.Optional; import java.util.stream.Collectors; @@ -38,13 +40,18 @@ private InsertSelectRenderer(Builder builder) { public InsertSelectStatementProvider render() { SelectStatementProvider selectStatement = model.selectModel().render(renderingStrategy); - return DefaultInsertSelectStatementProvider.withTableName(model.table().name()) - .withColumnsPhrase(calculateColumnsPhrase()) - .withSelectStatement(selectStatement.getSelectStatement()) + return DefaultInsertSelectStatementProvider.withInsertStatement(calculateInsertStatement(selectStatement)) .withParameters(selectStatement.getParameters()) .build(); } + private String calculateInsertStatement(SelectStatementProvider selectStatement) { + return "insert into" //$NON-NLS-1$ + + spaceBefore(model.table().name()) + + spaceBefore(calculateColumnsPhrase()) + + spaceBefore(selectStatement.getSelectStatement()); + } + private Optional calculateColumnsPhrase() { return model.columnList() .map(this::calculateColumnsPhrase); diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/DefaultSelectStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/select/render/DefaultSelectStatementProvider.java index 97108557e..a56f19019 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/render/DefaultSelectStatementProvider.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/render/DefaultSelectStatementProvider.java @@ -15,27 +15,18 @@ */ package org.mybatis.dynamic.sql.select.render; -import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; - import java.util.Collections; import java.util.HashMap; import java.util.Map; import java.util.Objects; -import java.util.Optional; public class DefaultSelectStatementProvider implements SelectStatementProvider { - private String queryExpression; + private String selectStatement; private Map parameters; - private Optional orderByClause; - private Optional limitClause; - private Optional offsetClause; private DefaultSelectStatementProvider(Builder builder) { - queryExpression = Objects.requireNonNull(builder.queryExpression); - orderByClause = Objects.requireNonNull(builder.orderByClause); + selectStatement = Objects.requireNonNull(builder.selectStatement); parameters = Collections.unmodifiableMap(Objects.requireNonNull(builder.parameters)); - limitClause = Objects.requireNonNull(builder.limitClause); - offsetClause = Objects.requireNonNull(builder.offsetClause); } @Override @@ -45,27 +36,19 @@ public Map getParameters() { @Override public String getSelectStatement() { - return queryExpression + spaceBefore(orderByClause) + spaceBefore(limitClause) + spaceBefore(offsetClause); + return selectStatement; } - public static Builder withQueryExpression(String queryExpression) { - return new Builder().withQueryExpression(queryExpression); + public static Builder withSelectStatement(String selectStatement) { + return new Builder().withSelectStatement(selectStatement); } public static class Builder { - private String queryExpression; - private Optional orderByClause = Optional.empty(); + private String selectStatement; private Map parameters = new HashMap<>(); - private Optional limitClause = Optional.empty(); - private Optional offsetClause = Optional.empty(); - public Builder withQueryExpression(String queryExpression) { - this.queryExpression = queryExpression; - return this; - } - - public Builder withOrderByClause(Optional orderByClause) { - this.orderByClause = orderByClause; + public Builder withSelectStatement(String selectStatement) { + this.selectStatement = selectStatement; return this; } @@ -74,16 +57,6 @@ public Builder withParameters(Map parameters) { return this; } - public Builder withLimitClause(Optional limitClause) { - this.limitClause = limitClause; - return this; - } - - public Builder withOffsetClause(Optional offsetClause) { - this.offsetClause = offsetClause; - return this; - } - public DefaultSelectStatementProvider build() { return new DefaultSelectStatementProvider(this); } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpression.java b/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpression.java deleted file mode 100644 index 47e65788f..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpression.java +++ /dev/null @@ -1,122 +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.select.render; - -import static org.mybatis.dynamic.sql.util.StringUtilities.spaceAfter; -import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; - -import java.util.HashMap; -import java.util.Map; -import java.util.Objects; -import java.util.Optional; - -import org.mybatis.dynamic.sql.where.render.WhereClauseProvider; - -public class QueryExpression { - - private String tableName; - private Optional connector; - private String columnList; - private Optional whereClause; - private Map parameters; - private boolean isDistinct; - private Optional joinClause; - private Optional groupByClause; - - private QueryExpression(Builder builder) { - tableName = Objects.requireNonNull(builder.tableName); - connector = Objects.requireNonNull(builder.connector); - columnList = Objects.requireNonNull(builder.columnList); - whereClause = Optional.ofNullable(builder.whereClause); - parameters = Objects.requireNonNull(builder.parameters); - isDistinct = builder.isDistinct; - joinClause = Objects.requireNonNull(builder.joinClause); - groupByClause = Objects.requireNonNull(builder.groupByClause); - } - - public Map parameters() { - return parameters; - } - - public String queryExpression() { - return spaceAfter(connector) - + "select " //$NON-NLS-1$ - + (isDistinct ? "distinct " : "") //$NON-NLS-1$ //$NON-NLS-2$ - + columnList - + " from " //$NON-NLS-1$ - + tableName - + spaceBefore(joinClause) - + spaceBefore(whereClause) - + spaceBefore(groupByClause); - } - - public static Builder withColumnList(String columnList) { - return new Builder().withColumnList(columnList); - } - - public static class Builder { - private Optional connector; - private String tableName; - private boolean isDistinct; - private String columnList; - private Optional joinClause = Optional.empty(); - private String whereClause; - private Map parameters = new HashMap<>(); - private Optional groupByClause = Optional.empty(); - - public Builder withConnector(Optional connector) { - this.connector = connector; - return this; - } - - public Builder withTableName(String tableName) { - this.tableName = tableName; - return this; - } - - public Builder isDistinct(boolean isDistinct) { - this.isDistinct = isDistinct; - return this; - } - - public Builder withWhereClause(Optional whereClauseProvider) { - whereClauseProvider.ifPresent(wcp -> { - whereClause = wcp.getWhereClause(); - parameters.putAll(wcp.getParameters()); - }); - return this; - } - - public Builder withColumnList(String columnList) { - this.columnList = columnList; - return this; - } - - public Builder withJoinClause(Optional joinClause) { - this.joinClause = joinClause; - return this; - } - - public Builder withGroupByClause(Optional groupByClause) { - this.groupByClause = groupByClause; - return this; - } - - public QueryExpression build() { - return new QueryExpression(this); - } - } -} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpressionCollector.java b/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpressionCollector.java deleted file mode 100644 index fe0ea4a3e..000000000 --- a/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpressionCollector.java +++ /dev/null @@ -1,57 +0,0 @@ -/** - * Copyright 2016-2017 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.select.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 QueryExpressionCollector { - private List queryExpressions = new ArrayList<>(); - private Map parameters = new HashMap<>(); - - private QueryExpressionCollector() { - super(); - } - - private void add(QueryExpression queryExpression) { - queryExpressions.add(queryExpression.queryExpression()); - parameters.putAll(queryExpression.parameters()); - } - - private QueryExpressionCollector merge(QueryExpressionCollector other) { - queryExpressions.addAll(other.queryExpressions); - parameters.putAll(other.parameters); - return this; - } - - public String queryExpression() { - return queryExpressions.stream().collect(Collectors.joining(" ")); //$NON-NLS-1$ - } - - public Map parameters() { - return parameters; - } - - public static Collector collect() { - return Collector.of(QueryExpressionCollector::new, - QueryExpressionCollector::add, - QueryExpressionCollector::merge); - } -} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpressionRenderer.java b/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpressionRenderer.java index f5fccb809..d3807b65e 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpressionRenderer.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/render/QueryExpressionRenderer.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. @@ -15,6 +15,11 @@ */ package org.mybatis.dynamic.sql.select.render; +import static org.mybatis.dynamic.sql.util.StringUtilities.spaceAfter; +import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; + +import java.util.Collections; +import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.concurrent.atomic.AtomicInteger; @@ -27,6 +32,7 @@ import org.mybatis.dynamic.sql.select.QueryExpressionModel; import org.mybatis.dynamic.sql.select.join.JoinModel; import org.mybatis.dynamic.sql.util.CustomCollectors; +import org.mybatis.dynamic.sql.util.FragmentAndParameters; import org.mybatis.dynamic.sql.where.WhereModel; import org.mybatis.dynamic.sql.where.render.WhereClauseProvider; import org.mybatis.dynamic.sql.where.render.WhereRenderer; @@ -42,16 +48,31 @@ private QueryExpressionRenderer(Builder builder) { sequence = Objects.requireNonNull(builder.sequence); } - public QueryExpression render() { - return QueryExpression.withColumnList(calculateColumnList()) - .withConnector(queryExpression.connector()) - .isDistinct(queryExpression.isDistinct()) - .withTableName(calculateTableName(queryExpression.table())) - .withJoinClause(queryExpression.joinModel().map(this::renderJoin)) - .withWhereClause(queryExpression.whereModel().flatMap(this::renderWhereClause)) - .withGroupByClause(queryExpression.groupByModel().map(this::renderGroupBy)) + public FragmentAndParameters render() { + Optional whereClause = queryExpression.whereModel().flatMap(this::renderWhereClause); + + return FragmentAndParameters.withFragment(calculateQueryExpression(whereClause)) + .withParameters(calculateParameters(whereClause)) .build(); } + + private String calculateQueryExpression(Optional whereClause) { + return spaceAfter(queryExpression.connector()) + + "select " //$NON-NLS-1$ + + (queryExpression.isDistinct() ? "distinct " : "") //$NON-NLS-1$ //$NON-NLS-2$ + + calculateColumnList() + + " from " //$NON-NLS-1$ + + calculateTableName(queryExpression.table()) + + spaceBefore(queryExpression.joinModel().map(this::renderJoin)) + + spaceBefore(whereClause.map(WhereClauseProvider::getWhereClause)) + + spaceBefore(queryExpression.groupByModel().map(this::renderGroupBy)); + } + + private Map calculateParameters(Optional whereClause) { + return whereClause + .map(WhereClauseProvider::getParameters) + .orElse(Collections.emptyMap()); + } private String calculateColumnList() { return queryExpression.mapColumns(this::applyTableAndColumnAlias) diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/SelectRenderer.java b/src/main/java/org/mybatis/dynamic/sql/select/render/SelectRenderer.java index fea2e6e90..50e45118e 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/render/SelectRenderer.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/render/SelectRenderer.java @@ -15,10 +15,13 @@ */ package org.mybatis.dynamic.sql.select.render; +import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; + import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.concurrent.atomic.AtomicInteger; +import java.util.stream.Collectors; import org.mybatis.dynamic.sql.SortSpecification; import org.mybatis.dynamic.sql.render.RenderingStrategy; @@ -26,6 +29,8 @@ import org.mybatis.dynamic.sql.select.QueryExpressionModel; import org.mybatis.dynamic.sql.select.SelectModel; import org.mybatis.dynamic.sql.util.CustomCollectors; +import org.mybatis.dynamic.sql.util.FragmentAndParameters; +import org.mybatis.dynamic.sql.util.FragmentCollector; public class SelectRenderer { private static final String LIMIT_PARAMETER = "_limit"; //$NON-NLS-1$ @@ -37,27 +42,27 @@ public class SelectRenderer { private SelectRenderer(Builder builder) { selectModel = Objects.requireNonNull(builder.selectModel); renderingStrategy = Objects.requireNonNull(builder.renderingStrategy); - sequence = builder.sequence.orElse(new AtomicInteger(1)); + sequence = builder.sequence().orElse(new AtomicInteger(1)); } public SelectStatementProvider render() { - QueryExpressionCollector collector = selectModel + FragmentCollector queryExpressionCollector = selectModel .mapQueryExpressions(this::renderQueryExpression) - .collect(QueryExpressionCollector.collect()); + .collect(FragmentCollector.collect()); + + Map parameters = queryExpressionCollector.parameters(); - Map parameters = collector.parameters(); - Optional limitClause = selectModel.limit().map(l -> renderLimit(parameters, l)); - Optional offsetClause = selectModel.offset().map(o -> renderOffset(parameters, o)); + String selectStatement = queryExpressionCollector.fragments().collect(Collectors.joining(" ")) //$NON-NLS-1$ + + spaceBefore(renderOrderBy()) + + spaceBefore(renderLimit(parameters)) + + spaceBefore(renderOffset(parameters)); - return DefaultSelectStatementProvider.withQueryExpression(collector.queryExpression()) + return DefaultSelectStatementProvider.withSelectStatement(selectStatement) .withParameters(parameters) - .withOrderByClause(selectModel.orderByModel().map(this::renderOrderBy)) - .withLimitClause(limitClause) - .withOffsetClause(offsetClause) .build(); } - private QueryExpression renderQueryExpression(QueryExpressionModel queryExpressionModel) { + private FragmentAndParameters renderQueryExpression(QueryExpressionModel queryExpressionModel) { return QueryExpressionRenderer.withQueryExpression(queryExpressionModel) .withRenderingStrategy(renderingStrategy) .withSequence(sequence) @@ -65,12 +70,17 @@ private QueryExpression renderQueryExpression(QueryExpressionModel queryExpressi .render(); } + private Optional renderOrderBy() { + return selectModel.orderByModel() + .map(this::renderOrderBy); + } + private String renderOrderBy(OrderByModel orderByModel) { - return orderByModel.mapColumns(this::orderByPhrase) + return orderByModel.mapColumns(this::calculateOrderByPhrase) .collect(CustomCollectors.joining(", ", "order by ", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ } - private String orderByPhrase(SortSpecification column) { + private String calculateOrderByPhrase(SortSpecification column) { String phrase = column.aliasOrName(); if (column.isDescending()) { phrase = phrase + " DESC"; //$NON-NLS-1$ @@ -78,6 +88,10 @@ private String orderByPhrase(SortSpecification column) { return phrase; } + private Optional renderLimit(Map parameters) { + return selectModel.limit().map(l -> renderLimit(parameters, l)); + } + private String renderLimit(Map parameters, Long limit) { String placeholder = renderingStrategy.getFormattedJdbcPlaceholder(RenderingStrategy.DEFAULT_PARAMETER_PREFIX, LIMIT_PARAMETER); @@ -85,6 +99,10 @@ private String renderLimit(Map parameters, Long limit) { return "limit " + placeholder; //$NON-NLS-1$ } + private Optional renderOffset(Map parameters) { + return selectModel.offset().map(o -> renderOffset(parameters, o)); + } + private String renderOffset(Map parameters, Long offset) { String placeholder = renderingStrategy.getFormattedJdbcPlaceholder(RenderingStrategy.DEFAULT_PARAMETER_PREFIX, OFFSET_PARAMETER); @@ -99,7 +117,7 @@ public static Builder withSelectModel(SelectModel selectModel) { public static class Builder { private SelectModel selectModel; private RenderingStrategy renderingStrategy; - private Optional sequence = Optional.empty(); + private AtomicInteger sequence; public Builder withSelectModel(SelectModel selectModel) { this.selectModel = selectModel; @@ -112,10 +130,14 @@ public Builder withRenderingStrategy(RenderingStrategy renderingStrategy) { } public Builder withSequence(AtomicInteger sequence) { - this.sequence = Optional.of(sequence); + this.sequence = sequence; return this; } + private Optional sequence() { + return Optional.ofNullable(sequence); + } + public SelectRenderer build() { return new SelectRenderer(this); } diff --git a/src/main/java/org/mybatis/dynamic/sql/update/render/DefaultUpdateStatementProvider.java b/src/main/java/org/mybatis/dynamic/sql/update/render/DefaultUpdateStatementProvider.java index 6caf616ca..395436992 100644 --- a/src/main/java/org/mybatis/dynamic/sql/update/render/DefaultUpdateStatementProvider.java +++ b/src/main/java/org/mybatis/dynamic/sql/update/render/DefaultUpdateStatementProvider.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. @@ -15,32 +15,16 @@ */ package org.mybatis.dynamic.sql.update.render; -import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; - import java.util.HashMap; import java.util.Map; import java.util.Objects; -import java.util.Optional; - -import org.mybatis.dynamic.sql.where.render.WhereClauseProvider; -/** - * This class combines a "set" clause and a "where" clause into one parameter object - * that can be sent to a MyBatis3 mapper method. - * - * @author Jeff Butler - * - */ public class DefaultUpdateStatementProvider implements UpdateStatementProvider { - private String tableName; - private String setClause; - private Optional whereClause; + private String updateStatement; private Map parameters = new HashMap<>(); private DefaultUpdateStatementProvider(Builder builder) { - tableName = Objects.requireNonNull(builder.tableName); - setClause = Objects.requireNonNull(builder.setClause); - whereClause = Optional.ofNullable(builder.whereClause); + updateStatement = Objects.requireNonNull(builder.updateStatement); parameters.putAll(builder.parameters); } @@ -51,37 +35,19 @@ public Map getParameters() { @Override public String getUpdateStatement() { - return "update" //$NON-NLS-1$ - + spaceBefore(tableName) - + spaceBefore(setClause) - + spaceBefore(whereClause); + return updateStatement; } - public static Builder withTableName(String tableName) { - return new Builder().withTableName(tableName); + public static Builder withUpdateStatement(String updateStatement) { + return new Builder().withUpdateStatement(updateStatement); } public static class Builder { - private String tableName; - private String setClause; - private String whereClause; + private String updateStatement; private Map parameters = new HashMap<>(); - public Builder withTableName(String tableName) { - this.tableName = tableName; - return this; - } - - public Builder withSetClause(String setClause) { - this.setClause = setClause; - return this; - } - - public Builder withWhereClause(Optional whereClauseProvider) { - whereClauseProvider.ifPresent(wcp -> { - whereClause = wcp.getWhereClause(); - parameters.putAll(wcp.getParameters()); - }); + public Builder withUpdateStatement(String updateStatement) { + this.updateStatement = updateStatement; return this; } 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 5a4bf0b92..88374165b 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 @@ -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. @@ -15,6 +15,10 @@ */ package org.mybatis.dynamic.sql.update.render; +import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore; + +import java.util.Collections; +import java.util.Map; import java.util.Objects; import java.util.Optional; import java.util.concurrent.atomic.AtomicInteger; @@ -42,18 +46,36 @@ private UpdateRenderer(Builder builder) { } public UpdateStatementProvider render() { - SetPhraseVisitor visitor = new SetPhraseVisitor(sequence, renderingStrategy); - - FragmentCollector fc = updateModel.mapColumnMappings(toFragmentAndParameters(visitor)) - .collect(FragmentCollector.collect()); + FragmentCollector fc = calculateColumnMappings(); - return DefaultUpdateStatementProvider.withTableName(updateModel.table().name()) - .withSetClause(calculateSetPhrase(fc)) + Optional whereClause = updateModel.whereModel().flatMap(this::renderWhereClause); + + return DefaultUpdateStatementProvider.withUpdateStatement(calculateUpdateStatement(fc, whereClause)) .withParameters(fc.parameters()) - .withWhereClause(updateModel.whereModel().flatMap(this::renderWhereClause)) + .withParameters(calculateWhereParameters(whereClause)) .build(); } + private FragmentCollector calculateColumnMappings() { + SetPhraseVisitor visitor = new SetPhraseVisitor(sequence, renderingStrategy); + + return updateModel.mapColumnMappings(toFragmentAndParameters(visitor)) + .collect(FragmentCollector.collect()); + } + + private String calculateUpdateStatement(FragmentCollector fc, Optional whereClause) { + return "update" //$NON-NLS-1$ + + spaceBefore(updateModel.table().name()) + + spaceBefore(calculateSetPhrase(fc)) + + spaceBefore(whereClause.map(WhereClauseProvider::getWhereClause)); + } + + private Map calculateWhereParameters(Optional whereClause) { + return whereClause + .map(WhereClauseProvider::getParameters) + .orElse(Collections.emptyMap()); + } + private String calculateSetPhrase(FragmentCollector collector) { return collector.fragments() .collect(Collectors.joining(", ", "set ", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ diff --git a/src/main/java/org/mybatis/dynamic/sql/where/render/RenderedCriterion.java b/src/main/java/org/mybatis/dynamic/sql/where/render/RenderedCriterion.java index 120d38589..0c0035ca4 100644 --- a/src/main/java/org/mybatis/dynamic/sql/where/render/RenderedCriterion.java +++ b/src/main/java/org/mybatis/dynamic/sql/where/render/RenderedCriterion.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. @@ -81,7 +81,7 @@ private String calculateFragment(FragmentCollector collector) { } public static class Builder { - private Optional connector; + private Optional connector = Optional.empty(); private Optional initialCondition = Optional.empty(); private List subCriteria = new ArrayList<>(); diff --git a/src/test/java/org/mybatis/dynamic/sql/select/render/QueryExpressionCollectorTest.java b/src/test/java/org/mybatis/dynamic/sql/select/render/QueryExpressionCollectorTest.java deleted file mode 100644 index 8c57775e5..000000000 --- a/src/test/java/org/mybatis/dynamic/sql/select/render/QueryExpressionCollectorTest.java +++ /dev/null @@ -1,72 +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.select.render; - -import static org.assertj.core.api.Assertions.assertThat; - -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.Optional; - -import org.junit.jupiter.api.Test; -import org.mybatis.dynamic.sql.where.render.WhereClauseProvider; - -public class QueryExpressionCollectorTest { - - @Test - public void testQueryExpressionCollectorMerge() { - List queryExpressions = new ArrayList<>(); - - Map parms1 = new HashMap<>(); - parms1.put("p1", 1); - - WhereClauseProvider wcp1 = WhereClauseProvider.withWhereClause("where fred = ?") - .withParameters(parms1) - .build(); - - QueryExpression qe1 = QueryExpression.withColumnList("foo") - .withConnector(Optional.empty()) - .withTableName("bar") - .withWhereClause(Optional.of(wcp1)) - .build(); - queryExpressions.add(qe1); - - Map parms2 = new HashMap<>(); - parms2.put("p2", 2); - - WhereClauseProvider wcp2 = WhereClauseProvider.withWhereClause("where betty = ?") - .withParameters(parms2) - .build(); - - QueryExpression qe2 = QueryExpression.withColumnList("bar") - .withConnector(Optional.of("union")) - .withTableName("foo") - .withWhereClause(Optional.of(wcp2)) - .build(); - queryExpressions.add(qe2); - - // parallelStream should trigger the merge - QueryExpressionCollector collector = queryExpressions.parallelStream() - .collect(QueryExpressionCollector.collect()); - - assertThat(collector.queryExpression()).isEqualTo("select foo from bar where fred = ? union select bar from foo where betty = ?"); - assertThat(collector.parameters().size()).isEqualTo(2); - assertThat(collector.parameters().get("p1")).isEqualTo(1); - assertThat(collector.parameters().get("p2")).isEqualTo(2); - } -}