Add stored procedure calls with unnamed args

lang/resources/org/partiql/type-domains/partiql.ion

@@ -26,7 +26,12 @@
                 (where where::(? expr)))
 
             // Data definition operations also cannot be composed with other `expr` nodes.
-            (ddl op::ddl_op))
+            (ddl op::ddl_op)
+
+            // Stored procedure calls are only allowed at the top level of a query and cannot be used as an expression
+            // Currently supports stored procedure calls with the unnamed argument syntax:
+            //     EXEC <symbol> [<expr>.*]
+            (exec procedure_name::symbol args::(* expr 0)))
 
         // The expressions that can result in values.
         (sum expr

lang/src/org/partiql/lang/ast/AstSerialization.kt

@@ -94,6 +94,7 @@ private class AstSerializerImpl(val astVersion: AstVersion, val ion: IonSystem):
                     is DropTable         -> case { writeDropTable(expr) }
                     is DropIndex         -> case { writeDropIndex(expr) }
                     is Parameter         -> case { writeParameter(expr)}
+                    is Exec              -> throw UnsupportedOperationException("EXEC clause not supported by the V0 AST")
                 }.toUnit()
             }
         }

lang/src/org/partiql/lang/ast/ExprNodeToStatement.kt

@@ -16,6 +16,7 @@ fun ExprNode.toAstStatement(): PartiqlAst.Statement {
 
         is CreateTable, is CreateIndex, is DropTable, is DropIndex -> toAstDdl()
 
+        is Exec -> toAstExec()
     }
 }
 
@@ -30,7 +31,7 @@ private fun ExprNode.toAstDdl(): PartiqlAst.Statement {
         when(thiz) {
             is Literal, is LiteralMissing, is VariableReference, is Parameter, is NAry, is CallAgg, is Typed,
             is Path, is SimpleCase, is SearchedCase, is Select, is Struct, is Seq,
-            is DataManipulation -> error("Can't convert ${thiz.javaClass} to PartiqlAst.ddl")
+            is DataManipulation, is Exec -> error("Can't convert ${thiz.javaClass} to PartiqlAst.ddl")
 
             is CreateTable -> ddl(createTable(thiz.tableName), metas)
             is CreateIndex -> ddl(createIndex(identifier(thiz.tableName, caseSensitive()), thiz.keys.map { it.toAstExpr() }), metas)
@@ -48,6 +49,18 @@ private fun ExprNode.toAstDdl(): PartiqlAst.Statement {
     }
 }
 
+private fun ExprNode.toAstExec() : PartiqlAst.Statement {
+    val node = this
+    val metas = metas.toElectrolyteMetaContainer()
+
+    return PartiqlAst.build {
+        when (node) {
+            is Exec -> exec(node.procedureName.name, node.args.map { it.toAstExpr() }, metas)
+            else -> error("Can't convert ${node.javaClass} to PartiqlAst.Statement.Exec")
+        }
+    }
+}
+
 fun ExprNode.toAstExpr(): PartiqlAst.Expr {
     val node = this
     val metas = this.metas.toElectrolyteMetaContainer()
@@ -147,8 +160,8 @@ fun ExprNode.toAstExpr(): PartiqlAst.Expr {
                     SeqType.BAG -> bag(node.values.map { it.toAstExpr() })
                 }
 
-            // These are handled by `toAstDml()`
-            is DataManipulation, is CreateTable, is CreateIndex, is DropTable, is DropIndex ->
+            // These are handled by `toAstDml()`, `toAstDdl()`, and `toAstExec()`
+            is DataManipulation, is CreateTable, is CreateIndex, is DropTable, is DropIndex, is Exec ->
                 error("Can't transform ${node.javaClass} to a PartiqlAst.expr }")
         }
     }

lang/src/org/partiql/lang/ast/StatementToExprNode.kt

@@ -2,6 +2,7 @@ package org.partiql.lang.ast
 
 import com.amazon.ion.IonSystem
 import com.amazon.ionelement.api.toIonValue
+import org.partiql.lang.domains.PartiqlAst
 import org.partiql.lang.domains.PartiqlAst.CaseSensitivity
 import org.partiql.lang.domains.PartiqlAst.DdlOp
 import org.partiql.lang.domains.PartiqlAst.DmlOp
@@ -33,6 +34,7 @@ private class StatementTransformer(val ion: IonSystem) {
             is Statement.Query -> stmt.toExprNode()
             is Statement.Dml -> stmt.toExprNode()
             is Statement.Ddl -> stmt.toExprNode()
+            is Statement.Exec -> stmt.toExprNode()
         }
 
     private fun ElectrolyteMetaContainer.toPartiQlMetaContainer(): PartiQlMetaContainer {
@@ -344,4 +346,8 @@ private class StatementTransformer(val ion: IonSystem) {
                     metas = metas)
         }
     }
+
+    private fun Statement.Exec.toExprNode(): ExprNode {
+        return Exec(procedureName.toSymbolicName(), this.args.toExprNodeList(), metas.toPartiQlMetaContainer())
+    }
 }

lang/src/org/partiql/lang/ast/ast.kt

@@ -103,6 +103,9 @@ sealed class ExprNode : AstNode(), HasMetas {
             is Parameter       -> {
                 copy(metas = metas)
             }
+            is Exec            -> {
+                copy(metas = metas)
+            }
         }
     }
 }
@@ -210,6 +213,19 @@ data class Typed(
     override val children: List<AstNode> = listOf(expr, type)
 }
 
+//********************************
+// Stored procedure clauses
+//********************************
+
+/** Represents a call to a stored procedure, i.e. `EXEC stored_procedure [<expr>.*]` */
+data class Exec(
+    val procedureName: SymbolicName,
+    val args: List<ExprNode>,
+    override val metas: MetaContainer
+) : ExprNode() {
+    override val children: List<AstNode> = args
+}
+
 //********************************
 // Path expressions
 //********************************

lang/src/org/partiql/lang/ast/passes/AstRewriterBase.kt

@@ -49,6 +49,7 @@ open class AstRewriterBase : AstRewriter {
             is CreateIndex       -> rewriteCreateIndex(node)
             is DropTable         -> rewriteDropTable(node)
             is DropIndex         -> rewriteDropIndex(node)
+            is Exec              -> rewriteExec(node)
         }
 
     open fun rewriteMetas(itemWithMetas: HasMetas): MetaContainer = itemWithMetas.metas
@@ -398,4 +399,10 @@ open class AstRewriterBase : AstRewriter {
             rewriteVariableReference(node.identifier) as VariableReference,
             rewriteMetas(node))
 
+    open fun rewriteExec(node: Exec): Exec =
+        Exec(
+            rewriteSymbolicName(node.procedureName),
+            node.args.map { rewriteExprNode(it) },
+            rewriteMetas(node))
+
 }

lang/src/org/partiql/lang/ast/passes/AstWalker.kt

@@ -116,6 +116,7 @@ open class AstWalker(private val visitor: AstVisitor) {
                     }
                 }
                 is CreateTable, is DropTable, is DropIndex -> case { }
+                is Exec -> case { }
             }.toUnit()
         }
     }

lang/src/org/partiql/lang/errors/ErrorCode.kt

@@ -297,6 +297,16 @@ enum class ErrorCode(private val category: ErrorCategory,
         LOC_TOKEN,
         "Aggregate function calls take 1 argument only"),
 
+    PARSE_NO_STORED_PROCEDURE_PROVIDED(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "No stored procedure provided"),
+
+    PARSE_EXEC_AT_UNEXPECTED_LOCATION(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "EXEC call found at unexpected location"),
+
     PARSE_MALFORMED_JOIN(
         ErrorCategory.PARSER,
         LOC_TOKEN,

lang/src/org/partiql/lang/eval/EvaluatingCompiler.kt

@@ -278,6 +278,8 @@ internal class EvaluatingCompiler(
             is CreateIndex,
             is DropIndex,
             is DropTable -> compileDdl(expr)
+            is Exec      -> compileExec(expr)
+
         }
     }
 
@@ -1924,6 +1926,10 @@ internal class EvaluatingCompiler(
         }
     }
 
+    private fun compileExec(node: ExprNode): ThunkEnv {
+        TODO()
+    }
+
     /** A special wrapper for `UNPIVOT` values as a BAG. */
     private class UnpivotedExprValue(private val values: Iterable<ExprValue>) : BaseExprValue() {
         override val type = ExprValueType.BAG

lang/src/org/partiql/lang/syntax/SqlParser.kt

@@ -114,7 +114,8 @@ class SqlParser(private val ion: IonSystem) : Parser {
         DROP_TABLE,
         DROP_INDEX,
         CREATE_INDEX,
-        PARAMETER;
+        PARAMETER,
+        EXEC;
 
         val identifier = name.toLowerCase()
     }
@@ -335,6 +336,10 @@ class SqlParser(private val ion: IonSystem) : Parser {
                     }
                 }
             }
+            EXEC -> {
+                val procedureName = SymbolicName(token?.text!!.toLowerCase(), token.toSourceLocationMetaContainer())
+                Exec(procedureName, children.map { it.toExprNode() }, metas)
+            }
             CALL_AGG -> {
                 val funcExpr =
                     VariableReference(
@@ -1015,6 +1020,7 @@ class SqlParser(private val ion: IonSystem) : Parser {
                     tail.tail.parseFunctionCall(head!!)
                 else -> err("Unexpected keyword", PARSE_UNEXPECTED_KEYWORD)
             }
+            "exec" -> tail.parseExec()
             else -> err("Unexpected keyword", PARSE_UNEXPECTED_KEYWORD)
         }
         LEFT_PAREN -> {
@@ -1712,6 +1718,28 @@ class SqlParser(private val ion: IonSystem) : Parser {
         }
     }
 
+    private fun List<Token>.parseExec(): ParseNode {
+        var rem = this
+        if (rem.head?.type == EOF) {
+            rem.err("No stored procedure provided", PARSE_NO_STORED_PROCEDURE_PROVIDED)
+        }
+
+        val procedureName = rem.head
+        rem = rem.tail
+
+        // Stored procedure call has no args
+        if (rem.head?.type == EOF) {
+            return ParseNode(EXEC, procedureName, emptyList(), rem)
+        }
+
+        else if (rem.head?.type == LEFT_PAREN) {
+            rem.err("Unexpected $LEFT_PAREN found following stored procedure call", PARSE_UNEXPECTED_TOKEN)
+        }
+
+        return rem.parseArgList(aliasSupportType = NONE, mode = NORMAL_ARG_LIST)
+                  .copy(type = EXEC, token = procedureName)
+    }
+
     /**
      * Parses substring
      *
@@ -2214,9 +2242,23 @@ class SqlParser(private val ion: IonSystem) : Parser {
         return ParseNode(ARG_LIST, null, items, rem)
     }
 
+    /**
+     * Checks that the given [Token] list does not have `EXEC` calls outside of the top level query. Throws
+     * an error if so.
+     */
+    private fun List<Token>.checkForUnexpectedExec() {
+        for ((index, token) in this.withIndex()) {
+            if (token.keywordText == "exec" && index != 0) {
+                token.err("EXEC call found at unexpected location", PARSE_EXEC_AT_UNEXPECTED_LOCATION)
+            }
+        }
+    }
+
     /** Entry point into the parser. */
     override fun parseExprNode(source: String): ExprNode {
-        val node = SqlLexer(ion).tokenize(source).parseExpression()
+        val tokens = SqlLexer(ion).tokenize(source)
+        tokens.checkForUnexpectedExec()
+        val node = tokens.parseExpression()
         val rem = node.remaining
         if (!rem.onlyEndOfStatement()) {
             when(rem.head?.type ) {

lang/test/org/partiql/lang/errors/ParserErrorsTest.kt

@@ -1546,4 +1546,87 @@ class ParserErrorsTest : TestBase() {
             Property.TOKEN_TYPE to TokenType.EOF,
             Property.TOKEN_VALUE to ion.newSymbol("EOF")))
 
+    //****************************************
+    // EXEC clause parsing errors
+    //****************************************
+
+    @Test
+    fun execNoStoredProcedureProvided() = checkInputThrowingParserException(
+        "EXEC",
+        ErrorCode.PARSE_NO_STORED_PROCEDURE_PROVIDED,
+        mapOf(
+            Property.LINE_NUMBER to 1L,
+            Property.COLUMN_NUMBER to 5L,
+            Property.TOKEN_TYPE to TokenType.EOF,
+            Property.TOKEN_VALUE to ion.newSymbol("EOF")))
+
+    @Test
+    fun execCommaBetweenStoredProcedureAndArg() = checkInputThrowingParserException(
+        "EXEC foo, arg0, arg1",
+        ErrorCode.PARSE_UNEXPECTED_TERM,
+        mapOf(
+            Property.LINE_NUMBER to 1L,
+            Property.COLUMN_NUMBER to 9L,
+            Property.TOKEN_TYPE to TokenType.COMMA,
+            Property.TOKEN_VALUE to ion.newSymbol(",")))
+
+    @Test
+    fun execArgTrailingComma() = checkInputThrowingParserException(
+        "EXEC foo arg0, arg1,",
+        ErrorCode.PARSE_UNEXPECTED_TERM,
+        mapOf(
+            Property.LINE_NUMBER to 1L,
+            Property.COLUMN_NUMBER to 21L,
+            Property.TOKEN_TYPE to TokenType.EOF,
+            Property.TOKEN_VALUE to ion.newSymbol("EOF")))
+
+    @Test
+    fun execUnexpectedParen() = checkInputThrowingParserException(
+        "EXEC foo()",
+        ErrorCode.PARSE_UNEXPECTED_TOKEN,
+        mapOf(
+            Property.LINE_NUMBER to 1L,
+            Property.COLUMN_NUMBER to 9L,
+            Property.TOKEN_TYPE to TokenType.LEFT_PAREN,
+            Property.TOKEN_VALUE to ion.newSymbol("(")))
+
+    @Test
+    fun execUnexpectedParenWithArgs() = checkInputThrowingParserException(
+        "EXEC foo(arg0, arg1)",
+        ErrorCode.PARSE_UNEXPECTED_TOKEN,
+        mapOf(
+            Property.LINE_NUMBER to 1L,
+            Property.COLUMN_NUMBER to 9L,
+            Property.TOKEN_TYPE to TokenType.LEFT_PAREN,
+            Property.TOKEN_VALUE to ion.newSymbol("(")))
+
+    @Test
+    fun execAtUnexpectedLocation() = checkInputThrowingParserException(
+        "EXEC EXEC",
+        ErrorCode.PARSE_EXEC_AT_UNEXPECTED_LOCATION,
+        mapOf(
+            Property.LINE_NUMBER to 1L,
+            Property.COLUMN_NUMBER to 6L,
+            Property.TOKEN_TYPE to TokenType.KEYWORD,
+            Property.TOKEN_VALUE to ion.newSymbol("exec")))
+
+    @Test
+    fun execAtUnexpectedLocationAfterExec() = checkInputThrowingParserException(
+        "EXEC foo EXEC",
+        ErrorCode.PARSE_EXEC_AT_UNEXPECTED_LOCATION,
+        mapOf(
+            Property.LINE_NUMBER to 1L,
+            Property.COLUMN_NUMBER to 10L,
+            Property.TOKEN_TYPE to TokenType.KEYWORD,
+            Property.TOKEN_VALUE to ion.newSymbol("exec")))
+
+    @Test
+    fun execAtUnexpectedLocationInExpression() = checkInputThrowingParserException(
+        "SELECT * FROM (EXEC undrop 'foo')",
+        ErrorCode.PARSE_EXEC_AT_UNEXPECTED_LOCATION,
+        mapOf(
+            Property.LINE_NUMBER to 1L,
+            Property.COLUMN_NUMBER to 16L,
+            Property.TOKEN_TYPE to TokenType.KEYWORD,
+            Property.TOKEN_VALUE to ion.newSymbol("exec")))
 }