From 6af7b274222f9afdc35c22b0fccdc06aa79883a5 Mon Sep 17 00:00:00 2001 From: u$f Date: Wed, 28 Aug 2024 15:58:22 +0200 Subject: [PATCH] edit --- .../java/org/usf/jquery/core/DBColumn.java | 396 ++++++++++++++---- .../org/usf/jquery/core/TypedComparator.java | 2 +- src/main/java/org/usf/jquery/core/Utils.java | 6 +- 3 files changed, 311 insertions(+), 93 deletions(-) diff --git a/src/main/java/org/usf/jquery/core/DBColumn.java b/src/main/java/org/usf/jquery/core/DBColumn.java index e33cf1ef..918ddfb9 100644 --- a/src/main/java/org/usf/jquery/core/DBColumn.java +++ b/src/main/java/org/usf/jquery/core/DBColumn.java @@ -1,6 +1,7 @@ package org.usf.jquery.core; import static org.usf.jquery.core.QueryParameterBuilder.formatValue; +import static org.usf.jquery.core.Utils.arrayJoin; import static org.usf.jquery.core.Validation.requireLegalVariable; import static org.usf.jquery.core.Validation.requireNoArgs; @@ -47,78 +48,95 @@ default NamedColumn as(String name) { return new NamedColumn(this, Objects.isNull(name) ? null : requireLegalVariable(name)); } - default DBOrder order() { - return new DBOrder(this); - } - - default DBOrder order(Order order) { - return new DBOrder(this, order); - } - // filters + default ColumnSingleFilter eq(Object value) { - return filter(ComparisonExpression.eq(value)); + return Comparator.eq().filter(this, value); } default ColumnSingleFilter ne(Object value) { - return filter(ComparisonExpression.ne(value)); + return Comparator.ne().filter(this, value); + } + + default ColumnSingleFilter lt(Object value) { + return Comparator.lt().filter(this, value); + } + + default ColumnSingleFilter le(Object value) { + return Comparator.le().filter(this, value); } default ColumnSingleFilter gt(Object value) { - return filter(ComparisonExpression.gt(value)); + return Comparator.gt().filter(this, value); } default ColumnSingleFilter ge(Object value) { - return filter(ComparisonExpression.ge(value)); + return Comparator.ge().filter(this, value); } - default ColumnSingleFilter lt(Object value) { - return filter(ComparisonExpression.lt(value)); + default ColumnSingleFilter like(Object value) { + return Comparator.like().filter(this, value); + } + + default ColumnSingleFilter startsLike(Object value) { + return Comparator.startsLike().filter(this, value); } - default ColumnSingleFilter le(Object value) { - return filter(ComparisonExpression.le(value)); + default ColumnSingleFilter endsLike(Object value) { + return Comparator.endsLike().filter(this, value); } - default ColumnSingleFilter like(Object value) { - return filter(ComparisonExpression.like(value)); + default ColumnSingleFilter contentLike(Object value) { + return Comparator.contentLike().filter(this, value); + } + + default ColumnSingleFilter startsNotLike(Object value) { + return Comparator.startsNotLike().filter(this, value); + } + + default ColumnSingleFilter endsNotLike(Object value) { + return Comparator.endsNotLike().filter(this, value); + } + + default ColumnSingleFilter contentNotLike(Object value) { + return Comparator.contentNotLike().filter(this, value); } default ColumnSingleFilter notLike(Object value) { - return filter(ComparisonExpression.notLike(value)); + return Comparator.notLike().filter(this, value); } default ColumnSingleFilter ilike(Object value) { - return filter(ComparisonExpression.iLike(value)); + return Comparator.iLike().filter(this, value); } default ColumnSingleFilter notILike(Object value) { - return filter(ComparisonExpression.notILike(value)); + return Comparator.notILike().filter(this, value); } - @SuppressWarnings("unchecked") - default ColumnSingleFilter in(T... values) { - return filter(ComparisonExpression.in(values)); + default ColumnSingleFilter isNull() { + return Comparator.isNull().filter(this); } - @SuppressWarnings("unchecked") - default ColumnSingleFilter notIn(T... values) { - return filter(ComparisonExpression.notIn(values)); + default ColumnSingleFilter notNull() { + return Comparator.notNull().filter(this); } - default ColumnSingleFilter isNull() { - return filter(ComparisonExpression.isNull()); + @SuppressWarnings("unchecked") + default ColumnSingleFilter in(T... arr) { + return Comparator.in().filter(arrayJoin(arr, this, 0)); } - default ColumnSingleFilter isNotNull() { - return filter(ComparisonExpression.isNotNull()); + @SuppressWarnings("unchecked") + default ColumnSingleFilter notIn(T... arr) { + return Comparator.notIn().filter(arrayJoin(arr, this, 0)); } - + default ColumnSingleFilter filter(ComparisonExpression exp) { return new ColumnSingleFilter(this, exp); } - // operations + // arithmetic operations default OperationColumn plus(Object o) { return Operator.plus().operation(this, o); @@ -136,104 +154,300 @@ default OperationColumn divide(Object o) { return Operator.divide().operation(this, o); } - default WhenFilterBridge when(ComparisonExpression ex) { - return new CaseSingleColumnBuilder(this).when(ex); + //numeric functions + + default OperationColumn sqrt(Object o) { + return Operator.sqrt().operation(this, o); } - static DBColumn column(@NonNull String value) { - return b-> value; + default OperationColumn exp(Object o) { + return Operator.exp().operation(this, o); + } + + default OperationColumn log(Object o) { + return Operator.log().operation(this, o); + } + + default OperationColumn abs(Object o) { + return Operator.abs().operation(this, o); } - static TaggableColumn allColumns(@NonNull DBView view) { - return ((DBColumn) b-> { - b.view(view); - return "*"; //avoid view.* as "" - }).as(null); + default OperationColumn ceil(Object o) { + return Operator.ceil().operation(this, o); + } + + default OperationColumn floor(Object o) { + return Operator.floor().operation(this, o); + } + + default OperationColumn trunc(Object o) { + return Operator.trunc().operation(this, o); } - static DBColumn constant(Object value) { - return constant(()-> value); + default OperationColumn round(Object o) { + return Operator.round().operation(this, o); + } + + default OperationColumn mod(Object o) { + return Operator.mod().operation(this, o); } + + default OperationColumn pow(Object o) { + return Operator.pow().operation(this, o); + } + + //string functions - static DBColumn constant(Supplier value) { - return new DBColumn() { - - @Override - public String sql(QueryParameterBuilder arg) { - return formatValue(value.get()); //lazy - } - - @Override - public Stream groupKeys() { - return Stream.empty(); - } - }; + default OperationColumn length() { + return Operator.length().operation(this); + } + + default OperationColumn trim() { + return Operator.trim().operation(this); + } + + default OperationColumn ltrim() { + return Operator.ltrim().operation(this); + } + + default OperationColumn rtrim() { + return Operator.rtrim().operation(this); + } + + default OperationColumn upper() { + return Operator.upper().operation(this); + } + + default OperationColumn lower() { + return Operator.lower().operation(this); + } + + default OperationColumn initcap() { + return Operator.initcap().operation(this); + } + + default OperationColumn reverse() { + return Operator.reverse().operation(this); + } + + default OperationColumn left(int n) { + return Operator.left().operation(this, n); + } + + default OperationColumn right(int n) { + return Operator.pow().operation(this, n); + } + + default OperationColumn replace(String oldValue, String newValue) { + return Operator.replace().operation(this, oldValue, newValue); + } + + default OperationColumn substring(int start, int end) { + return Operator.substring().operation(this, start, end); + } + + default OperationColumn concat(String... str) { + return Operator.concat().operation(arrayJoin(str, this, 0)); + } + + default OperationColumn pow(int n, String value) { + return Operator.pow().operation(this, n, value); + } + + default OperationColumn rpad(int n, String value) { + return Operator.rpad().operation(this, n, value); } - static OperationColumn count() { - return count(column("*")); + //temporal functions + + default OperationColumn year() { + return Operator.year().operation(this); + } + + default OperationColumn month() { + return Operator.month().operation(this); } - static OperationColumn count(Object arg) { - return Operator.count().operation(arg); + default OperationColumn week() { + return Operator.week().operation(this); + } + + default OperationColumn day() { + return Operator.day().operation(this); + } + + default OperationColumn dow() { + return Operator.dow().operation(this); + } + + default OperationColumn doy() { + return Operator.doy().operation(this); } - static OperationColumn min(Object arg) { - return Operator.min().operation(arg); + default OperationColumn hour() { + return Operator.hour().operation(this); } - static OperationColumn max(Object arg) { - return Operator.max().operation(arg); + default OperationColumn minute() { + return Operator.minute().operation(this); + } + + default OperationColumn second() { + return Operator.second().operation(this); + } + + default OperationColumn epoch() { + return Operator.epoch().operation(this); + } + + default OperationColumn yearMonth() { + return Operator.yearMonth().operation(this); } + + //cast functions - static OperationColumn sum(Object arg) { - return Operator.sum().operation(arg); + default OperationColumn varchar() { + return Operator.varchar().operation(this); + } + + default OperationColumn varchar(int size) { + return Operator.varchar().operation(this, size); + } + + default OperationColumn date() { + return Operator.date().operation(this); + } + + default OperationColumn timestamp() { + return Operator.timestamp().operation(this); + } + + default OperationColumn integer() { + return Operator.integer().operation(this); } - static OperationColumn avg(Object arg) { - return Operator.avg().operation(arg); + default OperationColumn bigint() { + return Operator.bigint().operation(this); } - //numeric + default OperationColumn decimal() { + return Operator.decimal().operation(this); + } - static OperationColumn abs(Object arg) { - return Operator.abs().operation(arg); + default OperationColumn decimal(int digit, int precision) { + return Operator.decimal().operation(this, digit, precision); } + + //aggregate functions - static OperationColumn sqrt(Object arg) { - return Operator.sqrt().operation(arg); + default OperationColumn coalesce(Object o) { + return Operator.coalesce().operation(this, o); } - static OperationColumn trunc(Object arg) { - return Operator.trunc().operation(arg); + default OperationColumn count() { + return Operator.count().operation(this); } - static OperationColumn ceil(Object arg) { - return Operator.ceil().operation(arg); + default OperationColumn min() { + return Operator.min().operation(this); } - static OperationColumn floor(Object arg) { - return Operator.floor().operation(arg); + default OperationColumn max() { + return Operator.max().operation(this); + } + + default OperationColumn sum() { + return Operator.sum().operation(this); + } + + default OperationColumn avg() { + return Operator.avg().operation(this); } - //string - static OperationColumn trim(Object arg) { - return Operator.trim().operation(arg); + + //window functions + + default OperationColumn rank() { + return Operator.rank().operation(this); + } + + default OperationColumn rowNumber() { + return Operator.rowNumber().operation(this); + } + + default OperationColumn denseRank() { + return Operator.denseRank().operation(this); } - static OperationColumn length(Object arg) { - return Operator.length().operation(arg); + //pipe functions + + default OperationColumn over(Partition part) { + return Operator.over().operation(this, part); } - static OperationColumn upper(Object arg) { - return Operator.upper().operation(arg); + //orders + + default DBOrder order() { + return new DBOrder(this); + } + + default DBOrder asc() { + return new DBOrder(this, Order.ASC); + } + + default DBOrder desc() { + return new DBOrder(this, Order.ASC); + } + + default WhenFilterBridge when(ComparisonExpression ex) { + return new CaseSingleColumnBuilder(this).when(ex); + } + + // constants + + static OperationColumn cdate() { + return Operator.cdate().operation(); + } + + static OperationColumn ctime() { + return Operator.ctime().operation(); + } + + static OperationColumn ctimestamp() { + return Operator.ctimestamp().operation(); } - static OperationColumn lower(Object arg) { - return Operator.lower().operation(arg); + static OperationColumn countAll() { + return Operator.count().operation(column("*")); } - static OperationColumn substring(Object arg, int start, int length) { - return Operator.substring().operation(arg, start, length); + static DBColumn column(@NonNull String value) { + return b-> value; + } + + static TaggableColumn allColumns(@NonNull DBView view) { + return ((DBColumn) b-> { + b.view(view); + return "*"; //avoid view.* as "" + }).as(null); + } + + static DBColumn constant(Object value) { + return constant(()-> value); + } + + static DBColumn constant(Supplier value) { + return new DBColumn() { + + @Override + public String sql(QueryParameterBuilder arg) { + return formatValue(value.get()); //lazy + } + + @Override + public Stream groupKeys() { + return Stream.empty(); + } + }; } } diff --git a/src/main/java/org/usf/jquery/core/TypedComparator.java b/src/main/java/org/usf/jquery/core/TypedComparator.java index b958b204..23c0602d 100644 --- a/src/main/java/org/usf/jquery/core/TypedComparator.java +++ b/src/main/java/org/usf/jquery/core/TypedComparator.java @@ -31,7 +31,7 @@ public ComparisonExpression expression(Object... right) { } } - public DBFilter filter(Object... args) { + public ColumnSingleFilter filter(Object... args) { try { return comparator.filter(parameterSet.assertArguments(args)); } catch (BadArgumentException e) { //TODO message diff --git a/src/main/java/org/usf/jquery/core/Utils.java b/src/main/java/org/usf/jquery/core/Utils.java index 23dfcc20..85f50ca5 100644 --- a/src/main/java/org/usf/jquery/core/Utils.java +++ b/src/main/java/org/usf/jquery/core/Utils.java @@ -58,8 +58,12 @@ public static String joinAndDelemit(String delemiter, String before, String } public static T[] arrayJoin(T[] arr, T o) { + return arrayJoin(arr, o, arr.length); + } + + public static T[] arrayJoin(T[] arr, T o, int idx) { var res = copyOf(arr, arr.length+1); - res[arr.length] = o; + res[idx] = o; return res; } }