/** * Check input parameter. * * @param expression * the expression * @return the string */ private String checkInputParameter(Expression expression) { return (expression instanceof InputParameter) ? kunderaQuery.getParametersMap() .get((expression).toParsedText()).toString() : expression.toParsedText().toString(); }
Object inValues = kunderaQuery.getParametersMap().get(inClauseValues.toParsedText()); log.debug(inClauseValues.toParsedText() + "named parameter found in query, Replacing parameter with " + inValues); : (Collection) kunderaQuery.getParametersMap().get(inClauseValues.toParsedText()); inParameterCollection.add(value.toParsedText()); throw new KunderaException(inClauseValues.toParsedText() + " not supported for IN clause");
if (((Map) obj).get(expression.toParsedText()) != null) temp.add(((Map) obj).get(expression.toParsedText())); temp.add(getEntityFieldValue(m, entity, expression.toParsedText()));
/** * Builds the records. * * @param iterable * the iterable * @param internalAgg * the internal agg * @return the map */ private Map<String, Object> buildRecords(ListIterable<Expression> iterable, InternalAggregations internalAgg) { Map<String, Object> temp = new HashMap<>(); Iterator<Expression> itr = iterable.iterator(); while (itr.hasNext()) { Expression exp = itr.next(); if (AggregateFunction.class.isAssignableFrom(exp.getClass())) { Object value = getAggregatedResult(internalAgg, ((AggregateFunction) exp).getIdentifier(), exp); if (!value.toString().equalsIgnoreCase(ESConstants.INFINITY)) { temp.put(exp.toParsedText(), Double.valueOf(value.toString())); } } } return temp; }
/** * Populate like query. * * @param likeExpression * the like expression * @param metadata * the metadata * @return the filter builder */ private QueryBuilder populateLikeQuery(LikeExpression likeExpression, EntityMetadata metadata) { Expression patternValue = likeExpression.getPatternValue(); String field = likeExpression.getStringExpression().toString(); String likePattern = (patternValue instanceof InputParameter) ? kunderaQuery.getParametersMap() .get((patternValue).toParsedText()).toString() : patternValue.toParsedText().toString(); String jpaField = getField(field); log.debug("Pattern value for field " + field + " is: " + patternValue); QueryBuilder filterBuilder = getQueryBuilder(kunderaQuery.new FilterClause(jpaField, Expression.LIKE, likePattern, field), metadata); return filterBuilder; }
/** * Process order by clause. * * @param termsBuilder * the terms builder * @param orderByExpression * the order by expression * @param groupByClause * the group by clause * @param entityMetadata * the entity metadata */ private void processOrderByClause(TermsBuilder termsBuilder, Expression orderByExpression, Expression groupByClause, EntityMetadata entityMetadata) { Expression orderByClause = (OrderByClause) orderByExpression; OrderByItem orderByItems = (OrderByItem) ((OrderByClause) orderByClause).getOrderByItems(); if (orderByClause instanceof CollectionExpression || !(orderByItems.getExpression().toParsedText().equalsIgnoreCase(groupByClause.toParsedText()))) { logger.error("Order by and group by on different field are not supported simultaneously"); throw new UnsupportedOperationException( "Order by and group by on different field are not supported simultaneously"); } String ordering = orderByItems.getOrdering().toString(); termsBuilder.order(Terms.Order.term(!ordering.equalsIgnoreCase(Expression.DESC))); }
/** * Populate filter clause. * * @param conditionalExpression * the conditional expression * @return the filter clause */ private FilterClause populateFilterClause(ComparisonExpression conditionalExpression) { String property = ((StateFieldPathExpression) conditionalExpression.getLeftExpression()).getPath(1); String condition = conditionalExpression.getComparisonOperator(); Expression rightExpression = conditionalExpression.getRightExpression(); Object value = (rightExpression instanceof InputParameter) ? kunderaQuery.getParametersMap().get( (rightExpression).toParsedText()) : rightExpression.toParsedText(); return (condition != null && property != null) ? kunderaQuery.new FilterClause(property, condition, value, property) : null; }
if (aggregations.get(expression.toParsedText()) != null) results.add(aggregations.get(expression.toParsedText()));
/** * Gets the aggregated result. * * @param internalAggs * the internal aggs * @param identifier * the identifier * @param exp * the exp * @return the aggregated result */ private Object getAggregatedResult(InternalAggregations internalAggs, String identifier, Expression exp) { switch (identifier) { case Expression.MIN: return (((InternalMin) internalAggs.get(exp.toParsedText())).getValue()); case Expression.MAX: return (((InternalMax) internalAggs.get(exp.toParsedText())).getValue()); case Expression.AVG: return (((InternalAvg) internalAggs.get(exp.toParsedText())).getValue()); case Expression.SUM: return (((InternalSum) internalAggs.get(exp.toParsedText())).getValue()); case Expression.COUNT: return (((InternalValueCount) internalAggs.get(exp.toParsedText())).getValue()); } throw new KunderaException("No support for " + identifier + " aggregation."); }
(boundExpression).toParsedText()) : boundExpression.toParsedText(); return value.toString();
/** * Populate IN query filter. * * @param inExpression * the in expression * @param metadata * the metadata * @return the filter builder */ private QueryBuilder populateInQuery(InExpression inExpression, EntityMetadata metadata) { String property = getField(inExpression.getExpression().toParsedText()); Expression inItemsParameter = inExpression.getInItems(); log.debug("IN query parameters for field " + property + " is: " + inItemsParameter); Iterable inItemsIterable = getInValuesCollection(inItemsParameter); return getFilter(kunderaQuery.new FilterClause(property, Expression.IN, inItemsIterable, property), metadata); }
log.error(condtionalExp.toParsedText() + "found in where clause. Not supported in elasticsearch."); throw new KunderaException(condtionalExp.toParsedText() + " not supported in ElasticSearch");
/** * Append aggregation. * * @param collectionExpression * the collection expression * @param entityMetadata * the entity metadata * @param nestedAggregation * @param aggregationBuilder * the aggregation builder * @return the filter aggregation builder */ private AggregationBuilder appendAggregation(CollectionExpression collectionExpression, EntityMetadata entityMetadata, AggregationBuilder aggregationBuilder) { ListIterable<Expression> functionlist = collectionExpression.children(); for (Expression function : functionlist) { if (isAggregationExpression(function) && checkIfKeyExists(function.toParsedText())) { aggregationBuilder.subAggregation(getMetricsAggregation(function, entityMetadata)); } } return aggregationBuilder; }
return checkIfKeyExists(expression.toParsedText()) ? aggregationBuilder .subAggregation(getMetricsAggregation(expression, entityMetadata)) : aggregationBuilder;
expression); String rightValue = ((ComparisonExpression) conditionalExpression).getRightExpression().toParsedText(); return validateBucket(leftValue.toString(), rightValue, ((ComparisonExpression) conditionalExpression).getIdentifier());
/** * Builds the select aggregations. * * @param selectStatement * the select statement * @param entityMetadata * the entity metadata * @param filter * the filter * @return the filter aggregation builder */ private AggregationBuilder buildSelectAggregations(AggregationBuilder aggregationBuilder, SelectStatement selectStatement, EntityMetadata entityMetadata) { Expression expression = ((SelectClause) selectStatement.getSelectClause()).getSelectExpression(); if (expression instanceof CollectionExpression) { aggregationBuilder = appendAggregation((CollectionExpression) expression, entityMetadata, aggregationBuilder); } else { if (isAggregationExpression(expression) && checkIfKeyExists(expression.toParsedText())) aggregationBuilder.subAggregation(getMetricsAggregation(expression, entityMetadata)); } return aggregationBuilder; }
builder.addSort(KunderaCoreUtils.getJPAColumnName(orderByItem.getExpression().toParsedText(), entityMetadata, metaModel), SortOrder.valueOf(ordering));
/** * Adds the sort order. * * @param builder * the builder * @param query * the query * @param entityMetadata * the entity metadata */ private void addSortOrder(SearchRequestBuilder builder, KunderaQuery query, EntityMetadata entityMetadata) { MetamodelImpl metaModel = (MetamodelImpl) kunderaMetadata.getApplicationMetadata() .getMetamodel(entityMetadata.getPersistenceUnit()); List<OrderByItem> orderList = KunderaQueryUtils.getOrderByItems(query.getJpqlExpression()); for (OrderByItem orderByItem : orderList) { String ordering = orderByItem.getOrdering().toString(); if (ordering.equalsIgnoreCase(ESConstants.DEFAULT)) { ordering = Expression.ASC; } builder.addSort(KunderaCoreUtils.getJPAColumnName(orderByItem.getExpression().toParsedText(), entityMetadata, metaModel), SortOrder.valueOf(ordering)); } }
/** * Populate between filter. * * @param betweenExpression * the between expression * @param m * the m * @param entity * the entity * @return the filter builder */ private QueryBuilder populateBetweenFilter(BetweenExpression betweenExpression, EntityMetadata m) { String lowerBoundExpression = getBetweenBoundaryValues(betweenExpression.getLowerBoundExpression()); String upperBoundExpression = getBetweenBoundaryValues(betweenExpression.getUpperBoundExpression()); String field = getField(betweenExpression.getExpression().toParsedText()); log.debug("Between clause for field " + field + "with lower bound " + lowerBoundExpression + "and upper bound " + upperBoundExpression); return new AndQueryBuilder(getFilter(kunderaQuery.new FilterClause(field, Expression.GREATER_THAN_OR_EQUAL, lowerBoundExpression, field), m), getFilter(kunderaQuery.new FilterClause(field, Expression.LOWER_THAN_OR_EQUAL, upperBoundExpression,field), m)); }
String jPAField = KunderaCoreUtils.getJPAColumnName(groupByClause.toParsedText(), entityMetadata, metaModel); TermsBuilder termsBuilder = AggregationBuilders.terms(ESConstants.GROUP_BY).field(jPAField).size(0);