Examples of com.alibaba.druid.sql.parser.ParserException

com.alibaba.druid.sql.parser.ParserException

    stmt.setTableName(tableName);
    if (identifierEquals(CHARACTER)) {
      lexer.nextToken();
      accept(Token.SET);
      if (lexer.token() != Token.LITERAL_CHARS) {
        throw new ParserException("syntax error, illegal charset");
      }
      String charset = lexer.stringVal();
      lexer.nextToken();
      stmt.setCharset(charset);
    }
    if (identifierEquals("FIELDS") || identifierEquals("COLUMNS")) {
      throw new ParserException("TODO");
    }
    if (identifierEquals("LINES")) {
      throw new ParserException("TODO");
    }
    if (identifierEquals(IGNORE)) {
      throw new ParserException("TODO");
    }
    if (lexer.token() == Token.SET) {
      throw new ParserException("TODO");
    }
    return stmt;
  }

View Full Code Here

                .parsePrimaryKey();
            SQLAlterTableAddPrimaryKey item = new SQLAlterTableAddPrimaryKey();
            item.setPrimaryKey(primaryKey);
            stmt.getItems().add(item);
          } else if (lexer.token() == Token.KEY) {
            throw new ParserException("TODO " + lexer.token() + " "
                + lexer.stringVal());
          } else if (lexer.token() == Token.CONSTRAINT) {
            throw new ParserException("TODO " + lexer.token() + " "
                + lexer.stringVal());
          } else if (identifierEquals(FULLTEXT)) {
            throw new ParserException("TODO " + lexer.token() + " "
                + lexer.stringVal());
          } else if (identifierEquals(SPATIAL)) {
            throw new ParserException("TODO " + lexer.token() + " "
                + lexer.stringVal());
          } else {
            WaspSqlAlterTableAddColumn item = new WaspSqlAlterTableAddColumn();
            SQLColumnDefinition columnDef = this.exprParser.parseColumn();
            item.getColumns().add(columnDef);
            if (identifierEquals("AFTER")) {
              lexer.nextToken();
              item.setAfterColumn(this.exprParser.name());
            }
            stmt.getItems().add(item);
          }
        } else if (identifierEquals("ALTER")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("CHANGE")) {
          lexer.nextToken();
          if (identifierEquals("COLUMN")) {
            lexer.nextToken();
          }
          WaspSqlAlterTableChangeColumn item = new WaspSqlAlterTableChangeColumn();
          item.setColumnName(this.exprParser.name());
          item.setNewColumnDefinition(this.exprParser.parseColumn());
          if (identifierEquals("AFTER")) {
            lexer.nextToken();
            item.setAfterColumn(this.exprParser.name());
          } else if (identifierEquals("FIRST")) {
            lexer.nextToken();
            if (lexer.token() == Token.IDENTIFIER) {
              item.setFirstColumn(this.exprParser.name());
            } else {
              item.setFirst(true);
            }
          }
          stmt.getItems().add(item);
        } else if (identifierEquals("MODIFY")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (lexer.token() == Token.DROP) {
          lexer.nextToken();
          if (lexer.token() == Token.INDEX) {
            lexer.nextToken();
            SQLName indexName = this.exprParser.name();
            SQLAlterTableDropIndex item = new SQLAlterTableDropIndex();
            item.setIndexName(indexName);
            stmt.getItems().add(item);
          } else {
            if (identifierEquals("COLUMN")) {
              lexer.nextToken();
            }
            SQLAlterTableDropColumnItem item = new SQLAlterTableDropColumnItem();
            item.setColumnName(this.exprParser.name());
            stmt.getItems().add(item);
          }
        } else if (identifierEquals("DISABLE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("ENABLE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("RENAME")) {
          lexer.nextToken();
          WaspSqlRenameTableStatement renameStmt = new WaspSqlRenameTableStatement();
          WaspSqlRenameTableStatement.Item item = new WaspSqlRenameTableStatement.Item();
          item.setName(stmt.getTableSource().getExpr());
          item.setTo(this.exprParser.name());
          renameStmt.getItems().add(item);


          return renameStmt;
        } else if (lexer.token() == Token.ORDER) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("CONVERT")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (lexer.token() == Token.DEFAULT) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("DISCARD")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("IMPORT")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("FORCE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("TRUNCATE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("COALESCE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());


        } else if (identifierEquals("REORGANIZE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("EXCHANGE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("ANALYZE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("CHECK")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("OPTIMIZE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("REBUILD")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("REPAIR")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals("REMOVE")) {
          throw new ParserException("TODO " + lexer.token() + " "
              + lexer.stringVal());
        } else if (identifierEquals(CHARACTER)) {
          lexer.nextToken();
          accept(Token.SET);
          accept(Token.EQ);
          WaspSqlAlterTableCharacter item = new WaspSqlAlterTableCharacter();
          item.setCharacterSet(this.exprParser.primary());
          if (lexer.token() == Token.COMMA) {
            lexer.nextToken();
            acceptIdentifier(COLLATE2);
            accept(Token.EQ);
            item.setCollate(this.exprParser.primary());
          }
          stmt.getItems().add(item);
        } else {
          break;
        }


        if (lexer.token() == Token.COMMA) {
          lexer.nextToken();
          continue;
        } else {
          break;
        }
      }


      return stmt;
    }
    throw new ParserException("TODO " + lexer.token() + " " + lexer.stringVal());
  }

View Full Code Here

            if (identifierEquals("READ")) {
                lexer.nextToken();


                if (identifierEquals("ONLY")) lexer.nextToken();
                else {
                    throw new ParserException("syntax error");
                }


                select.setRestriction(new OracleSelectRestriction.ReadOnly());
            } else if (lexer.token() == (Token.CHECK)) {
                lexer.nextToken();


                if (identifierEquals("OPTION")) lexer.nextToken();
                else {
                    throw new ParserException("syntax error");
                }


                OracleSelectRestriction.CheckOption checkOption = new OracleSelectRestriction.CheckOption();


                if (lexer.token() == Token.CONSTRAINT) {
                    lexer.nextToken();
                    throw new ParserException("TODO");
                }


                select.setRestriction(checkOption);
            } else {
                throw new ParserException("syntax error");
            }
        }


        return select;
    }

View Full Code Here

            modelColumnClause.setQueryPartitionClause(queryPartitionClause);
        }
    }


    private void parseModelColumnClause(ReferenceModelClause referenceModelClause) {
        throw new ParserException();
    }

View Full Code Here

            if (lexer.token() == Token.SELECT) {
                tableSource = new OracleSelectSubqueryTableSource(select());
            } else if (lexer.token() == (Token.LPAREN)) {
                tableSource = new OracleSelectSubqueryTableSource(select());
            } else {
                throw new ParserException("TODO :" + lexer.token());
            }
            accept(Token.RPAREN);


            parsePivot((OracleSelectTableSource) tableSource);


            return parseTableSourceRest(tableSource);
        }


        if (lexer.token() == (Token.SELECT)) {
            throw new ParserException("TODO");
        }


        OracleSelectTableReference tableReference = new OracleSelectTableReference();


        if (identifierEquals("ONLY")) {

View Full Code Here

            }


            accept(Token.IN);
            accept(Token.LPAREN);
            if (lexer.token() == (Token.LPAREN)) {
                throw new ParserException("TODO");
            }


            if (lexer.token() == (Token.SELECT)) {
                throw new ParserException("TODO");
            }


            for (;;) {
                item = new OracleSelectPivot.Item();
                item.setExpr(this.createExprParser().expr());
                item.setAlias(as());
                pivot.getPivotIn().add(item);


                if (lexer.token() != Token.COMMA) {
                    break;
                }


                lexer.nextToken();
            }


            accept(Token.RPAREN);


            accept(Token.RPAREN);


            tableSource.setPivot(pivot);
        } else if (identifierEquals("UNPIVOT")) {
            lexer.nextToken();


            OracleSelectUnPivot unPivot = new OracleSelectUnPivot();
            if (identifierEquals("INCLUDE")) {
                lexer.nextToken();
                acceptIdentifier("NULLS");
                unPivot.setNullsIncludeType(OracleSelectUnPivot.NullsIncludeType.INCLUDE_NULLS);
            } else if (identifierEquals("EXCLUDE")) {
                lexer.nextToken();
                acceptIdentifier("NULLS");
                unPivot.setNullsIncludeType(OracleSelectUnPivot.NullsIncludeType.EXCLUDE_NULLS);
            }


            accept(Token.LPAREN);


            if (lexer.token() == (Token.LPAREN)) {
                lexer.nextToken();
                this.createExprParser().exprList(unPivot.getItems());
                accept(Token.RPAREN);
            } else {
                unPivot.getItems().add(this.createExprParser().expr());
            }


            accept(Token.FOR);


            if (lexer.token() == (Token.LPAREN)) {
                lexer.nextToken();
                while (true) {
                    unPivot.getPivotFor().add(new SQLIdentifierExpr(lexer.stringVal()));
                    lexer.nextToken();


                    if (!(lexer.token() == (Token.COMMA))) break;
                    lexer.nextToken();
                }


                accept(Token.RPAREN);
            } else {
                unPivot.getPivotFor().add(new SQLIdentifierExpr(lexer.stringVal()));
                lexer.nextToken();
            }


            accept(Token.IN);
            accept(Token.LPAREN);
            if (lexer.token() == (Token.LPAREN)) {
                throw new ParserException("TODO");
            }


            if (lexer.token() == (Token.SELECT)) {
                throw new ParserException("TODO");
            }


            for (;;) {
                item = new OracleSelectPivot.Item();
                item.setExpr(this.createExprParser().expr());

View Full Code Here

        } else if (lexer.token() == Token.IDENTIFIER) {
            if (expr instanceof SQLHexExpr) {
                if ("USING".equalsIgnoreCase(lexer.stringVal())) {
                    lexer.nextToken();
                    if (lexer.token() != Token.IDENTIFIER) {
                        throw new ParserException("syntax error, illegal hex");
                    }
                    String charSet = lexer.stringVal();
                    lexer.nextToken();
                    expr.getAttributes().put("USING", charSet);


                    return primaryRest(expr);
                }
            } else if ("COLLATE".equalsIgnoreCase(lexer.stringVal())) {
                lexer.nextToken();


                if (lexer.token() != Token.IDENTIFIER) {
                    throw new ParserException("syntax error");
                }


                String collate = lexer.stringVal();
                lexer.nextToken();


                SQLBinaryOpExpr binaryExpr = new SQLBinaryOpExpr(expr, SQLBinaryOperator.COLLATE,
                                                                 new SQLIdentifierExpr(collate));


                expr = binaryExpr;


                return primaryRest(expr);
            } else if (expr instanceof SQLVariantRefExpr) {
                if ("COLLATE".equalsIgnoreCase(lexer.stringVal())) {
                    lexer.nextToken();


                    if (lexer.token() != Token.IDENTIFIER) {
                        throw new ParserException("syntax error");
                    }


                    String collate = lexer.stringVal();
                    lexer.nextToken();


                    expr.putAttribute("COLLATE", collate);


                    return primaryRest(expr);
                }
            } else if (expr instanceof SQLIntegerExpr) {
                SQLIntegerExpr intExpr = (SQLIntegerExpr) expr;
                String binaryString = lexer.stringVal();
                if (intExpr.getNumber().intValue() == 0 && binaryString.startsWith("b")) {
                    lexer.nextToken();
                    expr = new MySqlBinaryExpr(binaryString.substring(1));


                    return primaryRest(expr);
                }
            }
        }


        if (lexer.token() == Token.LPAREN && expr instanceof SQLIdentifierExpr) {
            SQLIdentifierExpr identExpr = (SQLIdentifierExpr) expr;
            String ident = identExpr.getName();


            if ("EXTRACT".equalsIgnoreCase(ident)) {
                lexer.nextToken();


                if (lexer.token() != Token.IDENTIFIER) {
                    throw new ParserException("syntax error");
                }


                String unitVal = lexer.stringVal();
                MySqlIntervalUnit unit = MySqlIntervalUnit.valueOf(unitVal);
                lexer.nextToken();


                accept(Token.FROM);


                SQLExpr value = expr();


                MySqlExtractExpr extract = new MySqlExtractExpr();
                extract.setValue(value);
                extract.setUnit(unit);
                accept(Token.RPAREN);


                expr = extract;


                return primaryRest(expr);
            } else if ("SUBSTRING".equalsIgnoreCase(ident)) {
                lexer.nextToken();
                SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(ident);
                for (;;) {
                    SQLExpr param = expr();
                    methodInvokeExpr.getParameters().add(param);


                    if (lexer.token() == Token.COMMA) {
                        lexer.nextToken();
                        continue;
                    } else if (lexer.token() == Token.FROM) {
                        lexer.nextToken();
                        SQLExpr from = expr();
                        methodInvokeExpr.putAttribute("FROM", from);


                        if (lexer.token() == Token.FOR) {
                            lexer.nextToken();
                            SQLExpr _for = expr();
                            methodInvokeExpr.putAttribute("FOR", _for);
                        }
                        break;
                    } else if (lexer.token() == Token.RPAREN) {
                        break;
                    } else {
                        throw new ParserException("syntax error");
                    }
                }


                accept(Token.RPAREN);
                expr = methodInvokeExpr;


                return primaryRest(expr);
            } else if ("TRIM".equalsIgnoreCase(ident)) {
                lexer.nextToken();
                SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(ident);


                if (lexer.token() == Token.IDENTIFIER) {
                    String flagVal = lexer.stringVal();
                    if ("LEADING".equalsIgnoreCase(flagVal)) {
                        lexer.nextToken();
                        methodInvokeExpr.getAttributes().put("TRIM_TYPE", "LEADING");
                    } else if ("BOTH".equalsIgnoreCase(flagVal)) {
                        lexer.nextToken();
                        methodInvokeExpr.getAttributes().put("TRIM_TYPE", "BOTH");
                    } else if ("TRAILING".equalsIgnoreCase(flagVal)) {
                        lexer.nextToken();
                        methodInvokeExpr.putAttribute("TRIM_TYPE", "TRAILING");
                    }
                }


                SQLExpr param = expr();
                methodInvokeExpr.getParameters().add(param);


                if (lexer.token() == Token.FROM) {
                    lexer.nextToken();
                    SQLExpr from = expr();
                    methodInvokeExpr.putAttribute("FROM", from);
                }


                accept(Token.RPAREN);
                expr = methodInvokeExpr;


                return primaryRest(expr);
            } else if ("MATCH".equalsIgnoreCase(ident)) {
                lexer.nextToken();
                MySqlMatchAgainstExpr matchAgainstExpr = new MySqlMatchAgainstExpr();


                if (lexer.token() == Token.RPAREN) {
                    lexer.nextToken();
                } else {
                    exprList(matchAgainstExpr.getColumns());
                    accept(Token.RPAREN);
                }


                acceptIdentifier("AGAINST");


                accept(Token.LPAREN);
                SQLExpr against = primary();
                matchAgainstExpr.setAgainst(against);


                if (lexer.token() == Token.IN) {
                    lexer.nextToken();
                    if (identifierEquals("NATURAL")) {
                        lexer.nextToken();
                        acceptIdentifier("LANGUAGE");
                        acceptIdentifier("MODE");
                        if (identifierEquals("WITH")) {
                            lexer.nextToken();
                            acceptIdentifier("QUERY");
                            acceptIdentifier("EXPANSION");
                            matchAgainstExpr.setSearchModifier(SearchModifier.IN_NATURAL_LANGUAGE_MODE_WITH_QUERY_EXPANSION);
                        } else {
                            matchAgainstExpr.setSearchModifier(SearchModifier.IN_NATURAL_LANGUAGE_MODE);
                        }
                    } else {
                        throw new ParserException("TODO");
                    }
                } else if (identifierEquals("WITH")) {
                    throw new ParserException("TODO");
                }


                accept(Token.RPAREN);


                expr = matchAgainstExpr;


                return primaryRest(expr);
            } else if ("CONVERT".equalsIgnoreCase(ident)) {
                lexer.nextToken();
                SQLMethodInvokeExpr methodInvokeExpr = new SQLMethodInvokeExpr(ident);


                if (lexer.token() != Token.RPAREN) {
                    exprList(methodInvokeExpr.getParameters());
                }


                if (identifierEquals("USING")) {
                    lexer.nextToken();
                    if (lexer.token() != Token.IDENTIFIER) {
                        throw new ParserException("syntax error");
                    }
                    String charset = lexer.stringVal();
                    lexer.nextToken();
                    methodInvokeExpr.putAttribute("USING", charset);
                }

View Full Code Here

            return primaryRest(methodInvokeExpr);
        } else {
            SQLExpr value = expr();


            if (lexer.token() != Token.IDENTIFIER) {
                throw new ParserException("Syntax error");
            }


            String unit = lexer.stringVal();
            lexer.nextToken();

View Full Code Here

            }
            return parseColumnRest(column);
        }
        
        if (identifierEquals("PARTITION")) {
            throw new ParserException("syntax error " + lexer.token() + " " + lexer.stringVal());
        }
        super.parseColumnRest(column);


        return column;
    }

View Full Code Here

            if (lexer.token() == Token.FIRST) {
                fetch.setOption(PGSelectQueryBlock.FetchClause.Option.FIRST);
            } else if (lexer.token() == Token.NEXT) {
                fetch.setOption(PGSelectQueryBlock.FetchClause.Option.NEXT);
            } else {
                throw new ParserException("expect 'FIRST' or 'NEXT'");
            }


            SQLExpr count = expr();
            fetch.setCount(count);


            if (lexer.token() == Token.ROW || lexer.token() == Token.ROWS) {
                lexer.nextToken();
            } else {
                throw new ParserException("expect 'ROW' or 'ROWS'");
            }


            if (lexer.token() == Token.ONLY) {
                lexer.nextToken();
            } else {
                throw new ParserException("expect 'ONLY'");
            }


            queryBlock.setFetch(fetch);
        }


        if (lexer.token() == Token.FOR) {
            lexer.nextToken();


            PGSelectQueryBlock.ForClause forClause = new PGSelectQueryBlock.ForClause();


            if (lexer.token() == Token.UPDATE) {
                forClause.setOption(PGSelectQueryBlock.ForClause.Option.UPDATE);
            } else if (lexer.token() == Token.SHARE) {
                forClause.setOption(PGSelectQueryBlock.ForClause.Option.SHARE);
            } else {
                throw new ParserException("expect 'FIRST' or 'NEXT'");
            }


            accept(Token.OF);


            for (;;) {

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of com.alibaba.druid.sql.parser.ParserException

com.alibaba.druid.sql.dialect.db2.parser.DB2SelectParser

com.alibaba.druid.sql.dialect.hive.parser.HiveStatementParser

com.alibaba.druid.sql.dialect.mysql.ast.statement.MySqlCreateTableParser

com.alibaba.druid.sql.dialect.mysql.parser.MySqlCreateTableParser

com.alibaba.druid.sql.dialect.mysql.parser.MySqlDDLParser

com.alibaba.druid.sql.dialect.mysql.parser.MySqlExprParser

com.alibaba.druid.sql.dialect.mysql.parser.MySqlLexer

com.alibaba.druid.sql.dialect.mysql.parser.MySqlSelectParser

com.alibaba.druid.sql.dialect.mysql.parser.MySqlStatementParser

com.alibaba.druid.sql.dialect.odps.parser.OdpsCreateTableParser

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.