How to use

columns

method

in

com.querydsl.sql.dml.SQLInsertClause

} else {
  final Long propertyId = queryFactory.insert(addonProperties)
      .columns()
      .set(addonProperties.ADDON_KEY, addonKey)
      .set(addonProperties.PROPERTY_KEY, propertyKey)

  @Transactional
  public Pizza save(Pizza pizza) {

    Long pizzaId = sqlQueryFactory.insert(qPizza)
        .columns(qPizza.baseId, qPizza.name, qPizza.price)
        .values(pizza.getBase().getId(), pizza.getName(), pizza.getPrice())
        .executeWithKey(Long.class);

    SQLInsertClause insert = sqlQueryFactory.insert(qPizzaToppings);
    pizza.getToppings().forEach(tpg -> insert.values(pizzaId, tpg.getId()).addBatch());
    insert.execute();

    pizza.setId(pizzaId);
    return pizza;
  }
}

public void insertOrUpdateDescriptor(PostgreSQLQueryFactory queryFactory, String addonKey, String jsonDescriptor) {
  final QAtlassianConnectDescriptors atlassianConnectDescriptors = new QAtlassianConnectDescriptors(rdbmsSchemaService.get().getSandbox());
  final long rowCount = queryFactory.query()
      .from(atlassianConnectDescriptors)
      .where(atlassianConnectDescriptors.ADDON_KEY.eq(addonKey))
      .fetchCount();
  if(rowCount > 0) {
    final long rowsUpdated = queryFactory.update(atlassianConnectDescriptors)
        .set(atlassianConnectDescriptors.DESCRIPTOR, jsonDescriptor)
        .where(atlassianConnectDescriptors.ADDON_KEY.eq(addonKey))
        .execute();
    if (rowsUpdated != 1) {
      throw new IllegalStateException(String.format("Failed to update descriptor of an add-on '%s'", addonKey));
    }
  } else {
    final long rowsInserted = queryFactory.insert(atlassianConnectDescriptors)
        .columns()
        .set(atlassianConnectDescriptors.ADDON_KEY, addonKey)
        .set(atlassianConnectDescriptors.DESCRIPTOR, jsonDescriptor)
        .execute();
    if (rowsInserted != 1) {
      throw new IllegalStateException(String.format("Failed to insert descriptor of an add-on '%s'", addonKey));
    }
  }
}

if (remnant.getSharedSecret().isPresent()) { // NONE -> JWT, where there is no OAuthClientID
  final long rowsInserted = queryFactory.insert(atlassianConnectAddonRemnant)
      .columns()
      .set(atlassianConnectAddonRemnant.ADDON_KEY, addonKey)
      .set(atlassianConnectAddonRemnant.SHARED_SECRET, remnant.getSharedSecret().get())
      .columns()
      .set(atlassianConnectAddonRemnant.ADDON_KEY, addonKey)
      .set(atlassianConnectAddonRemnant.OAUTH_CLIENT_ID, remnant.getOAuthClientId().get())

.columns()
.set(atlassianConnectAddonData.ADDON_KEY, rawConnectAddon.getAddonKey())
.set(atlassianConnectAddonData.BASE_URL, rawConnectAddon.getBaseUrl())

  @Test
  @ExcludeIn(ORACLE)
  public void insert_nulls_in_batch() {
//        QFoo f= QFoo.foo;
//        SQLInsertClause sic = new SQLInsertClause(c, new H2Templates(), f);
//        sic.columns(f.c1,f.c2).values(null,null).addBatch();
//        sic.columns(f.c1,f.c2).values(null,1).addBatch();
//        sic.execute();
    SQLInsertClause sic = insert(survey);
    sic.columns(survey.name, survey.name2).values(null, null).addBatch();
    sic.columns(survey.name, survey.name2).values(null, "X").addBatch();
    assertEquals(2, sic.execute());
  }

.columns()
.set(atlassianConnecListing.ADDON_KEY, addonKey)
.set(atlassianConnecListing.ADDON_NAME, rawConnectAddonListingData.getAddonName().orElse(null))

@Test
public void insert_with_columns() {
  assertEquals(1, insert(survey)
      .columns(survey.id, survey.name)
      .values(3, "Hello").execute());
}

@Test
public void insert_null_with_columns() {
  assertEquals(1, insert(survey)
      .columns(survey.id, survey.name)
      .values(3, null).execute());
}

@Test
@IncludeIn(MYSQL)
@SkipForQuoted
public void replace() {
  SQLInsertClause clause = mysqlReplace(survey);
  clause.columns(survey.id, survey.name)
    .values(3, "Hello");
  assertEquals("replace into SURVEY (ID, NAME) values (?, ?)", clause.toString());
  clause.execute();
}

@Before
public void setUp() throws Exception {
  new CreateTableClause(connection, configuration, "quoting")
      .column("from", String.class).size(30)
      .column("all", Boolean.class)
      .execute();
  execute(insert(quoting)
      .columns(quoting.from, quoting.all)
      .values("from", true));
}

@Test
@ExcludeIn(FIREBIRD) // too slow
public void insertBatch_with_subquery() {
  SQLInsertClause insert = insert(survey)
    .columns(survey.id, survey.name)
    .select(query().from(survey2).select(survey2.id.add(20), survey2.name))
    .addBatch();
  insert(survey)
    .columns(survey.id, survey.name)
    .select(query().from(survey2).select(survey2.id.add(40), survey2.name))
    .addBatch();
  assertEquals(1, insert.execute());
}

@Test
@IncludeIn(MYSQL)
@SkipForQuoted
public void insert_with_special_options() {
  SQLInsertClause clause = insert(survey)
    .columns(survey.id, survey.name)
    .values(3, "Hello");
  clause.addFlag(Position.START_OVERRIDE, "insert ignore into ");
  assertEquals("insert ignore into SURVEY (ID, NAME) values (?, ?)", clause.toString());
  assertEquals(1, clause.execute());
}

@Test
@ExcludeIn(FIREBIRD) // too slow
public void insert_with_subQuery() {
  int count = (int) query().from(survey).fetchCount();
  assertEquals(count, insert(survey)
    .columns(survey.id, survey.name)
    .select(query().from(survey2).select(survey2.id.add(20), survey2.name))
    .execute());
}

@Test
public void updateBatchFailed() {
  execute(insert(survey).columns(survey.name, survey.name2)
      .values("New Survey", "New Survey"));
  Exception result = null;
  try {
    execute(update(survey)
        .set(survey.id, 1).addBatch()
        .set(survey.id, 2).addBatch());
  } catch (QueryException e) {
    result = e;
  }
  assertNotNull(result);
  inspectExceptionResult(result);
}

@Test
@ExcludeIn(FIREBIRD) // too slow
public void insert_with_subQuery_Params() {
  Param<Integer> param = new Param<Integer>(Integer.class, "param");
  SQLQuery<?> sq = query().from(survey2);
  sq.set(param, 20);
  int count = (int) query().from(survey).fetchCount();
  assertEquals(count, insert(survey)
    .columns(survey.id, survey.name)
    .select(sq.select(survey2.id.add(param), survey2.name))
    .execute());
}

@Test
public void complex1() {
  // related to #584795
  QSurvey survey = new QSurvey("survey");
  QEmployee emp1 = new QEmployee("emp1");
  QEmployee emp2 = new QEmployee("emp2");
  SQLInsertClause insert = insert(survey);
  insert.columns(survey.id, survey.name);
  insert.select(select(survey.id, emp2.firstname).from(survey)
   .innerJoin(emp1)
    .on(survey.id.eq(emp1.id))
   .innerJoin(emp2)
    .on(emp1.superiorId.eq(emp2.superiorId), emp1.firstname.eq(emp2.firstname)));
  assertEquals(0, insert.execute());
}

  @Test
  @ExcludeIn({HSQLDB, CUBRID, DERBY})
  public void insert_with_subQuery3() {
//        insert into modules(name)
//        select 'MyModule'
//        where not exists
//        (select 1 from modules where modules.name = 'MyModule')

    assertEquals(1, insert(survey).columns(survey.name).select(
      query().where(query().from(survey2)
              .where(survey2.name.eq("MyModule2")).notExists())
        .select(Expressions.constant("MyModule2")))
      .execute());

    assertEquals(1L , query().from(survey).where(survey.name.eq("MyModule2")).fetchCount());
  }