@Override public void visit(StringLiteral expression) { TypeUtils.STRING_CONVERTER.appendTo(expression.getValue(), sb); }
@Override public Expression clone(boolean resolved) { return new StringLiteral(value); }
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));
@Override public void visit(StringLiteral expression) { TypeUtils.STRING_CONVERTER.appendTo(expression.getValue(), sb); }
@Override public Expression clone(boolean resolved) { return new StringLiteral(value); }
private String getJoinAlias(ArrayExpression expr) { StringBuilder sb = new StringBuilder(expr.getBase().toString()); Expression indexExpr = expr.getIndex(); if (indexExpr instanceof ParameterExpression) { ParameterExpression indexParamExpr = (ParameterExpression) indexExpr; sb.append('_'); sb.append(indexParamExpr.getName()); } else if (indexExpr instanceof PathExpression) { PathExpression indexPathExpr = (PathExpression) indexExpr; sb.append('_'); sb.append(((JoinNode) indexPathExpr.getBaseNode()).getAliasInfo().getAlias()); if (indexPathExpr.getField() != null) { sb.append('_'); sb.append(indexPathExpr.getField().replaceAll("\\.", "_")); } } else if (indexExpr instanceof NumericLiteral) { sb.append('_'); sb.append(((NumericLiteral) indexExpr).getValue()); } else if (indexExpr instanceof StringLiteral) { sb.append('_'); sb.append(((StringLiteral) indexExpr).getValue()); } else { throw new IllegalStateException("Invalid array index expression " + indexExpr.toString()); } return sb.toString(); }
private AggregateExpression createCountFunction(boolean distinct, List<Expression> countTupleArguments) { countTupleArguments.add(0, new StringLiteral(AbstractCountFunction.FUNCTION_NAME.toUpperCase())); if (distinct) { countTupleArguments.add(1, new StringLiteral(AbstractCountFunction.DISTINCT_QUALIFIER)); } return new AggregateExpression(false, "FUNCTION", countTupleArguments); }
@Override public void visit(FunctionExpression expression) { String name = expression.getFunctionName(); if ("FUNCTION".equalsIgnoreCase(name)) { // Skip the function name resolveFirst(expression.getExpressions().subList(1, expression.getExpressions().size()), true); resolveToFunctionReturnType(((StringLiteral) expression.getExpressions().get(0)).getValue()); } else if (ExpressionUtils.isSizeFunction(expression)) { // According to our grammar, we can only get a path here currentPosition.setAttribute(null); currentPosition.setCurrentType(metamodel.type(Long.class)); } else { resolveFirst(expression.getExpressions(), true); resolveToFunctionReturnType(name); } }
private Expression wrapSubqueryConditionally(SubqueryExpression subquery, boolean wrap) { if (wrap) { // we need to wrap subqueries in aggregate functions in COALESCE to trick the Hibernate parser // see https://hibernate.atlassian.net/browse/HHH-9331 List<Expression> subqueryFunctionArguments = new ArrayList<>(1); subqueryFunctionArguments.add(new StringLiteral(SubqueryFunction.FUNCTION_NAME)); subqueryFunctionArguments.add(subquery); return new FunctionExpression("FUNCTION", subqueryFunctionArguments); } else { return subquery; } }
String functionName; if (ExpressionUtils.isFunctionFunctionExpression(expression)) { functionName = ((StringLiteral) expression.getExpressions().get(0)).getValue(); } else { functionName = expression.getFunctionName();
@Override public Expression createExpression(String field) { 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 (valuesTypeName != null) { return new FunctionExpression("FUNCTION", Arrays.asList( new StringLiteral("TREAT_" + valuesTypeName.toUpperCase()), new PathExpression(pathElements) )); } else { return new PathExpression(pathElements); } }
setOperationArgs.add(new StringLiteral("SET_" + operationManager.getOperator().name())); setOperationArgs.add(asExpression(operationManager.getStartQueryBuilder())); setOperationArgs.add(new StringLiteral("ORDER_BY")); setOperationArgs.add(new StringLiteral(orderByElements.get(i).toString())); setOperationArgs.add(new StringLiteral("LIMIT")); setOperationArgs.add(new NumericLiteral(Integer.toString(operationBuilder.maxResults), NumericType.INTEGER)); setOperationArgs.add(new StringLiteral("OFFSET")); setOperationArgs.add(new NumericLiteral(Integer.toString(operationBuilder.firstResult), NumericType.INTEGER)); for (EntityFunctionNode node : queryBuilder.getEntityFunctionNodes(null)) { List<Expression> arguments = new ArrayList<Expression>(2); arguments.add(new StringLiteral("ENTITY_FUNCTION")); arguments.add(expression); arguments.add(new StringLiteral(entityName)); arguments.add(new StringLiteral(valuesClause)); arguments.add(new StringLiteral(valuesAliases == null ? "" : valuesAliases)); arguments.add(new StringLiteral(syntheticPredicate)); final boolean hasMaxResults = queryBuilder.getMaxResults() != Integer.MAX_VALUE; List<Expression> arguments = new ArrayList<Expression>(2); arguments.add(new StringLiteral("LIMIT")); arguments.add(expression);
@Override public Expression visitEscape_character(Escape_characterContext ctx) { if (ctx.Character_literal() != null) { return new StringLiteral(unquote(ctx.Character_literal().getText())); } else { return super.visitEscape_character(ctx); } }
@Override public Expression visitEscape_character(Escape_characterContext ctx) { if (ctx.Character_literal() != null) { return new StringLiteral(unquote(ctx.Character_literal().getText())); } else { return super.visitEscape_character(ctx); } }
@Override public Expression visitString_literal(String_literalContext ctx) { String literalValue = ctx.String_literal() == null ? ctx.Character_literal().getText() : ctx.String_literal().getText(); // strip quotes return new StringLiteral(unquote(literalValue)); }
@Override public Expression visitString_literal(String_literalContext ctx) { String literalValue = ctx.String_literal() == null ? ctx.Character_literal().getText() : ctx.String_literal().getText(); // strip quotes return new StringLiteral(unquote(literalValue)); }