private SelectOffsetStep<Record1<byte[]>> getRangeQuery(DSLContext ctx, TableReference tableRef, RangeRequest rangeRequest, long timestamp, int maxRows) { boolean reverse = rangeRequest.isReverse(); byte[] start = rangeRequest.getStartInclusive(); byte[] end = rangeRequest.getEndExclusive(); Condition cond = R_TIMESTAMP.lessThan(timestamp); if (start.length > 0) { cond = cond.and(reverse ? R_ROW_NAME.lessOrEqual(start) : R_ROW_NAME.greaterOrEqual(start)); } if (end.length > 0) { cond = cond.and(reverse ? R_ROW_NAME.greaterThan(end) : R_ROW_NAME.lessThan(end)); } return ctx.selectDistinct(R_ROW_NAME) .from(atlasTable(tableRef).as(RANGE_TABLE)) .where(cond) .orderBy(reverse ? R_ROW_NAME.desc() : R_ROW_NAME.asc()) .limit(maxRows); }
public ArrayList<SortField<?>> getColumnOrdering(ReflectedTable table, Params params) { ArrayList<SortField<?>> fields = new ArrayList<>(); if (params.containsKey("order")) { for (String key : params.get("order")) { String[] parts = key.split(",", 3); boolean ascending = true; if (parts.length > 1) { ascending = !parts[1].toLowerCase().startsWith("desc"); } if (ascending) { fields.add(table.get(parts[0]).asc()); } else { fields.add(table.get(parts[0]).desc()); } } } return fields; }
@Override protected SortField<?> sort(Sorter sorter, SqlSortOptions options) { if (Sorter.RELEVANT_OPERATOR.equals(sorter.getOperator())) { return DSL.field(DSL.name(options.getRecordTableAlias(), recordIdField.getName()), uuidType()).desc(); } else { return super.sort(sorter, options); } } }
public List<RepositoryEntry> list(DSLContext tx, UUID projectId, Field<?> sortField, boolean asc) { SelectConditionStep<Record11<UUID, UUID, String, String, String, String, String, String, UUID, String, String>> query = selectRepositoryEntry(tx) .where(REPOSITORIES.PROJECT_ID.eq(projectId)); if (sortField != null) { query.orderBy(asc ? sortField.asc() : sortField.desc()); } return query.fetch(this::toEntry); }
sortFields.add(desc ? field.desc() : field.asc());
@Override public PM_R withConnection(final Connection conn) throws SQLException { return DSL.using(conn, dialect, settings) .selectFrom(paymentMethodsTable) .where(DSL.field(KB_PAYMENT_METHOD_ID).equal(kbPaymentMethodId.toString())) .and(DSL.field(IS_DELETED).equal(FALSE)) .and(DSL.field(KB_TENANT_ID).equal(kbTenantId.toString())) .orderBy(DSL.field(recordIdFieldName).desc()) .fetchOne(); } });
@Override public RESP_R withConnection(final Connection conn) throws SQLException { return DSL.using(conn, dialect, settings) .selectFrom(responsesTable) .where(DSL.field(KB_PAYMENT_ID).equal(kbPaymentId.toString())) .and(DSL.field(TRANSACTION_TYPE).equal(TransactionType.AUTHORIZE.toString())) .and(DSL.field(KB_TENANT_ID).equal(kbTenantId.toString())) .orderBy(DSL.field(recordIdFieldName).desc()) .limit(1) .fetchOne(); } });
@Override public Select getSearch(SearchQuery<E> query, PredicatesHolder predicatesHolder) { if (predicatesHolder.isAborted()) { return null; } Condition conditions = new JdbcPredicatesTranslator().translate(predicatesHolder); int finalLimit = query.getLimit() < 0 ? Integer.MAX_VALUE : query.getLimit(); SelectConditionStep<Record> where = createSqlQuery(query.getPropertyKeys()) .where(conditions); List<Pair<String, Order>> orders = query.getOrders(); if (orders != null){ List<SortField<Object>> orderValues = orders.stream().filter(order -> !order.getValue1().equals(Order.shuffle)) .filter(order -> getFieldByPropertyKey(order.getValue0()) != null) .map(order -> order.getValue1().equals(Order.incr) ? field(getFieldByPropertyKey(order.getValue0())).asc() : field(getFieldByPropertyKey(order.getValue0())).desc()).collect(Collectors.toList()); if (orderValues.size() > 0) return where.orderBy(orderValues).limit(finalLimit); } return where.limit(finalLimit); }
private static final SortField<?> parseSortField(ParserContext ctx) { Field<?> field = parseField(ctx); SortField<?> sort; if (parseKeywordIf(ctx, "DESC")) sort = field.desc(); else if (parseKeywordIf(ctx, "ASC")) sort = field.asc(); else sort = field.sortDefault(); if (parseKeywordIf(ctx, "NULLS FIRST")) sort = sort.nullsFirst(); else if (parseKeywordIf(ctx, "NULLS LAST")) sort = sort.nullsLast(); return sort; }
.orderBy(ZIPKIN_SPANS.START_TS.max().desc()).limit(request.limit);
public List<SecretEntry> list(UUID orgId, UUID currentUserId, Field<?> sortField, boolean asc) { SelectConditionStep<Record1<UUID>> teamIds = select(TEAMS.TEAM_ID) .from(TEAMS) .where(TEAMS.ORG_ID.eq(orgId)); Condition filterByTeamMember = exists(selectOne().from(USER_TEAMS) .where(USER_TEAMS.USER_ID.eq(currentUserId) .and(USER_TEAMS.TEAM_ID.in(teamIds)))); try (DSLContext tx = DSL.using(cfg)) { SelectJoinStep<Record12<UUID, String, UUID, String, UUID, String, UUID, String, String, String, String, String>> query = selectEntry(tx); if (currentUserId != null) { query.where(or(SECRETS.VISIBILITY.eq(SecretVisibility.PUBLIC.toString()), filterByTeamMember)); } if (orgId != null) { query.where(SECRETS.ORG_ID.eq(orgId)); } if (sortField != null) { query.orderBy(asc ? sortField.asc() : sortField.desc()); } return query.fetch(SecretDao::toEntry); } }
public PolicyRules getRules(DSLContext tx, UUID orgId, UUID projectId, UUID userId) { PolicyEntry entry = getLinked(tx, orgId, projectId, userId); if (entry == null || entry.rules().isEmpty()) { return null; } Result<Record3<String, String, Integer>> rules = tx.withRecursive("children").as( select(POLICIES.POLICY_ID, POLICIES.PARENT_POLICY_ID, POLICIES.POLICY_NAME, POLICIES.RULES, field("1", Integer.class).as("level")).from(POLICIES) .where(POLICIES.POLICY_ID.eq(entry.id())) .unionAll( select(POLICIES.POLICY_ID, POLICIES.PARENT_POLICY_ID, POLICIES.POLICY_NAME, POLICIES.RULES, field("children.level + 1", Integer.class).as("level")).from(POLICIES) .join(name("children")) .on(POLICIES.POLICY_ID.eq( field(name("children", "PARENT_POLICY_ID"), UUID.class))))) .select(POLICIES.as("children").POLICY_NAME, POLICIES.as("children").RULES.cast(String.class), field("level", Integer.class)) .from(name("children")) .orderBy(field("level").desc()) .fetch(); ImmutablePolicyRules.Builder result = ImmutablePolicyRules.builder(); Map<String, Object> mergedRules = new HashMap<>(); for(Record3<String, String, Integer> r : rules) { result.addPolicyNames(r.value1()); mergedRules = ConfigurationUtils.deepMerge(mergedRules, deserialize(r.value2())); } return result .rules(mergedRules) .build(); }
final boolean asc = sorter.getBoolean(field); final Field column = this.getColumn(field); orders.add(asc ? column.asc() : column.desc());
final boolean asc = sorter.getBoolean(field); final Field column = this.getColumn(field); orders.add(asc ? column.asc() : column.desc());
q.orderBy(asc ? sortField.asc() : sortField.desc());