@Override public void configure(final Env env, final Config conf, final Binder binder) { Key<DataSource> dskey = Key.get(DataSource.class, Names.named(name)); Supplier<NoSuchElementException> noSuchElement = () -> new NoSuchElementException( "DataSource missing: " + dskey); HikariDataSource ds = (HikariDataSource) env.get(dskey).orElseThrow(noSuchElement); Configuration jooqconf = new DefaultConfiguration(); ConnectionProvider dscp = new DataSourceConnectionProvider(ds); jooqconf.set(JDBCUtils.dialect(env.get(Key.get(String.class, Names.named(name + ".url"))) .orElseThrow(noSuchElement))); jooqconf.set(dscp); jooqconf.set(new DefaultTransactionProvider(dscp)); if (callback != null) { callback.accept(jooqconf, conf); } ServiceKey serviceKey = env.serviceKey(); serviceKey.generate(Configuration.class, name, k -> binder.bind(k).toInstance(jooqconf)); Provider<DSLContext> dsl = () -> DSL.using(jooqconf); serviceKey.generate(DSLContext.class, name, k -> binder.bind(k).toProvider(dsl)); } }
/** * Create an aliased <code>PUBLIC.CATEGORY</code> table reference */ public Category(String alias) { this(DSL.name(alias), CATEGORY); }
private JdbcKeyValueService( Settings settings, SQLDialect sqlDialect, DataSource dataSource, String tablePrefix, int rowBatchSize, int batchSizeForReads, int batchSizeForMutations) { this.settings = settings; this.sqlDialect = sqlDialect; this.dataSource = dataSource; this.tablePrefix = tablePrefix; this.rowBatchSize = rowBatchSize; this.batchSizeForReads = batchSizeForReads; this.batchSizeForMutations = batchSizeForMutations; METADATA_TABLE = table(tablePrefix + "_metadata"); }
/** * Create a new DSL UPSERT statement ({@link SQLDialect#H2} * <code>MERGE</code>) or {@link SQLDialect#HANA} <code>UPSERT</code>). * * @see DSLContext#mergeInto(Table, Field...) */ @Generated("This method was generated using jOOQ-tools") @Support({ CUBRID, FIREBIRD_3_0, H2, HSQLDB, MARIADB, MYSQL, POSTGRES_9_5 }) public static <R extends Record, T1, T2> MergeKeyStep2<R, T1, T2> mergeInto(Table<R> table, Field<T1> field1, Field<T2> field2) { return using(new DefaultConfiguration()).mergeInto(table, field1, field2); }
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;
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); } }
private void createIndexTableIfNotExists(DSLContext dsl) { boolean tableExists = dsl.select(DSL.count()) .from("information_schema.tables") .where( DSL.field("table_schema").eq(colSchema.getName()) .and(DSL.field("table_name").eq(toroIndexTable.getName())) ) .fetchOne(0, int.class) > 0; if (!tableExists) { Name tableName = DSL.name(colSchema.getName(), toroIndexTable.getName()); dsl.execute( databaseInterface.createIndexesTableStatement( dsl.render(tableName), toroIndexTable.nameColumn.getName(), toroIndexTable.indexColumn.getName() ) ); } }
@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 PM_R withConnection(final Connection conn) throws SQLException { return DSL.using(conn, dialect, settings) .selectFrom(paymentMethodsTable) .where(DSL.field(KB_PAYMENT_METHOD_ID).equal(kbPaymentMethodId.toString())) .and(DSL.field(IS_DELETED).equal(FALSE)) .and(DSL.field(KB_TENANT_ID).equal(kbTenantId.toString())) .orderBy(DSL.field(recordIdFieldName).desc()) .fetchOne(); } });
@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); }
public List<IdAndStatus> getCascade(PartialProcessKey parentKey) { UUID parentInstanceId = parentKey.getInstanceId(); try (DSLContext tx = DSL.using(cfg)) { return tx.withRecursive("children").as( select(PROCESS_QUEUE.INSTANCE_ID, PROCESS_QUEUE.CREATED_AT, PROCESS_QUEUE.CURRENT_STATUS).from(PROCESS_QUEUE) .where(PROCESS_QUEUE.INSTANCE_ID.eq(parentInstanceId)) .unionAll( select(PROCESS_QUEUE.INSTANCE_ID, PROCESS_QUEUE.CREATED_AT, PROCESS_QUEUE.CURRENT_STATUS).from(PROCESS_QUEUE) .join(name("children")) .on(PROCESS_QUEUE.PARENT_INSTANCE_ID.eq( field(name("children", "INSTANCE_ID"), UUID.class))))) .select() .from(name("children")) .fetch(r -> new IdAndStatus(new ProcessKey(r.get(0, UUID.class), r.get(1, Timestamp.class)), ProcessStatus.valueOf(r.get(2, String.class)))); } }
/** * Returns an SQL statement that can be used to get when the rows * matching the query were last updated. */ public String lastUpdateStatement() { Table<?> table = initialize(DSL.table(DSL.name(database.recordUpdateTable.getName())).as(recordTableAlias)); return tableRenderContext.render(dslContext .select(DSL.field(DSL.name(recordTableAlias, database.recordUpdateDateField.getName())).max()) .from(table) .where(whereCondition)); }
@WithTimer public int getDepth(UUID parentInstanceId) { return txResult(tx -> tx.withRecursive("ancestors").as( select(PROCESS_QUEUE.INSTANCE_ID, PROCESS_QUEUE.PARENT_INSTANCE_ID, field("1", Integer.class).as("depth")) .from(PROCESS_QUEUE) .where(PROCESS_QUEUE.INSTANCE_ID.eq(parentInstanceId)) .unionAll( select(PROCESS_QUEUE.INSTANCE_ID, PROCESS_QUEUE.PARENT_INSTANCE_ID, field("1 + ancestors.depth", Integer.class).as("depth")) .from(PROCESS_QUEUE) .join(name("ancestors")) .on(PROCESS_QUEUE.INSTANCE_ID.eq( field(name("ancestors", "PARENT_INSTANCE_ID"), UUID.class))))) .select(max(field(name("ancestors", "depth"), Integer.class))) .from(name("ancestors")) .fetchOne(Record1::value1)); } }
@Override public Set<Integer> visit(ByStructureDatabaseQuery databaseQuery, Boolean forUpdate) { SelectConditionStep<Record1<Integer>> select = dsl.select(DSL.field("did", Integer.class)) .from(DSL.tableByName(colSchema.getName(), "root")) .where( DSL.field("sid", Integer.class).equal(databaseQuery.getSid()) ); Result<Record1<Integer>> fetched; if (forUpdate) { fetched = select.forUpdate().fetch(); } else { fetched = select.fetch(); } Set<Integer> result = Sets.newHashSetWithExpectedSize(fetched.size()); for (Record1<Integer> record1 : fetched) { result.add(record1.value1()); } return result; }
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); } }
@SuppressWarnings("unchecked") @Override public /* non-final */ <Z> List<P> fetch(Field<Z> field, Z... values) { return using(configuration) .selectFrom(table) .where(field.in(values)) .fetch() .map(mapper()); }
private Result<Record3<String, String, String>> fetchKeys(Condition condition) { return create().select( concat(DB_CLASS.CLASS_NAME, val("__"), DB_INDEX.INDEX_NAME).as("constraint_name"), DB_INDEX_KEY.KEY_ATTR_NAME, DB_CLASS.CLASS_NAME) .from(DB_INDEX) .join(DB_CLASS).on(DB_INDEX.CLASS_NAME.equal(DB_CLASS.CLASS_NAME)) .join(DB_INDEX_KEY).on( DB_INDEX_KEY.INDEX_NAME.equal(DB_INDEX.INDEX_NAME).and( DB_INDEX_KEY.CLASS_NAME.equal(DB_INDEX.CLASS_NAME))) .where(condition) .orderBy( DB_INDEX.INDEX_NAME.asc()) .fetch(); }
@Override public /* non-final */ <Z> P fetchOne(Field<Z> field, Z value) { R record = using(configuration) .selectFrom(table) .where(field.equal(value)) .fetchOne(); return record == null ? null : mapper().map(record); }