tool
/
starrocks
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[Refactor] Add mechanism to normalize names during parsing (#63309)

This commit is contained in:
Harbor Liu 2025-09-22 10:15:25 +08:00 committed by GitHub
parent df70c18210
commit 19bc2cc92b
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
15 changed files with 160 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
fe/fe-core/src/main/java/com/starrocks/sql/analyzer/BasicDbStmtAnalyzer.java
View File

@ -15,6 +15,7 @@
package com.starrocks.sql.analyzer;
import com.google.common.base.Strings;
import com.starrocks.common.util.Util;
import com.starrocks.qe.ConnectContext;
import com.starrocks.sql.ast.AstVisitorExtendInterface;
import com.starrocks.sql.ast.RecoverDbStmt;
@ -41,7 +42,8 @@ public class BasicDbStmtAnalyzer {
@Override
public Void visitUseDbStatement(UseDbStmt statement, ConnectContext context) {
statement.setCatalogName(getCatalogNameIfNotSet(statement.getCatalogName(), context));
String catalogName = Util.normalizeName(getCatalogNameIfNotSet(statement.getCatalogName(), context));
statement.setCatalogName(catalogName);
return null;
}

4
fe/fe-core/src/main/java/com/starrocks/sql/analyzer/CreateDbAnalyzer.java
View File

@ -18,6 +18,7 @@ import com.google.common.base.Strings;
import com.starrocks.common.ErrorCode;
import com.starrocks.common.ErrorReport;
import com.starrocks.common.util.PropertyAnalyzer;
import com.starrocks.common.util.Util;
import com.starrocks.connector.ConnectorType;
import com.starrocks.qe.ConnectContext;
import com.starrocks.server.CatalogMgr;
@ -34,7 +35,8 @@ public class CreateDbAnalyzer {
String catalogName = statement.getCatalogName();
if (Strings.isNullOrEmpty(catalogName)) {
catalogName = context.getCurrentCatalog();
statement.setCatalogName(catalogName);
String normalizedCatalogName = Util.normalizeName(catalogName);
statement.setCatalogName(normalizedCatalogName);
}
MetaUtils.checkCatalogExistAndReport(catalogName);

5
fe/fe-core/src/main/java/com/starrocks/sql/analyzer/DropStmtAnalyzer.java
View File

@ -30,6 +30,7 @@ import com.starrocks.catalog.system.information.InfoSchemaDb;
import com.starrocks.catalog.system.sys.SysDb;
import com.starrocks.common.ErrorCode;
import com.starrocks.common.ErrorReport;
import com.starrocks.common.util.Util;
import com.starrocks.qe.ConnectContext;
import com.starrocks.server.CatalogMgr;
import com.starrocks.server.GlobalStateMgr;
@ -176,7 +177,9 @@ public class DropStmtAnalyzer {
if (Strings.isNullOrEmpty(context.getCurrentCatalog())) {
throw new SemanticException(PARSER_ERROR_MSG.noCatalogSelected());
}
statement.setCatalogName(context.getCurrentCatalog());
String normalizedCatalogName = Util.normalizeName(context.getCurrentCatalog());
statement.setCatalogName(normalizedCatalogName);
}
MetaUtils.checkCatalogExistAndReport(statement.getCatalogName());

12
fe/fe-core/src/main/java/com/starrocks/sql/ast/AstVisitorExtendInterface.java
View File

@ -137,10 +137,6 @@ public interface AstVisitorExtendInterface<R, C> extends AstVisitor<R, C> {
// ---------------------------------------- Database Statement -----------------------------------------------------
default R visitUseDbStatement(UseDbStmt statement, C context) {
return visitStatement(statement, context);
}
default R visitShowDatabasesStatement(ShowDbStmt statement, C context) {
return visitShowStatement(statement, context);
}
@ -149,14 +145,6 @@ public interface AstVisitorExtendInterface<R, C> extends AstVisitor<R, C> {
return visitDDLStatement(statement, context);
}
default R visitCreateDbStatement(CreateDbStmt statement, C context) {
return visitDDLStatement(statement, context);
}
default R visitDropDbStatement(DropDbStmt statement, C context) {
return visitDDLStatement(statement, context);
}
default R visitShowCreateDbStatement(ShowCreateDbStmt statement, C context) {
return visitShowStatement(statement, context);
}

35
fe/fe-core/src/main/java/com/starrocks/sql/parser/AstBuilder.java
View File

@ -571,6 +571,8 @@ import static java.util.stream.Collectors.toList;
public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<ParseNode> {
private final long sqlMode;
private boolean caseInsensitive;
private final IdentityHashMap<ParserRuleContext, List<HintNode>> hintMap;
private int placeHolderSlotId = 0;
@ -600,11 +602,7 @@ public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<Pa
// rewriter
private static final CompoundPredicateExprRewriter COMPOUND_PREDICATE_EXPR_REWRITER = new CompoundPredicateExprRewriter();
protected AstBuilder(long sqlMode) {
this(sqlMode, new IdentityHashMap<>());
}
protected AstBuilder(long sqlMode, IdentityHashMap<ParserRuleContext, List<HintNode>> hintMap) {
protected AstBuilder(long sqlMode, boolean caseInsensitive, IdentityHashMap<ParserRuleContext, List<HintNode>> hintMap) {
this.hintMap = hintMap;
long hintSqlMode = 0L;
for (Map.Entry<ParserRuleContext, List<HintNode>> entry : hintMap.entrySet()) {
@ -616,6 +614,7 @@ public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<Pa
}
}
this.sqlMode = sqlMode | hintSqlMode;
this.caseInsensitive = caseInsensitive;
}
private static final AstBuilder.AstBuilderFactory INSTANCE = new AstBuilder.AstBuilderFactory();
@ -628,12 +627,9 @@ public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<Pa
protected AstBuilderFactory() {
}
public AstBuilder create(long sqlMode) {
return new AstBuilder(sqlMode, new IdentityHashMap<>());
}
public AstBuilder create(long sqlMode, IdentityHashMap<ParserRuleContext, List<HintNode>> hintMap) {
return new AstBuilder(sqlMode, hintMap);
public AstBuilder create(long sqlMode, boolean caseInsensitive,
IdentityHashMap<ParserRuleContext, List<HintNode>> hintMap) {
return new AstBuilder(sqlMode, caseInsensitive, hintMap);
}
}
@ -668,9 +664,9 @@ public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<Pa
QualifiedName qualifiedName = getQualifiedName(context.qualifiedName());
List<String> parts = qualifiedName.getParts();
if (parts.size() == 1) {
return new UseDbStmt(null, parts.get(0), pos);
return new UseDbStmt(null, normalizeName(parts.get(0)), pos);
} else if (parts.size() == 2) {
return new UseDbStmt(parts.get(0), parts.get(1), pos);
return new UseDbStmt(normalizeName(parts.get(0)), normalizeName(parts.get(1)), pos);
} else {
throw new ParsingException(PARSER_ERROR_MSG.invalidDbFormat(qualifiedName.toString()),
qualifiedName.getPos());
@ -742,7 +738,8 @@ public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<Pa
properties.put(property.getKey(), property.getValue());
}
}
return new CreateDbStmt(context.IF() != null, catalogName, dbName.toString(), properties, createPos(context));
return new CreateDbStmt(context.IF() != null, normalizeName(catalogName), normalizeName(dbName.toString()), properties,
createPos(context));
}
@Override
@ -753,7 +750,8 @@ public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<Pa
}
QualifiedName dbName = getQualifiedName(context.database);
return new DropDbStmt(context.IF() != null, catalogName, dbName.toString(), context.FORCE() != null,
return new DropDbStmt(context.IF() != null, normalizeName(catalogName), normalizeName(dbName.toString()),
context.FORCE() != null,
createPos(context));
}
@ -7241,7 +7239,8 @@ public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<Pa
}
private record LogicalBinaryNode(com.starrocks.sql.parser.StarRocksParser.LogicalBinaryContext context,
CompoundPredicate.Operator operator) {}
CompoundPredicate.Operator operator) {
}
// Iteratively build a left-deep CompoundPredicate tree for LogicalBinaryContext,
// allowing each node to have its own operator, using LogicalBinaryNode for clarity.
@ -9496,6 +9495,10 @@ public class AstBuilder extends com.starrocks.sql.parser.StarRocksBaseVisitor<Pa
return res;
}
private String normalizeName(String name) {
return caseInsensitive && name != null ? name.toLowerCase() : name;
}
public static IndexDef.IndexType getIndexType(com.starrocks.sql.parser.StarRocksParser.IndexTypeContext indexTypeContext) {
IndexDef.IndexType index;
if (indexTypeContext == null || indexTypeContext.BITMAP() != null) {

47
fe/fe-core/src/main/java/com/starrocks/sql/parser/SqlParser.java
View File

@ -20,6 +20,7 @@ import com.starrocks.common.Pair;
import com.starrocks.connector.parser.trino.TrinoParserUtils;
import com.starrocks.connector.trino.TrinoParserUnsupportedException;
import com.starrocks.qe.ConnectContext;
import com.starrocks.qe.GlobalVariable;
import com.starrocks.qe.SessionVariable;
import com.starrocks.server.GlobalStateMgr;
import com.starrocks.sql.ast.ImportColumnsStmt;
@ -43,6 +44,7 @@ import org.antlr.v4.runtime.misc.ParseCancellationException;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
@ -137,26 +139,31 @@ public class SqlParser {
LOG.warn("StarRocks parse sql [{}] error, cause by {}", sql, starRocksException);
if (trinoException instanceof UnsupportedException) {
throw unsupportedException(String.format("Trino parser parse sql error: [%s], " +
"and StarRocks parser also can not parse: [%s]", trinoException, starRocksException));
"and StarRocks parser also can not parse: [%s]", trinoException, starRocksException));
} else {
throw new StarRocksPlannerException(ErrorType.USER_ERROR,
String.format("Trino parser parse sql error: [%s], and StarRocks parser also can not parse: [%s]",
trinoException, starRocksException));
trinoException, starRocksException));
}
}
}
private static List<StatementBase> parseWithStarRocksDialect(String sql, SessionVariable sessionVariable) {
List<StatementBase> statements = Lists.newArrayList();
Pair<ParserRuleContext, StarRocksParser> pair = invokeParser(sql, sessionVariable, StarRocksParser::sqlStatements);
StarRocksParser.SqlStatementsContext sqlStatementsContext = (StarRocksParser.SqlStatementsContext) pair.first;
List<StarRocksParser.SingleStatementContext> singleStatementContexts = sqlStatementsContext.singleStatement();
Pair<ParserRuleContext, com.starrocks.sql.parser.StarRocksParser> pair =
invokeParser(sql, sessionVariable, com.starrocks.sql.parser.StarRocksParser::sqlStatements);
com.starrocks.sql.parser.StarRocksParser.SqlStatementsContext sqlStatementsContext =
(com.starrocks.sql.parser.StarRocksParser.SqlStatementsContext) pair.first;
List<com.starrocks.sql.parser.StarRocksParser.SingleStatementContext> singleStatementContexts =
sqlStatementsContext.singleStatement();
for (int idx = 0; idx < singleStatementContexts.size(); ++idx) {
// collect hint info
HintCollector collector = new HintCollector((CommonTokenStream) pair.second.getTokenStream(), sessionVariable);
collector.collect(singleStatementContexts.get(idx));
AstBuilder astBuilder = GlobalStateMgr.getCurrentState().getSqlParser().astBuilderFactory
.create(sessionVariable.getSqlMode(), collector.getContextWithHintMap());
AstBuilder astBuilder = GlobalStateMgr.getCurrentState().getSqlParser().astBuilderFactory.create(
sessionVariable.getSqlMode(),
GlobalVariable.enableTableNameCaseInsensitive,
collector.getContextWithHintMap());
StatementBase statement = (StatementBase) astBuilder.visitSingleStatement(singleStatementContexts.get(idx));
if (astBuilder.getParameters() != null && astBuilder.getParameters().size() != 0
&& !(statement instanceof PrepareStmt)) {
@ -212,16 +219,18 @@ public class SqlParser {
SessionVariable sessionVariable = new SessionVariable();
sessionVariable.setSqlMode(sqlMode);
ParserRuleContext expressionContext = invokeParser(expressionSql, sessionVariable,
StarRocksParser::expressionSingleton).first;
com.starrocks.sql.parser.StarRocksParser::expressionSingleton).first;
return (Expr) GlobalStateMgr.getCurrentState().getSqlParser().astBuilderFactory
.create(sqlMode).visit(expressionContext);
.create(sqlMode, GlobalVariable.enableTableNameCaseInsensitive, new IdentityHashMap<>()).visit(expressionContext);
}
public static List<Expr> parseSqlToExprs(String expressions, SessionVariable sessionVariable) {
StarRocksParser.ExpressionListContext expressionListContext = (StarRocksParser.ExpressionListContext)
invokeParser(expressions, sessionVariable, StarRocksParser::expressionList).first;
com.starrocks.sql.parser.StarRocksParser.ExpressionListContext expressionListContext =
(com.starrocks.sql.parser.StarRocksParser.ExpressionListContext)
invokeParser(expressions, sessionVariable,
com.starrocks.sql.parser.StarRocksParser::expressionList).first;
AstBuilder astBuilder = GlobalStateMgr.getCurrentState().getSqlParser().astBuilderFactory
.create(sessionVariable.getSqlMode());
.create(sessionVariable.getSqlMode(), GlobalVariable.enableTableNameCaseInsensitive, new IdentityHashMap<>());
return expressionListContext.expression().stream()
.map(e -> (Expr) astBuilder.visit(e))
.collect(Collectors.toList());
@ -231,20 +240,22 @@ public class SqlParser {
SessionVariable sessionVariable = new SessionVariable();
sessionVariable.setSqlMode(sqlMode);
ParserRuleContext importColumnsContext = invokeParser(expressionSql, sessionVariable,
StarRocksParser::importColumns).first;
com.starrocks.sql.parser.StarRocksParser::importColumns).first;
return (ImportColumnsStmt) GlobalStateMgr.getCurrentState().getSqlParser().astBuilderFactory
.create(sqlMode).visit(importColumnsContext);
.create(sqlMode, GlobalVariable.enableTableNameCaseInsensitive, new IdentityHashMap<>())
.visit(importColumnsContext);
}
private static Pair<ParserRuleContext, StarRocksParser> invokeParser(
private static Pair<ParserRuleContext, com.starrocks.sql.parser.StarRocksParser> invokeParser(
String sql, SessionVariable sessionVariable,
Function<StarRocksParser, ParserRuleContext> parseFunction) {
StarRocksLexer lexer = new StarRocksLexer(new CaseInsensitiveStream(CharStreams.fromString(sql)));
Function<com.starrocks.sql.parser.StarRocksParser, ParserRuleContext> parseFunction) {
com.starrocks.sql.parser.StarRocksLexer lexer =
new com.starrocks.sql.parser.StarRocksLexer(new CaseInsensitiveStream(CharStreams.fromString(sql)));
lexer.setSqlMode(sessionVariable.getSqlMode());
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
int exprLimit = Math.max(Config.expr_children_limit, sessionVariable.getExprChildrenLimit());
int tokenLimit = Math.max(MIN_TOKEN_LIMIT, sessionVariable.getParseTokensLimit());
StarRocksParser parser = new StarRocksParser(tokenStream);
com.starrocks.sql.parser.StarRocksParser parser = new com.starrocks.sql.parser.StarRocksParser(tokenStream);
parser.removeErrorListeners();
parser.addErrorListener(new ErrorHandler());
parser.removeParseListeners();

2
fe/fe-core/src/test/java/com/starrocks/qe/RedirectStatusTest.java
View File

@ -309,7 +309,7 @@ public class RedirectStatusTest {
@Test
public void testUseDbStmt() {
UseDbStmt stmt = new UseDbStmt("test_catalog", "test_db");
UseDbStmt stmt = new UseDbStmt("test_catalog", "test_db", NodePosition.ZERO);
Assertions.assertEquals(RedirectStatus.NO_FORWARD, RedirectStatus.getRedirectStatus(stmt));
}

11
fe/fe-core/src/test/java/com/starrocks/sql/analyzer/AstBuilderTest.java
View File

@ -12,12 +12,11 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package com.starrocks.sql.analyzer;
import com.starrocks.common.util.UUIDUtil;
import com.starrocks.qe.ConnectContext;
import com.starrocks.qe.GlobalVariable;
import com.starrocks.sql.ast.AlterClause;
import com.starrocks.sql.ast.AlterTableStmt;
import com.starrocks.sql.ast.ModifyBackendClause;
@ -37,13 +36,13 @@ import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import java.lang.reflect.Field;
import java.util.IdentityHashMap;
import java.util.List;
public class AstBuilderTest {
private static ConnectContext connectContext;
@BeforeAll
public static void beforeClass() throws Exception {
UtFrameUtils.createMinStarRocksCluster();
@ -62,7 +61,8 @@ public class AstBuilderTest {
StarRocksParser parser = new StarRocksParser(tokenStream);
StarRocksParser.SqlStatementsContext sqlStatements = parser.sqlStatements();
AstBuilder astBuilder = AstBuilder.getInstance().create(32);
AstBuilder astBuilder =
AstBuilder.getInstance().create(32, GlobalVariable.enableTableNameCaseInsensitive, new IdentityHashMap<>());
StatementBase statement = (StatementBase) astBuilder.visitSingleStatement(sqlStatements.singleStatement(0));
Field field = statement.getClass().getDeclaredField("alterClause");
field.setAccessible(true);
@ -78,7 +78,8 @@ public class AstBuilderTest {
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
StarRocksParser parser = new StarRocksParser(tokenStream);
StarRocksParser.SqlStatementsContext sqlStatements = parser.sqlStatements();
AstBuilder astBuilder = AstBuilder.getInstance().create(32);
AstBuilder astBuilder =
AstBuilder.getInstance().create(32, GlobalVariable.enableTableNameCaseInsensitive, new IdentityHashMap<>());
StatementBase statement = (StatementBase) astBuilder.visitSingleStatement(sqlStatements.singleStatement(0));
Field field = statement.getClass().getDeclaredField("alterClause");
field.setAccessible(true);

37
fe/fe-core/src/test/java/com/starrocks/sql/analyzer/TableObjectCaseInsensitiveTest.java
View File

@ -23,13 +23,17 @@ import com.starrocks.qe.DDLStmtExecutor;
import com.starrocks.qe.SetExecutor;
import com.starrocks.qe.ShowExecutor;
import com.starrocks.qe.ShowResultSet;
import com.starrocks.qe.SqlModeHelper;
import com.starrocks.server.GlobalStateMgr;
import com.starrocks.server.RunMode;
import com.starrocks.sql.ast.AdminSetConfigStmt;
import com.starrocks.sql.ast.CreateDbStmt;
import com.starrocks.sql.ast.CreateViewStmt;
import com.starrocks.sql.ast.DropDbStmt;
import com.starrocks.sql.ast.SetStmt;
import com.starrocks.sql.ast.ShowTableStmt;
import com.starrocks.sql.ast.UseDbStmt;
import com.starrocks.sql.parser.SqlParser;
import com.starrocks.utframe.UtFrameUtils;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.BeforeAll;
@ -387,4 +391,37 @@ public class TableObjectCaseInsensitiveTest {
public void testGrantCaseInsensitive() {
analyzeSuccess("grant select on table T0 to root;");
}
@Test
public void testUseDb() {
String sql = "use TEST_db";
UseDbStmt useDbStmt = (UseDbStmt) SqlParser.parseSingleStatement(sql, SqlModeHelper.MODE_DEFAULT);
Assertions.assertEquals("test_db", useDbStmt.getDbName());
sql = "use TEST_DB";
useDbStmt = (UseDbStmt) SqlParser.parseSingleStatement(sql, SqlModeHelper.MODE_DEFAULT);
Assertions.assertEquals("test_db", useDbStmt.getDbName());
}
@Test
public void testCreateDb() {
String sql = "CREATE DATABASE TEST_db";
CreateDbStmt createDbStmt = (CreateDbStmt) SqlParser.parseSingleStatement(sql, SqlModeHelper.MODE_DEFAULT);
Assertions.assertEquals("test_db", createDbStmt.getFullDbName());
sql = "CREATE DATABASE TEST_DB";
createDbStmt = (CreateDbStmt) SqlParser.parseSingleStatement(sql, SqlModeHelper.MODE_DEFAULT);
Assertions.assertEquals("test_db", createDbStmt.getFullDbName());
}
@Test
public void testDropDb() {
String sql = "DROP DATABASE TEST_db";
DropDbStmt dropDbStmt = (DropDbStmt) SqlParser.parseSingleStatement(sql, SqlModeHelper.MODE_DEFAULT);
Assertions.assertEquals("test_db", dropDbStmt.getDbName());
sql = "DROP DATABASE TEST_DB";
dropDbStmt = (DropDbStmt) SqlParser.parseSingleStatement(sql, SqlModeHelper.MODE_DEFAULT);
Assertions.assertEquals("test_db", dropDbStmt.getDbName());
}
}

13
fe/fe-core/src/test/java/com/starrocks/sql/parser/ParserBench.java
View File

@ -12,11 +12,11 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package com.starrocks.sql.parser;
import com.google.common.collect.Lists;
import com.starrocks.common.Config;
import com.starrocks.qe.GlobalVariable;
import com.starrocks.qe.SqlModeHelper;
import com.starrocks.sql.ast.StatementBase;
import org.antlr.v4.runtime.BaseErrorListener;
@ -39,6 +39,7 @@ import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.StringJoiner;
import java.util.concurrent.TimeUnit;
@ -102,9 +103,10 @@ public class ParserBench {
}
private StatementBase parseSql(String sql) {
StarRocksLexer lexer = new StarRocksLexer(new CaseInsensitiveStream(CharStreams.fromString(sql)));
com.starrocks.sql.parser.StarRocksLexer lexer =
new com.starrocks.sql.parser.StarRocksLexer(new CaseInsensitiveStream(CharStreams.fromString(sql)));
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
StarRocksParser parser = new StarRocksParser(tokenStream);
com.starrocks.sql.parser.StarRocksParser parser = new com.starrocks.sql.parser.StarRocksParser(tokenStream);
parser.removeErrorListeners();
parser.addErrorListener(new BaseErrorListener());
parser.removeParseListeners();
@ -112,8 +114,9 @@ public class ParserBench {
parser.addParseListener(new PostProcessListener(100000000, Config.expr_children_limit));
}
parser.getInterpreter().setPredictionMode(mode.equals("SLL") ? PredictionMode.SLL : PredictionMode.LL);
StarRocksParser.SqlStatementsContext sqlStatements = parser.sqlStatements();
return (StatementBase) new AstBuilder(SqlModeHelper.MODE_DEFAULT)
com.starrocks.sql.parser.StarRocksParser.SqlStatementsContext sqlStatements = parser.sqlStatements();
return (StatementBase) new AstBuilder(SqlModeHelper.MODE_DEFAULT, GlobalVariable.enableTableNameCaseInsensitive,
new IdentityHashMap<>())
.visitSingleStatement(sqlStatements.singleStatement(0));
}

38
fe/fe-core/src/test/java/com/starrocks/sql/parser/ParserTest.java
View File

@ -20,6 +20,7 @@ import com.starrocks.catalog.ScalarType;
import com.starrocks.catalog.Type;
import com.starrocks.common.Pair;
import com.starrocks.qe.ConnectContext;
import com.starrocks.qe.GlobalVariable;
import com.starrocks.qe.SessionVariable;
import com.starrocks.qe.SqlModeHelper;
import com.starrocks.qe.VariableMgr;
@ -48,6 +49,7 @@ import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import java.util.IdentityHashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.CountDownLatch;
@ -280,10 +282,11 @@ class ParserTest {
final Expr[] exprs = new Expr[2];
Thread t1 = new Thread(() -> {
synchronized (lock) {
StarRocksLexer lexer = new StarRocksLexer(new CaseInsensitiveStream(CharStreams.fromString(sql)));
com.starrocks.sql.parser.StarRocksLexer lexer =
new com.starrocks.sql.parser.StarRocksLexer(new CaseInsensitiveStream(CharStreams.fromString(sql)));
lexer.setSqlMode(SqlModeHelper.MODE_DEFAULT);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
StarRocksParser parser = new StarRocksParser(tokenStream);
com.starrocks.sql.parser.StarRocksParser parser = new com.starrocks.sql.parser.StarRocksParser(tokenStream);
parser.removeErrorListeners();
parser.addErrorListener(new BaseErrorListener());
parser.removeParseListeners();
@ -292,9 +295,12 @@ class ParserTest {
} catch (InterruptedException e) {
fail(e.getMessage());
}
List<StarRocksParser.SingleStatementContext> sqlStatements = parser.sqlStatements().singleStatement();
QueryStatement statement = (QueryStatement) new AstBuilder(SqlModeHelper.MODE_DEFAULT)
.visitSingleStatement(sqlStatements.get(0));
List<com.starrocks.sql.parser.StarRocksParser.SingleStatementContext> sqlStatements =
parser.sqlStatements().singleStatement();
QueryStatement statement =
(QueryStatement) new AstBuilder(SqlModeHelper.MODE_DEFAULT, GlobalVariable.enableTableNameCaseInsensitive,
new IdentityHashMap<>())
.visitSingleStatement(sqlStatements.get(0));
SelectList item = ((SelectRelation) statement.getQueryRelation()).getSelectList();
exprs[0] = item.getItems().get(0).getExpr();
latch.countDown();
@ -304,16 +310,19 @@ class ParserTest {
Thread t2 = new Thread(() -> {
synchronized (lock) {
StarRocksLexer lexer = new StarRocksLexer(new CaseInsensitiveStream(CharStreams.fromString(sql)));
com.starrocks.sql.parser.StarRocksLexer lexer =
new com.starrocks.sql.parser.StarRocksLexer(new CaseInsensitiveStream(CharStreams.fromString(sql)));
long sqlMode = SqlModeHelper.MODE_DEFAULT | SqlModeHelper.MODE_PIPES_AS_CONCAT;
lexer.setSqlMode(sqlMode);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
StarRocksParser parser = new StarRocksParser(tokenStream);
com.starrocks.sql.parser.StarRocksParser parser = new com.starrocks.sql.parser.StarRocksParser(tokenStream);
parser.removeErrorListeners();
parser.addErrorListener(new BaseErrorListener());
parser.removeParseListeners();
List<StarRocksParser.SingleStatementContext> sqlStatements = parser.sqlStatements().singleStatement();
QueryStatement statement = (QueryStatement) new AstBuilder(sqlMode)
List<com.starrocks.sql.parser.StarRocksParser.SingleStatementContext> sqlStatements =
parser.sqlStatements().singleStatement();
QueryStatement statement = (QueryStatement) new AstBuilder(sqlMode, GlobalVariable.enableTableNameCaseInsensitive,
new IdentityHashMap<>())
.visitSingleStatement(sqlStatements.get(0));
SelectList item = ((SelectRelation) statement.getQueryRelation()).getSelectList();
exprs[1] = item.getItems().get(0).getExpr();
@ -435,15 +444,16 @@ class ParserTest {
builder.append(exprString);
}
AstBuilder astBuilder = new AstBuilder(SqlModeHelper.MODE_DEFAULT);
StarRocksLexer lexer = new StarRocksLexer(
AstBuilder astBuilder = new AstBuilder(SqlModeHelper.MODE_DEFAULT, GlobalVariable.enableTableNameCaseInsensitive,
new IdentityHashMap<>());
com.starrocks.sql.parser.StarRocksLexer lexer = new com.starrocks.sql.parser.StarRocksLexer(
new CaseInsensitiveStream(CharStreams.fromString(builder.toString())));
lexer.setSqlMode(SqlModeHelper.MODE_DEFAULT);
CommonTokenStream tokenStream = new CommonTokenStream(lexer);
StarRocksParser parser = new StarRocksParser(tokenStream);
com.starrocks.sql.parser.StarRocksParser parser = new com.starrocks.sql.parser.StarRocksParser(tokenStream);
parser.getInterpreter().setPredictionMode(PredictionMode.LL);
long start = System.currentTimeMillis();
StarRocksParser.ExpressionContext context1 = parser.expression();
com.starrocks.sql.parser.StarRocksParser.ExpressionContext context1 = parser.expression();
Expr expr1 = (Expr) astBuilder.visit(context1);
long end = System.currentTimeMillis();
long timeOfLL = end - start;
@ -452,7 +462,7 @@ class ParserTest {
parser.reset();
parser.getInterpreter().setPredictionMode(PredictionMode.SLL);
start = System.currentTimeMillis();
StarRocksParser.ExpressionContext context2 = parser.expression();
com.starrocks.sql.parser.StarRocksParser.ExpressionContext context2 = parser.expression();
Expr expr2 = (Expr) astBuilder.visit(context2);
end = System.currentTimeMillis();
long timeOfSLL = end - start;

14
fe/fe-parser/src/main/java/com/starrocks/sql/ast/AstVisitor.java
View File

@ -434,6 +434,20 @@ public interface AstVisitor<R, C> {
return visitDDLStatement(statement, context);
}
// ---------------------------------------- Database Statement -----------------------------------------------------
default R visitUseDbStatement(UseDbStmt statement, C context) {
return visitStatement(statement, context);
}
default R visitCreateDbStatement(CreateDbStmt statement, C context) {
return visitDDLStatement(statement, context);
}
default R visitDropDbStatement(DropDbStmt statement, C context) {
return visitDDLStatement(statement, context);
}
// ------------------------------------------- User Statement ----------------------------------------------------
default R visitBaseCreateAlterUserStmt(BaseCreateAlterUserStmt statement, C context) {

9
fe/fe-core/src/main/java/com/starrocks/sql/ast/CreateDbStmt.java → fe/fe-parser/src/main/java/com/starrocks/sql/ast/CreateDbStmt.java
View File

@ -20,7 +20,6 @@ import com.starrocks.sql.parser.NodePosition;
import java.util.Map;
import static com.starrocks.common.util.Util.normalizeName;
public class CreateDbStmt extends DdlStmt {
private final boolean ifNotExists;
@ -40,8 +39,8 @@ public class CreateDbStmt extends DdlStmt {
Map<String, String> properties, NodePosition pos) {
super(pos);
this.ifNotExists = ifNotExists;
this.catalogName = normalizeName(catalogName);
this.dbName = normalizeName(dbName);
this.catalogName = catalogName;
this.dbName = dbName;
this.properties = properties;
}
@ -62,11 +61,11 @@ public class CreateDbStmt extends DdlStmt {
}
public void setCatalogName(String catalogName) {
this.catalogName = normalizeName(catalogName);
this.catalogName = catalogName;
}
@Override
public <R, C> R accept(AstVisitor<R, C> visitor, C context) {
return ((AstVisitorExtendInterface<R, C>) visitor).visitCreateDbStatement(this, context);
return visitor.visitCreateDbStatement(this, context);
}
}

14
fe/fe-core/src/main/java/com/starrocks/sql/ast/DropDbStmt.java → fe/fe-parser/src/main/java/com/starrocks/sql/ast/DropDbStmt.java
View File

@ -17,7 +17,6 @@ package com.starrocks.sql.ast;
import com.starrocks.sql.parser.NodePosition;
import static com.starrocks.common.util.Util.normalizeName;
// DROP DB Statement
public class DropDbStmt extends DdlStmt {
@ -37,12 +36,11 @@ public class DropDbStmt extends DdlStmt {
public DropDbStmt(boolean ifExists, String catalog, String dbName, boolean forceDrop, NodePosition pos) {
super(pos);
this.ifExists = ifExists;
this.catalog = normalizeName(catalog);
this.dbName = normalizeName(dbName);
this.catalog = catalog;
this.dbName = dbName;
this.forceDrop = forceDrop;
}
public boolean isSetIfExists() {
return ifExists;
}
@ -52,24 +50,20 @@ public class DropDbStmt extends DdlStmt {
}
public void setCatalogName(String catalogName) {
this.catalog = normalizeName(catalogName);
this.catalog = catalogName;
}
public String getDbName() {
return this.dbName;
}
public void setDbName(String dbName) {
this.dbName = normalizeName(dbName);
}
public boolean isForceDrop() {
return this.forceDrop;
}
@Override
public <R, C> R accept(AstVisitor<R, C> visitor, C context) {
return ((AstVisitorExtendInterface<R, C>) visitor).visitDropDbStatement(this, context);
return visitor.visitDropDbStatement(this, context);
}
}

15
fe/fe-core/src/main/java/com/starrocks/sql/ast/UseDbStmt.java → fe/fe-parser/src/main/java/com/starrocks/sql/ast/UseDbStmt.java
View File

@ -12,13 +12,10 @@
// See the License for the specific language governing permissions and
// limitations under the License.
package com.starrocks.sql.ast;
import com.starrocks.sql.parser.NodePosition;
import static com.starrocks.common.util.Util.normalizeName;
/**
* Representation of a USE [catalog.]db statement.
* Queries from MySQL client will not generate UseDbStmt, it will be handled by the COM_INIT_DB protocol.
@ -28,14 +25,10 @@ public class UseDbStmt extends StatementBase {
private String catalog;
private final String database;
public UseDbStmt(String catalog, String database) {
this(catalog, database, NodePosition.ZERO);
}
public UseDbStmt(String catalog, String database, NodePosition pos) {
super(pos);
this.catalog = normalizeName(catalog);
this.database = normalizeName(database);
this.catalog = catalog;
this.database = database;
}
public String getCatalogName() {
@ -43,7 +36,7 @@ public class UseDbStmt extends StatementBase {
}
public void setCatalogName(String catalogName) {
this.catalog = normalizeName(catalogName);
this.catalog = catalogName;
}
public String getDbName() {
@ -60,6 +53,6 @@ public class UseDbStmt extends StatementBase {
@Override
public <R, C> R accept(AstVisitor<R, C> visitor, C context) {
return ((AstVisitorExtendInterface<R, C>) visitor).visitUseDbStatement(this, context);
return visitor.visitUseDbStatement(this, context);
}
}