Ejemplo n.º 1
0
  /**
   * Adds {@literal order by} clause to the JPQL query.
   *
   * @param query
   * @param sort
   * @param alias
   * @return
   */
  public static String applySorting(String query, Sort sort, String alias) {

    Assert.hasText(query);

    if (null == sort || !sort.iterator().hasNext()) {
      return query;
    }

    StringBuilder builder = new StringBuilder(query);

    if (!ORDER_BY.matcher(query).matches()) {
      builder.append(" order by ");
    } else {
      builder.append(", ");
    }

    Set<String> aliases = getOuterJoinAliases(query);

    for (Order order : sort) {
      builder.append(getOrderClause(aliases, alias, order)).append(", ");
    }

    builder.delete(builder.length() - 2, builder.length());

    return builder.toString();
  }
  @Override
  protected DerivedViewQuery complete(ViewQuery criteria, Sort sort) {
    boolean descending = false;

    if (sort != null) {
      int sortCount = 0;
      Iterator<Sort.Order> it = sort.iterator();
      while (it.hasNext()) {
        sortCount++;
        if (!it.next().isAscending()) {
          descending = true;
        }
      }
      if (sortCount > 1) {
        throw new IllegalArgumentException(
            "Detected " + sortCount + " sort instructions, maximum one supported");
      }
      query.descending(descending);
    }

    if (tree.isLimiting()) {
      query.limit(tree.getMaxResults());
    }

    boolean isCount = tree.isCountProjection() == Boolean.TRUE;
    boolean isExplicitReduce = viewAnnotation != null && viewAnnotation.reduce();
    if (isCount || isExplicitReduce) {
      query.reduce();
    }

    return new DerivedViewQuery(query, tree.isLimiting(), isCount || isExplicitReduce);
  }
Ejemplo n.º 3
0
  /**
   * Apply sorting for the given query.
   *
   * @param query the query
   * @param sort the sort
   * @return the string
   */
  public static String applySorting(String query, Sort sort) {
    Assert.hasText(query);

    if (null == sort || !sort.iterator().hasNext()) {
      return query;
    }

    throw new UnsupportedOperationException("Not implemented");
  }
  protected String orderByExpression(Sort sort) {
    StringBuilder sb = new StringBuilder();

    for (Iterator<Order> it = sort.iterator(); it.hasNext(); ) {
      Order order = it.next();
      sb.append(order.getProperty()).append(' ').append(order.getDirection());

      if (it.hasNext()) sb.append(COMMA);
    }
    return sb.toString();
  }
 private String getOrderDesc(final Pageable pageable) {
   String result = null;
   Sort sort = pageable.getSort();
   if (sort == null) {
     return result;
   }
   final Iterator<Order> iterator = sort.iterator();
   while (iterator.hasNext()) {
     final Order order = iterator.next();
     order.getProperty();
   }
   return result;
 }
Ejemplo n.º 6
0
  @Override
  public Page<DBObject> findPage(
      String collectionName,
      GroupPropertyFilter groupPropertyFilter,
      Pageable pageable,
      DBObject fields) {

    DB db = mongoClient.getDB(mongoDB);
    DBCollection dbColl = db.getCollection(collectionName);

    BasicDBObject query = new BasicDBObject();
    List<BasicDBObject> andQueries = Lists.newArrayList();
    List<PropertyFilter> filters = groupPropertyFilter.convertToPropertyFilters();
    if (CollectionUtils.isNotEmpty(filters)) {
      // Query and Projection Operators: https://docs.mongodb.org/manual/reference/operator/query/
      for (PropertyFilter filter : filters) {
        Object matchValue = filter.getMatchValue();
        if (matchValue == null) {
          continue;
        }

        String[] propertyNames = filter.getConvertedPropertyNames();
        List<BasicDBObject> orQueries = Lists.newArrayList();
        for (String propertyName : propertyNames) {
          BasicDBObject queryItem = new BasicDBObject();
          orQueries.add(queryItem);
          switch (filter.getMatchType()) {
            case EQ:
              queryItem.put(propertyName, matchValue);
              break;
            case NE:
              queryItem.put(propertyName, new BasicDBObject("$ne", matchValue));
              break;
            case BK:
              List<BasicDBObject> orList = Lists.newArrayList();
              orList.add(new BasicDBObject(propertyName, 0));
              orList.add(new BasicDBObject(propertyName, ""));
              queryItem.put("$or", orList);
              break;
            case NB:
              queryItem.put(propertyName, new BasicDBObject("$regex", ".{1,}"));
              break;
            case NU:
              queryItem.put(propertyName, 0);
              break;
            case NN:
              queryItem.put(propertyName, 1);
              break;
            case CN:
              queryItem.put(
                  propertyName,
                  new BasicDBObject("$regex", ".*" + matchValue + ".*").append("$options", "i"));
              break;
            case NC:
              queryItem.put(
                  propertyName,
                  new BasicDBObject(
                      "$not",
                      new BasicDBObject("$regex", ".*" + matchValue + ".*")
                          .append("$options", "i")));
              break;
            case BW:
              queryItem.put(
                  propertyName,
                  new BasicDBObject("$regex", "^" + matchValue).append("$options", "i"));
              break;
            case BN:
              queryItem.put(
                  propertyName,
                  new BasicDBObject(
                      "$not",
                      new BasicDBObject("$regex", "^" + matchValue).append("$options", "i")));
              break;
            case EW:
              queryItem.put(
                  propertyName,
                  new BasicDBObject("$regex", matchValue + "$").append("$options", "i"));
              break;
            case EN:
              queryItem.put(
                  propertyName,
                  new BasicDBObject(
                      "$not",
                      new BasicDBObject("$regex", matchValue + "$").append("$options", "i")));
              break;
            case BT:
              Assert.isTrue(matchValue.getClass().isArray(), "Match value must be array");
              Object[] matchValues = (Object[]) matchValue;
              Assert.isTrue(matchValues.length == 2, "Match value must have two value");
              List<BasicDBObject> andList = Lists.newArrayList();
              andList.add(new BasicDBObject(propertyName, new BasicDBObject("$gte", matchValue)));
              andList.add(new BasicDBObject(propertyName, new BasicDBObject("$gle", matchValue)));
              queryItem.put("$and", andList);
              break;
            case GT:
              queryItem.put(propertyName, new BasicDBObject("$gt", matchValue));
              break;
            case GE:
              queryItem.put(propertyName, new BasicDBObject("$ge", matchValue));
              break;
            case LT:
              queryItem.put(propertyName, new BasicDBObject("$lt", matchValue));
              break;
            case LE:
              queryItem.put(propertyName, new BasicDBObject("$le", matchValue));
              break;
            case IN:
              queryItem.put(propertyName, new BasicDBObject("$in", matchValue));
              break;
            default:
              throw new UnsupportedOperationException(
                  "Undefined PropertyFilter MatchType: " + filter.getMatchType());
          }
        }
        if (orQueries.size() > 1) {
          andQueries.add(new BasicDBObject("$or", orQueries));
        } else {
          andQueries.add(orQueries.get(0));
        }
      }
      query = new BasicDBObject("$and", andQueries);
    }

    BasicDBObject sort = new BasicDBObject();
    Sort pageSort = pageable.getSort();
    if (pageSort != null) {
      Iterator<Order> orders = pageSort.iterator();
      while (orders.hasNext()) {
        Order order = orders.next();
        String prop = order.getProperty();
        if (order.isAscending()) {
          sort.put(prop, 1);
        } else {
          sort.put(prop, -1);
        }
      }
    }

    DBCursor cur =
        dbColl
            .find(query, fields)
            .sort(sort)
            .skip(pageable.getOffset())
            .limit(pageable.getPageSize());
    List<DBObject> rows = Lists.newArrayList();
    while (cur.hasNext()) {
      DBObject obj = cur.next();
      rows.add(obj);
    }
    Page<DBObject> page = new PageImpl<DBObject>(rows, pageable, dbColl.count(query));
    return page;
  }