refactor: renamed aggregations and terms

Author: Julien Ruaux

src/main/java/com/redis/trino/MetricAggregation.java renamed to src/main/java/com/redis/trino/RediSearchAggregation.java

@@ -44,7 +44,7 @@
 import io.trino.spi.expression.Variable;
 import io.trino.spi.type.Type;
 
-public class MetricAggregation {
+public class RediSearchAggregation {
 
 	public static final String MAX = "max";
 	public static final String MIN = "min";
@@ -59,7 +59,7 @@ public class MetricAggregation {
 	private final String alias;
 
 	@JsonCreator
-	public MetricAggregation(@JsonProperty("functionName") String functionName,
+	public RediSearchAggregation(@JsonProperty("functionName") String functionName,
 			@JsonProperty("outputType") Type outputType,
 			@JsonProperty("columnHandle") Optional<RediSearchColumnHandle> columnHandle,
 			@JsonProperty("alias") String alias) {
@@ -93,26 +93,21 @@ public static boolean isNumericType(Type type) {
 		return NUMERIC_TYPES.contains(type);
 	}
 
-	public static Optional<MetricAggregation> handleAggregation(AggregateFunction function,
+	public static Optional<RediSearchAggregation> handleAggregation(AggregateFunction function,
 			Map<String, ColumnHandle> assignments, String alias) {
 		if (!SUPPORTED_AGGREGATION_FUNCTIONS.contains(function.getFunctionName())) {
 			return Optional.empty();
 		}
-		// check
-		// 1. Function input can be found in assignments
-		// 2. Target type of column being aggregate must be numeric type
-		// 3. ColumnHandle support predicates(since text treats as VARCHAR, but text can
-		// not be treats as term in es by default
 		Optional<RediSearchColumnHandle> parameterColumnHandle = function.getArguments().stream()
 				.filter(Variable.class::isInstance).map(Variable.class::cast).map(Variable::getName)
 				.filter(assignments::containsKey).findFirst().map(assignments::get)
 				.map(RediSearchColumnHandle.class::cast)
-				.filter(column -> MetricAggregation.isNumericType(column.getType()));
-		// only count can accept empty ElasticsearchColumnHandle
-		if (!COUNT.equals(function.getFunctionName()) && parameterColumnHandle.isEmpty()) {
+				.filter(column -> RediSearchAggregation.isNumericType(column.getType()));
+		// only count can accept empty RediSearchColumnHandle
+		if (parameterColumnHandle.isEmpty() && !COUNT.equals(function.getFunctionName())) {
 			return Optional.empty();
 		}
-		return Optional.of(new MetricAggregation(function.getFunctionName(), function.getOutputType(),
+		return Optional.of(new RediSearchAggregation(function.getFunctionName(), function.getOutputType(),
 				parameterColumnHandle, alias));
 	}
 
@@ -124,7 +119,7 @@ public boolean equals(Object o) {
 		if (o == null || getClass() != o.getClass()) {
 			return false;
 		}
-		MetricAggregation that = (MetricAggregation) o;
+		RediSearchAggregation that = (RediSearchAggregation) o;
 		return Objects.equals(functionName, that.functionName) && Objects.equals(outputType, that.outputType)
 				&& Objects.equals(columnHandle, that.columnHandle) && Objects.equals(alias, that.alias);
 	}

src/main/java/com/redis/trino/TermAggregation.java renamed to src/main/java/com/redis/trino/RediSearchAggregationTerm.java

@@ -32,12 +32,13 @@
 import io.trino.spi.connector.ColumnHandle;
 import io.trino.spi.type.Type;
 
-public class TermAggregation {
+public class RediSearchAggregationTerm {
+
 	private final String term;
 	private final Type type;
 
 	@JsonCreator
-	public TermAggregation(@JsonProperty("term") String term, @JsonProperty("type") Type type) {
+	public RediSearchAggregationTerm(@JsonProperty("term") String term, @JsonProperty("type") Type type) {
 		this.term = term;
 		this.type = type;
 	}
@@ -52,9 +53,9 @@ public Type getType() {
 		return type;
 	}
 
-	public static Optional<TermAggregation> fromColumnHandle(ColumnHandle columnHandle) {
+	public static Optional<RediSearchAggregationTerm> fromColumnHandle(ColumnHandle columnHandle) {
 		RediSearchColumnHandle column = (RediSearchColumnHandle) columnHandle;
-		return Optional.of(new TermAggregation(column.getName(), column.getType()));
+		return Optional.of(new RediSearchAggregationTerm(column.getName(), column.getType()));
 	}
 
 	@Override
@@ -65,7 +66,7 @@ public boolean equals(Object o) {
 		if (o == null || getClass() != o.getClass()) {
 			return false;
 		}
-		TermAggregation that = (TermAggregation) o;
+		RediSearchAggregationTerm that = (RediSearchAggregationTerm) o;
 		return Objects.equals(term, that.term) && Objects.equals(type, that.type);
 	}
 

src/main/java/com/redis/trino/RediSearchMetadata.java

@@ -266,7 +266,7 @@ public Optional<LimitApplicationResult<ConnectorTableHandle>> applyLimit(Connect
 
 		return Optional.of(new LimitApplicationResult<>(new RediSearchTableHandle(handle.getType(),
 				handle.getSchemaTableName(), handle.getConstraint(), OptionalLong.of(limit),
-				handle.getTermAggregations(), handle.getMetricAggregations(), handle.getWildcards()), true, false));
+				handle.getAggregationTerms(), handle.getAggregations(), handle.getWildcards()), true, false));
 	}
 
 	@Override
@@ -329,7 +329,7 @@ public Optional<ConstraintApplicationResult<ConnectorTableHandle>> applyFilter(C
 		}
 
 		handle = new RediSearchTableHandle(handle.getType(), handle.getSchemaTableName(), newDomain, handle.getLimit(),
-				handle.getTermAggregations(), handle.getMetricAggregations(), newWildcards);
+				handle.getAggregationTerms(), handle.getAggregations(), newWildcards);
 
 		return Optional.of(new ConstraintApplicationResult<>(handle, TupleDomain.withColumnDomains(unsupported),
 				newExpression, false));
@@ -420,41 +420,42 @@ public Optional<AggregationApplicationResult<ConnectorTableHandle>> applyAggrega
 		RediSearchTableHandle table = (RediSearchTableHandle) handle;
 		// Global aggregation is represented by [[]]
 		verify(!groupingSets.isEmpty(), "No grouping sets provided");
-		if (!table.getTermAggregations().isEmpty()) {
+		if (!table.getAggregationTerms().isEmpty()) {
 			return Optional.empty();
 		}
 		ImmutableList.Builder<ConnectorExpression> projections = ImmutableList.builder();
 		ImmutableList.Builder<Assignment> resultAssignments = ImmutableList.builder();
-		ImmutableList.Builder<MetricAggregation> metricAggregations = ImmutableList.builder();
-		ImmutableList.Builder<TermAggregation> termAggregations = ImmutableList.builder();
+		ImmutableList.Builder<RediSearchAggregation> aggregations = ImmutableList.builder();
+		ImmutableList.Builder<RediSearchAggregationTerm> terms = ImmutableList.builder();
 		for (int i = 0; i < aggregates.size(); i++) {
 			AggregateFunction function = aggregates.get(i);
 			String colName = SYNTHETIC_COLUMN_NAME_PREFIX + i;
-			Optional<MetricAggregation> metricAggregation = MetricAggregation.handleAggregation(function, assignments,
+			Optional<RediSearchAggregation> aggregation = RediSearchAggregation.handleAggregation(function, assignments,
 					colName);
-			if (metricAggregation.isEmpty()) {
+			if (aggregation.isEmpty()) {
 				return Optional.empty();
 			}
 			io.trino.spi.type.Type outputType = function.getOutputType();
 			RediSearchColumnHandle newColumn = new RediSearchColumnHandle(colName, outputType,
 					RediSearchSession.toFieldType(outputType), false, true);
 			projections.add(new Variable(colName, function.getOutputType()));
 			resultAssignments.add(new Assignment(colName, newColumn, function.getOutputType()));
-			metricAggregations.add(metricAggregation.get());
+			aggregations.add(aggregation.get());
 		}
 		for (ColumnHandle columnHandle : groupingSets.get(0)) {
-			Optional<TermAggregation> termAggregation = TermAggregation.fromColumnHandle(columnHandle);
+			Optional<RediSearchAggregationTerm> termAggregation = RediSearchAggregationTerm
+					.fromColumnHandle(columnHandle);
 			if (termAggregation.isEmpty()) {
 				return Optional.empty();
 			}
-			termAggregations.add(termAggregation.get());
+			terms.add(termAggregation.get());
 		}
-		ImmutableList<MetricAggregation> metrics = metricAggregations.build();
-		if (metrics.isEmpty()) {
+		ImmutableList<RediSearchAggregation> aggregationList = aggregations.build();
+		if (aggregationList.isEmpty()) {
 			return Optional.empty();
 		}
 		RediSearchTableHandle tableHandle = new RediSearchTableHandle(Type.AGGREGATE, table.getSchemaTableName(),
-				table.getConstraint(), table.getLimit(), termAggregations.build(), metrics, table.getWildcards());
+				table.getConstraint(), table.getLimit(), terms.build(), aggregationList, table.getWildcards());
 		return Optional.of(new AggregationApplicationResult<>(tableHandle, projections.build(),
 				resultAssignments.build(), Map.of(), false));
 	}

src/main/java/com/redis/trino/RediSearchQueryBuilder.java

@@ -74,11 +74,11 @@ public class RediSearchQueryBuilder {
 
 	private static final Logger log = Logger.get(RediSearchQueryBuilder.class);
 
-	private static final Map<String, BiFunction<String, String, Reducer>> CONVERTERS = Map.of(MetricAggregation.MAX,
-			(alias, field) -> Max.property(field).as(alias).build(), MetricAggregation.MIN,
-			(alias, field) -> Min.property(field).as(alias).build(), MetricAggregation.SUM,
-			(alias, field) -> Sum.property(field).as(alias).build(), MetricAggregation.AVG,
-			(alias, field) -> Avg.property(field).as(alias).build(), MetricAggregation.COUNT,
+	private static final Map<String, BiFunction<String, String, Reducer>> CONVERTERS = Map.of(RediSearchAggregation.MAX,
+			(alias, field) -> Max.property(field).as(alias).build(), RediSearchAggregation.MIN,
+			(alias, field) -> Min.property(field).as(alias).build(), RediSearchAggregation.SUM,
+			(alias, field) -> Sum.property(field).as(alias).build(), RediSearchAggregation.AVG,
+			(alias, field) -> Avg.property(field).as(alias).build(), RediSearchAggregation.COUNT,
 			(alias, field) -> Count.as(alias));
 
 	public String buildQuery(TupleDomain<ColumnHandle> tupleDomain) {
@@ -231,18 +231,18 @@ private Object translateValue(Object trinoNativeValue, Type type) {
 		throw new IllegalArgumentException("Unhandled type: " + type);
 	}
 
-	private Reducer reducer(MetricAggregation aggregation) {
+	private Reducer reducer(RediSearchAggregation aggregation) {
 		Optional<RediSearchColumnHandle> column = aggregation.getColumnHandle();
 		String field = column.isPresent() ? column.get().getName() : null;
 		return CONVERTERS.get(aggregation.getFunctionName()).apply(aggregation.getAlias(), field);
 	}
 
 	public Optional<Group> group(RediSearchTableHandle table) {
-		List<TermAggregation> terms = table.getTermAggregations();
-		List<MetricAggregation> aggregates = table.getMetricAggregations();
+		List<RediSearchAggregationTerm> terms = table.getAggregationTerms();
+		List<RediSearchAggregation> aggregates = table.getAggregations();
 		List<String> groupFields = new ArrayList<>();
 		if (terms != null && !terms.isEmpty()) {
-			groupFields = terms.stream().map(TermAggregation::getTerm).collect(Collectors.toList());
+			groupFields = terms.stream().map(RediSearchAggregationTerm::getTerm).collect(Collectors.toList());
 		}
 		List<Reducer> reducers = aggregates.stream().map(this::reducer).collect(Collectors.toList());
 		if (reducers.isEmpty()) {

src/main/java/com/redis/trino/RediSearchTableHandle.java

@@ -50,8 +50,8 @@ public enum Type {
 	private final TupleDomain<ColumnHandle> constraint;
 	private final OptionalLong limit;
 	// for group by fields
-	private final List<TermAggregation> termAggregations;
-	private final List<MetricAggregation> metricAggregations;
+	private final List<RediSearchAggregationTerm> aggregationTerms;
+	private final List<RediSearchAggregation> aggregations;
 	private final Map<String, String> wildcards;
 
 	public RediSearchTableHandle(Type type, SchemaTableName schemaTableName) {
@@ -63,15 +63,15 @@ public RediSearchTableHandle(Type type, SchemaTableName schemaTableName) {
 	public RediSearchTableHandle(@JsonProperty("type") Type type,
 			@JsonProperty("schemaTableName") SchemaTableName schemaTableName,
 			@JsonProperty("constraint") TupleDomain<ColumnHandle> constraint, @JsonProperty("limit") OptionalLong limit,
-			@JsonProperty("aggTerms") List<TermAggregation> termAggregations,
-			@JsonProperty("aggregates") List<MetricAggregation> metricAggregations,
+			@JsonProperty("aggTerms") List<RediSearchAggregationTerm> aggregationTerms,
+			@JsonProperty("aggregates") List<RediSearchAggregation> aggregates,
 			@JsonProperty("wildcards") Map<String, String> wildcards) {
 		this.type = requireNonNull(type, "type is null");
 		this.schemaTableName = requireNonNull(schemaTableName, "schemaTableName is null");
 		this.constraint = requireNonNull(constraint, "constraint is null");
 		this.limit = requireNonNull(limit, "limit is null");
-		this.termAggregations = requireNonNull(termAggregations, "aggTerms is null");
-		this.metricAggregations = requireNonNull(metricAggregations, "aggregates is null");
+		this.aggregationTerms = requireNonNull(aggregationTerms, "aggTerms is null");
+		this.aggregations = requireNonNull(aggregates, "aggregates is null");
 		this.wildcards = requireNonNull(wildcards, "wildcards is null");
 	}
 
@@ -96,13 +96,13 @@ public OptionalLong getLimit() {
 	}
 
 	@JsonProperty
-	public List<TermAggregation> getTermAggregations() {
-		return termAggregations;
+	public List<RediSearchAggregationTerm> getAggregationTerms() {
+		return aggregationTerms;
 	}
 
 	@JsonProperty
-	public List<MetricAggregation> getMetricAggregations() {
-		return metricAggregations;
+	public List<RediSearchAggregation> getAggregations() {
+		return aggregations;
 	}
 
 	@JsonProperty