All Downloads are FREE. Search and download functionalities are using the official Maven repository.

app.cash.sqldelight.dialects.sqlite_3_25.grammar.SqliteParser Maven / Gradle / Ivy

Go to download

The SQLite v3.25 Dialect for SQLDelight

The newest version!
// This is a generated file. Not intended for manual editing.
package app.cash.sqldelight.dialects.sqlite_3_25.grammar;

import com.intellij.lang.PsiBuilder;
import com.intellij.lang.PsiBuilder.Marker;
import static app.cash.sqldelight.dialects.sqlite_3_25.grammar.psi.SqliteTypes.*;
import static app.cash.sqldelight.dialects.sqlite_3_25.grammar.SqliteParserUtil.*;
import com.intellij.psi.tree.IElementType;
import com.intellij.lang.ASTNode;
import com.intellij.psi.tree.TokenSet;
import com.intellij.lang.PsiParser;
import com.intellij.lang.LightPsiParser;
import static com.alecstrong.sql.psi.core.SqlParser.*;
import static com.alecstrong.sql.psi.core.SqlParserUtil.alterTableAddColumnExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.alterTableRenameTableExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.tableNameExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.columnAliasExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.resultColumnExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.joinClauseExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.groupByExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.valuesExpressionExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.columnNameExt;
import static com.alecstrong.sql.psi.core.SqlParserUtil.orderingTermExt;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.ALL;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.AND;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.AS;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.BETWEEN;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.BY;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.COLUMN;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.COMMA;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.DISTINCT;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.DOT;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.FROM;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.GROUP;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.HAVING;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.ID;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.LP;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.MULTIPLY;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.NO;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.ORDER;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.PARTITION;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.RENAME;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.ROW;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.RP;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.SELECT;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.TO;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.VALUES;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.WHERE;
import static com.alecstrong.sql.psi.core.psi.SqlTypes.WINDOW;

@SuppressWarnings({"SimplifiableIfStatement", "UnusedAssignment"})
public class SqliteParser implements PsiParser, LightPsiParser {

  public ASTNode parse(IElementType root_, PsiBuilder builder_) {
    parseLight(root_, builder_);
    return builder_.getTreeBuilt();
  }

  public void parseLight(IElementType root_, PsiBuilder builder_) {
    boolean result_;
    builder_ = adapt_builder_(root_, builder_, this, null);
    Marker marker_ = enter_section_(builder_, 0, _COLLAPSE_, null);
    result_ = parse_root_(root_, builder_);
    exit_section_(builder_, 0, marker_, root_, result_, true, TRUE_CONDITION);
  }

  protected boolean parse_root_(IElementType root_, PsiBuilder builder_) {
    return parse_root_(root_, builder_, 0);
  }

  static boolean parse_root_(IElementType root_, PsiBuilder builder_, int level_) {
    return root(builder_, level_ + 1);
  }

  /* ********************************************************** */
  // id | string
  public static boolean alter_table_column_alias_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "alter_table_column_alias_real")) return false;
    if (!nextTokenIs(builder_, "", ID, STRING)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, ALTER_TABLE_COLUMN_ALIAS, "");
    result_ = consumeToken(builder_, ID);
    if (!result_) result_ = consumeToken(builder_, STRING);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // RENAME [ COLUMN ] <>>> TO <>
  public static boolean alter_table_rename_column_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "alter_table_rename_column_real")) return false;
    if (!nextTokenIs(builder_, RENAME)) return false;
    boolean result_, pinned_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, ALTER_TABLE_RENAME_COLUMN, null);
    result_ = consumeToken(builder_, RENAME);
    pinned_ = result_; // pin = 1
    result_ = result_ && report_error_(builder_, alter_table_rename_column_real_1(builder_, level_ + 1));
    result_ = pinned_ && report_error_(builder_, columnNameExt(builder_, level_ + 1, alter_table_rename_column_real_2_0_parser_)) && result_;
    result_ = pinned_ && report_error_(builder_, consumeToken(builder_, TO)) && result_;
    result_ = pinned_ && alterTableColumnAliasExt(builder_, level_ + 1, SqliteParser::alter_table_column_alias_real) && result_;
    exit_section_(builder_, level_, marker_, result_, pinned_, null);
    return result_ || pinned_;
  }

  // [ COLUMN ]
  private static boolean alter_table_rename_column_real_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "alter_table_rename_column_real_1")) return false;
    consumeToken(builder_, COLUMN);
    return true;
  }

  /* ********************************************************** */
  // <>>>
  //   | <>>>
  //   | <>
  public static boolean alter_table_rules_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "alter_table_rules_real")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, ALTER_TABLE_RULES, "");
    result_ = alterTableAddColumnExt(builder_, level_ + 1, alter_table_rules_real_0_0_parser_);
    if (!result_) result_ = alterTableRenameTableExt(builder_, level_ + 1, alter_table_rules_real_1_0_parser_);
    if (!result_) result_ = alterTableRenameColumnExt(builder_, level_ + 1, SqliteParser::alter_table_rename_column_real);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // id
  public static boolean base_window_name_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "base_window_name_real")) return false;
    if (!nextTokenIs(builder_, ID)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, ID);
    exit_section_(builder_, marker_, BASE_WINDOW_NAME, result_);
    return result_;
  }

  /* ********************************************************** */
  // ( 'RANGE' | 'ROWS' | 'GROUPS' )
  //   (
  //     BETWEEN (
  //       'UNBOUNDED' 'PRECEDING' |
  //       'CURRENT' ROW |
  //       <> 'PRECEDING' |
  //       <> 'FOLLOWING'
  //     ) AND (
  //       'UNBOUNDED' 'FOLLOWING' |
  //       'CURRENT' ROW |
  //       <> 'PRECEDING' |
  //       <> 'FOLLOWING'
  //     ) |
  //     'UNBOUNDED' 'PRECEDING' |
  //     'CURRENT' ROW |
  //     <> 'PRECEDING'
  //   ) [ 'EXCLUDE' NO 'OTHERS' | 'EXCLUDE' 'CURRENT' ROW | 'EXCLUDE' GROUP | 'EXCLUDE' 'TIES' ]
  public static boolean frame_spec_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real")) return false;
    boolean result_, pinned_;
    Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, FRAME_SPEC, "");
    result_ = frame_spec_real_0(builder_, level_ + 1);
    pinned_ = result_; // pin = 1
    result_ = result_ && report_error_(builder_, frame_spec_real_1(builder_, level_ + 1));
    result_ = pinned_ && frame_spec_real_2(builder_, level_ + 1) && result_;
    exit_section_(builder_, level_, marker_, result_, pinned_, null);
    return result_ || pinned_;
  }

  // 'RANGE' | 'ROWS' | 'GROUPS'
  private static boolean frame_spec_real_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_0")) return false;
    boolean result_;
    result_ = consumeToken(builder_, "RANGE");
    if (!result_) result_ = consumeToken(builder_, "ROWS");
    if (!result_) result_ = consumeToken(builder_, "GROUPS");
    return result_;
  }

  // BETWEEN (
  //       'UNBOUNDED' 'PRECEDING' |
  //       'CURRENT' ROW |
  //       <> 'PRECEDING' |
  //       <> 'FOLLOWING'
  //     ) AND (
  //       'UNBOUNDED' 'FOLLOWING' |
  //       'CURRENT' ROW |
  //       <> 'PRECEDING' |
  //       <> 'FOLLOWING'
  //     ) |
  //     'UNBOUNDED' 'PRECEDING' |
  //     'CURRENT' ROW |
  //     <> 'PRECEDING'
  private static boolean frame_spec_real_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = frame_spec_real_1_0(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_1(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_2(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // BETWEEN (
  //       'UNBOUNDED' 'PRECEDING' |
  //       'CURRENT' ROW |
  //       <> 'PRECEDING' |
  //       <> 'FOLLOWING'
  //     ) AND (
  //       'UNBOUNDED' 'FOLLOWING' |
  //       'CURRENT' ROW |
  //       <> 'PRECEDING' |
  //       <> 'FOLLOWING'
  //     )
  private static boolean frame_spec_real_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, BETWEEN);
    result_ = result_ && frame_spec_real_1_0_1(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, AND);
    result_ = result_ && frame_spec_real_1_0_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'UNBOUNDED' 'PRECEDING' |
  //       'CURRENT' ROW |
  //       <> 'PRECEDING' |
  //       <> 'FOLLOWING'
  private static boolean frame_spec_real_1_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = frame_spec_real_1_0_1_0(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_0_1_1(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_0_1_2(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_0_1_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'UNBOUNDED' 'PRECEDING'
  private static boolean frame_spec_real_1_0_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "UNBOUNDED");
    result_ = result_ && consumeToken(builder_, "PRECEDING");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'CURRENT' ROW
  private static boolean frame_spec_real_1_0_1_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_1_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "CURRENT");
    result_ = result_ && consumeToken(builder_, ROW);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <> 'PRECEDING'
  private static boolean frame_spec_real_1_0_1_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_1_2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && consumeToken(builder_, "PRECEDING");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <> 'FOLLOWING'
  private static boolean frame_spec_real_1_0_1_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_1_3")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && consumeToken(builder_, "FOLLOWING");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'UNBOUNDED' 'FOLLOWING' |
  //       'CURRENT' ROW |
  //       <> 'PRECEDING' |
  //       <> 'FOLLOWING'
  private static boolean frame_spec_real_1_0_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_3")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = frame_spec_real_1_0_3_0(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_0_3_1(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_0_3_2(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_1_0_3_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'UNBOUNDED' 'FOLLOWING'
  private static boolean frame_spec_real_1_0_3_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_3_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "UNBOUNDED");
    result_ = result_ && consumeToken(builder_, "FOLLOWING");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'CURRENT' ROW
  private static boolean frame_spec_real_1_0_3_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_3_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "CURRENT");
    result_ = result_ && consumeToken(builder_, ROW);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <> 'PRECEDING'
  private static boolean frame_spec_real_1_0_3_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_3_2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && consumeToken(builder_, "PRECEDING");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <> 'FOLLOWING'
  private static boolean frame_spec_real_1_0_3_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_0_3_3")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && consumeToken(builder_, "FOLLOWING");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'UNBOUNDED' 'PRECEDING'
  private static boolean frame_spec_real_1_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "UNBOUNDED");
    result_ = result_ && consumeToken(builder_, "PRECEDING");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'CURRENT' ROW
  private static boolean frame_spec_real_1_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "CURRENT");
    result_ = result_ && consumeToken(builder_, ROW);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <> 'PRECEDING'
  private static boolean frame_spec_real_1_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_1_3")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && consumeToken(builder_, "PRECEDING");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ 'EXCLUDE' NO 'OTHERS' | 'EXCLUDE' 'CURRENT' ROW | 'EXCLUDE' GROUP | 'EXCLUDE' 'TIES' ]
  private static boolean frame_spec_real_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_2")) return false;
    frame_spec_real_2_0(builder_, level_ + 1);
    return true;
  }

  // 'EXCLUDE' NO 'OTHERS' | 'EXCLUDE' 'CURRENT' ROW | 'EXCLUDE' GROUP | 'EXCLUDE' 'TIES'
  private static boolean frame_spec_real_2_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_2_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = frame_spec_real_2_0_0(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_2_0_1(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_2_0_2(builder_, level_ + 1);
    if (!result_) result_ = frame_spec_real_2_0_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'EXCLUDE' NO 'OTHERS'
  private static boolean frame_spec_real_2_0_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_2_0_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "EXCLUDE");
    result_ = result_ && consumeToken(builder_, NO);
    result_ = result_ && consumeToken(builder_, "OTHERS");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'EXCLUDE' 'CURRENT' ROW
  private static boolean frame_spec_real_2_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_2_0_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "EXCLUDE");
    result_ = result_ && consumeToken(builder_, "CURRENT");
    result_ = result_ && consumeToken(builder_, ROW);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'EXCLUDE' GROUP
  private static boolean frame_spec_real_2_0_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_2_0_2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "EXCLUDE");
    result_ = result_ && consumeToken(builder_, GROUP);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // 'EXCLUDE' 'TIES'
  private static boolean frame_spec_real_2_0_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "frame_spec_real_2_0_3")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "EXCLUDE");
    result_ = result_ && consumeToken(builder_, "TIES");
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // <> | <> | <>
  public static boolean overrides_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "overrides_real")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, OVERRIDES, "");
    result_ = alterTableRulesExt(builder_, level_ + 1, SqliteParser::alter_table_rules_real);
    if (!result_) result_ = resultColumnExt(builder_, level_ + 1, SqliteParser::result_column_real);
    if (!result_) result_ = selectStmtExt(builder_, level_ + 1, SqliteParser::select_stmt_real);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  /* ********************************************************** */
  // MULTIPLY
  //                   | <>>> DOT MULTIPLY
  //                   | (<> | <>) [ [ AS ] <>>> ]
  public static boolean result_column_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "result_column_real")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_, level_, _COLLAPSE_, RESULT_COLUMN, "");
    result_ = consumeToken(builder_, MULTIPLY);
    if (!result_) result_ = result_column_real_1(builder_, level_ + 1);
    if (!result_) result_ = result_column_real_2(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // <>>> DOT MULTIPLY
  private static boolean result_column_real_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "result_column_real_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = tableNameExt(builder_, level_ + 1, result_column_real_1_0_0_parser_);
    result_ = result_ && consumeTokens(builder_, 0, DOT, MULTIPLY);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // (<> | <>) [ [ AS ] <>>> ]
  private static boolean result_column_real_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "result_column_real_2")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = result_column_real_2_0(builder_, level_ + 1);
    result_ = result_ && result_column_real_2_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <> | <>
  private static boolean result_column_real_2_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "result_column_real_2_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = windowFunctionInvocationExt(builder_, level_ + 1, SqliteParser::window_function_invocation_real);
    if (!result_) result_ = expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ [ AS ] <>>> ]
  private static boolean result_column_real_2_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "result_column_real_2_1")) return false;
    result_column_real_2_1_0(builder_, level_ + 1);
    return true;
  }

  // [ AS ] <>>>
  private static boolean result_column_real_2_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "result_column_real_2_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = result_column_real_2_1_0_0(builder_, level_ + 1);
    result_ = result_ && columnAliasExt(builder_, level_ + 1, result_column_real_2_1_0_1_0_parser_);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ AS ]
  private static boolean result_column_real_2_1_0_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "result_column_real_2_1_0_0")) return false;
    consumeToken(builder_, AS);
    return true;
  }

  /* ********************************************************** */
  // <>
  static boolean root(PsiBuilder builder_, int level_) {
    return overridesExt(builder_, level_ + 1, SqliteParser::overrides_real);
  }

  /* ********************************************************** */
  // SELECT [ DISTINCT | ALL ] <>>> ( COMMA <>>> ) * [ FROM <>>> ] [ WHERE <> ] [<>>>] [ HAVING <> ] [ WINDOW <> AS <> ( COMMA <> AS <> ) * ] | VALUES <>>> ( COMMA <>>> ) *
  public static boolean select_stmt_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real")) return false;
    if (!nextTokenIs(builder_, "");
    result_ = select_stmt_real_0(builder_, level_ + 1);
    if (!result_) result_ = select_stmt_real_1(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, false, null);
    return result_;
  }

  // SELECT [ DISTINCT | ALL ] <>>> ( COMMA <>>> ) * [ FROM <>>> ] [ WHERE <> ] [<>>>] [ HAVING <> ] [ WINDOW <> AS <> ( COMMA <> AS <> ) * ]
  private static boolean select_stmt_real_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, SELECT);
    result_ = result_ && select_stmt_real_0_1(builder_, level_ + 1);
    result_ = result_ && resultColumnExt(builder_, level_ + 1, select_stmt_real_0_2_0_parser_);
    result_ = result_ && select_stmt_real_0_3(builder_, level_ + 1);
    result_ = result_ && select_stmt_real_0_4(builder_, level_ + 1);
    result_ = result_ && select_stmt_real_0_5(builder_, level_ + 1);
    result_ = result_ && select_stmt_real_0_6(builder_, level_ + 1);
    result_ = result_ && select_stmt_real_0_7(builder_, level_ + 1);
    result_ = result_ && select_stmt_real_0_8(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ DISTINCT | ALL ]
  private static boolean select_stmt_real_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_1")) return false;
    select_stmt_real_0_1_0(builder_, level_ + 1);
    return true;
  }

  // DISTINCT | ALL
  private static boolean select_stmt_real_0_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_1_0")) return false;
    boolean result_;
    result_ = consumeToken(builder_, DISTINCT);
    if (!result_) result_ = consumeToken(builder_, ALL);
    return result_;
  }

  // ( COMMA <>>> ) *
  private static boolean select_stmt_real_0_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_3")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!select_stmt_real_0_3_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "select_stmt_real_0_3", pos_)) break;
    }
    return true;
  }

  // COMMA <>>>
  private static boolean select_stmt_real_0_3_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_3_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && resultColumnExt(builder_, level_ + 1, select_stmt_real_0_3_0_1_0_parser_);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ FROM <>>> ]
  private static boolean select_stmt_real_0_4(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_4")) return false;
    select_stmt_real_0_4_0(builder_, level_ + 1);
    return true;
  }

  // FROM <>>>
  private static boolean select_stmt_real_0_4_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_4_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, FROM);
    result_ = result_ && joinClauseExt(builder_, level_ + 1, select_stmt_real_0_4_0_1_0_parser_);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ WHERE <> ]
  private static boolean select_stmt_real_0_5(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_5")) return false;
    select_stmt_real_0_5_0(builder_, level_ + 1);
    return true;
  }

  // WHERE <>
  private static boolean select_stmt_real_0_5_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_5_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, WHERE);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [<>>>]
  private static boolean select_stmt_real_0_6(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_6")) return false;
    groupByExt(builder_, level_ + 1, select_stmt_real_0_6_0_0_parser_);
    return true;
  }

  // [ HAVING <> ]
  private static boolean select_stmt_real_0_7(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_7")) return false;
    select_stmt_real_0_7_0(builder_, level_ + 1);
    return true;
  }

  // HAVING <>
  private static boolean select_stmt_real_0_7_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_7_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, HAVING);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ WINDOW <> AS <> ( COMMA <> AS <> ) * ]
  private static boolean select_stmt_real_0_8(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_8")) return false;
    select_stmt_real_0_8_0(builder_, level_ + 1);
    return true;
  }

  // WINDOW <> AS <> ( COMMA <> AS <> ) *
  private static boolean select_stmt_real_0_8_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_8_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, WINDOW);
    result_ = result_ && windowNameExt(builder_, level_ + 1, SqliteParser::window_name_real);
    result_ = result_ && consumeToken(builder_, AS);
    result_ = result_ && windowDefnExt(builder_, level_ + 1, SqliteParser::window_defn_real);
    result_ = result_ && select_stmt_real_0_8_0_4(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ( COMMA <> AS <> ) *
  private static boolean select_stmt_real_0_8_0_4(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_8_0_4")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!select_stmt_real_0_8_0_4_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "select_stmt_real_0_8_0_4", pos_)) break;
    }
    return true;
  }

  // COMMA <> AS <>
  private static boolean select_stmt_real_0_8_0_4_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_0_8_0_4_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && windowNameExt(builder_, level_ + 1, SqliteParser::window_name_real);
    result_ = result_ && consumeToken(builder_, AS);
    result_ = result_ && windowDefnExt(builder_, level_ + 1, SqliteParser::window_defn_real);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // VALUES <>>> ( COMMA <>>> ) *
  private static boolean select_stmt_real_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, VALUES);
    result_ = result_ && valuesExpressionExt(builder_, level_ + 1, select_stmt_real_1_1_0_parser_);
    result_ = result_ && select_stmt_real_1_2(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ( COMMA <>>> ) *
  private static boolean select_stmt_real_1_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_1_2")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!select_stmt_real_1_2_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "select_stmt_real_1_2", pos_)) break;
    }
    return true;
  }

  // COMMA <>>>
  private static boolean select_stmt_real_1_2_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "select_stmt_real_1_2_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && valuesExpressionExt(builder_, level_ + 1, select_stmt_real_1_2_0_1_0_parser_);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // LP [ <> ]
  //   [ PARTITION BY <> ( COMMA <> ) * ]
  //   [ ORDER BY <>>> ( COMMA <>>> ) * ]
  //   [ <> ]
  // RP
  public static boolean window_defn_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real")) return false;
    if (!nextTokenIs(builder_, LP)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, LP);
    result_ = result_ && window_defn_real_1(builder_, level_ + 1);
    result_ = result_ && window_defn_real_2(builder_, level_ + 1);
    result_ = result_ && window_defn_real_3(builder_, level_ + 1);
    result_ = result_ && window_defn_real_4(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RP);
    exit_section_(builder_, marker_, WINDOW_DEFN, result_);
    return result_;
  }

  // [ <> ]
  private static boolean window_defn_real_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_1")) return false;
    baseWindowNameExt(builder_, level_ + 1, SqliteParser::base_window_name_real);
    return true;
  }

  // [ PARTITION BY <> ( COMMA <> ) * ]
  private static boolean window_defn_real_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_2")) return false;
    window_defn_real_2_0(builder_, level_ + 1);
    return true;
  }

  // PARTITION BY <> ( COMMA <> ) *
  private static boolean window_defn_real_2_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_2_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokens(builder_, 0, PARTITION, BY);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && window_defn_real_2_0_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ( COMMA <> ) *
  private static boolean window_defn_real_2_0_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_2_0_3")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!window_defn_real_2_0_3_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "window_defn_real_2_0_3", pos_)) break;
    }
    return true;
  }

  // COMMA <>
  private static boolean window_defn_real_2_0_3_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_2_0_3_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ ORDER BY <>>> ( COMMA <>>> ) * ]
  private static boolean window_defn_real_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_3")) return false;
    window_defn_real_3_0(builder_, level_ + 1);
    return true;
  }

  // ORDER BY <>>> ( COMMA <>>> ) *
  private static boolean window_defn_real_3_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_3_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeTokens(builder_, 0, ORDER, BY);
    result_ = result_ && orderingTermExt(builder_, level_ + 1, window_defn_real_3_0_2_0_parser_);
    result_ = result_ && window_defn_real_3_0_3(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ( COMMA <>>> ) *
  private static boolean window_defn_real_3_0_3(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_3_0_3")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!window_defn_real_3_0_3_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "window_defn_real_3_0_3", pos_)) break;
    }
    return true;
  }

  // COMMA <>>>
  private static boolean window_defn_real_3_0_3_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_3_0_3_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && orderingTermExt(builder_, level_ + 1, window_defn_real_3_0_3_0_1_0_parser_);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ <> ]
  private static boolean window_defn_real_4(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_defn_real_4")) return false;
    frameSpecExt(builder_, level_ + 1, SqliteParser::frame_spec_real);
    return true;
  }

  /* ********************************************************** */
  // id
  public static boolean window_func_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_func_real")) return false;
    if (!nextTokenIs(builder_, ID)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, ID);
    exit_section_(builder_, marker_, WINDOW_FUNC, result_);
    return result_;
  }

  /* ********************************************************** */
  // <> LP [ MULTIPLY | ( <> ( COMMA <> ) * ) ] RP [ 'FILTER' LP WHERE <> RP] 'OVER' ( <> | <> )
  public static boolean window_function_invocation_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real")) return false;
    boolean result_, pinned_;
    Marker marker_ = enter_section_(builder_, level_, _NONE_, WINDOW_FUNCTION_INVOCATION, "");
    result_ = windowFuncExt(builder_, level_ + 1, SqliteParser::window_func_real);
    result_ = result_ && consumeToken(builder_, LP);
    result_ = result_ && window_function_invocation_real_2(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, RP);
    result_ = result_ && window_function_invocation_real_4(builder_, level_ + 1);
    result_ = result_ && consumeToken(builder_, "OVER");
    pinned_ = result_; // pin = 6
    result_ = result_ && window_function_invocation_real_6(builder_, level_ + 1);
    exit_section_(builder_, level_, marker_, result_, pinned_, null);
    return result_ || pinned_;
  }

  // [ MULTIPLY | ( <> ( COMMA <> ) * ) ]
  private static boolean window_function_invocation_real_2(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real_2")) return false;
    window_function_invocation_real_2_0(builder_, level_ + 1);
    return true;
  }

  // MULTIPLY | ( <> ( COMMA <> ) * )
  private static boolean window_function_invocation_real_2_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real_2_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, MULTIPLY);
    if (!result_) result_ = window_function_invocation_real_2_0_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <> ( COMMA <> ) *
  private static boolean window_function_invocation_real_2_0_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real_2_0_1")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = expr(builder_, level_ + 1, -1);
    result_ = result_ && window_function_invocation_real_2_0_1_1(builder_, level_ + 1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // ( COMMA <> ) *
  private static boolean window_function_invocation_real_2_0_1_1(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real_2_0_1_1")) return false;
    while (true) {
      int pos_ = current_position_(builder_);
      if (!window_function_invocation_real_2_0_1_1_0(builder_, level_ + 1)) break;
      if (!empty_element_parsed_guard_(builder_, "window_function_invocation_real_2_0_1_1", pos_)) break;
    }
    return true;
  }

  // COMMA <>
  private static boolean window_function_invocation_real_2_0_1_1_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real_2_0_1_1_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, COMMA);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // [ 'FILTER' LP WHERE <> RP]
  private static boolean window_function_invocation_real_4(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real_4")) return false;
    window_function_invocation_real_4_0(builder_, level_ + 1);
    return true;
  }

  // 'FILTER' LP WHERE <> RP
  private static boolean window_function_invocation_real_4_0(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real_4_0")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, "FILTER");
    result_ = result_ && consumeTokens(builder_, 0, LP, WHERE);
    result_ = result_ && expr(builder_, level_ + 1, -1);
    result_ = result_ && consumeToken(builder_, RP);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  // <> | <>
  private static boolean window_function_invocation_real_6(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_function_invocation_real_6")) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = windowDefnExt(builder_, level_ + 1, SqliteParser::window_defn_real);
    if (!result_) result_ = windowNameExt(builder_, level_ + 1, SqliteParser::window_name_real);
    exit_section_(builder_, marker_, null, result_);
    return result_;
  }

  /* ********************************************************** */
  // id
  public static boolean window_name_real(PsiBuilder builder_, int level_) {
    if (!recursion_guard_(builder_, level_, "window_name_real")) return false;
    if (!nextTokenIs(builder_, ID)) return false;
    boolean result_;
    Marker marker_ = enter_section_(builder_);
    result_ = consumeToken(builder_, ID);
    exit_section_(builder_, marker_, WINDOW_NAME, result_);
    return result_;
  }

  static final Parser alter_table_rename_column_real_2_0_parser_ = (builder_, level_) -> column_name_real(builder_, level_ + 1);
  static final Parser alter_table_rules_real_0_0_parser_ = (builder_, level_) -> alter_table_add_column_real(builder_, level_ + 1);
  static final Parser alter_table_rules_real_1_0_parser_ = (builder_, level_) -> alter_table_rename_table_real(builder_, level_ + 1);
  static final Parser result_column_real_1_0_0_parser_ = (builder_, level_) -> table_name_real(builder_, level_ + 1);
  static final Parser result_column_real_2_1_0_1_0_parser_ = (builder_, level_) -> column_alias_real(builder_, level_ + 1);
  static final Parser select_stmt_real_0_2_0_parser_ = (builder_, level_) -> result_column_real(builder_, level_ + 1);
  static final Parser select_stmt_real_0_3_0_1_0_parser_ = select_stmt_real_0_2_0_parser_;
  static final Parser select_stmt_real_0_4_0_1_0_parser_ = (builder_, level_) -> join_clause_real(builder_, level_ + 1);
  static final Parser select_stmt_real_0_6_0_0_parser_ = (builder_, level_) -> group_by_real(builder_, level_ + 1);
  static final Parser select_stmt_real_1_1_0_parser_ = (builder_, level_) -> values_expression_real(builder_, level_ + 1);
  static final Parser select_stmt_real_1_2_0_1_0_parser_ = select_stmt_real_1_1_0_parser_;
  static final Parser window_defn_real_3_0_2_0_parser_ = (builder_, level_) -> ordering_term_real(builder_, level_ + 1);
  static final Parser window_defn_real_3_0_3_0_1_0_parser_ = window_defn_real_3_0_2_0_parser_;
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy