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(); }
private long getLatestTimestamp(DSLContext ctx) { return ctx.select(LATEST_TIMESTAMP) .from(TABLE) .where(DUMMY_COLUMN.eq(0)) .fetchOne(LATEST_TIMESTAMP); } }
@Override public void putMetadataForTables(final Map<TableReference, byte[]> tableRefToMetadata) { if (tableRefToMetadata.isEmpty()) { return; } run((Function<DSLContext, Void>) ctx -> { Query query = ctx .update(METADATA_TABLE) .set(METADATA, (byte[]) null) .where(TABLE_NAME.eq((String) null)); BatchBindStep batch = ctx.batch(query); for (Entry<TableReference, byte[]> entry : tableRefToMetadata.entrySet()) { batch = batch.bind(entry.getValue(), entry.getKey().getQualifiedName()); } batch.execute(); return null; }); }
@Override public byte[] getMetadataForTable(final TableReference tableRef) { return run(ctx -> { byte[] metadata = ctx .select(METADATA) .from(METADATA_TABLE) .where(TABLE_NAME.eq(tableRef.getQualifiedName())) .fetchOne(METADATA); return MoreObjects.firstNonNull(metadata, new byte[0]); }); }
@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; }); }
@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 Select<? extends Record> getLatestTimestampQueryManyTimestamps(DSLContext ctx, TableReference tableRef, RowN[] rows) { return ctx.select(A_ROW_NAME, A_COL_NAME, DSL.max(A_TIMESTAMP).as(MAX_TIMESTAMP)) .from(atlasTable(tableRef).as(ATLAS_TABLE)) .join(values(ctx, rows, TEMP_TABLE_1, ROW_NAME, COL_NAME, TIMESTAMP)) .on(A_ROW_NAME.eq(T1_ROW_NAME) .and(A_COL_NAME.eq(T1_COL_NAME))) .where(A_TIMESTAMP.lessThan(T1_TIMESTAMP)) .groupBy(A_ROW_NAME, A_COL_NAME); }
public static JdbcTimestampBoundStore create(final JdbcKeyValueService kvs) { final JdbcTimestampBoundStore store = new JdbcTimestampBoundStore(kvs); kvs.run((Function<DSLContext, Void>) ctx -> { String partialSql = ctx.createTable(store.TABLE) .column(DUMMY_COLUMN, INTEGER.nullable(false)) .column(LATEST_TIMESTAMP, BIGINT.nullable(false)) .getSQL(); int endIndex = partialSql.lastIndexOf(')'); String fullSql = partialSql.substring(0, endIndex) + "," + " CONSTRAINT " + kvs.primaryKey(TIMESTAMP_TABLE) + " PRIMARY KEY (" + DUMMY_COLUMN.getName() + ")" + partialSql.substring(endIndex); try { ctx.execute(fullSql); } catch (DataAccessException e) { kvs.handleTableCreationException(e); } ctx.insertInto(store.TABLE, DUMMY_COLUMN, LATEST_TIMESTAMP) .select(ctx.select(DUMMY_COLUMN, LATEST_TIMESTAMP) .from(kvs.values(ctx, new RowN[] {(RowN) DSL.row(0, 10000L)}, "t", DUMMY_COLUMN.getName(), LATEST_TIMESTAMP.getName())) .whereNotExists(ctx.selectOne() .from(store.TABLE) .where(DUMMY_COLUMN.eq(0)))) .execute(); return null; }); return store; }
/** * Performs an async <code>DELETE</code> statement for a given condition and passes the number of affected rows * to the <code>resultHandler</code>. * @param field the field * @param value the value * @param resultHandler the resultHandler which succeeds when the blocking method of this type succeeds or fails * with an <code>DataAccessException</code> if the blocking method of this type throws an exception * @param <Z> the value type */ default <Z> void deleteExecAsync(Field<Z> field, Z value, Handler<AsyncResult<Integer>> resultHandler){ deleteExecAsync(field.eq(value),resultHandler); }
/** * Create a <code>null</code>-safe condition. */ static final <T> Condition condition(Field<T> field, T value) { return (value == null) ? field.isNull() : field.eq(value); }
result = leftField.eq(rightField); break; case ge:
@SuppressWarnings({ "unchecked", "rawtypes" }) @Override public void accept(Context<?> ctx) { ConditionProviderImpl condition = new ConditionProviderImpl(); for (Entry<Field<?>, ?> entry : map.entrySet()) { Field f1 = entry.getKey(); Field f2 = Tools.field(entry.getValue(), f1); condition.addConditions(f1.eq(f2)); } ctx.visit(condition); } }
@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 int numItems(int uidx) { return dsl .selectCount() .from(DATA) .where(UIDX.eq(uidx)) .fetchOne().value1(); }
@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 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())); }