Refine search
private Result<? extends Record> fetchValues(DSLContext ctx, TableReference tableRef, Select<? extends Record> subQuery) { return ctx.select(A_ROW_NAME, A_COL_NAME, A_TIMESTAMP, A_VALUE) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .join(subQuery.asTable(TEMP_TABLE_2)) .on(A_ROW_NAME.eq(T2_ROW_NAME) .and(A_COL_NAME.eq(T2_COL_NAME)) .and(A_TIMESTAMP.eq(T2_MAX_TIMESTAMP))) .fetch(); }
public boolean isArchived(UUID checkpointId) { try (DSLContext tx = DSL.using(cfg)) { return tx.fetchExists(selectFrom(PROCESS_CHECKPOINT_ARCHIVE) .where(PROCESS_CHECKPOINT_ARCHIVE.CHECKPOINT_ID.eq(checkpointId) .and(PROCESS_CHECKPOINT_ARCHIVE.STATUS.eq(ArchivalStatus.DONE.toString())))); } }
int i = 0; for (Cell cell : partCells) { rows[i++] = row(new Object[] {cell.getRowName(), cell.getColumnName(), timestamp, value}); ctx.insertInto(table(tableName(tableRef)), field(ROW_NAME, byte[].class), field(COL_NAME, byte[].class), field(TIMESTAMP, Long.class), field(VALUE, byte[].class)) .select(ctx.select(T1_ROW_NAME, T1_COL_NAME, T1_TIMESTAMP, T1_VALUE) .from(values(ctx, rows, TEMP_TABLE_1, ROW_NAME, COL_NAME, TIMESTAMP, VALUE)) .whereNotExists(ctx.selectOne() .from(atlasTable(tableRef).as(ATLAS_TABLE)) .where(A_ROW_NAME.eq(T1_ROW_NAME) .and(A_COL_NAME.eq(T1_COL_NAME)) .and(A_TIMESTAMP.eq(T1_TIMESTAMP))))) .execute(); return null;
@Override public List<? extends Host> getActiveHosts(long accountId) { return create() .select(HOST.fields()) .from(HOST) .leftOuterJoin(AGENT) .on(AGENT.ID.eq(HOST.AGENT_ID)) .where( AGENT.ID.isNull() .or(AGENT.STATE.in(CommonStatesConstants.ACTIVE, AgentConstants.STATE_FINISHING_RECONNECT, AgentConstants.STATE_RECONNECTED)) .and(HOST.REMOVED.isNull()) .and(HOST.ACCOUNT_ID.eq(accountId)) .and(HOST.STATE.in(CommonStatesConstants.ACTIVATING, CommonStatesConstants.ACTIVE, CommonStatesConstants.UPDATING_ACTIVE))) .fetchInto(Host.class); }
private Select<? extends Record> getLatestTimestampQueryAllColumnsSubQuery(DSLContext ctx, TableReference tableRef, Select<Record1<byte[]>> subQuery, long timestamp) { return ctx.select(A_ROW_NAME, A_COL_NAME, DSL.max(A_TIMESTAMP).as(MAX_TIMESTAMP)) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .where(A_ROW_NAME.in(subQuery) .and(A_TIMESTAMP.lessThan(timestamp))) .groupBy(A_ROW_NAME, A_COL_NAME); }
@Override public List<? extends StoragePoolHostMap> findMapsToRemove(Long storagePoolId) { return create() .selectFrom(STORAGE_POOL_HOST_MAP) .where(STORAGE_POOL_HOST_MAP.STORAGE_POOL_ID.eq(storagePoolId) .and((STORAGE_POOL_HOST_MAP.REMOVED.isNull() .or(STORAGE_POOL_HOST_MAP.STATE.eq(CommonStatesConstants.REMOVING))))) .fetchInto(StoragePoolHostMap.class); }
public UUID findUserId(String key) { try (DSLContext tx = DSL.using(cfg)) { return tx.select(API_KEYS.USER_ID) .from(API_KEYS) .where(API_KEYS.API_KEY.eq(hash(key)) .and(API_KEYS.EXPIRED_AT.isNull() .or(API_KEYS.EXPIRED_AT.greaterThan(currentTimestamp())))) .fetchOne(API_KEYS.USER_ID); } }
@Override public Account getAccountById(Long id) { return create() .selectFrom(ACCOUNT) .where( ACCOUNT.ID.eq(id) .and(ACCOUNT.STATE.ne(CommonStatesConstants.PURGED)) .and(ACCOUNT.REMOVED.isNull()) ).fetchOne(); }
/** * Checks if a value exists. */ public boolean exists(ProcessKey processKey, String path) { try (DSLContext tx = DSL.using(cfg)) { return tx.fetchExists(tx.selectFrom(PROCESS_STATE) .where(PROCESS_STATE.INSTANCE_ID.eq(processKey.getInstanceId()) .and(PROCESS_STATE.INSTANCE_CREATED_AT.eq(processKey.getCreatedAt())) .and(PROCESS_STATE.ITEM_PATH.startsWith(path)))); } }
public List<ApiKeyEntry> poll(int days) { return txResult(tx -> tx.select(API_KEYS.KEY_ID, API_KEYS.KEY_NAME, API_KEYS.EXPIRED_AT, API_KEYS.USER_ID) .from(API_KEYS) .where(API_KEYS.EXPIRED_AT.isNotNull() .and(currentTimestamp().greaterOrEqual(trunc(API_KEYS.EXPIRED_AT).minus(days)) .and(API_KEYS.LAST_NOTIFIED_AT.isNull() .or(API_KEYS.LAST_NOTIFIED_AT.lessOrEqual(API_KEYS.EXPIRED_AT.minus(days)))))) .fetch(this::toEntry)); }
@Override public PageResult<T> fetch(PageResult<T> page, Stream<Condition> conditions, SortField<?>... sorts) { Condition c = conditions.reduce((acc, item) -> acc.and(item)).orElse(DSL.trueCondition()); return fetch(page, e -> { return e.select(table.fields()).from(table).where(c).orderBy(sorts); }, entityClass); }
@Override public boolean canCreate(Long hostId, String event) { if (!ContainerEventConstants.EVENT_START.equals(event)) { return true; } Record1<Integer> count = create().select(DSL.count()) .from(CONTAINER_EVENT) .where(CONTAINER_EVENT.HOST_ID.eq(hostId) .and(CONTAINER_EVENT.STATE.notEqual(CommonStatesConstants.CREATED))) .fetchAny(); return count.value1() < MAX_EVENTS.get(); }
private void deleteDirectory(DSLContext tx, UUID instanceId, Timestamp instanceCreatedAt, String path) { tx.deleteFrom(PROCESS_STATE) .where(PROCESS_STATE.INSTANCE_ID.eq(instanceId) .and(PROCESS_STATE.INSTANCE_CREATED_AT.eq(instanceCreatedAt))) .and(PROCESS_STATE.ITEM_PATH.eq(path) .or(PROCESS_STATE.ITEM_PATH.startsWith(fixPath(path)))) .execute(); }
@Override public synchronized void storeUpperLimit(final long limit) throws MultipleRunningTimestampServiceError { kvs.runInTransaction((Function<DSLContext, Void>) ctx -> { int rowsUpdated = ctx.update(TABLE) .set(LATEST_TIMESTAMP, limit) .where(DUMMY_COLUMN.eq(0).and(LATEST_TIMESTAMP.eq(latestTimestamp))) .execute(); if (rowsUpdated != 1) { long actualLatestTimestamp = getLatestTimestamp(ctx); throw new MultipleRunningTimestampServiceError("Timestamp limit changed underneath " + "us (limit in memory: " + latestTimestamp + ", limit in db: " + actualLatestTimestamp + "). This may indicate that another timestamp service is running against this db!"); } latestTimestamp = limit; return null; }); }
private void addPkRecords(ReflectedTable t1, ReflectedTable t2, HashMap<Object, ArrayList<Object>> pkValues, Params params, DSLContext dsl, ArrayList<Record> records) { List<Field<Object>> fks = t2.getFksTo(t1.getName()); ArrayList<Field<?>> fields = columns.getNames(t2, false, params); Condition condition = DSL.falseCondition(); for (Field<Object> fk : fks) { condition = condition.or(fk.in(pkValues.keySet())); } ResultQuery<org.jooq.Record> query = dsl.select(fields).from(t2).where(condition); for (org.jooq.Record record : query.fetch()) { records.add(Record.valueOf(record.intoMap())); } }
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); }
private Condition buildConditionClause(Triggers t, String eventSource, Map<String, String> conditions) { Condition result = t.EVENT_SOURCE.eq(eventSource); if (conditions == null) { return result; } for (Map.Entry<String, String> e : conditions.entrySet()) { result = result.and( jsonText(t.CONDITIONS, e.getKey()).isNull() .or( value(e.getValue()).likeRegex(jsonText(t.CONDITIONS, e.getKey()).cast(String.class)))); } return result; }
@Override public final Condition or(String sql, Object... bindings) { return getWhere().or(sql, bindings); }