diff --git a/src/main/java/net/sf/jsqlparser/statement/create/macro/CreateMacro.java b/src/main/java/net/sf/jsqlparser/statement/create/macro/CreateMacro.java
index 11aa3f5b1..addf28daa 100644
--- a/src/main/java/net/sf/jsqlparser/statement/create/macro/CreateMacro.java
+++ b/src/main/java/net/sf/jsqlparser/statement/create/macro/CreateMacro.java
@@ -12,25 +12,37 @@
 import net.sf.jsqlparser.expression.Expression;
 import net.sf.jsqlparser.statement.Statement;
 import net.sf.jsqlparser.statement.StatementVisitor;
+import net.sf.jsqlparser.statement.create.table.ColDataType;
 import net.sf.jsqlparser.statement.select.Select;
 
 import java.io.Serializable;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Consumer;
 
 /**
- * DuckDB's {@code CREATE [OR REPLACE] [TEMPORARY] MACRO name (parameters) AS [TABLE] body}, a named
- * expression or query that is inlined at call sites.
+ * DuckDB's
+ * {@code CREATE [OR REPLACE] [TEMPORARY] {MACRO | FUNCTION} [IF NOT EXISTS] name (parameters) AS [TABLE] body [, (parameters) AS [TABLE] body ...]},
+ * a named expression or query that is inlined at call sites, optionally overloaded on its
+ * parameters.
+ *
+ * <p>
+ * {@link #getParameters()}, {@link #getExpression()} and {@link #getSelect()} and their setters
+ * address the first overload.
+ *
+ * <p>
+ * As in DuckDB, a {@code ,} after a {@code TABLE} body that ends with a list (FROM, GROUP BY, ORDER
+ * BY ...) continues that list rather than starting a new overload.
  *
  * @see <a href="https://duckdb.org/docs/stable/sql/statements/create_macro">CREATE MACRO</a>
  */
 public class CreateMacro implements Statement {
     private boolean orReplace;
     private boolean temporary;
+    private boolean functionKeyword;
+    private boolean ifNotExists;
     private String name;
-    private List<Parameter> parameters;
-    private Expression expression;
-    private Select select;
+    private List<Overload> overloads = new ArrayList<>();
 
     public boolean isOrReplace() {
         return orReplace;
@@ -58,6 +70,33 @@ public CreateMacro withTemporary(boolean temporary) {
         return this;
     }
 
+    /** Whether it was written {@code CREATE FUNCTION}, DuckDB's alias of {@code CREATE MACRO}. */
+    public boolean isFunctionKeyword() {
+        return functionKeyword;
+    }
+
+    public void setFunctionKeyword(boolean functionKeyword) {
+        this.functionKeyword = functionKeyword;
+    }
+
+    public CreateMacro withFunctionKeyword(boolean functionKeyword) {
+        setFunctionKeyword(functionKeyword);
+        return this;
+    }
+
+    public boolean isIfNotExists() {
+        return ifNotExists;
+    }
+
+    public void setIfNotExists(boolean ifNotExists) {
+        this.ifNotExists = ifNotExists;
+    }
+
+    public CreateMacro withIfNotExists(boolean ifNotExists) {
+        setIfNotExists(ifNotExists);
+        return this;
+    }
+
     public String getName() {
         return name;
     }
@@ -71,12 +110,33 @@ public CreateMacro withName(String name) {
         return this;
     }
 
+    public List<Overload> getOverloads() {
+        return overloads;
+    }
+
+    /** Copies {@code overloads}, so that the first-overload setters can add to an empty list. */
+    public void setOverloads(List<Overload> overloads) {
+        this.overloads = overloads == null ? new ArrayList<>() : new ArrayList<>(overloads);
+    }
+
+    public CreateMacro withOverloads(List<Overload> overloads) {
+        setOverloads(overloads);
+        return this;
+    }
+
+    private Overload firstOverload() {
+        if (overloads.isEmpty()) {
+            overloads.add(new Overload());
+        }
+        return overloads.get(0);
+    }
+
     public List<Parameter> getParameters() {
-        return parameters;
+        return overloads.isEmpty() ? null : overloads.get(0).getParameters();
     }
 
     public void setParameters(List<Parameter> parameters) {
-        this.parameters = parameters;
+        firstOverload().setParameters(parameters);
     }
 
     public CreateMacro withParameters(List<Parameter> parameters) {
@@ -85,11 +145,11 @@ public CreateMacro withParameters(List<Parameter> parameters) {
     }
 
     public Expression getExpression() {
-        return expression;
+        return overloads.isEmpty() ? null : overloads.get(0).getExpression();
     }
 
     public void setExpression(Expression expression) {
-        this.expression = expression;
+        firstOverload().setExpression(expression);
     }
 
     public CreateMacro withExpression(Expression expression) {
@@ -98,11 +158,11 @@ public CreateMacro withExpression(Expression expression) {
     }
 
     public Select getSelect() {
-        return select;
+        return overloads.isEmpty() ? null : overloads.get(0).getSelect();
     }
 
     public void setSelect(Select select) {
-        this.select = select;
+        firstOverload().setSelect(select);
     }
 
     public CreateMacro withSelect(Select select) {
@@ -112,7 +172,7 @@ public CreateMacro withSelect(Select select) {
 
     /** A table macro returns a relation, a scalar macro an expression. */
     public boolean isTable() {
-        return select != null;
+        return getSelect() != null;
     }
 
     public StringBuilder appendTo(StringBuilder builder) {
@@ -129,19 +189,16 @@ public StringBuilder appendTo(StringBuilder builder, Consumer<Expression> expres
         if (temporary) {
             builder.append("TEMPORARY ");
         }
-        builder.append("MACRO ").append(name).append(" (");
-        for (int i = 0; i < parameters.size(); i++) {
+        builder.append(functionKeyword ? "FUNCTION " : "MACRO ");
+        if (ifNotExists) {
+            builder.append("IF NOT EXISTS ");
+        }
+        builder.append(name).append(" ");
+        for (int i = 0; i < overloads.size(); i++) {
             if (i > 0) {
                 builder.append(", ");
             }
-            parameters.get(i).appendTo(builder, expressionRenderer);
-        }
-        builder.append(") AS ");
-        if (select != null) {
-            builder.append("TABLE ");
-            selectRenderer.accept(select);
-        } else {
-            expressionRenderer.accept(expression);
+            overloads.get(i).appendTo(builder, expressionRenderer, selectRenderer);
         }
         return builder;
     }
@@ -156,17 +213,102 @@ public <T, S> T accept(StatementVisitor<T> statementVisitor, S context) {
         return statementVisitor.visit(this, context);
     }
 
-    /** A macro parameter, optionally carrying a default value ({@code b := 5}). */
+    /** One {@code (parameters) AS [TABLE] body} of a macro. */
+    public static class Overload implements Serializable {
+        private List<Parameter> parameters = new ArrayList<>();
+        private Expression expression;
+        private Select select;
+
+        public List<Parameter> getParameters() {
+            return parameters;
+        }
+
+        public void setParameters(List<Parameter> parameters) {
+            this.parameters = parameters;
+        }
+
+        public Overload withParameters(List<Parameter> parameters) {
+            setParameters(parameters);
+            return this;
+        }
+
+        public Expression getExpression() {
+            return expression;
+        }
+
+        public void setExpression(Expression expression) {
+            this.expression = expression;
+        }
+
+        public Overload withExpression(Expression expression) {
+            setExpression(expression);
+            return this;
+        }
+
+        public Select getSelect() {
+            return select;
+        }
+
+        public void setSelect(Select select) {
+            this.select = select;
+        }
+
+        public Overload withSelect(Select select) {
+            setSelect(select);
+            return this;
+        }
+
+        /** A table overload returns a relation, a scalar one an expression. */
+        public boolean isTable() {
+            return select != null;
+        }
+
+        @Override
+        public String toString() {
+            StringBuilder builder = new StringBuilder();
+            return appendTo(builder, builder::append, builder::append).toString();
+        }
+
+        private StringBuilder appendTo(StringBuilder builder,
+                Consumer<Expression> expressionRenderer, Consumer<Select> selectRenderer) {
+            builder.append("(");
+            for (int i = 0; i < parameters.size(); i++) {
+                if (i > 0) {
+                    builder.append(", ");
+                }
+                parameters.get(i).appendTo(builder, expressionRenderer);
+            }
+            builder.append(") AS ");
+            if (select != null) {
+                builder.append("TABLE ");
+                selectRenderer.accept(select);
+            } else {
+                expressionRenderer.accept(expression);
+            }
+            return builder;
+        }
+    }
+
+    /**
+     * A macro parameter, optionally typed ({@code a INTEGER}) and carrying a default value
+     * ({@code b := 5}).
+     */
     public static class Parameter implements Serializable {
         private final String name;
+        private final ColDataType type;
         private final Expression defaultValue;
 
         public Parameter(String name) {
-            this(name, null);
+            this(name, null, null);
         }
 
         public Parameter(String name, Expression defaultValue) {
+            this(name, null, defaultValue);
+        }
+
+        public Parameter(String name, ColDataType type, Expression defaultValue) {
             this.name = name;
+            this.type = type;
             this.defaultValue = defaultValue;
         }
 
@@ -174,6 +316,10 @@ public String getName() {
             return name;
         }
 
+        public ColDataType getType() {
+            return type;
+        }
+
         public Expression getDefaultValue() {
             return defaultValue;
         }
@@ -187,6 +333,9 @@ public String toString() {
         private StringBuilder appendTo(StringBuilder builder,
                 Consumer<Expression> expressionRenderer) {
             builder.append(name);
+            if (type != null) {
+                builder.append(" ").append(type);
+            }
             if (defaultValue != null) {
                 builder.append(" := ");
                 expressionRenderer.accept(defaultValue);
diff --git a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
index 0741d1e4d..728301e04 100644
--- a/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
+++ b/src/main/java/net/sf/jsqlparser/util/TablesNamesFinder.java
@@ -2722,8 +2722,10 @@ public void visit(CopyStatement copyStatement) {
 
     @Override
     public <S> Void visit(CreateMacro createMacro, S context) {
-        if (createMacro.getSelect() != null) {
-            createMacro.getSelect().accept((SelectVisitor<?>) this, context);
+        for (CreateMacro.Overload overload : createMacro.getOverloads()) {
+            if (overload.getSelect() != null) {
+                overload.getSelect().accept((SelectVisitor<?>) this, context);
+            }
         }
         return null;
     }
diff --git a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
index eb904885a..64172751a 100644
--- a/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
+++ b/src/main/jjtree/net/sf/jsqlparser/parser/JSqlParserCC.jjt
@@ -1435,6 +1435,69 @@ public class CCJSqlParser extends AbstractJSqlParser<CCJSqlParser> {
         return getToken(offset).kind == K_MACRO;
     }
 
+    /**
+     * DuckDB's FUNCTION alias of MACRO: FUNCTION [IF NOT EXISTS] name (parameters) AS body, where
+     * AS directly follows the parameters, the body is not a string and no LANGUAGE or OPTIONS
+     * clause follows it, unlike other dialects' CREATE FUNCTION (RETURNS ..., PostgreSQL's
+     * AS $tag$ ... $tag$ LANGUAGE ..., BigQuery's AS (expr) OPTIONS (...)).
+     */
+    private boolean isCreateFunctionMacroAhead() {
+        int offset = 1;
+        int kind = getToken(offset).kind;
+        if (kind == K_TEMP || kind == K_TEMPORARY) {
+            offset++;
+        }
+        if (getToken(offset).kind != K_FUNCTION) {
+            return false;
+        }
+        // IF NOT EXISTS and a qualified name, at most 8 tokens, up to the parameter list
+        int nameEnd = offset + 8;
+        offset++;
+        while (getToken(offset).kind != OPENING_BRACKET) {
+            kind = getToken(offset).kind;
+            if (offset > nameEnd || kind == EOF || kind == ST_SEMICOLON) {
+                return false;
+            }
+            offset++;
+        }
+        int depth = 0;
+        do {
+            kind = getToken(offset).kind;
+            if (kind == OPENING_BRACKET) {
+                depth++;
+            } else if (kind == CLOSING_BRACKET) {
+                depth--;
+            } else if (kind == EOF) {
+                return false;
+            }
+            offset++;
+        } while (depth > 0);
+        if (getToken(offset).kind != K_AS) {
+            return false;
+        }
+        Token body = getToken(offset + 1);
+        if (body.kind == S_CHAR_LITERAL || body.kind == S_DOLLAR_QUOTED_STRING
+                || body.image.length() > 1 && body.image.startsWith("$") && body.image.endsWith("$")) {
+            return false;
+        }
+        // no LANGUAGE or OPTIONS clause outside parentheses up to the end of the statement
+        depth = 0;
+        for (offset++;; offset++) {
+            Token token = getToken(offset);
+            if (token.kind == EOF || depth == 0 && token.kind == ST_SEMICOLON) {
+                return true;
+            }
+            if (token.kind == OPENING_BRACKET) {
+                depth++;
+            } else if (token.kind == CLOSING_BRACKET) {
+                depth--;
+            } else if (depth == 0 && ("LANGUAGE".equalsIgnoreCase(token.image)
+                    || "OPTIONS".equalsIgnoreCase(token.image))) {
+                return false;
+            }
+        }
+    }
+
     /** DuckDB sampling methods, which are ordinary identifiers except for SYSTEM/BERNOULLI. */
     private boolean isSampleMethod(Token token) {
         return token.kind == K_SYSTEM || token.kind == K_BERNOULLI
@@ -5048,41 +5111,66 @@ RenameTableStatement RenameTableStatement(): {
 }
 
 /**
- * DuckDB's CREATE [OR REPLACE] [TEMPORARY] MACRO name (parameters) AS [TABLE] body.
+ * DuckDB's CREATE [OR REPLACE] [TEMPORARY] {MACRO | FUNCTION} [IF NOT EXISTS] name
+ * (parameters) AS [TABLE] body [, (parameters) AS [TABLE] body ...].
  */
 CreateMacro CreateMacro(boolean isUsingOrReplace) #CreateMacro:
 {
     CreateMacro createMacro = new CreateMacro();
-    List<CreateMacro.Parameter> parameters = new ArrayList<CreateMacro.Parameter>();
+    List<CreateMacro.Overload> overloads = new ArrayList<CreateMacro.Overload>();
     ObjectNames name;
-    Expression expression;
-    Select select;
-    String parameterName;
-    Expression defaultValue;
+    CreateMacro.Overload overload;
 }
 {
     { createMacro.setOrReplace(isUsingOrReplace); }
     [ ( <K_TEMP> | <K_TEMPORARY> ) { createMacro.setTemporary(true); } ]
-    <K_MACRO> name=RelObjectNames() { createMacro.setName(String.join(".", name.getNames())); }
+    ( <K_MACRO> | <K_FUNCTION> { createMacro.setFunctionKeyword(true); } )
+    [ LOOKAHEAD(3) <K_IF> <K_NOT> <K_EXISTS> { createMacro.setIfNotExists(true); } ]
+    name=RelObjectNames() { createMacro.setName(String.join(".", name.getNames())); }
+    overload=MacroOverload() { overloads.add(overload); }
+    ( LOOKAHEAD(2) "," overload=MacroOverload() { overloads.add(overload); } )*
+    { createMacro.setOverloads(overloads); }
+    { return createMacro; }
+}
+
+/**
+ * One (parameters) AS [TABLE] body of a DuckDB macro, a parameter being name [type] [:= default].
+ */
+CreateMacro.Overload MacroOverload():
+{
+    CreateMacro.Overload overload = new CreateMacro.Overload();
+    List<CreateMacro.Parameter> parameters = new ArrayList<CreateMacro.Parameter>();
+    CreateMacro.Parameter parameter;
+    Expression expression;
+    Select select;
+}
+{
     "("
     [
-        parameterName=RelObjectName() { defaultValue = null; }
-        [ ":=" defaultValue=Expression() ]
-        { parameters.add(new CreateMacro.Parameter(parameterName, defaultValue)); }
-        (
-            "," parameterName=RelObjectName() { defaultValue = null; }
-            [ ":=" defaultValue=Expression() ]
-            { parameters.add(new CreateMacro.Parameter(parameterName, defaultValue)); }
-        )*
+        parameter=MacroParameter() { parameters.add(parameter); }
+        ( "," parameter=MacroParameter() { parameters.add(parameter); } )*
     ]
-    ")" { createMacro.setParameters(parameters); }
+    ")" { overload.setParameters(parameters); }
     <K_AS>
     (
-        LOOKAHEAD(2) <K_TABLE> select=Select() { createMacro.setSelect(select); }
+        LOOKAHEAD(2) <K_TABLE> select=Select() { overload.setSelect(select); }
         |
-        expression=Expression() { createMacro.setExpression(expression); }
+        expression=Expression() { overload.setExpression(expression); }
     )
-    { return createMacro; }
+    { return overload; }
+}
+
+CreateMacro.Parameter MacroParameter():
+{
+    String name;
+    ColDataType type = null;
+    Expression defaultValue = null;
+}
+{
+    name=RelObjectName()
+    [ LOOKAHEAD({ getToken(1).kind != K_COMMA && getToken(1).kind != CLOSING_BRACKET && !":=".equals(getToken(1).image) }) type=ColDataType() ]
+    [ ":=" defaultValue=Expression() ]
+    { return new CreateMacro.Parameter(name, type, defaultValue); }
 }
 
 /**
@@ -20187,6 +20275,10 @@ Statement Create():
                 || "DEFINER".equalsIgnoreCase(getToken(1).image) })
         statement = CreateTrigger()
         |
+        LOOKAHEAD({ isCreateMacroAhead() }) statement = CreateMacro(isUsingOrReplace)
+        |
+        LOOKAHEAD({ isCreateFunctionMacroAhead() }) statement = CreateMacro(isUsingOrReplace)
+        |
         statement = CreateFunctionStatement(isUsingOrReplace)
         |
         statement = CreateSchema()
@@ -20198,8 +20290,6 @@ Statement Create():
         |
         statement = CreateSynonym(isUsingOrReplace)
         |
-        LOOKAHEAD({ isCreateMacroAhead() }) statement = CreateMacro(isUsingOrReplace)
-        |
         LOOKAHEAD(3) statement = CreateTable(isUsingOrReplace)
         |
         LOOKAHEAD(2) statement = CreateView(isUsingOrReplace)
diff --git a/src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java b/src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java
index a18c26665..fbc09b52c 100644
--- a/src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java
+++ b/src/test/java/net/sf/jsqlparser/statement/select/DuckDBTest.java
@@ -12,6 +12,7 @@
 import net.sf.jsqlparser.JSQLParserException;
 import net.sf.jsqlparser.expression.Function;
 import net.sf.jsqlparser.expression.LambdaExpression;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
 import net.sf.jsqlparser.schema.Table;
 import net.sf.jsqlparser.statement.create.table.CreateTable;
 import net.sf.jsqlparser.statement.insert.Insert;
@@ -25,14 +26,17 @@
 import net.sf.jsqlparser.statement.PrepareStatement;
 import net.sf.jsqlparser.statement.DeallocateStatement;
 import net.sf.jsqlparser.statement.CopyStatement;
+import net.sf.jsqlparser.statement.create.function.CreateFunction;
 import net.sf.jsqlparser.statement.create.macro.CreateMacro;
 import net.sf.jsqlparser.statement.create.extension.CreateExtensionRepository;
 import net.sf.jsqlparser.statement.create.trigger.CreateTrigger;
 import net.sf.jsqlparser.test.TestUtils;
+import net.sf.jsqlparser.util.TablesNamesFinder;
 import org.junit.jupiter.api.Assertions;
 import org.junit.jupiter.api.Test;
 
 import java.util.Arrays;
+import java.util.HashSet;
 
 public class DuckDBTest {
 
@@ -506,6 +510,82 @@ void testCreateTableMacro() throws JSQLParserException {
         Assertions.assertNotNull(createMacro.getSelect());
     }
 
+    @Test
+    void testCreateMacroIfNotExists() throws JSQLParserException {
+        String sqlStr = "CREATE MACRO IF NOT EXISTS add(a, b) AS a + b";
+        CreateMacro createMacro =
+                (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+
+        Assertions.assertTrue(createMacro.isIfNotExists());
+        Assertions.assertEquals("add", createMacro.getName());
+    }
+
+    @Test
+    void testCreateMacroWithTypedParameters() throws JSQLParserException {
+        String sqlStr = "CREATE MACRO add(a INTEGER, b DOUBLE, c := 5) AS a + b + c";
+        CreateMacro createMacro =
+                (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+
+        Assertions.assertEquals("INTEGER", createMacro.getParameters().get(0).getType().toString());
+        Assertions.assertEquals("DOUBLE", createMacro.getParameters().get(1).getType().toString());
+        Assertions.assertNull(createMacro.getParameters().get(2).getType());
+        Assertions.assertEquals("5",
+                createMacro.getParameters().get(2).getDefaultValue().toString());
+    }
+
+    @Test
+    void testCreateOverloadedMacro() throws JSQLParserException {
+        String sqlStr = "CREATE OR REPLACE MACRO is_maximal(a TINYINT) AS a = 127, "
+                + "(a INT) AS a = 2147483647";
+        CreateMacro createMacro =
+                (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+
+        Assertions.assertEquals(2, createMacro.getOverloads().size());
+        Assertions.assertEquals("TINYINT",
+                createMacro.getOverloads().get(0).getParameters().get(0).getType().toString());
+        Assertions.assertEquals("a = 2147483647",
+                createMacro.getOverloads().get(1).getExpression().toString());
+    }
+
+    @Test
+    void testCreateOverloadedTableMacro() throws JSQLParserException {
+        String sqlStr = "CREATE MACRO get_t(i) AS TABLE SELECT * FROM t WHERE id = i, "
+                + "(i, j) AS TABLE SELECT * FROM u WHERE id = i AND x = j";
+        CreateMacro createMacro =
+                (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+
+        Assertions.assertEquals(2, createMacro.getOverloads().size());
+        Assertions.assertTrue(createMacro.getOverloads().get(1).isTable());
+        Assertions.assertEquals(2, createMacro.getOverloads().get(1).getParameters().size());
+        Assertions.assertEquals(new HashSet<>(Arrays.asList("t", "u")),
+                TablesNamesFinder.findTables(sqlStr));
+    }
+
+    @Test
+    void testCreateFunctionAsMacro() throws JSQLParserException {
+        for (String sqlStr : Arrays.asList(
+                "CREATE FUNCTION add(a, b) AS a + b",
+                "CREATE OR REPLACE TEMPORARY FUNCTION IF NOT EXISTS add(a INTEGER) AS a + 1",
+                "CREATE FUNCTION get_t(i) AS TABLE SELECT * FROM t WHERE id = i")) {
+            CreateMacro createMacro =
+                    (CreateMacro) TestUtils.assertSqlCanBeParsedAndDeparsed(sqlStr, true);
+
+            Assertions.assertTrue(createMacro.isFunctionKeyword());
+        }
+    }
+
+    @Test
+    void testCreateFunctionOfOtherDialectsIsNotAMacro() throws JSQLParserException {
+        for (String sqlStr : Arrays.asList(
+                "CREATE FUNCTION add(a integer, b integer) RETURNS integer AS 'select $1 + $2' LANGUAGE SQL",
+                "CREATE FUNCTION add(IN a integer, OUT b integer) AS 'select $1 + 1' LANGUAGE SQL",
+                "CREATE FUNCTION add(IN a integer, OUT b integer) AS $$ select $1 + 1 $$ LANGUAGE SQL",
+                "CREATE FUNCTION add(IN a integer, OUT b integer) AS $function$ select $1 + 1 $function$ LANGUAGE SQL",
+                "CREATE OR REPLACE FUNCTION ds.add(x INT64) AS (x + 1) OPTIONS (description = 'd')")) {
+            Assertions.assertInstanceOf(CreateFunction.class, CCJSqlParserUtil.parse(sqlStr));
+        }
+    }
+
     @Test
     void testCreateExtensionRepository() throws JSQLParserException {
         String sqlStr =