From f5d3cd80ca00f1e1a3a8f3fe7941b8aa8820e2ca Mon Sep 17 00:00:00 2001
From: dssysolyatin <dm.sysolyatin@gmail.com>
Date: Thu, 6 Apr 2023 17:01:25 +0300
Subject: [PATCH] [CALCITE-5612] Babel parser should support PostgreSQL's SET
 TRANSACTION command

---
 babel/src/main/codegen/config.fmpp            |  29 +-
 .../codegen/includes/parserPostgresImpls.ftl  | 337 ++++++++++++++++++
 .../includes/parserPostgresqlImpls.ftl        | 264 --------------
 .../{postgresql => postgres}/SqlBegin.java    |  41 +--
 .../{postgresql => postgres}/SqlCommit.java   |  23 +-
 .../{postgresql => postgres}/SqlDiscard.java  |  22 +-
 .../{postgresql => postgres}/SqlRollback.java |  23 +-
 .../sql/babel/postgres/SqlSetOptions.java     |  72 ++++
 .../{postgresql => postgres}/SqlShow.java     |  23 +-
 .../TransactionChainingMode.java}             |   4 +-
 .../sql/babel/postgres/TransactionMode.java   |  37 ++
 .../package-info.java                         |   2 +-
 .../apache/calcite/test/BabelParserTest.java  |  71 +++-
 core/src/main/codegen/default_config.fmpp     |   3 +
 core/src/main/codegen/templates/Parser.jj     |   9 +-
 .../java/org/apache/calcite/sql/SqlAlter.java |   2 +-
 .../apache/calcite/sql/SqlBasicFunction.java  |   2 +-
 .../org/apache/calcite/sql/SqlDialect.java    |  32 ++
 .../org/apache/calcite/sql/SqlOperator.java   |  40 ++-
 .../org/apache/calcite/sql/SqlSetOption.java  |  68 +++-
 .../sql/dialect/PostgresqlSqlDialect.java     |  39 ++
 .../calcite/sql/fun/SqlBasicOperator.java     |  63 ++++
 .../calcite/sql/fun/SqlCallFactories.java     |  38 ++
 .../calcite/sql/fun/SqlCallFactory.java       |  48 +++
 .../calcite/sql/fun/SqlStdOperatorTable.java  |   2 +-
 .../calcite/sql/SqlSetOptionOperatorTest.java |   2 +-
 site/_docs/babel_reference.md                 | 139 ++++++++
 .../calcite/sql/parser/SqlParserTest.java     |   4 +-
 28 files changed, 1010 insertions(+), 429 deletions(-)
 create mode 100644 babel/src/main/codegen/includes/parserPostgresImpls.ftl
 delete mode 100644 babel/src/main/codegen/includes/parserPostgresqlImpls.ftl
 rename babel/src/main/java/org/apache/calcite/sql/babel/{postgresql => postgres}/SqlBegin.java (62%)
 rename babel/src/main/java/org/apache/calcite/sql/babel/{postgresql => postgres}/SqlCommit.java (71%)
 rename babel/src/main/java/org/apache/calcite/sql/babel/{postgresql => postgres}/SqlDiscard.java (72%)
 rename babel/src/main/java/org/apache/calcite/sql/babel/{postgresql => postgres}/SqlRollback.java (71%)
 create mode 100644 babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlSetOptions.java
 rename babel/src/main/java/org/apache/calcite/sql/babel/{postgresql => postgres}/SqlShow.java (72%)
 rename babel/src/main/java/org/apache/calcite/sql/babel/{postgresql/AndChain.java => postgres/TransactionChainingMode.java} (92%)
 create mode 100644 babel/src/main/java/org/apache/calcite/sql/babel/postgres/TransactionMode.java
 rename babel/src/main/java/org/apache/calcite/sql/babel/{postgresql => postgres}/package-info.java (94%)
 create mode 100644 core/src/main/java/org/apache/calcite/sql/fun/SqlBasicOperator.java
 create mode 100644 core/src/main/java/org/apache/calcite/sql/fun/SqlCallFactories.java
 create mode 100644 core/src/main/java/org/apache/calcite/sql/fun/SqlCallFactory.java
 create mode 100644 site/_docs/babel_reference.md

diff --git a/babel/src/main/codegen/config.fmpp b/babel/src/main/codegen/config.fmpp
index bf5895c7c7d..981768ba9d3 100644
--- a/babel/src/main/codegen/config.fmpp
+++ b/babel/src/main/codegen/config.fmpp
@@ -30,12 +30,14 @@ data: {
       "org.apache.calcite.sql.SqlCreate",
       "org.apache.calcite.sql.babel.SqlBabelCreateTable",
       "org.apache.calcite.sql.babel.TableCollectionType",
-      "org.apache.calcite.sql.babel.postgresql.AndChain",
-      "org.apache.calcite.sql.babel.postgresql.SqlBegin",
-      "org.apache.calcite.sql.babel.postgresql.SqlCommit",
-      "org.apache.calcite.sql.babel.postgresql.SqlDiscard",
-      "org.apache.calcite.sql.babel.postgresql.SqlRollback",
-      "org.apache.calcite.sql.babel.postgresql.SqlShow",
+      "org.apache.calcite.sql.babel.postgres.TransactionMode",
+      "org.apache.calcite.sql.babel.postgres.TransactionChainingMode",
+      "org.apache.calcite.sql.babel.postgres.SqlBegin",
+      "org.apache.calcite.sql.babel.postgres.SqlCommit",
+      "org.apache.calcite.sql.babel.postgres.SqlDiscard",
+      "org.apache.calcite.sql.babel.postgres.SqlRollback",
+      "org.apache.calcite.sql.babel.postgres.SqlShow",
+      "org.apache.calcite.sql.babel.postgres.SqlSetOptions",
       "org.apache.calcite.sql.ddl.SqlDdlNodes",
     ]
 
@@ -49,6 +51,7 @@ data: {
       "SEED"
       "SEMI"
       "SEQUENCES"
+      "SNAPSHOT"
       "TEMP"
       "VOLATILE"
     ]
@@ -567,12 +570,11 @@ data: {
     ]
 
     statementParserMethods: [
-      "PostgresqlSqlShow()",
-      "PostgresqlSqlSetOption()",
-      "PostgresqlSqlBegin()",
-      "PostgresqlSqlDiscard()",
-      "PostgresqlSqlCommit()",
-      "PostgresqlSqlRollback()"
+      "PostgresSqlBegin()"
+      "PostgresSqlCommit()"
+      "PostgresSqlDiscard()"
+      "PostgresSqlRollback()"
+      "PostgresSqlShow()"
     ]
 
     # Binary operators tokens.
@@ -608,9 +610,10 @@ data: {
     # Example: "parserImpls.ftl".
     implementationFiles: [
       "parserImpls.ftl"
-      "parserPostgresqlImpls.ftl"
+      "parserPostgresImpls.ftl"
     ]
 
+    setOptionParserMethod: "PostgresSqlSetOption"
     includePosixOperators: true
     includeParsingStringLiteralAsArrayLiteral: true
   }
diff --git a/babel/src/main/codegen/includes/parserPostgresImpls.ftl b/babel/src/main/codegen/includes/parserPostgresImpls.ftl
new file mode 100644
index 00000000000..f0fe683099e
--- /dev/null
+++ b/babel/src/main/codegen/includes/parserPostgresImpls.ftl
@@ -0,0 +1,337 @@
+<#--
+// Licensed to the Apache Software Foundation (ASF) under one or more
+// contributor license agreements.  See the NOTICE file distributed with
+// this work for additional information regarding copyright ownership.
+// The ASF licenses this file to you under the Apache License, Version 2.0
+// (the "License"); you may not use this file except in compliance with
+// the License.  You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+-->
+
+/**
+ * <blockquote><pre>
+ *    SHOW ALL
+ *    SHOW TIME ZONE
+ *    SHOW TRANSACTION ISOLATION LEVEL
+ *    SHOW SESSION AUTHORIZATION
+ *    SHOW Identifier()
+ * </pre></blockquote>
+ *
+ * @see <a href="https://www.postgresql.org/docs/current/sql-show.html">
+ * PostgreSQL SHOW documentation</a>
+ * @see <a href="https://github.com/postgres/postgres/blob/master/src/backend/parser/gram.y">
+ * PostgreSQL grammar file (VariableShowStmt) </a>
+ */
+SqlNode PostgresSqlShow() :
+{
+    final String name;
+    final Span s;
+}
+{
+    <SHOW> { s = span(); }
+    (   <ALL> { name = "all"; }
+    |   <TIME> <ZONE> { name = "timezone"; }
+    |   <TRANSACTION> <ISOLATION> <LEVEL> { name = "transaction_isolation"; }
+    |   <SESSION> <AUTHORIZATION> { name = "session_authorization"; }
+    |   name = Identifier()
+    ) {
+        return SqlShow.OPERATOR.createCall(null, s.end(this), new SqlIdentifier(name, getPos()));
+    }
+}
+
+/**
+ * <blockquote><pre>
+ *    SET { SESSION | LOCAL } configuration_parameter { TO | = } { value | DEFAULT }
+ *    SET { SESSION | LOCAL } TIME ZONE { value | LOCAL | DEFAULT }
+ *    SET { SESSION | LOCAL } (SCHEMA | NAMES | SEED) value
+ *    SET { SESSION | LOCAL } TRANSACTION transaction_mode [, ...]
+ *    SET { SESSION | LOCAL } TRANSACTION SNAPSHOT snapshot_id
+ *    SET { SESSION | LOCAL } SESSION CHARACTERISTICS AS TRANSACTION transaction_mode [, ...]
+ *    SET { SESSION | LOCAL } SESSION AUTHORIZATION
+ *    SET { SESSION | LOCAL } ROLE role_name
+ *    SET { SESSION | LOCAL } ROLE NONE
+ *    RESET ALL
+ *    RESET SESSION AUTHORIZATION
+ *    RESET TIME ZONE
+ *    RESET TRANSACTION ISOLATION LEVEL
+ *    RESET CompoundIdentifier()
+ *
+ *    value - Values can be specified as string constants, identifiers, numbers, or
+ *    comma-separated lists of these
+ *
+ *    transaction_mode is one of:
+ *         ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
+ *         READ WRITE | READ ONLY
+ *         [ NOT ] DEFERRABLE
+ * </blockquote></pre>
+ *
+ * @see <a href="https://www.postgresql.org/docs/current/sql-set.html">
+ * PostgreSQL SET documentation</a>
+ * @see <a href="https://www.postgresql.org/docs/current/sql-reset.html">
+ * PostgreSQL RESET documentation</a>
+ * @see <a href="https://www.postgresql.org/docs/current/sql-set-role.html">
+ * PostgreSQL SET ROLE documentation</a>
+ * @see <a href="https://www.postgresql.org/docs/current/sql-set-transaction.html">
+ * PostgreSQL SET TRANSACTION documentation</a>
+ * @see <a href="https://www.postgresql.org/docs/current/sql-set-session-authorization.html">
+ * PostgreSQL SET SESSION AUTHORIZATION documentation</a>
+ * @see <a href="https://github.com/postgres/postgres/blob/master/src/backend/parser/gram.y">
+ * PostgreSQL grammar file (VariableSetStmt, VariableResetStmt) </a>
+ */
+SqlAlter PostgresSqlSetOption(Span s, String scope) :
+{
+    final SqlAlter node;
+}
+{
+
+    { s.add(this); }
+    (
+        <SET>
+        (   LOOKAHEAD(2) node = PostgresSqlSetParameter(s, scope)
+        |   <SESSION> { scope = token.image.toUpperCase(Locale.ROOT); } node = PostgresSqlSetParameter(s, scope)
+        |   <LOCAL> { scope = token.image.toUpperCase(Locale.ROOT); } node = PostgresSqlSetParameter(s, scope)
+        )
+    |   node = PostgresSqlResetParameter(s, scope)
+    ) {
+        return node;
+    }
+}
+
+SqlAlter PostgresSqlSetParameter(Span s, String scope) :
+{
+    SqlNode name;
+    final SqlNode val;
+}
+{
+    (
+        <SESSION>
+        (
+            <CHARACTERISTICS> <AS> <TRANSACTION> {
+                name = SqlSetOptions.Names.SESSION_CHARACTERISTICS_AS_TRANSACTION.symbol(getPos());
+            } val = PostgresSqlTransactionModeList()
+        |
+            <AUTHORIZATION> {
+                name = new SqlIdentifier("session_authorization", getPos());
+            } val = PostgresSqlOptionValue()
+        )
+    |
+        <TRANSACTION>
+            (
+                <SNAPSHOT> val = PostgresSqlOptionValues() {
+                    name = SqlSetOptions.Names.TRANSACTION_SNAPSHOT.symbol(getPos());
+                }
+            |
+                val = PostgresSqlTransactionModeList() {
+                    name = SqlSetOptions.Names.TRANSACTION.symbol(getPos());
+                }
+            )
+    |
+        <TIME> <ZONE> { name = SqlSetOptions.Names.TIME_ZONE.symbol(getPos()); }
+        (   val = Default()
+        |   <LOCAL> { val = SqlSetOptions.Values.LOCAL.symbol(getPos()); }
+        |   val = Literal()
+        )
+    |
+        <ROLE> { name = SqlSetOptions.Names.ROLE.symbol(getPos()); }
+        (   <NONE> { val = SqlSetOptions.Values.NONE.symbol(getPos()); }
+        |   val = PostgresSqlOptionValue()
+        )
+    |
+        (   name = CompoundIdentifier() ( <EQ> | <TO> )
+        |   <SCHEMA> { name = new SqlIdentifier("search_path", getPos()); }
+        |   <NAMES> { name = new SqlIdentifier("client_encoding", getPos()); }
+        |   <SEED> { name = new SqlIdentifier("seed", getPos()); }
+        ) val = PostgresSqlOptionValues()
+    ) {
+        return new SqlSetOption(s.end(val), scope, name, val);
+    }
+}
+
+SqlAlter PostgresSqlResetParameter(Span s, String scope) :
+{
+    SqlNode name;
+    SqlNode value;
+}
+{
+    <RESET> { s.add(this); }
+    (   <ALL> { name = SqlSetOptions.Names.ALL.symbol(getPos()); }
+    |   <SESSION> <AUTHORIZATION> { name = new SqlIdentifier("session_authorization", getPos()); }
+    |   <TIME> <ZONE> { name = new SqlIdentifier("timezone", getPos()); }
+    |   <TRANSACTION> <ISOLATION> <LEVEL> { name = new SqlIdentifier("transaction_isolation", getPos()); }
+    |   name = CompoundIdentifier()
+    ) {
+        return new SqlSetOption(s.end(name), scope, name, null);
+    }
+}
+
+SqlNode PostgresSqlOptionValues() :
+{
+    final List<SqlNode> list;
+    Span s;
+    SqlNode e;
+}
+{
+    e = PostgresSqlOptionValue() { s = span(); list = startList(e); }
+    ( <COMMA> e = PostgresSqlOptionValue() { list.add(e); } )*
+    { return list.size() > 1 ? new SqlNodeList(list, s.end(this)) : e; }
+}
+
+SqlNode PostgresSqlOptionValue() :
+{
+    final SqlNode val;
+}
+{
+    (   val = Default()
+    |   val = Literal()
+    |   val = SimpleIdentifier()
+    |   <ON> {
+            // OFF is handled by SimpleIdentifier, ON handled here.
+            val = new SqlIdentifier(token.image.toUpperCase(Locale.ROOT), getPos());
+        }
+    ) {
+        return val;
+    }
+}
+
+/**
+ * <blockquote><pre>
+ *    DISCARD { ALL | PLANS | SEQUENCES | TEMPORARY | TEMP }
+ * </blockquote></pre>
+ *
+ * @see <a href="https://www.postgresql.org/docs/current/sql-discard.html">
+ * PostgreSQL DISCARD documentation</a>
+ */
+SqlNode PostgresSqlDiscard() :
+{
+    final Span s;
+}
+{
+    { s = span(); }
+    <DISCARD> ( <ALL> | <PLANS> | <SEQUENCES> | <TEMPORARY> | <TEMP> ) {
+        return SqlDiscard.OPERATOR.createCall(s.end(this), new SqlIdentifier(
+            token.image.toUpperCase(Locale.ROOT), getPos()));
+    }
+}
+
+/**
+ * <blockquote><pre>
+ *     BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]
+ *     where transaction_mode is one of:
+ *         ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
+ *         READ WRITE | READ ONLY
+ *         [ NOT ] DEFERRABLE
+ * </blockquote></pre>
+ *
+ * @see <a href="https://www.postgresql.org/docs/current/sql-begin.html">
+ * PostgreSQL BEGIN documentation</a>
+ */
+SqlNode PostgresSqlBegin() :
+{
+    final Span s;
+    SqlNodeList transactionModeList = SqlNodeList.EMPTY;
+}
+{
+    { s = span(); }
+    <BEGIN> [ ( <WORK> | <TRANSACTION> ) ] [ transactionModeList = PostgresSqlTransactionModeList() ] {
+        return SqlBegin.OPERATOR.createCall(s.end(this), (SqlNode) transactionModeList);
+    }
+}
+
+SqlNodeList PostgresSqlTransactionModeList() :
+{
+    final List<SqlNode> list;
+    Span s;
+    SqlNode e;
+}
+{
+    { s = span(); }
+    e = PostgresSqlTransactionMode() { s = span(); list = startList(e); }
+    ( <COMMA> e = PostgresSqlTransactionMode() { list.add(e); } )*
+    { return new SqlNodeList(list, s.end(this)); }
+}
+
+SqlNode PostgresSqlTransactionMode() :
+{
+    final Span s;
+    TransactionMode m;
+}
+{
+    { s = span(); }
+    (   <READ>
+        (   <WRITE> { m = TransactionMode.READ_WRITE; }
+        |   <ONLY>  { m = TransactionMode.READ_ONLY; }
+        )
+    |   <DEFERRABLE> { m = TransactionMode.DEFERRABLE; }
+    |   <NOT> <DEFERRABLE> { m = TransactionMode.NOT_DEFERRABLE; }
+    |   <ISOLATION> <LEVEL>
+        (   <SERIALIZABLE> { m = TransactionMode.ISOLATION_LEVEL_SERIALIZABLE; }
+        |   <REPEATABLE> <READ> { m = TransactionMode.ISOLATION_LEVEL_REPEATABLE_READ; }
+        |   <READ>
+            (   <COMMITTED> { m = TransactionMode.ISOLATION_LEVEL_READ_COMMITTED; }
+            |   <UNCOMMITTED>  { m = TransactionMode.ISOLATION_LEVEL_READ_UNCOMMITTED; }
+            )
+        )
+    ) {
+        return m.symbol(s.end(this));
+    }
+}
+
+/**
+ * <blockquote><pre>
+ *     COMMIT [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]
+ * </blockquote></pre>
+ *
+ * @see <a href="https://www.postgresql.org/docs/current/sql-commit.html">
+ * PostgreSQL COMMIT documentation</a>
+ */
+SqlNode PostgresSqlCommit() :
+{
+    final Span s;
+    TransactionChainingMode chainingMode = TransactionChainingMode.AND_NO_CHAIN;
+}
+{
+    { s = span(); }
+    <COMMIT> [ <WORK> | <TRANSACTION> ] [ chainingMode = PostgresTransactionChainingMode() ] {
+        final SqlParserPos pos = s.end(this);
+        return SqlCommit.OPERATOR.createCall(pos, chainingMode.symbol(pos));
+    }
+}
+
+/**
+ * <blockquote><pre>
+ *     ROLLBACK [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ]
+ * </blockquote></pre>
+ *
+ * @see <a href="https://www.postgresql.org/docs/current/sql-rollback.html">
+ * PostgreSQL ROLLBACK documentation</a>
+ */
+SqlNode PostgresSqlRollback() :
+{
+    final Span s;
+    TransactionChainingMode chainingMode = TransactionChainingMode.AND_NO_CHAIN;
+}
+{
+    { s = span(); }
+    <ROLLBACK> [ <WORK> | <TRANSACTION> ] [ chainingMode = PostgresTransactionChainingMode() ] {
+        final SqlParserPos pos = s.end(this);
+        return SqlRollback.OPERATOR.createCall(pos, chainingMode.symbol(pos));
+    }
+}
+
+TransactionChainingMode PostgresTransactionChainingMode() :
+{
+    TransactionChainingMode chainingMode = TransactionChainingMode.AND_NO_CHAIN;
+}
+{
+    (   <AND> <CHAIN> { chainingMode = TransactionChainingMode.AND_CHAIN; }
+    |   <AND> <NO> <CHAIN>
+    )
+    { return chainingMode; }
+}
diff --git a/babel/src/main/codegen/includes/parserPostgresqlImpls.ftl b/babel/src/main/codegen/includes/parserPostgresqlImpls.ftl
deleted file mode 100644
index 630e6a29988..00000000000
--- a/babel/src/main/codegen/includes/parserPostgresqlImpls.ftl
+++ /dev/null
@@ -1,264 +0,0 @@
-<#--
-// Licensed to the Apache Software Foundation (ASF) under one or more
-// contributor license agreements.  See the NOTICE file distributed with
-// this work for additional information regarding copyright ownership.
-// The ASF licenses this file to you under the Apache License, Version 2.0
-// (the "License"); you may not use this file except in compliance with
-// the License.  You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
--->
-
-/** SHOW (<TRANSACTION ISOLATION LEVEL> | name) */
-SqlNode PostgresqlSqlShow() :
-{
-    final SqlIdentifier parameter;
-    final Span s;
-}
-{
-    <SHOW> { s = span(); }
-  (
-      parameter = PostgresqlTransactionIsolationLevel()
-|
-      <IDENTIFIER> {
-          parameter = new SqlIdentifier(token.image.toLowerCase(Locale.ROOT), getPos());
-      }
-  ) { return SqlShow.OPERATOR.createCall(null, s.end(this), parameter); }
-}
-
-SqlIdentifier PostgresqlTransactionIsolationLevel() :
-{
-    final Span s;
-}
-{
-  { s = span(); } <TRANSACTION> <ISOLATION> <LEVEL> {
-    return new SqlIdentifier("transaction_isolation", s.end(this));
-  }
-}
-
-/**
- * SET [ SESSION | LOCAL ] configuration_parameter { TO | = } { value | 'value' | DEFAULT }
- * SET [ SESSION | LOCAL ] TIME ZONE { value | 'value' | LOCAL | DEFAULT }
- * SET [ SESSION | LOCAL ] (SCHEMA | NAMES | SEED) value
- * value - Values can be specified as string constants, identifiers, numbers, or comma-separated lists of these
- */
-SqlNode PostgresqlSqlSetOption() :
-{
-    SqlIdentifier name;
-    final SqlNode val;
-    String scope = null;
-    Span s;
-}
-{
-    { s = span(); }
-    (
-        <SET> {
-            s.add(this);
-        }
-        [ scope = PostgresqlOptionScope() ]
-        (
-          <TIME> <ZONE> { name = new SqlIdentifier("timezone", getPos()); }
-          (
-            val = Default()
-          |
-            <LOCAL> { val = SqlLiteral.createCharString("LOCAL", getPos()); }
-          |
-            val = Literal()
-          )
-        |
-          (
-              <SCHEMA> { name = new SqlIdentifier("search_path", getPos()); }
-            |
-              <NAMES> { name = new SqlIdentifier("client_encoding", getPos()); }
-            |
-              <SEED> { name = new SqlIdentifier("seed", getPos()); }
-            |
-              name = CompoundIdentifier()
-              ( <EQ> | <TO> )
-          )
-          val = PostgresqlSqlOptionValues()
-        ){
-          return new SqlSetOption(s.end(val), scope, name, val);
-        }
-
-    |
-        <RESET> {
-            s.add(this);
-        }
-        (
-            name = CompoundIdentifier()
-        |
-            <ALL> {
-                name = new SqlIdentifier(token.image.toUpperCase(Locale.ROOT),
-                    getPos());
-            }
-        )
-        {
-            return new SqlSetOption(s.end(name), scope, name, null);
-        }
-    )
-}
-
-String PostgresqlOptionScope() :
-{
-}
-{
-    ( <LOCAL> | <SESSION> ) { return token.image.toUpperCase(Locale.ROOT); }
-}
-
-SqlNode PostgresqlSqlOptionValues():
-{
-  final List<SqlNode> list;
-  Span s;
-  SqlNode e;
-}
-{
-   e = PostgresqlSqlOptionValue() { s = span(); list = startList(e); }
-   ( <COMMA> e = PostgresqlSqlOptionValue() { list.add(e); } )*
-   {
-      return list.size() > 1 ? new SqlNodeList(list, s.end(this)) : e;
-   }
-}
-
-SqlNode PostgresqlSqlOptionValue():
-{
-  final SqlNode val;
-}
-{
-  (
-      val = Default()
-  |
-      val = Literal()
-  |
-      val = SimpleIdentifier()
-  ) {
-    return val;
-  }
-}
-
-/** DISCARD { ALL | PLANS | SEQUENCES | TEMPORARY | TEMP } */
-SqlNode PostgresqlSqlDiscard() :
-{
-  final Span s;
-}
-{
-  { s = span(); }
-   <DISCARD> ( <ALL> | <PLANS> | <SEQUENCES> | <TEMPORARY> | <TEMP> ) {
-      return SqlDiscard.OPERATOR.createCall(s.end(this), new SqlIdentifier(
-         token.image.toUpperCase(Locale.ROOT), getPos()));
-   }
-}
-
-/**
- * BEGIN [ WORK | TRANSACTION ] [ transaction_mode [, ...] ]
- * where transaction_mode is one of:
- * ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
- * READ WRITE | READ ONLY
- * [ NOT ] DEFERRABLE
- */
-SqlNode PostgresqlSqlBegin() :
-{
-  final Span s;
-  SqlNodeList transactionModeList = SqlNodeList.EMPTY;
-}
-{
-  { s = span(); }
-  <BEGIN> [ ( <WORK> | <TRANSACTION> ) ] [transactionModeList = PostgresqlSqlBeginTransactionModeList()] {
-    return SqlBegin.OPERATOR.createCall(s.end(this), (SqlNode) transactionModeList);
-  }
-}
-
-SqlNodeList PostgresqlSqlBeginTransactionModeList():
-{
-  final List<SqlNode> list;
-  Span s;
-  SqlNode e;
-}
-{
-  { s = span(); }
-  e = PostgresqlSqlBeginTransactionMode() { s = span(); list = startList(e); }
-  ( <COMMA> e = PostgresqlSqlBeginTransactionMode() { list.add(e); } )*
-  { return new SqlNodeList(list, s.end(this)); }
-}
-
-SqlNode PostgresqlSqlBeginTransactionMode():
-{
-  final Span s;
-  SqlBegin.TransactionMode m;
-}
-{
-    { s = span(); }
-(
-    LOOKAHEAD(2)
-    <READ>
-    (
-      <WRITE> { m = SqlBegin.TransactionMode.READ_WRITE; }
-    |
-      <ONLY>  { m = SqlBegin.TransactionMode.READ_ONLY; }
-    )
-|
-    <DEFERRABLE> { m = SqlBegin.TransactionMode.DEFERRABLE; }
-|
-    <NOT> <DEFERRABLE> { m = SqlBegin.TransactionMode.NOT_DEFERRABLE; }
-|
-    <ISOLATION> <LEVEL>
-    (
-        <SERIALIZABLE> { m = SqlBegin.TransactionMode.ISOLATION_LEVEL_SERIALIZABLE; }
-    |
-        <REPEATABLE> <READ> { m = SqlBegin.TransactionMode.ISOLATION_LEVEL_REPEATABLE_READ; }
-    |
-        <READ>
-        (
-          <COMMITTED> { m = SqlBegin.TransactionMode.ISOLATION_LEVEL_READ_COMMITTED; }
-        |
-          <UNCOMMITTED>  { m = SqlBegin.TransactionMode.ISOLATION_LEVEL_READ_UNCOMMITTED; }
-        )
-    )
-) {
-    return m.symbol(s.end(this));
-  }
-}
-
-/** COMMIT [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ] */
-SqlNode PostgresqlSqlCommit():
-{
-  final Span s;
-  AndChain chain = AndChain.AND_NO_CHAIN;
-}
-{
-  { s = span(); }
-  <COMMIT> [ <WORK> | <TRANSACTION> ] [
-  (
-    <AND> <CHAIN> { chain = AndChain.AND_CHAIN; }
-  |
-    <AND> <NO> <CHAIN>
-  )] {
-    final SqlParserPos pos = s.end(this);
-    return SqlCommit.OPERATOR.createCall(pos, chain.symbol(pos));
-  }
-}
-
-/** ROLLBACK [ WORK | TRANSACTION ] [ AND [ NO ] CHAIN ] */
-SqlNode PostgresqlSqlRollback():
-{
-  final Span s;
-  AndChain chain = AndChain.AND_NO_CHAIN;
-}
-{
-  { s = span(); }
-  <ROLLBACK> [ <WORK> | <TRANSACTION> ] [
-  (
-    <AND> <CHAIN> { chain = AndChain.AND_CHAIN; }
-  |
-    <AND> <NO> <CHAIN>
-  )] {
-    final SqlParserPos pos = s.end(this);
-    return SqlRollback.OPERATOR.createCall(pos, chain.symbol(pos));
-  }
-}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlBegin.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlBegin.java
similarity index 62%
rename from babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlBegin.java
rename to babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlBegin.java
index 0036920ac84..db24bcc40a2 100644
--- a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlBegin.java
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlBegin.java
@@ -14,24 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.calcite.sql.babel.postgresql;
+package org.apache.calcite.sql.babel.postgres;
 
 import org.apache.calcite.sql.SqlCall;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlWriter;
-import org.apache.calcite.sql.Symbolizable;
+import org.apache.calcite.sql.fun.SqlBasicOperator;
 import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.ReturnTypes;
 
 import com.google.common.collect.ImmutableList;
 
-import org.checkerframework.checker.nullness.qual.Nullable;
-
 import java.util.List;
 
 /**
@@ -40,15 +34,10 @@
  * @see <a href="https://www.postgresql.org/docs/current/sql-begin.html">BEGIN specification</a>
  */
 public class SqlBegin extends SqlCall {
-  public static final SqlSpecialOperator OPERATOR =
-      new SqlSpecialOperator("BEGIN", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.BOOLEAN, null,
-          null) {
-        @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
-            final SqlParserPos pos,
-            final @Nullable SqlNode... operands) {
-          return new SqlBegin(pos, (SqlNodeList) operands[0]);
-        }
-      };
+  public static final SqlBasicOperator OPERATOR =
+      SqlBasicOperator.create("BEGIN").withCallFactory(
+          (operator, functionQualifier, pos, operands) ->
+              new SqlBegin(pos, (SqlNodeList) operands[0]));
 
   private final SqlNodeList transactionModeList;
 
@@ -69,22 +58,4 @@ protected SqlBegin(final SqlParserPos pos, final SqlNodeList transactionModeList
     writer.keyword("BEGIN");
     transactionModeList.unparse(writer, -1, -1);
   }
-
-  /**
-   * Transaction mode.
-   */
-  public enum TransactionMode implements Symbolizable {
-    READ_WRITE,
-    READ_ONLY,
-    DEFERRABLE,
-    NOT_DEFERRABLE,
-    ISOLATION_LEVEL_SERIALIZABLE,
-    ISOLATION_LEVEL_REPEATABLE_READ,
-    ISOLATION_LEVEL_READ_COMMITTED,
-    ISOLATION_LEVEL_READ_UNCOMMITTED;
-
-    @Override public String toString() {
-      return super.toString().replace("_", " ");
-    }
-  }
 }
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlCommit.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlCommit.java
similarity index 71%
rename from babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlCommit.java
rename to babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlCommit.java
index 63d0396feba..bc1c16817f9 100644
--- a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlCommit.java
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlCommit.java
@@ -14,22 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.calcite.sql.babel.postgresql;
+package org.apache.calcite.sql.babel.postgres;
 
 import org.apache.calcite.sql.SqlCall;
-import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.fun.SqlBasicOperator;
 import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.ReturnTypes;
 
 import com.google.common.collect.ImmutableList;
 
-import org.checkerframework.checker.nullness.qual.Nullable;
-
 import java.util.List;
 
 /**
@@ -39,15 +35,10 @@
  */
 public class SqlCommit extends SqlCall {
 
-  public static final SqlSpecialOperator OPERATOR =
-      new SqlSpecialOperator("COMMIT", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.BOOLEAN, null,
-          null) {
-        @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
-            final SqlParserPos pos,
-            final @Nullable SqlNode... operands) {
-          return new SqlCommit(pos, (SqlLiteral) operands[0]);
-        }
-      };
+  public static final SqlBasicOperator OPERATOR =
+      SqlBasicOperator.create("COMMIT").withCallFactory(
+          (operator, functionQualifier, pos, operands) ->
+              new SqlCommit(pos, (SqlLiteral) operands[0]));
   private final SqlLiteral chain;
 
   protected SqlCommit(final SqlParserPos pos, final SqlLiteral chain) {
@@ -65,7 +56,7 @@ protected SqlCommit(final SqlParserPos pos, final SqlLiteral chain) {
 
   @Override public void unparse(final SqlWriter writer, final int leftPrec, final int rightPrec) {
     writer.keyword("COMMIT");
-    if (this.chain.symbolValue(AndChain.class) == AndChain.AND_CHAIN) {
+    if (chain.symbolValue(TransactionChainingMode.class) == TransactionChainingMode.AND_CHAIN) {
       writer.literal("AND CHAIN");
     }
   }
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlDiscard.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlDiscard.java
similarity index 72%
rename from babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlDiscard.java
rename to babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlDiscard.java
index 1dac9a450db..f6bf52271fd 100644
--- a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlDiscard.java
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlDiscard.java
@@ -14,23 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.calcite.sql.babel.postgresql;
+package org.apache.calcite.sql.babel.postgres;
 
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlIdentifier;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.fun.SqlBasicOperator;
 import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.ReturnTypes;
 
 import com.google.common.collect.ImmutableList;
 
-import org.checkerframework.checker.nullness.qual.Nullable;
-
 import java.util.List;
 
 /**
@@ -39,15 +34,10 @@
  * @see <a href="https://www.postgresql.org/docs/current/sql-discard.html">DISCARD specification</a>
  */
 public class SqlDiscard extends SqlCall {
-  public static final SqlSpecialOperator OPERATOR =
-      new SqlSpecialOperator("DISCARD", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.BOOLEAN,
-          null, null) {
-        @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
-            final SqlParserPos pos,
-            final @Nullable SqlNode... operands) {
-          return new SqlDiscard(pos, (SqlIdentifier) operands[0]);
-        }
-      };
+  public static final SqlBasicOperator OPERATOR =
+      SqlBasicOperator.create("DISCARD").withCallFactory(
+          (operator, functionQualifier, pos, operands) ->
+              new SqlDiscard(pos, (SqlIdentifier) operands[0]));
 
   private final SqlIdentifier subcommand;
 
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlRollback.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlRollback.java
similarity index 71%
rename from babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlRollback.java
rename to babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlRollback.java
index 74ec7b8258c..1a6f463e0f4 100644
--- a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlRollback.java
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlRollback.java
@@ -14,22 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.calcite.sql.babel.postgresql;
+package org.apache.calcite.sql.babel.postgres;
 
 import org.apache.calcite.sql.SqlCall;
-import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.fun.SqlBasicOperator;
 import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.ReturnTypes;
 
 import com.google.common.collect.ImmutableList;
 
-import org.checkerframework.checker.nullness.qual.Nullable;
-
 import java.util.List;
 
 /**
@@ -39,15 +35,10 @@
  */
 public class SqlRollback extends SqlCall {
 
-  public static final SqlSpecialOperator OPERATOR =
-      new SqlSpecialOperator("ROLLBACK", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.BOOLEAN,
-          null, null) {
-        @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
-            final SqlParserPos pos,
-            final @Nullable SqlNode... operands) {
-          return new SqlRollback(pos, (SqlLiteral) operands[0]);
-        }
-      };
+  public static final SqlBasicOperator OPERATOR =
+      SqlBasicOperator.create("ROLLBACK").withCallFactory(
+          (operator, functionQualifier, pos, operands) ->
+              new SqlRollback(pos, (SqlLiteral) operands[0]));
   private final SqlLiteral chain;
 
   protected SqlRollback(final SqlParserPos pos, final SqlLiteral chain) {
@@ -65,7 +56,7 @@ protected SqlRollback(final SqlParserPos pos, final SqlLiteral chain) {
 
   @Override public void unparse(final SqlWriter writer, final int leftPrec, final int rightPrec) {
     writer.keyword("ROLLBACK");
-    if (this.chain.symbolValue(AndChain.class) == AndChain.AND_CHAIN) {
+    if (chain.symbolValue(TransactionChainingMode.class) == TransactionChainingMode.AND_CHAIN) {
       writer.literal("AND CHAIN");
     }
   }
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlSetOptions.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlSetOptions.java
new file mode 100644
index 00000000000..cbddfbfd406
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlSetOptions.java
@@ -0,0 +1,72 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.babel.postgres;
+
+import org.apache.calcite.sql.Symbolizable;
+
+/**
+ * Contains enums convertible to {@link org.apache.calcite.sql.SqlLiteral}, used for
+ * {@link org.apache.calcite.sql.SqlSetOption#name} and
+ * {@link org.apache.calcite.sql.SqlSetOption#value} fields.
+ */
+public class SqlSetOptions {
+  private SqlSetOptions() {
+  }
+
+  /**
+   * {@link org.apache.calcite.sql.SqlIdentifier} can not be used
+   * as a name parameter. For example, in PostgreSQL, these two SQL commands
+   * have different meanings:
+   * <ul>
+   *   <li><code>RESET ALL</code> resets all settable run-time parameters to default values.</li>
+   *   <li><code>RESET "ALL"</code> resets parameter "ALL".</li>
+   * </ul>
+   * Using only {@link org.apache.calcite.sql.SqlIdentifier} makes
+   * it impossible to distinguish which case is being referred to.
+   * This enum has been introduced to avoid this problem.
+   */
+  public enum Names implements Symbolizable {
+    ALL,
+    TRANSACTION,
+    TRANSACTION_SNAPSHOT,
+    SESSION_CHARACTERISTICS_AS_TRANSACTION,
+    TIME_ZONE,
+    ROLE;
+
+    @Override public String toString() {
+      return super.toString().replace("_", " ");
+    }
+  }
+
+  /**
+   * Makes possible to represent NONE, LOCAL as {@link org.apache.calcite.sql.SqlLiteral}.
+   * It is needed for the following SQL statements:
+   * <ul>
+   *   <li><code>SET TIME ZONE LOCAL</code></li>
+   *   <li><code>SET ROLE NONE</code></li>
+   * </ul>
+   *
+   * @see <a href="https://www.postgresql.org/docs/current/sql-set.html">
+   * PostgreSQL SET documentation</a>
+   * @see <a href="https://www.postgresql.org/docs/current/sql-set-role.html">
+   * PostgreSQL SET ROLE documentation</a>
+   */
+  public enum Values implements Symbolizable {
+    NONE,
+    LOCAL
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlShow.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlShow.java
similarity index 72%
rename from babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlShow.java
rename to babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlShow.java
index 5587aa31e9e..ed909e0f226 100644
--- a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/SqlShow.java
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/SqlShow.java
@@ -14,23 +14,18 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.calcite.sql.babel.postgresql;
+package org.apache.calcite.sql.babel.postgres;
 
 import org.apache.calcite.sql.SqlCall;
 import org.apache.calcite.sql.SqlIdentifier;
-import org.apache.calcite.sql.SqlKind;
-import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlOperator;
-import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlWriter;
+import org.apache.calcite.sql.fun.SqlBasicOperator;
 import org.apache.calcite.sql.parser.SqlParserPos;
-import org.apache.calcite.sql.type.ReturnTypes;
 
 import com.google.common.collect.ImmutableList;
 
-import org.checkerframework.checker.nullness.qual.Nullable;
-
 import java.util.List;
 
 /**
@@ -39,16 +34,10 @@
  * @see <a href="https://www.postgresql.org/docs/current/sql-show.html">SHOW specification</a>
  */
 public class SqlShow extends SqlCall {
-  public static final SqlSpecialOperator OPERATOR =
-      new SqlSpecialOperator("SHOW", SqlKind.OTHER_FUNCTION, 32, false, ReturnTypes.VARCHAR_2000,
-          null, null) {
-    @Override public SqlCall createCall(@Nullable final SqlLiteral functionQualifier,
-        final SqlParserPos pos,
-        final @Nullable SqlNode... operands) {
-      return new SqlShow(pos, (SqlIdentifier) operands[0]);
-    }
-  };
-
+  public static final SqlBasicOperator OPERATOR =
+      SqlBasicOperator.create("SHOW").withCallFactory(
+          (operator, functionQualifier, pos, operands) ->
+              new SqlShow(pos, (SqlIdentifier) operands[0]));
   private final SqlIdentifier name;
 
   protected SqlShow(final SqlParserPos pos, SqlIdentifier name) {
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/AndChain.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/TransactionChainingMode.java
similarity index 92%
rename from babel/src/main/java/org/apache/calcite/sql/babel/postgresql/AndChain.java
rename to babel/src/main/java/org/apache/calcite/sql/babel/postgres/TransactionChainingMode.java
index f9129b5a048..eab8d76173e 100644
--- a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/AndChain.java
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/TransactionChainingMode.java
@@ -14,7 +14,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-package org.apache.calcite.sql.babel.postgresql;
+package org.apache.calcite.sql.babel.postgres;
 
 import org.apache.calcite.sql.Symbolizable;
 
@@ -26,7 +26,7 @@
  * @see <a href="https://www.postgresql.org/docs/current/sql-commit.html">COMMIT specification</a>
  * @see <a href="https://www.postgresql.org/docs/current/sql-rollback.html">ROLLBACK specification</a>
  */
-public enum AndChain implements Symbolizable {
+public enum TransactionChainingMode implements Symbolizable {
   AND_CHAIN,
   AND_NO_CHAIN;
 
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgres/TransactionMode.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/TransactionMode.java
new file mode 100644
index 00000000000..8cca014c36e
--- /dev/null
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/TransactionMode.java
@@ -0,0 +1,37 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.babel.postgres;
+
+import org.apache.calcite.sql.Symbolizable;
+
+/**
+ * Defines transaction mode keywords.
+ */
+public enum TransactionMode implements Symbolizable {
+  READ_WRITE,
+  READ_ONLY,
+  DEFERRABLE,
+  NOT_DEFERRABLE,
+  ISOLATION_LEVEL_SERIALIZABLE,
+  ISOLATION_LEVEL_REPEATABLE_READ,
+  ISOLATION_LEVEL_READ_COMMITTED,
+  ISOLATION_LEVEL_READ_UNCOMMITTED;
+
+  @Override public String toString() {
+    return super.toString().replace("_", " ");
+  }
+}
diff --git a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/package-info.java b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/package-info.java
similarity index 94%
rename from babel/src/main/java/org/apache/calcite/sql/babel/postgresql/package-info.java
rename to babel/src/main/java/org/apache/calcite/sql/babel/postgres/package-info.java
index 2362f6f4636..5d09fea82b0 100644
--- a/babel/src/main/java/org/apache/calcite/sql/babel/postgresql/package-info.java
+++ b/babel/src/main/java/org/apache/calcite/sql/babel/postgres/package-info.java
@@ -18,4 +18,4 @@
 /**
  * Parse tree for PostgreSQL extensions used by the Babel parser.
  */
-package org.apache.calcite.sql.babel.postgresql;
+package org.apache.calcite.sql.babel.postgres;
diff --git a/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java b/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
index a5faeea15fa..1b3c218ac69 100644
--- a/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
+++ b/babel/src/test/java/org/apache/calcite/test/BabelParserTest.java
@@ -358,31 +358,42 @@ private void checkParseInfixCast(String sqlType) {
         .ok("SELECT (ARRAY['a', 'b'])");
   }
 
-  @Test void testPostgresqlShow() {
+  @Test void testPostgresSqlShow() {
     SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
     f.sql("SHOW autovacuum")
         .ok("SHOW \"autovacuum\"");
+    f.sql("SHOW \"autovacuum\"")
+        .same();
+    f.sql("SHOW ALL")
+        .ok("SHOW \"all\"");
+    f.sql("SHOW TIME ZONE")
+        .ok("SHOW \"timezone\"");
+    f.sql("SHOW SESSION AUTHORIZATION")
+        .ok("SHOW \"session_authorization\"");
     f.sql("SHOW TRANSACTION ISOLATION LEVEL")
         .ok("SHOW \"transaction_isolation\"");
   }
 
-  @Test void testPostgresqlSetOption() {
+  @Test void testPostgresSqlSetOption() {
     SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
     f.sql("SET SESSION autovacuum = true")
-        .ok("ALTER SESSION SET \"autovacuum\" = TRUE");
+        .ok("SET \"autovacuum\" = TRUE");
     f.sql("SET SESSION autovacuum = DEFAULT")
-        .ok("ALTER SESSION SET \"autovacuum\" = DEFAULT");
+        .ok("SET \"autovacuum\" = DEFAULT");
     f.sql("SET LOCAL autovacuum TO 'DEFAULT'")
-        .ok("ALTER LOCAL SET \"autovacuum\" = 'DEFAULT'");
+        .ok("SET LOCAL \"autovacuum\" = 'DEFAULT'");
 
     f.sql("SET SESSION TIME ZONE DEFAULT")
-        .ok("ALTER SESSION SET \"timezone\" = DEFAULT");
+        .ok("SET TIME ZONE DEFAULT");
     f.sql("SET SESSION TIME ZONE LOCAL")
-        .ok("ALTER SESSION SET \"timezone\" = 'LOCAL'");
-    f.sql("SET TIME ZONE 'PST8PDT'")
-        .ok("SET \"timezone\" = 'PST8PDT'");
-    f.sql("SET TIME ZONE INTERVAL '-08:00' HOUR TO MINUTE")
-        .ok("SET \"timezone\" = INTERVAL '-08:00' HOUR TO MINUTE");
+        .ok("SET TIME ZONE LOCAL");
+    f.sql("SET TIME ZONE 'PST8PDT'").same();
+    f.sql("SET TIME ZONE INTERVAL '-08:00' HOUR TO MINUTE").same();
+    f.sql("SET timezone = 'PST8PDT'")
+            .ok("SET \"timezone\" = 'PST8PDT'");
+
+    f.sql("SET SESSION AUTHORIZATION DEFAULT")
+        .ok("SET \"session_authorization\" = DEFAULT");
 
     f.sql("SET search_path = public,public,\"$user\"")
         .ok("SET \"search_path\" = \"public\", \"public\", \"$user\"");
@@ -390,9 +401,39 @@ private void checkParseInfixCast(String sqlType) {
         .ok("SET \"search_path\" = \"public\", \"public\", \"$user\"");
     f.sql("SET NAMES iso_8859_15_to_utf8")
         .ok("SET \"client_encoding\" = \"iso_8859_15_to_utf8\"");
+
+    f.sql("SET TRANSACTION READ ONLY").same();
+    f.sql("SET TRANSACTION READ WRITE").same();
+    f.sql("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE").same();
+    f.sql("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ ONLY, DEFERRABLE").same();
+    f.sql("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE, READ WRITE, NOT DEFERRABLE").same();
+
+    f.sql("SET TRANSACTION SNAPSHOT '000003A1-1'").same();
+
+    f.sql("SET ROLE NONE").same();
+    f.sql("SET ROLE 'paul'").same();
   }
 
-  @Test void testPostgresqlBegin() {
+  @Test void testPostgresSqlReset() {
+    SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
+
+    // RESET ROLE, RESET SESSION AUTHORIZATION, RESET TRANSACTION ISOLATION LEVEL,
+    // and RESET TIME ZONE are simply syntactic sugar for a more unified syntax
+    // RESET "<variable_name>".
+    f.sql("RESET ALL").same();
+    f.sql("RESET ROLE")
+        .ok("RESET \"role\"");
+    f.sql("RESET SESSION AUTHORIZATION")
+        .ok("RESET \"session_authorization\"");
+    f.sql("RESET TRANSACTION ISOLATION LEVEL")
+        .ok("RESET \"transaction_isolation\"");
+    f.sql("RESET TIME ZONE")
+        .ok("RESET \"timezone\"");
+    f.sql("RESET autovacuum")
+        .ok("RESET \"autovacuum\"");
+  }
+
+  @Test void testPostgresSqlBegin() {
     SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
     f.sql("BEGIN").same();
     f.sql("BEGIN READ ONLY").same();
@@ -404,7 +445,7 @@ private void checkParseInfixCast(String sqlType) {
     f.sql("BEGIN ISOLATION LEVEL SERIALIZABLE, READ WRITE, NOT DEFERRABLE").same();
   }
 
-  @Test void testPostgresqlCommit() {
+  @Test void testPostgresSqlCommit() {
     SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
     f.sql("COMMIT").same();
     f.sql("COMMIT WORK")
@@ -416,7 +457,7 @@ private void checkParseInfixCast(String sqlType) {
     f.sql("COMMIT AND CHAIN").same();
   }
 
-  @Test void testPostgresqlRollback() {
+  @Test void testPostgresSqlRollback() {
     SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
     f.sql("ROLLBACK").same();
     f.sql("ROLLBACK WORK")
@@ -428,7 +469,7 @@ private void checkParseInfixCast(String sqlType) {
     f.sql("ROLLBACK AND CHAIN").same();
   }
 
-  @Test void testPostgresqlDiscard() {
+  @Test void testPostgresSqlDiscard() {
     SqlParserFixture f = fixture().withDialect(PostgresqlSqlDialect.DEFAULT);
     f.sql("DISCARD ALL").same();
     f.sql("DISCARD PLANS").same();
diff --git a/core/src/main/codegen/default_config.fmpp b/core/src/main/codegen/default_config.fmpp
index 5f48306c652..f3c048bd5b3 100644
--- a/core/src/main/codegen/default_config.fmpp
+++ b/core/src/main/codegen/default_config.fmpp
@@ -451,6 +451,9 @@ parser: {
   # Example: "< IDENTIFIER: (<LETTER>|<DIGIT>)+ >".
   customIdentifierToken: ""
 
+  # Method for parsing "SET [OR RESET]" calls.
+  setOptionParserMethod: "SqlSetOption"
+
   includePosixOperators: false
   includeCompoundIdentifier: true
   includeBraces: true
diff --git a/core/src/main/codegen/templates/Parser.jj b/core/src/main/codegen/templates/Parser.jj
index b26efd896e6..b25d998eb15 100644
--- a/core/src/main/codegen/templates/Parser.jj
+++ b/core/src/main/codegen/templates/Parser.jj
@@ -1145,7 +1145,7 @@ SqlNode SqlStmt() :
         LOOKAHEAD(2) stmt = ${method}
     |
 </#list>
-        stmt = SqlSetOption(Span.of(), null)
+        stmt = ${parser.setOptionParserMethod!default.parser.setOptionParserMethod}(Span.of(), null)
     |
         stmt = SqlAlter()
     |
@@ -4371,7 +4371,7 @@ SqlSetOption SqlSetOption(Span s, String scope) :
             }
         )
         {
-            return new SqlSetOption(s.end(val), scope, name, val);
+            return new SqlSetOption(s.end(val), scope, (SqlNode) name, val);
         }
     |
         <RESET> {
@@ -4386,7 +4386,7 @@ SqlSetOption SqlSetOption(Span s, String scope) :
             }
         )
         {
-            return new SqlSetOption(s.end(name), scope, name, null);
+            return new SqlSetOption(s.end(name), scope, (SqlNode) name, null);
         }
     )
 }
@@ -4410,8 +4410,7 @@ SqlAlter SqlAlter() :
         alterNode = ${method}(s, scope)
     |
 </#list>
-
-        alterNode = SqlSetOption(s, scope)
+        alterNode = ${parser.setOptionParserMethod!default.parser.setOptionParserMethod}(s, scope)
     )
     {
         return alterNode;
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlAlter.java b/core/src/main/java/org/apache/calcite/sql/SqlAlter.java
index b562dc2c215..e7f232bbc24 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlAlter.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlAlter.java
@@ -39,7 +39,7 @@ protected SqlAlter(SqlParserPos pos, @Nullable String scope) {
     this.scope = scope;
   }
 
-  @Override public final void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
+  @Override public void unparse(SqlWriter writer, int leftPrec, int rightPrec) {
     String scope = this.scope;
     if (scope != null) {
       writer.keyword("ALTER");
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlBasicFunction.java b/core/src/main/java/org/apache/calcite/sql/SqlBasicFunction.java
index ceba36579e0..980df24d4e8 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlBasicFunction.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlBasicFunction.java
@@ -42,7 +42,7 @@
  * behavior only by providing strategy objects, not by overriding methods in a
  * subclass.
  */
-public class SqlBasicFunction extends SqlFunction {
+public final class SqlBasicFunction extends SqlFunction {
   private final SqlSyntax syntax;
   private final boolean deterministic;
   private final SqlOperandHandler operandHandler;
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlDialect.java b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
index 9ebc4c383c4..81f783db978 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlDialect.java
@@ -1002,6 +1002,38 @@ public void unparseOffsetFetch(SqlWriter writer, @Nullable SqlNode offset,
   public void unparseTopN(SqlWriter writer, @Nullable SqlNode offset, @Nullable SqlNode fetch) {
   }
 
+  public void unparseSqlSetOption(SqlWriter writer,
+      int leftPrec, int rightPrec, SqlSetOption option) {
+    String scope = option.getScope();
+    if (scope != null) {
+      writer.keyword("ALTER");
+      writer.keyword(scope);
+    }
+
+    SqlNode value = option.getValue();
+    if (value != null) {
+      writer.keyword("SET");
+    } else {
+      writer.keyword("RESET");
+    }
+
+    final SqlWriter.Frame frame =
+        writer.startList(SqlWriter.FrameTypeEnum.SIMPLE);
+    SqlNode name = option.name();
+    if (name.getKind() == SqlKind.IDENTIFIER) {
+      name.unparse(writer, leftPrec, rightPrec);
+    } else {
+      new SqlIdentifier(name.toSqlString(this).getSql(), name.getParserPosition())
+          .unparse(writer, leftPrec, rightPrec);
+    }
+
+    if (value != null) {
+      writer.sep("=");
+      value.unparse(writer, leftPrec, rightPrec);
+    }
+    writer.endList(frame);
+  }
+
   /** Unparses offset/fetch using ANSI standard "OFFSET offset ROWS FETCH NEXT
    * fetch ROWS ONLY" syntax. */
   protected static void unparseFetchUsingAnsi(SqlWriter writer, @Nullable SqlNode offset,
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlOperator.java b/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
index 44d0ce9e391..318318bf420 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlOperator.java
@@ -20,6 +20,8 @@
 import org.apache.calcite.plan.Strong;
 import org.apache.calcite.rel.type.RelDataType;
 import org.apache.calcite.rel.type.RelDataTypeFactory;
+import org.apache.calcite.sql.fun.SqlCallFactories;
+import org.apache.calcite.sql.fun.SqlCallFactory;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.SqlParserPos;
 import org.apache.calcite.sql.type.SqlOperandTypeChecker;
@@ -33,7 +35,6 @@
 import org.apache.calcite.sql.validate.SqlValidatorImpl;
 import org.apache.calcite.sql.validate.SqlValidatorScope;
 import org.apache.calcite.sql.validate.SqlValidatorUtil;
-import org.apache.calcite.util.ImmutableNullableList;
 import org.apache.calcite.util.Litmus;
 import org.apache.calcite.util.Util;
 
@@ -121,6 +122,9 @@ public abstract class SqlOperator {
   /** Used to validate operand types. */
   private final @Nullable SqlOperandTypeChecker operandTypeChecker;
 
+  /** Used to create {@link org.apache.calcite.sql.SqlCall}. */
+  private final SqlCallFactory callFactory;
+
   //~ Constructors -----------------------------------------------------------
 
   /**
@@ -133,7 +137,8 @@ protected SqlOperator(
       int rightPrecedence,
       @Nullable SqlReturnTypeInference returnTypeInference,
       @Nullable SqlOperandTypeInference operandTypeInference,
-      @Nullable SqlOperandTypeChecker operandTypeChecker) {
+      @Nullable SqlOperandTypeChecker operandTypeChecker,
+      SqlCallFactory callFactory) {
     this.name = name;
     this.kind = requireNonNull(kind, "kind");
     this.leftPrec = leftPrecedence;
@@ -145,6 +150,29 @@ protected SqlOperator(
     }
     this.operandTypeInference = operandTypeInference;
     this.operandTypeChecker = operandTypeChecker;
+    this.callFactory = callFactory;
+  }
+
+  /**
+   * Creates an operator.
+   */
+  protected SqlOperator(
+      String name,
+      SqlKind kind,
+      int leftPrecedence,
+      int rightPrecedence,
+      @Nullable SqlReturnTypeInference returnTypeInference,
+      @Nullable SqlOperandTypeInference operandTypeInference,
+      @Nullable SqlOperandTypeChecker operandTypeChecker) {
+    this(
+        name,
+        kind,
+        leftPrecedence,
+        rightPrecedence,
+        returnTypeInference,
+        operandTypeInference,
+        operandTypeChecker,
+        SqlCallFactories.SQL_BASIC_CALL_FACTORY);
   }
 
   /**
@@ -241,6 +269,10 @@ public int getRightPrec() {
    */
   public abstract SqlSyntax getSyntax();
 
+  public final SqlCallFactory getSqlCallFactory() {
+    return callFactory;
+  }
+
   /**
    * Creates a call to this operator with a list of operands.
    *
@@ -273,9 +305,7 @@ public SqlCall createCall(
       @Nullable SqlLiteral functionQualifier,
       SqlParserPos pos,
       @Nullable SqlNode... operands) {
-    pos = pos.plusAll(operands);
-    return new SqlBasicCall(this, ImmutableNullableList.copyOf(operands), pos,
-        functionQualifier);
+    return callFactory.create(this, functionQualifier, pos, operands);
   }
 
   /** Not supported. Choose between
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlSetOption.java b/core/src/main/java/org/apache/calcite/sql/SqlSetOption.java
index 8eb6ae8f545..3a7206eb2d9 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlSetOption.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlSetOption.java
@@ -70,14 +70,32 @@ public class SqlSetOption extends SqlAlter {
           final SqlNode scopeNode = operands[0];
           return new SqlSetOption(pos,
               scopeNode == null ? null : scopeNode.toString(),
-              (SqlIdentifier) operands[1], operands[2]);
+              operands[1], operands[2]);
         }
       };
 
   /** Name of the option as an {@link org.apache.calcite.sql.SqlIdentifier}
    * with one or more parts.*/
+  @Deprecated // to be removed before 2.0
   SqlIdentifier name;
 
+  /**
+   * Name of the option as an {@link SqlNode}.
+   *
+   * <p>{@link org.apache.calcite.sql.SqlIdentifier} can not be used
+   * as a name parameter. For example, in PostgreSQL, these two SQL commands
+   * have different meanings:
+   * <ul>
+   *   <li><code>RESET ALL</code> resets all settable run-time parameters to default values.</li>
+   *   <li><code>RESET "ALL"</code> resets parameter "ALL".</li>
+   * </ul>
+   * Using only {@link org.apache.calcite.sql.SqlIdentifier} makes
+   * it impossible to distinguish which case is being referred to.
+   *
+   * <p>TODO: Rename to 'name' when deprecated `name` field is removed.
+   */
+  SqlNode nameAsSqlNode;
+
   /** Value of the option. May be a {@link org.apache.calcite.sql.SqlLiteral} or
    * a {@link org.apache.calcite.sql.SqlIdentifier} with one
    * part. Reserved words (currently just 'ON') are converted to
@@ -89,18 +107,26 @@ public class SqlSetOption extends SqlAlter {
    *
    * @param pos Parser position, must not be null.
    * @param scope Scope (generally "SYSTEM" or "SESSION"), may be null.
-   * @param name Name of option, as an identifier, must not be null.
+   * @param name Name of option, must not be null.
    * @param value Value of option, as an identifier or literal, may be null.
    *              If null, assume RESET command, else assume SET command.
    */
-  public SqlSetOption(SqlParserPos pos, @Nullable String scope, SqlIdentifier name,
+  public SqlSetOption(SqlParserPos pos, @Nullable String scope, SqlNode name,
       @Nullable SqlNode value) {
     super(pos, scope);
     this.scope = scope;
-    this.name = requireNonNull(name, "name");
+    this.name = requireNonNull(name, "name") instanceof SqlIdentifier ? (SqlIdentifier) name
+        : new SqlIdentifier(name.toString(), name.getParserPosition());
+    this.nameAsSqlNode = name;
     this.value = value;
   }
 
+  @Deprecated // to be removed before 2.0
+  public SqlSetOption(SqlParserPos pos, @Nullable String scope, SqlIdentifier name,
+      @Nullable SqlNode value) {
+    this(pos, scope, (SqlNode) name, value);
+  }
+
   @Override public SqlKind getKind() {
     return SqlKind.SET_OPTION;
   }
@@ -132,7 +158,7 @@ public SqlSetOption(SqlParserPos pos, @Nullable String scope, SqlIdentifier name
       }
       break;
     case 1:
-      name = (SqlIdentifier) requireNonNull(operand, /**/ "name");
+      setName(requireNonNull(operand, "operand"));
       break;
     case 2:
       value = operand;
@@ -142,20 +168,12 @@ public SqlSetOption(SqlParserPos pos, @Nullable String scope, SqlIdentifier name
     }
   }
 
+  @Override public void unparse(final SqlWriter writer, final int leftPrec, final int rightPrec) {
+    writer.getDialect().unparseSqlSetOption(writer, leftPrec, rightPrec, this);
+  }
+
   @Override protected void unparseAlterOperation(SqlWriter writer, int leftPrec, int rightPrec) {
-    if (value != null) {
-      writer.keyword("SET");
-    } else {
-      writer.keyword("RESET");
-    }
-    final SqlWriter.Frame frame =
-        writer.startList(SqlWriter.FrameTypeEnum.SIMPLE);
-    name.unparse(writer, leftPrec, rightPrec);
-    if (value != null) {
-      writer.sep("=");
-      value.unparse(writer, leftPrec, rightPrec);
-    }
-    writer.endList(frame);
+    throw new UnsupportedOperationException();
   }
 
   @Override public void validate(SqlValidator validator,
@@ -165,14 +183,28 @@ public SqlSetOption(SqlParserPos pos, @Nullable String scope, SqlIdentifier name
     }
   }
 
+  @Deprecated // to be removed before 2.0
   public SqlIdentifier getName() {
     return name;
   }
 
+  // TODO: Rename to 'getName' when deprecated `getName` method is removed.
+  public SqlNode name() {
+    return nameAsSqlNode;
+  }
+
+  @Deprecated // to be removed before 2.0
   public void setName(SqlIdentifier name) {
     this.name = name;
   }
 
+  public void setName(SqlNode name) {
+    this.name =
+        name instanceof SqlIdentifier ? (SqlIdentifier) name
+            : new SqlIdentifier(name.toString(), name.getParserPosition());
+    this.nameAsSqlNode = name;
+  }
+
   public @Nullable SqlNode getValue() {
     return value;
   }
diff --git a/core/src/main/java/org/apache/calcite/sql/dialect/PostgresqlSqlDialect.java b/core/src/main/java/org/apache/calcite/sql/dialect/PostgresqlSqlDialect.java
index 627b3c79a41..77db1f36360 100644
--- a/core/src/main/java/org/apache/calcite/sql/dialect/PostgresqlSqlDialect.java
+++ b/core/src/main/java/org/apache/calcite/sql/dialect/PostgresqlSqlDialect.java
@@ -27,11 +27,13 @@
 import org.apache.calcite.sql.SqlDataTypeSpec;
 import org.apache.calcite.sql.SqlDialect;
 import org.apache.calcite.sql.SqlIdentifier;
+import org.apache.calcite.sql.SqlKind;
 import org.apache.calcite.sql.SqlLiteral;
 import org.apache.calcite.sql.SqlNode;
 import org.apache.calcite.sql.SqlNodeList;
 import org.apache.calcite.sql.SqlOperator;
 import org.apache.calcite.sql.SqlSelect;
+import org.apache.calcite.sql.SqlSetOption;
 import org.apache.calcite.sql.SqlWriter;
 import org.apache.calcite.sql.fun.SqlCase;
 import org.apache.calcite.sql.fun.SqlFloorFunction;
@@ -44,6 +46,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.List;
+import java.util.Objects;
 
 import static org.apache.calcite.linq4j.Nullness.castNonNull;
 
@@ -189,4 +192,40 @@ public PostgresqlSqlDialect(Context context) {
   @Override public boolean supportsGroupByLiteral() {
     return false;
   }
+
+  @Override public void unparseSqlSetOption(SqlWriter writer,
+      int leftPrec, int rightPrec, SqlSetOption option) {
+    String scope = option.getScope();
+    SqlNode value = option.getValue();
+    SqlNode name = option.name();
+
+    if (Objects.equals(scope, "SYSTEM")) {
+      writer.keyword("ALTER SYSTEM");
+    }
+    if (value != null) {
+      writer.keyword("SET");
+    } else {
+      writer.keyword("RESET");
+    }
+
+    if (Objects.equals(scope, "LOCAL")) {
+      writer.keyword("LOCAL");
+    }
+
+    if (name.getKind() == SqlKind.IDENTIFIER) {
+      name.unparse(writer, leftPrec, rightPrec);
+      final SqlWriter.Frame frame =
+          writer.startList(SqlWriter.FrameTypeEnum.SIMPLE);
+      if (value != null) {
+        writer.sep("=");
+        value.unparse(writer, leftPrec, rightPrec);
+      }
+      writer.endList(frame);
+    } else {
+      name.unparse(writer, leftPrec, rightPrec);
+      if (value != null) {
+        value.unparse(writer, leftPrec, rightPrec);
+      }
+    }
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlBasicOperator.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlBasicOperator.java
new file mode 100644
index 00000000000..e84042b5cdc
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlBasicOperator.java
@@ -0,0 +1,63 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.fun;
+
+import org.apache.calcite.sql.SqlKind;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.SqlSyntax;
+import org.apache.calcite.sql.type.InferTypes;
+import org.apache.calcite.sql.type.OperandTypes;
+import org.apache.calcite.sql.type.ReturnTypes;
+
+/**
+ * Concrete implementation of {@link SqlOperator}.
+ *
+ * <p>The class is final, and instances are immutable.
+ *
+ * <p>Instances are created only by {@link SqlBasicOperator#create} and are
+ * "modified" by "wither" methods such as {@link #withPrecedence} to create a new
+ * instance with one property changed. Since the class is final, you can modify
+ * behavior only by providing strategy objects, not by overriding methods in a
+ * subclass.
+ */
+public final class SqlBasicOperator extends SqlOperator {
+  @Override public SqlSyntax getSyntax() {
+    return SqlSyntax.SPECIAL;
+  }
+
+  /** Private constructor. Use {@link #create}. */
+  private SqlBasicOperator(String name, int leftPrecedence, int rightPrecedence,
+      SqlCallFactory callFactory) {
+    super(name, SqlKind.OTHER, leftPrecedence, rightPrecedence,
+        ReturnTypes.BOOLEAN, InferTypes.RETURN_TYPE, OperandTypes.ANY, callFactory);
+  }
+
+  public static SqlBasicOperator create(String name) {
+    return new SqlBasicOperator(name, 0, 0,
+        SqlCallFactories.SQL_BASIC_CALL_FACTORY);
+  }
+
+  public SqlBasicOperator withPrecedence(int prec, boolean leftAssoc) {
+    return new SqlBasicOperator(getName(), leftPrec(prec, leftAssoc),
+        rightPrec(prec, leftAssoc), getSqlCallFactory());
+  }
+
+  public SqlBasicOperator withCallFactory(SqlCallFactory sqlCallFactory) {
+    return new SqlBasicOperator(getName(), getLeftPrec(),
+        getRightPrec(), sqlCallFactory);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlCallFactories.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlCallFactories.java
new file mode 100644
index 00000000000..89e0fb897c3
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlCallFactories.java
@@ -0,0 +1,38 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.fun;
+
+import org.apache.calcite.sql.SqlBasicCall;
+import org.apache.calcite.util.ImmutableNullableList;
+
+/**
+ * Contains static factory methods for creating instances of {@link SqlCallFactory}.
+ */
+public abstract class SqlCallFactories {
+  private SqlCallFactories() {
+  }
+
+  /**
+   * A {@link SqlCallFactory} that creates instances of {@link SqlBasicCall}.
+   */
+  public static final SqlCallFactory SQL_BASIC_CALL_FACTORY =
+      (operator, functionQualifier, pos, operands) -> {
+        pos = pos.plusAll(operands);
+        return new SqlBasicCall(operator, ImmutableNullableList.copyOf(operands), pos,
+            functionQualifier);
+      };
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlCallFactory.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlCallFactory.java
new file mode 100644
index 00000000000..015f482b7c4
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlCallFactory.java
@@ -0,0 +1,48 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to you under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.calcite.sql.fun;
+
+import org.apache.calcite.sql.SqlCall;
+import org.apache.calcite.sql.SqlLiteral;
+import org.apache.calcite.sql.SqlNode;
+import org.apache.calcite.sql.SqlOperator;
+import org.apache.calcite.sql.parser.SqlParserPos;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * A factory for creating {@link org.apache.calcite.sql.SqlCall}.
+ */
+@FunctionalInterface
+public interface SqlCallFactory {
+
+  /**
+   * Creates a call to this operator with an array of operands.
+   *
+   * <p>The position of the resulting call is the union of the {@code pos}
+   * and the positions of all of the operands.
+   *
+   * @param functionQualifier Function qualifier (e.g. "DISTINCT"), or null
+   * @param pos               Parser position of the identifier of the call
+   * @param operands          Array of operands
+   */
+  SqlCall create(
+      SqlOperator operator,
+      @Nullable SqlLiteral functionQualifier,
+      SqlParserPos pos,
+      @Nullable SqlNode... operands);
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java b/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
index 00dd8df9b3b..0258f75d0bf 100644
--- a/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
+++ b/core/src/main/java/org/apache/calcite/sql/fun/SqlStdOperatorTable.java
@@ -198,7 +198,7 @@ public class SqlStdOperatorTable extends ReflectiveSqlOperatorTable {
 
   /**
    * <code>DEFAULT</code> operator indicates that an argument to a function call
-   * is to take its default value..
+   * is to take its default value.
    */
   public static final SqlSpecialOperator DEFAULT = new SqlDefaultOperator();
 
diff --git a/core/src/test/java/org/apache/calcite/sql/SqlSetOptionOperatorTest.java b/core/src/test/java/org/apache/calcite/sql/SqlSetOptionOperatorTest.java
index 1d15443c041..0b0c29a9bd2 100644
--- a/core/src/test/java/org/apache/calcite/sql/SqlSetOptionOperatorTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/SqlSetOptionOperatorTest.java
@@ -63,7 +63,7 @@ private static void checkSqlSetOptionSame(SqlNode node) {
     assertThat(opt.getClass(), equalTo(returned.getClass()));
     SqlSetOption optRet = (SqlSetOption) returned;
     assertThat(optRet.getScope(), is(opt.getScope()));
-    assertThat(optRet.getName(), is(opt.getName()));
+    assertThat(optRet.name(), is(opt.name()));
     assertThat(optRet.getFunctionQuantifier(), is(opt.getFunctionQuantifier()));
     assertThat(optRet.getParserPosition(), is(opt.getParserPosition()));
     assertThat(optRet.getValue(), is(opt.getValue()));
diff --git a/site/_docs/babel_reference.md b/site/_docs/babel_reference.md
new file mode 100644
index 00000000000..ce1df4bb13a
--- /dev/null
+++ b/site/_docs/babel_reference.md
@@ -0,0 +1,139 @@
+---
+layout: docs
+title: SQL language (Babel)
+permalink: /docs/babel_reference.html
+---
+<!--
+{% comment %}
+Licensed to the Apache Software Foundation (ASF) under one or more
+contributor license agreements.  See the NOTICE file distributed with
+this work for additional information regarding copyright ownership.
+The ASF licenses this file to you under the Apache License, Version 2.0
+(the "License"); you may not use this file except in compliance with
+the License.  You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+{% endcomment %}
+-->
+
+<style>
+.container {
+  width: 400px;
+  height: 26px;
+}
+.gray {
+  width: 60px;
+  height: 26px;
+  background: gray;
+  float: left;
+}
+.r15 {
+  width: 40px;
+  height: 6px;
+  background: yellow;
+  margin-top: 4px;
+  margin-left: 10px;
+}
+.r12 {
+  width: 10px;
+  height: 6px;
+  background: yellow;
+  margin-top: 4px;
+  margin-left: 10px;
+}
+.r13 {
+  width: 20px;
+  height: 6px;
+  background: yellow;
+  margin-top: 4px;
+  margin-left: 10px;
+}
+.r2 {
+  width: 2px;
+  height: 6px;
+  background: yellow;
+  margin-top: 4px;
+  margin-left: 20px;
+}
+.r24 {
+  width: 20px;
+  height: 6px;
+  background: yellow;
+  margin-top: 4px;
+  margin-left: 20px;
+}
+.r35 {
+  width: 20px;
+  height: 6px;
+  background: yellow;
+  margin-top: 4px;
+  margin-left: 30px;
+}
+</style>
+
+The page describes SQL statements and expressions that are recognized by Calcite's Babel SQL parser,
+in addition to those recognized by [Calcite's default SQL parser](reference.html).
+
+## Grammar
+
+SQL grammar in [BNF](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_Form)-like
+form. This grammar covers only the modified or added statements in Calcite's babel SQL parser, referring to
+[Calcite's default SQL grammar](reference.html).
+
+{% highlight sql %}
+statement:
+      setStatement
+  |   resetStatement
+  |   begin
+  |   commit
+  |   rollback
+  |   discard
+  |   explain
+  |   describe
+  |   insert
+  |   update
+  |   merge
+  |   delete
+  |   query
+
+begin:
+      BEGIN [ { WORK | TRANSACTION } ] [ transactionMode [, transactionMode]* ]
+
+commit:
+      COMMIT [ { WORK | TRANSACTION } ] [ AND [ NO ] CHAIN ]
+
+rollback:
+      ROLLBACK [ { WORK | TRANSACTION } ] [ AND [ NO ] CHAIN ]
+
+discard:
+      DISCARD { ALL | PLANS | SEQUENCES | TEMPORARY | TEMP }
+
+setStatement:
+      [ ALTER { SYSTEM | SESSION } ] SET [ { SESSION | LOCAL } ]
+      {
+          identifier { TO | = } { expression [, expression]*  | DEFAULT }
+      |   TIME ZONE { expression | 'value' | LOCAL | DEFAULT }
+      |   (SCHEMA | NAMES | SEED) expression
+      |   TRANSACTION transactionMode [, transactionMode]*
+      |   TRANSACTION SNAPSHOT expression
+      |   SESSION CHARACTERISTICS AS TRANSACTION transactionMode [, transactionMode]*
+      |   SESSION AUTHORIZATION expression
+      |   ROLE { NONE | expression }
+      }
+}
+
+resetStatement:
+      RESET { ALL | SESSION AUTHORIZATION | TIME ZONE | TRANSACTION ISOLATION LEVEL | identifier }
+
+transactionMode:
+      ISOLATION LEVEL { SERIALIZABLE | REPEATABLE READ | READ COMMITTED | READ UNCOMMITTED }
+  |   READ WRITE
+  |   READ ONLY
+  |   [ NOT ] DEFERRABLE
+{% endhighlight %}
diff --git a/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java b/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
index 9e4734b9394..806179469ad 100644
--- a/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
+++ b/testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java
@@ -7793,7 +7793,7 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
     SqlSetOption opt = (SqlSetOption) node;
     assertThat(opt.getScope(), equalTo("SYSTEM"));
     SqlPrettyWriter writer = new SqlPrettyWriter();
-    assertThat(writer.format(opt.getName()), equalTo("\"SCHEMA\""));
+    assertThat(writer.format(opt.name()), equalTo("\"SCHEMA\""));
     writer = new SqlPrettyWriter();
     assertThat(writer.format(opt.getValue()), equalTo("TRUE"));
     writer = new SqlPrettyWriter();
@@ -7825,7 +7825,7 @@ private static Consumer<List<? extends Throwable>> checkWarnings(
     opt = (SqlSetOption) node;
     assertThat(opt.getScope(), equalTo(null));
     writer = new SqlPrettyWriter();
-    assertThat(writer.format(opt.getName()), equalTo("\"SCHEMA\""));
+    assertThat(writer.format(opt.name()), equalTo("\"SCHEMA\""));
     assertThat(opt.getValue(), equalTo(null));
     writer = new SqlPrettyWriter();
     assertThat(writer.format(opt),