How to use

keyword

method

in

org.jooq.RenderContext

@Override
public final void toSQL(RenderContext ctx) {
  ctx.keyword(keyword);
}

TableLike<?> values(DSLContext ctx, RowN[] rows, String tableName, String... fieldNames) {
  switch (sqlDialect.family()) {
  case H2:
    List<SelectField<?>> fields = Lists.newArrayListWithCapacity(fieldNames.length);
    for (int i = 1; i <= fieldNames.length; i++) {
      fields.add(DSL.field("C" + i).as(fieldNames[i-1]));
    }
    RenderContext context = ctx.renderContext();
    context.start(TABLE_VALUES)
      .keyword("values")
      .formatIndentLockStart();
    boolean firstRow = true;
    for (Row row : rows) {
      if (!firstRow) {
        context.sql(',').formatSeparator();
      }
      context.sql(row.toString());
      firstRow = false;
    }
    context.formatIndentLockEnd()
      .end(TABLE_VALUES);
    String valuesClause = context.render();
    return ctx.select(fields).from(valuesClause).asTable(tableName);
  default:
    return DSL.values(rows).as(tableName, fieldNames);
  }
}

@Override
public final void toSQL(RenderContext context) {
  context.visit(row)
      .sql(" ")
      .keyword(isNull ? "is null" : "is not null");
}

@Override
public final void toSQL(RenderContext ctx) {
  ctx.keyword("lateral")
    .sql(" ")
    .visit(table);
}

static void toSQLAs(RenderContext context) {
  if (asList(DERBY, HSQLDB, MARIADB, MYSQL, POSTGRES).contains(context.configuration().dialect())) {
    context.sql(" ").keyword("as");
  }
}

@Override
public final void toSQL(RenderContext context) {
  context.keyword("not(").visit(condition).sql(")");
}

@Override
public final void toSQL(RenderContext context) {
  context.visit(field).sql(" ").keyword(isNull ? "is null" : "is not null");
}

/**
 * Render <code>KEEP (DENSE_RANK [FIRST | LAST] ORDER BY {...})</code> clause
 */
private void toSQLKeepDenseRankOrderByClause(RenderContext ctx) {
  if (!keepDenseRankOrderBy.isEmpty()) {
    ctx.sql(" ").keyword("keep")
      .sql(" (").keyword("dense_rank")
      .sql(" ").keyword(first ? "first" : "last")
      .sql(" ").keyword("order by")
      .sql(" ").visit(keepDenseRankOrderBy)
      .sql(")");
  }
}

  @Override
  public void toSQL(RenderContext context) {
    context.sql("(").keyword("select").sql(" * ")
        .keyword("from").sql(" ").keyword("unnest").sql("(").visit(array).sql(") ")
        .keyword("as").sql(" ").literal(alias)
        .sql("(").literal("COLUMN_VALUE").sql("))");
  }
}

/**
 * Render <code>WITHIN GROUP (ORDER BY ..)</code> clause
 */
private final void toSQLWithinGroupClause(RenderContext ctx) {
  if (!withinGroupOrderBy.isEmpty()) {
    ctx.sql(" ").keyword("within group")
      .sql(" (").keyword("order by")
      .sql(" ").visit(withinGroupOrderBy)
      .sql(")");
  }
}

  @Override
  public void toSQL(RenderContext context) {
    context.keyword("table(").sql("COLUMN_VALUE ");
    // If the array type is unknown (e.g. because it's returned from
    // a stored function
    // Then the best choice for arbitrary types is varchar
    if (array.getDataType().getType() == Object[].class) {
      context.keyword(H2DataType.VARCHAR.getTypeName());
    }
    else {
      context.keyword(array.getDataType().getTypeName());
    }
    context.sql(" = ").visit(array).sql(")");
  }
}

@Override
public final void toSQL(RenderContext context) {
  for (int i = 0; i < queries.size(); i++) {
    if (i != 0) {
      context.formatSeparator()
          .keyword(operator.toSQL(context.configuration().dialect()))
          .formatSeparator();
    }
    wrappingParenthesis(context, "(");
    context.visit(queries.get(i));
    wrappingParenthesis(context, ")");
  }
}

@Override
public final void toSQL(RenderContext context) {
  context.visit(delegate)
      .sql(" ").keyword("with")
      .sql(" (").sql(hint)
      .sql(")");
}

private final void toSQLCast(RenderContext context, DataType<?> type, int length, int precision, int scale) {
  context.keyword("cast").sql("(");
  toSQL(context, value, getType());
  context.sql(" ").keyword("as").sql(" ")
      .sql(type.length(length).precision(precision, scale).getCastTypeName(context.configuration()))
      .sql(")");
}

@Override
public final void toSQL(RenderContext context) {
  context.visit(field)
      .sql(" ")
      .keyword(comparator.toSQL())
      .sql(" ")
      .visit(query);
}

@Override
public final void toSQL(RenderContext context) {
  context.visit(left)
      .sql(" ")
      .keyword(comparator.toSQL())
      .sql(" (")
      .visit(right)
      .sql(")");
}

@Override
public final void toSQL(RenderContext context) {
  switch (context.configuration().dialect()) {
    case HSQLDB: {
      context.keyword("table(").visit(function).sql(")");
      break;
    }
    default:
      throw new SQLDialectNotSupportedException("FUNCTION TABLE is not supported for " + context.configuration().dialect());
  }
}

final void toSQLReturning(RenderContext context) {
  if (!returning.isEmpty()) {
    switch (context.configuration().dialect()) {
      case FIREBIRD:
      case POSTGRES:
        context.formatSeparator()
            .keyword("returning")
            .sql(" ")
            .visit(returning);
        break;
      default:
        // Other dialects don't render a RETURNING clause, but
        // use JDBC's Statement.RETURN_GENERATED_KEYS mode instead
        break;
    }
  }
}

private final void toSQLOverClause(RenderContext ctx) {
  QueryPart window = window(ctx);
  // Render this clause only if needed
  if (window == null)
    return;
  // [#1524] Don't render this clause where it is not supported
  if (term == ROW_NUMBER && ctx.configuration().dialect() == HSQLDB)
    return;
  ctx.sql(" ")
    .keyword("over")
    .sql(" (")
    .visit(window)
    .sql(")");
}

@Override
public final void toSQL(RenderContext context) {
  // Some databases need extra parentheses around the RHS
  boolean extraParentheses = asList().contains(context.configuration().dialect().family());
  boolean subquery = context.subquery();
  context.visit(left)
      .sql(" ")
      .keyword(comparator.toSQL())
      .sql(" (")
      .sql(extraParentheses ? "(" : "");
  context.data(DATA_ROW_VALUE_EXPRESSION_PREDICATE_SUBQUERY, true);
  context.subquery(true)
      .visit(right)
      .subquery(subquery);
  context.data(DATA_ROW_VALUE_EXPRESSION_PREDICATE_SUBQUERY, null);
  context.sql(extraParentheses ? ")" : "")
      .sql(")");
}