Cleanup Jooq usage

backend/src/main/java/com/bakdata/conquery/sql/conversion/cqelement/aggregation/PostgreSqlDateAggregator.java

@@ -93,9 +93,10 @@ public QueryStep invertAggregatedIntervals(QueryStep baseStep, NameGenerator nam
 		// see https://www.postgresql.org/docs/current/functions-range.html
 		// {[-infinity,infinity]} - {multirange} computes the inverse of a {multirange}
 		Field<Object> invertedValidityDate = DSL.field(
-				"{0}::datemultirange - {1}",
+				"{0}::{1} - {2}",
 				Object.class,
 				maxDateRange,
+				DSL.keyword("datemultirange"),
 				validityDate.get().getRange()
 		).as(PostgresDateAggregationCteStep.DATES_INVERTED.suffix());
 
@@ -127,7 +128,7 @@ private ColumnDateRange getAggregatedValidityDate(DateAggregationDates dateAggre
 	}
 
 	private static String createEmptyRangeForNullValues(Field<?> field) {
-		return DSL.when(field.isNull(), DSL.field("'{}'::datemultirange"))
+		return DSL.when(field.isNull(), DSL.field("'{}'::{0}", DSL.keyword("datemultirange")))
 				  .otherwise(field)
 				  .toString();
 	}

backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/HanaSqlFunctionProvider.java

@@ -116,23 +116,24 @@ public Field<String> validityDateStringAggregation(ColumnDateRange columnDateRan
 		Field<String> withMaxDateReplaced = replace(endDateExpression, MAX_DATE_VALUE, INFINITY_SIGN);
 
 		// add interval braces to ranges: start is allways included, end is allways excluded except if it's the maximum/infinity date
-		Field<String> enclosedMinDate = DSL.field("'[' || %s".formatted(withMinDateReplaced), String.class);
-		Field<String> enclosedMaxDate = DSL.when(withMaxDateReplaced.like(INFINITY_SIGN), DSL.field("%s || ']'".formatted(withMaxDateReplaced), String.class))
-										   .otherwise(DSL.field("%s || ')'".formatted(withMaxDateReplaced), String.class));
+		Field<String> enclosedMinDate = DSL.field("'[' || {0}", String.class, withMinDateReplaced);
+		Field<String> enclosedMaxDate = DSL.when(withMaxDateReplaced.like(INFINITY_SIGN), DSL.field("{0} || ']'", String.class, withMaxDateReplaced))
+										   .otherwise(DSL.field("{0} || ')'", String.class, withMaxDateReplaced));
 
-		Field<String> rangeConcatenated = DSL.field("%s || ',' || %s".formatted(enclosedMinDate, enclosedMaxDate), String.class);
+		Field<String> rangeConcatenated = DSL.field("{0} || ',' || {1}", String.class, enclosedMinDate, enclosedMaxDate);
 
 		Field<String> stringAggregation = DSL.field(
-				"STRING_AGG({0}, {1} {2})",
+				"{0}({1}, {2} {3})",
 				String.class,
+				DSL.keyword("STRING_AGG"),
 				rangeConcatenated,
 				DSL.toChar(DELIMITER),
 				DSL.orderBy(startDate)
 		);
 
 		// encapsulate all ranges (including empty ranges) within curly braces
 		return DSL.when(stringAggregation.isNull(), DSL.field(DSL.val("{}")))
-				  .otherwise(DSL.field(("'{' || %s || '}'".formatted(stringAggregation)), String.class));
+				  .otherwise(DSL.field("'{' || {0} || '}'", String.class, stringAggregation));
 	}
 
 	@Override
@@ -175,25 +176,44 @@ public <T> Field<T> first(Field<T> column, List<Field<?>> orderByColumns) {
 		if (orderByColumns.isEmpty()) {
 			orderByColumns = List.of(column);
 		}
-		return DSL.field(DSL.sql("FIRST_VALUE({0} {1})", column, DSL.orderBy(orderByColumns)), column.getType());
+		return DSL.field(
+				"{0}({1} {2})",
+				column.getType(),
+				DSL.keyword("FIRST_VALUE"),
+				column,
+				DSL.orderBy(orderByColumns)
+		);
 	}
 
 	@Override
 	public <T> Field<T> last(Field<T> column, List<Field<?>> orderByColumns) {
 		if (orderByColumns.isEmpty()) {
 			orderByColumns = List.of(column);
 		}
-		return DSL.field(DSL.sql("LAST_VALUE({0} {1} DESC)", column, DSL.orderBy(orderByColumns)), column.getType());
+		return DSL.field(
+				"{0}({1} {2} {3})",
+				column.getType(),
+				DSL.keyword("LAST_VALUE"),
+				column,
+				DSL.orderBy(orderByColumns),
+				DSL.keyword("DESC")
+		);
 	}
 
 	@Override
 	public <T> Field<T> random(Field<T> column) {
-		return DSL.field(DSL.sql("FIRST_VALUE({0} {1})", column, DSL.orderBy(DSL.function("RAND", Object.class))), column.getType());
+		return DSL.field(
+				"{0}({1} {2})",
+				column.getType(),
+				DSL.keyword("FIRST_VALUE"),
+				column,
+				DSL.orderBy(DSL.function("RAND", Object.class))
+		);
 	}
 
 	@Override
 	public Condition likeRegex(Field<String> field, String pattern) {
-		return DSL.condition("{0} LIKE_REGEXPR {1}", field, pattern);
+		return DSL.condition("{0} {1} {2}", field, DSL.keyword("LIKE_REGEXPR"), pattern);
 	}
 
 	@Override
@@ -207,7 +227,14 @@ public Field<Date> addDays(Field<Date> dateColumn, int amountOfDays) {
 	}
 
 	private Field<String> toVarcharField(Field<Date> startDate, Param<Integer> dateExpressionLength) {
-		return DSL.field("CAST({0} AS VARCHAR({1}))", String.class, startDate, dateExpressionLength);
+		return DSL.field(
+				"{0}({1} {2}({3}))",
+				String.class,
+				DSL.keyword("CAST"),
+				startDate,
+				DSL.keyword("AS VARCHAR"),
+				dateExpressionLength
+		);
 	}
 
 }

backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/PostgreSqlFunctionProvider.java

@@ -9,11 +9,11 @@
 import com.bakdata.conquery.models.datasets.Column;
 import com.bakdata.conquery.models.datasets.concepts.ValidityDate;
 import com.bakdata.conquery.sql.conversion.model.ColumnDateRange;
+import org.jooq.ArrayAggOrderByStep;
 import org.jooq.Condition;
 import org.jooq.DatePart;
 import org.jooq.Field;
 import org.jooq.Name;
-import org.jooq.WindowSpecificationRowsStep;
 import org.jooq.impl.DSL;
 
 /**
@@ -118,15 +118,15 @@ public ColumnDateRange daterange(ValidityDate validityDate, String qualifier, St
 
 	@Override
 	public ColumnDateRange aggregated(ColumnDateRange columnDateRange) {
-		return ColumnDateRange.of(DSL.field("range_agg({0})", columnDateRange.getRange()));
+		return ColumnDateRange.of(DSL.function("range_agg", Object.class, columnDateRange.getRange()));
 	}
 
 	@Override
 	public Field<String> validityDateStringAggregation(ColumnDateRange columnDateRange) {
 		if (!columnDateRange.isSingleColumnRange()) {
 			throw new UnsupportedOperationException("All column date ranges should have been converted to single column ranges.");
 		}
-		Field<String> aggregatedValidityDate = DSL.field("%s::varchar".formatted(columnDateRange.getRange().toString()), String.class);
+		Field<String> aggregatedValidityDate = DSL.field("{0}::{1}", String.class, columnDateRange.getRange(), DSL.keyword("varchar"));
 		return replace(aggregatedValidityDate, INFINITY_DATE_VALUE, INFINITY_SIGN);
 	}
 
@@ -159,21 +159,31 @@ public Field<Date> addDays(Field<Date> dateColumn, int amountOfDays) {
 
 	@Override
 	public <T> Field<T> first(Field<T> column, List<Field<?>> orderByColumn) {
-		return DSL.field(DSL.sql("({0})[1]", DSL.arrayAgg(column)), column.getType());
+		return DSL.field("({0})[1]", column.getType(), DSL.arrayAgg(column));
 	}
 
 	@Override
 	public <T> Field<T> last(Field<T> column, List<Field<?>> orderByColumns) {
-		String orderByClause = orderByColumns.stream()
-											 .map(Field::toString)
-											 .collect(Collectors.joining(", ", "ORDER BY ", " DESC"));
-		return DSL.field(DSL.sql("({0})[1]", DSL.arrayAgg(DSL.field("%s %s".formatted(column, orderByClause)))), column.getType());
+		ArrayAggOrderByStep<Object[]> arrayAgg = DSL.arrayAgg(DSL.field(
+																	  "{0} {1} {2} {3}",
+																	  column,
+																	  DSL.keyword("ORDER BY"),
+																	  DSL.sql(orderByColumns.stream().map(Field::toString).collect(Collectors.joining(","))),
+																	  DSL.keyword("DESC")
+															  )
+		);
+		return DSL.field("({0})[1]", column.getType(), arrayAgg);
 	}
 
 	@Override
 	public <T> Field<T> random(Field<T> column) {
-		WindowSpecificationRowsStep orderByRandomClause = DSL.orderBy(DSL.function("random", Object.class));
-		return DSL.field(DSL.sql("({0})[1]", DSL.arrayAgg(DSL.field("%s %s".formatted(column, orderByRandomClause)))), column.getType());
+		ArrayAggOrderByStep<Object[]> arrayAgg = DSL.arrayAgg(DSL.field(
+				"{0} {1} {2}",
+				column,
+				DSL.keyword("ORDER BY"),
+				DSL.function("random", Object.class)
+		));
+		return DSL.field("({0})[1]", column.getType(), arrayAgg);
 	}
 
 	@Override
@@ -192,16 +202,19 @@ private Field<?> daterange(Field<?> startColumn, Field<?> endColumn, String boun
 	}
 
 	private Field<Integer> extract(DatePart datePart, Field<Integer> timeInterval) {
-		return DSL.function(
-				"EXTRACT",
+		return DSL.field(
+				"{0}({1} {2} {3})",
 				Integer.class,
-				DSL.inlined(DSL.field("%s FROM %s".formatted(datePart, timeInterval)))
+				DSL.keyword("EXTRACT"),
+				DSL.keyword(datePart.toSQL()),
+				DSL.keyword("FROM"),
+				timeInterval
 		);
 	}
 
 	@Override
 	public Field<Date> toDateField(String dateValue) {
-		return DSL.field("%s::date".formatted(DSL.val(dateValue)), Date.class);
+		return DSL.field("{0}::{1}", Date.class, DSL.val(dateValue), DSL.keyword("date"));
 	}
 
 }

backend/src/main/java/com/bakdata/conquery/sql/conversion/dialect/SqlFunctionProvider.java

@@ -118,9 +118,13 @@ default Field<String> replace(Field<String> target, String old, String _new) {
 	}
 
 	default Field<String> prefixStringAggregation(Field<String> field, String prefix) {
-		Field<String> likePattern = DSL.inline(prefix + "%");
-		String sqlTemplate = "'[' || STRING_AGG(CASE WHEN {0} LIKE {1} THEN {0} ELSE NULL END, ', ') || ']'";
-		return DSL.field(DSL.sql(sqlTemplate, field, likePattern), String.class);
+		return DSL.field(
+				"'[' || {0}({1}, {2}) || ']'",
+				String.class,
+				DSL.keyword("STRING_AGG"),
+				DSL.when(field.like(DSL.inline(prefix + "%")), field),
+				DSL.val(", ")
+		);
 	}
 
 }