@Override public List<? extends ProjectMember> getProjectMembersByIdentity(long projectId, Set<Identity> identities) { Condition allMembers = DSL.falseCondition(); for (Identity identity : identities) { allMembers = allMembers.or(PROJECT_MEMBER.EXTERNAL_ID.eq(identity.getExternalId()) .and(PROJECT_MEMBER.EXTERNAL_ID_TYPE.eq(identity.getExternalIdType())) .and(PROJECT_MEMBER.REMOVED.isNull()) .and(PROJECT_MEMBER.STATE.eq(CommonStatesConstants.ACTIVE)) .and(PROJECT_MEMBER.PROJECT_ID.eq(projectId))); } SelectQuery<Record> query = create().selectQuery(); query.addFrom(PROJECT_MEMBER); query.addConditions(allMembers); query.setDistinct(true); return query.fetchInto(PROJECT_MEMBER); }
SelectQuery query = ... query.addConditions( ( CAR.COLOR.eq("blue") .or ( CAR.MODEL.eq("Genesis") ) ) .or ( CAR.MANUFACTOR.eq("ford") .and ( CAR.COLOR.eq("blue") ) ) )
@Override public final void refresh(final Field<?>... refreshFields) { SelectQuery<Record> select = create().selectQuery(); select.addSelect(refreshFields); select.addFrom(getTable()); Tools.addConditions(select, this, getPrimaryKey().getFieldsArray()); if (select.execute() == 1) { final AbstractRecord source = (AbstractRecord) select.getResult().get(0); delegate(configuration(), (Record) this, REFRESH) .operate(new RecordOperation<Record, RuntimeException>() { @Override public Record operate(Record record) throws RuntimeException { setValues(refreshFields, source); return record; } }); } else { throw new NoDataFoundException("Exactly one row expected for refresh. Record does not exist in database."); } }
@SuppressWarnings("unchecked") @Override protected <T> List<T> getListByRelationshipMap(Object obj, MapRelationship rel) { Class<UpdatableRecord<?>> typeClass = JooqUtils.getRecordClass(schemaFactory, rel.getObjectType()); String mappingType = schemaFactory.getSchemaName(rel.getMappingType()); String fromType = schemaFactory.getSchemaName(rel.getObjectType()); TableField<?, Object> fieldFrom = JooqUtils.getTableField(getMetaDataManager(), fromType, ObjectMetaDataManager.ID_FIELD); TableField<?, Object> mappingTo = JooqUtils.getTableField(getMetaDataManager(), mappingType, rel.getOtherRelationship().getPropertyName()); TableField<?, Object> mappingOther = JooqUtils.getTableField(getMetaDataManager(), mappingType, rel.getPropertyName()); TableField<?, Object> mappingRemoved = JooqUtils.getTableField(getMetaDataManager(), mappingType, ObjectMetaDataManager.REMOVED_FIELD); Table<?> table = JooqUtils.getTable(schemaFactory, typeClass); Table<?> mapTable = JooqUtils.getTable(schemaFactory, rel.getMappingType()); SelectQuery<?> query = create().selectQuery(); query.addFrom(table); query.addSelect(table.fields()); query.addJoin(mapTable, fieldFrom.eq(mappingTo).and(mappingRemoved == null ? DSL.trueCondition() : mappingRemoved.isNull()).and( mappingOther.eq(ObjectUtils.getId(obj)))); return (List<T>) query.fetchInto(typeClass); }
if (time_from > -1) select.addConditions(CDR.TIME_FROM_FIELD.ge(inline(new Timestamp(time_from)))); if (time_to > -1 && time_from <= time_to) select.addConditions(CDR.TIME_TO_FIELD.lt(inline(new Timestamp(time_to)))); if (account != null && !account.isEmpty()) select.addConditions(CDR.ACCOUNT_FIELD.eq(inline(account))); if (metric != null && !metric.isEmpty()) select.addConditions(CDR.METRIC_FIELD.eq(inline(metric))); if (currency != null && !currency.isEmpty()) select.addConditions(CDR.CURRENCY_FIELD.eq(inline(currency))); select.addLimit(selectedPage * pageLimit, pageLimit);
query.addConditions(PROCESS_QUEUE.PROJECT_ID.in(projectIds) .or(PROCESS_QUEUE.PROJECT_ID.isNull())); } else { query.addConditions(PROCESS_QUEUE.PROJECT_ID.in(projectIds)); query.addConditions(PROCESS_QUEUE.PROJECT_ID.eq(filter.projectId())); query.addConditions(PROCESS_QUEUE.CREATED_AT.greaterThan(filter.afterCreatedAt())); query.addConditions(PROCESS_QUEUE.CREATED_AT.lessThan(filter.beforeCreatedAt())); query.addConditions(USERS.USERNAME.startsWith(filter.initiator())); query.addConditions(PROCESS_QUEUE.CURRENT_STATUS.eq(status.name())); query.addConditions(PROCESS_QUEUE.PARENT_INSTANCE_ID.eq(filter.parentId())); query.addOrderBy(PROCESS_QUEUE.CREATED_AT.asc()); } else { query.addOrderBy(PROCESS_QUEUE.CREATED_AT.desc()); query.addLimit(limit); query.addOffset(offset); List<ProcessEntry> processEntries = query.fetch(this::toEntry);
SelectQuery select = DSL.using(configuration).selectQuery(); select.addFrom(CAR);
@Override public final SelectImpl limit(int numberOfRows) { this.limit = numberOfRows; this.limitParam = null; getQuery().addLimit(numberOfRows); return this; }
@Override public final SelectImpl and(Condition condition) { switch (conditionStep) { case WHERE: getQuery().addConditions(condition); break; case CONNECT_BY: getQuery().addConnectBy(condition); break; case HAVING: getQuery().addHaving(condition); break; case ON: joinConditions.addConditions(condition); break; } return this; }
/** * This method must be able to return both incompatible types * SelectSelectStep<Record> and SelectSelectStep<R> */ @Override public final SelectImpl select(Field<?>... fields) { getQuery().addSelect(fields); return this; }
protected void addJoins(SelectQuery<?> query, Map<Table<?>, Condition> joins) { if (joins == null) { return; } for (Map.Entry<Table<?>, Condition> entry : joins.entrySet()) { query.addJoin(entry.getKey(), JoinType.LEFT_OUTER_JOIN, entry.getValue()); } }
select.addConditions(Usage.TIME_FIELD.between(inline(new Timestamp(time_from)), inline(new Timestamp(time_to)))); select.addConditions(onlySelectTheseMetrics(metrics)); select.addGroupBy(Usage.METRIC_FIELD, Usage.ACCOUNT_FIELD, Usage.USAGE_FIELD, Usage.UNIT_FIELD, Usage.DATA_FIELD);
public List<ProcessEntry> list(UUID parentInstanceId, Set<String> tags) { try (DSLContext tx = DSL.using(cfg)) { SelectQuery<Record> query = buildSelect(tx, DEFAULT_INCLUDES); query.addConditions(PROCESS_QUEUE.PARENT_INSTANCE_ID.eq(parentInstanceId)); filterByTags(query, tags); query.addOrderBy(PROCESS_QUEUE.CREATED_AT.desc()); return query.fetch(this::toEntry); } }
@Override public final SelectImpl orderSiblingsBy(Collection<? extends SortField<?>> fields) { getQuery().addOrderBy(fields); getQuery().setOrderBySiblings(true); return this; }
@Override public final SelectImpl or(Condition condition) { switch (conditionStep) { case WHERE: getQuery().addConditions(Operator.OR, condition); break; case CONNECT_BY: throw new IllegalStateException("Cannot connect conditions for the CONNECT BY clause using the OR operator"); case HAVING: getQuery().addHaving(Operator.OR, condition); break; case ON: joinConditions.addConditions(Operator.OR, condition); break; } return this; }
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<ProcessEntry> get(List<PartialProcessKey> processKeys) { try (DSLContext tx = DSL.using(cfg)) { List<UUID> instanceIds = processKeys.stream() .map(PartialProcessKey::getInstanceId) .collect(Collectors.toList()); SelectQuery<Record> query = buildSelect(tx, DEFAULT_INCLUDES); query.addConditions(PROCESS_QUEUE.INSTANCE_ID.in(instanceIds)); return query.fetch(this::toEntry); } }