/* Generated By:JJTree&JavaCC: Do not edit this line. OrientSql.java */
package com.orientechnologies.orient.core.sql.parser;

import java.io.InputStream;
import java.util.List;
import java.util.ArrayList;
import com.orientechnologies.orient.core.sql.OCommandSQLParsingException;
import com.orientechnologies.orient.core.exception.OQueryParsingException;

/** Orient Database Sql grammar. */
public class OrientSql/*@bgen(jjtree)*/implements OrientSqlTreeConstants, OrientSqlConstants {/*@bgen(jjtree)*/
  protected JJTOrientSqlState jjtree = new JJTOrientSqlState();
  private int inputParamCount = 0;

    public OrientSql(InputStream stream) {
      this(new JavaCharStream(stream));
    }

    public OrientSql(InputStream stream, String charset) throws java.io.UnsupportedEncodingException {
      this(new JavaCharStream(stream, charset));
    }

  final public ORid Rid() throws ParseException {
 /*@bgen(jjtree) Rid */
  ORid jjtn000 = new ORid(JJTRID);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      if (jj_2_1(4)) {
        jj_consume_token(266);
        jjtn000.cluster = Integer();
        jj_consume_token(COLON);
        jjtn000.position = Integer();
                 jjtn000.legacy = true;
      } else if (jj_2_2(3)) {
        jjtn000.cluster = Integer();
        jj_consume_token(COLON);
        jjtn000.position = Integer();
             jjtn000.legacy = true;
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LBRACE:
          jj_consume_token(LBRACE);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case RID_ATTR:
            jj_consume_token(RID_ATTR);
            break;
          case RID_STRING:
            jj_consume_token(RID_STRING);
            break;
          default:
            jj_la1[0] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          jj_consume_token(COLON);
          jjtn000.expression = Expression();
          jj_consume_token(RBRACE);
               jjtn000.legacy = false;
          break;
        default:
          jj_la1[1] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

/** Root productions. */
  final public OStatement parse() throws ParseException {
 /*@bgen(jjtree) parse */
 Oparse jjtn000 = new Oparse(JJTPARSE);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));OStatement result;
    try {
      result = Statement();
      jj_consume_token(0);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return result;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtn000.jjtSetLastToken(getToken(0));
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public List<OStatement> parseScript() throws ParseException {
 /*@bgen(jjtree) parseScript */
  OparseScript jjtn000 = new OparseScript(JJTPARSESCRIPT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));List<OStatement> result = new ArrayList<OStatement>();
  OStatement last;
    try {
      label_1:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SELECT:
        case TRAVERSE:
        case MATCH:
        case INSERT:
        case CREATE:
        case DELETE:
        case UPDATE:
        case WHILE:
        case RETURN:
        case LET:
        case PROFILE:
        case TRUNCATE:
        case FIND:
        case ALTER:
        case DROP:
        case REBUILD:
        case OPTIMIZE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case SLEEP:
        case CONSOLE:
        case HA:
        case FOREACH:
        case MOVE:
        case SEMICOLON:
          ;
          break;
        default:
          jj_la1[2] = jj_gen;
          break label_1;
        }
        if (jj_2_3(2147483647)) {
          last = StatementSemicolon();
                                     result.add(last);
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case IF:
            last = IfStatement();
                              result.add(last);
            break;
          case FOREACH:
            last = ForEachBlock();
                               result.add(last);
            break;
          case WHILE:
            last = WhileBlock();
                             result.add(last);
            break;
          case SEMICOLON:
            jj_consume_token(SEMICOLON);
            break;
          default:
            jj_la1[3] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
      jj_consume_token(0);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return result;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public java.lang.String String() throws ParseException {
 /*@bgen(jjtree) String */
OString jjtn000 = new OString(JJTSTRING);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtn000.jjtSetFirstToken(getToken(1));Token token = null;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STRING_LITERAL:
        token = jj_consume_token(STRING_LITERAL);
        break;
      case RID_STRING:
        token = jj_consume_token(RID_STRING);
        break;
      default:
        jj_la1[4] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return token.image;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OIdentifier Identifier() throws ParseException {
 /*@bgen(jjtree) Identifier */
    OIdentifier jjtn000 = new OIdentifier(JJTIDENTIFIER);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));Token quotedToken = null;
    Token token = null;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IDENTIFIER:
        token = jj_consume_token(IDENTIFIER);
        break;
      case IN:
        token = jj_consume_token(IN);
        break;
      case SET:
        token = jj_consume_token(SET);
        break;
      case PUT:
        token = jj_consume_token(PUT);
        break;
      case ADD:
        token = jj_consume_token(ADD);
        break;
      case REMOVE:
        token = jj_consume_token(REMOVE);
        break;
      case MERGE:
        token = jj_consume_token(MERGE);
        break;
      case CONTENT:
        token = jj_consume_token(CONTENT);
        break;
      case ORDER:
        token = jj_consume_token(ORDER);
        break;
      case KEY:
        token = jj_consume_token(KEY);
        break;
      case OFFSET:
        token = jj_consume_token(OFFSET);
        break;
      case GROUP:
        token = jj_consume_token(GROUP);
        break;
      case VALUE:
        token = jj_consume_token(VALUE);
        break;
      case VALUES:
        token = jj_consume_token(VALUES);
        break;
      case RECORD:
        token = jj_consume_token(RECORD);
        break;
      case TO:
        token = jj_consume_token(TO);
        break;
      case LUCENE:
        token = jj_consume_token(LUCENE);
        break;
      case CLASS:
        token = jj_consume_token(CLASS);
        break;
      case CLASSES:
        token = jj_consume_token(CLASSES);
        break;
      case VIEW:
        token = jj_consume_token(VIEW);
        break;
      case UPDATABLE:
        token = jj_consume_token(UPDATABLE);
        break;
      case MINDEPTH:
        token = jj_consume_token(MINDEPTH);
        break;
      case NEAR:
        token = jj_consume_token(NEAR);
        break;
      case WITHIN:
        token = jj_consume_token(WITHIN);
        break;
      case EXCEPTION:
        token = jj_consume_token(EXCEPTION);
        break;
      case PROFILE:
        token = jj_consume_token(PROFILE);
        break;
      case STORAGE:
        token = jj_consume_token(STORAGE);
        break;
      case ON:
        token = jj_consume_token(ON);
        break;
      case OFF:
        token = jj_consume_token(OFF);
        break;
      case TRUNCATE:
        token = jj_consume_token(TRUNCATE);
        break;
      case FIND:
        token = jj_consume_token(FIND);
        break;
      case REFERENCES:
        token = jj_consume_token(REFERENCES);
        break;
      case EXTENDS:
        token = jj_consume_token(EXTENDS);
        break;
      case CLUSTERS:
        token = jj_consume_token(CLUSTERS);
        break;
      case ABSTRACT:
        token = jj_consume_token(ABSTRACT);
        break;
      case ALTER:
        token = jj_consume_token(ALTER);
        break;
      case NAME:
        token = jj_consume_token(NAME);
        break;
      case SHORTNAME:
        token = jj_consume_token(SHORTNAME);
        break;
      case SUPERCLASS:
        token = jj_consume_token(SUPERCLASS);
        break;
      case SUPERCLASSES:
        token = jj_consume_token(SUPERCLASSES);
        break;
      case OVERSIZE:
        token = jj_consume_token(OVERSIZE);
        break;
      case STRICTMODE:
        token = jj_consume_token(STRICTMODE);
        break;
      case ADDCLUSTER:
        token = jj_consume_token(ADDCLUSTER);
        break;
      case REMOVECLUSTER:
        token = jj_consume_token(REMOVECLUSTER);
        break;
      case CUSTOM:
        token = jj_consume_token(CUSTOM);
        break;
      case CLUSTERSELECTION:
        token = jj_consume_token(CLUSTERSELECTION);
        break;
      case DESCRIPTION:
        token = jj_consume_token(DESCRIPTION);
        break;
      case ENCRYPTION:
        token = jj_consume_token(ENCRYPTION);
        break;
      case DROP:
        token = jj_consume_token(DROP);
        break;
      case PROPERTY:
        token = jj_consume_token(PROPERTY);
        break;
      case FORCE:
        token = jj_consume_token(FORCE);
        break;
      case METADATA:
        token = jj_consume_token(METADATA);
        break;
      case COLLATE:
        token = jj_consume_token(COLLATE);
        break;
      case INDEX:
        token = jj_consume_token(INDEX);
        break;
      case ENGINE:
        token = jj_consume_token(ENGINE);
        break;
      case REBUILD:
        token = jj_consume_token(REBUILD);
        break;
      case ID:
        token = jj_consume_token(ID);
        break;
      case DATABASE:
        token = jj_consume_token(DATABASE);
        break;
      case OPTIMIZE:
        token = jj_consume_token(OPTIMIZE);
        break;
      case LINK:
        token = jj_consume_token(LINK);
        break;
      case TYPE:
        token = jj_consume_token(TYPE);
        break;
      case INVERSE:
        token = jj_consume_token(INVERSE);
        break;
      case EXPLAIN:
        token = jj_consume_token(EXPLAIN);
        break;
      case GRANT:
        token = jj_consume_token(GRANT);
        break;
      case REVOKE:
        token = jj_consume_token(REVOKE);
        break;
      case READ:
        token = jj_consume_token(READ);
        break;
      case EXECUTE:
        token = jj_consume_token(EXECUTE);
        break;
      case ALL:
        token = jj_consume_token(ALL);
        break;
      case NONE:
        token = jj_consume_token(NONE);
        break;
      case FUNCTION:
        token = jj_consume_token(FUNCTION);
        break;
      case PARAMETERS:
        token = jj_consume_token(PARAMETERS);
        break;
      case IDEMPOTENT:
        token = jj_consume_token(IDEMPOTENT);
        break;
      case LANGUAGE:
        token = jj_consume_token(LANGUAGE);
        break;
      case BEGIN:
        token = jj_consume_token(BEGIN);
        break;
      case COMMIT:
        token = jj_consume_token(COMMIT);
        break;
      case ROLLBACK:
        token = jj_consume_token(ROLLBACK);
        break;
      case IF:
        token = jj_consume_token(IF);
        break;
      case ELSE:
        token = jj_consume_token(ELSE);
        break;
      case CONTINUE:
        token = jj_consume_token(CONTINUE);
        break;
      case FAIL:
        token = jj_consume_token(FAIL);
        break;
      case ISOLATION:
        token = jj_consume_token(ISOLATION);
        break;
      case SLEEP:
        token = jj_consume_token(SLEEP);
        break;
      case CONSOLE:
        token = jj_consume_token(CONSOLE);
        break;
      case BLOB:
        token = jj_consume_token(BLOB);
        break;
      case SHARED:
        token = jj_consume_token(SHARED);
        break;
      case DEFAULT_:
        token = jj_consume_token(DEFAULT_);
        break;
      case SEQUENCE:
        token = jj_consume_token(SEQUENCE);
        break;
      case CACHE:
        token = jj_consume_token(CACHE);
        break;
      case CYCLE:
        token = jj_consume_token(CYCLE);
        break;
      case NOLIMIT:
        token = jj_consume_token(NOLIMIT);
        break;
      case NOCYCLE:
        token = jj_consume_token(NOCYCLE);
        break;
      case START:
        token = jj_consume_token(START);
        break;
      case OPTIONAL:
        token = jj_consume_token(OPTIONAL);
        break;
      case COUNT:
        token = jj_consume_token(COUNT);
        break;
      case HA:
        token = jj_consume_token(HA);
        break;
      case STATUS:
        token = jj_consume_token(STATUS);
        break;
      case SERVER:
        token = jj_consume_token(SERVER);
        break;
      case SYNC:
        token = jj_consume_token(SYNC);
        break;
      case EXISTS:
        token = jj_consume_token(EXISTS);
        break;
      case MOVE:
        token = jj_consume_token(MOVE);
        break;
      case DEPTH_ALIAS:
        token = jj_consume_token(DEPTH_ALIAS);
        break;
      case PATH_ALIAS:
        token = jj_consume_token(PATH_ALIAS);
        break;
      case IDENTIFIED:
        token = jj_consume_token(IDENTIFIED);
        break;
      case ROLE:
        token = jj_consume_token(ROLE);
        break;
      case USER:
        token = jj_consume_token(USER);
        break;
      case RID:
        token = jj_consume_token(RID);
        break;
      case DEFAULTCLUSTER:
        token = jj_consume_token(DEFAULTCLUSTER);
        break;
      case QUOTED_IDENTIFIER:
        quotedToken = jj_consume_token(QUOTED_IDENTIFIER);
        break;
      default:
        jj_la1[5] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    if(token!=null){
        jjtn000.value = token.image;
    }else{
        jjtn000.quoted = true;
        jjtn000.value = quotedToken.image;
        jjtn000.value = jjtn000.value.substring(1, jjtn000.value.length() - 1);
        /*try{
            jjtThis.value = java.net.URLEncoder.encode(jjtThis.value, null);
        }catch(Exception e){

        }*/
    }

    {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OInteger Integer() throws ParseException {
 /*@bgen(jjtree) Integer */
    OInteger jjtn000 = new OInteger(JJTINTEGER);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));int sign = 1;
    Token tokenVal;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
        jj_consume_token(MINUS);
               sign = -1;
        break;
      default:
        jj_la1[6] = jj_gen;
        ;
      }
      tokenVal = jj_consume_token(INTEGER_LITERAL);
        //jjtThis.value = sign * Long.parseLong(tokenVal.image);
        jjtn000.setValue(sign, tokenVal.image);
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OFloatingPoint FloatingPoint() throws ParseException {
 /*@bgen(jjtree) FloatingPoint */
    OFloatingPoint jjtn000 = new OFloatingPoint(JJTFLOATINGPOINT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));String stringValue;
    Token tokenVal;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
        jj_consume_token(MINUS);
                    jjtn000.sign = -1;
        break;
      default:
        jj_la1[7] = jj_gen;
        ;
      }
      tokenVal = jj_consume_token(FLOATING_POINT_LITERAL);
                                                                                jjtn000.stringValue = tokenVal.image;
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public ONumber Number() throws ParseException {
 /*@bgen(jjtree) Number */
  ONumber jjtn000 = new ONumber(JJTNUMBER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));ONumber result;
    try {
      if (jj_2_4(2147483647)) {
        result = Integer();
      } else if (jj_2_5(2147483647)) {
        result = FloatingPoint();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return result;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OStatement Statement() throws ParseException {
 /*@bgen(jjtree) Statement */
 OStatement jjtn000 = new OStatement(JJTSTATEMENT);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));OStatement result = null;
    try {
      result = StatementInternal();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SEMICOLON:
        jj_consume_token(SEMICOLON);
        break;
      default:
        jj_la1[8] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return result;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OStatement StatementSemicolon() throws ParseException {
 /*@bgen(jjtree) StatementSemicolon */
 OStatementSemicolon jjtn000 = new OStatementSemicolon(JJTSTATEMENTSEMICOLON);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));OStatement result = null;
    try {
      result = StatementInternal();
      jj_consume_token(SEMICOLON);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return result;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OStatement StatementInternal() throws ParseException {
 /*@bgen(jjtree) StatementInternal */
    OStatementInternal jjtn000 = new OStatementInternal(JJTSTATEMENTINTERNAL);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OStatement result = null;
    try {
      if (jj_2_46(2)) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SELECT:
        case TRAVERSE:
        case MATCH:
        case FIND:
          result = QueryStatement();
          break;
        default:
          jj_la1[9] = jj_gen;
          if (jj_2_6(2)) {
            result = DeleteStatement();
          } else if (jj_2_7(2)) {
            result = DeleteVertexStatement();
          } else if (jj_2_8(2)) {
            result = DeleteEdgeStatement();
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case INSERT:
              result = InsertStatement();
              break;
            default:
              jj_la1[10] = jj_gen;
              if (jj_2_9(2)) {
                result = CreateClassStatement();
              } else if (jj_2_10(2)) {
                result = CreateViewStatement();
              } else if (jj_2_11(2)) {
                result = CreatePropertyStatement();
              } else if (jj_2_12(2)) {
                result = CreateIndexStatement();
              } else if (jj_2_13(2)) {
                result = CreateClusterStatement();
              } else if (jj_2_14(2)) {
                result = CreateLinkStatement();
              } else if (jj_2_15(2)) {
                result = CreateFunctionStatement();
              } else if (jj_2_16(2)) {
                result = CreateUserStatement();
              } else if (jj_2_17(2)) {
                result = DropUserStatement();
              } else if (jj_2_18(2)) {
                result = CreateSequenceStatement();
              } else if (jj_2_19(2147483647)) {
                result = CreateVertexStatementNoTarget();
              } else if (jj_2_20(2147483647)) {
                result = CreateVertexStatement();
              } else if (jj_2_21(2147483647)) {
                result = CreateVertexStatementEmpty();
              } else if (jj_2_22(2147483647)) {
                result = CreateVertexStatementEmptyNoTarget();
              } else if (jj_2_23(2147483647)) {
                result = CreateEdgeStatement();
              } else if (jj_2_24(2147483647)) {
                result = UpdateEdgeStatement();
              } else if (jj_2_25(2147483647)) {
                result = UpdateStatement();
              } else {
                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
                case MOVE:
                  result = MoveVertexStatement();
                  break;
                default:
                  jj_la1[11] = jj_gen;
                  if (jj_2_26(2147483647)) {
                    result = ProfileStorageStatement();
                  } else if (jj_2_27(2147483647)) {
                    result = TruncateClassStatement();
                  } else if (jj_2_28(2147483647)) {
                    result = TruncateClusterStatement();
                  } else if (jj_2_29(2147483647)) {
                    result = TruncateRecordStatement();
                  } else if (jj_2_30(2)) {
                    result = AlterSequenceStatement();
                  } else if (jj_2_31(2147483647)) {
                    result = AlterClassStatement();
                  } else if (jj_2_32(2)) {
                    result = DropSequenceStatement();
                  } else if (jj_2_33(2147483647)) {
                    result = DropClassStatement();
                  } else if (jj_2_34(2147483647)) {
                    result = DropViewStatement();
                  } else if (jj_2_35(2147483647)) {
                    result = AlterPropertyStatement();
                  } else if (jj_2_36(2147483647)) {
                    result = DropPropertyStatement();
                  } else {
                    switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
                    case REBUILD:
                      result = RebuildIndexStatement();
                      break;
                    default:
                      jj_la1[12] = jj_gen;
                      if (jj_2_37(2)) {
                        result = DropIndexStatement();
                      } else if (jj_2_38(2147483647)) {
                        result = AlterClusterStatement();
                      } else if (jj_2_39(2)) {
                        result = DropClusterStatement();
                      } else if (jj_2_40(2)) {
                        result = AlterDatabaseStatement();
                      } else {
                        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
                        case OPTIMIZE:
                          result = OptimizeDatabaseStatement();
                          break;
                        case GRANT:
                          result = GrantStatement();
                          break;
                        case REVOKE:
                          result = RevokeStatement();
                          break;
                        case BEGIN:
                          result = BeginStatement();
                          break;
                        case COMMIT:
                          result = CommitStatement();
                          break;
                        case ROLLBACK:
                          result = RollbackStatement();
                          break;
                        case RETURN:
                          result = ReturnStatement();
                          break;
                        case SLEEP:
                          result = SleepStatement();
                          break;
                        case CONSOLE:
                          result = ConsoleStatement();
                          break;
                        case IF:
                          result = IfStatement();
                          break;
                        default:
                          jj_la1[13] = jj_gen;
                          if (jj_2_41(2147483647)) {
                            result = HaRemoveServerStatement();
                          } else if (jj_2_42(2147483647)) {
                            result = HaStatusStatement();
                          } else if (jj_2_43(2147483647)) {
                            result = HaSyncDatabaseStatement();
                          } else if (jj_2_44(2147483647)) {
                            result = HaSyncClusterStatement();
                          } else if (jj_2_45(2147483647)) {
                            result = HaSetStatement();
                          } else {
                            jj_consume_token(-1);
                            throw new ParseException();
                          }
                        }
                      }
                    }
                  }
                }
              }
            }
          }
        }
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case EXPLAIN:
          result = ExplainStatement();
          break;
        default:
          jj_la1[14] = jj_gen;
          if (jj_2_47(2147483647)) {
            result = ProfileStatement();
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case LET:
              result = LetStatement();
              break;
            default:
              jj_la1[15] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
            {if (true) return result;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OStatement QueryStatement() throws ParseException {
 /*@bgen(jjtree) QueryStatement */
 OQueryStatement jjtn000 = new OQueryStatement(JJTQUERYSTATEMENT);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));OStatement result;
    try {
      if (jj_2_48(2147483647)) {
        result = SelectStatement();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SELECT:
          result = SelectWithoutTargetStatement();
          break;
        case TRAVERSE:
          result = TraverseStatement();
          break;
        case MATCH:
          result = MatchStatement();
          break;
        default:
          jj_la1[16] = jj_gen;
          if (jj_2_49(2147483647)) {
            result = FindReferencesStatement();
          } else {
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
       {if (true) return result;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OSelectWithoutTargetStatement SelectWithoutTargetStatement() throws ParseException {
 /*@bgen(jjtree) SelectWithoutTargetStatement */
  OSelectWithoutTargetStatement jjtn000 = new OSelectWithoutTargetStatement(JJTSELECTWITHOUTTARGETSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(SELECT);
      jjtn000.projection = Projection();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LET:
        jjtn000.letClause = LetClause();
        break;
      default:
        jj_la1[17] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNWIND:
        jjtn000.unwind = Unwind();
        break;
      default:
        jj_la1[18] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
      case SKIP2:
      case OFFSET:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SKIP2:
        case OFFSET:
          jjtn000.skip = Skip();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LIMIT:
            jjtn000.limit = Limit();
            break;
          default:
            jj_la1[19] = jj_gen;
            ;
          }
          break;
        case LIMIT:
          jjtn000.limit = Limit();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case SKIP2:
          case OFFSET:
            jjtn000.skip = Skip();
            break;
          default:
            jj_la1[20] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[21] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[22] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case FETCHPLAN:
        jjtn000.fetchPlan = FetchPlan();
        break;
      default:
        jj_la1[23] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TIMEOUT:
        jjtn000.timeout = Timeout();
        break;
      default:
        jj_la1[24] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LOCK:
        jj_consume_token(LOCK);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RECORD:
          jj_consume_token(RECORD);
                          jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.EXCLUSIVE_LOCK;
          break;
        case NONE:
          jj_consume_token(NONE);
                        jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.NONE;
          break;
        case SHARED:
          jj_consume_token(SHARED);
                          jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.SHARED_LOCK;
          break;
        case DEFAULT_:
          jj_consume_token(DEFAULT_);
                            jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.DEFAULT;
          break;
        default:
          jj_la1[25] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[26] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PARALLEL:
        jj_consume_token(PARALLEL);
                       jjtn000.parallel = true;
        break;
      default:
        jj_la1[27] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NOCACHE:
        jj_consume_token(NOCACHE);
                      jjtn000.noCache = true;
        break;
      default:
        jj_la1[28] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
        jjtn000.validate();
        {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OSelectStatement SelectStatement() throws ParseException {
 /*@bgen(jjtree) SelectStatement */
  OSelectStatement jjtn000 = new OSelectStatement(JJTSELECTSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(SELECT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case NULL:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case DISTINCT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case THIS:
      case RECORD_ATTRIBUTE:
      case RID_STRING:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case TRUE:
      case FALSE:
      case LPAREN:
      case LBRACE:
      case LBRACKET:
      case HOOK:
      case COLON:
      case MINUS:
      case STAR:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 266:
        jjtn000.projection = Projection();
        break;
      default:
        jj_la1[29] = jj_gen;
        ;
      }
      jj_consume_token(FROM);
      jjtn000.target = FromClause();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LET:
        jjtn000.letClause = LetClause();
        break;
      default:
        jj_la1[30] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[31] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case GROUP:
        jjtn000.groupBy = GroupBy();
        break;
      default:
        jj_la1[32] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ORDER:
        jjtn000.orderBy = OrderBy();
        break;
      default:
        jj_la1[33] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNWIND:
        jjtn000.unwind = Unwind();
        break;
      default:
        jj_la1[34] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
      case SKIP2:
      case OFFSET:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SKIP2:
        case OFFSET:
          jjtn000.skip = Skip();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LIMIT:
            jjtn000.limit = Limit();
            break;
          default:
            jj_la1[35] = jj_gen;
            ;
          }
          break;
        case LIMIT:
          jjtn000.limit = Limit();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case SKIP2:
          case OFFSET:
            jjtn000.skip = Skip();
            break;
          default:
            jj_la1[36] = jj_gen;
            ;
          }
          break;
        default:
          jj_la1[37] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[38] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case FETCHPLAN:
        jjtn000.fetchPlan = FetchPlan();
        break;
      default:
        jj_la1[39] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TIMEOUT:
        jjtn000.timeout = Timeout();
        break;
      default:
        jj_la1[40] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LOCK:
        jj_consume_token(LOCK);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RECORD:
          jj_consume_token(RECORD);
                          jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.EXCLUSIVE_LOCK;
          break;
        case NONE:
          jj_consume_token(NONE);
                        jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.NONE;
          break;
        case SHARED:
          jj_consume_token(SHARED);
                          jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.SHARED_LOCK;
          break;
        case DEFAULT_:
          jj_consume_token(DEFAULT_);
                            jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.DEFAULT;
          break;
        default:
          jj_la1[41] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[42] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case PARALLEL:
        jj_consume_token(PARALLEL);
                       jjtn000.parallel = true;
        break;
      default:
        jj_la1[43] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NOCACHE:
        jj_consume_token(NOCACHE);
                      jjtn000.noCache = true;
        break;
      default:
        jj_la1[44] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
        jjtn000.validate();
        {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OTraverseStatement TraverseStatement() throws ParseException {
 /*@bgen(jjtree) TraverseStatement */
  OTraverseStatement jjtn000 = new OTraverseStatement(JJTTRAVERSESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OTraverseProjectionItem lastProjection;
    try {
      jj_consume_token(TRAVERSE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case DISTINCT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case THIS:
      case RECORD_ATTRIBUTE:
      case LBRACKET:
      case STAR:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        lastProjection = TraverseProjectionItem();
                                                        jjtn000.projections.add(lastProjection);
        label_2:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[45] = jj_gen;
            break label_2;
          }
          jj_consume_token(COMMA);
          lastProjection = TraverseProjectionItem();
                                                                   jjtn000.projections.add(lastProjection);
        }
        break;
      default:
        jj_la1[46] = jj_gen;
        ;
      }
      jj_consume_token(FROM);
      jjtn000.target = FromClause();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MAXDEPTH:
        jj_consume_token(MAXDEPTH);
        jjtn000.maxDepth = Integer();
        break;
      default:
        jj_la1[47] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHILE:
        jj_consume_token(WHILE);
        jjtn000.whileClause = WhereClause();
        break;
      default:
        jj_la1[48] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[49] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STRATEGY:
        jj_consume_token(STRATEGY);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DEPTH_FIRST:
          jj_consume_token(DEPTH_FIRST);
                                jjtn000.strategy = OTraverseStatement.Strategy.DEPTH_FIRST;
          break;
        case BREADTH_FIRST:
          jj_consume_token(BREADTH_FIRST);
                                  jjtn000.strategy = OTraverseStatement.Strategy.BREADTH_FIRST;
          break;
        default:
          jj_la1[50] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[51] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchStatement MatchStatement() throws ParseException {
 /*@bgen(jjtree) MatchStatement */
    OMatchStatement jjtn000 = new OMatchStatement(JJTMATCHSTATEMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OMatchExpression lastMatchExpr = null;
    OExpression lastReturn = null;
    OIdentifier lastReturnAlias = null;
    ONestedProjection lastNestedProjection = null;
    try {
      jj_consume_token(MATCH);
      lastMatchExpr = MatchExpression();
                                            jjtn000.matchExpressions.add(lastMatchExpr);
      label_3:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[52] = jj_gen;
          break label_3;
        }
        jj_consume_token(COMMA);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LBRACE:
          lastMatchExpr = MatchExpression();
                                                   jjtn000.matchExpressions.add(lastMatchExpr);
          break;
        case NOT:
          jj_consume_token(NOT);
          lastMatchExpr = MatchExpression();
                                                            jjtn000.notMatchExpressions.add(lastMatchExpr);
          break;
        default:
          jj_la1[53] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jj_consume_token(RETURN);
      if (jj_2_50(2)) {
        jj_consume_token(DISTINCT);
                           jjtn000.returnDistinct = true;
        lastReturn = Expression();
                                         lastReturnAlias = null;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COLON:
          lastNestedProjection = NestedProjection();
          break;
        default:
          jj_la1[54] = jj_gen;
          ;
        }
      } else if (jj_2_51(2147483647)) {
        lastReturn = Expression();
                                         lastReturnAlias = null;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COLON:
          lastNestedProjection = NestedProjection();
          break;
        default:
          jj_la1[55] = jj_gen;
          ;
        }
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AS:
        jj_consume_token(AS);
        lastReturnAlias = Identifier();
        break;
      default:
        jj_la1[56] = jj_gen;
        ;
      }
            jjtn000.returnAliases.add(lastReturnAlias);
            jjtn000.returnItems.add(lastReturn);
            jjtn000.returnNestedProjections.add(lastNestedProjection);
            lastNestedProjection = null;
      label_4:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[57] = jj_gen;
          break label_4;
        }
        jj_consume_token(COMMA);
        lastReturn = Expression();
                                       lastReturnAlias = null;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COLON:
          lastNestedProjection = NestedProjection();
          break;
        default:
          jj_la1[58] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case AS:
          jj_consume_token(AS);
          lastReturnAlias = Identifier();
          break;
        default:
          jj_la1[59] = jj_gen;
          ;
        }
                jjtn000.returnAliases.add(lastReturnAlias);
                jjtn000.returnItems.add(lastReturn);
                jjtn000.returnNestedProjections.add(lastNestedProjection);
                lastNestedProjection = null;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case GROUP:
        jjtn000.groupBy = GroupBy();
        break;
      default:
        jj_la1[60] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ORDER:
        jjtn000.orderBy = OrderBy();
        break;
      default:
        jj_la1[61] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNWIND:
        jjtn000.unwind = Unwind();
        break;
      default:
        jj_la1[62] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SKIP2:
      case OFFSET:
        jjtn000.skip = Skip();
        break;
      default:
        jj_la1[63] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[64] = jj_gen;
        ;
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
       {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODeleteStatement DeleteStatement() throws ParseException {
 /*@bgen(jjtree) DeleteStatement */
  ODeleteStatement jjtn000 = new ODeleteStatement(JJTDELETESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(DELETE);
      jj_consume_token(FROM);
      jjtn000.fromClause = FromClause();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RETURN:
        jj_consume_token(RETURN);
        jj_consume_token(BEFORE);
                              jjtn000.returnBefore = true;
        break;
      default:
        jj_la1[65] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[66] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[67] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNSAFE:
        jj_consume_token(UNSAFE);
                     jjtn000.unsafe = true;
        break;
      default:
        jj_la1[68] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODeleteVertexStatement DeleteVertexStatement() throws ParseException {
 /*@bgen(jjtree) DeleteVertexStatement */
  ODeleteVertexStatement jjtn000 = new ODeleteVertexStatement(JJTDELETEVERTEXSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(DELETE);
      jj_consume_token(VERTEX);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case FROM:
        jj_consume_token(FROM);
                  jjtn000.from = true;
        break;
      default:
        jj_la1[69] = jj_gen;
        ;
      }
      jjtn000.fromClause = FromClause();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RETURN:
        jj_consume_token(RETURN);
        jj_consume_token(BEFORE);
                              jjtn000.returnBefore = true;
        break;
      default:
        jj_la1[70] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[71] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[72] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BATCH:
        jjtn000.batch = Batch();
        break;
      default:
        jj_la1[73] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODeleteEdgeStatement DeleteEdgeStatement() throws ParseException {
 /*@bgen(jjtree) DeleteEdgeStatement */
  ODeleteEdgeStatement jjtn000 = new ODeleteEdgeStatement(JJTDELETEEDGESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));ODeleteEdgeStatement result;
    try {
      if (jj_2_52(2147483647)) {
        result = DeleteEdgeByRidStatement();
      } else if (jj_2_53(2147483647)) {
        result = DeleteEdgeFromToStatement();
      } else if (jj_2_54(2147483647)) {
        result = DeleteEdgeVToStatement();
      } else if (jj_2_55(2147483647)) {
        result = DeleteEdgeToStatement();
      } else if (jj_2_56(2147483647)) {
        result = DeleteEdgeWhereStatement();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return result;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODeleteEdgeStatement DeleteEdgeByRidStatement() throws ParseException {
 /*@bgen(jjtree) DeleteEdgeByRidStatement */
    ODeleteEdgeByRidStatement jjtn000 = new ODeleteEdgeByRidStatement(JJTDELETEEDGEBYRIDSTATEMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));ORid lastRid;
    try {
      jj_consume_token(DELETE);
      jj_consume_token(EDGE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_LITERAL:
      case LBRACE:
      case MINUS:
      case 266:
        jjtn000.rid = Rid();
        break;
      case LBRACKET:
        jj_consume_token(LBRACKET);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INTEGER_LITERAL:
        case LBRACE:
        case MINUS:
        case 266:
          lastRid = Rid();
                    jjtn000.rids = new ArrayList();
                    jjtn000.rids.add(lastRid);
          label_5:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[74] = jj_gen;
              break label_5;
            }
            jj_consume_token(COMMA);
            lastRid = Rid();
                                      jjtn000.rids.add(lastRid);
          }
          break;
        default:
          jj_la1[75] = jj_gen;
          ;
        }
        jj_consume_token(RBRACKET);
        break;
      default:
        jj_la1[76] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BATCH:
        jjtn000.batch = Batch();
        break;
      default:
        jj_la1[77] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODeleteEdgeStatement DeleteEdgeFromToStatement() throws ParseException {
 /*@bgen(jjtree) DeleteEdgeFromToStatement */
    ODeleteEdgeFromToStatement jjtn000 = new ODeleteEdgeFromToStatement(JJTDELETEEDGEFROMTOSTATEMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));ORid lastRid;
    try {
      jj_consume_token(DELETE);
      jj_consume_token(EDGE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.className = Identifier();
        break;
      default:
        jj_la1[78] = jj_gen;
        ;
      }
      jj_consume_token(FROM);
      jjtn000.leftExpression = Expression();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
        jj_consume_token(TO);
        jjtn000.rightExpression = Expression();
        break;
      default:
        jj_la1[79] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[80] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[81] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BATCH:
        jjtn000.batch = Batch();
        break;
      default:
        jj_la1[82] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODeleteEdgeStatement DeleteEdgeToStatement() throws ParseException {
 /*@bgen(jjtree) DeleteEdgeToStatement */
    ODeleteEdgeToStatement jjtn000 = new ODeleteEdgeToStatement(JJTDELETEEDGETOSTATEMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));ORid lastRid;
    try {
      jj_consume_token(DELETE);
      jj_consume_token(EDGE);
      jjtn000.className = Identifier();
      jj_consume_token(TO);
      jjtn000.rightExpression = Expression();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[83] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[84] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BATCH:
        jjtn000.batch = Batch();
        break;
      default:
        jj_la1[85] = jj_gen;
        ;
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODeleteEdgeStatement DeleteEdgeVToStatement() throws ParseException {
 /*@bgen(jjtree) DeleteEdgeVToStatement */
    ODeleteEdgeVToStatement jjtn000 = new ODeleteEdgeVToStatement(JJTDELETEEDGEVTOSTATEMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));ORid lastRid;
    try {
      jj_consume_token(DELETE);
      jj_consume_token(EDGE);
      jj_consume_token(TO);
      jjtn000.rightExpression = Expression();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[86] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[87] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BATCH:
        jjtn000.batch = Batch();
        break;
      default:
        jj_la1[88] = jj_gen;
        ;
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODeleteEdgeStatement DeleteEdgeWhereStatement() throws ParseException {
 /*@bgen(jjtree) DeleteEdgeWhereStatement */
    ODeleteEdgeWhereStatement jjtn000 = new ODeleteEdgeWhereStatement(JJTDELETEEDGEWHERESTATEMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));ORid lastRid;
    try {
      jj_consume_token(DELETE);
      jj_consume_token(EDGE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.className = Identifier();
        break;
      default:
        jj_la1[89] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[90] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[91] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BATCH:
        jjtn000.batch = Batch();
        break;
      default:
        jj_la1[92] = jj_gen;
        ;
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUpdateEdgeStatement UpdateEdgeStatement() throws ParseException {
 /*@bgen(jjtree) UpdateEdgeStatement */
  OUpdateEdgeStatement jjtn000 = new OUpdateEdgeStatement(JJTUPDATEEDGESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OUpdateOperations lastOperations;
 ORid lastRid;
    try {
      jj_consume_token(UPDATE);
      jj_consume_token(EDGE);
      jjtn000.target = FromClause();
      label_6:
      while (true) {
        lastOperations = UpdateOperations();
                                                jjtn000.operations.add(lastOperations);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case INCREMENT:
          ;
          break;
        default:
          jj_la1[93] = jj_gen;
          break label_6;
        }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UPSERT:
        jj_consume_token(UPSERT);
                     jjtn000.upsert = true;
        break;
      default:
        jj_la1[94] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RETURN:
        jj_consume_token(RETURN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BEFORE:
          jj_consume_token(BEFORE);
                             jjtn000.returnBefore = true;
          break;
        case AFTER:
          jj_consume_token(AFTER);
                                                                        jjtn000.returnAfter = true;
          break;
        default:
          jj_la1[95] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case NULL:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case DISTINCT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case THIS:
        case RECORD_ATTRIBUTE:
        case RID_STRING:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case TRUE:
        case FALSE:
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case HOOK:
        case COLON:
        case MINUS:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
        case 266:
          jjtn000.returnProjection = Projection();
          break;
        default:
          jj_la1[96] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[97] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[98] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LOCK:
        jj_consume_token(LOCK);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RECORD:
          jj_consume_token(RECORD);
                      jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.EXCLUSIVE_LOCK;
          break;
        case NONE:
          jj_consume_token(NONE);
                    jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.NONE;
          break;
        case SHARED:
          jj_consume_token(SHARED);
                      jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.SHARED_LOCK;
          break;
        case DEFAULT_:
          jj_consume_token(DEFAULT_);
                        jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.DEFAULT;
          break;
        default:
          jj_la1[99] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[100] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[101] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TIMEOUT:
        jjtn000.timeout = Timeout();
        break;
      default:
        jj_la1[102] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtn000.jjtSetLastToken(getToken(0));
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUpdateStatement UpdateStatement() throws ParseException {
 /*@bgen(jjtree) UpdateStatement */
  OUpdateStatement jjtn000 = new OUpdateStatement(JJTUPDATESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OUpdateOperations lastOperations;
 ORid lastRid;
    try {
      jj_consume_token(UPDATE);
      jjtn000.target = FromClause();
      label_7:
      while (true) {
        lastOperations = UpdateOperations();
                                                jjtn000.operations.add(lastOperations);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case INCREMENT:
          ;
          break;
        default:
          jj_la1[103] = jj_gen;
          break label_7;
        }
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UPSERT:
        jj_consume_token(UPSERT);
                     jjtn000.upsert = true;
        break;
      default:
        jj_la1[104] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RETURN:
        jj_consume_token(RETURN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BEFORE:
          jj_consume_token(BEFORE);
                         jjtn000.returnBefore = true;
          break;
        case AFTER:
          jj_consume_token(AFTER);
                                                                    jjtn000.returnAfter = true;
          break;
        case COUNT:
          jj_consume_token(COUNT);
                                                                                jjtn000.returnCount = true;
          break;
        default:
          jj_la1[105] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case NULL:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case DISTINCT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case THIS:
        case RECORD_ATTRIBUTE:
        case RID_STRING:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case TRUE:
        case FALSE:
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case HOOK:
        case COLON:
        case MINUS:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
        case 266:
          jjtn000.returnProjection = Projection();
          break;
        default:
          jj_la1[106] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[107] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
        jj_consume_token(WHERE);
        jjtn000.whereClause = WhereClause();
        break;
      default:
        jj_la1[108] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LOCK:
        jj_consume_token(LOCK);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RECORD:
          jj_consume_token(RECORD);
                          jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.EXCLUSIVE_LOCK;
          break;
        case NONE:
          jj_consume_token(NONE);
                        jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.NONE;
          break;
        case SHARED:
          jj_consume_token(SHARED);
                          jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.SHARED_LOCK;
          break;
        case DEFAULT_:
          jj_consume_token(DEFAULT_);
                            jjtn000.lockRecord = com.orientechnologies.orient.core.storage.OStorage.LOCKING_STRATEGY.DEFAULT;
          break;
        default:
          jj_la1[109] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[110] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LIMIT:
        jjtn000.limit = Limit();
        break;
      default:
        jj_la1[111] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TIMEOUT:
        jjtn000.timeout = Timeout();
        break;
      default:
        jj_la1[112] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUpdateOperations UpdateOperations() throws ParseException {
 /*@bgen(jjtree) UpdateOperations */
    OUpdateOperations jjtn000 = new OUpdateOperations(JJTUPDATEOPERATIONS);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OUpdateItem lastItem;
    OUpdatePutItem lastPutItem;
    OUpdateIncrementItem lastIncrementItem;
    OUpdateRemoveItem lastRemoveItem;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SET:
        jj_consume_token(SET);
                    jjtn000.type = OUpdateOperations.TYPE_SET;
        lastItem = UpdateItem();
                                      jjtn000.updateItems.add(lastItem);
        label_8:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[113] = jj_gen;
            break label_8;
          }
          jj_consume_token(COMMA);
          lastItem = UpdateItem();
                                                  jjtn000.updateItems.add(lastItem);
        }
        break;
      case PUT:
        jj_consume_token(PUT);
                    jjtn000.type = OUpdateOperations.TYPE_PUT;
        lastPutItem = UpdatePutItem();
                                             jjtn000.updatePutItems.add(lastPutItem);
        label_9:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[114] = jj_gen;
            break label_9;
          }
          jj_consume_token(COMMA);
          lastPutItem = UpdatePutItem();
                                                         jjtn000.updatePutItems.add(lastPutItem);
        }
        break;
      case MERGE:
      case CONTENT:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case MERGE:
          jj_consume_token(MERGE);
                          jjtn000.type = OUpdateOperations.TYPE_MERGE;
          break;
        case CONTENT:
          jj_consume_token(CONTENT);
                            jjtn000.type = OUpdateOperations.TYPE_CONTENT;
          break;
        default:
          jj_la1[115] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        jjtn000.json = Json();
        break;
      case ADD:
      case INCREMENT:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INCREMENT:
          jj_consume_token(INCREMENT);
                              jjtn000.type = OUpdateOperations.TYPE_INCREMENT;
          break;
        case ADD:
          jj_consume_token(ADD);
                        jjtn000.type = OUpdateOperations.TYPE_ADD;
          break;
        default:
          jj_la1[116] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        lastIncrementItem = UpdateIncrementItem();
                                                        jjtn000.updateIncrementItems.add(lastIncrementItem);
        label_10:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[117] = jj_gen;
            break label_10;
          }
          jj_consume_token(COMMA);
          lastIncrementItem = UpdateIncrementItem();
                                                                    jjtn000.updateIncrementItems.add(lastIncrementItem);
        }
        break;
      case REMOVE:
        jj_consume_token(REMOVE);
                       jjtn000.type = OUpdateOperations.TYPE_REMOVE;
        lastRemoveItem = UpdateRemoveItem();
                                                   jjtn000.updateRemoveItems.add(lastRemoveItem);
        label_11:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[118] = jj_gen;
            break label_11;
          }
          jj_consume_token(COMMA);
          lastRemoveItem = UpdateRemoveItem();
                                                       jjtn000.updateRemoveItems.add(lastRemoveItem);
        }
        break;
      default:
        jj_la1[119] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUpdateItem UpdateItem() throws ParseException {
 /*@bgen(jjtree) UpdateItem */
  OUpdateItem jjtn000 = new OUpdateItem(JJTUPDATEITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
      case DOT:
        jjtn000.leftModifier = Modifier();
        break;
      default:
        jj_la1[120] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
        jj_consume_token(EQ);
                   jjtn000.operator = OUpdateItem.OPERATOR_EQ;
        break;
      case PLUSASSIGN:
        jj_consume_token(PLUSASSIGN);
                           jjtn000.operator = OUpdateItem.OPERATOR_PLUSASSIGN;
        break;
      case MINUSASSIGN:
        jj_consume_token(MINUSASSIGN);
                        jjtn000.operator = OUpdateItem.OPERATOR_MINUSASSIGN;
        break;
      case STARASSIGN:
        jj_consume_token(STARASSIGN);
                       jjtn000.operator = OUpdateItem.OPERATOR_STARASSIGN;
        break;
      case SLASHASSIGN:
        jj_consume_token(SLASHASSIGN);
                        jjtn000.operator = OUpdateItem.OPERATOR_SLASHASSIGN;
        break;
      default:
        jj_la1[121] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtn000.right = Expression();
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUpdateIncrementItem UpdateIncrementItem() throws ParseException {
 /*@bgen(jjtree) UpdateIncrementItem */
  OUpdateIncrementItem jjtn000 = new OUpdateIncrementItem(JJTUPDATEINCREMENTITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
      case DOT:
        jjtn000.leftModifier = Modifier();
        break;
      default:
        jj_la1[122] = jj_gen;
        ;
      }
      jj_consume_token(EQ);
      jjtn000.right = Expression();
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUpdateRemoveItem UpdateRemoveItem() throws ParseException {
 /*@bgen(jjtree) UpdateRemoveItem */
  OUpdateRemoveItem jjtn000 = new OUpdateRemoveItem(JJTUPDATEREMOVEITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Expression();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
        jj_consume_token(EQ);
        jjtn000.right = Expression();
        break;
      default:
        jj_la1[123] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUpdatePutItem UpdatePutItem() throws ParseException {
 /*@bgen(jjtree) UpdatePutItem */
  OUpdatePutItem jjtn000 = new OUpdatePutItem(JJTUPDATEPUTITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Identifier();
      jj_consume_token(EQ);
      jjtn000.key = Expression();
      jj_consume_token(COMMA);
      jjtn000.value = Expression();
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUpdateAddItem UpdateAddItem() throws ParseException {
 /*@bgen(jjtree) UpdateAddItem */
  OUpdateAddItem jjtn000 = new OUpdateAddItem(JJTUPDATEADDITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Identifier();
      jj_consume_token(EQ);
      jjtn000.right = Expression();
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OInsertStatement InsertStatement() throws ParseException {
 /*@bgen(jjtree) InsertStatement */
  OInsertStatement jjtn000 = new OInsertStatement(JJTINSERTSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(INSERT);
      jj_consume_token(INTO);
      if (jj_2_57(2147483647)) {
        jjtn000.targetIndex = IndexIdentifier();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.targetClass = Identifier();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case CLUSTER:
            jj_consume_token(CLUSTER);
            jjtn000.targetClusterName = Identifier();
            break;
          default:
            jj_la1[124] = jj_gen;
            ;
          }
          break;
        case CLUSTER_IDENTIFIER:
        case CLUSTER_NUMBER_IDENTIFIER:
          jjtn000.targetCluster = Cluster();
          break;
        default:
          jj_la1[125] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      if (jj_2_58(2147483647)) {
        jjtn000.insertBody = InsertBody();
      } else {
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RETURN:
        jj_consume_token(RETURN);
        jjtn000.returnStatement = Projection();
        break;
      default:
        jj_la1[126] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SELECT:
      case FROM:
      case LPAREN:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case FROM:
          jj_consume_token(FROM);
                   jjtn000.selectWithFrom = true;
          break;
        default:
          jj_la1[127] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SELECT:
          if (jj_2_59(2147483647)) {
            jjtn000.selectStatement = SelectStatement();
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case SELECT:
              jjtn000.selectStatement = SelectWithoutTargetStatement();
              break;
            default:
              jj_la1[128] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
          break;
        default:
          jj_la1[130] = jj_gen;
          if (jj_2_61(2)) {
            jj_consume_token(LPAREN);
            if (jj_2_60(2147483647)) {
              jjtn000.selectStatement = SelectStatement();
            } else {
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case SELECT:
                jjtn000.selectStatement = SelectWithoutTargetStatement();
                break;
              default:
                jj_la1[129] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
              }
            }
                  jjtn000.selectInParentheses = true;
            jj_consume_token(RPAREN);
          } else {
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
        break;
      default:
        jj_la1[131] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNSAFE:
        jj_consume_token(UNSAFE);
                 jjtn000.unsafe = true;
        break;
      default:
        jj_la1[132] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OInsertBody InsertBody() throws ParseException {
 /*@bgen(jjtree) InsertBody */
    OInsertBody jjtn000 = new OInsertBody(JJTINSERTBODY);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OIdentifier lastIdentifier;
    OExpression lastExpression;
    List<OExpression> lastExpressionList;
    try {
      if (jj_2_62(3)) {
        jj_consume_token(LPAREN);
        lastIdentifier = Identifier();
                    jjtn000.identifierList = new ArrayList<OIdentifier>();
                    jjtn000.identifierList.add(lastIdentifier);
        label_12:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[133] = jj_gen;
            break label_12;
          }
          jj_consume_token(COMMA);
          lastIdentifier = Identifier();
                                                    jjtn000.identifierList.add(lastIdentifier);
        }
        jj_consume_token(RPAREN);
        jj_consume_token(VALUES);
        jj_consume_token(LPAREN);
                    jjtn000.valueExpressions = new ArrayList<List<OExpression>>();
                    lastExpressionList = new ArrayList<OExpression>();
                    jjtn000.valueExpressions.add(lastExpressionList);
        lastExpression = Expression();
                                                lastExpressionList.add(lastExpression);
        label_13:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[134] = jj_gen;
            break label_13;
          }
          jj_consume_token(COMMA);
          lastExpression = Expression();
                                                    lastExpressionList.add(lastExpression);
        }
        jj_consume_token(RPAREN);
        label_14:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[135] = jj_gen;
            break label_14;
          }
          jj_consume_token(COMMA);
          jj_consume_token(LPAREN);
                        lastExpressionList = new ArrayList<OExpression>();
                        jjtn000.valueExpressions.add(lastExpressionList);
          lastExpression = Expression();
                                                    lastExpressionList.add(lastExpression);
          label_15:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[136] = jj_gen;
              break label_15;
            }
            jj_consume_token(COMMA);
            lastExpression = Expression();
                                                        lastExpressionList.add(lastExpression);
          }
          jj_consume_token(RPAREN);
        }
      } else if (jj_2_63(3)) {
        jj_consume_token(SET);
                    jjtn000.setExpressions = new ArrayList<OInsertSetExpression>();
                    OInsertSetExpression lastSetExpr = new OInsertSetExpression();
                    jjtn000.setExpressions.add(lastSetExpr);
        lastSetExpr.left = Identifier();
        jj_consume_token(EQ);
        lastSetExpr.right = Expression();
        label_16:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[137] = jj_gen;
            break label_16;
          }
          jj_consume_token(COMMA);
                         lastSetExpr = new OInsertSetExpression();
                         jjtn000.setExpressions.add(lastSetExpr);
          lastSetExpr.left = Identifier();
          jj_consume_token(EQ);
          lastSetExpr.right = Expression();
        }
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CONTENT:
          jj_consume_token(CONTENT);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LBRACE:
            jjtn000.content = Json();
            break;
          case HOOK:
          case COLON:
            jjtn000.contentInputParam = InputParameter();
            break;
          default:
            jj_la1[138] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[139] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateVertexStatementEmptyNoTarget CreateVertexStatementEmptyNoTarget() throws ParseException {
 /*@bgen(jjtree) CreateVertexStatementEmptyNoTarget */
  OCreateVertexStatementEmptyNoTarget jjtn000 = new OCreateVertexStatementEmptyNoTarget(JJTCREATEVERTEXSTATEMENTEMPTYNOTARGET);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(CREATE);
      jj_consume_token(VERTEX);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
         {if (true) return jjtn000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateVertexStatementEmpty CreateVertexStatementEmpty() throws ParseException {
 /*@bgen(jjtree) CreateVertexStatementEmpty */
  OCreateVertexStatementEmpty jjtn000 = new OCreateVertexStatementEmpty(JJTCREATEVERTEXSTATEMENTEMPTY);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(CREATE);
      jj_consume_token(VERTEX);
      jjtn000.targetClass = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CLUSTER:
        jj_consume_token(CLUSTER);
        jjtn000.targetClusterName = Identifier();
        break;
      default:
        jj_la1[140] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateVertexStatement CreateVertexStatement() throws ParseException {
 /*@bgen(jjtree) CreateVertexStatement */
  OCreateVertexStatement jjtn000 = new OCreateVertexStatement(JJTCREATEVERTEXSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(CREATE);
      jj_consume_token(VERTEX);
      if (jj_2_64(2147483647)) {
        jjtn000.targetClass = Identifier();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CLUSTER:
          jj_consume_token(CLUSTER);
          jjtn000.targetClusterName = Identifier();
          break;
        default:
          jj_la1[141] = jj_gen;
          ;
        }
      } else if (jj_2_65(2147483647)) {
        jjtn000.targetCluster = Cluster();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RETURN:
        jj_consume_token(RETURN);
        jjtn000.returnStatement = Projection();
        break;
      default:
        jj_la1[142] = jj_gen;
        ;
      }
      if (jj_2_66(2147483647)) {
        jjtn000.insertBody = InsertBody();
      } else {
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateVertexStatementNoTarget CreateVertexStatementNoTarget() throws ParseException {
 /*@bgen(jjtree) CreateVertexStatementNoTarget */
  OCreateVertexStatementNoTarget jjtn000 = new OCreateVertexStatementNoTarget(JJTCREATEVERTEXSTATEMENTNOTARGET);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(CREATE);
      jj_consume_token(VERTEX);
      jjtn000.insertBody = InsertBody();
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMoveVertexStatement MoveVertexStatement() throws ParseException {
 /*@bgen(jjtree) MoveVertexStatement */
  OMoveVertexStatement jjtn000 = new OMoveVertexStatement(JJTMOVEVERTEXSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OExpression lastSetExpr;
    try {
      jj_consume_token(MOVE);
      jj_consume_token(VERTEX);
      jjtn000.source = FromItem();
      jj_consume_token(TO);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CLUSTER_IDENTIFIER:
      case CLUSTER_NUMBER_IDENTIFIER:
        jjtn000.targetCluster = Cluster();
        break;
      case CLASS:
        jj_consume_token(CLASS);
        jj_consume_token(COLON);
        jjtn000.targetClass = Identifier();
        break;
      default:
        jj_la1[143] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case INCREMENT:
        jjtn000.updateOperations = UpdateOperations();
        break;
      default:
        jj_la1[144] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BATCH:
        jjtn000.batch = Batch();
        break;
      default:
        jj_la1[145] = jj_gen;
        ;
      }
     jjtree.closeNodeScope(jjtn000, true);
     jjtc000 = false;
     jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtn000.jjtSetLastToken(getToken(0));
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateEdgeStatement CreateEdgeStatement() throws ParseException {
 /*@bgen(jjtree) CreateEdgeStatement */
    OCreateEdgeStatement jjtn000 = new OCreateEdgeStatement(JJTCREATEEDGESTATEMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));ORid lastRid;
    try {
      jj_consume_token(CREATE);
      jj_consume_token(EDGE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.targetClass = Identifier();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CLUSTER:
          jj_consume_token(CLUSTER);
          jjtn000.targetClusterName = Identifier();
          break;
        default:
          jj_la1[146] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[147] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UPSERT:
        jj_consume_token(UPSERT);
                     jjtn000.upsert = true;
        break;
      default:
        jj_la1[148] = jj_gen;
        ;
      }
      jj_consume_token(FROM);
      jjtn000.leftExpression = Expression();
      jj_consume_token(TO);
      jjtn000.rightExpression = Expression();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SET:
      case CONTENT:
      case LPAREN:
        jjtn000.body = InsertBody();
        break;
      default:
        jj_la1[149] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RETRY:
        jjtn000.retry = Retry();
        break;
      default:
        jj_la1[150] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WAIT:
        jjtn000.wait = Wait();
        break;
      default:
        jj_la1[151] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case BATCH:
        jjtn000.batch = Batch();
        break;
      default:
        jj_la1[152] = jj_gen;
        ;
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OInputParameter InputParameter() throws ParseException {
 /*@bgen(jjtree) InputParameter */
  OInputParameter jjtn000 = new OInputParameter(JJTINPUTPARAMETER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OInputParameter result;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case HOOK:
        result = PositionalParameter();
        break;
      case COLON:
        result = NamedParameter();
        break;
      default:
        jj_la1[153] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return result;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OPositionalParameter PositionalParameter() throws ParseException {
 /*@bgen(jjtree) PositionalParameter */
  OPositionalParameter jjtn000 = new OPositionalParameter(JJTPOSITIONALPARAMETER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(HOOK);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
            jjtn000.paramNumber = inputParamCount;
            inputParamCount++;
            {if (true) return jjtn000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ONamedParameter NamedParameter() throws ParseException {
 /*@bgen(jjtree) NamedParameter */
ONamedParameter jjtn000 = new ONamedParameter(JJTNAMEDPARAMETER);
boolean jjtc000 = true;
jjtree.openNodeScope(jjtn000);
jjtn000.jjtSetFirstToken(getToken(1));OIdentifier identifierParam;
Token token;
    try {
      jj_consume_token(COLON);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        identifierParam = Identifier();
                                                 jjtn000.paramName = identifierParam.toString();
        break;
      case SKIP2:
        token = jj_consume_token(SKIP2);
                                 jjtn000.paramName = token.image;
        break;
      case LIMIT:
        token = jj_consume_token(LIMIT);
                             jjtn000.paramName = token.image;
        break;
      case FROM:
        token = jj_consume_token(FROM);
                            jjtn000.paramName = token.image;
        break;
      default:
        jj_la1[154] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
         jjtn000.paramNumber = inputParamCount;
     inputParamCount++;
         {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OProjection Projection() throws ParseException {
 /*@bgen(jjtree) Projection */
    OProjection jjtn000 = new OProjection(JJTPROJECTION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));java.util.List<OProjectionItem> items = new java.util.ArrayList<OProjectionItem>();
    OProjectionItem lastItem = null;
    try {
      if (jj_2_67(2147483647)) {
        lastItem = ProjectionItem();
                                         items.add(lastItem);
        label_17:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[155] = jj_gen;
            break label_17;
          }
          jj_consume_token(COMMA);
          lastItem = ProjectionItem();
                                                                                items.add(lastItem);
        }
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DISTINCT:
          jj_consume_token(DISTINCT);
                         jjtn000.distinct = true;
          lastItem = ProjectionItem();
                                             items.add(lastItem);
          label_18:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[156] = jj_gen;
              break label_18;
            }
            jj_consume_token(COMMA);
            lastItem = ProjectionItem();
                                                                                items.add(lastItem);
          }
          break;
        default:
          jj_la1[157] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
            jjtn000.items = items;
            {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OProjectionItem ProjectionItem() throws ParseException {
 /*@bgen(jjtree) ProjectionItem */
  OProjectionItem jjtn000 = new OProjectionItem(JJTPROJECTIONITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.expression = Expression();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COLON:
        jjtn000.nestedProjection = NestedProjection();
        break;
      default:
        jj_la1[158] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AS:
        jj_consume_token(AS);
        jjtn000.alias = Alias();
        break;
      default:
        jj_la1[159] = jj_gen;
        ;
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ONestedProjection NestedProjection() throws ParseException {
 /*@bgen(jjtree) NestedProjection */
   ONestedProjection jjtn000 = new ONestedProjection(JJTNESTEDPROJECTION);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   jjtn000.jjtSetFirstToken(getToken(1));ONestedProjectionItem lastItem;
    try {
      jj_consume_token(COLON);
      jj_consume_token(LBRACE);
      lastItem = NestedProjectionItem();
       if(lastItem.exclude) {
         jjtn000.excludeItems.add(lastItem);
       } else if(lastItem.star) {
         jjtn000.starItem = lastItem;
       } else {
         jjtn000.includeItems.add(lastItem);
       }
      label_19:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[160] = jj_gen;
          break label_19;
        }
        jj_consume_token(COMMA);
        lastItem = NestedProjectionItem();
            if(lastItem.exclude) {
              jjtn000.excludeItems.add(lastItem);
            } else if(lastItem.star) {
              jjtn000.starItem = lastItem;
            } else {
              jjtn000.includeItems.add(lastItem);
            }
      }
      jj_consume_token(RBRACE);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtn000.jjtSetLastToken(getToken(0));
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public ONestedProjectionItem NestedProjectionItem() throws ParseException {
 /*@bgen(jjtree) NestedProjectionItem */
  ONestedProjectionItem jjtn000 = new ONestedProjectionItem(JJTNESTEDPROJECTIONITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STAR:
        jj_consume_token(STAR);
               jjtn000.star = true;
        break;
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case NULL:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case DISTINCT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case THIS:
      case RECORD_ATTRIBUTE:
      case RID_STRING:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case TRUE:
      case FALSE:
      case LPAREN:
      case LBRACE:
      case LBRACKET:
      case BANG:
      case HOOK:
      case COLON:
      case MINUS:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 266:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BANG:
          jj_consume_token(BANG);
                 jjtn000.exclude = true;
          break;
        default:
          jj_la1[161] = jj_gen;
          ;
        }
        jjtn000.expression = Expression();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case STAR:
          jj_consume_token(STAR);
                 jjtn000.rightWildcard = true;
          break;
        default:
          jj_la1[162] = jj_gen;
          ;
        }
        break;
      default:
        jj_la1[163] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case COLON:
        jjtn000.expansion = NestedProjection();
        break;
      default:
        jj_la1[164] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case AS:
        jj_consume_token(AS);
        jjtn000.alias = Identifier();
        break;
      default:
        jj_la1[165] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtn000.jjtSetLastToken(getToken(0));
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public OArraySelector ArraySelector() throws ParseException {
 /*@bgen(jjtree) ArraySelector */
  OArraySelector jjtn000 = new OArraySelector(JJTARRAYSELECTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      if (jj_2_68(2147483647)) {
        jjtn000.rid = Rid();
      } else if (jj_2_69(2147483647)) {
        jjtn000.inputParam = InputParameter();
      } else if (jj_2_70(2147483647)) {
        jjtn000.expression = Expression();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OArrayNumberSelector ArrayNumberSelector() throws ParseException {
 /*@bgen(jjtree) ArrayNumberSelector */
  OArrayNumberSelector jjtn000 = new OArrayNumberSelector(JJTARRAYNUMBERSELECTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));Token tokenVal;
    try {
      if (jj_2_71(2147483647)) {
        jjtn000.inputValue = InputParameter();
      } else if (jj_2_72(2147483647)) {
        tokenVal = jj_consume_token(INTEGER_LITERAL);
                                       jjtn000.integer = Integer.parseInt(tokenVal.image);
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OArraySingleValuesSelector ArraySingleValuesSelector() throws ParseException {
 /*@bgen(jjtree) ArraySingleValuesSelector */
  OArraySingleValuesSelector jjtn000 = new OArraySingleValuesSelector(JJTARRAYSINGLEVALUESSELECTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OArraySelector lastSelector;
    try {
      lastSelector = ArraySelector();
                                         jjtn000.items.add(lastSelector);
      label_20:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[166] = jj_gen;
          break label_20;
        }
        jj_consume_token(COMMA);
        lastSelector = ArraySelector();
                                                   jjtn000.items.add(lastSelector);
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OArrayRangeSelector ArrayRangeSelector() throws ParseException {
 /*@bgen(jjtree) ArrayRangeSelector */
  OArrayRangeSelector jjtn000 = new OArrayRangeSelector(JJTARRAYRANGESELECTOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));Token token;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_RANGE:
        token = jj_consume_token(INTEGER_RANGE);
                String img = token.image;
                String[] splitted = img.split("\u005c\u005c.\u005c\u005c.");
                jjtn000.from = Integer.parseInt(splitted[0], 10);
                jjtn000.to = Integer.parseInt(splitted[1], 10);
                jjtn000.newRange = true;
        break;
      case ELLIPSIS_INTEGER_RANGE:
        token = jj_consume_token(ELLIPSIS_INTEGER_RANGE);
                String img2 = token.image;
                String[] splitted2 = img2.split("\u005c\u005c.\u005c\u005c.\u005c\u005c.");
                jjtn000.from = Integer.parseInt(splitted2[0], 10);
                jjtn000.to = Integer.parseInt(splitted2[1], 10);
                jjtn000.newRange = true;
                jjtn000.included = true;
        break;
      case INTEGER_LITERAL:
      case HOOK:
      case COLON:
        jjtn000.fromSelector = ArrayNumberSelector();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RANGE:
          jj_consume_token(RANGE);
                        jjtn000.newRange = true;
          break;
        case ELLIPSIS:
          jj_consume_token(ELLIPSIS);
                           jjtn000.newRange = true; jjtn000.included = true;
          break;
        default:
          jj_la1[167] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        jjtn000.toSelector = ArrayNumberSelector();
        break;
      default:
        jj_la1[168] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OIdentifier Alias() throws ParseException {
 /*@bgen(jjtree) Alias */
  OAlias jjtn000 = new OAlias(JJTALIAS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier identifier;
    try {
      identifier = Identifier();
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
         {if (true) return identifier;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ORecordAttribute RecordAttribute() throws ParseException {
 /*@bgen(jjtree) RecordAttribute */
  ORecordAttribute jjtn000 = new ORecordAttribute(JJTRECORDATTRIBUTE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));Token token;
    try {
      token = jj_consume_token(RECORD_ATTRIBUTE);
                                         jjtn000.name = token.image;
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OFunctionCall FunctionCall() throws ParseException {
 /*@bgen(jjtree) FunctionCall */
    OFunctionCall jjtn000 = new OFunctionCall(JJTFUNCTIONCALL);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OExpression lastExpression = null;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.name = Identifier();
        break;
      case DISTINCT:
        jj_consume_token(DISTINCT);
                           jjtn000.name = new OIdentifier("distinct");
        break;
      default:
        jj_la1[169] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(LPAREN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case NULL:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case DISTINCT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case THIS:
      case RECORD_ATTRIBUTE:
      case RID_STRING:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case TRUE:
      case FALSE:
      case LPAREN:
      case LBRACE:
      case LBRACKET:
      case HOOK:
      case COLON:
      case MINUS:
      case STAR:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 266:
        lastExpression = Expression();
                                           jjtn000.params.add(lastExpression);
        label_21:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[170] = jj_gen;
            break label_21;
          }
          jj_consume_token(COMMA);
          lastExpression = Expression();
                                                                                jjtn000.params.add(lastExpression);
        }
        break;
      default:
        jj_la1[171] = jj_gen;
        ;
      }
      jj_consume_token(RPAREN);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMethodCall MethodCall() throws ParseException {
 /*@bgen(jjtree) MethodCall */
  OMethodCall jjtn000 = new OMethodCall(JJTMETHODCALL);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OExpression lastExpression;
    try {
      jj_consume_token(DOT);
      jjtn000.methodName = Identifier();
      jj_consume_token(LPAREN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case NULL:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case DISTINCT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case THIS:
      case RECORD_ATTRIBUTE:
      case RID_STRING:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case TRUE:
      case FALSE:
      case LPAREN:
      case LBRACE:
      case LBRACKET:
      case HOOK:
      case COLON:
      case MINUS:
      case STAR:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 266:
        lastExpression = Expression();
                                            jjtn000.params.add(lastExpression);
        label_22:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[172] = jj_gen;
            break label_22;
          }
          jj_consume_token(COMMA);
          lastExpression = Expression();
                                                      jjtn000.params.add(lastExpression);
        }
        break;
      default:
        jj_la1[173] = jj_gen;
        ;
      }
      jj_consume_token(RPAREN);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OLevelZeroIdentifier LevelZeroIdentifier() throws ParseException {
 /*@bgen(jjtree) LevelZeroIdentifier */
  OLevelZeroIdentifier jjtn000 = new OLevelZeroIdentifier(JJTLEVELZEROIDENTIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      if (jj_2_73(2147483647)) {
        jjtn000.functionCall = FunctionCall();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case THIS:
          jj_consume_token(THIS);
                 jjtn000.self = true;
          break;
        default:
          jj_la1[174] = jj_gen;
          if (jj_2_74(2147483647)) {
            jjtn000.collection = Collection();
          } else {
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OSuffixIdentifier SuffixIdentifier() throws ParseException {
 /*@bgen(jjtree) SuffixIdentifier */
  OSuffixIdentifier jjtn000 = new OSuffixIdentifier(JJTSUFFIXIDENTIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      if (jj_2_75(2147483647)) {
        jjtn000.identifier = Identifier();
      } else if (jj_2_76(2147483647)) {
        jjtn000.recordAttribute = RecordAttribute();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case STAR:
          jj_consume_token(STAR);
                   jjtn000.star = true;
          break;
        default:
          jj_la1[175] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBaseIdentifier BaseIdentifier() throws ParseException {
 /*@bgen(jjtree) BaseIdentifier */
  OBaseIdentifier jjtn000 = new OBaseIdentifier(JJTBASEIDENTIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      if (jj_2_77(2147483647)) {
        jjtn000.levelZero = LevelZeroIdentifier();
      } else if (jj_2_78(2147483647)) {
        jjtn000.suffix = SuffixIdentifier();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OModifier Modifier() throws ParseException {
 /*@bgen(jjtree) Modifier */
  OModifier jjtn000 = new OModifier(JJTMODIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
        jj_consume_token(LBRACKET);
                             jjtn000.squareBrackets = true;
        if (jj_2_79(2147483647)) {
          jjtn000.rightBinaryCondition = RightBinaryCondition();
        } else if (jj_2_80(2147483647)) {
          jjtn000.arrayRange = ArrayRangeSelector();
        } else if (jj_2_81(2147483647)) {
          jjtn000.condition = OrBlock();
        } else if (jj_2_82(2147483647)) {
          jjtn000.arraySingleValues = ArraySingleValuesSelector();
        } else {
          jj_consume_token(-1);
          throw new ParseException();
        }
        jj_consume_token(RBRACKET);
        break;
      default:
        jj_la1[176] = jj_gen;
        if (jj_2_83(2147483647)) {
          jjtn000.methodCall = MethodCall();
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case DOT:
            jj_consume_token(DOT);
            jjtn000.suffix = SuffixIdentifier();
            break;
          default:
            jj_la1[177] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
      if (jj_2_84(2147483647)) {
        jjtn000.next = Modifier();
      } else {
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OExpression Expression() throws ParseException {
 /*@bgen(jjtree) Expression */
 OExpression jjtn000 = new OExpression(JJTEXPRESSION);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));Token token;
    try {
      if (jj_2_85(2147483647)) {
        jjtn000.arrayConcatExpression = ArrayConcatExpression();
                                                                  jjtn000.value = jjtn000.arrayConcatExpression;
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NULL:
          jj_consume_token(NULL);
                jjtn000.isNull = true; jjtn000.value = null;
          break;
        case TRUE:
          jj_consume_token(TRUE);
                 jjtn000.booleanValue = true; jjtn000.value = true;
          break;
        case FALSE:
          jj_consume_token(FALSE);
                  jjtn000.booleanValue = false; jjtn000.value = false;
          break;
        default:
          jj_la1[178] = jj_gen;
          if (jj_2_86(2147483647)) {
            jjtn000.rid = Rid();
                              jjtn000.value = jjtn000.rid;
          } else if (jj_2_87(2147483647)) {
            jjtn000.mathExpression = MathExpression();
                                                    jjtn000.value = jjtn000.mathExpression;
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case LBRACE:
              jjtn000.json = Json();
                               jjtn000.value = jjtn000.json;
              break;
            default:
              jj_la1[179] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OArrayConcatExpression ArrayConcatExpression() throws ParseException {
 /*@bgen(jjtree) ArrayConcatExpression */
    OArrayConcatExpression jjtn000 = new OArrayConcatExpression(JJTARRAYCONCATEXPRESSION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OArrayConcatExpressionElement sub;
    jjtn000.setChildExpressions(new java.util.ArrayList());
    try {
      sub = ArrayConcatExpressionElement();
                                                   jjtn000.getChildExpressions().add(sub);
      label_23:
      while (true) {
        jj_consume_token(SC_OR);
        sub = ArrayConcatExpressionElement();
                                                       jjtn000.getChildExpressions().add(sub);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case SC_OR:
          ;
          break;
        default:
          jj_la1[180] = jj_gen;
          break label_23;
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
            {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OArrayConcatExpressionElement ArrayConcatExpressionElement() throws ParseException {
 /*@bgen(jjtree) ArrayConcatExpressionElement */
 OArrayConcatExpressionElement jjtn000 = new OArrayConcatExpressionElement(JJTARRAYCONCATEXPRESSIONELEMENT);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));Token token;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NULL:
        jj_consume_token(NULL);
                jjtn000.isNull = true; jjtn000.value = null;
        break;
      case TRUE:
        jj_consume_token(TRUE);
                 jjtn000.booleanValue = true; jjtn000.value = true;
        break;
      case FALSE:
        jj_consume_token(FALSE);
                  jjtn000.booleanValue = false; jjtn000.value = false;
        break;
      default:
        jj_la1[181] = jj_gen;
        if (jj_2_88(2147483647)) {
          jjtn000.rid = Rid();
                              jjtn000.value = jjtn000.rid;
        } else if (jj_2_89(2147483647)) {
          jjtn000.mathExpression = MathExpression();
                                                    jjtn000.value = jjtn000.mathExpression;
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LBRACE:
            jjtn000.json = Json();
                               jjtn000.value = jjtn000.json;
            break;
          default:
            jj_la1[182] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMathExpression MathExpression() throws ParseException {
 /*@bgen(jjtree) MathExpression */
    OMathExpression jjtn000 = new OMathExpression(JJTMATHEXPRESSION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OMathExpression sub;
    jjtn000.setChildExpressions(new java.util.ArrayList());
    try {
      sub = FirstLevelExpression();
                                           jjtn000.getChildExpressions().add(sub);
      label_24:
      while (true) {
        if (jj_2_90(2)) {
          ;
        } else {
          break label_24;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case STAR:
          jj_consume_token(STAR);
                         jjtn000.operators.add( OMathExpression.Operator.STAR);
          break;
        case SLASH:
          jj_consume_token(SLASH);
                          jjtn000.operators.add( OMathExpression.Operator.SLASH);
          break;
        case REM:
          jj_consume_token(REM);
                        jjtn000.operators.add( OMathExpression.Operator.REM);
          break;
        case PLUS:
          jj_consume_token(PLUS);
                             jjtn000.operators.add( OMathExpression.Operator.PLUS);
          break;
        case MINUS:
          jj_consume_token(MINUS);
                              jjtn000.operators.add(OMathExpression.Operator.MINUS);
          break;
        case LSHIFT:
          jj_consume_token(LSHIFT);
                               jjtn000.operators.add(OMathExpression.Operator.LSHIFT);
          break;
        case RSHIFT:
          jj_consume_token(RSHIFT);
                               jjtn000.operators.add(OMathExpression.Operator.RSHIFT);
          break;
        case RUNSIGNEDSHIFT:
          jj_consume_token(RUNSIGNEDSHIFT);
                                       jjtn000.operators.add(OMathExpression.Operator.RUNSIGNEDSHIFT);
          break;
        case BIT_AND:
          jj_consume_token(BIT_AND);
                                jjtn000.operators.add(OMathExpression.Operator.BIT_AND);
          break;
        case BIT_OR:
          jj_consume_token(BIT_OR);
                               jjtn000.operators.add(OMathExpression.Operator.BIT_OR);
          break;
        case XOR:
          jj_consume_token(XOR);
                            jjtn000.operators.add(OMathExpression.Operator.XOR);
          break;
        default:
          jj_la1[183] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        sub = FirstLevelExpression();
                                               jjtn000.getChildExpressions().add(sub);
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
            if(jjtn000.getChildExpressions().size() != 1){
                {if (true) return jjtn000;}
            }else{
                {if (true) return jjtn000.getChildExpressions().get(0);}
            }
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMathExpression FirstLevelExpression() throws ParseException {
 /*@bgen(jjtree) FirstLevelExpression */
  OFirstLevelExpression jjtn000 = new OFirstLevelExpression(JJTFIRSTLEVELEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OMathExpression expr;
    try {
      if (jj_2_91(2147483647)) {
        expr = ParenthesisExpression();
      } else if (jj_2_92(2147483647)) {
        expr = BaseExpression();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return expr;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMathExpression ParenthesisExpression() throws ParseException {
 /*@bgen(jjtree) ParenthesisExpression */
  OParenthesisExpression jjtn000 = new OParenthesisExpression(JJTPARENTHESISEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(LPAREN);
      if (jj_2_93(2)) {
        jjtn000.statement = QueryStatement();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case NULL:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case DISTINCT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case THIS:
        case RECORD_ATTRIBUTE:
        case RID_STRING:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case TRUE:
        case FALSE:
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case HOOK:
        case COLON:
        case MINUS:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
        case 266:
          jjtn000.expression = Expression();
          break;
        case INSERT:
          jjtn000.statement = InsertStatement();
          break;
        default:
          jj_la1[184] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jj_consume_token(RPAREN);
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
         {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBaseExpression BaseExpression() throws ParseException {
 /*@bgen(jjtree) BaseExpression */
  OBaseExpression jjtn000 = new OBaseExpression(JJTBASEEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case MINUS:
        jjtn000.number = Number();
        break;
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case DISTINCT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case THIS:
      case RECORD_ATTRIBUTE:
      case LBRACKET:
      case STAR:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.identifier = BaseIdentifier();
        if (jj_2_94(2147483647)) {
          jjtn000.modifier = Modifier();
        } else {
          ;
        }
        break;
      case HOOK:
      case COLON:
        jjtn000.inputParam = InputParameter();
        if (jj_2_95(2147483647)) {
          jjtn000.modifier = Modifier();
        } else {
          ;
        }
        break;
      case RID_STRING:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RID_STRING:
        case STRING_LITERAL:
          jjtn000.string = String();
          break;
        case CHARACTER_LITERAL:
          token = jj_consume_token(CHARACTER_LITERAL);
                                              jjtn000.string = token.image;
          break;
        default:
          jj_la1[185] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        if (jj_2_96(2147483647)) {
          jjtn000.modifier = Modifier();
        } else {
          ;
        }
        break;
      default:
        jj_la1[186] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
         {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OFromClause FromClause() throws ParseException {
 /*@bgen(jjtree) FromClause */
  OFromClause jjtn000 = new OFromClause(JJTFROMCLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.item = FromItem();
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OLetClause LetClause() throws ParseException {
 /*@bgen(jjtree) LetClause */
    OLetClause jjtn000 = new OLetClause(JJTLETCLAUSE);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OLetItem lastItem;
    try {
      jj_consume_token(LET);
      lastItem = LetItem();
                                     jjtn000.items.add(lastItem);
      label_25:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[187] = jj_gen;
          break label_25;
        }
        jj_consume_token(COMMA);
        lastItem = LetItem();
                                                                                jjtn000.items.add(lastItem);
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OLetItem LetItem() throws ParseException {
 /*@bgen(jjtree) LetItem */
  OLetItem jjtn000 = new OLetItem(JJTLETITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.varName = Identifier();
      jj_consume_token(EQ);
      if (jj_2_97(2147483647)) {
        jjtn000.expression = Expression();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LPAREN:
          jj_consume_token(LPAREN);
          jjtn000.query = QueryStatement();
          jj_consume_token(RPAREN);
          break;
        default:
          jj_la1[188] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OFromItem FromItem() throws ParseException {
 /*@bgen(jjtree) FromItem */
    OFromItem jjtn000 = new OFromItem(JJTFROMITEM);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));jjtn000.rids = new java.util.ArrayList();
    jjtn000.inputParams = new java.util.ArrayList();
    ORid lastRid;
    OInputParameter lastParam;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_LITERAL:
      case LBRACE:
      case MINUS:
      case 266:
        lastRid = Rid();
                          jjtn000.rids.add(lastRid);
        break;
      default:
        jj_la1[193] = jj_gen;
        if (jj_2_101(2)) {
          jj_consume_token(LBRACKET);
          lastRid = Rid();
                                         jjtn000.rids.add(lastRid);
          label_26:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[189] = jj_gen;
              break label_26;
            }
            jj_consume_token(COMMA);
            lastRid = Rid();
                                          jjtn000.rids.add(lastRid);
          }
          jj_consume_token(RBRACKET);
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LBRACKET:
            jj_consume_token(LBRACKET);
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case HOOK:
              lastParam = PositionalParameter();
                                                    jjtn000.inputParams.add(lastParam);
              break;
            case COLON:
              lastParam = NamedParameter();
                                               jjtn000.inputParams.add(lastParam);
              break;
            default:
              jj_la1[190] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
            label_27:
            while (true) {
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case COMMA:
              case COLON:
                ;
                break;
              default:
                jj_la1[191] = jj_gen;
                break label_27;
              }
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case COMMA:
                jj_consume_token(COMMA);
                lastParam = PositionalParameter();
                                                    jjtn000.inputParams.add(lastParam);
                break;
              case COLON:
                lastParam = NamedParameter();
                                               jjtn000.inputParams.add(lastParam);
                break;
              default:
                jj_la1[192] = jj_gen;
                jj_consume_token(-1);
                throw new ParseException();
              }
            }
            jj_consume_token(RBRACKET);
            break;
          case CLUSTER_IDENTIFIER:
          case CLUSTER_NUMBER_IDENTIFIER:
            jjtn000.cluster = Cluster();
            break;
          case CLUSTER:
            jjtn000.clusterList = ClusterList();
            break;
          default:
            jj_la1[194] = jj_gen;
            if (jj_2_102(2147483647)) {
              jjtn000.index = IndexIdentifier();
            } else {
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case METADATA_IDENTIFIER:
                jjtn000.metadata = MetadataIdentifier();
                break;
              case LPAREN:
                jj_consume_token(LPAREN);
                jjtn000.statement = QueryStatement();
                jj_consume_token(RPAREN);
                if (jj_2_98(2147483647)) {
                  jjtn000.modifier = Modifier();
                } else {
                  ;
                }
                break;
              case HOOK:
              case COLON:
                jjtn000.inputParam = InputParameter();
                break;
              default:
                jj_la1[195] = jj_gen;
                if (jj_2_103(2)) {
                  jjtn000.functionCall = FunctionCall();
                  if (jj_2_99(2147483647)) {
                    jjtn000.modifier = Modifier();
                  } else {
                    ;
                  }
                } else {
                  switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
                  case TO:
                  case VALUE:
                  case VALUES:
                  case SET:
                  case ADD:
                  case PUT:
                  case MERGE:
                  case CONTENT:
                  case REMOVE:
                  case ORDER:
                  case GROUP:
                  case OFFSET:
                  case RECORD:
                  case CACHE:
                  case CYCLE:
                  case NOLIMIT:
                  case NOCYCLE:
                  case LUCENE:
                  case NEAR:
                  case WITHIN:
                  case MINDEPTH:
                  case CLASS:
                  case SUPERCLASS:
                  case CLASSES:
                  case SUPERCLASSES:
                  case VIEW:
                  case UPDATABLE:
                  case EXCEPTION:
                  case PROFILE:
                  case STORAGE:
                  case ON:
                  case OFF:
                  case TRUNCATE:
                  case FIND:
                  case REFERENCES:
                  case EXTENDS:
                  case CLUSTERS:
                  case ABSTRACT:
                  case ALTER:
                  case NAME:
                  case SHORTNAME:
                  case OVERSIZE:
                  case STRICTMODE:
                  case ADDCLUSTER:
                  case REMOVECLUSTER:
                  case CUSTOM:
                  case CLUSTERSELECTION:
                  case DESCRIPTION:
                  case ENCRYPTION:
                  case DROP:
                  case PROPERTY:
                  case FORCE:
                  case METADATA:
                  case INDEX:
                  case COLLATE:
                  case ENGINE:
                  case REBUILD:
                  case ID:
                  case DATABASE:
                  case OPTIMIZE:
                  case LINK:
                  case TYPE:
                  case INVERSE:
                  case EXPLAIN:
                  case GRANT:
                  case REVOKE:
                  case READ:
                  case EXECUTE:
                  case ALL:
                  case NONE:
                  case FUNCTION:
                  case PARAMETERS:
                  case IDEMPOTENT:
                  case LANGUAGE:
                  case BEGIN:
                  case COMMIT:
                  case ROLLBACK:
                  case IF:
                  case ELSE:
                  case CONTINUE:
                  case FAIL:
                  case ISOLATION:
                  case SLEEP:
                  case CONSOLE:
                  case BLOB:
                  case SHARED:
                  case DEFAULT_:
                  case SEQUENCE:
                  case START:
                  case OPTIONAL:
                  case COUNT:
                  case HA:
                  case STATUS:
                  case SERVER:
                  case SYNC:
                  case EXISTS:
                  case MOVE:
                  case DEPTH_ALIAS:
                  case PATH_ALIAS:
                  case IDENTIFIED:
                  case ROLE:
                  case USER:
                  case RID:
                  case DEFAULTCLUSTER:
                  case IN:
                  case KEY:
                  case IDENTIFIER:
                  case QUOTED_IDENTIFIER:
                    jjtn000.identifier = Identifier();
                    if (jj_2_100(2147483647)) {
                      jjtn000.modifier = Modifier();
                    } else {
                      ;
                    }
                    break;
                  default:
                    jj_la1[196] = jj_gen;
                    jj_consume_token(-1);
                    throw new ParseException();
                  }
                }
              }
            }
          }
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCluster Cluster() throws ParseException {
 /*@bgen(jjtree) Cluster */
  OCluster jjtn000 = new OCluster(JJTCLUSTER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));Token cName;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CLUSTER_IDENTIFIER:
        cName = jj_consume_token(CLUSTER_IDENTIFIER);
                                          jjtn000.clusterName = cName.image.split(":")[1];
        break;
      case CLUSTER_NUMBER_IDENTIFIER:
        cName = jj_consume_token(CLUSTER_NUMBER_IDENTIFIER);
                                                 jjtn000.clusterNumber = Integer.parseInt(cName.image.split(":")[1]);
        break;
      default:
        jj_la1[197] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OClusterList ClusterList() throws ParseException {
 /*@bgen(jjtree) ClusterList */
  OClusterList jjtn000 = new OClusterList(JJTCLUSTERLIST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier lastIdentifier;
    try {
      jj_consume_token(CLUSTER);
      jj_consume_token(COLON);
      jj_consume_token(LBRACKET);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        lastIdentifier = Identifier();
                                                jjtn000.clusters.add(lastIdentifier);
        label_28:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[198] = jj_gen;
            break label_28;
          }
          jj_consume_token(COMMA);
          lastIdentifier = Identifier();
                                                          jjtn000.clusters.add(lastIdentifier);
        }
        break;
      default:
        jj_la1[199] = jj_gen;
        ;
      }
      jj_consume_token(RBRACKET);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMetadataIdentifier MetadataIdentifier() throws ParseException {
 /*@bgen(jjtree) MetadataIdentifier */
  OMetadataIdentifier jjtn000 = new OMetadataIdentifier(JJTMETADATAIDENTIFIER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));Token mdName;
    try {
      mdName = jj_consume_token(METADATA_IDENTIFIER);
                                            jjtn000.name = mdName.image.split(":")[1];
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OIndexName IndexName() throws ParseException {
 /*@bgen(jjtree) IndexName */
    OIndexName jjtn000 = new OIndexName(JJTINDEXNAME);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));StringBuilder builder = new StringBuilder();
    Token token;
    OIdentifier lastIdentifier;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case 267:
        jj_consume_token(267);
                             builder.append("__@recordmap@___");
        break;
      default:
        jj_la1[200] = jj_gen;
        ;
      }
      lastIdentifier = Identifier();
                                      builder.append(lastIdentifier.getValue());
      label_29:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DOT:
        case MINUS:
          ;
          break;
        default:
          jj_la1[201] = jj_gen;
          break label_29;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DOT:
          jj_consume_token(DOT);
                    builder.append(".");
          break;
        case MINUS:
          jj_consume_token(MINUS);
                      builder.append("-");
          break;
        default:
          jj_la1[202] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        lastIdentifier = Identifier();
                                        builder.append(lastIdentifier.getValue());
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
        jjtn000.value = builder.toString();
        {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OIndexIdentifier IndexIdentifier() throws ParseException {
 /*@bgen(jjtree) IndexIdentifier */
    OIndexIdentifier jjtn000 = new OIndexIdentifier(JJTINDEXIDENTIFIER);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));Token token;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INDEX_COLON:
        jj_consume_token(INDEX_COLON);
        jjtn000.indexName = IndexName();
                                              jjtn000.type = OIndexIdentifier.Type.INDEX;
        break;
      case INDEXVALUES_IDENTIFIER:
      case INDEXVALUESASC_IDENTIFIER:
      case INDEXVALUESDESC_IDENTIFIER:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INDEXVALUES_IDENTIFIER:
          token = jj_consume_token(INDEXVALUES_IDENTIFIER);
                                                   jjtn000.type = OIndexIdentifier.Type.VALUES;
          break;
        case INDEXVALUESASC_IDENTIFIER:
          token = jj_consume_token(INDEXVALUESASC_IDENTIFIER);
                                                      jjtn000.type = OIndexIdentifier.Type.VALUESASC;
          break;
        case INDEXVALUESDESC_IDENTIFIER:
          token = jj_consume_token(INDEXVALUESDESC_IDENTIFIER);
                                                       jjtn000.type = OIndexIdentifier.Type.VALUESDESC;
          break;
        default:
          jj_la1[203] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
                jjtn000.indexNameString = token.image.split(":")[1];
        break;
      default:
        jj_la1[204] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OWhereClause WhereClause() throws ParseException {
 /*@bgen(jjtree) WhereClause */
  OWhereClause jjtn000 = new OWhereClause(JJTWHERECLAUSE);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.baseExpression = OrBlock();
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
         {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OOrBlock OrBlock() throws ParseException {
 /*@bgen(jjtree) OrBlock */
  OOrBlock jjtn000 = new OOrBlock(JJTORBLOCK);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OAndBlock lastAnd = null;
    try {
      lastAnd = AndBlock();
                               jjtn000.getSubBlocks().add(lastAnd);
      label_30:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case OR:
          ;
          break;
        default:
          jj_la1[205] = jj_gen;
          break label_30;
        }
        jj_consume_token(OR);
        lastAnd = AndBlock();
                                      jjtn000.getSubBlocks().add(lastAnd);
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OAndBlock AndBlock() throws ParseException {
 /*@bgen(jjtree) AndBlock */
 OAndBlock jjtn000 = new OAndBlock(JJTANDBLOCK);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));ONotBlock lastNot = null;
    try {
      lastNot = NotBlock();
                           jjtn000.getSubBlocks().add(lastNot);
      label_31:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case AND:
          ;
          break;
        default:
          jj_la1[206] = jj_gen;
          break label_31;
        }
        jj_consume_token(AND);
        lastNot = NotBlock();
                                   jjtn000.getSubBlocks().add(lastNot);
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ONotBlock NotBlock() throws ParseException {
 /*@bgen(jjtree) NotBlock */
  ONotBlock jjtn000 = new ONotBlock(JJTNOTBLOCK);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NOT:
        jj_consume_token(NOT);
               jjtn000.negate = true;
        if (jj_2_104(2147483647)) {
          jjtn000.sub = ConditionBlock();
        } else if (jj_2_105(2147483647)) {
          jjtn000.sub = ParenthesisBlock();
        } else {
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case NULL:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case DISTINCT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case THIS:
      case RECORD_ATTRIBUTE:
      case RID_STRING:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case TRUE:
      case FALSE:
      case LPAREN:
      case LBRACE:
      case LBRACKET:
      case HOOK:
      case COLON:
      case MINUS:
      case STAR:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 266:
        if (jj_2_106(2147483647)) {
          jjtn000.sub = ConditionBlock();
        } else if (jj_2_107(2147483647)) {
          jjtn000.sub = ParenthesisBlock();
        } else {
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[207] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression ParenthesisBlock() throws ParseException {
 /*@bgen(jjtree) ParenthesisBlock */
  OParenthesisBlock jjtn000 = new OParenthesisBlock(JJTPARENTHESISBLOCK);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(LPAREN);
      jjtn000.subElement = OrBlock();
      jj_consume_token(RPAREN);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression ConditionBlock() throws ParseException {
 /*@bgen(jjtree) ConditionBlock */
 OConditionBlock jjtn000 = new OConditionBlock(JJTCONDITIONBLOCK);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));OBooleanExpression result = null;
    try {
      if (jj_2_108(2147483647)) {
        result = IsNotNullCondition();
      } else if (jj_2_109(2147483647)) {
        result = IsNullCondition();
      } else if (jj_2_110(2147483647)) {
        result = IsNotDefinedCondition();
      } else if (jj_2_111(2147483647)) {
        result = IsDefinedCondition();
      } else if (jj_2_112(2147483647)) {
        result = InCondition();
      } else if (jj_2_113(2147483647)) {
        result = NotInCondition();
      } else if (jj_2_114(2147483647)) {
        result = BinaryCondition();
      } else if (jj_2_115(2147483647)) {
        result = BetweenCondition();
      } else if (jj_2_116(2147483647)) {
        result = ContainsCondition();
      } else if (jj_2_117(2147483647)) {
        result = ContainsValueCondition();
      } else if (jj_2_118(2147483647)) {
        result = ContainsAllCondition();
      } else if (jj_2_119(2147483647)) {
        result = ContainsAnyCondition();
      } else if (jj_2_120(2147483647)) {
        result = ContainsTextCondition();
      } else if (jj_2_121(2147483647)) {
        result = MatchesCondition();
      } else if (jj_2_122(2147483647)) {
        result = IndexMatchCondition();
      } else if (jj_2_123(2147483647)) {
        result = InstanceofCondition();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TRUE:
          jj_consume_token(TRUE);
             result = OBooleanExpression.TRUE;
          break;
        case FALSE:
          jj_consume_token(FALSE);
              result = OBooleanExpression.FALSE;
          break;
        default:
          jj_la1[208] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return result;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBinaryCompareOperator CompareOperator() throws ParseException {
 /*@bgen(jjtree) CompareOperator */
   OCompareOperator jjtn000 = new OCompareOperator(JJTCOMPAREOPERATOR);
   boolean jjtc000 = true;
   jjtree.openNodeScope(jjtn000);
   jjtn000.jjtSetFirstToken(getToken(1));OBinaryCompareOperator result;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
      case EQEQ:
        result = EqualsCompareOperator();
        break;
      case LT:
        result = LtOperator();
        break;
      case GT:
        result = GtOperator();
        break;
      case NE:
        result = NeOperator();
        break;
      case NEQ:
        result = NeqOperator();
        break;
      case GE:
        result = GeOperator();
        break;
      case LE:
        result = LeOperator();
        break;
      case LIKE:
        result = LikeOperator();
        break;
      case CONTAINSKEY:
        result = ContainsKeyOperator();
        break;
      case LUCENE:
        result = LuceneOperator();
        break;
      case NEAR:
        result = NearOperator();
        break;
      case WITHIN:
        result = WithinOperator();
        break;
      case SC_AND:
        result = ScAndOperator();
        break;
      default:
        jj_la1[209] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return result;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OLtOperator LtOperator() throws ParseException {
 /*@bgen(jjtree) LtOperator */
  OLtOperator jjtn000 = new OLtOperator(JJTLTOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(LT);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OGtOperator GtOperator() throws ParseException {
 /*@bgen(jjtree) GtOperator */
  OGtOperator jjtn000 = new OGtOperator(JJTGTOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(GT);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ONeOperator NeOperator() throws ParseException {
 /*@bgen(jjtree) NeOperator */
  ONeOperator jjtn000 = new ONeOperator(JJTNEOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(NE);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ONeqOperator NeqOperator() throws ParseException {
 /*@bgen(jjtree) NeqOperator */
  ONeqOperator jjtn000 = new ONeqOperator(JJTNEQOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(NEQ);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OGeOperator GeOperator() throws ParseException {
 /*@bgen(jjtree) GeOperator */
  OGeOperator jjtn000 = new OGeOperator(JJTGEOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(GE);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OLeOperator LeOperator() throws ParseException {
 /*@bgen(jjtree) LeOperator */
  OLeOperator jjtn000 = new OLeOperator(JJTLEOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(LE);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OLikeOperator LikeOperator() throws ParseException {
 /*@bgen(jjtree) LikeOperator */
  OLikeOperator jjtn000 = new OLikeOperator(JJTLIKEOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(LIKE);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OLuceneOperator LuceneOperator() throws ParseException {
 /*@bgen(jjtree) LuceneOperator */
  OLuceneOperator jjtn000 = new OLuceneOperator(JJTLUCENEOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(LUCENE);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ONearOperator NearOperator() throws ParseException {
 /*@bgen(jjtree) NearOperator */
  ONearOperator jjtn000 = new ONearOperator(JJTNEAROPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(NEAR);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OWithinOperator WithinOperator() throws ParseException {
 /*@bgen(jjtree) WithinOperator */
  OWithinOperator jjtn000 = new OWithinOperator(JJTWITHINOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(WITHIN);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OScAndOperator ScAndOperator() throws ParseException {
 /*@bgen(jjtree) ScAndOperator */
  OScAndOperator jjtn000 = new OScAndOperator(JJTSCANDOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(SC_AND);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OContainsKeyOperator ContainsKeyOperator() throws ParseException {
 /*@bgen(jjtree) ContainsKeyOperator */
  OContainsKeyOperator jjtn000 = new OContainsKeyOperator(JJTCONTAINSKEYOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(CONTAINSKEY);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OContainsValueOperator ContainsValueOperator() throws ParseException {
 /*@bgen(jjtree) ContainsValueOperator */
  OContainsValueOperator jjtn000 = new OContainsValueOperator(JJTCONTAINSVALUEOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(CONTAINSVALUE);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OEqualsCompareOperator EqualsCompareOperator() throws ParseException {
 /*@bgen(jjtree) EqualsCompareOperator */
  OEqualsCompareOperator jjtn000 = new OEqualsCompareOperator(JJTEQUALSCOMPAREOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EQ:
        jj_consume_token(EQ);
               jjtn000.doubleEquals = false;
        break;
      case EQEQ:
        jj_consume_token(EQEQ);
                 jjtn000.doubleEquals = true;
        break;
      default:
        jj_la1[210] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public ORightBinaryCondition RightBinaryCondition() throws ParseException {
 /*@bgen(jjtree) RightBinaryCondition */
  ORightBinaryCondition jjtn000 = new ORightBinaryCondition(JJTRIGHTBINARYCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LUCENE:
      case NEAR:
      case WITHIN:
      case EQ:
      case EQEQ:
      case LT:
      case GT:
      case LE:
      case GE:
      case NE:
      case NEQ:
      case SC_AND:
      case LIKE:
      case CONTAINSKEY:
        jjtn000.operator = CompareOperator();
        jjtn000.right = Expression();
        break;
      case NOT:
      case IN:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case NOT:
          jj_consume_token(NOT);
                   jjtn000.not = true;
          break;
        default:
          jj_la1[211] = jj_gen;
          ;
        }
        jjtn000.inOperator = InOperator();
        jjtn000.right = Expression();
        break;
      default:
        jj_la1[212] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
    if (jjtc000) {
      jjtree.clearNodeScope(jjtn000);
      jjtc000 = false;
    } else {
      jjtree.popNode();
    }
    if (jjte000 instanceof RuntimeException) {
      {if (true) throw (RuntimeException)jjte000;}
    }
    if (jjte000 instanceof ParseException) {
      {if (true) throw (ParseException)jjte000;}
    }
    {if (true) throw (Error)jjte000;}
    } finally {
    if (jjtc000) {
      jjtree.closeNodeScope(jjtn000, true);
      jjtn000.jjtSetLastToken(getToken(0));
    }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression BinaryCondition() throws ParseException {
 /*@bgen(jjtree) BinaryCondition */
  OBinaryCondition jjtn000 = new OBinaryCondition(JJTBINARYCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Expression();
      jjtn000.operator = CompareOperator();
      jjtn000.right = Expression();
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression ContainsValueCondition() throws ParseException {
 /*@bgen(jjtree) ContainsValueCondition */
  OContainsValueCondition jjtn000 = new OContainsValueCondition(JJTCONTAINSVALUECONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Expression();
      jjtn000.operator = ContainsValueOperator();
      if (jj_2_124(3)) {
        jj_consume_token(LPAREN);
        jjtn000.condition = OrBlock();
        jj_consume_token(RPAREN);
      } else if (jj_2_125(2147483647)) {
        jjtn000.expression = Expression();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
    {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression InstanceofCondition() throws ParseException {
 /*@bgen(jjtree) InstanceofCondition */
    OInstanceofCondition jjtn000 = new OInstanceofCondition(JJTINSTANCEOFCONDITION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));Token token;
    try {
      jjtn000.left = Expression();
      jj_consume_token(INSTANCEOF);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.right = Identifier();
        break;
      case RID_STRING:
      case STRING_LITERAL:
        jjtn000.rightString = String();
        break;
      case CHARACTER_LITERAL:
        token = jj_consume_token(CHARACTER_LITERAL);
                                                 jjtn000.rightString = token.image;
        break;
      default:
        jj_la1[213] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression IndexMatchCondition() throws ParseException {
 /*@bgen(jjtree) IndexMatchCondition */
    OIndexMatchCondition jjtn000 = new OIndexMatchCondition(JJTINDEXMATCHCONDITION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));Token token;
    jjtn000.leftExpressions = new ArrayList();
    OExpression lastExpression;
    try {
      jj_consume_token(KEY);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LUCENE:
      case NEAR:
      case WITHIN:
      case EQ:
      case EQEQ:
      case LT:
      case GT:
      case LE:
      case GE:
      case NE:
      case NEQ:
      case SC_AND:
      case LIKE:
      case CONTAINSKEY:
        jjtn000.operator = CompareOperator();
        jj_consume_token(LBRACKET);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case NULL:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case DISTINCT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case THIS:
        case RECORD_ATTRIBUTE:
        case RID_STRING:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case TRUE:
        case FALSE:
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case HOOK:
        case COLON:
        case MINUS:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
        case 266:
          lastExpression = Expression();
                                                    jjtn000.leftExpressions.add(lastExpression);
          label_32:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[214] = jj_gen;
              break label_32;
            }
            jj_consume_token(COMMA);
            lastExpression = Expression();
                                                        jjtn000.leftExpressions.add(lastExpression);
          }
          break;
        default:
          jj_la1[215] = jj_gen;
          ;
        }
        jj_consume_token(RBRACKET);
        break;
      case BETWEEN:
        jj_consume_token(BETWEEN);
                           jjtn000.between = true;
        jj_consume_token(LBRACKET);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case NULL:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case DISTINCT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case THIS:
        case RECORD_ATTRIBUTE:
        case RID_STRING:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case TRUE:
        case FALSE:
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case HOOK:
        case COLON:
        case MINUS:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
        case 266:
          lastExpression = Expression();
                                                    jjtn000.leftExpressions.add(lastExpression);
          label_33:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[216] = jj_gen;
              break label_33;
            }
            jj_consume_token(COMMA);
            lastExpression = Expression();
                                                        jjtn000.leftExpressions.add(lastExpression);
          }
          break;
        default:
          jj_la1[217] = jj_gen;
          ;
        }
        jj_consume_token(RBRACKET);
        jj_consume_token(AND);
        jj_consume_token(LBRACKET);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case NULL:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case DISTINCT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case THIS:
        case RECORD_ATTRIBUTE:
        case RID_STRING:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case TRUE:
        case FALSE:
        case LPAREN:
        case LBRACE:
        case LBRACKET:
        case HOOK:
        case COLON:
        case MINUS:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
        case 266:
          lastExpression = Expression();
                                                    jjtn000.rightExpressions.add(lastExpression);
          label_34:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[218] = jj_gen;
              break label_34;
            }
            jj_consume_token(COMMA);
            lastExpression = Expression();
                                                        jjtn000.rightExpressions.add(lastExpression);
          }
          break;
        default:
          jj_la1[219] = jj_gen;
          ;
        }
        jj_consume_token(RBRACKET);
        break;
      default:
        jj_la1[220] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression BetweenCondition() throws ParseException {
 /*@bgen(jjtree) BetweenCondition */
  OBetweenCondition jjtn000 = new OBetweenCondition(JJTBETWEENCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.first = Expression();
      jj_consume_token(BETWEEN);
      jjtn000.second = Expression();
      jj_consume_token(AND);
      jjtn000.third = Expression();
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression IsNullCondition() throws ParseException {
 /*@bgen(jjtree) IsNullCondition */
  OIsNullCondition jjtn000 = new OIsNullCondition(JJTISNULLCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.expression = Expression();
      jj_consume_token(IS);
      jj_consume_token(NULL);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression IsNotNullCondition() throws ParseException {
 /*@bgen(jjtree) IsNotNullCondition */
  OIsNotNullCondition jjtn000 = new OIsNotNullCondition(JJTISNOTNULLCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.expression = Expression();
      jj_consume_token(IS);
      jj_consume_token(NOT);
      jj_consume_token(NULL);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression IsDefinedCondition() throws ParseException {
 /*@bgen(jjtree) IsDefinedCondition */
  OIsDefinedCondition jjtn000 = new OIsDefinedCondition(JJTISDEFINEDCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.expression = Expression();
      jj_consume_token(IS);
      jj_consume_token(DEFINED);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression IsNotDefinedCondition() throws ParseException {
 /*@bgen(jjtree) IsNotDefinedCondition */
  OIsNotDefinedCondition jjtn000 = new OIsNotDefinedCondition(JJTISNOTDEFINEDCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.expression = Expression();
      jj_consume_token(IS);
      jj_consume_token(NOT);
      jj_consume_token(DEFINED);
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression ContainsCondition() throws ParseException {
 /*@bgen(jjtree) ContainsCondition */
  OContainsCondition jjtn000 = new OContainsCondition(JJTCONTAINSCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Expression();
      jj_consume_token(CONTAINS);
      if (jj_2_126(3)) {
        jj_consume_token(LPAREN);
        jjtn000.condition = OrBlock();
        jj_consume_token(RPAREN);
      } else if (jj_2_127(2147483647)) {
        jjtn000.right = Expression();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OInOperator InOperator() throws ParseException {
 /*@bgen(jjtree) InOperator */
  OInOperator jjtn000 = new OInOperator(JJTINOPERATOR);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(IN);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression InCondition() throws ParseException {
 /*@bgen(jjtree) InCondition */
    OInCondition jjtn000 = new OInCondition(JJTINCONDITION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OExpression lastExpression;
    try {
      jjtn000.left = Expression();
      jjtn000.operator = InOperator();
      if (jj_2_129(2)) {
        jj_consume_token(LPAREN);
        if (jj_2_128(2147483647)) {
          jjtn000.rightStatement = SelectStatement();
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case SELECT:
            jjtn000.rightStatement = SelectWithoutTargetStatement();
            break;
          default:
            jj_la1[221] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
        jj_consume_token(RPAREN);
      } else if (jj_2_130(2)) {
        jj_consume_token(LPAREN);
        jjtn000.rightParam = InputParameter();
        jj_consume_token(RPAREN);
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case DISTINCT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case THIS:
        case RECORD_ATTRIBUTE:
        case RID_STRING:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case LPAREN:
        case LBRACKET:
        case HOOK:
        case COLON:
        case MINUS:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.rightMathExpression = MathExpression();
          break;
        default:
          jj_la1[222] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
   jjtree.closeNodeScope(jjtn000, true);
   jjtc000 = false;
   jjtn000.jjtSetLastToken(getToken(0));
  {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression NotInCondition() throws ParseException {
 /*@bgen(jjtree) NotInCondition */
    ONotInCondition jjtn000 = new ONotInCondition(JJTNOTINCONDITION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OExpression lastExpression;
    try {
      jjtn000.left = Expression();
      jj_consume_token(NOT);
      InOperator();
      if (jj_2_132(2)) {
        jj_consume_token(LPAREN);
        if (jj_2_131(2147483647)) {
          jjtn000.rightStatement = SelectStatement();
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case SELECT:
            jjtn000.rightStatement = SelectWithoutTargetStatement();
            break;
          default:
            jj_la1[223] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
        }
        jj_consume_token(RPAREN);
      } else if (jj_2_133(2)) {
        jj_consume_token(LPAREN);
        jjtn000.rightParam = InputParameter();
        jj_consume_token(RPAREN);
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case DISTINCT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case THIS:
        case RECORD_ATTRIBUTE:
        case RID_STRING:
        case INTEGER_LITERAL:
        case FLOATING_POINT_LITERAL:
        case CHARACTER_LITERAL:
        case STRING_LITERAL:
        case LPAREN:
        case LBRACKET:
        case HOOK:
        case COLON:
        case MINUS:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.rightMathExpression = MathExpression();
          break;
        default:
          jj_la1[224] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression ContainsAllCondition() throws ParseException {
 /*@bgen(jjtree) ContainsAllCondition */
  OContainsAllCondition jjtn000 = new OContainsAllCondition(JJTCONTAINSALLCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Expression();
      jj_consume_token(CONTAINSALL);
      if (jj_2_134(3)) {
        jj_consume_token(LPAREN);
        jjtn000.rightBlock = OrBlock();
        jj_consume_token(RPAREN);
      } else if (jj_2_135(2147483647)) {
        jjtn000.right = Expression();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression ContainsAnyCondition() throws ParseException {
 /*@bgen(jjtree) ContainsAnyCondition */
  OContainsAnyCondition jjtn000 = new OContainsAnyCondition(JJTCONTAINSANYCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Expression();
      jj_consume_token(CONTAINSANY);
      if (jj_2_136(3)) {
        jj_consume_token(LPAREN);
        jjtn000.rightBlock = OrBlock();
        jj_consume_token(RPAREN);
      } else if (jj_2_137(2147483647)) {
        jjtn000.right = Expression();
      } else {
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression ContainsTextCondition() throws ParseException {
 /*@bgen(jjtree) ContainsTextCondition */
  OContainsTextCondition jjtn000 = new OContainsTextCondition(JJTCONTAINSTEXTCONDITION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.left = Expression();
      jj_consume_token(CONTAINSTEXT);
      jjtn000.right = Expression();
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBooleanExpression MatchesCondition() throws ParseException {
 /*@bgen(jjtree) MatchesCondition */
 OMatchesCondition jjtn000 = new OMatchesCondition(JJTMATCHESCONDITION);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));Token token;
    try {
      jjtn000.expression = Expression();
      jj_consume_token(MATCHES);
      if (jj_2_138(2147483647)) {
        jjtn000.rightExpression = Expression();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RID_STRING:
        case STRING_LITERAL:
          jjtn000.right = String();
          break;
        case CHARACTER_LITERAL:
          token = jj_consume_token(CHARACTER_LITERAL);
                                           jjtn000.right = token.image;
          break;
        case HOOK:
        case COLON:
          jjtn000.rightParam = InputParameter();
          break;
        default:
          jj_la1[225] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OOrderBy OrderBy() throws ParseException {
 /*@bgen(jjtree) OrderBy */
    OOrderBy jjtn000 = new OOrderBy(JJTORDERBY);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));jjtn000.items = new java.util.ArrayList();
    OOrderByItem lastItem;
    OIdentifier lastIdentifier;
    OModifier lastModifier;
    ORid lastRid;
    Token lastToken;
    try {
      jj_consume_token(ORDER);
      jj_consume_token(BY);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case RECORD_ATTRIBUTE:
      case INTEGER_LITERAL:
      case LBRACE:
      case MINUS:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 266:
                    lastItem = new OOrderByItem();
                    jjtn000.items.add(lastItem);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          lastIdentifier = Identifier();
                                                        lastItem.alias = lastIdentifier.getStringValue();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LBRACKET:
          case DOT:
            lastModifier = Modifier();
                                                       lastItem.modifier = lastModifier;
            break;
          default:
            jj_la1[226] = jj_gen;
            ;
          }
          break;
        case INTEGER_LITERAL:
        case LBRACE:
        case MINUS:
        case 266:
          lastItem.rid = Rid();
          break;
        case RECORD_ATTRIBUTE:
          lastToken = jj_consume_token(RECORD_ATTRIBUTE);
                                                     lastItem.recordAttr = lastToken.image;
          break;
        default:
          jj_la1[227] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ASC:
        case DESC:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case DESC:
            jj_consume_token(DESC);
                       lastItem.type = OOrderByItem.DESC;
            break;
          case ASC:
            jj_consume_token(ASC);
                                                                      lastItem.type = OOrderByItem.ASC;
            break;
          default:
            jj_la1[228] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[229] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COLLATE:
          jj_consume_token(COLLATE);
          lastItem.collate = Expression();
          break;
        default:
          jj_la1[230] = jj_gen;
          ;
        }
        break;
      case LPAREN:
        jj_consume_token(LPAREN);
                    lastItem = new OOrderByItem();
                    jjtn000.items.add(lastItem);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          lastIdentifier = Identifier();
                                                        lastItem.alias = lastIdentifier.getStringValue();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LBRACKET:
          case DOT:
            lastModifier = Modifier();
                                                       lastItem.modifier = lastModifier;
            break;
          default:
            jj_la1[231] = jj_gen;
            ;
          }
          break;
        case INTEGER_LITERAL:
        case LBRACE:
        case MINUS:
        case 266:
          lastItem.rid = Rid();
          break;
        case RECORD_ATTRIBUTE:
          lastToken = jj_consume_token(RECORD_ATTRIBUTE);
                                                     lastItem.recordAttr = lastToken.image;
          break;
        default:
          jj_la1[232] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case ASC:
        case DESC:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case DESC:
            jj_consume_token(DESC);
                       lastItem.type = OOrderByItem.DESC;
            break;
          case ASC:
            jj_consume_token(ASC);
                                                                      lastItem.type = OOrderByItem.ASC;
            break;
          default:
            jj_la1[233] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[234] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COLLATE:
          jj_consume_token(COLLATE);
          lastItem.collate = Expression();
          break;
        default:
          jj_la1[235] = jj_gen;
          ;
        }
        jj_consume_token(RPAREN);
        break;
      default:
        jj_la1[236] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      label_35:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[237] = jj_gen;
          break label_35;
        }
        jj_consume_token(COMMA);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case RECORD_ATTRIBUTE:
        case INTEGER_LITERAL:
        case LBRACE:
        case MINUS:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
        case 266:
                        lastItem = new OOrderByItem();
                        jjtn000.items.add(lastItem);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case TO:
          case VALUE:
          case VALUES:
          case SET:
          case ADD:
          case PUT:
          case MERGE:
          case CONTENT:
          case REMOVE:
          case ORDER:
          case GROUP:
          case OFFSET:
          case RECORD:
          case CACHE:
          case CYCLE:
          case NOLIMIT:
          case NOCYCLE:
          case LUCENE:
          case NEAR:
          case WITHIN:
          case MINDEPTH:
          case CLASS:
          case SUPERCLASS:
          case CLASSES:
          case SUPERCLASSES:
          case VIEW:
          case UPDATABLE:
          case EXCEPTION:
          case PROFILE:
          case STORAGE:
          case ON:
          case OFF:
          case TRUNCATE:
          case FIND:
          case REFERENCES:
          case EXTENDS:
          case CLUSTERS:
          case ABSTRACT:
          case ALTER:
          case NAME:
          case SHORTNAME:
          case OVERSIZE:
          case STRICTMODE:
          case ADDCLUSTER:
          case REMOVECLUSTER:
          case CUSTOM:
          case CLUSTERSELECTION:
          case DESCRIPTION:
          case ENCRYPTION:
          case DROP:
          case PROPERTY:
          case FORCE:
          case METADATA:
          case INDEX:
          case COLLATE:
          case ENGINE:
          case REBUILD:
          case ID:
          case DATABASE:
          case OPTIMIZE:
          case LINK:
          case TYPE:
          case INVERSE:
          case EXPLAIN:
          case GRANT:
          case REVOKE:
          case READ:
          case EXECUTE:
          case ALL:
          case NONE:
          case FUNCTION:
          case PARAMETERS:
          case IDEMPOTENT:
          case LANGUAGE:
          case BEGIN:
          case COMMIT:
          case ROLLBACK:
          case IF:
          case ELSE:
          case CONTINUE:
          case FAIL:
          case ISOLATION:
          case SLEEP:
          case CONSOLE:
          case BLOB:
          case SHARED:
          case DEFAULT_:
          case SEQUENCE:
          case START:
          case OPTIONAL:
          case COUNT:
          case HA:
          case STATUS:
          case SERVER:
          case SYNC:
          case EXISTS:
          case MOVE:
          case DEPTH_ALIAS:
          case PATH_ALIAS:
          case IDENTIFIED:
          case ROLE:
          case USER:
          case RID:
          case DEFAULTCLUSTER:
          case IN:
          case KEY:
          case IDENTIFIER:
          case QUOTED_IDENTIFIER:
            lastIdentifier = Identifier();
                                                            lastItem.alias = lastIdentifier.toString();
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case LBRACKET:
            case DOT:
              lastModifier = Modifier();
                                                           lastItem.modifier = lastModifier;
              break;
            default:
              jj_la1[238] = jj_gen;
              ;
            }
            break;
          case INTEGER_LITERAL:
          case LBRACE:
          case MINUS:
          case 266:
            lastItem.rid = Rid();
            break;
          case RECORD_ATTRIBUTE:
            lastToken = jj_consume_token(RECORD_ATTRIBUTE);
                                                         lastItem.recordAttr = lastToken.image;
            break;
          default:
            jj_la1[239] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case ASC:
          case DESC:
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case DESC:
              jj_consume_token(DESC);
                           lastItem.type = OOrderByItem.DESC;
              break;
            case ASC:
              jj_consume_token(ASC);
                                                                          lastItem.type = OOrderByItem.ASC;
              break;
            default:
              jj_la1[240] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
            break;
          default:
            jj_la1[241] = jj_gen;
            ;
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COLLATE:
            jj_consume_token(COLLATE);
            lastItem.collate = Expression();
            break;
          default:
            jj_la1[242] = jj_gen;
            ;
          }
          break;
        case LPAREN:
          jj_consume_token(LPAREN);
                        lastItem = new OOrderByItem();
                        jjtn000.items.add(lastItem);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case TO:
          case VALUE:
          case VALUES:
          case SET:
          case ADD:
          case PUT:
          case MERGE:
          case CONTENT:
          case REMOVE:
          case ORDER:
          case GROUP:
          case OFFSET:
          case RECORD:
          case CACHE:
          case CYCLE:
          case NOLIMIT:
          case NOCYCLE:
          case LUCENE:
          case NEAR:
          case WITHIN:
          case MINDEPTH:
          case CLASS:
          case SUPERCLASS:
          case CLASSES:
          case SUPERCLASSES:
          case VIEW:
          case UPDATABLE:
          case EXCEPTION:
          case PROFILE:
          case STORAGE:
          case ON:
          case OFF:
          case TRUNCATE:
          case FIND:
          case REFERENCES:
          case EXTENDS:
          case CLUSTERS:
          case ABSTRACT:
          case ALTER:
          case NAME:
          case SHORTNAME:
          case OVERSIZE:
          case STRICTMODE:
          case ADDCLUSTER:
          case REMOVECLUSTER:
          case CUSTOM:
          case CLUSTERSELECTION:
          case DESCRIPTION:
          case ENCRYPTION:
          case DROP:
          case PROPERTY:
          case FORCE:
          case METADATA:
          case INDEX:
          case COLLATE:
          case ENGINE:
          case REBUILD:
          case ID:
          case DATABASE:
          case OPTIMIZE:
          case LINK:
          case TYPE:
          case INVERSE:
          case EXPLAIN:
          case GRANT:
          case REVOKE:
          case READ:
          case EXECUTE:
          case ALL:
          case NONE:
          case FUNCTION:
          case PARAMETERS:
          case IDEMPOTENT:
          case LANGUAGE:
          case BEGIN:
          case COMMIT:
          case ROLLBACK:
          case IF:
          case ELSE:
          case CONTINUE:
          case FAIL:
          case ISOLATION:
          case SLEEP:
          case CONSOLE:
          case BLOB:
          case SHARED:
          case DEFAULT_:
          case SEQUENCE:
          case START:
          case OPTIONAL:
          case COUNT:
          case HA:
          case STATUS:
          case SERVER:
          case SYNC:
          case EXISTS:
          case MOVE:
          case DEPTH_ALIAS:
          case PATH_ALIAS:
          case IDENTIFIED:
          case ROLE:
          case USER:
          case RID:
          case DEFAULTCLUSTER:
          case IN:
          case KEY:
          case IDENTIFIER:
          case QUOTED_IDENTIFIER:
            lastIdentifier = Identifier();
                                                            lastItem.alias = lastIdentifier.toString();
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case LBRACKET:
            case DOT:
              lastModifier = Modifier();
                                                           lastItem.modifier = lastModifier;
              break;
            default:
              jj_la1[243] = jj_gen;
              ;
            }
            break;
          case INTEGER_LITERAL:
          case LBRACE:
          case MINUS:
          case 266:
            lastItem.rid = Rid();
            break;
          case RECORD_ATTRIBUTE:
            lastToken = jj_consume_token(RECORD_ATTRIBUTE);
                                                         lastItem.recordAttr = lastToken.image;
            break;
          default:
            jj_la1[244] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case ASC:
          case DESC:
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case DESC:
              jj_consume_token(DESC);
                           lastItem.type = OOrderByItem.DESC;
              break;
            case ASC:
              jj_consume_token(ASC);
                                                                          lastItem.type = OOrderByItem.ASC;
              break;
            default:
              jj_la1[245] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
            break;
          default:
            jj_la1[246] = jj_gen;
            ;
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COLLATE:
            jj_consume_token(COLLATE);
            lastItem.collate = Expression();
            break;
          default:
            jj_la1[247] = jj_gen;
            ;
          }
          jj_consume_token(RPAREN);
          break;
        default:
          jj_la1[248] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OGroupBy GroupBy() throws ParseException {
 /*@bgen(jjtree) GroupBy */
  OGroupBy jjtn000 = new OGroupBy(JJTGROUPBY);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OExpression lastExpression;
    try {
      jj_consume_token(GROUP);
      jj_consume_token(BY);
      lastExpression = Expression();
                                                     jjtn000.items.add(lastExpression);
      label_36:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[249] = jj_gen;
          break label_36;
        }
        jj_consume_token(COMMA);
        lastExpression = Expression();
                                            jjtn000.items.add(lastExpression);
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OUnwind Unwind() throws ParseException {
 /*@bgen(jjtree) Unwind */
  OUnwind jjtn000 = new OUnwind(JJTUNWIND);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier lastIdentifier;
    try {
      jj_consume_token(UNWIND);
      lastIdentifier = Identifier();
                                                 jjtn000.items.add(lastIdentifier);
      label_37:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COMMA:
          ;
          break;
        default:
          jj_la1[250] = jj_gen;
          break label_37;
        }
        jj_consume_token(COMMA);
        lastIdentifier = Identifier();
                                            jjtn000.items.add(lastIdentifier);
      }
    jjtree.closeNodeScope(jjtn000, true);
    jjtc000 = false;
    jjtn000.jjtSetLastToken(getToken(0));
   {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
  if (jjtc000) {
    jjtree.clearNodeScope(jjtn000);
    jjtc000 = false;
  } else {
    jjtree.popNode();
  }
  if (jjte000 instanceof RuntimeException) {
    {if (true) throw (RuntimeException)jjte000;}
  }
  if (jjte000 instanceof ParseException) {
    {if (true) throw (ParseException)jjte000;}
  }
  {if (true) throw (Error)jjte000;}
    } finally {
  if (jjtc000) {
    jjtree.closeNodeScope(jjtn000, true);
    jjtn000.jjtSetLastToken(getToken(0));
  }
    }
    throw new Error("Missing return statement in function");
  }

  final public OLimit Limit() throws ParseException {
 /*@bgen(jjtree) Limit */
  OLimit jjtn000 = new OLimit(JJTLIMIT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(LIMIT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_LITERAL:
      case MINUS:
        jjtn000.num = Integer();
        break;
      case HOOK:
      case COLON:
        jjtn000.inputParam = InputParameter();
        break;
      default:
        jj_la1[251] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OSkip Skip() throws ParseException {
 /*@bgen(jjtree) Skip */
  OSkip jjtn000 = new OSkip(JJTSKIP);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case SKIP2:
        jj_consume_token(SKIP2);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INTEGER_LITERAL:
        case MINUS:
          jjtn000.num = Integer();
          break;
        case HOOK:
        case COLON:
          jjtn000.inputParam = InputParameter();
          break;
        default:
          jj_la1[252] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case OFFSET:
        jj_consume_token(OFFSET);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INTEGER_LITERAL:
        case MINUS:
          jjtn000.num = Integer();
          break;
        case HOOK:
        case COLON:
          jjtn000.inputParam = InputParameter();
          break;
        default:
          jj_la1[253] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[254] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.jjtSetLastToken(getToken(0));
       {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OBatch Batch() throws ParseException {
 /*@bgen(jjtree) Batch */
  OBatch jjtn000 = new OBatch(JJTBATCH);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(BATCH);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_LITERAL:
      case MINUS:
        jjtn000.num = Integer();
        break;
      case HOOK:
      case COLON:
        jjtn000.inputParam = InputParameter();
        break;
      default:
        jj_la1[255] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OTimeout Timeout() throws ParseException {
 /*@bgen(jjtree) Timeout */
  OTimeout jjtn000 = new OTimeout(JJTTIMEOUT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OInteger val;
    try {
      jj_consume_token(TIMEOUT);
      val = Integer();
                              jjtn000.val = val.getValue();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case RETURN:
      case EXCEPTION:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case RETURN:
          jj_consume_token(RETURN);
                             jjtn000.failureStrategy = OTimeout.RETURN;
          break;
        case EXCEPTION:
          jj_consume_token(EXCEPTION);
                                jjtn000.failureStrategy = OTimeout.EXCEPTION;
          break;
        default:
          jj_la1[256] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[257] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public java.lang.Number Wait() throws ParseException {
 /*@bgen(jjtree) Wait */
  OWait jjtn000 = new OWait(JJTWAIT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OInteger val;
    try {
      jj_consume_token(WAIT);
      val = Integer();
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return val.getValue();}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public java.lang.Number Retry() throws ParseException {
 /*@bgen(jjtree) Retry */
  ORetry jjtn000 = new ORetry(JJTRETRY);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OInteger val;
    try {
      jj_consume_token(RETRY);
      val = Integer();
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return val.getValue();}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCollection Collection() throws ParseException {
 /*@bgen(jjtree) Collection */
    OCollection jjtn000 = new OCollection(JJTCOLLECTION);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OExpression lastExpression;
    try {
      jj_consume_token(LBRACKET);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case NULL:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case DISTINCT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case THIS:
      case RECORD_ATTRIBUTE:
      case RID_STRING:
      case INTEGER_LITERAL:
      case FLOATING_POINT_LITERAL:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case TRUE:
      case FALSE:
      case LPAREN:
      case LBRACE:
      case LBRACKET:
      case HOOK:
      case COLON:
      case MINUS:
      case STAR:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 266:
        lastExpression = Expression();
                                            jjtn000.expressions.add(lastExpression);
        label_38:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[258] = jj_gen;
            break label_38;
          }
          jj_consume_token(COMMA);
          lastExpression = Expression();
                                                jjtn000.expressions.add(lastExpression);
        }
        break;
      default:
        jj_la1[259] = jj_gen;
        ;
      }
      jj_consume_token(RBRACKET);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OFetchPlan FetchPlan() throws ParseException {
 /*@bgen(jjtree) FetchPlan */
  OFetchPlan jjtn000 = new OFetchPlan(JJTFETCHPLAN);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OFetchPlanItem lastItem;
    try {
      jj_consume_token(FETCHPLAN);
      lastItem = FetchPlanItem();
                                                 jjtn000.items.add(lastItem);
      label_39:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case LBRACKET:
        case STAR:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          ;
          break;
        default:
          jj_la1[260] = jj_gen;
          break label_39;
        }
        lastItem = FetchPlanItem();
                                       jjtn000.items.add(lastItem);
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OFetchPlanItem FetchPlanItem() throws ParseException {
 /*@bgen(jjtree) FetchPlanItem */
  OFetchPlanItem jjtn000 = new OFetchPlanItem(JJTFETCHPLANITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier lastIdentifier;
  boolean lastStarred = false;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STAR:
        jj_consume_token(STAR);
                     jjtn000.star = true;
        break;
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case LBRACKET:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LBRACKET:
          jj_consume_token(LBRACKET);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case INTEGER_LITERAL:
          case MINUS:
            jjtn000.leftDepth = Integer();
            break;
          case STAR:
            jj_consume_token(STAR);
                             jjtn000.leftStar = true;
            break;
          default:
            jj_la1[261] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          jj_consume_token(RBRACKET);
          break;
        default:
          jj_la1[262] = jj_gen;
          ;
        }
        lastIdentifier = Identifier();
                                            lastStarred = false;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case STAR:
          jj_consume_token(STAR);
                                                                             lastStarred = true;
          break;
        default:
          jj_la1[263] = jj_gen;
          ;
        }
                String field = lastIdentifier.getValue();
                if(lastStarred){
                    field += "*";
                }
                jjtn000.fieldChain.add(field);
        label_40:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case DOT:
            ;
            break;
          default:
            jj_la1[264] = jj_gen;
            break label_40;
          }
          jj_consume_token(DOT);
          lastIdentifier = Identifier();
                                                       lastStarred = false;
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case STAR:
            jj_consume_token(STAR);
                                                                                lastStarred = true;
            break;
          default:
            jj_la1[265] = jj_gen;
            ;
          }
                     field = lastIdentifier.getValue();
                     if(lastStarred){
                         field += "*";
                     }
                     jjtn000.fieldChain.add(field);
        }
        break;
      default:
        jj_la1[266] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(COLON);
      jjtn000.rightDepth = Integer();
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OTraverseProjectionItem TraverseProjectionItem() throws ParseException {
 /*@bgen(jjtree) TraverseProjectionItem */
  OTraverseProjectionItem jjtn000 = new OTraverseProjectionItem(JJTTRAVERSEPROJECTIONITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.base = BaseIdentifier();
      if (jj_2_139(2147483647)) {
        jjtn000.modifier = Modifier();
      } else {
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OJson Json() throws ParseException {
 /*@bgen(jjtree) Json */
    OJson jjtn000 = new OJson(JJTJSON);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OJsonItem lastItem;
    Token token;
    try {
      jj_consume_token(LBRACE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case RECORD_ATTRIBUTE:
      case RID_STRING:
      case CHARACTER_LITERAL:
      case STRING_LITERAL:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
              lastItem = new OJsonItem();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          lastItem.leftIdentifier = Identifier();
          break;
        case RECORD_ATTRIBUTE:
          token = jj_consume_token(RECORD_ATTRIBUTE);
                                            lastItem.leftString = token.image;
          break;
        case RID_STRING:
        case STRING_LITERAL:
          lastItem.leftString = String();
                                                   lastItem.leftString = lastItem.leftString.substring(1, lastItem.leftString.length() - 1);
          break;
        case CHARACTER_LITERAL:
          token = jj_consume_token(CHARACTER_LITERAL);
                                              lastItem.leftString = token.image.substring(1, token.image.length() - 1);
          break;
        default:
          jj_la1[267] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        jj_consume_token(COLON);
        lastItem.right = Expression();
                                            jjtn000.items.add(lastItem);
        label_41:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[268] = jj_gen;
            break label_41;
          }
          jj_consume_token(COMMA);
                  lastItem = new OJsonItem();
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case TO:
          case VALUE:
          case VALUES:
          case SET:
          case ADD:
          case PUT:
          case MERGE:
          case CONTENT:
          case REMOVE:
          case ORDER:
          case GROUP:
          case OFFSET:
          case RECORD:
          case CACHE:
          case CYCLE:
          case NOLIMIT:
          case NOCYCLE:
          case LUCENE:
          case NEAR:
          case WITHIN:
          case MINDEPTH:
          case CLASS:
          case SUPERCLASS:
          case CLASSES:
          case SUPERCLASSES:
          case VIEW:
          case UPDATABLE:
          case EXCEPTION:
          case PROFILE:
          case STORAGE:
          case ON:
          case OFF:
          case TRUNCATE:
          case FIND:
          case REFERENCES:
          case EXTENDS:
          case CLUSTERS:
          case ABSTRACT:
          case ALTER:
          case NAME:
          case SHORTNAME:
          case OVERSIZE:
          case STRICTMODE:
          case ADDCLUSTER:
          case REMOVECLUSTER:
          case CUSTOM:
          case CLUSTERSELECTION:
          case DESCRIPTION:
          case ENCRYPTION:
          case DROP:
          case PROPERTY:
          case FORCE:
          case METADATA:
          case INDEX:
          case COLLATE:
          case ENGINE:
          case REBUILD:
          case ID:
          case DATABASE:
          case OPTIMIZE:
          case LINK:
          case TYPE:
          case INVERSE:
          case EXPLAIN:
          case GRANT:
          case REVOKE:
          case READ:
          case EXECUTE:
          case ALL:
          case NONE:
          case FUNCTION:
          case PARAMETERS:
          case IDEMPOTENT:
          case LANGUAGE:
          case BEGIN:
          case COMMIT:
          case ROLLBACK:
          case IF:
          case ELSE:
          case CONTINUE:
          case FAIL:
          case ISOLATION:
          case SLEEP:
          case CONSOLE:
          case BLOB:
          case SHARED:
          case DEFAULT_:
          case SEQUENCE:
          case START:
          case OPTIONAL:
          case COUNT:
          case HA:
          case STATUS:
          case SERVER:
          case SYNC:
          case EXISTS:
          case MOVE:
          case DEPTH_ALIAS:
          case PATH_ALIAS:
          case IDENTIFIED:
          case ROLE:
          case USER:
          case RID:
          case DEFAULTCLUSTER:
          case IN:
          case KEY:
          case IDENTIFIER:
          case QUOTED_IDENTIFIER:
            lastItem.leftIdentifier = Identifier();
            break;
          case RECORD_ATTRIBUTE:
            token = jj_consume_token(RECORD_ATTRIBUTE);
                                                lastItem.leftString = token.image;
            break;
          case RID_STRING:
          case STRING_LITERAL:
            lastItem.leftString = String();
                                                       lastItem.leftString = lastItem.leftString.substring(1, lastItem.leftString.length() - 1);
            break;
          case CHARACTER_LITERAL:
            token = jj_consume_token(CHARACTER_LITERAL);
                                                  lastItem.leftString = token.image.substring(1, token.image.length() - 1);
            break;
          default:
            jj_la1[269] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          jj_consume_token(COLON);
          lastItem.right = Expression();
                                                jjtn000.items.add(lastItem);
        }
        break;
      default:
        jj_la1[270] = jj_gen;
        ;
      }
      jj_consume_token(RBRACE);
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchExpression MatchExpression() throws ParseException {
 /*@bgen(jjtree) MatchExpression */
  OMatchExpression jjtn000 = new OMatchExpression(JJTMATCHEXPRESSION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OMatchPathItem nextItem = null;
    try {
      jjtn000.origin = MatchFilter();
      label_42:
      while (true) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case DOT:
        case LT:
        case DECR:
        case MINUS:
          ;
          break;
        default:
          jj_la1[271] = jj_gen;
          break label_42;
        }
        if (jj_2_140(3)) {
          nextItem = MatchPathItem();
        } else if (jj_2_141(3)) {
          nextItem = MultiMatchPathItemArrows();
        } else if (jj_2_142(3)) {
          nextItem = MultiMatchPathItem();
        } else if (jj_2_143(2147483647)) {
          nextItem = OutPathItem();
        } else {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case LT:
            nextItem = InPathItem();
            break;
          default:
            jj_la1[272] = jj_gen;
            if (jj_2_144(2147483647)) {
              nextItem = BothPathItem();
            } else {
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
        }
              jjtn000.items.add(nextItem);
      }
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.jjtSetLastToken(getToken(0));
        {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem MatchPathItem() throws ParseException {
 /*@bgen(jjtree) MatchPathItem */
  OMatchPathItem jjtn000 = new OMatchPathItem(JJTMATCHPATHITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.method = MethodCall();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        jjtn000.filter = MatchFilter();
        break;
      default:
        jj_la1[273] = jj_gen;
        ;
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
       {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem MatchPathItemFirst() throws ParseException {
 /*@bgen(jjtree) MatchPathItemFirst */
  OMatchPathItemFirst jjtn000 = new OMatchPathItemFirst(JJTMATCHPATHITEMFIRST);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.function = FunctionCall();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        jjtn000.filter = MatchFilter();
        break;
      default:
        jj_la1[274] = jj_gen;
        ;
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
       {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem MultiMatchPathItem() throws ParseException {
 /*@bgen(jjtree) MultiMatchPathItem */
  OMultiMatchPathItem jjtn000 = new OMultiMatchPathItem(JJTMULTIMATCHPATHITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OMatchPathItem nextItem = null;
    try {
      jj_consume_token(DOT);
      jj_consume_token(LPAREN);
      nextItem = MatchPathItemFirst();
                                              jjtn000.items.add(nextItem);
      label_43:
      while (true) {
        if (jj_2_145(2147483647)) {
          ;
        } else {
          break label_43;
        }
        nextItem = MatchPathItem();
                                         jjtn000.items.add(nextItem);
      }
      jj_consume_token(RPAREN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        jjtn000.filter = MatchFilter();
        break;
      default:
        jj_la1[275] = jj_gen;
        ;
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
       {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem MultiMatchPathItemArrows() throws ParseException {
 /*@bgen(jjtree) MultiMatchPathItemArrows */
    OMultiMatchPathItemArrows jjtn000 = new OMultiMatchPathItemArrows(JJTMULTIMATCHPATHITEMARROWS);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OMatchPathItem prevItem = null;
    OMatchPathItem nextItem = null;
    try {
      jj_consume_token(DOT);
      jj_consume_token(LPAREN);
      label_44:
      while (true) {
        if (jj_2_146(2147483647)) {
          nextItem = OutPathItemOpt();
                                               jjtn000.items.add(nextItem);
        } else if (jj_2_147(2147483647)) {
          nextItem = InPathItemOpt();
                                              jjtn000.items.add(nextItem);
        } else if (jj_2_148(2147483647)) {
          nextItem = BothPathItemOpt();
                                                jjtn000.items.add(nextItem);
        } else {
          jj_consume_token(-1);
          throw new ParseException();
        }
                if(prevItem !=null && prevItem.filter == null){
                    {if (true) throw new OQueryParsingException("MATCH sub-pattern with no square brackets");}
                }
                prevItem = nextItem;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case LT:
        case DECR:
        case MINUS:
          ;
          break;
        default:
          jj_la1[276] = jj_gen;
          break label_44;
        }
      }
      jj_consume_token(RPAREN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        jjtn000.filter = MatchFilter();
        break;
      default:
        jj_la1[277] = jj_gen;
        ;
      }
       jjtree.closeNodeScope(jjtn000, true);
       jjtc000 = false;
       jjtn000.jjtSetLastToken(getToken(0));
       {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchFilter MatchFilter() throws ParseException {
 /*@bgen(jjtree) MatchFilter */
  OMatchFilter jjtn000 = new OMatchFilter(JJTMATCHFILTER);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OMatchFilterItem lastItem = null;
    try {
      jj_consume_token(LBRACE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case WHERE:
      case WHILE:
      case AS:
      case MAXDEPTH:
      case CLASS:
      case CLASSES:
      case OPTIONAL:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case RID:
      case CLUSTER:
      case CLUSTER_IDENTIFIER:
      case CLUSTER_NUMBER_IDENTIFIER:
        lastItem = MatchFilterItem();
                                               jjtn000.items.add(lastItem);
        label_45:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[278] = jj_gen;
            break label_45;
          }
          jj_consume_token(COMMA);
          lastItem = MatchFilterItem();
                                                   jjtn000.items.add(lastItem);
        }
        break;
      default:
        jj_la1[279] = jj_gen;
        ;
      }
      jj_consume_token(RBRACE);
        jjtree.closeNodeScope(jjtn000, true);
        jjtc000 = false;
        jjtn000.jjtSetLastToken(getToken(0));
        {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchFilterItem MatchFilterItem() throws ParseException {
 /*@bgen(jjtree) MatchFilterItem */
 OMatchFilterItem jjtn000 = new OMatchFilterItem(JJTMATCHFILTERITEM);
 boolean jjtc000 = true;
 jjtree.openNodeScope(jjtn000);
 jjtn000.jjtSetFirstToken(getToken(1));Token lastToken;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CLASS:
        jj_consume_token(CLASS);
        jj_consume_token(COLON);
        jjtn000.className = Expression();
        break;
      case CLASSES:
        jj_consume_token(CLASSES);
        jj_consume_token(COLON);
        jjtn000.classNames = Expression();
        break;
      case CLUSTER:
        jj_consume_token(CLUSTER);
        jj_consume_token(COLON);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.clusterName = Identifier();
          break;
        case INTEGER_LITERAL:
        case MINUS:
          jjtn000.clusterId = Integer();
          break;
        default:
          jj_la1[280] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case CLUSTER_IDENTIFIER:
      case CLUSTER_NUMBER_IDENTIFIER:
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case CLUSTER_IDENTIFIER:
          lastToken = jj_consume_token(CLUSTER_IDENTIFIER);
                                                  jjtn000.clusterName = new OIdentifier(lastToken.image.split(":")[1]);
          break;
        case CLUSTER_NUMBER_IDENTIFIER:
          lastToken = jj_consume_token(CLUSTER_NUMBER_IDENTIFIER);
                                                         jjtn000.clusterId = new OInteger(-1); jjtn000.clusterId.setValue(Integer.parseInt(lastToken.image.split(":")[1]));
          break;
        default:
          jj_la1[281] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case RID:
        jj_consume_token(RID);
        jj_consume_token(COLON);
        jjtn000.rid = Rid();
        break;
      case AS:
        jj_consume_token(AS);
        jj_consume_token(COLON);
        jjtn000.alias = Identifier();
        break;
      case WHERE:
        jj_consume_token(WHERE);
        jj_consume_token(COLON);
        jj_consume_token(LPAREN);
        jjtn000.filter = WhereClause();
        jj_consume_token(RPAREN);
        break;
      case WHILE:
        jj_consume_token(WHILE);
        jj_consume_token(COLON);
        jj_consume_token(LPAREN);
        jjtn000.whileCondition = WhereClause();
        jj_consume_token(RPAREN);
        break;
      case MAXDEPTH:
        jj_consume_token(MAXDEPTH);
        jj_consume_token(COLON);
        jjtn000.maxDepth = Integer();
        break;
      case OPTIONAL:
        jj_consume_token(OPTIONAL);
        jj_consume_token(COLON);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TRUE:
          jj_consume_token(TRUE);
                         jjtn000.optional = true;
          break;
        case FALSE:
          jj_consume_token(FALSE);
                          jjtn000.optional = false;
          break;
        default:
          jj_la1[282] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case DEPTH_ALIAS:
        jj_consume_token(DEPTH_ALIAS);
        jj_consume_token(COLON);
        jjtn000.depthAlias = Identifier();
        break;
      case PATH_ALIAS:
        jj_consume_token(PATH_ALIAS);
        jj_consume_token(COLON);
        jjtn000.pathAlias = Identifier();
        break;
      default:
        jj_la1[283] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem OutPathItem() throws ParseException {
 /*@bgen(jjtree) OutPathItem */
  OOutPathItem jjtn000 = new OOutPathItem(JJTOUTPATHITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier edgeName = null;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
        jj_consume_token(MINUS);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          edgeName = Identifier();
          break;
        default:
          jj_la1[284] = jj_gen;
          ;
        }
        jj_consume_token(MINUS);
        break;
      case DECR:
        jj_consume_token(DECR);
        break;
      default:
        jj_la1[285] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(GT);
      jjtn000.filter = MatchFilter();
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     if(edgeName==null){
        edgeName = new OIdentifier(-1);
        edgeName.value = "E";
     }
     jjtn000.method = new OMethodCall(-1);
     jjtn000.method.methodName = new OIdentifier(-1);
     jjtn000.method.methodName.value = "out";
     OExpression exp = new OExpression(-1);
     OBaseExpression sub = new OBaseExpression(edgeName.getStringValue());
     exp.mathExpression = sub;
     jjtn000.method.params.add(exp);
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem InPathItem() throws ParseException {
 /*@bgen(jjtree) InPathItem */
  OInPathItem jjtn000 = new OInPathItem(JJTINPATHITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier edgeName = null;
    try {
      jj_consume_token(LT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
        jj_consume_token(MINUS);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          edgeName = Identifier();
          break;
        default:
          jj_la1[286] = jj_gen;
          ;
        }
        jj_consume_token(MINUS);
        break;
      case DECR:
        jj_consume_token(DECR);
        break;
      default:
        jj_la1[287] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtn000.filter = MatchFilter();
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     if(edgeName==null){
        edgeName = new OIdentifier(-1);
        edgeName.value = "E";
     }
     jjtn000.method = new OMethodCall(-1);
     jjtn000.method.methodName = new OIdentifier(-1);
     jjtn000.method.methodName.value = "in";
     OExpression exp = new OExpression(-1);
     OBaseExpression sub = new OBaseExpression(edgeName.getStringValue());
     exp.mathExpression = sub;
     jjtn000.method.params.add(exp);
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem BothPathItem() throws ParseException {
 /*@bgen(jjtree) BothPathItem */
  OBothPathItem jjtn000 = new OBothPathItem(JJTBOTHPATHITEM);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier edgeName = null;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
        jj_consume_token(MINUS);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          edgeName = Identifier();
          break;
        default:
          jj_la1[288] = jj_gen;
          ;
        }
        jj_consume_token(MINUS);
        break;
      case DECR:
        jj_consume_token(DECR);
        break;
      default:
        jj_la1[289] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtn000.filter = MatchFilter();
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     if(edgeName==null){
        edgeName = new OIdentifier(-1);
        edgeName.value = "E";
     }
     jjtn000.method = new OMethodCall(-1);
     jjtn000.method.methodName = new OIdentifier(-1);
     jjtn000.method.methodName.value = "both";
     OExpression exp = new OExpression(-1);
     OBaseExpression sub = new OBaseExpression(edgeName.getStringValue());
     exp.mathExpression = sub;
     jjtn000.method.params.add(exp);
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem OutPathItemOpt() throws ParseException {
 /*@bgen(jjtree) OutPathItemOpt */
  OOutPathItemOpt jjtn000 = new OOutPathItemOpt(JJTOUTPATHITEMOPT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier edgeName = null;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
        jj_consume_token(MINUS);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          edgeName = Identifier();
          break;
        default:
          jj_la1[290] = jj_gen;
          ;
        }
        jj_consume_token(MINUS);
        break;
      case DECR:
        jj_consume_token(DECR);
        break;
      default:
        jj_la1[291] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jj_consume_token(GT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        jjtn000.filter = MatchFilter();
        break;
      default:
        jj_la1[292] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     if(edgeName==null){
        edgeName = new OIdentifier(-1);
        edgeName.value = "E";
     }
     jjtn000.method = new OMethodCall(-1);
     jjtn000.method.methodName = new OIdentifier(-1);
     jjtn000.method.methodName.value = "out";
     OExpression exp = new OExpression(-1);
     OBaseExpression sub = new OBaseExpression(edgeName.getStringValue());
     exp.mathExpression = sub;
     jjtn000.method.params.add(exp);
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem InPathItemOpt() throws ParseException {
 /*@bgen(jjtree) InPathItemOpt */
  OInPathItemOpt jjtn000 = new OInPathItemOpt(JJTINPATHITEMOPT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier edgeName = null;
    try {
      jj_consume_token(LT);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
        jj_consume_token(MINUS);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          edgeName = Identifier();
          break;
        default:
          jj_la1[293] = jj_gen;
          ;
        }
        jj_consume_token(MINUS);
        break;
      case DECR:
        jj_consume_token(DECR);
        break;
      default:
        jj_la1[294] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        jjtn000.filter = MatchFilter();
        break;
      default:
        jj_la1[295] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     if(edgeName==null){
        edgeName = new OIdentifier(-1);
        edgeName.value = "E";
     }
     jjtn000.method = new OMethodCall(-1);
     jjtn000.method.methodName = new OIdentifier(-1);
     jjtn000.method.methodName.value = "in";
     OExpression exp = new OExpression(-1);
     OBaseExpression sub = new OBaseExpression(edgeName.getStringValue());
     exp.mathExpression = sub;
     jjtn000.method.params.add(exp);
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OMatchPathItem BothPathItemOpt() throws ParseException {
 /*@bgen(jjtree) BothPathItemOpt */
  OBothPathItemOpt jjtn000 = new OBothPathItemOpt(JJTBOTHPATHITEMOPT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));OIdentifier edgeName = null;
    try {
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case MINUS:
        jj_consume_token(MINUS);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          edgeName = Identifier();
          break;
        default:
          jj_la1[296] = jj_gen;
          ;
        }
        jj_consume_token(MINUS);
        break;
      case DECR:
        jj_consume_token(DECR);
        break;
      default:
        jj_la1[297] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACE:
        jjtn000.filter = MatchFilter();
        break;
      default:
        jj_la1[298] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
     if(edgeName==null){
        edgeName = new OIdentifier(-1);
        edgeName.value = "E";
     }
     jjtn000.method = new OMethodCall(-1);
     jjtn000.method.methodName = new OIdentifier(-1);
     jjtn000.method.methodName.value = "both";
     OExpression exp = new OExpression(-1);
     OBaseExpression sub = new OBaseExpression(edgeName.getStringValue());
     exp.mathExpression = sub;
     jjtn000.method.params.add(exp);
     {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OProfileStorageStatement ProfileStorageStatement() throws ParseException {
 /*@bgen(jjtree) ProfileStorageStatement */
  OProfileStorageStatement jjtn000 = new OProfileStorageStatement(JJTPROFILESTORAGESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(PROFILE);
      jj_consume_token(STORAGE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ON:
        jj_consume_token(ON);
                      jjtn000.on = true;
        break;
      case OFF:
        jj_consume_token(OFF);
                       jjtn000.on = false;
        break;
      default:
        jj_la1[299] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
         {if (true) return jjtn000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OTruncateClassStatement TruncateClassStatement() throws ParseException {
 /*@bgen(jjtree) TruncateClassStatement */
  OTruncateClassStatement jjtn000 = new OTruncateClassStatement(JJTTRUNCATECLASSSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(TRUNCATE);
      jj_consume_token(CLASS);
      jjtn000.className = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case POLYMORPHIC:
        jj_consume_token(POLYMORPHIC);
                         jjtn000.polymorphic = true;
        break;
      default:
        jj_la1[300] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNSAFE:
        jj_consume_token(UNSAFE);
                    jjtn000.unsafe = true;
        break;
      default:
        jj_la1[301] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OTruncateClusterStatement TruncateClusterStatement() throws ParseException {
 /*@bgen(jjtree) TruncateClusterStatement */
  OTruncateClusterStatement jjtn000 = new OTruncateClusterStatement(JJTTRUNCATECLUSTERSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(TRUNCATE);
      jj_consume_token(CLUSTER);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.clusterName = Identifier();
        break;
      case INTEGER_LITERAL:
      case MINUS:
        jjtn000.clusterNumber = Integer();
        break;
      default:
        jj_la1[302] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNSAFE:
        jj_consume_token(UNSAFE);
                    jjtn000.unsafe = true;
        break;
      default:
        jj_la1[303] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OTruncateRecordStatement TruncateRecordStatement() throws ParseException {
 /*@bgen(jjtree) TruncateRecordStatement */
  OTruncateRecordStatement jjtn000 = new OTruncateRecordStatement(JJTTRUNCATERECORDSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));ORid lastRecord;
    try {
      jj_consume_token(TRUNCATE);
      jj_consume_token(RECORD);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_LITERAL:
      case LBRACE:
      case MINUS:
      case 266:
        jjtn000.record = Rid();
        break;
      case LBRACKET:
        jj_consume_token(LBRACKET);
                                     jjtn000.records = new ArrayList<ORid>();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INTEGER_LITERAL:
        case LBRACE:
        case MINUS:
        case 266:
          lastRecord = Rid();
                                                     jjtn000.records.add(lastRecord);
          label_46:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[304] = jj_gen;
              break label_46;
            }
            jj_consume_token(COMMA);
            lastRecord = Rid();
                                                             jjtn000.records.add(lastRecord);
          }
          break;
        default:
          jj_la1[305] = jj_gen;
          ;
        }
        jj_consume_token(RBRACKET);
        break;
      default:
        jj_la1[306] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OFindReferencesStatement FindReferencesStatement() throws ParseException {
 /*@bgen(jjtree) FindReferencesStatement */
  OFindReferencesStatement jjtn000 = new OFindReferencesStatement(JJTFINDREFERENCESSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));SimpleNode lastTarget;
    try {
      jj_consume_token(FIND);
      jj_consume_token(REFERENCES);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case INTEGER_LITERAL:
      case LBRACE:
      case MINUS:
      case 266:
        jjtn000.rid = Rid();
        break;
      case LPAREN:
        jj_consume_token(LPAREN);
        jjtn000.subQuery = StatementInternal();
        jj_consume_token(RPAREN);
        break;
      default:
        jj_la1[307] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LBRACKET:
        jj_consume_token(LBRACKET);
                     jjtn000.targets = new ArrayList<SimpleNode>();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          lastTarget = Identifier();
          break;
        case CLUSTER_IDENTIFIER:
        case CLUSTER_NUMBER_IDENTIFIER:
          lastTarget = Cluster();
          break;
        default:
          jj_la1[308] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
           jjtn000.targets.add(lastTarget);
        label_47:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[309] = jj_gen;
            break label_47;
          }
          jj_consume_token(COMMA);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case TO:
          case VALUE:
          case VALUES:
          case SET:
          case ADD:
          case PUT:
          case MERGE:
          case CONTENT:
          case REMOVE:
          case ORDER:
          case GROUP:
          case OFFSET:
          case RECORD:
          case CACHE:
          case CYCLE:
          case NOLIMIT:
          case NOCYCLE:
          case LUCENE:
          case NEAR:
          case WITHIN:
          case MINDEPTH:
          case CLASS:
          case SUPERCLASS:
          case CLASSES:
          case SUPERCLASSES:
          case VIEW:
          case UPDATABLE:
          case EXCEPTION:
          case PROFILE:
          case STORAGE:
          case ON:
          case OFF:
          case TRUNCATE:
          case FIND:
          case REFERENCES:
          case EXTENDS:
          case CLUSTERS:
          case ABSTRACT:
          case ALTER:
          case NAME:
          case SHORTNAME:
          case OVERSIZE:
          case STRICTMODE:
          case ADDCLUSTER:
          case REMOVECLUSTER:
          case CUSTOM:
          case CLUSTERSELECTION:
          case DESCRIPTION:
          case ENCRYPTION:
          case DROP:
          case PROPERTY:
          case FORCE:
          case METADATA:
          case INDEX:
          case COLLATE:
          case ENGINE:
          case REBUILD:
          case ID:
          case DATABASE:
          case OPTIMIZE:
          case LINK:
          case TYPE:
          case INVERSE:
          case EXPLAIN:
          case GRANT:
          case REVOKE:
          case READ:
          case EXECUTE:
          case ALL:
          case NONE:
          case FUNCTION:
          case PARAMETERS:
          case IDEMPOTENT:
          case LANGUAGE:
          case BEGIN:
          case COMMIT:
          case ROLLBACK:
          case IF:
          case ELSE:
          case CONTINUE:
          case FAIL:
          case ISOLATION:
          case SLEEP:
          case CONSOLE:
          case BLOB:
          case SHARED:
          case DEFAULT_:
          case SEQUENCE:
          case START:
          case OPTIONAL:
          case COUNT:
          case HA:
          case STATUS:
          case SERVER:
          case SYNC:
          case EXISTS:
          case MOVE:
          case DEPTH_ALIAS:
          case PATH_ALIAS:
          case IDENTIFIED:
          case ROLE:
          case USER:
          case RID:
          case DEFAULTCLUSTER:
          case IN:
          case KEY:
          case IDENTIFIER:
          case QUOTED_IDENTIFIER:
            lastTarget = Identifier();
            break;
          case CLUSTER_IDENTIFIER:
          case CLUSTER_NUMBER_IDENTIFIER:
            lastTarget = Cluster();
            break;
          default:
            jj_la1[310] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
                           jjtn000.targets.add(lastTarget);
        }
        jj_consume_token(RBRACKET);
        break;
      default:
        jj_la1[311] = jj_gen;
        ;
      }
      jjtree.closeNodeScope(jjtn000, true);
      jjtc000 = false;
      jjtn000.jjtSetLastToken(getToken(0));
      {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateClassStatement CreateClassStatement() throws ParseException {
 /*@bgen(jjtree) CreateClassStatement */
        OCreateClassStatement jjtn000 = new OCreateClassStatement(JJTCREATECLASSSTATEMENT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtn000.jjtSetFirstToken(getToken(1));OIdentifier lastIdentifier;
        OInteger lastInteger;
    try {
      jj_consume_token(CREATE);
      jj_consume_token(CLASS);
      jjtn000.name = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
        jj_consume_token(IF);
        jj_consume_token(NOT);
        jj_consume_token(EXISTS);
                                        jjtn000.ifNotExists = true;
        break;
      default:
        jj_la1[312] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case EXTENDS:
        jj_consume_token(EXTENDS);
        lastIdentifier = Identifier();
                                                                  jjtn000.superclasses = new ArrayList<OIdentifier>(); jjtn000.superclasses.add(lastIdentifier);
        label_48:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[313] = jj_gen;
            break label_48;
          }
          jj_consume_token(COMMA);
          lastIdentifier = Identifier();
                                                                jjtn000.superclasses.add(lastIdentifier);
        }
        break;
      default:
        jj_la1[314] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CLUSTER:
        jj_consume_token(CLUSTER);
        lastInteger = Integer();
                                                            jjtn000.clusters = new ArrayList<OInteger>(); jjtn000.clusters.add(lastInteger);
        label_49:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[315] = jj_gen;
            break label_49;
          }
          jj_consume_token(COMMA);
          lastInteger = Integer();
                                                          jjtn000.clusters.add(lastInteger);
        }
        break;
      default:
        jj_la1[316] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CLUSTERS:
        jj_consume_token(CLUSTERS);
        jjtn000.totalClusterNo = Integer();
        break;
      default:
        jj_la1[317] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ABSTRACT:
        jj_consume_token(ABSTRACT);
                               jjtn000.abstractClass = true;
        break;
      default:
        jj_la1[318] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateViewStatement CreateViewStatement() throws ParseException {
 /*@bgen(jjtree) CreateViewStatement */
  OCreateViewStatement jjtn000 = new OCreateViewStatement(JJTCREATEVIEWSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(CREATE);
      jj_consume_token(VIEW);
      jjtn000.name = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
        jj_consume_token(IF);
        jj_consume_token(NOT);
        jj_consume_token(EXISTS);
                                        jjtn000.ifNotExists = true;
        break;
      default:
        jj_la1[319] = jj_gen;
        ;
      }
      jj_consume_token(FROM);
      jj_consume_token(LPAREN);
      jjtn000.statement = QueryStatement();
      jj_consume_token(RPAREN);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case METADATA:
        jj_consume_token(METADATA);
        jjtn000.metadata = Json();
        break;
      default:
        jj_la1[320] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          jjtn000.checkMetadataSyntax();
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OAlterClassStatement AlterClassStatement() throws ParseException {
 /*@bgen(jjtree) AlterClassStatement */
        OAlterClassStatement jjtn000 = new OAlterClassStatement(JJTALTERCLASSSTATEMENT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtn000.jjtSetFirstToken(getToken(1));OIdentifier lastIdentifier;
        OInteger lastInteger;
        Token lastToken;
    try {
      jj_consume_token(ALTER);
      jj_consume_token(CLASS);
      jjtn000.name = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case NAME:
        jj_consume_token(NAME);
                                 jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.NAME;
        jjtn000.identifierValue = Identifier();
        break;
      case SHORTNAME:
        jj_consume_token(SHORTNAME);
                                      jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.SHORTNAME;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.identifierValue = Identifier();
          break;
        case NULL:
          jj_consume_token(NULL);
          break;
        default:
          jj_la1[321] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case SUPERCLASS:
        jj_consume_token(SUPERCLASS);
                                       jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.SUPERCLASS;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case PLUS:
        case MINUS:
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case PLUS:
            jj_consume_token(PLUS);
                                                jjtn000.add = true;
            break;
          case MINUS:
            jj_consume_token(MINUS);
                                                 jjtn000.remove = true;
            break;
          default:
            jj_la1[322] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[323] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.identifierValue = Identifier();
          break;
        case NULL:
          jj_consume_token(NULL);
                                         jjtn000.identifierValue = null;
          break;
        default:
          jj_la1[324] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case SUPERCLASSES:
        jj_consume_token(SUPERCLASSES);
                                jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.SUPERCLASSES;
                                jjtn000.identifierListValue = new ArrayList<OIdentifier>();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          lastIdentifier = Identifier();
                                                                        jjtn000.identifierListValue.add(lastIdentifier);
          label_50:
          while (true) {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case COMMA:
              ;
              break;
            default:
              jj_la1[325] = jj_gen;
              break label_50;
            }
            jj_consume_token(COMMA);
            lastIdentifier = Identifier();
                                                                                jjtn000.identifierListValue.add(lastIdentifier);
          }
          break;
        case NULL:
          jj_consume_token(NULL);
                                         jjtn000.identifierListValue = null;
          break;
        default:
          jj_la1[326] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case OVERSIZE:
        jj_consume_token(OVERSIZE);
                                     jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.OVERSIZE;
        jjtn000.numberValue = Number();
        break;
      case STRICTMODE:
        jj_consume_token(STRICTMODE);
                                       jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.STRICTMODE;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TRUE:
          jj_consume_token(TRUE);
                                                 jjtn000.booleanValue = true;
          break;
        case FALSE:
          jj_consume_token(FALSE);
                                                  jjtn000.booleanValue = false;
          break;
        default:
          jj_la1[327] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case ADDCLUSTER:
        jj_consume_token(ADDCLUSTER);
                                       jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.ADDCLUSTER;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.identifierValue = Identifier();
          break;
        case INTEGER_LITERAL:
        case MINUS:
          jjtn000.numberValue = Integer();
          break;
        default:
          jj_la1[328] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case REMOVECLUSTER:
        jj_consume_token(REMOVECLUSTER);
                                          jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.REMOVECLUSTER;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.identifierValue = Identifier();
          break;
        case INTEGER_LITERAL:
        case MINUS:
          jjtn000.numberValue = Integer();
          break;
        default:
          jj_la1[329] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case CUSTOM:
        jj_consume_token(CUSTOM);
                                   jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.CUSTOM;
        jjtn000.customKey = Identifier();
        jj_consume_token(EQ);
        jjtn000.customValue = Expression();
        break;
      case ABSTRACT:
        jj_consume_token(ABSTRACT);
                                     jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.ABSTRACT;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TRUE:
          jj_consume_token(TRUE);
                                                 jjtn000.booleanValue = true;
          break;
        case FALSE:
          jj_consume_token(FALSE);
                                                  jjtn000.booleanValue = false;
          break;
        default:
          jj_la1[330] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case CLUSTERSELECTION:
        jj_consume_token(CLUSTERSELECTION);
                                             jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.CLUSTERSELECTION;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.identifierValue = Identifier();
          break;
        case 268:
          jj_consume_token(268);
                                                jjtn000.customString = "round-robin";
          break;
        case RID_STRING:
        case STRING_LITERAL:
          jjtn000.customString = String();
                                                                    jjtn000.customString = jjtn000.customString.substring(1, jjtn000.customString.length() - 1);
          break;
        default:
          jj_la1[331] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case DESCRIPTION:
        jj_consume_token(DESCRIPTION);
                                        jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.DESCRIPTION;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.identifierValue = Identifier();
          break;
        case NULL:
          jj_consume_token(NULL);
          break;
        default:
          jj_la1[332] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case ENCRYPTION:
        jj_consume_token(ENCRYPTION);
                                       jjtn000.property = com.orientechnologies.orient.core.metadata.schema.OClass.ATTRIBUTES.ENCRYPTION;
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.identifierValue = Identifier();
          break;
        case NULL:
          jj_consume_token(NULL);
          break;
        default:
          jj_la1[333] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      case DEFAULTCLUSTER:
        jj_consume_token(DEFAULTCLUSTER);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case INTEGER_LITERAL:
        case MINUS:
          jjtn000.defaultClusterId = Integer();
          break;
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.defaultClusterName = Identifier();
          break;
        default:
          jj_la1[334] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        break;
      default:
        jj_la1[335] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNSAFE:
        jj_consume_token(UNSAFE);
                     jjtn000.unsafe = true;
        break;
      default:
        jj_la1[336] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODropClassStatement DropClassStatement() throws ParseException {
 /*@bgen(jjtree) DropClassStatement */
  ODropClassStatement jjtn000 = new ODropClassStatement(JJTDROPCLASSSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(DROP);
      jj_consume_token(CLASS);
      jjtn000.name = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
        jj_consume_token(IF);
        jj_consume_token(EXISTS);
                          jjtn000.ifExists = true;
        break;
      default:
        jj_la1[337] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNSAFE:
        jj_consume_token(UNSAFE);
                     jjtn000.unsafe = true;
        break;
      default:
        jj_la1[338] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODropViewStatement DropViewStatement() throws ParseException {
 /*@bgen(jjtree) DropViewStatement */
  ODropViewStatement jjtn000 = new ODropViewStatement(JJTDROPVIEWSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(DROP);
      jj_consume_token(VIEW);
      jjtn000.name = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
        jj_consume_token(IF);
        jj_consume_token(EXISTS);
                          jjtn000.ifExists = true;
        break;
      default:
        jj_la1[339] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public void IfNotExists() throws ParseException {
                    /*@bgen(jjtree) IfNotExists */
  OIfNotExists jjtn000 = new OIfNotExists(JJTIFNOTEXISTS);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(IF);
      jj_consume_token(NOT);
      jj_consume_token(EXISTS);
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
  }

  final public OCreatePropertyStatement CreatePropertyStatement() throws ParseException {
 /*@bgen(jjtree) CreatePropertyStatement */
        OCreatePropertyStatement jjtn000 = new OCreatePropertyStatement(JJTCREATEPROPERTYSTATEMENT);
        boolean jjtc000 = true;
        jjtree.openNodeScope(jjtn000);
        jjtn000.jjtSetFirstToken(getToken(1));OCreatePropertyAttributeStatement lastAttribute;
    try {
      jj_consume_token(CREATE);
      jj_consume_token(PROPERTY);
      jjtn000.className = Identifier();
      jj_consume_token(DOT);
      jjtn000.propertyName = Identifier();
      if (jj_2_149(3)) {
        IfNotExists();
                                                   jjtn000.ifNotExists = true;
      } else {
        ;
      }
      jjtn000.propertyType = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.linkedType = Identifier();
        break;
      default:
        jj_la1[340] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case LPAREN:
        jj_consume_token(LPAREN);
        lastAttribute = CreatePropertyAttributeStatement();
                                                                         jjtn000.attributes.add(lastAttribute);
        label_51:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[341] = jj_gen;
            break label_51;
          }
          jj_consume_token(COMMA);
          lastAttribute = CreatePropertyAttributeStatement();
                                                                                jjtn000.attributes.add(lastAttribute);
        }
        jj_consume_token(RPAREN);
        break;
      default:
        jj_la1[342] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case UNSAFE:
        jj_consume_token(UNSAFE);
                             jjtn000.unsafe = true;
        break;
      default:
        jj_la1[343] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreatePropertyAttributeStatement CreatePropertyAttributeStatement() throws ParseException {
 /*@bgen(jjtree) CreatePropertyAttributeStatement */
  OCreatePropertyAttributeStatement jjtn000 = new OCreatePropertyAttributeStatement(JJTCREATEPROPERTYATTRIBUTESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jjtn000.settingName = Identifier();
      if (getToken(1).kind != COMMA && getToken(1).kind != RPAREN) {
        jjtn000.settingValue = Expression();
      } else {
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OAlterPropertyStatement AlterPropertyStatement() throws ParseException {
 /*@bgen(jjtree) AlterPropertyStatement */
  OAlterPropertyStatement jjtn000 = new OAlterPropertyStatement(JJTALTERPROPERTYSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(ALTER);
      jj_consume_token(PROPERTY);
      jjtn000.className = Identifier();
      jj_consume_token(DOT);
      jjtn000.propertyName = Identifier();
      if (jj_2_150(3)) {
        jj_consume_token(CUSTOM);
        jjtn000.customPropertyName = Identifier();
        jj_consume_token(EQ);
        jjtn000.customPropertyValue = Expression();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.settingName = Identifier();
          jjtn000.settingValue = Expression();
          break;
        default:
          jj_la1[344] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODropPropertyStatement DropPropertyStatement() throws ParseException {
 /*@bgen(jjtree) DropPropertyStatement */
  ODropPropertyStatement jjtn000 = new ODropPropertyStatement(JJTDROPPROPERTYSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(DROP);
      jj_consume_token(PROPERTY);
      jjtn000.className = Identifier();
      jj_consume_token(DOT);
      jjtn000.propertyName = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
        jj_consume_token(IF);
        jj_consume_token(EXISTS);
                          jjtn000.ifExists = true;
        break;
      default:
        jj_la1[345] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case FORCE:
        jj_consume_token(FORCE);
                    jjtn000.force = true;
        break;
      default:
        jj_la1[346] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateIndexStatement CreateIndexStatement() throws ParseException {
 /*@bgen(jjtree) CreateIndexStatement */
    OCreateIndexStatement jjtn000 = new OCreateIndexStatement(JJTCREATEINDEXSTATEMENT);
    boolean jjtc000 = true;
    jjtree.openNodeScope(jjtn000);
    jjtn000.jjtSetFirstToken(getToken(1));OCreateIndexStatement.Property lastProperty;
    OIdentifier lastIdentifier;
    ORecordAttribute lastRecordAttr;
    try {
      jj_consume_token(CREATE);
      jj_consume_token(INDEX);
      jjtn000.name = IndexName();
      if (jj_2_152(4)) {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case IF:
          jj_consume_token(IF);
          jj_consume_token(NOT);
          jj_consume_token(EXISTS);
                                   jjtn000.ifNotExists = true;
          break;
        default:
          jj_la1[347] = jj_gen;
          ;
        }
        jj_consume_token(ON);
        jjtn000.className = Identifier();
        jj_consume_token(LPAREN);
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          lastIdentifier = Identifier();
                    lastProperty = new OCreateIndexStatement.Property();
                    lastProperty.name = lastIdentifier;
                    jjtn000.propertyList.add(lastProperty);
          break;
        case RECORD_ATTRIBUTE:
          lastRecordAttr = RecordAttribute();
                    lastProperty = new OCreateIndexStatement.Property();
                    lastProperty.recordAttribute = lastRecordAttr;
                    jjtn000.propertyList.add(lastProperty);
          break;
        default:
          jj_la1[348] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case BY:
          jj_consume_token(BY);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case KEY:
            jj_consume_token(KEY);
                            lastProperty.byKey = true;
            break;
          case VALUE:
            jj_consume_token(VALUE);
                              lastProperty.byValue = true;
            break;
          default:
            jj_la1[349] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          break;
        default:
          jj_la1[350] = jj_gen;
          ;
        }
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case COLLATE:
          jj_consume_token(COLLATE);
          lastProperty.collate = Identifier();
          break;
        default:
          jj_la1[351] = jj_gen;
          ;
        }
        label_52:
        while (true) {
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COMMA:
            ;
            break;
          default:
            jj_la1[352] = jj_gen;
            break label_52;
          }
          jj_consume_token(COMMA);
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case TO:
          case VALUE:
          case VALUES:
          case SET:
          case ADD:
          case PUT:
          case MERGE:
          case CONTENT:
          case REMOVE:
          case ORDER:
          case GROUP:
          case OFFSET:
          case RECORD:
          case CACHE:
          case CYCLE:
          case NOLIMIT:
          case NOCYCLE:
          case LUCENE:
          case NEAR:
          case WITHIN:
          case MINDEPTH:
          case CLASS:
          case SUPERCLASS:
          case CLASSES:
          case SUPERCLASSES:
          case VIEW:
          case UPDATABLE:
          case EXCEPTION:
          case PROFILE:
          case STORAGE:
          case ON:
          case OFF:
          case TRUNCATE:
          case FIND:
          case REFERENCES:
          case EXTENDS:
          case CLUSTERS:
          case ABSTRACT:
          case ALTER:
          case NAME:
          case SHORTNAME:
          case OVERSIZE:
          case STRICTMODE:
          case ADDCLUSTER:
          case REMOVECLUSTER:
          case CUSTOM:
          case CLUSTERSELECTION:
          case DESCRIPTION:
          case ENCRYPTION:
          case DROP:
          case PROPERTY:
          case FORCE:
          case METADATA:
          case INDEX:
          case COLLATE:
          case ENGINE:
          case REBUILD:
          case ID:
          case DATABASE:
          case OPTIMIZE:
          case LINK:
          case TYPE:
          case INVERSE:
          case EXPLAIN:
          case GRANT:
          case REVOKE:
          case READ:
          case EXECUTE:
          case ALL:
          case NONE:
          case FUNCTION:
          case PARAMETERS:
          case IDEMPOTENT:
          case LANGUAGE:
          case BEGIN:
          case COMMIT:
          case ROLLBACK:
          case IF:
          case ELSE:
          case CONTINUE:
          case FAIL:
          case ISOLATION:
          case SLEEP:
          case CONSOLE:
          case BLOB:
          case SHARED:
          case DEFAULT_:
          case SEQUENCE:
          case START:
          case OPTIONAL:
          case COUNT:
          case HA:
          case STATUS:
          case SERVER:
          case SYNC:
          case EXISTS:
          case MOVE:
          case DEPTH_ALIAS:
          case PATH_ALIAS:
          case IDENTIFIED:
          case ROLE:
          case USER:
          case RID:
          case DEFAULTCLUSTER:
          case IN:
          case KEY:
          case IDENTIFIER:
          case QUOTED_IDENTIFIER:
            lastIdentifier = Identifier();
                        lastProperty = new OCreateIndexStatement.Property();
                        lastProperty.name = lastIdentifier;
                        jjtn000.propertyList.add(lastProperty);
            break;
          case RECORD_ATTRIBUTE:
            lastRecordAttr = RecordAttribute();
                        lastProperty = new OCreateIndexStatement.Property();
                        lastProperty.recordAttribute = lastRecordAttr;
                        jjtn000.propertyList.add(lastProperty);
            break;
          default:
            jj_la1[353] = jj_gen;
            jj_consume_token(-1);
            throw new ParseException();
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case BY:
            jj_consume_token(BY);
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case KEY:
              jj_consume_token(KEY);
                                lastProperty.byKey = true;
              break;
            case VALUE:
              jj_consume_token(VALUE);
                                  lastProperty.byValue = true;
              break;
            default:
              jj_la1[354] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
            break;
          default:
            jj_la1[355] = jj_gen;
            ;
          }
          switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
          case COLLATE:
            jj_consume_token(COLLATE);
            lastProperty.collate = Identifier();
            break;
          default:
            jj_la1[356] = jj_gen;
            ;
          }
        }
        jj_consume_token(RPAREN);
        jjtn000.type = Identifier();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          if (jj_2_151(3)) {
            jj_consume_token(IF);
            jj_consume_token(NOT);
            jj_consume_token(EXISTS);
                                  jjtn000.ifNotExists = true;
            jjtn000.type = Identifier();
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case TO:
            case VALUE:
            case VALUES:
            case SET:
            case ADD:
            case PUT:
            case MERGE:
            case CONTENT:
            case REMOVE:
            case ORDER:
            case GROUP:
            case OFFSET:
            case RECORD:
            case CACHE:
            case CYCLE:
            case NOLIMIT:
            case NOCYCLE:
            case LUCENE:
            case NEAR:
            case WITHIN:
            case MINDEPTH:
            case CLASS:
            case SUPERCLASS:
            case CLASSES:
            case SUPERCLASSES:
            case VIEW:
            case UPDATABLE:
            case EXCEPTION:
            case PROFILE:
            case STORAGE:
            case ON:
            case OFF:
            case TRUNCATE:
            case FIND:
            case REFERENCES:
            case EXTENDS:
            case CLUSTERS:
            case ABSTRACT:
            case ALTER:
            case NAME:
            case SHORTNAME:
            case OVERSIZE:
            case STRICTMODE:
            case ADDCLUSTER:
            case REMOVECLUSTER:
            case CUSTOM:
            case CLUSTERSELECTION:
            case DESCRIPTION:
            case ENCRYPTION:
            case DROP:
            case PROPERTY:
            case FORCE:
            case METADATA:
            case INDEX:
            case COLLATE:
            case ENGINE:
            case REBUILD:
            case ID:
            case DATABASE:
            case OPTIMIZE:
            case LINK:
            case TYPE:
            case INVERSE:
            case EXPLAIN:
            case GRANT:
            case REVOKE:
            case READ:
            case EXECUTE:
            case ALL:
            case NONE:
            case FUNCTION:
            case PARAMETERS:
            case IDEMPOTENT:
            case LANGUAGE:
            case BEGIN:
            case COMMIT:
            case ROLLBACK:
            case IF:
            case ELSE:
            case CONTINUE:
            case FAIL:
            case ISOLATION:
            case SLEEP:
            case CONSOLE:
            case BLOB:
            case SHARED:
            case DEFAULT_:
            case SEQUENCE:
            case START:
            case OPTIONAL:
            case COUNT:
            case HA:
            case STATUS:
            case SERVER:
            case SYNC:
            case EXISTS:
            case MOVE:
            case DEPTH_ALIAS:
            case PATH_ALIAS:
            case IDENTIFIED:
            case ROLE:
            case USER:
            case RID:
            case DEFAULTCLUSTER:
            case IN:
            case KEY:
            case IDENTIFIER:
            case QUOTED_IDENTIFIER:
              jjtn000.type = Identifier();
              break;
            default:
              jj_la1[357] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
          break;
        default:
          jj_la1[358] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
      if (jj_2_155(2)) {
        jj_consume_token(ENGINE);
        jjtn000.engine = Identifier();
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          if (jj_2_153(2)) {
            jj_consume_token(METADATA);
            jjtn000.metadata = Json();
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case TO:
            case VALUE:
            case VALUES:
            case SET:
            case ADD:
            case PUT:
            case MERGE:
            case CONTENT:
            case REMOVE:
            case ORDER:
            case GROUP:
            case OFFSET:
            case RECORD:
            case CACHE:
            case CYCLE:
            case NOLIMIT:
            case NOCYCLE:
            case LUCENE:
            case NEAR:
            case WITHIN:
            case MINDEPTH:
            case CLASS:
            case SUPERCLASS:
            case CLASSES:
            case SUPERCLASSES:
            case VIEW:
            case UPDATABLE:
            case EXCEPTION:
            case PROFILE:
            case STORAGE:
            case ON:
            case OFF:
            case TRUNCATE:
            case FIND:
            case REFERENCES:
            case EXTENDS:
            case CLUSTERS:
            case ABSTRACT:
            case ALTER:
            case NAME:
            case SHORTNAME:
            case OVERSIZE:
            case STRICTMODE:
            case ADDCLUSTER:
            case REMOVECLUSTER:
            case CUSTOM:
            case CLUSTERSELECTION:
            case DESCRIPTION:
            case ENCRYPTION:
            case DROP:
            case PROPERTY:
            case FORCE:
            case METADATA:
            case INDEX:
            case COLLATE:
            case ENGINE:
            case REBUILD:
            case ID:
            case DATABASE:
            case OPTIMIZE:
            case LINK:
            case TYPE:
            case INVERSE:
            case EXPLAIN:
            case GRANT:
            case REVOKE:
            case READ:
            case EXECUTE:
            case ALL:
            case NONE:
            case FUNCTION:
            case PARAMETERS:
            case IDEMPOTENT:
            case LANGUAGE:
            case BEGIN:
            case COMMIT:
            case ROLLBACK:
            case IF:
            case ELSE:
            case CONTINUE:
            case FAIL:
            case ISOLATION:
            case SLEEP:
            case CONSOLE:
            case BLOB:
            case SHARED:
            case DEFAULT_:
            case SEQUENCE:
            case START:
            case OPTIONAL:
            case COUNT:
            case HA:
            case STATUS:
            case SERVER:
            case SYNC:
            case EXISTS:
            case MOVE:
            case DEPTH_ALIAS:
            case PATH_ALIAS:
            case IDENTIFIED:
            case ROLE:
            case USER:
            case RID:
            case DEFAULTCLUSTER:
            case IN:
            case KEY:
            case IDENTIFIER:
            case QUOTED_IDENTIFIER:
              lastIdentifier = Identifier();
                                                   jjtn000.keyTypes.add(lastIdentifier);
              label_53:
              while (true) {
                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
                case COMMA:
                  ;
                  break;
                default:
                  jj_la1[359] = jj_gen;
                  break label_53;
                }
                jj_consume_token(COMMA);
                lastIdentifier = Identifier();
                                                               jjtn000.keyTypes.add(lastIdentifier);
              }
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case METADATA:
                jj_consume_token(METADATA);
                jjtn000.metadata = Json();
                break;
              default:
                jj_la1[360] = jj_gen;
                ;
              }
              break;
            default:
              jj_la1[361] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
          break;
        default:
          jj_la1[362] = jj_gen;
          ;
        }
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          if (jj_2_154(2)) {
            jj_consume_token(METADATA);
            jjtn000.metadata = Json();
          } else {
            switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
            case TO:
            case VALUE:
            case VALUES:
            case SET:
            case ADD:
            case PUT:
            case MERGE:
            case CONTENT:
            case REMOVE:
            case ORDER:
            case GROUP:
            case OFFSET:
            case RECORD:
            case CACHE:
            case CYCLE:
            case NOLIMIT:
            case NOCYCLE:
            case LUCENE:
            case NEAR:
            case WITHIN:
            case MINDEPTH:
            case CLASS:
            case SUPERCLASS:
            case CLASSES:
            case SUPERCLASSES:
            case VIEW:
            case UPDATABLE:
            case EXCEPTION:
            case PROFILE:
            case STORAGE:
            case ON:
            case OFF:
            case TRUNCATE:
            case FIND:
            case REFERENCES:
            case EXTENDS:
            case CLUSTERS:
            case ABSTRACT:
            case ALTER:
            case NAME:
            case SHORTNAME:
            case OVERSIZE:
            case STRICTMODE:
            case ADDCLUSTER:
            case REMOVECLUSTER:
            case CUSTOM:
            case CLUSTERSELECTION:
            case DESCRIPTION:
            case ENCRYPTION:
            case DROP:
            case PROPERTY:
            case FORCE:
            case METADATA:
            case INDEX:
            case COLLATE:
            case ENGINE:
            case REBUILD:
            case ID:
            case DATABASE:
            case OPTIMIZE:
            case LINK:
            case TYPE:
            case INVERSE:
            case EXPLAIN:
            case GRANT:
            case REVOKE:
            case READ:
            case EXECUTE:
            case ALL:
            case NONE:
            case FUNCTION:
            case PARAMETERS:
            case IDEMPOTENT:
            case LANGUAGE:
            case BEGIN:
            case COMMIT:
            case ROLLBACK:
            case IF:
            case ELSE:
            case CONTINUE:
            case FAIL:
            case ISOLATION:
            case SLEEP:
            case CONSOLE:
            case BLOB:
            case SHARED:
            case DEFAULT_:
            case SEQUENCE:
            case START:
            case OPTIONAL:
            case COUNT:
            case HA:
            case STATUS:
            case SERVER:
            case SYNC:
            case EXISTS:
            case MOVE:
            case DEPTH_ALIAS:
            case PATH_ALIAS:
            case IDENTIFIED:
            case ROLE:
            case USER:
            case RID:
            case DEFAULTCLUSTER:
            case IN:
            case KEY:
            case IDENTIFIER:
            case QUOTED_IDENTIFIER:
              lastIdentifier = Identifier();
                                                   jjtn000.keyTypes.add(lastIdentifier);
              label_54:
              while (true) {
                switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
                case COMMA:
                  ;
                  break;
                default:
                  jj_la1[363] = jj_gen;
                  break label_54;
                }
                jj_consume_token(COMMA);
                lastIdentifier = Identifier();
                                                               jjtn000.keyTypes.add(lastIdentifier);
              }
              switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
              case METADATA:
                jj_consume_token(METADATA);
                jjtn000.metadata = Json();
                break;
              default:
                jj_la1[364] = jj_gen;
                ;
              }
              break;
            default:
              jj_la1[365] = jj_gen;
              jj_consume_token(-1);
              throw new ParseException();
            }
          }
          break;
        default:
          jj_la1[366] = jj_gen;
          ;
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ORebuildIndexStatement RebuildIndexStatement() throws ParseException {
 /*@bgen(jjtree) RebuildIndexStatement */
  ORebuildIndexStatement jjtn000 = new ORebuildIndexStatement(JJTREBUILDINDEXSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(REBUILD);
      jj_consume_token(INDEX);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 267:
        jjtn000.name = IndexName();
        break;
      case STAR:
        jj_consume_token(STAR);
                     jjtn000.all = true;
        break;
      default:
        jj_la1[367] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODropIndexStatement DropIndexStatement() throws ParseException {
 /*@bgen(jjtree) DropIndexStatement */
  ODropIndexStatement jjtn000 = new ODropIndexStatement(JJTDROPINDEXSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(DROP);
      jj_consume_token(INDEX);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
      case 267:
        jjtn000.name = IndexName();
        break;
      case STAR:
        jj_consume_token(STAR);
                     jjtn000.all = true;
        break;
      default:
        jj_la1[368] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
        jj_consume_token(IF);
        jj_consume_token(EXISTS);
                          jjtn000.ifExists = true;
        break;
      default:
        jj_la1[369] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCreateClusterStatement CreateClusterStatement() throws ParseException {
 /*@bgen(jjtree) CreateClusterStatement */
  OCreateClusterStatement jjtn000 = new OCreateClusterStatement(JJTCREATECLUSTERSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(CREATE);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case CLUSTER:
        jj_consume_token(CLUSTER);
        break;
      case BLOB:
        jj_consume_token(BLOB);
        jj_consume_token(CLUSTER);
                                 jjtn000.blob = true;
        break;
      default:
        jj_la1[370] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      jjtn000.name = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
        jj_consume_token(IF);
        jj_consume_token(NOT);
        jj_consume_token(EXISTS);
                                jjtn000.ifNotExists = true;
        break;
      default:
        jj_la1[371] = jj_gen;
        ;
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case ID:
        jj_consume_token(ID);
        jjtn000.id = Integer();
        break;
      default:
        jj_la1[372] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
      if (jjtc000) {
        jjtree.clearNodeScope(jjtn000);
        jjtc000 = false;
      } else {
        jjtree.popNode();
      }
      if (jjte000 instanceof RuntimeException) {
        {if (true) throw (RuntimeException)jjte000;}
      }
      if (jjte000 instanceof ParseException) {
        {if (true) throw (ParseException)jjte000;}
      }
      {if (true) throw (Error)jjte000;}
    } finally {
      if (jjtc000) {
        jjtree.closeNodeScope(jjtn000, true);
        jjtn000.jjtSetLastToken(getToken(0));
      }
    }
    throw new Error("Missing return statement in function");
  }

  final public OAlterClusterStatement AlterClusterStatement() throws ParseException {
 /*@bgen(jjtree) AlterClusterStatement */
  OAlterClusterStatement jjtn000 = new OAlterClusterStatement(JJTALTERCLUSTERSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(ALTER);
      jj_consume_token(CLUSTER);
      jjtn000.name = Identifier();
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case STAR:
        jj_consume_token(STAR);
                   jjtn000.starred = true;
        break;
      default:
        jj_la1[373] = jj_gen;
        ;
      }
      jjtn000.attributeName = Identifier();
      jjtn000.attributeValue = Expression();
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public ODropClusterStatement DropClusterStatement() throws ParseException {
 /*@bgen(jjtree) DropClusterStatement */
  ODropClusterStatement jjtn000 = new ODropClusterStatement(JJTDROPCLUSTERSTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(DROP);
      jj_consume_token(CLUSTER);
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case TO:
      case VALUE:
      case VALUES:
      case SET:
      case ADD:
      case PUT:
      case MERGE:
      case CONTENT:
      case REMOVE:
      case ORDER:
      case GROUP:
      case OFFSET:
      case RECORD:
      case CACHE:
      case CYCLE:
      case NOLIMIT:
      case NOCYCLE:
      case LUCENE:
      case NEAR:
      case WITHIN:
      case MINDEPTH:
      case CLASS:
      case SUPERCLASS:
      case CLASSES:
      case SUPERCLASSES:
      case VIEW:
      case UPDATABLE:
      case EXCEPTION:
      case PROFILE:
      case STORAGE:
      case ON:
      case OFF:
      case TRUNCATE:
      case FIND:
      case REFERENCES:
      case EXTENDS:
      case CLUSTERS:
      case ABSTRACT:
      case ALTER:
      case NAME:
      case SHORTNAME:
      case OVERSIZE:
      case STRICTMODE:
      case ADDCLUSTER:
      case REMOVECLUSTER:
      case CUSTOM:
      case CLUSTERSELECTION:
      case DESCRIPTION:
      case ENCRYPTION:
      case DROP:
      case PROPERTY:
      case FORCE:
      case METADATA:
      case INDEX:
      case COLLATE:
      case ENGINE:
      case REBUILD:
      case ID:
      case DATABASE:
      case OPTIMIZE:
      case LINK:
      case TYPE:
      case INVERSE:
      case EXPLAIN:
      case GRANT:
      case REVOKE:
      case READ:
      case EXECUTE:
      case ALL:
      case NONE:
      case FUNCTION:
      case PARAMETERS:
      case IDEMPOTENT:
      case LANGUAGE:
      case BEGIN:
      case COMMIT:
      case ROLLBACK:
      case IF:
      case ELSE:
      case CONTINUE:
      case FAIL:
      case ISOLATION:
      case SLEEP:
      case CONSOLE:
      case BLOB:
      case SHARED:
      case DEFAULT_:
      case SEQUENCE:
      case START:
      case OPTIONAL:
      case COUNT:
      case HA:
      case STATUS:
      case SERVER:
      case SYNC:
      case EXISTS:
      case MOVE:
      case DEPTH_ALIAS:
      case PATH_ALIAS:
      case IDENTIFIED:
      case ROLE:
      case USER:
      case RID:
      case DEFAULTCLUSTER:
      case IN:
      case KEY:
      case IDENTIFIER:
      case QUOTED_IDENTIFIER:
        jjtn000.name = Identifier();
        break;
      case INTEGER_LITERAL:
      case MINUS:
        jjtn000.id = Integer();
        break;
      default:
        jj_la1[374] = jj_gen;
        jj_consume_token(-1);
        throw new ParseException();
      }
      switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
      case IF:
        jj_consume_token(IF);
        jj_consume_token(EXISTS);
                          jjtn000.ifExists = true;
        break;
      default:
        jj_la1[375] = jj_gen;
        ;
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OAlterDatabaseStatement AlterDatabaseStatement() throws ParseException {
 /*@bgen(jjtree) AlterDatabaseStatement */
  OAlterDatabaseStatement jjtn000 = new OAlterDatabaseStatement(JJTALTERDATABASESTATEMENT);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(ALTER);
      jj_consume_token(DATABASE);
      if (jj_2_156(3)) {
        jj_consume_token(CUSTOM);
        jjtn000.customPropertyName = Identifier();
        jj_consume_token(EQ);
        jjtn000.customPropertyValue = Expression();
      } else {
        switch ((jj_ntk==-1)?jj_ntk():jj_ntk) {
        case TO:
        case VALUE:
        case VALUES:
        case SET:
        case ADD:
        case PUT:
        case MERGE:
        case CONTENT:
        case REMOVE:
        case ORDER:
        case GROUP:
        case OFFSET:
        case RECORD:
        case CACHE:
        case CYCLE:
        case NOLIMIT:
        case NOCYCLE:
        case LUCENE:
        case NEAR:
        case WITHIN:
        case MINDEPTH:
        case CLASS:
        case SUPERCLASS:
        case CLASSES:
        case SUPERCLASSES:
        case VIEW:
        case UPDATABLE:
        case EXCEPTION:
        case PROFILE:
        case STORAGE:
        case ON:
        case OFF:
        case TRUNCATE:
        case FIND:
        case REFERENCES:
        case EXTENDS:
        case CLUSTERS:
        case ABSTRACT:
        case ALTER:
        case NAME:
        case SHORTNAME:
        case OVERSIZE:
        case STRICTMODE:
        case ADDCLUSTER:
        case REMOVECLUSTER:
        case CUSTOM:
        case CLUSTERSELECTION:
        case DESCRIPTION:
        case ENCRYPTION:
        case DROP:
        case PROPERTY:
        case FORCE:
        case METADATA:
        case INDEX:
        case COLLATE:
        case ENGINE:
        case REBUILD:
        case ID:
        case DATABASE:
        case OPTIMIZE:
        case LINK:
        case TYPE:
        case INVERSE:
        case EXPLAIN:
        case GRANT:
        case REVOKE:
        case READ:
        case EXECUTE:
        case ALL:
        case NONE:
        case FUNCTION:
        case PARAMETERS:
        case IDEMPOTENT:
        case LANGUAGE:
        case BEGIN:
        case COMMIT:
        case ROLLBACK:
        case IF:
        case ELSE:
        case CONTINUE:
        case FAIL:
        case ISOLATION:
        case SLEEP:
        case CONSOLE:
        case BLOB:
        case SHARED:
        case DEFAULT_:
        case SEQUENCE:
        case START:
        case OPTIONAL:
        case COUNT:
        case HA:
        case STATUS:
        case SERVER:
        case SYNC:
        case EXISTS:
        case MOVE:
        case DEPTH_ALIAS:
        case PATH_ALIAS:
        case IDENTIFIED:
        case ROLE:
        case USER:
        case RID:
        case DEFAULTCLUSTER:
        case IN:
        case KEY:
        case IDENTIFIER:
        case QUOTED_IDENTIFIER:
          jjtn000.settingName = Identifier();
          jjtn000.settingValue = Expression();
          break;
        default:
          jj_la1[376] = jj_gen;
          jj_consume_token(-1);
          throw new ParseException();
        }
      }
          jjtree.closeNodeScope(jjtn000, true);
          jjtc000 = false;
          jjtn000.jjtSetLastToken(getToken(0));
          {if (true) return jjtn000;}
    } catch (Throwable jjte000) {
          if (jjtc000) {
            jjtree.clearNodeScope(jjtn000);
            jjtc000 = false;
          } else {
            jjtree.popNode();
          }
          if (jjte000 instanceof RuntimeException) {
            {if (true) throw (RuntimeException)jjte000;}
          }
          if (jjte000 instanceof ParseException) {
            {if (true) throw (ParseException)jjte000;}
          }
          {if (true) throw (Error)jjte000;}
    } finally {
          if (jjtc000) {
            jjtree.closeNodeScope(jjtn000, true);
            jjtn000.jjtSetLastToken(getToken(0));
          }
    }
    throw new Error("Missing return statement in function");
  }

  final public OCommandLineOption CommandLineOption() throws ParseException {
 /*@bgen(jjtree) CommandLineOption */
  OCommandLineOption jjtn000 = new OCommandLineOption(JJTCOMMANDLINEOPTION);
  boolean jjtc000 = true;
  jjtree.openNodeScope(jjtn000);
  jjtn000.jjtSetFirstToken(getToken(1));
    try {
      jj_consume_token(MINUS);
      jjtn000.name = Identifier();
      jjtree.closeNodeScope(jjtn000, tru