Add SQL DDL support for CREATE/DROP TABLE and SHOW CREATE TABLE

pinot-common/src/main/codegen/config.fmpp

@@ -53,6 +53,18 @@ data: {
       "BIG_DECIMAL"
       "STRING"
       "BYTES"
+      # Pinot DDL (CREATE/DROP/SHOW TABLE) keywords
+      "DIMENSION"
+      "METRIC"
+      "GRANULARITY"
+      "OFFLINE"
+      "REALTIME"
+      "PROPERTIES"
+      "TABLES"
+      "TABLE_TYPE"
+      # IF is not a SQL reserved word but Calcite core does not declare it as a token; we need it
+      # for DDL "IF [NOT] EXISTS" clauses.
+      "IF"
     ]
 
     # List of non-reserved keywords to add;
@@ -70,6 +82,16 @@ data: {
       "DATETIME"
       "VARIANT"
       "UUID"
+      # Pinot DDL keywords kept non-reserved so users can still use them as identifiers
+      "DIMENSION"
+      "METRIC"
+      "GRANULARITY"
+      "OFFLINE"
+      "REALTIME"
+      "PROPERTIES"
+      "TABLES"
+      "TABLE_TYPE"
+      "IF"
 
       # The following keywords are reserved in core Calcite,
       # are reserved in some version of SQL,
@@ -568,6 +590,9 @@ data: {
     statementParserMethods: [
       "SqlInsertFromFile()"
       "SqlPhysicalExplain()"
+      "SqlPinotCreateTable()"
+      "SqlPinotDropTable()"
+      "SqlPinotShow()"
     ]
 
     # List of methods for parsing custom literals.

pinot-common/src/main/codegen/includes/parserImpls.ftl

@@ -45,10 +45,8 @@ SqlNodeList DataFileDefList() :
     }
 }
 
-/**
- * INSERT INTO [db_name.]table_name
- *   FROM [ FILE | ARCHIVE ] 'file_uri' [, [ FILE | ARCHIVE ] 'file_uri' ]
- */
+/// INSERT INTO [db_name.]table_name
+/// FROM [ FILE | ARCHIVE ] 'file_uri' [, [ FILE | ARCHIVE ] 'file_uri' ]
 SqlInsertFromFile SqlInsertFromFile() :
 {
     SqlParserPos pos;
@@ -109,3 +107,204 @@ SqlNode SqlPhysicalExplain() :
             nDynamicParams);
     }
 }
+
+/// CREATE TABLE [IF NOT EXISTS] [db.]name (
+/// col TYPE [NULL | NOT NULL] [DEFAULT literal]
+/// [ DIMENSION | METRIC | DATETIME FORMAT 'fmt' GRANULARITY 'gran' ],
+/// ...
+/// )
+/// TABLE_TYPE = OFFLINE | REALTIME
+/// [ PROPERTIES ( 'k' = 'v', ... ) ]
+SqlNode SqlPinotCreateTable() :
+{
+    SqlParserPos pos;
+    SqlIdentifier name;
+    boolean ifNotExists = false;
+    SqlNodeList columns;
+    SqlNodeList primaryKeyColumns = null;
+    SqlLiteral tableType;
+    SqlNodeList properties = null;
+}
+{
+    <CREATE> { pos = getPos(); }
+    <TABLE>
+    [ LOOKAHEAD(3) <IF> <NOT> <EXISTS> { ifNotExists = true; } ]
+    name = CompoundIdentifier()
+    columns = PinotColumnList()
+    [ LOOKAHEAD(2) primaryKeyColumns = PinotPrimaryKeyList() ]
+    <TABLE_TYPE> <EQ>
+    tableType = PinotTableTypeLiteral()
+    [ <PROPERTIES> properties = PinotPropertyList() ]
+    {
+        return new SqlPinotCreateTable(pos, name, ifNotExists, columns, primaryKeyColumns,
+            tableType, properties);
+    }
+}
+
+SqlNodeList PinotColumnList() :
+{
+    SqlParserPos pos;
+    SqlPinotColumnDeclaration col;
+    List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    <LPAREN> { pos = getPos(); }
+    col = PinotColumnDeclaration() { list.add(col); }
+    ( <COMMA> col = PinotColumnDeclaration() { list.add(col); } )*
+    <RPAREN>
+    {
+        return new SqlNodeList(list, pos.plus(getPos()));
+    }
+}
+
+SqlNodeList PinotPrimaryKeyList() :
+{
+    SqlParserPos pos;
+    SqlIdentifier col;
+    List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    <PRIMARY> { pos = getPos(); } <KEY>
+    <LPAREN>
+    col = SimpleIdentifier() { list.add(col); }
+    ( <COMMA> col = SimpleIdentifier() { list.add(col); } )*
+    <RPAREN>
+    {
+        return new SqlNodeList(list, pos.plus(getPos()));
+    }
+}
+
+SqlPinotColumnDeclaration PinotColumnDeclaration() :
+{
+    SqlParserPos pos;
+    SqlIdentifier name;
+    SqlDataTypeSpec type;
+    boolean nullable = true;
+    SqlNode defaultValue = null;
+    String role = null;
+    SqlNode fmtNode = null;
+    SqlNode granNode = null;
+    boolean multiValue = false;
+}
+{
+    name = SimpleIdentifier() { pos = getPos(); }
+    type = DataType()
+    [
+        LOOKAHEAD(2)
+        <NOT> <NULL> { nullable = false; }
+    |
+        <NULL> { nullable = true; }
+    ]
+    [ <DEFAULT_> defaultValue = Literal() ]
+    [
+        <DIMENSION> { role = "DIMENSION"; } [ <ARRAY> { multiValue = true; } ]
+    |
+        <METRIC> { role = "METRIC"; }
+    |
+        <DATETIME> { role = "DATETIME"; }
+        <FORMAT> fmtNode = StringLiteral()
+        <GRANULARITY> granNode = StringLiteral()
+    ]
+    {
+        return new SqlPinotColumnDeclaration(pos, name, type, nullable, defaultValue, role,
+            (SqlLiteral) fmtNode, (SqlLiteral) granNode, multiValue);
+    }
+}
+
+SqlLiteral PinotTableTypeLiteral() :
+{
+    String value;
+    SqlParserPos pos;
+}
+{
+    (
+        <OFFLINE> { value = "OFFLINE"; pos = getPos(); }
+    |
+        <REALTIME> { value = "REALTIME"; pos = getPos(); }
+    )
+    {
+        return SqlLiteral.createCharString(value, pos);
+    }
+}
+
+SqlNodeList PinotPropertyList() :
+{
+    SqlParserPos pos;
+    SqlPinotProperty prop;
+    List<SqlNode> list = new ArrayList<SqlNode>();
+}
+{
+    <LPAREN> { pos = getPos(); }
+    [
+        prop = PinotProperty() { list.add(prop); }
+        ( <COMMA> prop = PinotProperty() { list.add(prop); } )*
+    ]
+    <RPAREN>
+    {
+        return new SqlNodeList(list, pos.plus(getPos()));
+    }
+}
+
+SqlPinotProperty PinotProperty() :
+{
+    SqlParserPos pos;
+    SqlNode keyNode;
+    SqlNode valueNode;
+}
+{
+    keyNode = StringLiteral() { pos = getPos(); }
+    <EQ> valueNode = StringLiteral()
+    {
+        return new SqlPinotProperty(pos, (SqlLiteral) keyNode, (SqlLiteral) valueNode);
+    }
+}
+
+/// DROP TABLE [IF EXISTS] [db.]name [TYPE OFFLINE | REALTIME]
+SqlNode SqlPinotDropTable() :
+{
+    SqlParserPos pos;
+    SqlIdentifier name;
+    boolean ifExists = false;
+    SqlLiteral tableType = null;
+}
+{
+    <DROP> { pos = getPos(); }
+    <TABLE>
+    [ LOOKAHEAD(2) <IF> <EXISTS> { ifExists = true; } ]
+    name = CompoundIdentifier()
+    [ <TYPE> tableType = PinotTableTypeLiteral() ]
+    {
+        return new SqlPinotDropTable(pos, name, ifExists, tableType);
+    }
+}
+
+/// SHOW TABLES [FROM db]
+/// | SHOW CREATE TABLE [db.]name [TYPE OFFLINE | REALTIME]
+///
+/// Both grammar branches share a leading `SHOW` token; combining them into a single entry point
+/// keeps the JavaCC choice unambiguous (no need for LOOKAHEAD across multiple statementParser
+/// methods that all start with SHOW).
+SqlNode SqlPinotShow() :
+{
+    SqlParserPos pos;
+    SqlIdentifier name;
+    SqlIdentifier database = null;
+    SqlLiteral tableType = null;
+}
+{
+    <SHOW> { pos = getPos(); }
+    (
+        <TABLES>
+        [ <FROM> database = SimpleIdentifier() ]
+        {
+            return new SqlPinotShowTables(pos, database);
+        }
+    |
+        <CREATE> <TABLE>
+        name = CompoundIdentifier()
+        [ <TYPE> tableType = PinotTableTypeLiteral() ]
+        {
+            return new SqlPinotShowCreateTable(pos, name, tableType);
+        }
+    )
+}