@Override public int compare(Object o1, Object o2) { Object v1 = OwsUtils.get(o1, sortOrder.getPropertyName().getPropertyName()); Object v2 = OwsUtils.get(o2, sortOrder.getPropertyName().getPropertyName()); if (v1 == null) { if (v2 == null) { return 0; } else { return -1; } } else if (v2 == null) { return 1; } Comparable c1 = (Comparable) v1; Comparable c2 = (Comparable) v2; return c1.compareTo(c2); } };
@Override public <T extends CatalogInfo> CloseableIterator<T> list( final Class<T> of, final Filter filter, @Nullable Integer offset, @Nullable Integer count, @Nullable SortBy... sortOrder) { if (sortOrder != null) { for (SortBy so : sortOrder) { if (sortOrder != null && !canSort(of, so.getPropertyName().getPropertyName())) { throw new IllegalArgumentException( "Can't sort objects of type " + of.getName() + " by " + so.getPropertyName()); } } } Iterable<T> iterable = iterable(of, filter, sortOrder); if (offset != null && offset.intValue() > 0) { iterable = Iterables.skip(iterable, offset.intValue()); } if (count != null && count.intValue() >= 0) { iterable = Iterables.limit(iterable, count.intValue()); } Iterator<T> iterator = iterable.iterator(); return new CloseableIteratorAdapter<T>(iterator); }
@Override public <T extends CatalogInfo> CloseableIterator<T> list( final Class<T> of, final Filter filter, Integer offset, Integer count, SortBy sortOrder) { CatalogFacade facade = getFacade(); if (sortOrder != null && !facade.canSort(of, sortOrder.getPropertyName().getPropertyName())) { // TODO: use GeoTools' merge-sort code to provide sorting anyways throw new UnsupportedOperationException( "Catalog backend can't sort on property " + sortOrder.getPropertyName() + " in-process sorting is pending implementation"); } return facade.list(of, filter, offset, count, sortOrder); }
private <T extends CatalogInfo> void testOrderBy( Class<T> clazz, Filter filter, Integer offset, Integer limit, SortBy sortOrder, List<T> expected) { CatalogPropertyAccessor pe = new CatalogPropertyAccessor(); List<Object> props = new ArrayList<Object>(); List<Object> actual = new ArrayList<Object>(); String sortProperty = sortOrder.getPropertyName().getPropertyName(); for (T info : expected) { Object pval = pe.getProperty(info, sortProperty); props.add(pval); } CloseableIterator<T> it = catalog.list(clazz, filter, offset, limit, sortOrder); try { while (it.hasNext()) { Object property = pe.getProperty(it.next(), sortProperty); actual.add(property); } } finally { it.close(); } assertEquals(props, actual); }
public Object getProperty(Object object, QName name) throws Exception { SortBy sortBy = (SortBy) object; if (OGC.PropertyName.equals(name)) { return sortBy.getPropertyName(); } if ("SortOrder".equals(name.getLocalPart())) { return sortBy.getSortOrder(); } return null; } }
/** * Returns all the properties used in the sortBy (excluding primary keys and the like, e.g., * natural sorting) * * @param sortBy * @return */ private Set<String> getSortPropertyNames(SortBy[] sortBy) { Set<String> result = new HashSet<>(); for (SortBy sort : sortBy) { PropertyName p = sort.getPropertyName(); if (p != null && p.getPropertyName() != null) { result.add(p.getPropertyName()); } } return result; }
private String sortByToString(LiteFeatureTypeStyle style, Class[] classes) { StringBuilder sb = new StringBuilder("Layer ").append(style.layer.getTitle()).append("["); SortBy[] sortBy = style.sortBy; for (int i = 0; i < sortBy.length; i++) { SortBy curr = sortBy[i]; if (curr == SortBy.NATURAL_ORDER) { sb.append("NaturalOrder"); } else if (curr == SortBy.REVERSE_ORDER) { sb.append("ReverseNaturalOrder"); } else { sb.append(curr.getPropertyName().getPropertyName()); sb.append("(").append(classes[i].getSimpleName()).append(")"); if (curr.getSortOrder() == SortOrder.DESCENDING) { sb.append(" D"); } } if (i < sortBy.length) { sb.append(", "); } } sb.append("]"); return sb.toString(); }
/** * Extracts List of Sort attributes names from Query * * @param query * @return List of Sort attributes names */ public static List<String> getAttributesOnSort(Query query) { List<String> result = new ArrayList<>(); if (query.getSortBy() == null) return result; for (int i = 0; i < query.getSortBy().length; i++) { result.add(query.getSortBy()[i].getPropertyName().getPropertyName()); } return result; }
@SuppressWarnings("unchecked") protected int compare( SimpleFeature feature1, SimpleFeature feature2, SortBy order) { PropertyName name = order.getPropertyName(); Comparable value1 = (Comparable) name.evaluate(feature1); Comparable value2 = (Comparable) name.evaluate(feature2); if (value1 == value2) { return 0; } if (order.getSortOrder() == SortOrder.ASCENDING) { if (value1 == null) { return -1; } return value1.compareTo(value2); } else { if (value2 == null) { return -1; } return value2.compareTo(value1); } } });
LinkedHashSet<PropertyName> sortProperties = new LinkedHashSet<>(); for (SortBy sb : sortBy) { PropertyName pn = sb.getPropertyName(); if (pn != null) { sortProperties.add(pn);
protected SortBy[] unrollSortBy(SortBy[] sortArray) { if (sortArray == null) return null; ArrayList<SortBy> unrolledSorts = new ArrayList<>(); FilterFactory2 ff = CommonFactoryFinder.getFilterFactory2(GeoTools.getDefaultHints()); for (SortBy aSort : sortArray) { SortBy newSort = ff.sort( unrollIndex(aSort.getPropertyName(), mapping).getPropertyName(), aSort.getSortOrder()); unrolledSorts.add(newSort); } return unrolledSorts.toArray(new SortBy[] {}); }
transformed.add(sort); PropertyName pname = sort.getPropertyName(); Expression ex = expressions.get(pname.getPropertyName()); if (ex == null) {
prefix, getPropertyName(featureType, sort[i].getPropertyName()), sql); sql.append(order); sql.append(",");
comparators.add(new FidComparator(false)); } else { String name = sb.getPropertyName().getPropertyName(); boolean ascending = sb.getSortOrder() == SortOrder.ASCENDING; comparators.add(new PropertyComparator(name, ascending));
@Override public boolean supportsSorting(final SortBy[] sortAttributes) { final SimpleFeatureType featureType = typeInfo.getFeatureType(); for (SortBy sortBy : sortAttributes) { if (SortBy.NATURAL_ORDER == sortBy || SortBy.REVERSE_ORDER == sortBy) { // TODO: we should be able to support natural order return false; } else { String attName = sortBy.getPropertyName().getPropertyName(); AttributeDescriptor descriptor = featureType.getDescriptor(attName); if (descriptor == null) { return false; } if (descriptor instanceof GeometryDescriptor) { return false; } } } return true; } };
@Override public boolean supportsSorting(SortBy[] sortAttributes) { // we use external sorting if any of the sort attributes is computed for (SortBy sortBy : sortAttributes) { if (sortBy == SortBy.NATURAL_ORDER || sortBy == SortBy.REVERSE_ORDER) { // fine, we support this continue; } else { String pn = sortBy.getPropertyName().getPropertyName(); AttributeDescriptor descriptor = transformer.getSchema().getDescriptor(pn); if (descriptor == null) { return false; } else { Class<?> binding = descriptor.getType().getBinding(); if (!Comparable.class.isAssignableFrom(binding)) { if (LOGGER.isLoggable(Level.FINE)) { LOGGER.log( Level.FINE, "Can't sort on {0} because its property type {1} is not comparable", new Object[] {descriptor.getLocalName(), binding}); } return false; } } } } return true; } };
@Override public boolean supportsSorting(final SortBy[] sortAttributes) { if (super.supportsSorting(sortAttributes)) return true; for (int i = 0; i < sortAttributes.length; i++) { SortBy sortBy = sortAttributes[i]; if (SortBy.NATURAL_ORDER == sortBy || SortBy.REVERSE_ORDER == sortBy) { // we do only if we have a non null primary key return !(source.getPrimaryKey() instanceof NullPrimaryKey); } else { PropertyName propertyName = sortBy.getPropertyName(); SortOrder sortOrder = sortBy.getSortOrder(); if (!supportsPropertySorting(propertyName, sortOrder)) { return false; } } } return true; }
static final boolean canSort(SimpleFeatureType schema, SortBy[] sortBy) { if (sortBy == SortBy.UNSORTED) { return true; } // check all attributes are serializable for (AttributeDescriptor ad : schema.getAttributeDescriptors()) { Class<?> binding = ad.getType().getBinding(); if (!Serializable.class.isAssignableFrom(binding)) { return false; } } // check all sorting attributes are comparable for (SortBy sb : sortBy) { if (sb != SortBy.NATURAL_ORDER && sb != SortBy.REVERSE_ORDER) { AttributeDescriptor ad = schema.getDescriptor(sb.getPropertyName().getPropertyName()); if (ad == null) { return false; } Class<?> binding = ad.getType().getBinding(); if (!Comparable.class.isAssignableFrom(binding) || Geometry.class.isAssignableFrom(binding)) { return false; } } } return true; }
private void next() { if (iterator.hasNext()) { this.currentFeature = iterator.next(); // update the current key for (int i = 0; i < sortBy.length; i++) { SortBy sb = sortBy[i]; if (sb == SortBy.NATURAL_ORDER || sb == SortBy.REVERSE_ORDER) { currentKey.components[i] = currentFeature.getIdentifier().getID(); } else { Object value = sb.getPropertyName().evaluate(currentFeature); currentKey.components[i] = value; } } } else { // mark as complete but don't close, we might have // other fts to paint complete = true; } }
private Class[] getSortByAttributeClasses(LiteFeatureTypeStyle style) { SortBy[] sb = style.sortBy; FeatureType schema = style.layer.getFeatureSource().getSchema(); Class[] classes = new Class[sb.length]; for (int i = 0; i < classes.length; i++) { PropertyName property = sb[i].getPropertyName(); if (property == null) { // natural sorts classes[i] = String.class; } else { PropertyDescriptor pd = property.evaluate(schema, null); if (pd == null) { throw new IllegalArgumentException( "Property " + property + " could not be found in feature type " + schema.getName() + " in layer " + style.layer.getTitle()); } classes[i] = pd.getType().getBinding(); } } return classes; }