use of com.blazebit.persistence.parser.expression.ListIndexExpression in project blaze-persistence by Blazebit.
the class JoinManager method getArrayExpressionPredicate.
private Predicate getArrayExpressionPredicate(JoinNode joinNode, ArrayExpression arrayExpr) {
if (arrayExpr.getIndex() instanceof Predicate) {
return (Predicate) arrayExpr.getIndex();
} else {
PathExpression keyPath = new PathExpression(new ArrayList<PathElementExpression>(), true);
keyPath.getExpressions().add(new PropertyExpression(joinNode.getAliasInfo().getAlias()));
keyPath.setPathReference(new SimplePathReference(joinNode, null, joinNode.getNodeType()));
Attribute<?, ?> arrayBaseAttribute = joinNode.getParentTreeNode().getAttribute();
Expression keyExpression;
if (arrayBaseAttribute instanceof ListAttribute<?, ?>) {
keyExpression = new ListIndexExpression(keyPath);
} else {
keyExpression = new MapKeyExpression(keyPath);
}
return new EqPredicate(keyExpression, arrayExpr.getIndex());
}
}
use of com.blazebit.persistence.parser.expression.ListIndexExpression in project blaze-persistence by Blazebit.
the class JoinNode method createExpression.
public Expression createExpression(String field, boolean asPath) {
List<PathElementExpression> pathElements = new ArrayList<>();
if (qualificationExpression != null) {
List<PathElementExpression> pathElementExpressions = new ArrayList<>(1);
pathElementExpressions.add(new PropertyExpression(parent.getAlias()));
PathExpression path = new PathExpression(pathElementExpressions);
if ("KEY".equalsIgnoreCase(qualificationExpression)) {
pathElements.add(new MapKeyExpression(path));
} else if ("INDEX".equalsIgnoreCase(qualificationExpression)) {
pathElements.add(new ListIndexExpression(path));
} else if ("ENTRY".equalsIgnoreCase(qualificationExpression)) {
pathElements.add(new MapEntryExpression(path));
}
} else {
pathElements.add(new PropertyExpression(aliasInfo.getAlias()));
}
if (field != null) {
for (String fieldPart : field.split("\\.")) {
pathElements.add(new PropertyExpression(fieldPart));
}
}
if (!asPath && valuesTypeName != null) {
return new FunctionExpression("FUNCTION", Arrays.asList(new StringLiteral("TREAT_" + valuesTypeName.toUpperCase()), new PathExpression(pathElements)));
} else {
return new PathExpression(pathElements);
}
}
use of com.blazebit.persistence.parser.expression.ListIndexExpression in project blaze-persistence by Blazebit.
the class AbstractAttribute method checkAttribute.
public void checkAttribute(ManagedType<?> managedType, MetamodelBuildingContext context) {
Class<?> expressionType = getJavaType();
Class<?> keyType = null;
Class<?> elementType = null;
ManagedType<?> elementManagedType;
javax.persistence.metamodel.Attribute<?, ?> elementAttribute;
if (possibleTargetTypes.size() != 1) {
if (getElementType() instanceof ManagedViewType<?>) {
elementManagedType = context.getEntityMetamodel().getManagedType(((ManagedViewType<?>) getElementType()).getEntityClass());
} else {
elementManagedType = context.getEntityMetamodel().getManagedType(getElementType().getJavaType());
}
elementAttribute = null;
} else {
elementManagedType = context.getEntityMetamodel().getManagedType(possibleTargetTypes.get(0).getLeafBaseValueClass());
elementAttribute = possibleTargetTypes.get(0).getLeafMethod();
}
ScalarTargetResolvingExpressionVisitor visitor = new ScalarTargetResolvingExpressionVisitor(elementManagedType, elementAttribute, context.getEntityMetamodel(), context.getJpqlFunctions(), declaringType.getEntityViewRootTypes());
if (fetches.length != 0) {
if (context.getEntityMetamodel().getManagedType(getElementType().getJavaType()) == null) {
context.addError("Specifying fetches for non-entity attribute type [" + Arrays.toString(fetches) + "] at the " + getLocation() + " is not allowed!");
} else {
for (int i = 0; i < fetches.length; i++) {
final String fetch = fetches[i];
final String errorLocation;
if (fetches.length == 1) {
errorLocation = "the fetch expression";
} else {
errorLocation = "the " + (i + 1) + ". fetch expression";
}
visitor.clear();
try {
// Validate the fetch expression parses
context.getExpressionFactory().createPathExpression(fetch).accept(visitor);
} catch (SyntaxErrorException ex) {
try {
context.getExpressionFactory().createSimpleExpression(fetch, false, false, true);
// The used expression is not usable for fetches
context.addError("Invalid fetch expression '" + fetch + "' of the " + getLocation() + ". Simplify the fetch expression to a simple path expression. Encountered error: " + ex.getMessage());
} catch (SyntaxErrorException ex2) {
// This is a real syntax error
context.addError("Syntax error in " + errorLocation + " '" + fetch + "' of the " + getLocation() + ": " + ex.getMessage());
}
} catch (IllegalArgumentException ex) {
context.addError("An error occurred while trying to resolve the " + errorLocation + " '" + fetch + "' of the " + getLocation() + ": " + ex.getMessage());
}
}
}
}
if (limitExpression != null) {
try {
Expression inItemExpression = context.getTypeValidationExpressionFactory().createInItemExpression(limitExpression);
if (!(inItemExpression instanceof ParameterExpression) && !(inItemExpression instanceof NumericLiteral) || inItemExpression instanceof NumericLiteral && ((NumericLiteral) inItemExpression).getNumericType() != NumericType.INTEGER) {
context.addError("Syntax error in the limit expression '" + limitExpression + "' of the " + getLocation() + ": The expression must be a integer literal or a parameter expression");
}
} catch (SyntaxErrorException ex) {
context.addError("Syntax error in the limit expression '" + limitExpression + "' of the " + getLocation() + ": " + ex.getMessage());
} catch (IllegalArgumentException ex) {
context.addError("An error occurred while trying to resolve the limit expression '" + limitExpression + "' of the " + getLocation() + ": " + ex.getMessage());
}
try {
Expression inItemExpression = context.getTypeValidationExpressionFactory().createInItemExpression(offsetExpression);
if (!(inItemExpression instanceof ParameterExpression) && !(inItemExpression instanceof NumericLiteral) || inItemExpression instanceof NumericLiteral && ((NumericLiteral) inItemExpression).getNumericType() != NumericType.INTEGER) {
context.addError("Syntax error in the offset expression '" + offsetExpression + "' of the " + getLocation() + ": The expression must be a integer literal or a parameter expression");
}
} catch (SyntaxErrorException ex) {
context.addError("Syntax error in the offset expression '" + offsetExpression + "' of the " + getLocation() + ": " + ex.getMessage());
} catch (IllegalArgumentException ex) {
context.addError("An error occurred while trying to resolve the offset expression '" + offsetExpression + "' of the " + getLocation() + ": " + ex.getMessage());
}
for (int i = 0; i < orderByItems.size(); i++) {
OrderByItem orderByItem = orderByItems.get(i);
String expression = orderByItem.getExpression();
try {
visitor.clear();
context.getTypeValidationExpressionFactory().createSimpleExpression(expression, false, false, true).accept(visitor);
} catch (SyntaxErrorException ex) {
context.addError("Syntax error in the " + (i + 1) + "th order by expression '" + expression + "' of the " + getLocation() + ": " + ex.getMessage());
} catch (IllegalArgumentException ex) {
context.addError("An error occurred while trying to resolve the " + (i + 1) + "th order by expression '" + expression + "' of the " + getLocation() + ": " + ex.getMessage());
}
}
}
if (fetchStrategy == FetchStrategy.MULTISET) {
if (getElementType() instanceof ManagedViewTypeImplementor<?> && ((ManagedViewTypeImplementor<?>) getElementType()).hasJpaManagedAttributes()) {
context.addError("Using the MULTISET fetch strategy is not allowed when the subview contains attributes with entity types. MULTISET at the " + getLocation() + " is not allowed!");
} else if (getElementType() instanceof BasicTypeImpl<?> && ((BasicTypeImpl<?>) getElementType()).isJpaManaged()) {
context.addError("Using the MULTISET fetch strategy is not allowed with entity types. MULTISET at the " + getLocation() + " is not allowed!");
}
}
Expression indexExpression = null;
if (isCollection()) {
elementType = getElementType().getJavaType();
if (!isUpdatable()) {
// Updatable collection attributes are specially handled in the type compatibility check
if (isIndexed()) {
if (getCollectionType() == PluralAttribute.CollectionType.MAP) {
expressionType = Collection.class;
keyType = getKeyType().getJavaType();
} else {
expressionType = Collection.class;
keyType = Integer.class;
}
} else {
// We can assign e.g. a Set to a List, so let's use the common supertype
expressionType = Collection.class;
}
}
if (isIndexed()) {
if (getCollectionType() == PluralAttribute.CollectionType.MAP) {
indexExpression = getKeyMappingExpression();
String[] keyFetches = getKeyFetches();
if (keyFetches.length != 0) {
ManagedType<?> managedKeyType = context.getEntityMetamodel().getManagedType(getKeyType().getJavaType());
if (managedKeyType == null) {
context.addError("Specifying key fetches for non-entity attribute key type [" + Arrays.toString(keyFetches) + "] at the " + getLocation() + " is not allowed!");
} else {
ScalarTargetResolvingExpressionVisitor keyVisitor = new ScalarTargetResolvingExpressionVisitor(managedKeyType, context.getEntityMetamodel(), context.getJpqlFunctions(), declaringType.getEntityViewRootTypes());
for (int i = 0; i < keyFetches.length; i++) {
final String fetch = keyFetches[i];
final String errorLocation;
if (keyFetches.length == 1) {
errorLocation = "the key fetch expression";
} else {
errorLocation = "the " + (i + 1) + ". key fetch expression";
}
keyVisitor.clear();
try {
// Validate the fetch expression parses
context.getExpressionFactory().createPathExpression(fetch).accept(keyVisitor);
} catch (SyntaxErrorException ex) {
try {
context.getExpressionFactory().createSimpleExpression(fetch, false, false, true);
// The used expression is not usable for fetches
context.addError("Invalid key fetch expression '" + fetch + "' of the " + getLocation() + ". Simplify the key fetch expression to a simple path expression. Encountered error: " + ex.getMessage());
} catch (SyntaxErrorException ex2) {
// This is a real syntax error
context.addError("Syntax error in " + errorLocation + " '" + fetch + "' of the " + getLocation() + ": " + ex.getMessage());
}
} catch (IllegalArgumentException ex) {
context.addError("An error occurred while trying to resolve the " + errorLocation + " '" + fetch + "' of the " + getLocation() + ": " + ex.getMessage());
}
}
}
}
} else {
indexExpression = getMappingIndexExpression();
}
}
}
if (isSubview()) {
ManagedViewTypeImplementor<?> subviewType = (ManagedViewTypeImplementor<?>) getElementType();
if (isCollection()) {
elementType = subviewType.getEntityClass();
} else {
expressionType = subviewType.getEntityClass();
}
} else {
// If we determined, that the java type is a basic type, let's double check if the user didn't do something wrong
Class<?> elementJavaType = getElementType().getJavaType();
if ((elementJavaType.getModifiers() & Modifier.ABSTRACT) != 0) {
// If the element type has an entity view annotation, although it is considered basic, we throw an error as this means, the view was probably not registered
if (!isQueryParameter() && AnnotationUtils.findAnnotation(elementJavaType, EntityView.class) != null && getElementType().getConvertedType() == null) {
context.addError("The element type '" + elementJavaType.getName() + "' is considered basic although the class is annotated with @EntityView. Add a type converter or add the java class to the entity view configuration! Problematic attribute " + getLocation());
}
}
}
if (isKeySubview()) {
keyType = ((ManagedViewTypeImplementor<?>) getKeyType()).getEntityClass();
}
if (keyType != null) {
validateTypesCompatible(possibleIndexTargetTypes, keyType, null, isUpdatable(), true, context, ExpressionLocation.MAPPING_INDEX, getLocation());
}
if (isCorrelated()) {
// Validate that resolving "correlationBasis" on "managedType" is valid
validateTypesCompatible(managedType, correlationBasisExpression, Object.class, null, false, true, declaringType.getEntityViewRootTypes(), context, ExpressionLocation.CORRELATION_BASIS, getLocation());
if (correlated != null) {
// Validate that resolving "correlationResult" on "correlated" is compatible with "expressionType" and "elementType"
validateTypesCompatible(possibleTargetTypes, expressionType, elementType, false, !isCollection(), context, ExpressionLocation.CORRELATION_RESULT, getLocation());
Predicate correlationPredicate = getCorrelationPredicate();
if (correlationPredicate != null) {
ExpressionFactory ef = context.getTypeValidationExpressionFactory();
// First we need to prefix the correlation basis expression with an alias because we use that in the predicate
PrefixingQueryGenerator prefixingQueryGenerator = new PrefixingQueryGenerator(ef, correlationKeyAlias, null, null, declaringType.getEntityViewRootTypes().keySet(), false, false);
prefixingQueryGenerator.setQueryBuffer(new StringBuilder());
correlationBasisExpression.accept(prefixingQueryGenerator);
// Next we replace the plain alias usage with the prefixed correlation basis expression
AliasReplacementVisitor aliasReplacementVisitor = new AliasReplacementVisitor(ef.createSimpleExpression(prefixingQueryGenerator.getQueryBuffer().toString()), correlationKeyAlias);
correlationPredicate = correlationPredicate.copy(ExpressionCopyContext.EMPTY);
correlationPredicate.accept(aliasReplacementVisitor);
// Finally we validate that the expression
try {
Map<String, javax.persistence.metamodel.Type<?>> rootTypes = new HashMap<>(declaringType.getEntityViewRootTypes());
rootTypes.put(correlationKeyAlias, managedType);
ScalarTargetResolvingExpressionVisitor correlationVisitor = new ScalarTargetResolvingExpressionVisitor(correlated, context.getEntityMetamodel(), context.getJpqlFunctions(), rootTypes);
correlationPredicate.accept(correlationVisitor);
} catch (SyntaxErrorException ex) {
context.addError("Syntax error in the condition expression '" + correlationPredicate + "' of the " + getLocation() + ": " + ex.getMessage());
} catch (IllegalArgumentException ex) {
context.addError("An error occurred while trying to resolve the condition expression '" + correlationPredicate + "' of the " + getLocation() + ": " + ex.getMessage());
}
}
}
} else if (isSubquery()) {
if (subqueryExpression != null && !subqueryExpression.isEmpty()) {
// If a converter is applied, we already know that there was a type match with the underlying type
if (getElementType().getConvertedType() == null) {
validateTypesCompatible(possibleTargetTypes, expressionType, elementType, false, !isCollection(), context, ExpressionLocation.SUBQUERY_EXPRESSION, getLocation());
}
}
} else if (!isQueryParameter()) {
// Forcing singular via @MappingSingular
if (!isCollection() && (Collection.class.isAssignableFrom(expressionType) || Map.class.isAssignableFrom(expressionType))) {
Class<?>[] typeArguments = getTypeArguments();
elementType = typeArguments[typeArguments.length - 1];
}
// If a converter is applied, we already know that there was a type match with the underlying type
if (getElementType().getConvertedType() == null) {
// Validate that resolving "mapping" on "managedType" is compatible with "expressionType" and "elementType"
validateTypesCompatible(possibleTargetTypes, expressionType, elementType, isUpdatable(), !isCollection(), context, ExpressionLocation.MAPPING, getLocation());
}
if (isMutable() && (declaringType.isUpdatable() || declaringType.isCreatable())) {
UpdatableExpressionVisitor updatableVisitor = new UpdatableExpressionVisitor(context.getEntityMetamodel(), managedType.getJavaType(), isUpdatable(), declaringType.getEntityViewRootTypes());
try {
// NOTE: Not supporting "this" here because it doesn't make sense to have an updatable mapping that refers to this
// The only thing that might be interesting is supporting "this" when we support cascading as properties could be nested
// But not sure yet if the embeddable attributes would then be modeled as "updatable".
// I guess these attributes are not "updatable" but that probably depends on the decision regarding collections as they have a similar problem
// A collection itself might not be "updatable" but it's elements could be. This is roughly the same problem
mappingExpression.accept(updatableVisitor);
Map<javax.persistence.metamodel.Attribute<?, ?>, javax.persistence.metamodel.Type<?>> possibleTargets = updatableVisitor.getPossibleTargets();
if (possibleTargets.size() > 1) {
context.addError("Multiple possible target type for the mapping in the " + getLocation() + ": " + possibleTargets);
}
// TODO: maybe allow to override this per-attribute?
if (isDisallowOwnedUpdatableSubview()) {
for (Type<?> updateCascadeAllowedSubtype : getUpdateCascadeAllowedSubtypes()) {
ManagedViewType<?> managedViewType = (ManagedViewType<?>) updateCascadeAllowedSubtype;
if (managedViewType.isUpdatable()) {
context.addError("Invalid use of @UpdatableEntityView type '" + managedViewType.getJavaType().getName() + "' for the " + getLocation() + ". Consider using a read-only view type instead or use @AllowUpdatableEntityViews! " + "For further information on this topic, please consult the documentation https://persistence.blazebit.com/documentation/entity-view/manual/en_US/index.html#updatable-mappings-subview");
}
}
}
} catch (IllegalArgumentException ex) {
context.addError("There is an error for the " + getLocation() + ": " + ex.getMessage());
}
if (isUpdatable()) {
if (isCollection() && getElementCollectionType() != null) {
context.addError("The use of a multi-collection i.e. List<Collection<?>> or Map<?, Collection<?>> at the " + getLocation() + " is unsupported for updatable collections!");
}
}
if ((isUpdatable() || isKeySubview() && ((ManagedViewTypeImplementor<?>) getKeyType()).isUpdatable()) && indexExpression != null) {
boolean invalid;
if (getCollectionType() == PluralAttribute.CollectionType.MAP) {
invalid = !(indexExpression instanceof MapKeyExpression) || !"this".equals(((MapKeyExpression) indexExpression).getPath().getPath());
} else {
invalid = !(indexExpression instanceof ListIndexExpression) || !"this".equals(((ListIndexExpression) indexExpression).getPath().getPath());
}
if (invalid) {
context.addError("The @MappingIndex at the " + getLocation() + " is a complex mapping and can thus not be updatable!");
}
}
}
}
}
use of com.blazebit.persistence.parser.expression.ListIndexExpression in project blaze-persistence by Blazebit.
the class EqualityCheckingVisitor method visit.
@Override
public Boolean visit(ListIndexExpression expression) {
if (referenceExpression.getClass() != expression.getClass()) {
return Boolean.TRUE;
}
ListIndexExpression reference = (ListIndexExpression) referenceExpression;
referenceExpression = reference.getPath();
return expression.getPath().accept(this);
}
use of com.blazebit.persistence.parser.expression.ListIndexExpression in project blaze-persistence by Blazebit.
the class SizeTransformationVisitor method getSizeExpression.
private Expression getSizeExpression(ExpressionModifier parentModifier, PathExpression sizeArg) {
JoinNode sizeArgJoin = (JoinNode) sizeArg.getBaseNode();
String property = sizeArg.getPathReference().getField();
final Type<?> nodeType = ((JoinNode) sizeArg.getBaseNode()).getNodeType();
if (!(nodeType instanceof EntityType<?>)) {
throw new IllegalArgumentException("Size on a collection owned by a non-entity type is not supported yet: " + sizeArg);
}
final EntityType<?> startType = (EntityType<?>) nodeType;
AttributeHolder result = JpaUtils.getAttributeForJoining(metamodel, sizeArg);
PluralAttribute<?, ?, ?> targetAttribute = (PluralAttribute<?, ?, ?>) result.getAttribute();
if (targetAttribute == null) {
throw new RuntimeException("Attribute [" + property + "] not found on class " + startType.getJavaType().getName());
}
final PluralAttribute.CollectionType collectionType = targetAttribute.getCollectionType();
final boolean isElementCollection = jpaProvider.getJpaMetamodelAccessor().isElementCollection(targetAttribute);
boolean subqueryRequired;
if (isElementCollection) {
subqueryRequired = false;
} else {
ManagedType<?> managedTargetType = (ManagedType<?>) result.getAttributeType();
if (managedTargetType instanceof EntityType<?>) {
// we could also generate counts for collections with embeddable id but we do not implement this for now
subqueryRequired = ((EntityType<?>) managedTargetType).getIdType().getPersistenceType() == PersistenceType.EMBEDDABLE;
} else {
throw new RuntimeException("Path [" + sizeArg.toString() + "] does not refer to a collection");
}
}
// build group by id clause
List<PathExpression> groupByExprs = new ArrayList<>();
for (SingularAttribute<?, ?> idAttribute : JpaMetamodelUtils.getIdAttributes(startType)) {
List<PathElementExpression> pathElementExpr = new ArrayList<>(2);
pathElementExpr.add(new PropertyExpression(sizeArgJoin.getAlias()));
pathElementExpr.add(new PropertyExpression(idAttribute.getName()));
PathExpression groupByExpr = new PathExpression(pathElementExpr);
groupByExprs.add(groupByExpr);
}
subqueryRequired = subqueryRequired || // we could also generate counts for collections with IdClass attributes but we do not implement this for now
!startType.hasSingleIdAttribute() || joinManager.getRoots().size() > 1 || clause == ClauseType.JOIN || !isCountTransformationEnabled() || // for now, we always generate a subquery when a bag is encountered
jpaProvider.isBag((EntityType<?>) targetAttribute.getDeclaringType(), targetAttribute.getName()) || requiresBlacklistedNode(sizeArg) || aggregateFunctionContext;
if (subqueryRequired) {
return wrapSubqueryConditionally(generateSubquery(sizeArg), aggregateFunctionContext);
} else {
if (currentJoinNode != null && (!currentJoinNode.equals(sizeArgJoin))) {
int currentJoinDepth = currentJoinNode.getJoinDepth();
int sizeArgJoinDepth = sizeArgJoin.getJoinDepth();
if (currentJoinDepth > sizeArgJoinDepth) {
return wrapSubqueryConditionally(generateSubquery(sizeArg), aggregateFunctionContext);
} else {
// we have to change all transformed expressions to subqueries
for (TransformedExpressionEntry transformedExpressionEntry : transformedExpressions) {
PathExpression originalSizeArg = transformedExpressionEntry.getOriginalSizeArg();
Expression subquery = wrapSubqueryConditionally(generateSubquery(originalSizeArg), transformedExpressionEntry.isAggregateFunctionContext());
transformedExpressionEntry.getParentModifier().set(subquery);
}
transformedExpressions.clear();
requiredGroupBys.clear();
lateJoins.clear();
distinctRequired = false;
if (currentJoinDepth == sizeArgJoinDepth) {
return wrapSubqueryConditionally(generateSubquery(sizeArg), aggregateFunctionContext);
}
}
}
for (PathExpression groupByExpr : groupByExprs) {
joinManager.implicitJoin(groupByExpr, true, true, true, null, null, new HashSet<String>(), false, false, false, false);
}
PathExpression originalSizeArg = sizeArg.copy(ExpressionCopyContext.EMPTY);
originalSizeArg.setPathReference(sizeArg.getPathReference());
sizeArg.setUsedInCollectionFunction(false);
List<Expression> countArguments = new ArrayList<>();
String joinLookupKey = getJoinLookupKey(sizeArg);
LateJoinEntry lateJoin = lateJoins.get(joinLookupKey);
if (lateJoin == null) {
lateJoin = new LateJoinEntry();
lateJoins.put(joinLookupKey, lateJoin);
}
lateJoin.getExpressionsToJoin().add(sizeArg);
lateJoin.getClauseDependencies().add(clause);
if ((isElementCollection && collectionType != PluralAttribute.CollectionType.MAP) || collectionType == PluralAttribute.CollectionType.SET) {
if (IDENTIFIABLE_PERSISTENCE_TYPES.contains(targetAttribute.getElementType().getPersistenceType()) && targetAttribute.isCollection()) {
// append id attribute name of joinable size argument
PluralAttribute<?, ?, ?> sizeArgTargetAttribute = (PluralAttribute<?, ?, ?>) JpaMetamodelUtils.getAttribute(startType, sizeArg.getPathReference().getField());
for (Attribute<?, ?> idAttribute : JpaMetamodelUtils.getIdAttributes(((IdentifiableType<?>) sizeArgTargetAttribute.getElementType()))) {
List<PathElementExpression> pathElementExpressions = new ArrayList<>(sizeArg.getExpressions().size() + 1);
pathElementExpressions.addAll(sizeArg.getExpressions());
pathElementExpressions.add(new PropertyExpression(idAttribute.getName()));
PathExpression pathExpression = new PathExpression(pathElementExpressions);
countArguments.add(pathExpression);
lateJoin.getExpressionsToJoin().add(pathExpression);
}
} else {
countArguments.add(sizeArg);
}
} else {
sizeArg.setCollectionQualifiedPath(true);
if (collectionType == PluralAttribute.CollectionType.LIST) {
countArguments.add(new ListIndexExpression(sizeArg));
} else {
countArguments.add(new MapKeyExpression(sizeArg));
}
}
AggregateExpression countExpr = createCountFunction(distinctRequired, countArguments);
transformedExpressions.add(new TransformedExpressionEntry(countExpr, originalSizeArg, parentModifier, aggregateFunctionContext));
currentJoinNode = (JoinNode) originalSizeArg.getBaseNode();
if (!distinctRequired) {
if (lateJoins.size() + joinManager.getCollectionJoins().size() > 1) {
distinctRequired = true;
/*
* As soon as we encounter another collection join, set previously
* performed transformations to distinct.
*/
for (TransformedExpressionEntry transformedExpressionEntry : transformedExpressions) {
AggregateExpression transformedExpr = transformedExpressionEntry.getTransformedExpression();
if (ExpressionUtils.isCustomFunctionInvocation(transformedExpr) && AbstractCountFunction.FUNCTION_NAME.equalsIgnoreCase(((StringLiteral) transformedExpr.getExpressions().get(0)).getValue())) {
Expression possibleDistinct = transformedExpr.getExpressions().get(1);
if (!(possibleDistinct instanceof StringLiteral) || !AbstractCountFunction.DISTINCT_QUALIFIER.equals(((StringLiteral) possibleDistinct).getValue())) {
transformedExpr.getExpressions().add(1, new StringLiteral(AbstractCountFunction.DISTINCT_QUALIFIER));
}
} else {
transformedExpr.setDistinct(true);
}
}
}
}
for (Expression groupByExpr : groupByExprs) {
String groupByExprString = groupByExpr.toString();
ResolvedExpression resolvedExpression = new ResolvedExpression(groupByExprString, groupByExpr);
Set<ClauseType> clauseTypes = requiredGroupBys.get(resolvedExpression);
if (clauseTypes == null) {
requiredGroupBys.put(resolvedExpression, EnumSet.of(clause));
} else {
clauseTypes.add(clause);
}
}
return countExpr;
}
}
Aggregations