@Override public Multimap<Cell, Long> getAllTimestamps(final TableReference tableRef, final Set<Cell> cells, final long timestamp) throws InsufficientConsistencyException { if (cells.isEmpty()) { return ImmutableMultimap.of(); } Multimap<Cell, Long> toReturn = ArrayListMultimap.create(); for (List<Cell> partition : Iterables.partition(cells, batchSizeForReads)) { toReturn.putAll(run(ctx -> { Result<? extends Record> records = ctx .select(A_ROW_NAME, A_COL_NAME, A_TIMESTAMP) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .join(values(ctx, toRows(Sets.newHashSet(partition)), TEMP_TABLE_1, ROW_NAME, COL_NAME)) .on(A_ROW_NAME.eq(T1_ROW_NAME) .and(A_COL_NAME.eq(T1_COL_NAME))) .where(A_TIMESTAMP.lessThan(timestamp)) .fetch(); Multimap<Cell, Long> results = ArrayListMultimap.create(records.size() / 4, 4); for (Record record : records) { results.put( Cell.create(record.getValue(A_ROW_NAME), record.getValue(A_COL_NAME)), record.getValue(A_TIMESTAMP)); } return results; })); } return toReturn; }
private void putBatch(DSLContext ctx, TableReference tableRef, PutBatch batch, boolean allowReinserts) { InsertValuesStep4<Record, byte[], byte[], Long, byte[]> query = ctx.insertInto(table(tableName(tableRef)), field(ROW_NAME, byte[].class), field(COL_NAME, byte[].class), field(TIMESTAMP, Long.class), field(VALUE, byte[].class)); query = batch.addValuesForInsert(query); try { query.execute(); } catch (DataAccessException e) { if (allowReinserts) { Result<? extends Record> records = ctx .select(A_ROW_NAME, A_COL_NAME, A_TIMESTAMP, A_VALUE) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .where(row(A_ROW_NAME, A_COL_NAME, A_TIMESTAMP).in(batch.getRowsForSelect())) .fetch(); if (records.isEmpty()) { throw e; } PutBatch nextBatch = batch.getNextBatch(records); if (nextBatch != null) { putBatch(ctx, tableRef, nextBatch, allowReinserts); return; } } throw new KeyAlreadyExistsException("Conflict on table " + tableRef, e); } }
public List<TriggerEntry> list(DSLContext tx, String eventSource, Map<String, String> conditions) { SelectJoinStep<Record12<UUID, UUID, String, UUID, String, UUID, String, String, String[], String, String, String>> query = selectTriggers(tx); return query.where(buildConditionClause(TRIGGERS, eventSource, conditions)) .fetch(this::toEntity); }
@Override public <R extends TableRecord<R>> Result<R> fetchByExample(R example) { return selectFrom(example.getTable()) .where(condition(example)) .fetch(); }
public List<RepositoryEntry> find(String repoUrl) { try (DSLContext tx = DSL.using(cfg)) { return selectRepositoryEntry(tx) .where(REPOSITORIES.REPO_URL.contains(repoUrl)) .fetch(this::toEntry); } }
@Override public IntIterator getIidxUidxs(int iidx) { return new StreamIntIterator(dsl .select(UIDX) .from(DATA) .where(IIDX.eq(iidx)) .fetch().stream() .mapToInt(Record1::value1)); }
@Override public DoubleIterator getIidxVs(int iidx) { return new StreamDoubleIterator(dsl .select(V) .from(DATA) .where(IIDX.eq(iidx)) .fetch().stream() .mapToDouble(Record1::value1)); }
@Override public boolean containsItem(String i) { return dsl .select() .from(ITEMS) .where(ITEM_ID.eq(i)) .fetch().isNotEmpty(); }
@Override public Stream<IdxPref> getUidxPreferences(int uidx) { return dsl .select(IIDX, V) .from(DATA) .where(UIDX.eq(uidx)) .fetch().stream() .map(r -> new IdxPref(r.value1(), r.value2())); }
@Override public Stream<IdxPref> getIidxPreferences(int iidx) { return dsl .select(UIDX, V) .from(DATA) .where(IIDX.eq(iidx)) .fetch().stream() .map(r -> new IdxPref(r.value1(), r.value2())); }
@Override public List<? extends StoragePool> findExternalActivePools() { return create() .selectFrom(STORAGE_POOL) .where( STORAGE_POOL.EXTERNAL.eq(true) .and(STORAGE_POOL.STATE.eq(CommonStatesConstants.ACTIVE)) ).fetch(); }
@Override public List<? extends Agent> findAgentsToPing() { Condition c = AGENT.STATE.eq(CommonStatesConstants.ACTIVE); for (String prefix : AgentConstants.AGENT_IGNORE_PREFIXES) { c = c.and(AGENT.URI.notLike(prefix + "%")); } return create() .selectFrom(AGENT) .where(c) .fetch(); }
public List<TriggerEntry> list(UUID projectId, UUID repositoryId) { try (DSLContext tx = DSL.using(cfg)) { SelectJoinStep<Record12<UUID, UUID, String, UUID, String, UUID, String, String, String[], String, String, String>> query = selectTriggers(tx); return query.where(TRIGGERS.PROJECT_ID.eq(projectId).and(TRIGGERS.REPO_ID.eq(repositoryId))) .fetch(this::toEntity); } }
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); }
public List<Map<String,Object>> list(UUID inventoryId) { try (DSLContext tx = DSL.using(cfg)) { return tx.select(INVENTORY_DATA.ITEM_PATH, INVENTORY_DATA.ITEM_DATA.cast(String.class)) .from(INVENTORY_DATA) .where(INVENTORY_DATA.INVENTORY_ID.eq(inventoryId)) .fetch(this::toListItem); } }
@Override public Stream<IdPref<String>> getItemPreferences(String i) { return dsl .select(USER_ID, V) .from(DATA).naturalJoin(USERS).naturalJoin(ITEMS) .where(ITEM_ID.eq(i)) .fetch().stream() .map(r -> new IdPref<>(r.value1(), r.value2())); }
@Override public List<? extends Host> getHosts(Long accountId, List<String> uuids) { return create() .selectFrom(HOST) .where(HOST.ACCOUNT_ID.eq(accountId) .and(HOST.STATE.notIn(CommonStatesConstants.REMOVED, CommonStatesConstants.REMOVING)) .and(HOST.UUID.in(uuids))).fetch(); }
@Override public boolean isUnique(UserPreference userPreference, long accountId) { return create().selectFrom(USER_PREFERENCE) .where(USER_PREFERENCE.NAME.eq(userPreference.getName()) .and(USER_PREFERENCE.ACCOUNT_ID.eq(accountId)).and(USER_PREFERENCE.REMOVED.isNull())).fetch().size() == 0; } }
@Override public boolean isSchedulerServiceEnabled(Long accountId) { return create() .select(SERVICE.ID) .from(SERVICE) .where(SERVICE.ACCOUNT_ID.equal(accountId) .and(SERVICE.SYSTEM.isTrue()) .and(SERVICE.REMOVED.isNull()) .and(SERVICE.STATE.notIn(INACTIVE_STATES)) .and(SERVICE.DATA.like("%io.rancher.container.agent_service.scheduling%"))).fetch().size() > 0; } }
public List<ProcessStatusHistoryEntry> getHistory(ProcessKey processKey) { try (DSLContext tx = DSL.using(cfg)) { ProcessEvents pe = PROCESS_EVENTS.as("pe"); return tx.select(historyEntryToJsonb(pe)) .from(pe) .where(pe.INSTANCE_ID.eq(processKey.getInstanceId()) .and(pe.INSTANCE_CREATED_AT.eq(processKey.getCreatedAt())) .and(pe.EVENT_TYPE.eq(EventType.PROCESS_STATUS.name()) .and(pe.EVENT_DATE.greaterOrEqual(processKey.getCreatedAt())))) .fetch(r -> deserialize(r.value1(), STATUS_HISTORY_ENTRY)); } }