public Object getValueAt(int row, int column) { Ordering ordering = getOrdering(row); switch (column) { case 0: return ordering.getSortSpecString(); case 1: return ordering.isAscending() ? Boolean.TRUE : Boolean.FALSE; case 2: return ordering.isCaseInsensitive() ? Boolean.TRUE : Boolean.FALSE; default: throw new IndexOutOfBoundsException("Invalid column: " + column); } }
public void addOrdering(String path, String descending, String ignoreCase) { if (orderings == null) { orderings = new ArrayList(); } if (path != null && path.trim().length() == 0) { path = null; } boolean isDescending = "true".equalsIgnoreCase(descending); boolean isIgnoringCase = "true".equalsIgnoreCase(ignoreCase); orderings.add(new Ordering(path, !isDescending, isIgnoringCase)); }
/** * @since 4.0 */ public <E> List<E> orderedList(Collection<E> objects) { List<E> newList = new ArrayList<>(objects); orderList(newList); return newList; }
/** * @since 4.0 */ public Ordering(Expression sortSpec, SortOrder sortOrder) { setSortSpec(sortSpec); setSortOrder(sortOrder); }
void addOrdering() { String orderingPath = getSelectedPath(); if (orderingPath == null) { return; } // check if such ordering already exists for (Ordering ord : selectQuery.getOrderings()) { if (orderingPath.equals(ord.getSortSpecString())) { return; } } selectQuery.addOrdering(new Ordering(orderingPath, SortOrder.ASCENDING)); int index = selectQuery.getOrderings().size() - 1; OrderingModel model = (OrderingModel) table.getModel(); model.fireTableRowsInserted(index, index); mediator.fireQueryEvent(new QueryEvent(SelectQueryOrderingTab.this, selectQuery)); }
@Test public void testSelectRequest_Sort() { SelectContext<E2> context = new SelectContext<>(E2.class); Sort sort = new Sort(Arrays.asList( new Sort("name", Dir.DESC), new Sort("address", Dir.ASC))); context.setRawRequest(AgRequest.builder().sort(sort).build()); createEntityStage.execute(context); ResourceEntity<E2> resourceEntity = context.getEntity(); assertEquals(2, resourceEntity.getOrderings().size()); Iterator<Ordering> it = resourceEntity.getOrderings().iterator(); Ordering o1 = it.next(); Ordering o2 = it.next(); assertEquals(SortOrder.DESCENDING, o1.getSortOrder()); assertEquals("name", o1.getSortSpecString()); assertEquals(SortOrder.ASCENDING, o2.getSortOrder()); assertEquals("address", o2.getSortSpecString()); }
void validateOrdering( QueryDescriptor query, Entity root, Ordering ordering, ValidationResult validationResult) { // validate paths in ordering String path = ordering.getSortSpecString(); Iterator<CayenneMapEntry> it = root.resolvePathComponents(path); while (it.hasNext()) { try { it.next(); } catch (ExpressionException e) { addFailure(validationResult, query, "Invalid ordering path: '%s'", path); } } }
if (ord.isCaseInsensitive()) { ordComp.append("UPPER("); Expression exp = ord.getSortSpec(); if (ord.isCaseInsensitive()) { ordComp.append(")"); if (!ord.isAscending()) { buf.append(" DESC");
/** * Encodes itself as a query ordering. * * @since 1.1 */ @Override public void encodeAsXML(XMLEncoder encoder) { encoder.print("<ordering"); if (isDescending()) { encoder.print(" descending=\"true\""); } if (isCaseInsensitive()) { encoder.print(" ignore-case=\"true\""); } encoder.print(">"); if (getSortSpec() != null) { getSortSpec().encodeAsXML(encoder); } encoder.println("</ordering>"); }
@Override public String toString() { StringWriter buffer = new StringWriter(); PrintWriter pw = new PrintWriter(buffer); XMLEncoder encoder = new XMLEncoder(pw); encodeAsXML(encoder); pw.close(); buffer.flush(); return buffer.toString(); }
/** * Returns true if the sorting is done in descending order. * * @since 3.0 */ public boolean isDescending() { return !isAscending(); }
protected void validateOrdering( Entity entity, Ordering ordering, ProjectPath path, Validator validator) { if (ordering == null) { return; } try { testExpression(entity, ordering.getSortSpec()); } catch (ExpressionException e) { validator .registerWarning(buildValidationMessage(e, "Invalid ordering"), path); } }
public Ordering(Expression sortExpression, boolean ascending, boolean caseInsensitive) { setSortSpec(sortExpression); this.ascending = ascending; this.caseInsensitive = caseInsensitive; }
private void collectOrdering(ResourceEntity<?> resourceEntity, Sort sort) { String property = sort.getProperty(); if (property != null && !property.isEmpty()) { // TODO: do we need to support nested ID? AgEntity<?> entity = resourceEntity.getAgEntity(); // note using "toString" instead of "getPath" to convert ASTPath to // String representation. This ensures "db:" prefix is preserved if // present property = pathCache.getPathDescriptor(entity, new ASTObjPath(sort.getProperty())).getPathExp().toString(); // check for dupes... for (Ordering o : resourceEntity.getOrderings()) { if (property.equals(o.getSortSpecString())) { return; } } Dir direction = sort.getDirection(); if (direction == null) { direction = Dir.ASC; } SortOrder so = direction == Dir.ASC ? SortOrder.ASCENDING : SortOrder.DESCENDING; resourceEntity.getOrderings().add(new Ordering(property, so)); } } }
@Test public void testSelectRequest_SortSimple_NoDir() { SelectContext<E2> context = new SelectContext<>(E2.class); Sort sort = new Sort(E2.NAME.getName()); context.setRawRequest(AgRequest.builder().sort(sort).build()); createEntityStage.execute(context); ResourceEntity<E2> resourceEntity = context.getEntity(); assertEquals(1, resourceEntity.getOrderings().size()); Ordering o1 = resourceEntity.getOrderings().iterator().next(); assertEquals(SortOrder.ASCENDING, o1.getSortOrder()); assertEquals(E2.NAME.getName(), o1.getSortSpecString()); }
for(Ordering ordering: ((SelectQuery)query).getOrderings()) { String path = ordering.getSortSpecString(); Iterator<CayenneMapEntry> it = ((ObjEntity)query.getRoot()).resolvePathComponents(path); while (it.hasNext()) {
if (ord.isCaseInsensitive()) { out.append("UPPER("); Expression exp = ord.getSortSpec(); if (ord.isCaseInsensitive()) { out.append(")"); if (!ord.isAscending()) { mainBuffer.append(" DESC");
public String toString() { StringWriter buffer = new StringWriter(); PrintWriter pw = new PrintWriter(buffer); XMLEncoder encoder = new XMLEncoder(pw); encodeAsXML(encoder); pw.close(); buffer.flush(); return buffer.toString(); } }
/** * Encodes itself as a query ordering. * * @since 1.1 */ public void encodeAsXML(XMLEncoder encoder) { encoder.print("<ordering"); if (!ascending) { encoder.print(" descending=\"true\""); } if (caseInsensitive) { encoder.print(" ignore-case=\"true\""); } encoder.print(">"); if (getSortSpec() != null) { getSortSpec().encodeAsXML(encoder); } encoder.println("</ordering>"); }
/** * Add an ascending ordering on the given property. If there is already an ordering * on this query then add this ordering with a lower priority. * * @param property the property to sort on * @return this object */ public ColumnSelect<T> orderBy(String property) { return orderBy(new Ordering(property)); }