private Property parseProperty(String chunk) { String[] pairs = chunk.split(" "); if (pairs.length == 0) { return null; } ArrayList<String> wordList = new ArrayList<>(pairs.length); for (String pair : pairs) { if (!isEmptyString(pair)) { wordList.add(pair); } } if (wordList.isEmpty()) { return null; } if (wordList.size() == 1) { return new Property(wordList.get(0), true); } if (wordList.size() == 2) { boolean asc = isAscending(wordList.get(1)); return new Property(wordList.get(0), asc); } if (wordList.size() == 4) { // nulls high or nulls low as 3rd and 4th boolean asc = isAscending(wordList.get(1)); return new Property(wordList.get(0), asc, wordList.get(2), wordList.get(3)); } return new Property(chunk.trim(), true); }
private List<OrmQueryProperties> removeQueryJoins() { List<OrmQueryProperties> queryJoins = detail.removeSecondaryQueries(); if (queryJoins != null) { if (orderBy != null) { // remove any orderBy properties that relate to // paths of the secondary queries for (OrmQueryProperties joinPath : queryJoins) { // loop through the orderBy properties and // move any ones related to the query join List<Property> properties = orderBy.getProperties(); Iterator<Property> it = properties.iterator(); while (it.hasNext()) { Property property = it.next(); if (property.getProperty().startsWith(joinPath.getPath())) { // remove this orderBy segment and // add it to the secondary join it.remove(); joinPath.addSecJoinOrderProperty(property); } } } } } return queryJoins; }
/** * Return a copy of this OrderBy with the path trimmed. */ public OrderBy<T> copyWithTrim(String path) { List<Property> newList = new ArrayList<>(list.size()); for (Property aList : list) { newList.add(aList.copyWithTrim(path)); } return new OrderBy<>(newList); }
private static Property parseOrderProperty(String[] pairs) { if (pairs.length == 0) { return null; } ArrayList<String> wordList = Lists.newArrayListWithCapacity(pairs.length); for (String pair : pairs) { if (StringUtils.isNotBlank(pair)) { wordList.add(pair); } } if (wordList.isEmpty()) { return null; } String field = wordList.get(0); if (wordList.size() == 1) { if (field.startsWith("-")) { return new Property(field.substring(1), false); } else { return new Property(field, true); } } if (wordList.size() == 2) { boolean asc = isOrderAscending(wordList.get(1)); return new Property(field, asc); } throw new UnprocessableEntityException( Messages.get("info.query.orderby1.unprocessable.entity", Arrays.toString(pairs), wordList.size()) ); }
private Property parseProperty(String chunk) { String[] pairs = chunk.split(" "); if (pairs.length == 0) { return null; } ArrayList<String> wordList = new ArrayList<>(pairs.length); for (String pair : pairs) { if (!isEmptyString(pair)) { wordList.add(pair); } } if (wordList.isEmpty()) { return null; } if (wordList.size() == 1) { return new Property(wordList.get(0), true); } if (wordList.size() == 2) { boolean asc = isAscending(wordList.get(1)); return new Property(wordList.get(0), asc); } if (wordList.size() == 4) { // nulls high or nulls low as 3rd and 4th boolean asc = isAscending(wordList.get(1)); return new Property(wordList.get(0), asc, wordList.get(2), wordList.get(3)); } return new Property(chunk.trim(), true); }
private List<OrmQueryProperties> removeQueryJoins() { List<OrmQueryProperties> queryJoins = detail.removeSecondaryQueries(); if (queryJoins != null) { if (orderBy != null) { // remove any orderBy properties that relate to // paths of the secondary queries for (OrmQueryProperties joinPath : queryJoins) { // loop through the orderBy properties and // move any ones related to the query join List<Property> properties = orderBy.getProperties(); Iterator<Property> it = properties.iterator(); while (it.hasNext()) { Property property = it.next(); if (property.getProperty().startsWith(joinPath.getPath())) { // remove this orderBy segment and // add it to the secondary join it.remove(); joinPath.addSecJoinOrderProperty(property); } } } } } return queryJoins; }
@Override public void enterOrderby_property(EQLParser.Orderby_propertyContext ctx) { int childCount = ctx.getChildCount(); String path = child(ctx, 0); boolean asc = true; String nulls = null; String nullsFirstLast = null; if (childCount == 3) { asc = child(ctx, 1).startsWith(ASC); nullsFirstLast = ctx.getChild(2).getChild(1).getText(); nulls = NULLS; } else if (childCount == 2) { String firstChild = child(ctx, 1); if (firstChild.startsWith(NULLS)) { nullsFirstLast = ctx.getChild(1).getChild(1).getText(); nulls = NULLS; } else { asc = firstChild.startsWith(ASC); } } query.orderBy().add(new OrderBy.Property(path, asc, nulls, nullsFirstLast)); }
/** * Validate all the expression properties/paths given the bean descriptor. */ @Override public Set<String> validate(BeanType<T> desc) { SpiExpressionValidation validation = new SpiExpressionValidation(desc); if (whereExpressions != null) { whereExpressions.validate(validation); } if (havingExpressions != null) { havingExpressions.validate(validation); } if (orderBy != null) { for (Property property : orderBy.getProperties()) { validation.validate(property.getProperty()); } } return validation.getUnknownProperties(); }
/** * <p>validate.</p> * * @param orderBy a {@link io.ebean.OrderBy} object. * @param validation a {@link ameba.db.ebean.internal.ListExpressionValidation} object. * @param ignoreUnknown a boolean. */ public static void validate(OrderBy<?> orderBy, ListExpressionValidation validation, boolean ignoreUnknown) { if (orderBy == null) return; Iterator<Property> it = orderBy.getProperties().iterator(); while (it.hasNext()) { validation.validate(it.next().getProperty()); if (ignoreUnknown && !validation.lastValid()) { it.remove(); } } }
/** * Returns the OrderBy in string format. */ public String toStringFormat() { if (list.isEmpty()) { return null; } StringBuilder sb = new StringBuilder(); for (int i = 0; i < list.size(); i++) { Property property = list.get(i); if (i > 0) { sb.append(", "); } sb.append(property.toStringFormat()); } return sb.toString(); }
private String parseProperty(Property p) { String propName = p.getProperty(); ElPropertyValue el = desc.getElGetValue(propName); if (el == null) { return p.toStringFormat(); } BeanProperty beanProperty = el.getBeanProperty(); if (beanProperty instanceof BeanPropertyAssoc<?>) { BeanPropertyAssoc<?> ap = (BeanPropertyAssoc<?>) beanProperty; IdBinder idBinder = ap.getTargetDescriptor().getIdBinder(); return idBinder.getOrderBy(el.getElName(), p.isAscending()); } return p.toStringFormat(); } }
/** * Return true if the property is known to be contained in the order by clause. */ public boolean containsProperty(String propertyName) { for (Property aList : list) { if (propertyName.equals(aList.getProperty())) { return true; } } return false; }
/** * Reverse the ascending/descending order on all the properties. */ public void reverse() { for (Property aList : list) { aList.reverse(); } }
/** * Return a copy of this OrderBy with the path trimmed. */ public OrderBy<T> copyWithTrim(String path) { List<Property> newList = new ArrayList<>(list.size()); for (Property aList : list) { newList.add(aList.copyWithTrim(path)); } return new OrderBy<>(newList); }
@Override public String toString() { return toStringFormat(); }
/** * Return a copy of this property. */ public Property copy() { return new Property(property, ascending, collation, nulls, highLow); }
/** * Add a property with ascending order to this OrderBy. */ public Query<T> asc(String propertyName, String collation) { list.add(new Property(propertyName, true, collation)); return query; }
/** * Add a property with ascending order to this OrderBy. */ public Query<T> asc(String propertyName) { list.add(new Property(propertyName, true)); return query; }
/** * Return a copy of this Property with the path trimmed. */ public Property copyWithTrim(String path) { return new Property(property.substring(path.length() + 1), ascending, collation, nulls, highLow); }
/** * Add a property with descending order to this OrderBy. */ public Query<T> desc(String propertyName, String collation) { list.add(new Property(propertyName, false, collation)); return query; }