final void addAll(Field<?>... fields) { SortField<?>[] result = new SortField[fields.length]; for (int i = 0; i < fields.length; i++) { result[i] = fields[i].asc(); } addAll(Arrays.asList(result)); }
final void addAll(Field<?>... fields) { SortField<?>[] result = new SortField[fields.length]; for (int i = 0; i < fields.length; i++) result[i] = fields[i].asc(); addAll(Arrays.asList(result)); }
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; }
final SortFieldList getNonEmptyOrderBy() { if (getOrderBy().isEmpty()) { SortFieldList result = new SortFieldList(); result.add(getSelect().get(0).asc()); return result; } return getOrderBy(); }
final SortFieldList getNonEmptyOrderByForDistinct(Configuration configuration) { SortFieldList order = new SortFieldList(); order.addAll(getNonEmptyOrderBy(configuration)); for (Field<?> field : getSelect()) order.add(field.asc()); return order; }
@Override public List<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(KB_TENANT_ID).equal(kbTenantId.toString())) .orderBy(DSL.field(recordIdFieldName).asc()) .fetch(); } });
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());
final SortFieldList getNonEmptyOrderBy(Configuration configuration) { if (getOrderBy().isEmpty()) { SortFieldList result = new SortFieldList(); switch (configuration.family()) { default: result.add(DSL.field("({select} 0)").asc()); break; } return result; } return getOrderBy(); }
@Override public List<PM_R> withConnection(final Connection conn) throws SQLException { return DSL.using(conn, dialect, settings) .selectFrom(paymentMethodsTable) .where(DSL.field(KB_ACCOUNT_ID).equal(kbAccountId.toString())) .and(DSL.field(IS_DELETED).equal(FALSE)) .and(DSL.field(KB_TENANT_ID).equal(kbTenantId.toString())) .orderBy(DSL.field(recordIdFieldName).asc()) .fetch(); } });
@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; }
protected void addJoin(SelectQuery<?> query, Table<?> toTable, SchemaFactory schemaFactory, String fromType, Table<?> from, String asName, Relationship rel) { TableField<?, Object> fieldFrom = null; TableField<?, Object> fieldTo = null; switch (rel.getRelationshipType()) { case REFERENCE: fieldFrom = JooqUtils.getTableField(getMetaDataManager(), fromType, rel.getPropertyName()); fieldTo = JooqUtils.getTableField(getMetaDataManager(), schemaFactory.getSchemaName(rel.getObjectType()), ObjectMetaDataManager.ID_FIELD); break; case CHILD: fieldFrom = JooqUtils.getTableField(getMetaDataManager(), fromType, ObjectMetaDataManager.ID_FIELD); fieldTo = JooqUtils.getTableField(getMetaDataManager(), schemaFactory.getSchemaName(rel.getObjectType()), rel.getPropertyName()); break; default: throw new IllegalArgumentException("Illegal Relationship type [" + rel.getRelationshipType() + "]"); } if (fieldFrom == null || fieldTo == null) { throw new IllegalStateException("Failed to construction join query for [" + fromType + "] [" + from + "] [" + rel + "]"); } query.addJoin(toTable, JoinType.LEFT_OUTER_JOIN, fieldFrom.eq(fieldTo.getTable().as(asName).field(fieldTo.getName()))); query.addOrderBy(fieldTo.getTable().as(asName).field(ObjectMetaDataManager.ID_FIELD).asc()); }
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); } }
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());
protected void addMappingJoins(SelectQuery<?> query, Table<?> toTable, SchemaFactory schemaFactory, String fromType, Table<?> from, String asName, MapRelationship rel) { Table<?> mappingTable = JooqUtils.getTableFromRecordClass(rel.getMappingType()); /* * We don't required the mapping type to be visible external, that's why * we use the schemaFactory from the objectManager, because it is the * superset schemaFactory. */ String mappingType = getObjectManager().getSchemaFactory().getSchemaName(rel.getMappingType()); TableField<?, Object> fieldFrom = JooqUtils.getTableField(getMetaDataManager(), fromType, ObjectMetaDataManager.ID_FIELD); TableField<?, Object> fieldTo = JooqUtils.getTableField(getMetaDataManager(), mappingType, rel.getPropertyName()); TableField<?, Object> fieldRemoved = JooqUtils.getTableField(getMetaDataManager(), mappingType, ObjectMetaDataManager.REMOVED_FIELD); org.jooq.Condition cond = fieldFrom.eq(fieldTo.getTable().field(fieldTo.getName())).and( fieldRemoved == null ? DSL.trueCondition() : fieldRemoved.isNull()); query.addJoin(mappingTable, JoinType.LEFT_OUTER_JOIN, cond); fieldFrom = JooqUtils.getTableField(getMetaDataManager(), mappingType, rel.getOtherRelationship().getPropertyName()); fieldTo = JooqUtils.getTableField(getMetaDataManager(), schemaFactory.getSchemaName(rel.getObjectType()), ObjectMetaDataManager.ID_FIELD); cond = fieldFrom.eq(fieldTo.getTable().asTable(asName).field(fieldTo.getName())); query.addJoin(toTable, JoinType.LEFT_OUTER_JOIN, cond); query.addOrderBy(fieldTo.getTable().asTable(asName).field(fieldTo.getName()).asc()); }
r1.ROUTINE_SCHEMA.asc(), r1.ROUTINE_NAME.asc(), field(name("overload")).asc()) .fetch()) {
q.orderBy(asc ? sortField.asc() : sortField.desc());