org.mybatis.dynamic.sql.SqlBuilder Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of mybatis-dynamic-sql Show documentation
Show all versions of mybatis-dynamic-sql Show documentation
MyBatis framework for generating dynamic SQL
/**
* 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;
import java.util.Arrays;
import java.util.Collection;
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.InsertDSL;
import org.mybatis.dynamic.sql.insert.InsertSelectDSL;
import org.mybatis.dynamic.sql.insert.MultiRowInsertDSL;
import org.mybatis.dynamic.sql.select.CountDSL;
import org.mybatis.dynamic.sql.select.QueryExpressionDSL.FromGatherer;
import org.mybatis.dynamic.sql.select.SelectDSL;
import org.mybatis.dynamic.sql.select.SelectModel;
import org.mybatis.dynamic.sql.select.SimpleSortSpecification;
import org.mybatis.dynamic.sql.select.aggregate.Avg;
import org.mybatis.dynamic.sql.select.aggregate.Count;
import org.mybatis.dynamic.sql.select.aggregate.CountAll;
import org.mybatis.dynamic.sql.select.aggregate.CountDistinct;
import org.mybatis.dynamic.sql.select.aggregate.Max;
import org.mybatis.dynamic.sql.select.aggregate.Min;
import org.mybatis.dynamic.sql.select.aggregate.Sum;
import org.mybatis.dynamic.sql.select.function.Add;
import org.mybatis.dynamic.sql.select.function.Divide;
import org.mybatis.dynamic.sql.select.function.Lower;
import org.mybatis.dynamic.sql.select.function.Multiply;
import org.mybatis.dynamic.sql.select.function.Substring;
import org.mybatis.dynamic.sql.select.function.Subtract;
import org.mybatis.dynamic.sql.select.function.Upper;
import org.mybatis.dynamic.sql.select.join.EqualTo;
import org.mybatis.dynamic.sql.select.join.JoinCondition;
import org.mybatis.dynamic.sql.select.join.JoinCriterion;
import org.mybatis.dynamic.sql.update.UpdateDSL;
import org.mybatis.dynamic.sql.update.UpdateModel;
import org.mybatis.dynamic.sql.util.Buildable;
import org.mybatis.dynamic.sql.where.WhereDSL;
import org.mybatis.dynamic.sql.where.condition.IsBetween;
import org.mybatis.dynamic.sql.where.condition.IsBetweenWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsEqualTo;
import org.mybatis.dynamic.sql.where.condition.IsEqualToColumn;
import org.mybatis.dynamic.sql.where.condition.IsEqualToWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsEqualToWithSubselect;
import org.mybatis.dynamic.sql.where.condition.IsGreaterThan;
import org.mybatis.dynamic.sql.where.condition.IsGreaterThanColumn;
import org.mybatis.dynamic.sql.where.condition.IsGreaterThanOrEqualTo;
import org.mybatis.dynamic.sql.where.condition.IsGreaterThanOrEqualToColumn;
import org.mybatis.dynamic.sql.where.condition.IsGreaterThanOrEqualToWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsGreaterThanOrEqualToWithSubselect;
import org.mybatis.dynamic.sql.where.condition.IsGreaterThanWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsGreaterThanWithSubselect;
import org.mybatis.dynamic.sql.where.condition.IsIn;
import org.mybatis.dynamic.sql.where.condition.IsInCaseInsensitive;
import org.mybatis.dynamic.sql.where.condition.IsInCaseInsensitiveWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsInWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsInWithSubselect;
import org.mybatis.dynamic.sql.where.condition.IsLessThan;
import org.mybatis.dynamic.sql.where.condition.IsLessThanColumn;
import org.mybatis.dynamic.sql.where.condition.IsLessThanOrEqualTo;
import org.mybatis.dynamic.sql.where.condition.IsLessThanOrEqualToColumn;
import org.mybatis.dynamic.sql.where.condition.IsLessThanOrEqualToWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsLessThanOrEqualToWithSubselect;
import org.mybatis.dynamic.sql.where.condition.IsLessThanWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsLessThanWithSubselect;
import org.mybatis.dynamic.sql.where.condition.IsLike;
import org.mybatis.dynamic.sql.where.condition.IsLikeCaseInsensitive;
import org.mybatis.dynamic.sql.where.condition.IsLikeCaseInsensitiveWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsLikeWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsNotBetween;
import org.mybatis.dynamic.sql.where.condition.IsNotBetweenWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsNotEqualTo;
import org.mybatis.dynamic.sql.where.condition.IsNotEqualToColumn;
import org.mybatis.dynamic.sql.where.condition.IsNotEqualToWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsNotEqualToWithSubselect;
import org.mybatis.dynamic.sql.where.condition.IsNotIn;
import org.mybatis.dynamic.sql.where.condition.IsNotInCaseInsensitive;
import org.mybatis.dynamic.sql.where.condition.IsNotInCaseInsensitiveWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsNotInWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsNotInWithSubselect;
import org.mybatis.dynamic.sql.where.condition.IsNotLike;
import org.mybatis.dynamic.sql.where.condition.IsNotLikeCaseInsensitive;
import org.mybatis.dynamic.sql.where.condition.IsNotLikeCaseInsensitiveWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsNotLikeWhenPresent;
import org.mybatis.dynamic.sql.where.condition.IsNotNull;
import org.mybatis.dynamic.sql.where.condition.IsNull;
public interface SqlBuilder {
// statements
static CountDSL countFrom(SqlTable table) {
return CountDSL.countFrom(table);
}
static DeleteDSL deleteFrom(SqlTable table) {
return DeleteDSL.deleteFrom(table);
}
static InsertDSL.IntoGatherer insert(T record) {
return InsertDSL.insert(record);
}
@SafeVarargs
static BatchInsertDSL.IntoGatherer insert(T...records) {
return BatchInsertDSL.insert(records);
}
static BatchInsertDSL.IntoGatherer insert(Collection records) {
return BatchInsertDSL.insert(records);
}
@SafeVarargs
static MultiRowInsertDSL.IntoGatherer insertMultiple(T...records) {
return MultiRowInsertDSL.insert(records);
}
static MultiRowInsertDSL.IntoGatherer insertMultiple(Collection records) {
return MultiRowInsertDSL.insert(records);
}
static InsertSelectDSL.InsertColumnGatherer insertInto(SqlTable table) {
return InsertSelectDSL.insertInto(table);
}
static FromGatherer select(BasicColumn...selectList) {
return SelectDSL.select(selectList);
}
static FromGatherer select(Collection selectList) {
return SelectDSL.select(selectList);
}
static FromGatherer selectDistinct(BasicColumn...selectList) {
return SelectDSL.selectDistinct(selectList);
}
static FromGatherer selectDistinct(Collection selectList) {
return SelectDSL.selectDistinct(selectList);
}
static UpdateDSL update(SqlTable table) {
return UpdateDSL.update(table);
}
static WhereDSL where() {
return WhereDSL.where();
}
static WhereDSL where(BindableColumn column, VisitableCondition condition) {
return WhereDSL.where().where(column, condition);
}
static WhereDSL where(BindableColumn column, VisitableCondition condition,
SqlCriterion... subCriteria) {
return WhereDSL.where().where(column, condition, subCriteria);
}
// where condition connectors
static SqlCriterion or(BindableColumn column, VisitableCondition condition) {
return SqlCriterion.withColumn(column)
.withConnector("or") //$NON-NLS-1$
.withCondition(condition)
.build();
}
static SqlCriterion or(BindableColumn column, VisitableCondition condition,
SqlCriterion...subCriteria) {
return SqlCriterion.withColumn(column)
.withConnector("or") //$NON-NLS-1$
.withCondition(condition)
.withSubCriteria(Arrays.asList(subCriteria))
.build();
}
static SqlCriterion and(BindableColumn column, VisitableCondition condition) {
return SqlCriterion.withColumn(column)
.withConnector("and") //$NON-NLS-1$
.withCondition(condition)
.build();
}
static SqlCriterion and(BindableColumn column, VisitableCondition condition,
SqlCriterion...subCriteria) {
return SqlCriterion.withColumn(column)
.withConnector("and") //$NON-NLS-1$
.withCondition(condition)
.withSubCriteria(Arrays.asList(subCriteria))
.build();
}
// join support
static JoinCriterion and(BasicColumn joinColumn, JoinCondition joinCondition) {
return new JoinCriterion.Builder()
.withConnector("and") //$NON-NLS-1$
.withJoinColumn(joinColumn)
.withJoinCondition(joinCondition)
.build();
}
static JoinCriterion on(BasicColumn joinColumn, JoinCondition joinCondition) {
return new JoinCriterion.Builder()
.withConnector("on") //$NON-NLS-1$
.withJoinColumn(joinColumn)
.withJoinCondition(joinCondition)
.build();
}
static EqualTo equalTo(BasicColumn column) {
return new EqualTo(column);
}
// aggregate support
static CountAll count() {
return new CountAll();
}
static Count count(BasicColumn column) {
return Count.of(column);
}
static CountDistinct countDistinct(BasicColumn column) {
return CountDistinct.of(column);
}
static Max max(BasicColumn column) {
return Max.of(column);
}
static Min min(BasicColumn column) {
return Min.of(column);
}
static Avg avg(BasicColumn column) {
return Avg.of(column);
}
static Sum sum(BasicColumn column) {
return Sum.of(column);
}
// constants
static Constant constant(String constant) {
return Constant.of(constant);
}
static StringConstant stringConstant(String constant) {
return StringConstant.of(constant);
}
// functions
@SafeVarargs
static Add add(BindableColumn firstColumn, BasicColumn secondColumn,
BasicColumn... subsequentColumns) {
return Add.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
}
@SafeVarargs
static Divide divide(BindableColumn firstColumn, BasicColumn secondColumn,
BasicColumn... subsequentColumns) {
return Divide.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
}
@SafeVarargs
static Multiply multiply(BindableColumn firstColumn, BasicColumn secondColumn,
BasicColumn... subsequentColumns) {
return Multiply.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
}
@SafeVarargs
static Subtract subtract(BindableColumn firstColumn, BasicColumn secondColumn,
BasicColumn... subsequentColumns) {
return Subtract.of(firstColumn, secondColumn, Arrays.asList(subsequentColumns));
}
static Lower lower(BindableColumn column) {
return Lower.of(column);
}
static Substring substring(BindableColumn column, int offset, int length) {
return Substring.of(column, offset, length);
}
static Upper upper(BindableColumn column) {
return Upper.of(column);
}
// conditions for all data types
static IsNull isNull() {
return new IsNull<>();
}
static IsNotNull isNotNull() {
return new IsNotNull<>();
}
static IsEqualTo isEqualTo(T value) {
return isEqualTo(() -> value);
}
static IsEqualTo isEqualTo(Supplier valueSupplier) {
return IsEqualTo.of(valueSupplier);
}
static IsEqualToWithSubselect isEqualTo(Buildable selectModelBuilder) {
return IsEqualToWithSubselect.of(selectModelBuilder);
}
static IsEqualToColumn isEqualTo(BasicColumn column) {
return IsEqualToColumn.of(column);
}
static IsEqualToWhenPresent isEqualToWhenPresent(T value) {
return isEqualToWhenPresent(() -> value);
}
static IsEqualToWhenPresent isEqualToWhenPresent(Supplier valueSupplier) {
return IsEqualToWhenPresent.of(valueSupplier);
}
static IsNotEqualTo isNotEqualTo(T value) {
return isNotEqualTo(() -> value);
}
static IsNotEqualTo isNotEqualTo(Supplier valueSupplier) {
return IsNotEqualTo.of(valueSupplier);
}
static IsNotEqualToWithSubselect isNotEqualTo(Buildable selectModelBuilder) {
return IsNotEqualToWithSubselect.of(selectModelBuilder);
}
static IsNotEqualToColumn isNotEqualTo(BasicColumn column) {
return IsNotEqualToColumn.of(column);
}
static IsNotEqualToWhenPresent isNotEqualToWhenPresent(T value) {
return isNotEqualToWhenPresent(() -> value);
}
static IsNotEqualToWhenPresent isNotEqualToWhenPresent(Supplier valueSupplier) {
return IsNotEqualToWhenPresent.of(valueSupplier);
}
static IsGreaterThan isGreaterThan(T value) {
return isGreaterThan(() -> value);
}
static IsGreaterThan isGreaterThan(Supplier valueSupplier) {
return IsGreaterThan.of(valueSupplier);
}
static IsGreaterThanWithSubselect isGreaterThan(Buildable selectModelBuilder) {
return IsGreaterThanWithSubselect.of(selectModelBuilder);
}
static IsGreaterThanColumn isGreaterThan(BasicColumn column) {
return IsGreaterThanColumn.of(column);
}
static IsGreaterThanWhenPresent isGreaterThanWhenPresent(T value) {
return isGreaterThanWhenPresent(() -> value);
}
static IsGreaterThanWhenPresent isGreaterThanWhenPresent(Supplier valueSupplier) {
return IsGreaterThanWhenPresent.of(valueSupplier);
}
static IsGreaterThanOrEqualTo isGreaterThanOrEqualTo(T value) {
return isGreaterThanOrEqualTo(() -> value);
}
static IsGreaterThanOrEqualTo isGreaterThanOrEqualTo(Supplier valueSupplier) {
return IsGreaterThanOrEqualTo.of(valueSupplier);
}
static IsGreaterThanOrEqualToWithSubselect isGreaterThanOrEqualTo(
Buildable selectModelBuilder) {
return IsGreaterThanOrEqualToWithSubselect.of(selectModelBuilder);
}
static IsGreaterThanOrEqualToColumn isGreaterThanOrEqualTo(BasicColumn column) {
return IsGreaterThanOrEqualToColumn.of(column);
}
static IsGreaterThanOrEqualToWhenPresent isGreaterThanOrEqualToWhenPresent(T value) {
return isGreaterThanOrEqualToWhenPresent(() -> value);
}
static IsGreaterThanOrEqualToWhenPresent isGreaterThanOrEqualToWhenPresent(Supplier valueSupplier) {
return IsGreaterThanOrEqualToWhenPresent.of(valueSupplier);
}
static IsLessThan isLessThan(T value) {
return isLessThan(() -> value);
}
static IsLessThan isLessThan(Supplier valueSupplier) {
return IsLessThan.of(valueSupplier);
}
static IsLessThanWithSubselect isLessThan(Buildable selectModelBuilder) {
return IsLessThanWithSubselect.of(selectModelBuilder);
}
static IsLessThanColumn isLessThan(BasicColumn column) {
return IsLessThanColumn.of(column);
}
static IsLessThanWhenPresent isLessThanWhenPresent(T value) {
return isLessThanWhenPresent(() -> value);
}
static IsLessThanWhenPresent isLessThanWhenPresent(Supplier valueSupplier) {
return IsLessThanWhenPresent.of(valueSupplier);
}
static IsLessThanOrEqualTo isLessThanOrEqualTo(T value) {
return isLessThanOrEqualTo(() -> value);
}
static IsLessThanOrEqualTo isLessThanOrEqualTo(Supplier valueSupplier) {
return IsLessThanOrEqualTo.of(valueSupplier);
}
static IsLessThanOrEqualToWithSubselect isLessThanOrEqualTo(Buildable selectModelBuilder) {
return IsLessThanOrEqualToWithSubselect.of(selectModelBuilder);
}
static IsLessThanOrEqualToColumn isLessThanOrEqualTo(BasicColumn column) {
return IsLessThanOrEqualToColumn.of(column);
}
static IsLessThanOrEqualToWhenPresent isLessThanOrEqualToWhenPresent(T value) {
return isLessThanOrEqualToWhenPresent(() -> value);
}
static IsLessThanOrEqualToWhenPresent isLessThanOrEqualToWhenPresent(Supplier valueSupplier) {
return IsLessThanOrEqualToWhenPresent.of(valueSupplier);
}
@SafeVarargs
static IsIn isIn(T...values) {
return isIn(Arrays.asList(values));
}
static IsIn isIn(Collection values) {
return IsIn.of(values);
}
static IsInWithSubselect isIn(Buildable selectModelBuilder) {
return IsInWithSubselect.of(selectModelBuilder);
}
@SafeVarargs
static IsInWhenPresent isInWhenPresent(T...values) {
return isInWhenPresent(Arrays.asList(values));
}
static IsInWhenPresent isInWhenPresent(Collection values) {
return IsInWhenPresent.of(values);
}
@SafeVarargs
static IsNotIn isNotIn(T...values) {
return isNotIn(Arrays.asList(values));
}
static IsNotIn isNotIn(Collection values) {
return IsNotIn.of(values);
}
static IsNotInWithSubselect isNotIn(Buildable selectModelBuilder) {
return IsNotInWithSubselect.of(selectModelBuilder);
}
@SafeVarargs
static IsNotInWhenPresent isNotInWhenPresent(T...values) {
return isNotInWhenPresent(Arrays.asList(values));
}
static IsNotInWhenPresent isNotInWhenPresent(Collection values) {
return IsNotInWhenPresent.of(values);
}
static IsBetween.Builder isBetween(T value1) {
return isBetween(() -> value1);
}
static IsBetween.Builder isBetween(Supplier valueSupplier1) {
return IsBetween.isBetween(valueSupplier1);
}
static IsBetweenWhenPresent.Builder isBetweenWhenPresent(T value1) {
return isBetweenWhenPresent(() -> value1);
}
static IsBetweenWhenPresent.Builder isBetweenWhenPresent(Supplier valueSupplier1) {
return IsBetweenWhenPresent.isBetweenWhenPresent(valueSupplier1);
}
static IsNotBetween.Builder isNotBetween(T value1) {
return isNotBetween(() -> value1);
}
static IsNotBetween.Builder isNotBetween(Supplier valueSupplier1) {
return IsNotBetween.isNotBetween(valueSupplier1);
}
static IsNotBetweenWhenPresent.Builder isNotBetweenWhenPresent(T value1) {
return isNotBetweenWhenPresent(() -> value1);
}
static IsNotBetweenWhenPresent.Builder isNotBetweenWhenPresent(Supplier valueSupplier1) {
return IsNotBetweenWhenPresent.isNotBetweenWhenPresent(valueSupplier1);
}
// for string columns, but generic for columns with type handlers
static IsLike isLike(T value) {
return isLike(() -> value);
}
static IsLike isLike(Supplier valueSupplier) {
return IsLike.of(valueSupplier);
}
static IsLikeWhenPresent isLikeWhenPresent(T value) {
return isLikeWhenPresent(() -> value);
}
static IsLikeWhenPresent isLikeWhenPresent(Supplier valueSupplier) {
return IsLikeWhenPresent.of(valueSupplier);
}
static IsNotLike isNotLike(T value) {
return isNotLike(() -> value);
}
static IsNotLike isNotLike(Supplier valueSupplier) {
return IsNotLike.of(valueSupplier);
}
static IsNotLikeWhenPresent isNotLikeWhenPresent(T value) {
return isNotLikeWhenPresent(() -> value);
}
static IsNotLikeWhenPresent isNotLikeWhenPresent(Supplier valueSupplier) {
return IsNotLikeWhenPresent.of(valueSupplier);
}
// shortcuts for booleans
static IsEqualTo isTrue() {
return isEqualTo(Boolean.TRUE);
}
static IsEqualTo isFalse() {
return isEqualTo(Boolean.FALSE);
}
// conditions for strings only
static IsLikeCaseInsensitive isLikeCaseInsensitive(String value) {
return isLikeCaseInsensitive(() -> value);
}
static IsLikeCaseInsensitive isLikeCaseInsensitive(Supplier valueSupplier) {
return IsLikeCaseInsensitive.of(valueSupplier);
}
static IsLikeCaseInsensitiveWhenPresent isLikeCaseInsensitiveWhenPresent(String value) {
return isLikeCaseInsensitiveWhenPresent(() -> value);
}
static IsLikeCaseInsensitiveWhenPresent isLikeCaseInsensitiveWhenPresent(Supplier valueSupplier) {
return IsLikeCaseInsensitiveWhenPresent.of(valueSupplier);
}
static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(String value) {
return isNotLikeCaseInsensitive(() -> value);
}
static IsNotLikeCaseInsensitive isNotLikeCaseInsensitive(Supplier valueSupplier) {
return IsNotLikeCaseInsensitive.of(valueSupplier);
}
static IsNotLikeCaseInsensitiveWhenPresent isNotLikeCaseInsensitiveWhenPresent(String value) {
return isNotLikeCaseInsensitiveWhenPresent(() -> value);
}
static IsNotLikeCaseInsensitiveWhenPresent isNotLikeCaseInsensitiveWhenPresent(Supplier valueSupplier) {
return IsNotLikeCaseInsensitiveWhenPresent.of(valueSupplier);
}
static IsInCaseInsensitive isInCaseInsensitive(String...values) {
return isInCaseInsensitive(Arrays.asList(values));
}
static IsInCaseInsensitive isInCaseInsensitive(Collection values) {
return IsInCaseInsensitive.of(values);
}
static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(String...values) {
return isInCaseInsensitiveWhenPresent(Arrays.asList(values));
}
static IsInCaseInsensitiveWhenPresent isInCaseInsensitiveWhenPresent(Collection values) {
return IsInCaseInsensitiveWhenPresent.of(values);
}
static IsNotInCaseInsensitive isNotInCaseInsensitive(String...values) {
return isNotInCaseInsensitive(Arrays.asList(values));
}
static IsNotInCaseInsensitive isNotInCaseInsensitive(Collection values) {
return IsNotInCaseInsensitive.of(values);
}
static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(String...values) {
return isNotInCaseInsensitiveWhenPresent(Arrays.asList(values));
}
static IsNotInCaseInsensitiveWhenPresent isNotInCaseInsensitiveWhenPresent(Collection values) {
return IsNotInCaseInsensitiveWhenPresent.of(values);
}
// order by support
static SortSpecification sortColumn(String name) {
return SimpleSortSpecification.of(name);
}
}