Remove functionName w/ qualifiedName

Author: alancai98

partiql-lang/src/main/kotlin/org/partiql/lang/syntax/impl/PartiQLPigVisitor.kt

@@ -1326,7 +1326,7 @@ internal class PartiQLPigVisitor(
     }
 
     override fun visitFunctionCall(ctx: PartiQLParser.FunctionCallContext) = PartiqlAst.build {
-        val nameCtx = ctx.functionName()
+        val nameCtx = ctx.qualifiedName()
         val name = if (nameCtx.qualifier.isNotEmpty()) {
             error("Legacy AST does not support qualified function names")
         } else {

partiql-parser/src/main/antlr/PartiQL.g4

@@ -763,12 +763,7 @@ dateFunction
 
 // SQL-99 10.4 — <routine invocation> ::= <routine name> <SQL argument list>
 functionCall
-    : functionName PAREN_LEFT ( expr ( COMMA expr )* )? PAREN_RIGHT
-    ;
-
-// SQL-99 10.4 — <routine name> ::= [ <schema name> <period> ] <qualified identifier>
-functionName
-    : (qualifier+=symbolPrimitive PERIOD)* name=symbolPrimitive
+    : qualifiedName PAREN_LEFT ( expr ( COMMA expr )* )? PAREN_RIGHT
     ;
 
 pathStep

partiql-parser/src/main/kotlin/org/partiql/parser/internal/PartiQLParserDefault.kt

@@ -1857,37 +1857,32 @@ internal class PartiQLParserDefault : PartiQLParser {
 
         override fun visitFunctionCall(ctx: GeneratedParser.FunctionCallContext) = translate(ctx) {
             val args = visitOrEmpty<Expr>(ctx.expr())
-            when (val funcName = ctx.functionName()) {
-                is GeneratedParser.FunctionNameContext -> {
+            when (val funcName = ctx.qualifiedName()) {
+                is GeneratedParser.QualifiedNameContext -> {
                     when (funcName.name.start.type) {
                         GeneratedParser.MOD -> exprBinary(Expr.Binary.Op.MODULO, args[0], args[1])
+                        GeneratedParser.CHARACTER_LENGTH, GeneratedParser.CHAR_LENGTH -> {
+                            val path = ctx.qualifiedName().qualifier.map { visitSymbolPrimitive(it) }
+                            val name = identifierSymbol("char_length", Identifier.CaseSensitivity.INSENSITIVE)
+                            if (path.isEmpty()) {
+                                exprCall(name, args)
+                            } else {
+                                val root = path.first()
+                                val steps = path.drop(1) + listOf(name)
+                                exprCall(identifierQualified(root, steps), args)
+                            }
+                        }
                         else -> visitNonReservedFunctionCall(ctx, args)
                     }
                 }
                 else -> visitNonReservedFunctionCall(ctx, args)
             }
         }
         private fun visitNonReservedFunctionCall(ctx: GeneratedParser.FunctionCallContext, args: List<Expr>): Expr.Call {
-            val function = visit(ctx.functionName()) as Identifier
+            val function = visitQualifiedName(ctx.qualifiedName())
             return exprCall(function, args)
         }
 
-        override fun visitFunctionName(ctx: GeneratedParser.FunctionNameContext): Identifier {
-            val path = ctx.qualifier.map { visitSymbolPrimitive(it) }
-            val name = when (ctx.name.start.type) {
-                GeneratedParser.CHARACTER_LENGTH, GeneratedParser.CHAR_LENGTH ->
-                    identifierSymbol("char_length", Identifier.CaseSensitivity.INSENSITIVE)
-                else -> visitSymbolPrimitive(ctx.name)
-            }
-            return if (path.isEmpty()) {
-                name
-            } else {
-                val root = path.first()
-                val steps = path.drop(1) + listOf(name)
-                identifierQualified(root, steps)
-            }
-        }
-
         /**
          *
          * FUNCTIONS WITH SPECIAL FORMS