/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, field4) * .values(field1, field2, field3, field4) * .values(field1, field2, field3, field4) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4> InsertValuesStep4<R, T1, T2, T3, T4> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4) { return (InsertValuesStep4) insertInto(into, new Field[] { field1, field2, field3, field4 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field6, field7) * .values(valueA1, valueA2, valueA3, .., valueA6, valueA7) * .values(valueB1, valueB2, valueB3, .., valueB6, valueB7) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7> InsertValuesStep7<R, T1, T2, T3, T4, T5, T6, T7> 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) { return (InsertValuesStep7) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field14, field15) * .values(valueA1, valueA2, valueA3, .., valueA14, valueA15) * .values(valueB1, valueB2, valueB3, .., valueB14, valueB15) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> InsertValuesStep15<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> 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) { return (InsertValuesStep15) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field16, field17) * .values(valueA1, valueA2, valueA3, .., valueA16, valueA17) * .values(valueB1, valueB2, valueB3, .., valueB16, valueB17) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> InsertValuesStep17<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> 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) { return (InsertValuesStep17) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, field4, field5) * .values(field1, field2, field3, field4, field5) * .values(field1, field2, field3, field4, field5) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5> InsertValuesStep5<R, T1, T2, T3, T4, T5> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2, Field<T3> field3, Field<T4> field4, Field<T5> field5) { return (InsertValuesStep5) insertInto(into, new Field[] { field1, field2, field3, field4, field5 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field7, field8) * .values(valueA1, valueA2, valueA3, .., valueA7, valueA8) * .values(valueB1, valueB2, valueB3, .., valueB7, valueB8) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8> InsertValuesStep8<R, T1, T2, T3, T4, T5, T6, T7, T8> 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) { return (InsertValuesStep8) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field9, field10) * .values(valueA1, valueA2, valueA3, .., valueA9, valueA10) * .values(valueB1, valueB2, valueB3, .., valueB9, valueB10) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> InsertValuesStep10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> 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) { return (InsertValuesStep10) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field10, field11) * .values(valueA1, valueA2, valueA3, .., valueA10, valueA11) * .values(valueB1, valueB2, valueB3, .., valueB10, valueB11) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <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 (InsertValuesStep11) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field11, field12) * .values(valueA1, valueA2, valueA3, .., valueA11, valueA12) * .values(valueB1, valueB2, valueB3, .., valueB11, valueB12) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <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 (InsertValuesStep12) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2) * .values(field1, field2) * .values(field1, field2) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2> InsertValuesStep2<R, T1, T2> insertInto(Table<R> into, Field<T1> field1, Field<T2> field2) { return (InsertValuesStep2) insertInto(into, new Field[] { field1, field2 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field8, field9) * .values(valueA1, valueA2, valueA3, .., valueA8, valueA9) * .values(valueB1, valueB2, valueB3, .., valueB8, valueB9) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9> InsertValuesStep9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9> 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) { return (InsertValuesStep9) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field12, field13) * .values(valueA1, valueA2, valueA3, .., valueA12, valueA13) * .values(valueB1, valueB2, valueB3, .., valueB12, valueB13) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> InsertValuesStep13<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> 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) { return (InsertValuesStep13) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field17, field18) * .values(valueA1, valueA2, valueA3, .., valueA17, valueA18) * .values(valueB1, valueB2, valueB3, .., valueB17, valueB18) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> InsertValuesStep18<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> 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) { return (InsertValuesStep18) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field18, field19) * .values(valueA1, valueA2, valueA3, .., valueA18, valueA19) * .values(valueB1, valueB2, valueB3, .., valueB18, valueB19) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <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 (InsertValuesStep19) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14, field15, field16, field17, field18, field19 }); }
/** * Create a new DSL insert statement. * <p> * Unlike {@link Insert} factory methods in the {@link DSLContext} API, this * creates an unattached, and thus not directly renderable or executable * <code>INSERT</code> statement. * <p> * Example: <code><pre> * import static org.jooq.impl.DSL.*; * * // [...] * * insertInto(table, field1, field2, field3, .., field13, field14) * .values(valueA1, valueA2, valueA3, .., valueA13, valueA14) * .values(valueB1, valueB2, valueB3, .., valueB13, valueB14) * .onDuplicateKeyUpdate() * .set(field1, value1) * .set(field2, value2) * </pre></code> * * @see DSLContext#insertInto(Table, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field, Field) */ @Generated("This method was generated using jOOQ-tools") @Support public static <R extends Record, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> InsertValuesStep14<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> 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) { return (InsertValuesStep14) insertInto(into, new Field[] { field1, field2, field3, field4, field5, field6, field7, field8, field9, field10, field11, field12, field13, field14 }); }
@Override public Query getInsertStatement(Edge element) { JdbcSchema.Row row = toRow(element); if (row == null) return null; Map<Field<Object>, Object> fields = row.getFields().entrySet().stream() .collect(Collectors.toMap((entry) -> field(entry.getKey()), Map.Entry::getValue)); // return DSL.update(table(getTable())).set(fields).where(field(this.getFieldByPropertyKey(T.id.getAccessor())).eq(row.getId())); return DSL.insertInto(table(getTable())).set(fields); } }
@Override public Query getInsertStatement(E element) { JdbcSchema.Row row = toRow(element); if (row == null) return null; return DSL.insertInto(table(getTable()), CollectionUtils.collect(row.getFields().keySet(), DSL::field)) .values(row.getFields().values()); }
@Override public final void formatInsert(Writer writer, Table<?> table, Field<?>... f) { DSLContext ctx = configuration.dsl(); try { for (R record : this) { if (table == null) if (record instanceof TableRecord) table = ((TableRecord<?>) record).getTable(); else table = table(name("UNKNOWN_TABLE")); writer.append(ctx.renderInlined(insertInto(table, f).values(record.intoArray()))) .append(";\n"); } writer.flush(); } catch (java.io.IOException e) { throw new IOException("Exception while writing INSERTs", e); } }
private final void toSQLMySQLOnDuplicateKeyUpdate(Context<?> ctx) { Fields<?> fields = new Fields<Record>(getUpsertFields()); Map<Field<?>, Field<?>> map = new LinkedHashMap<Field<?>, Field<?>>(); for (Field<?> field : fields.fields) map.put(field, getUpsertValues().get(fields.indexOf(field))); if (upsertSelect != null) { ctx.sql("[ merge with select is not supported in MySQL / MariaDB ]"); } else { ctx.visit(insertInto(table, getUpsertFields()) .values(getUpsertValues()) .onDuplicateKeyUpdate() .set(map)); } }
private final void toPostgresInsertOnConflict(Context<?> ctx) { if (upsertSelect != null) { ctx.sql("[ merge with select is not supported in PostgreSQL ]"); } else { Fields<?> fields = new Fields<Record>(getUpsertFields()); Map<Field<?>, Field<?>> map = new LinkedHashMap<Field<?>, Field<?>>(); for (Field<?> field : fields.fields) { int i = fields.indexOf(field); if (i > -1 && i < getUpsertValues().size()) map.put(field, getUpsertValues().get(i)); } ctx.visit(insertInto(table, getUpsertFields()) .values(getUpsertValues()) .onConflict(getUpsertKeys()) .doUpdate() .set(map)); } }