Files
Druid/src/main/java/com/alibaba/druid/sql/parser/SQLParser.java
T

617 lines
19 KiB
Java

/*
* Copyright 1999-2017 Alibaba Group Holding Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.alibaba.druid.sql.parser;
import com.alibaba.druid.DbType;
import com.alibaba.druid.sql.ast.statement.SQLCreateTableStatement;
import com.alibaba.druid.util.FnvHash;
import com.alibaba.druid.util.StringUtils;
import java.util.TimeZone;
public class SQLParser {
protected final Lexer lexer;
protected DbType dbType;
public SQLParser(String sql, DbType dbType, SQLParserFeature... features){
this(new Lexer(sql, null, dbType), dbType);
for (SQLParserFeature feature : features) {
config(feature, true);
}
this.lexer.nextToken();
}
public SQLParser(String sql){
this(sql, null);
}
public SQLParser(Lexer lexer){
this(lexer, null);
if (dbType == null) {
dbType = lexer.dbType;
}
}
public SQLParser(Lexer lexer, DbType dbType){
this.lexer = lexer;
this.dbType = dbType;
}
public final Lexer getLexer() {
return lexer;
}
public DbType getDbType() {
return dbType;
}
protected boolean identifierEquals(String text) {
return lexer.identifierEquals(text);
}
protected void acceptIdentifier(String text) {
if (lexer.identifierEquals(text)) {
lexer.nextToken();
} else {
setErrorEndPos(lexer.pos());
throw new ParserException("syntax error, expect " + text + ", actual " + lexer.token + ", " + lexer.info());
}
}
protected String tableAlias() {
return tableAlias(false);
}
protected String tableAlias(boolean must) {
final Token token = lexer.token;
if (token == Token.CONNECT
|| token == Token.START
|| token == Token.SELECT
|| token == Token.FROM
|| token == Token.WHERE) {
if (must) {
throw new ParserException("illegal alias. " + lexer.info());
}
return null;
}
if (token == Token.IDENTIFIER) {
String ident = lexer.stringVal;
long hash = lexer.hash_lower;
if (isEnabled(SQLParserFeature.IgnoreNameQuotes) && ident.length() > 1) {
ident = StringUtils.removeNameQuotes(ident);
}
if (hash == FnvHash.Constants.START
|| hash == FnvHash.Constants.CONNECT
|| hash == FnvHash.Constants.NATURAL
|| hash == FnvHash.Constants.CROSS
|| hash == FnvHash.Constants.OFFSET
|| hash == FnvHash.Constants.LIMIT) {
if (must) {
throw new ParserException("illegal alias. " + lexer.info());
}
Lexer.SavePoint mark = lexer.mark();
lexer.nextToken();
switch (lexer.token) {
case EOF:
case COMMA:
case WHERE:
case INNER:
case ON:
return ident;
default:
lexer.reset(mark);
break;
}
return null;
}
if (!must) {
if (hash == FnvHash.Constants.MODEL) {
Lexer.SavePoint mark = lexer.mark();
lexer.nextToken();
if (lexer.token == Token.PARTITION
|| lexer.token == Token.UNION
|| lexer.identifierEquals(FnvHash.Constants.DIMENSION)
|| lexer.identifierEquals(FnvHash.Constants.IGNORE)
|| lexer.identifierEquals(FnvHash.Constants.KEEP)) {
lexer.reset(mark);
return null;
}
return ident;
} else if (hash == FnvHash.Constants.WINDOW) {
Lexer.SavePoint mark = lexer.mark();
lexer.nextToken();
if (lexer.token == Token.IDENTIFIER) {
lexer.reset(mark);
return null;
}
return ident;
} else if (hash == FnvHash.Constants.DISTRIBUTE
|| hash == FnvHash.Constants.SORT
|| hash == FnvHash.Constants.CLUSTER) {
Lexer.SavePoint mark = lexer.mark();
lexer.nextToken();
if (lexer.token == Token.BY) {
lexer.reset(mark);
return null;
}
return ident;
}
}
}
if (!must) {
switch (token) {
case LEFT:
case RIGHT:
case INNER:
case FULL: {
Lexer.SavePoint mark = lexer.mark();
String strVal = lexer.stringVal();
lexer.nextToken();
if (lexer.token == Token.OUTER
|| lexer.token == Token.JOIN
|| lexer.identifierEquals(FnvHash.Constants.ANTI)
|| lexer.identifierEquals(FnvHash.Constants.SEMI)) {
lexer.reset(mark);
break;
} else {
return strVal;
}
}
case IN: {
Lexer.SavePoint mark = lexer.mark();
String strVal = lexer.stringVal();
lexer.nextToken();
switch (lexer.token) {
case WHERE:
case RPAREN: {
return strVal;
}
default:
lexer.reset(mark);
break;
}
break;
}
case FOR:
case GRANT:
if (dbType == DbType.odps){
String strVal = lexer.stringVal();
lexer.nextToken();
return strVal;
}
break;
case TABLE:
if (dbType == DbType.odps){
Lexer.SavePoint mark = lexer.mark();
String strVal = lexer.stringVal();
lexer.nextToken();
switch (lexer.token) {
case FROM:
case GROUP:
return strVal;
default:
lexer.reset(mark);
break;
}
}
break;
case SHOW:
case REPEAT:
case USE:
case OUT: {
String strVal = lexer.stringVal();
lexer.nextToken();
return strVal;
}
default:
break;
}
}
return this.as();
}
protected String as() {
String alias = null;
final Token token = lexer.token;
if (token == Token.COMMA) {
return null;
}
if (token == Token.AS) {
lexer.nextTokenAlias();
if (lexer.token == Token.LPAREN) {
return null;
}
// for oracle
if (dbType == DbType.oracle && (lexer.token == Token.COMMA || lexer.token == Token.FROM)) {
return null;
}
alias = lexer.stringVal();
lexer.nextToken();
if (alias != null) {
while (lexer.token == Token.DOT) {
lexer.nextToken();
alias += ('.' + lexer.token.name());
lexer.nextToken();
}
return alias;
}
if (lexer.token == Token.LPAREN) {
return null;
}
throw new ParserException("Error : " + lexer.info());
}
if (lexer.token == Token.LITERAL_ALIAS) {
alias = lexer.stringVal();
lexer.nextToken();
} else if (lexer.token == Token.IDENTIFIER) {
alias = lexer.stringVal();
lexer.nextToken();
} else if (lexer.token == Token.LITERAL_CHARS) {
alias = "'" + lexer.stringVal() + "'";
lexer.nextToken();
} else {
switch (lexer.token) {
case CASE:
case USER:
case LOB:
case END:
case DEFERRED:
case OUTER:
case DO:
case STORE:
case MOD:
case ANY:
case BEGIN:
case CAST:
case COMPUTE:
case ESCAPE:
case FULL:
case MERGE:
case OPEN:
case SOME:
case TRUNCATE:
case UNTIL:
case VIEW:
case KILL:
case COMMENT:
alias = lexer.stringVal();
lexer.nextToken();
break;
case INTERSECT:
case EXCEPT:
case DESC:
case MINUS: {
alias = lexer.stringVal();
Lexer.SavePoint mark = lexer.mark();
lexer.nextToken();
if (lexer.token() != Token.COMMA
&& lexer.token() != Token.RPAREN) {
alias = null;
lexer.reset(mark);
}
break;
}
case CHECK:
case INDEX:
case ALL:
case INNER:
case CLOSE:
case VALUES:
if (dbType == DbType.odps) {
alias = lexer.stringVal();
lexer.nextToken();
break;
}
break;
case GROUP:
case ORDER:
if (dbType == DbType.odps) {
Lexer.SavePoint mark = lexer.mark();
alias = lexer.stringVal();
lexer.nextToken();
if (lexer.token == Token.BY) {
lexer.reset(mark);
alias = null;
}
break;
}
break;
default:
break;
}
}
switch (lexer.token) {
case KEY:
case INTERVAL:
case CONSTRAINT:
alias = lexer.token.name();
lexer.nextToken();
return alias;
default:
break;
}
if (isEnabled(SQLParserFeature.IgnoreNameQuotes) && alias != null && alias.length() > 1) {
alias = StringUtils.removeNameQuotes(alias);
}
return alias;
}
protected String alias() {
String alias = null;
if (lexer.token == Token.LITERAL_ALIAS) {
alias = lexer.stringVal();
lexer.nextToken();
} else if (lexer.token == Token.IDENTIFIER) {
alias = lexer.stringVal();
lexer.nextToken();
} else if (lexer.token == Token.LITERAL_CHARS) {
alias = "'" + lexer.stringVal() + "'";
lexer.nextToken();
} else {
switch (lexer.token) {
case KEY:
case INDEX:
case CASE:
// case MODEL:
case PCTFREE:
case INITRANS:
case MAXTRANS:
case SEGMENT:
case CREATION:
case IMMEDIATE:
case DEFERRED:
case STORAGE:
case NEXT:
case MINEXTENTS:
case MAXEXTENTS:
case MAXSIZE:
case PCTINCREASE:
case FLASH_CACHE:
case CELL_FLASH_CACHE:
case NONE:
case LOB:
case STORE:
case ROW:
case CHUNK:
case CACHE:
case NOCACHE:
case LOGGING:
case NOCOMPRESS:
case KEEP_DUPLICATES:
case EXCEPTIONS:
case PURGE:
case INITIALLY:
case END:
case COMMENT:
case ENABLE:
case DISABLE:
case SEQUENCE:
case USER:
case ANALYZE:
case OPTIMIZE:
case GRANT:
case REVOKE:
case FULL:
case TO:
case NEW:
case INTERVAL:
case LOCK:
case LIMIT:
case IDENTIFIED:
case PASSWORD:
case BINARY:
case WINDOW:
case OFFSET:
case SHARE:
case START:
case CONNECT:
case MATCHED:
case ERRORS:
case REJECT:
case UNLIMITED:
case BEGIN:
case EXCLUSIVE:
case MODE:
case ADVISE:
case TYPE:
case CLOSE:
case OPEN:
case ANY:
case CAST:
case COMPUTE:
case ESCAPE:
case INTERSECT:
case MERGE:
case MINUS:
case SOME:
case TRUNCATE:
case UNTIL:
case VIEW:
case FUNCTION:
case DESC:
case KILL:
case SHOW:
case NULL:
case ORDER:
case GROUP:
case ALL:
case CONSTRAINT:
case INNER:
case LEFT:
case RIGHT:
case VALUES:
case SCHEMA:
case PARTITION:
case UPDATE:
case DO:
case REPEAT:
case DEFAULT:
case LIKE:
case IS:
case UNIQUE:
case CHECK:
case INOUT:
case DECLARE:
case TABLE:
case TRIGGER:
case IN:
case OUT:
case BY:
alias = lexer.stringVal();
lexer.nextToken();
return alias;
case QUES:
alias = "?";
lexer.nextToken();
default:
break;
}
}
return alias;
}
protected void printError(Token token) {
String arround;
if (lexer.mark >= 0 && (lexer.text.length() > lexer.mark + 30)) {
int begin, end;
if (lexer.mark - 5 > 0) {
begin = lexer.mark - 5;
end = lexer.mark + 30;
} else {
begin = lexer.mark;
end = lexer.mark + 30;
}
if (begin < 10) {
begin = 0;
} else {
for (int i = 1; i < 10 && i < begin; ++i) {
char ch = lexer.text.charAt(begin - i);
if (ch == ' ' || ch == '\n') {
begin = begin - i + 1;
}
}
}
arround = lexer.text.substring(begin, end);
} else if (lexer.mark >= 0) {
if (lexer.mark - 5 > 0) {
arround = lexer.text.substring(lexer.mark - 5);
} else {
arround = lexer.text.substring(lexer.mark);
}
} else {
arround = lexer.text;
}
// throw new
// ParserException("syntax error, error arround:'"+arround+"',expect "
// + token + ", actual " + lexer.token + " "
// + lexer.stringVal() + ", pos " + this.lexer.pos());
StringBuilder buf = new StringBuilder()
.append("syntax error, error in :'")
.append(arround);
if (token != lexer.token) {
buf.append("', expect ")
.append(token.name)
.append(", actual ")
.append(lexer.token.name);
}
buf.append(", ")
.append(
lexer.info());
throw new ParserException(buf.toString());
}
public void accept(Token token) {
if (lexer.token == token) {
lexer.nextToken();
} else {
setErrorEndPos(lexer.pos());
printError(token);
}
}
public int acceptInteger() {
if (lexer.token == Token.LITERAL_INT) {
int intVal = ((Integer) lexer.integerValue()).intValue();
lexer.nextToken();
return intVal;
} else {
throw new ParserException("syntax error, expect int, actual " + lexer.token + " "
+ lexer.info());
}
}
public void match(Token token) {
if (lexer.token != token) {
throw new ParserException("syntax error, expect " + token + ", actual " + lexer.token + " "
+ lexer.info());
}
}
private int errorEndPos = -1;
protected void setErrorEndPos(int errPos) {
if (errPos > errorEndPos) {
errorEndPos = errPos;
}
}
public void config(SQLParserFeature feature, boolean state) {
this.lexer.config(feature, state);
}
public TimeZone getTimeZone() {
return lexer.getTimeZone();
}
public void setTimeZone(TimeZone timeZone) {
this.lexer.setTimeZone(timeZone);
}
public final boolean isEnabled(SQLParserFeature feature) {
return lexer.isEnabled(feature);
}
protected SQLCreateTableStatement newCreateStatement() {
return new SQLCreateTableStatement(dbType);
}
}