handleTableCreationException(e); ctx.insertInto(METADATA_TABLE, TABLE_NAME, METADATA) .values(tableRef.getQualifiedName(), metadata) .execute();
@Override public <R extends Record> InsertValuesStepN<R> insertInto(Table<R> into, Collection<? extends Field<?>> fields) { return delegate.insertInto(into, fields); }
DSLContext request = DSL.using(sqlConnection, SQLDialect.MYSQL); InsertValuesStep2<?, Object, Object> step = request.insertInto( DSL.table("MyTable"), DSL.field("MyColumn1"), DSL.field("MyColumn2")); // ... some code ... step = step.values("hello", 98); // ... some code ... step = values("world", 67); // ... some code ... step.execute();
@Override public <R extends Record, T1, T2, T3> InsertValuesStep3<R, T1, T2, T3> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3) { return delegate.insertInto(into, field1, field2, field3); }
@Override public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> InsertValuesStep11<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> insertInto( Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11) { return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11); }
@Override public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> InsertValuesStep12<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> insertInto( Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12) { return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12); }
@Override public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> InsertValuesStep19<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> insertInto( Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19) { return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19); }
@Override public <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> InsertValuesStep22<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> insertInto( Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5, Field<T6> field6, Field<T7> field7, Field<T8> field8, Field<T9> field9, Field<T10> field10, Field<T11> field11, Field<T12> field12, Field<T13> field13, Field<T14> field14, Field<T15> field15, Field<T16> field16, Field<T17> field17, Field<T18> field18, Field<T19> field19, Field<T20> field20, Field<T21> field21, Field<T22> field22) { return delegate.insertInto(into, field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19, field20, field21, field22); }
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; }
ctx.insertInto(table(tableName(tableRef)), field(ROW_NAME, byte[].class), field(COL_NAME, byte[].class),
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); } }
protected void set(String name, String value, boolean visible) { create() .insertInto(DATA, DATA.NAME, DATA.VISIBLE, DATA.VALUE) .values(name, visible, value) .execute(); }
@Override public EXECUTE insert(P pojo, boolean onDuplicateKeyIgnore) { Objects.requireNonNull(pojo); return queryExecutor().execute(dslContext -> { InsertSetMoreStep<R> insertStep = dslContext.insertInto(getTable()).set(newRecord(dslContext, pojo)); return onDuplicateKeyIgnore?insertStep.onDuplicateKeyIgnore():insertStep; }); }
public UUID insert(DSLContext tx, UUID orgId, String name, String description) { return tx.insertInto(TEAMS) .columns(TEAMS.ORG_ID, TEAMS.TEAM_NAME, TEAMS.DESCRIPTION) .values(orgId, name, description) .returning(TEAMS.TEAM_ID) .fetchOne() .getTeamId(); }
@Override public EXECUTE insert(Collection<P> pojos, boolean onDuplicateKeyIgnore) { Arguments.require(!pojos.isEmpty(), "No elements"); return queryExecutor().execute(dslContext -> { InsertSetStep<R> insertSetStep = dslContext.insertInto(getTable()); InsertValuesStepN<R> insertValuesStepN = null; for (P pojo : pojos) { insertValuesStepN = insertSetStep.values(newRecord(dslContext, pojo).intoArray()); } return onDuplicateKeyIgnore?insertValuesStepN.onDuplicateKeyIgnore():insertValuesStepN; }); }
private UUID insert(DSLContext tx, UUID ownerId, String name, UUID orgId, UUID parentId, InventoryVisibility visibility) { if (visibility == null) { visibility = InventoryVisibility.PUBLIC; } return tx.insertInto(INVENTORIES) .columns(INVENTORIES.OWNER_ID, INVENTORIES.INVENTORY_NAME, INVENTORIES.ORG_ID, INVENTORIES.PARENT_INVENTORY_ID, INVENTORIES.VISIBILITY) .values(ownerId, name, orgId, parentId, visibility.toString()) .returning(INVENTORIES.INVENTORY_ID) .fetchOne() .getInventoryId(); }
@SuppressWarnings("unchecked") @Override public void createRoles(DynamicSchema dynamicSchema) { List<String> roles = (List<String>) CollectionUtils.toList(CollectionUtils.getNestedValue(dynamicSchema.getData(), "fields", "roles")); InsertValuesStep2<DynamicSchemaRoleRecord, Long, String> insertStart = create() .insertInto(DYNAMIC_SCHEMA_ROLE, DYNAMIC_SCHEMA_ROLE.DYNAMIC_SCHEMA_ID, DYNAMIC_SCHEMA_ROLE.ROLE); for (String role: roles) { insertStart = insertStart.values(dynamicSchema.getId(), role); } insertStart.execute(); }
public void upsertAccessLevel(DSLContext tx, UUID inventoryId, UUID teamId, ResourceAccessLevel level) { tx.insertInto(INVENTORY_TEAM_ACCESS) .columns(INVENTORY_TEAM_ACCESS.INVENTORY_ID, INVENTORY_TEAM_ACCESS.TEAM_ID, INVENTORY_TEAM_ACCESS.ACCESS_LEVEL) .values(inventoryId, teamId, level.toString()) .onDuplicateKeyUpdate() .set(INVENTORY_TEAM_ACCESS.ACCESS_LEVEL, level.toString()) .execute(); }
public INSERT_RETURNING insertReturningPrimary(P object){ UniqueKey<?> key = getTable().getPrimaryKey(); //usually key shouldn't be null because DAO generation is omitted in such cases Objects.requireNonNull(key,()->"No primary key"); return queryExecutor().insertReturning( dslContext -> dslContext.insertInto(getTable()).set(newRecord(dslContext, object)).returning(key.getFields()), keyConverter()); }
private UUID insert(DSLContext tx, UUID inventoryId, String queryName, String text) { return tx.insertInto(INVENTORY_QUERIES) .columns(INVENTORY_QUERIES.INVENTORY_ID, INVENTORY_QUERIES.QUERY_NAME, INVENTORY_QUERIES.QUERY_TEXT) .values(value(inventoryId), value(queryName), value(text)) .returning(INVENTORY_QUERIES.QUERY_ID) .fetchOne() .getQueryId(); }