diff --git a/pom.xml b/pom.xml index bc3cbf3c2..8ff99b25b 100644 --- a/pom.xml +++ b/pom.xml @@ -138,13 +138,13 @@ org.hsqldb hsqldb - 2.4.1 + 2.5.0 test org.springframework spring-jdbc - 5.1.7.RELEASE + 5.1.8.RELEASE test diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlTable.java b/src/main/java/org/mybatis/dynamic/sql/SqlTable.java index a203e2bc7..380561008 100644 --- a/src/main/java/org/mybatis/dynamic/sql/SqlTable.java +++ b/src/main/java/org/mybatis/dynamic/sql/SqlTable.java @@ -40,7 +40,8 @@ protected SqlTable(Supplier> schemaSupplier, String tableName) this(Optional::empty, schemaSupplier, tableName); } - protected SqlTable(Supplier> catalogSupplier, Supplier> schemaSupplier, String tableName) { + protected SqlTable(Supplier> catalogSupplier, Supplier> schemaSupplier, + String tableName) { Objects.requireNonNull(catalogSupplier); Objects.requireNonNull(schemaSupplier); Objects.requireNonNull(tableName); @@ -48,7 +49,8 @@ protected SqlTable(Supplier> catalogSupplier, Supplier compose(catalogSupplier, schemaSupplier, tableName); } - private String compose(Supplier> catalogSupplier, Supplier> schemaSupplier, String tableName) { + private String compose(Supplier> catalogSupplier, Supplier> schemaSupplier, + String tableName) { return catalogSupplier.get().map(c -> compose(c, schemaSupplier, tableName)) .orElse(compose(schemaSupplier, tableName)); } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/FetchFirstPagingModel.java b/src/main/java/org/mybatis/dynamic/sql/select/FetchFirstPagingModel.java new file mode 100644 index 000000000..b881c6afa --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/select/FetchFirstPagingModel.java @@ -0,0 +1,61 @@ +/** + * 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.select; + +import java.util.Optional; + +public class FetchFirstPagingModel implements PagingModel { + + private Long fetchFirstRows; + private Long offset; + + private FetchFirstPagingModel(Builder builder) { + this.fetchFirstRows = builder.fetchFirstRows; + this.offset = builder.offset; + } + + public Optional fetchFirstRows() { + return Optional.ofNullable(fetchFirstRows); + } + + public Optional offset() { + return Optional.ofNullable(offset); + } + + @Override + public R accept(PagingModelVisitor visitor) { + return visitor.visit(this); + } + + public static class Builder { + private Long fetchFirstRows; + private Long offset; + + public Builder withFetchFirstRows(Long fetchFirstRows) { + this.fetchFirstRows = fetchFirstRows; + return this; + } + + public Builder withOffset(Long offset) { + this.offset = offset; + return this; + } + + public FetchFirstPagingModel build() { + return new FetchFirstPagingModel(this); + } + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/LimitAndOffsetPagingModel.java b/src/main/java/org/mybatis/dynamic/sql/select/LimitAndOffsetPagingModel.java new file mode 100644 index 000000000..8eed1a2bb --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/select/LimitAndOffsetPagingModel.java @@ -0,0 +1,61 @@ +/** + * 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.select; + +import java.util.Optional; + +public class LimitAndOffsetPagingModel implements PagingModel { + + private Long limit; + private Long offset; + + private LimitAndOffsetPagingModel(Builder builder) { + this.limit = builder.limit; + this.offset = builder.offset; + } + + public Optional limit() { + return Optional.ofNullable(limit); + } + + public Optional offset() { + return Optional.ofNullable(offset); + } + + @Override + public R accept(PagingModelVisitor visitor) { + return visitor.visit(this); + } + + public static class Builder { + private Long limit; + private Long offset; + + public Builder withLimit(Long limit) { + this.limit = limit; + return this; + } + + public Builder withOffset(Long offset) { + this.offset = offset; + return this; + } + + public LimitAndOffsetPagingModel build() { + return new LimitAndOffsetPagingModel(this); + } + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/PagingModel.java b/src/main/java/org/mybatis/dynamic/sql/select/PagingModel.java new file mode 100644 index 000000000..1d5869dbd --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/select/PagingModel.java @@ -0,0 +1,20 @@ +/** + * 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.select; + +public interface PagingModel { + R accept(PagingModelVisitor visitor); +} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/PagingModelVisitor.java b/src/main/java/org/mybatis/dynamic/sql/select/PagingModelVisitor.java new file mode 100644 index 000000000..f0f6b3f3c --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/select/PagingModelVisitor.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.select; + +public interface PagingModelVisitor { + R visit(LimitAndOffsetPagingModel pagingModel); + + R visit(FetchFirstPagingModel pagingModel); +} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java b/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java index 2058ec646..4f5e87d86 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java @@ -149,11 +149,16 @@ public SelectDSL.LimitFinisher limit(long limit) { return selectDSL.limit(limit); } - public SelectDSL.OffsetFinisher offset(long offset) { + public SelectDSL.OffsetFirstFinisher offset(long offset) { selectDSL.addQueryExpression(buildModel()); return selectDSL.offset(offset); } + public SelectDSL.FetchFirstFinisher fetchFirst(long fetchFirstRows) { + selectDSL.addQueryExpression(buildModel()); + return selectDSL.fetchFirst(fetchFirstRows); + } + public static class FromGatherer { private FromGathererBuilder builder; private Map tableAliasMap = new HashMap<>(); @@ -250,12 +255,18 @@ public SelectDSL.LimitFinisher limit(long limit) { return selectDSL.limit(limit); } - public SelectDSL.OffsetFinisher offset(long offset) { + public SelectDSL.OffsetFirstFinisher offset(long offset) { whereModel = buildWhereModel(); selectDSL.addQueryExpression(buildModel()); return selectDSL.offset(offset); } + public SelectDSL.FetchFirstFinisher fetchFirst(long fetchFirstRows) { + whereModel = buildWhereModel(); + selectDSL.addQueryExpression(buildModel()); + return selectDSL.fetchFirst(fetchFirstRows); + } + @Override public R build() { whereModel = buildWhereModel(); @@ -413,7 +424,7 @@ public SelectDSL.LimitFinisher limit(long limit) { return selectDSL.limit(limit); } - public SelectDSL.OffsetFinisher offset(long offset) { + public SelectDSL.OffsetFirstFinisher offset(long offset) { joinModel = buildJoinModel(); selectDSL.addQueryExpression(buildModel()); return selectDSL.offset(offset); @@ -435,7 +446,7 @@ public SelectDSL.LimitFinisher limit(long limit) { return selectDSL.limit(limit); } - public SelectDSL.OffsetFinisher offset(long offset) { + public SelectDSL.OffsetFirstFinisher offset(long offset) { return selectDSL.offset(offset); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java b/src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java index b47b8e934..5de3598a5 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java @@ -38,8 +38,7 @@ public class SelectDSL implements Buildable { private Function adapterFunction; private List queryExpressions = new ArrayList<>(); private OrderByModel orderByModel; - private Long limit; - private Long offset; + private PagingModel pagingModel; private SelectDSL(Function adapterFunction) { this.adapterFunction = Objects.requireNonNull(adapterFunction); @@ -100,39 +99,116 @@ void setOrderByModel(OrderByModel orderByModel) { } public LimitFinisher limit(long limit) { - this.limit = limit; - return new LimitFinisher(); + return new LimitFinisher(limit); } - public OffsetFinisher offset(long offset) { - this.offset = offset; - return new OffsetFinisher(); + public OffsetFirstFinisher offset(long offset) { + return new OffsetFirstFinisher(offset); + } + + public FetchFirstFinisher fetchFirst(long fetchFirstRows) { + return new FetchFirstFinisher(fetchFirstRows); } @Override public R build() { SelectModel selectModel = SelectModel.withQueryExpressions(queryExpressions) .withOrderByModel(orderByModel) - .withLimit(limit) - .withOffset(offset) + .withPagingModel(pagingModel) .build(); return adapterFunction.apply(selectModel); } public class LimitFinisher implements Buildable { - public OffsetFinisher offset(int offset) { - return SelectDSL.this.offset(offset); + private long limit; + + public LimitFinisher(long limit) { + this.limit = limit; + } + + public OffsetFinisher offset(long offset) { + return new OffsetFinisher(limit, offset); } @Override public R build() { + SelectDSL.this.pagingModel = new LimitAndOffsetPagingModel.Builder() + .withLimit(limit) + .build(); return SelectDSL.this.build(); } } public class OffsetFinisher implements Buildable { + private LimitAndOffsetPagingModel pagingModel; + + public OffsetFinisher(long limit, long offset) { + pagingModel = new LimitAndOffsetPagingModel.Builder() + .withLimit(limit) + .withOffset(offset) + .build(); + } + + @Override + public R build() { + SelectDSL.this.pagingModel = pagingModel; + return SelectDSL.this.build(); + } + } + + public class OffsetFirstFinisher implements Buildable { + private long offset; + + public OffsetFirstFinisher(long offset) { + this.offset = offset; + } + + public FetchFirstFinisher fetchFirst(long fetchFirstRows) { + return new FetchFirstFinisher(offset, fetchFirstRows); + } + + @Override + public R build() { + SelectDSL.this.pagingModel = new LimitAndOffsetPagingModel.Builder() + .withOffset(offset) + .build(); + return SelectDSL.this.build(); + } + } + + public class FetchFirstFinisher { + private Long offset; + private Long fetchFirstRows; + + public FetchFirstFinisher(long fetchFirstRows) { + this.fetchFirstRows = fetchFirstRows; + } + + public FetchFirstFinisher(long offset, long fetchFirstRows) { + this.offset = offset; + this.fetchFirstRows = fetchFirstRows; + } + + public RowsOnlyFinisher rowsOnly() { + return new RowsOnlyFinisher(offset, fetchFirstRows); + } + } + + public class RowsOnlyFinisher implements Buildable { + private Long offset; + private Long fetchFirstRows; + + public RowsOnlyFinisher(Long offset, Long fetchFirstRows) { + this.offset = offset; + this.fetchFirstRows = fetchFirstRows; + } + @Override public R build() { + SelectDSL.this.pagingModel = new FetchFirstPagingModel.Builder() + .withOffset(offset) + .withFetchFirstRows(fetchFirstRows) + .build(); return SelectDSL.this.build(); } } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/SelectModel.java b/src/main/java/org/mybatis/dynamic/sql/select/SelectModel.java index acb90dd3b..ffb116212 100644 --- a/src/main/java/org/mybatis/dynamic/sql/select/SelectModel.java +++ b/src/main/java/org/mybatis/dynamic/sql/select/SelectModel.java @@ -29,14 +29,12 @@ public class SelectModel { private List queryExpressions; private OrderByModel orderByModel; - private Long limit; - private Long offset; + private PagingModel pagingModel; private SelectModel(Builder builder) { queryExpressions = Objects.requireNonNull(builder.queryExpressions); orderByModel = builder.orderByModel; - limit = builder.limit; - offset = builder.offset; + pagingModel = builder.pagingModel; } public Stream mapQueryExpressions(Function mapper) { @@ -47,12 +45,8 @@ public Optional orderByModel() { return Optional.ofNullable(orderByModel); } - public Optional limit() { - return Optional.ofNullable(limit); - } - - public Optional offset() { - return Optional.ofNullable(offset); + public Optional pagingModel() { + return Optional.ofNullable(pagingModel); } public SelectStatementProvider render(RenderingStrategy renderingStrategy) { @@ -69,8 +63,7 @@ public static Builder withQueryExpressions(List queryExpre public static class Builder { private List queryExpressions = new ArrayList<>(); private OrderByModel orderByModel; - private Long limit; - private Long offset; + private PagingModel pagingModel; public Builder withQueryExpressions(List queryExpressions) { this.queryExpressions.addAll(queryExpressions); @@ -81,14 +74,9 @@ public Builder withOrderByModel(OrderByModel orderByModel) { this.orderByModel = orderByModel; return this; } - - public Builder withLimit(Long limit) { - this.limit = limit; - return this; - } - - public Builder withOffset(Long offset) { - this.offset = offset; + + public Builder withPagingModel(PagingModel pagingModel) { + this.pagingModel = pagingModel; return this; } diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/FetchFirstPagingModelRenderer.java b/src/main/java/org/mybatis/dynamic/sql/select/render/FetchFirstPagingModelRenderer.java new file mode 100644 index 000000000..f485fab55 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/select/render/FetchFirstPagingModelRenderer.java @@ -0,0 +1,79 @@ +/** + * 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.select.render; + +import java.util.Optional; + +import org.mybatis.dynamic.sql.render.RenderingStrategy; +import org.mybatis.dynamic.sql.select.FetchFirstPagingModel; +import org.mybatis.dynamic.sql.util.FragmentAndParameters; + +public class FetchFirstPagingModelRenderer { + private static final String FETCH_FIRST_ROWS_PARAMETER = "_fetchFirstRows"; //$NON-NLS-1$ + private static final String OFFSET_PARAMETER = "_offset"; //$NON-NLS-1$ + private RenderingStrategy renderingStrategy; + private FetchFirstPagingModel pagingModel; + + public FetchFirstPagingModelRenderer(RenderingStrategy renderingStrategy, + FetchFirstPagingModel pagingModel) { + this.renderingStrategy = renderingStrategy; + this.pagingModel = pagingModel; + } + + public Optional render() { + return pagingModel.offset() + .map(this::renderWithOffset) + .orElse(renderFetchFirstRowsOnly()); + } + + private Optional renderWithOffset(Long offset) { + return pagingModel.fetchFirstRows() + .map(ffr -> renderOffsetAndFetchFirstRows(offset, ffr)) + .orElse(renderOffsetOnly(offset)); + } + + private Optional renderFetchFirstRowsOnly() { + return pagingModel.fetchFirstRows().flatMap(this::renderFetchFirstRowsOnly); + } + + private Optional renderFetchFirstRowsOnly(Long fetchFirstRows) { + return FragmentAndParameters + .withFragment("fetch first " + renderPlaceholder(FETCH_FIRST_ROWS_PARAMETER) //$NON-NLS-1$ + + " rows only") //$NON-NLS-1$ + .withParameter(FETCH_FIRST_ROWS_PARAMETER, fetchFirstRows) + .buildOptional(); + } + + private Optional renderOffsetOnly(Long offset) { + return FragmentAndParameters.withFragment("offset " + renderPlaceholder(OFFSET_PARAMETER)) //$NON-NLS-1$ + .withParameter(OFFSET_PARAMETER, offset) + .buildOptional(); + } + + private Optional renderOffsetAndFetchFirstRows(Long offset, Long fetchFirstRows) { + return FragmentAndParameters.withFragment("offset " + renderPlaceholder(OFFSET_PARAMETER) //$NON-NLS-1$ + + " fetch first " + renderPlaceholder(FETCH_FIRST_ROWS_PARAMETER) //$NON-NLS-1$ + + " rows only") //$NON-NLS-1$ + .withParameter(OFFSET_PARAMETER, offset) + .withParameter(FETCH_FIRST_ROWS_PARAMETER, fetchFirstRows) + .buildOptional(); + } + + private String renderPlaceholder(String parameterName) { + return renderingStrategy.getFormattedJdbcPlaceholder(RenderingStrategy.DEFAULT_PARAMETER_PREFIX, + parameterName); + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/LimitAndOffsetPagingModelRenderer.java b/src/main/java/org/mybatis/dynamic/sql/select/render/LimitAndOffsetPagingModelRenderer.java new file mode 100644 index 000000000..81b9f1a03 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/select/render/LimitAndOffsetPagingModelRenderer.java @@ -0,0 +1,77 @@ +/** + * 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.select.render; + +import java.util.Optional; + +import org.mybatis.dynamic.sql.render.RenderingStrategy; +import org.mybatis.dynamic.sql.select.LimitAndOffsetPagingModel; +import org.mybatis.dynamic.sql.util.FragmentAndParameters; + +public class LimitAndOffsetPagingModelRenderer { + private static final String LIMIT_PARAMETER = "_limit"; //$NON-NLS-1$ + private static final String OFFSET_PARAMETER = "_offset"; //$NON-NLS-1$ + private RenderingStrategy renderingStrategy; + private LimitAndOffsetPagingModel pagingModel; + + public LimitAndOffsetPagingModelRenderer(RenderingStrategy renderingStrategy, + LimitAndOffsetPagingModel pagingModel) { + this.renderingStrategy = renderingStrategy; + this.pagingModel = pagingModel; + } + + public Optional render() { + return pagingModel.limit() + .map(this::renderWithLimit) + .orElse(renderOffsetOnly()); + } + + private Optional renderWithLimit(Long limit) { + return pagingModel.offset() + .map(o -> renderLimitAndOffset(limit, o)) + .orElse(renderLimitOnly(limit)); + } + + private Optional renderOffsetOnly() { + return pagingModel.offset().flatMap(this::renderOffsetOnly); + } + + private Optional renderOffsetOnly(Long offset) { + return FragmentAndParameters + .withFragment("offset " + renderPlaceholder(OFFSET_PARAMETER)) //$NON-NLS-1$ + .withParameter(OFFSET_PARAMETER, offset) + .buildOptional(); + } + + private Optional renderLimitOnly(Long limit) { + return FragmentAndParameters.withFragment("limit " + renderPlaceholder(LIMIT_PARAMETER)) //$NON-NLS-1$ + .withParameter(LIMIT_PARAMETER, limit) + .buildOptional(); + } + + private Optional renderLimitAndOffset(Long limit, Long offset) { + return FragmentAndParameters.withFragment("limit " + renderPlaceholder(LIMIT_PARAMETER) //$NON-NLS-1$ + + " offset " + renderPlaceholder(OFFSET_PARAMETER)) //$NON-NLS-1$ + .withParameter(LIMIT_PARAMETER, limit) + .withParameter(OFFSET_PARAMETER, offset) + .buildOptional(); + } + + private String renderPlaceholder(String parameterName) { + return renderingStrategy.getFormattedJdbcPlaceholder(RenderingStrategy.DEFAULT_PARAMETER_PREFIX, + parameterName); + } +} diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/PagingModelRenderer.java b/src/main/java/org/mybatis/dynamic/sql/select/render/PagingModelRenderer.java new file mode 100644 index 000000000..52a4f8927 --- /dev/null +++ b/src/main/java/org/mybatis/dynamic/sql/select/render/PagingModelRenderer.java @@ -0,0 +1,42 @@ +/** + * 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.select.render; + +import java.util.Optional; + +import org.mybatis.dynamic.sql.render.RenderingStrategy; +import org.mybatis.dynamic.sql.select.FetchFirstPagingModel; +import org.mybatis.dynamic.sql.select.LimitAndOffsetPagingModel; +import org.mybatis.dynamic.sql.select.PagingModelVisitor; +import org.mybatis.dynamic.sql.util.FragmentAndParameters; + +public class PagingModelRenderer implements PagingModelVisitor> { + private RenderingStrategy renderingStrategy; + + public PagingModelRenderer(RenderingStrategy renderingStrategy) { + this.renderingStrategy = renderingStrategy; + } + + @Override + public Optional visit(LimitAndOffsetPagingModel pagingModel) { + return new LimitAndOffsetPagingModelRenderer(renderingStrategy, pagingModel).render(); + } + + @Override + public Optional visit(FetchFirstPagingModel pagingModel) { + return new FetchFirstPagingModelRenderer(renderingStrategy, pagingModel).render(); + } +} 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 50e45118e..4219e6243 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,9 +15,6 @@ */ 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; @@ -26,6 +23,7 @@ import org.mybatis.dynamic.sql.SortSpecification; import org.mybatis.dynamic.sql.render.RenderingStrategy; import org.mybatis.dynamic.sql.select.OrderByModel; +import org.mybatis.dynamic.sql.select.PagingModel; import org.mybatis.dynamic.sql.select.QueryExpressionModel; import org.mybatis.dynamic.sql.select.SelectModel; import org.mybatis.dynamic.sql.util.CustomCollectors; @@ -33,8 +31,6 @@ import org.mybatis.dynamic.sql.util.FragmentCollector; public class SelectRenderer { - private static final String LIMIT_PARAMETER = "_limit"; //$NON-NLS-1$ - private static final String OFFSET_PARAMETER = "_offset"; //$NON-NLS-1$ private SelectModel selectModel; private RenderingStrategy renderingStrategy; private AtomicInteger sequence; @@ -46,19 +42,16 @@ private SelectRenderer(Builder builder) { } public SelectStatementProvider render() { - FragmentCollector queryExpressionCollector = selectModel + FragmentCollector fragmentCollector = selectModel .mapQueryExpressions(this::renderQueryExpression) .collect(FragmentCollector.collect()); + fragmentCollector.add(renderOrderBy()); + fragmentCollector.add(renderPagingModel()); - Map parameters = queryExpressionCollector.parameters(); - - String selectStatement = queryExpressionCollector.fragments().collect(Collectors.joining(" ")) //$NON-NLS-1$ - + spaceBefore(renderOrderBy()) - + spaceBefore(renderLimit(parameters)) - + spaceBefore(renderOffset(parameters)); + String selectStatement = fragmentCollector.fragments().collect(Collectors.joining(" ")); //$NON-NLS-1$ return DefaultSelectStatementProvider.withSelectStatement(selectStatement) - .withParameters(parameters) + .withParameters(fragmentCollector.parameters()) .build(); } @@ -70,14 +63,15 @@ private FragmentAndParameters renderQueryExpression(QueryExpressionModel queryEx .render(); } - private Optional renderOrderBy() { + private Optional renderOrderBy() { return selectModel.orderByModel() .map(this::renderOrderBy); } - private String renderOrderBy(OrderByModel orderByModel) { - return orderByModel.mapColumns(this::calculateOrderByPhrase) + private FragmentAndParameters renderOrderBy(OrderByModel orderByModel) { + String phrase = orderByModel.mapColumns(this::calculateOrderByPhrase) .collect(CustomCollectors.joining(", ", "order by ", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ + return FragmentAndParameters.withFragment(phrase).build(); } private String calculateOrderByPhrase(SortSpecification column) { @@ -88,28 +82,14 @@ private String calculateOrderByPhrase(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); - parameters.put(LIMIT_PARAMETER, limit); - return "limit " + placeholder; //$NON-NLS-1$ + private Optional renderPagingModel() { + return selectModel.pagingModel().flatMap(this::renderPagingModel); } - private Optional renderOffset(Map parameters) { - return selectModel.offset().map(o -> renderOffset(parameters, o)); + private Optional renderPagingModel(PagingModel pagingModel) { + return pagingModel.accept(new PagingModelRenderer(renderingStrategy)); } - - private String renderOffset(Map parameters, Long offset) { - String placeholder = renderingStrategy.getFormattedJdbcPlaceholder(RenderingStrategy.DEFAULT_PARAMETER_PREFIX, - OFFSET_PARAMETER); - parameters.put(OFFSET_PARAMETER, offset); - return "offset " + placeholder; //$NON-NLS-1$ - } - + public static Builder withSelectModel(SelectModel selectModel) { return new Builder().withSelectModel(selectModel); } diff --git a/src/main/java/org/mybatis/dynamic/sql/util/FragmentCollector.java b/src/main/java/org/mybatis/dynamic/sql/util/FragmentCollector.java index f975dafcf..7f8623546 100644 --- a/src/main/java/org/mybatis/dynamic/sql/util/FragmentCollector.java +++ b/src/main/java/org/mybatis/dynamic/sql/util/FragmentCollector.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. @@ -19,6 +19,7 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Optional; import java.util.stream.Collector; import java.util.stream.Stream; @@ -39,6 +40,10 @@ public void add(FragmentAndParameters fragmentAndParameters) { parameters.putAll(fragmentAndParameters.parameters()); } + public void add(Optional fragmentAndParameters) { + fragmentAndParameters.ifPresent(this::add); + } + public FragmentCollector merge(FragmentCollector other) { fragments.addAll(other.fragments); parameters.putAll(other.parameters); diff --git a/src/site/markdown/docs/select.md b/src/site/markdown/docs/select.md index 2629fbaf9..aef7c231d 100644 --- a/src/site/markdown/docs/select.md +++ b/src/site/markdown/docs/select.md @@ -196,10 +196,43 @@ When using a column function (lower, upper, etc.), then is is customary to give In this example the `substring` function is used in both the select list and the GROUP BY expression. In the ORDER BY expression, we use the `sortColumn` function to duplicate the alias given to the column in the select list. ## Limit and Offset Support -Since version 1.1.1, the select statement supports limit and offset. You can specify: +Since version 1.1.1 the select statement supports limit and offset for paging (or slicing) queries. You can specify: - Limit only - Offset only - Both limit and offset It is important to note that the select renderer writes limit and offset clauses into the generated select statement as is. The library does not attempt to normalize those values for databases that don't support limit and offset directly. Therefore, it is very important for users to understand whether or not the target database supports limit and offset. If the target database does not support limit and offset, then it is likely that using this support will create SQL that has runtime errors. + +An example follows: + +```java + SelectStatementProvider selectStatement = select(animalData.allColumns()) + .from(animalData) + .orderBy(id) + .limit(3) + .offset(22) + .build() + .render(RenderingStrategy.MYBATIS3); +``` + +## Fetch First Support +Since version 1.1.2 the select statement supports fetch first for paging (or slicing) queries. You can specify: + +- Fetch first only +- Offset only +- Both offset and fetch first + +Fetch first is an SQL standard and is supported by most databases. + +An example follows: + +```java + SelectStatementProvider selectStatement = select(animalData.allColumns()) + .from(animalData) + .orderBy(id) + .offset(22) + .fetchFirst(3).rowsOnly() + .build() + .render(RenderingStrategy.MYBATIS3); +``` diff --git a/src/test/java/examples/animal/data/FetchFirstTest.java b/src/test/java/examples/animal/data/FetchFirstTest.java new file mode 100644 index 000000000..aa6339fbe --- /dev/null +++ b/src/test/java/examples/animal/data/FetchFirstTest.java @@ -0,0 +1,202 @@ +/** + * 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 examples.animal.data; + +import static examples.animal.data.AnimalDataDynamicSqlSupport.*; +import static org.assertj.core.api.Assertions.assertThat; +import static org.junit.jupiter.api.Assertions.assertAll; +import static org.mybatis.dynamic.sql.SqlBuilder.*; + +import java.io.InputStream; +import java.io.InputStreamReader; +import java.sql.Connection; +import java.sql.DriverManager; +import java.util.List; + +import org.apache.ibatis.datasource.unpooled.UnpooledDataSource; +import org.apache.ibatis.jdbc.ScriptRunner; +import org.apache.ibatis.mapping.Environment; +import org.apache.ibatis.session.Configuration; +import org.apache.ibatis.session.SqlSession; +import org.apache.ibatis.session.SqlSessionFactory; +import org.apache.ibatis.session.SqlSessionFactoryBuilder; +import org.apache.ibatis.transaction.jdbc.JdbcTransactionFactory; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; +import org.mybatis.dynamic.sql.render.RenderingStrategy; +import org.mybatis.dynamic.sql.select.render.SelectStatementProvider; + +public class FetchFirstTest { + + private static final String JDBC_URL = "jdbc:hsqldb:mem:aname"; + private static final String JDBC_DRIVER = "org.hsqldb.jdbcDriver"; + + private SqlSessionFactory sqlSessionFactory; + + @BeforeEach + public void setup() throws Exception { + Class.forName(JDBC_DRIVER); + InputStream is = getClass().getResourceAsStream("/examples/animal/data/CreateAnimalData.sql"); + try (Connection connection = DriverManager.getConnection(JDBC_URL, "sa", "")) { + ScriptRunner sr = new ScriptRunner(connection); + sr.setLogWriter(null); + sr.runScript(new InputStreamReader(is)); + } + + UnpooledDataSource ds = new UnpooledDataSource(JDBC_DRIVER, JDBC_URL, "sa", ""); + Environment environment = new Environment("test", new JdbcTransactionFactory(), ds); + Configuration config = new Configuration(environment); + config.addMapper(AnimalDataMapper.class); + sqlSessionFactory = new SqlSessionFactoryBuilder().build(config); + } + + @Test + public void testOffsetAndFetchFirstAfterFrom() { + try (SqlSession sqlSession = sqlSessionFactory.openSession()) { + SelectStatementProvider selectStatement = select(animalData.allColumns()) + .from(animalData) + .offset(22) + .fetchFirst(3).rowsOnly() + .build() + .render(RenderingStrategy.MYBATIS3); + + AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class); + List records = mapper.selectMany(selectStatement); + + assertAll( + () -> assertThat(records.size()).isEqualTo(3), + () -> assertThat(records.get(0).getId()).isEqualTo(23), + () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData offset #{parameters._offset} fetch first #{parameters._fetchFirstRows} rows only"), + () -> assertThat(selectStatement.getParameters().get("_fetchFirstRows")).isEqualTo(3L), + () -> assertThat(selectStatement.getParameters().get("_offset")).isEqualTo(22L) + ); + } + } + + @Test + public void testFetchFirstOnlyAfterFrom() { + try (SqlSession sqlSession = sqlSessionFactory.openSession()) { + SelectStatementProvider selectStatement = select(animalData.allColumns()) + .from(animalData) + .fetchFirst(3).rowsOnly() + .build() + .render(RenderingStrategy.MYBATIS3); + + AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class); + List records = mapper.selectMany(selectStatement); + + assertAll( + () -> assertThat(records.size()).isEqualTo(3), + () -> assertThat(records.get(0).getId()).isEqualTo(1), + () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData fetch first #{parameters._fetchFirstRows} rows only"), + () -> assertThat(selectStatement.getParameters().get("_fetchFirstRows")).isEqualTo(3L) + ); + } + } + + @Test + public void testOffsetAndFetchFirstAfterWhere() { + try (SqlSession sqlSession = sqlSessionFactory.openSession()) { + SelectStatementProvider selectStatement = select(animalData.allColumns()) + .from(animalData) + .where(id, isLessThan(50)) + .and(id, isGreaterThan(22)) + .offset(22) + .fetchFirst(3).rowsOnly() + .build() + .render(RenderingStrategy.MYBATIS3); + + AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class); + List records = mapper.selectMany(selectStatement); + + assertAll( + () -> assertThat(records.size()).isEqualTo(3), + () -> assertThat(records.get(0).getId()).isEqualTo(45), + () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} and id > #{parameters.p2,jdbcType=INTEGER} offset #{parameters._offset} fetch first #{parameters._fetchFirstRows} rows only"), + () -> assertThat(selectStatement.getParameters().get("_fetchFirstRows")).isEqualTo(3L), + () -> assertThat(selectStatement.getParameters().get("_offset")).isEqualTo(22L) + ); + } + } + + @Test + public void testFetchFirstOnlyAfterWhere() { + try (SqlSession sqlSession = sqlSessionFactory.openSession()) { + SelectStatementProvider selectStatement = select(animalData.allColumns()) + .from(animalData) + .where(id, isLessThan(50)) + .fetchFirst(3).rowsOnly() + .build() + .render(RenderingStrategy.MYBATIS3); + + AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class); + List records = mapper.selectMany(selectStatement); + + assertAll( + () -> assertThat(records.size()).isEqualTo(3), + () -> assertThat(records.get(0).getId()).isEqualTo(1), + () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData where id < #{parameters.p1,jdbcType=INTEGER} fetch first #{parameters._fetchFirstRows} rows only"), + () -> assertThat(selectStatement.getParameters().get("_fetchFirstRows")).isEqualTo(3L) + ); + } + } + + @Test + public void testOffsetAndFetchFirstAfterOrderBy() { + try (SqlSession sqlSession = sqlSessionFactory.openSession()) { + SelectStatementProvider selectStatement = select(animalData.allColumns()) + .from(animalData) + .orderBy(id) + .offset(22) + .fetchFirst(3).rowsOnly() + .build() + .render(RenderingStrategy.MYBATIS3); + + AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class); + List records = mapper.selectMany(selectStatement); + + assertAll( + () -> assertThat(records.size()).isEqualTo(3), + () -> assertThat(records.get(0).getId()).isEqualTo(23), + () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id offset #{parameters._offset} fetch first #{parameters._fetchFirstRows} rows only"), + () -> assertThat(selectStatement.getParameters().get("_fetchFirstRows")).isEqualTo(3L), + () -> assertThat(selectStatement.getParameters().get("_offset")).isEqualTo(22L) + ); + } + } + + @Test + public void testLimitOnlyAfterOrderBy() { + try (SqlSession sqlSession = sqlSessionFactory.openSession()) { + SelectStatementProvider selectStatement = select(animalData.allColumns()) + .from(animalData) + .orderBy(id) + .fetchFirst(3).rowsOnly() + .build() + .render(RenderingStrategy.MYBATIS3); + + AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class); + List records = mapper.selectMany(selectStatement); + + assertAll( + () -> assertThat(records.size()).isEqualTo(3), + () -> assertThat(records.get(0).getId()).isEqualTo(1), + () -> assertThat(selectStatement.getSelectStatement()).isEqualTo("select * from AnimalData order by id fetch first #{parameters._fetchFirstRows} rows only"), + () -> assertThat(selectStatement.getParameters().get("_fetchFirstRows")).isEqualTo(3L) + ); + } + } +}