How to use

formatNewLine

method

in

org.jooq.RenderContext

@Override
public final void toSQL(RenderContext context) {
  // If this is already a subquery, proceed
  if (context.subquery()) {
    context.formatIndentStart()
        .formatNewLine()
        .visit(query)
        .formatIndentEnd()
        .formatNewLine();
  }
  else {
    context.subquery(true)
        .formatIndentStart()
        .formatNewLine()
        .visit(query)
        .formatIndentEnd()
        .formatNewLine()
        .subquery(false);
  }
}

.formatNewLine();
.formatNewLine();

private final void wrappingParenthesis(RenderContext context, String parenthesis) {
  switch (context.configuration().dialect()) {
    // Sybase ASE, Derby, Firebird and SQLite have some syntax issues with unions.
    // Check out https://issues.apache.org/jira/browse/DERBY-2374
    /* [pro] xx
    xxxx xxxxxxx
    xxxx xxxx
    xx [/pro] */
    case DERBY:
    case FIREBIRD:
    case SQLITE:
    // [#288] MySQL has a very special way of dealing with UNION's
    // So include it as well
    case MARIADB:
    case MYSQL:
      return;
  }
  if (")".equals(parenthesis)) {
    context.formatIndentEnd()
        .formatNewLine();
  }
  context.sql(parenthesis);
  if ("(".equals(parenthesis)) {
    context.formatIndentStart()
        .formatNewLine();
  }
}

private void toSQLTable(RenderContext context, Table<?> table) {
  // [#671] Some databases formally require nested JOINS on the right hand
  // side of the join expression to be wrapped in parentheses (e.g. MySQL).
  // In other databases, it's a good idea to wrap them all
  boolean wrap = table instanceof JoinTable &&
    (table == rhs || asList().contains(context.configuration().dialect().family()));
  if (wrap) {
    context.sql("(")
        .formatIndentStart()
        .formatNewLine();
  }
  context.visit(table);
  if (wrap) {
    context.formatIndentEnd()
        .formatNewLine()
        .sql(")");
  }
}

context.sql("(")
    .formatIndentStart()
    .formatNewLine();
    .formatNewLine()
    .sql(")");

  @Override
  public final void toSQL(RenderContext context) {

    // If this is already a subquery, proceed
    if (context.subquery()) {
      context.sql("(")
          .formatIndentStart()
          .formatNewLine()
          .visit(query)
          .formatIndentEnd()
          .formatNewLine()
          .sql(")");
    }
    else {
      context.sql("(")
          .subquery(true)
          .formatIndentStart()
          .formatNewLine()
          .visit(query)
          .formatIndentEnd()
          .formatNewLine()
          .subquery(false)
          .sql(")");
    }
  }
}

    .formatNewLine();
  context.formatNewLine();
context.formatIndentEnd().formatNewLine();

@Override
public final void toSQL(RenderContext context) {
  boolean indent = (size() > 1);
  context.sql("(");
  if (indent) {
    context.formatIndentStart();
  }
  String separator = "";
  for (Field<?> field : values()) {
    context.sql(separator);
    if (indent) {
      context.formatNewLine();
    }
    context.visit(field);
    separator = ", ";
  }
  if (indent) {
    context.formatIndentEnd()
        .formatNewLine();
  }
  context.sql(")");
}

.formatIndentStart(e1.indent)
.formatIndentStart()
.formatNewLine()
.visit(e1.joinNode.joinTree())
.formatNewLine()
.sql(')')
.render();

@Override
public final void toSQL(RenderContext context) {
  // If this is already a subquery, proceed
  if (context.subquery()) {
    context.keyword(operator.toSQL())
        .sql(" (")
        .formatIndentStart()
        .formatNewLine()
        .visit(query)
        .formatIndentEnd()
        .formatNewLine()
        .sql(")");
  }
  else {
    context.keyword(operator.toSQL())
        .sql(" (")
        .subquery(true)
        .formatIndentStart()
        .formatNewLine()
        .visit(query)
        .formatIndentEnd()
        .formatNewLine()
        .subquery(false)
        .sql(")");
  }
}

@Override
public final void toSQL(RenderContext context) {
  if (size() > 0) {
    String separator = "";
    // [#989] Some dialects do not support qualified column references
    // in the UPDATE statement's SET clause
    // [#2055] Other dialects require qualified column references to
    // disambiguated columns in queries like
    // UPDATE t1 JOIN t2 .. SET t1.val = ..., t2.val = ...
    boolean restoreQualify = context.qualify();
    boolean supportsQualify = asList(POSTGRES, SQLITE).contains(context.configuration().dialect()) ? false : restoreQualify;
    for (Entry<Field<?>, Field<?>> entry : entrySet()) {
      context.sql(separator);
      if (!"".equals(separator)) {
        context.formatNewLine();
      }
      context.start(assignmentClause)
          .qualify(supportsQualify)
          .visit(entry.getKey())
          .qualify(restoreQualify)
          .sql(" = ")
          .visit(entry.getValue())
          .end(assignmentClause);
      separator = ", ";
    }
  }
  else {
    context.sql("[ no fields are updated ]");
  }
}

context.sql("(")
    .formatIndentStart()
    .formatNewLine();
    .formatNewLine()
    .sql(")");
break;

@Override
public final void toSQL(RenderContext ctx) {
  // If this is already a subquery, proceed
  if (ctx.subquery()) {
    ctx.keyword(quantifier.toSQL())
      .sql(" (")
      .formatIndentStart()
      .formatNewLine()
      .visit(delegate(ctx.configuration()))
      .formatIndentEnd()
      .formatNewLine()
      .sql(")");
  }
  else {
    ctx.keyword(quantifier.toSQL())
      .sql(" (")
      .subquery(true)
      .formatIndentStart()
      .formatNewLine()
      .visit(delegate(ctx.configuration()))
      .formatIndentEnd()
      .formatNewLine()
      .subquery(false)
      .sql(")");
  }
}

final void toSQLReferenceKeys(RenderContext context) {
  boolean indent = (size() > 1);
  context.sql("(");
  if (indent) {
    context.formatIndentStart();
  }
  // [#989] Avoid qualifying fields in INSERT field declaration
  boolean qualify = context.qualify();
  context.qualify(false);
  String separator = "";
  for (Field<?> field : keySet()) {
    context.sql(separator);
    if (indent) {
      context.formatNewLine();
    }
    context.visit(field);
    separator = ", ";
  }
  context.qualify(qualify);
  if (indent) {
    context.formatIndentEnd()
        .formatNewLine();
  }
  context.sql(")");
}

@Override
public final void toSQL(RenderContext context) {
  // If this is already a subquery, proceed
  if (context.subquery()) {
    context.visit(field)
        .sql(" ")
        .keyword(comparator.toSQL())
        .sql(" (")
        .formatIndentStart()
        .formatNewLine()
        .visit(query)
        .formatIndentEnd()
        .formatNewLine()
        .sql(")");
  }
  else {
    context.visit(field)
        .sql(" ")
        .keyword(comparator.toSQL())
        .sql(" (")
        .subquery(true)
        .formatIndentStart()
        .formatNewLine()
        .visit(query)
        .formatIndentEnd()
        .formatNewLine()
        .subquery(false)
        .sql(")");
  }
}

context.formatNewLine();

  select(list(field("*"))).from(((Table<?>) wrapped).as(alias));
context.sql("(").formatIndentStart().formatNewLine()
    .visit(select).formatIndentEnd().formatNewLine()
    .sql(")");
  select(field("*")).from(((Table<?>) wrapped).as(alias)));
context.sql("(").formatIndentStart().formatNewLine()
    .visit(select).formatIndentEnd().formatNewLine()
    .sql(")");

    .formatNewLine()
    .subquery(true)
    .visit(selects)
    .subquery(subquery)
    .formatIndentEnd()
    .formatNewLine();
break;

.formatNewLine()
.subquery(true)
.visit(select)
.subquery(false)
.formatIndentEnd()
.formatNewLine()
.sql(")");

    .keyword("using").sql(" ")
    .formatIndentStart()
    .formatNewLine();
context.data(DATA_WRAP_DERIVED_TABLES_IN_PARENTHESES, true);
context.visit(using);