From 6d3a81de13322a79f83d07b86fb427bdf2087fed Mon Sep 17 00:00:00 2001
From: Mihai Budiu <mbudiu@feldera.com>
Date: Fri, 23 Feb 2024 07:25:40 -0800
Subject: [PATCH] [CALCITE-6138] Parser does not accept TIMESTAMP WITH TIME
 ZONE as a data type

Signed-off-by: Mihai Budiu <mbudiu@feldera.com>
---
 .../adapter/cassandra/CassandraFilter.java    |  4 +
 core/src/main/codegen/templates/Parser.jj     | 46 +++++------
 .../adapter/enumerable/RexImpTable.java       |  6 ++
 .../calcite/jdbc/JavaTypeFactoryImpl.java     |  2 +
 .../calcite/rel/metadata/RelMdSize.java       |  4 +
 .../calcite/rel/rules/DateRangeRules.java     | 16 +++-
 .../MaterializedViewAggregateRule.java        |  3 +-
 .../rel/type/RelDataTypeSystemImpl.java       |  8 ++
 .../org/apache/calcite/rex/RexBuilder.java    | 62 +++++++++++++++
 .../org/apache/calcite/rex/RexLiteral.java    | 33 +++++++-
 .../sql/SqlAbstractDateTimeLiteral.java       |  2 +-
 .../calcite/sql/SqlBasicTypeNameSpec.java     | 27 +++++--
 .../calcite/sql/SqlJdbcDataTypeName.java      |  2 +
 .../org/apache/calcite/sql/SqlLiteral.java    | 21 +++++
 .../apache/calcite/sql/SqlTimeTzLiteral.java  | 70 +++++++++++++++++
 .../calcite/sql/SqlTimestampLiteral.java      |  2 +-
 .../calcite/sql/SqlTimestampTzLiteral.java    | 70 +++++++++++++++++
 .../apache/calcite/sql/SqlUnknownLiteral.java |  4 +
 .../calcite/sql/parser/SqlParserUtil.java     | 49 ++++++++++++
 .../apache/calcite/sql/type/ReturnTypes.java  |  7 ++
 .../sql/type/SqlTypeAssignmentRule.java       |  6 ++
 .../calcite/sql/type/SqlTypeCoercionRule.java | 45 +++++++++++
 .../calcite/sql/type/SqlTypeFamily.java       |  8 +-
 .../apache/calcite/sql/type/SqlTypeName.java  | 27 +++++--
 .../sql2rel/SqlNodeToRexConverterImpl.java    |  5 ++
 .../calcite/util/TimeWithTimeZoneString.java  |  6 ++
 .../apache/calcite/util/TimestampString.java  |  5 ++
 .../util/TimestampWithTimeZoneString.java     |  9 +++
 .../java/org/apache/calcite/util/Util.java    | 10 ++-
 .../calcite/jdbc/CalciteRemoteDriverTest.java |  2 +-
 .../apache/calcite/rex/RexBuilderTest.java    | 78 ++++++++++++++++++-
 .../calcite/sql/type/SqlTypeFactoryTest.java  |  2 +
 .../apache/calcite/test/SqlValidatorTest.java | 11 +++
 site/_docs/reference.md                       |  6 +-
 .../calcite/sql/parser/SqlParserTest.java     | 17 ++--
 35 files changed, 614 insertions(+), 61 deletions(-)
 create mode 100644 core/src/main/java/org/apache/calcite/sql/SqlTimeTzLiteral.java
 create mode 100644 core/src/main/java/org/apache/calcite/sql/SqlTimestampTzLiteral.java

diff --git a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraFilter.java b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraFilter.java
index aeb749a6d288..117c79a99c72 100644
--- a/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraFilter.java
+++ b/cassandra/src/main/java/org/apache/calcite/adapter/cassandra/CassandraFilter.java
@@ -36,6 +36,7 @@
 import org.apache.calcite.sql.type.SqlTypeName;
 import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.TimestampString;
+import org.apache.calcite.util.TimestampWithTimeZoneString;
 import org.apache.calcite.util.Util;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -192,6 +193,9 @@ private String translateMatch(RexNode condition) {
     private static Object literalValue(RexLiteral literal) {
       Comparable<?> value = RexLiteral.value(literal);
       switch (literal.getTypeName()) {
+      case TIMESTAMP_TZ:
+        assert value instanceof TimestampWithTimeZoneString;
+        return value.toString();
       case TIMESTAMP:
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
         assert value instanceof TimestampString;
diff --git a/core/src/main/codegen/templates/Parser.jj b/core/src/main/codegen/templates/Parser.jj
index 78f9f590edd1..542b164e1810 100644
--- a/core/src/main/codegen/templates/Parser.jj
+++ b/core/src/main/codegen/templates/Parser.jj
@@ -4787,6 +4787,7 @@ SqlLiteral DateTimeLiteral() :
 {
     final String p;
     final Span s;
+    boolean local = false;
 }
 {
     <LBRACE_D> <QUOTED_STRING> {
@@ -4818,6 +4819,7 @@ SqlLiteral DateTimeLiteral() :
         return SqlLiteral.createUnknown("DATETIME", p, s.end(this));
     }
 |
+    LOOKAHEAD(2)
     <TIME> { s = span(); } p = SimpleStringLiteral() {
       return SqlLiteral.createUnknown("TIME", p, s.end(this));
     }
@@ -4827,8 +4829,14 @@ SqlLiteral DateTimeLiteral() :
         return SqlLiteral.createUnknown("TIMESTAMP", p, s.end(this));
     }
 |
-    <TIMESTAMP> { s = span(); } <WITH> <LOCAL> <TIME> <ZONE> p = SimpleStringLiteral() {
-        return SqlLiteral.createUnknown("TIMESTAMP WITH LOCAL TIME ZONE", p, s.end(this));
+    LOOKAHEAD(2)
+    <TIME> { s = span(); } <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("TIME WITH " + (local ? "LOCAL " : "") + "TIME ZONE", p, s.end(this));
+    }
+|
+    LOOKAHEAD(2)
+    <TIMESTAMP> { s = span(); } <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> p = SimpleStringLiteral() {
+        return SqlLiteral.createUnknown("TIMESTAMP WITH " + (local ? "LOCAL " : "") + "TIME ZONE", p, s.end(this));
     }
 }
 
@@ -6112,7 +6120,6 @@ SqlTypeNameSpec DateTimeTypeName() :
 {
     int precision = -1;
     SqlTypeName typeName;
-    boolean withLocalTimeZone = false;
     final Span s;
 }
 {
@@ -6124,25 +6131,15 @@ SqlTypeNameSpec DateTimeTypeName() :
     LOOKAHEAD(2)
     <TIME> { s = span(); }
     precision = PrecisionOpt()
-    withLocalTimeZone = TimeZoneOpt()
+    typeName = TimeZoneOpt(true)
     {
-        if (withLocalTimeZone) {
-            typeName = SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE;
-        } else {
-            typeName = SqlTypeName.TIME;
-        }
         return new SqlBasicTypeNameSpec(typeName, precision, s.end(this));
     }
 |
     <TIMESTAMP> { s = span(); }
     precision = PrecisionOpt()
-    withLocalTimeZone = TimeZoneOpt()
+    typeName = TimeZoneOpt(false)
     {
-        if (withLocalTimeZone) {
-            typeName = SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE;
-        } else {
-            typeName = SqlTypeName.TIMESTAMP;
-        }
         return new SqlBasicTypeNameSpec(typeName, precision, s.end(this));
     }
 }
@@ -6163,23 +6160,22 @@ int PrecisionOpt() :
 
 /**
 * Parse a time zone suffix for DateTime types. According to SQL-2011,
-* "with time zone" and "without time zone" belong to standard SQL but we
-* only implement the "without time zone".
-*
-* <p>We also support "with local time zone".
-*
-* @return true if this is "with local time zone".
+* "with time zone" and "without time zone" belong to standard SQL.
+* We also support "with local time zone".
 */
-boolean TimeZoneOpt() :
+SqlTypeName TimeZoneOpt(boolean timeType) :
 {
+    boolean local = false;
 }
 {
     LOOKAHEAD(3)
-    <WITHOUT> <TIME> <ZONE> { return false; }
+    <WITHOUT> <TIME> <ZONE> { return timeType ? SqlTypeName.TIME : SqlTypeName.TIMESTAMP;  }
 |
-    <WITH> <LOCAL> <TIME> <ZONE> { return true; }
+    <WITH> ( <LOCAL> { local = true; } )? <TIME> <ZONE> {
+        return timeType ? (local ? SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE : SqlTypeName.TIME_TZ)
+                        : (local ? SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE : SqlTypeName.TIMESTAMP_TZ); }
 |
-    { return false; }
+    { return timeType ? SqlTypeName.TIME : SqlTypeName.TIMESTAMP; }
 }
 
 /**
diff --git a/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java b/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
index e37120e2e522..1bc88f18c43f 100644
--- a/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
+++ b/core/src/main/java/org/apache/calcite/adapter/enumerable/RexImpTable.java
@@ -2451,6 +2451,7 @@ private static class ContainsSubstrImplementor extends AbstractRexCallImplemento
       // Search does not include TZ so this conversion is okay
       case TIMESTAMP:
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      case TIMESTAMP_TZ:
         expr = Expressions.call(BuiltInMethod.UNIX_TIMESTAMP_TO_STRING.method, expr);
         break;
       default:
@@ -2633,6 +2634,7 @@ private static class FloorImplementor extends MethodImplementor {
                       translator.getRoot()));
           // fall through
         case TIMESTAMP:
+        case TIMESTAMP_TZ:
           type = long.class;
           floorMethod = custom ? customTimestampMethod : timestampMethod;
           preFloor = true;
@@ -2713,6 +2715,7 @@ private static class TimestampAddImplementor
       final Expression operand2 = argValueList.get(2);
       switch (call.getType().getSqlTypeName()) {
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      case TIMESTAMP_TZ:
       case TIMESTAMP:
         return Expressions.call(customTimestampMethod, translator.getRoot(),
             operand0, operand1, operand2);
@@ -2745,6 +2748,7 @@ private static class TimestampDiffImplementor
     private Method getMethod(RexCall call) {
       switch (call.operands.get(1).getType().getSqlTypeName()) {
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      case TIMESTAMP_TZ:
       case TIMESTAMP:
         return customTimestampMethod;
       default:
@@ -3106,6 +3110,7 @@ private static class ExtractImplementor extends AbstractRexCallImplementor {
                   Expressions.call(BuiltInMethod.TIME_ZONE.method,
                       translator.getRoot()));
           // fall through
+        case TIMESTAMP_TZ:
         case TIMESTAMP:
           operand =
               Expressions.call(BuiltInMethod.FLOOR_DIV.method, operand,
@@ -3136,6 +3141,7 @@ private static class ExtractImplementor extends AbstractRexCallImplementor {
                   Expressions.constant(TimeUnit.DAY.multiplier.longValue()));
           // fall through
         case TIMESTAMP:
+        case TIMESTAMP_TZ:
           // convert to seconds
           return Expressions.divide(operand,
               Expressions.constant(TimeUnit.SECOND.multiplier.longValue()));
diff --git a/core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java b/core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java
index 05ed58165438..1b015fe2f935 100644
--- a/core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java
+++ b/core/src/main/java/org/apache/calcite/jdbc/JavaTypeFactoryImpl.java
@@ -180,6 +180,7 @@ private static Type fieldType(Field field) {
       case DATE:
       case TIME:
       case TIME_WITH_LOCAL_TIME_ZONE:
+      case TIME_TZ:
       case INTEGER:
       case INTERVAL_YEAR:
       case INTERVAL_YEAR_MONTH:
@@ -187,6 +188,7 @@ private static Type fieldType(Field field) {
         return type.isNullable() ? Integer.class : int.class;
       case TIMESTAMP:
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      case TIMESTAMP_TZ:
       case BIGINT:
       case INTERVAL_DAY:
       case INTERVAL_DAY_HOUR:
diff --git a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java
index 903a65f48a98..f2d2c6a882f1 100644
--- a/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java
+++ b/core/src/main/java/org/apache/calcite/rel/metadata/RelMdSize.java
@@ -302,6 +302,7 @@ protected RelMdSize() {}
     case DATE:
     case TIME:
     case TIME_WITH_LOCAL_TIME_ZONE:
+    case TIME_TZ:
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
     case INTERVAL_MONTH:
@@ -311,6 +312,7 @@ protected RelMdSize() {}
     case FLOAT: // sic
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+    case TIMESTAMP_TZ:
     case INTERVAL_DAY:
     case INTERVAL_DAY_HOUR:
     case INTERVAL_DAY_MINUTE:
@@ -364,6 +366,7 @@ public double typeValueSize(RelDataType type, @Nullable Comparable value) {
     case DATE:
     case TIME:
     case TIME_WITH_LOCAL_TIME_ZONE:
+    case TIME_TZ:
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
     case INTERVAL_MONTH:
@@ -373,6 +376,7 @@ public double typeValueSize(RelDataType type, @Nullable Comparable value) {
     case DOUBLE:
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+    case TIMESTAMP_TZ:
     case INTERVAL_DAY:
     case INTERVAL_DAY_HOUR:
     case INTERVAL_DAY_MINUTE:
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java b/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
index 9c51470f0a7c..d720624dd47d 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/DateRangeRules.java
@@ -575,7 +575,14 @@ private RexLiteral dateTimeLiteral(RexBuilder rexBuilder, Calendar calendar,
         ts = TimestampString.fromCalendarFields(calendar);
         p = operand.getType().getPrecision();
         return rexBuilder.makeTimestampLiteral(ts, p);
-      case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+      case TIMESTAMP_TZ: {
+        ts = TimestampString.fromCalendarFields(calendar);
+        final TimeZone tz = calendar.getTimeZone();
+        final TimestampWithTimeZoneString localTs = new TimestampWithTimeZoneString(ts, tz);
+        p = operand.getType().getPrecision();
+        return rexBuilder.makeTimestampTzLiteral(localTs, p);
+      }
+      case TIMESTAMP_WITH_LOCAL_TIME_ZONE: {
         ts = TimestampString.fromCalendarFields(calendar);
         final TimeZone tz = TimeZone.getTimeZone(this.timeZone);
         final TimestampString localTs =
@@ -584,6 +591,7 @@ private RexLiteral dateTimeLiteral(RexBuilder rexBuilder, Calendar calendar,
                 .getLocalTimestampString();
         p = operand.getType().getPrecision();
         return rexBuilder.makeTimestampWithLocalTimeZoneLiteral(localTs, p);
+      }
       case DATE:
         final DateString d = DateString.fromCalendarFields(calendar);
         return rexBuilder.makeDateLiteral(d);
@@ -646,6 +654,12 @@ private RexNode compareFloorCeil(SqlKind comparison, RexNode operand,
 
     private Calendar timestampValue(RexLiteral timeLiteral) {
       switch (timeLiteral.getTypeName()) {
+      case TIMESTAMP_TZ:
+        TimestampWithTimeZoneString value =
+            requireNonNull(timeLiteral.getValueAs(TimestampWithTimeZoneString.class));
+        return Util.calendar(
+            value.getLocalTimestampString().getMillisSinceEpoch(),
+            value.getTimeZone());
       case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
         final TimeZone tz = TimeZone.getTimeZone(this.timeZone);
         return Util.calendar(
diff --git a/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewAggregateRule.java b/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewAggregateRule.java
index 289c088a8f82..579efc3336e0 100644
--- a/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewAggregateRule.java
+++ b/core/src/main/java/org/apache/calcite/rel/rules/materialize/MaterializedViewAggregateRule.java
@@ -775,7 +775,8 @@ private static int find(RelNode rel, int ref) {
       exprsLineage.put(expr, i);
       SqlTypeName sqlTypeName = expr.getType().getSqlTypeName();
       if (sqlTypeName == SqlTypeName.TIMESTAMP
-          || sqlTypeName == SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE) {
+          || sqlTypeName == SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE
+          || sqlTypeName == SqlTypeName.TIMESTAMP_TZ) {
         timestampExprs.add(expr);
       }
     }
diff --git a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
index 55702ce9cdb0..d4a9cac0f8ce 100644
--- a/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
+++ b/core/src/main/java/org/apache/calcite/rel/type/RelDataTypeSystemImpl.java
@@ -101,10 +101,12 @@ public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
       return 15;
     case TIME:
     case TIME_WITH_LOCAL_TIME_ZONE:
+    case TIME_TZ:
     case DATE:
       return 0; // SQL99 part 2 section 6.1 syntax rule 30
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+    case TIMESTAMP_TZ:
       // farrago supports only 0 (see
       // SqlTypeName.getDefaultPrecision), but it should be 6
       // (microseconds) per SQL99 part 2 section 6.1 syntax rule 30.
@@ -126,8 +128,10 @@ public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
       return 65536;
     case TIME:
     case TIME_WITH_LOCAL_TIME_ZONE:
+    case TIME_TZ:
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+    case TIMESTAMP_TZ:
       return SqlTypeName.MAX_DATETIME_PRECISION;
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
@@ -168,6 +172,8 @@ public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
       return isPrefix ? "TIMESTAMP '" : "'";
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       return isPrefix ? "TIMESTAMP WITH LOCAL TIME ZONE '" : "'";
+    case TIMESTAMP_TZ:
+      return isPrefix ? "TIMESTAMP WITH TIME ZONE '" : "'";
     case INTERVAL_DAY:
     case INTERVAL_DAY_HOUR:
     case INTERVAL_DAY_MINUTE:
@@ -187,6 +193,8 @@ public abstract class RelDataTypeSystemImpl implements RelDataTypeSystem {
       return isPrefix ? "TIME '" : "'";
     case TIME_WITH_LOCAL_TIME_ZONE:
       return isPrefix ? "TIME WITH LOCAL TIME ZONE '" : "'";
+    case TIME_TZ:
+      return isPrefix ? "TIME WITH TIME ZONE '" : "'";
     case DATE:
       return isPrefix ? "DATE '" : "'";
     case ARRAY:
diff --git a/core/src/main/java/org/apache/calcite/rex/RexBuilder.java b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
index dab524f5ee55..ecbe67e0d97f 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexBuilder.java
@@ -48,7 +48,9 @@
 import org.apache.calcite.util.Pair;
 import org.apache.calcite.util.Sarg;
 import org.apache.calcite.util.TimeString;
+import org.apache.calcite.util.TimeWithTimeZoneString;
 import org.apache.calcite.util.TimestampString;
+import org.apache.calcite.util.TimestampWithTimeZoneString;
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
@@ -1015,6 +1017,14 @@ protected RexLiteral makeLiteral(
       }
       o = ((TimeString) o).round(p);
       break;
+    case TIME_TZ:
+      assert o instanceof TimeWithTimeZoneString;
+      p = type.getPrecision();
+      if (p == RelDataType.PRECISION_NOT_SPECIFIED) {
+        p = 0;
+      }
+      o = ((TimeWithTimeZoneString) o).round(p);
+      break;
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       assert o instanceof TimestampString;
@@ -1024,6 +1034,14 @@ protected RexLiteral makeLiteral(
       }
       o = ((TimestampString) o).round(p);
       break;
+    case TIMESTAMP_TZ:
+      assert o instanceof TimestampWithTimeZoneString;
+      p = type.getPrecision();
+      if (p == RelDataType.PRECISION_NOT_SPECIFIED) {
+        p = 0;
+      }
+      o = ((TimestampWithTimeZoneString) o).round(p);
+      break;
     default:
       break;
     }
@@ -1270,6 +1288,16 @@ public RexLiteral makeTimeWithLocalTimeZoneLiteral(
         SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE);
   }
 
+  /** Creates a Time with time-zone literal. */
+  public RexLiteral makeTimeTzLiteral(
+      TimeWithTimeZoneString time,
+      int precision) {
+    return makeLiteral(
+        requireNonNull(time, "time"),
+        typeFactory.createSqlType(SqlTypeName.TIME_TZ, precision),
+        SqlTypeName.TIME_TZ);
+  }
+
   // CHECKSTYLE: IGNORE 1
   /** @deprecated Use {@link #makeTimestampLiteral(TimestampString, int)}. */
   @Deprecated // to be removed before 2.0
@@ -1301,6 +1329,15 @@ public RexLiteral makeTimestampWithLocalTimeZoneLiteral(
         SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
   }
 
+  public RexLiteral makeTimestampTzLiteral(
+      TimestampWithTimeZoneString timestamp,
+      int precision) {
+    return makeLiteral(
+        requireNonNull(timestamp, "timestamp"),
+        typeFactory.createSqlType(SqlTypeName.TIMESTAMP_TZ, precision),
+        SqlTypeName.TIMESTAMP_TZ);
+  }
+
   /**
    * Creates a literal representing an interval type, for example
    * {@code YEAR TO MONTH} or {@code DOW}.
@@ -1544,8 +1581,12 @@ private static Comparable zeroValue(RelDataType type) {
       return DateTimeUtils.ZERO_CALENDAR;
     case TIME_WITH_LOCAL_TIME_ZONE:
       return new TimeString(0, 0, 0);
+    case TIME_TZ:
+      return new TimeWithTimeZoneString(0, 0, 0, "GMT+00");
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       return new TimestampString(0, 1, 1, 0, 0, 0);
+    case TIMESTAMP_TZ:
+      return new TimestampWithTimeZoneString(0, 1, 1, 0, 0, 0, "GMT+00");
     default:
       throw Util.unexpected(type.getSqlTypeName());
     }
@@ -1662,12 +1703,17 @@ public RexNode makeLiteral(@Nullable Object value, RelDataType type,
       return makeTimeLiteral((TimeString) value, type.getPrecision());
     case TIME_WITH_LOCAL_TIME_ZONE:
       return makeTimeWithLocalTimeZoneLiteral((TimeString) value, type.getPrecision());
+    case TIME_TZ:
+      return makeTimeTzLiteral((TimeWithTimeZoneString) value, type.getPrecision());
     case DATE:
       return makeDateLiteral((DateString) value);
     case TIMESTAMP:
       return makeTimestampLiteral((TimestampString) value, type.getPrecision());
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       return makeTimestampWithLocalTimeZoneLiteral((TimestampString) value, type.getPrecision());
+    case TIMESTAMP_TZ:
+      return makeTimestampTzLiteral(
+          (TimestampWithTimeZoneString) value, type.getPrecision());
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
     case INTERVAL_MONTH:
@@ -1827,6 +1873,14 @@ public RexNode makeLambdaCall(RexNode expr, List<RexLambdaRef> parameters) {
       } else {
         return TimeString.fromMillisOfDay((Integer) o);
       }
+    case TIME_TZ:
+      if (o instanceof TimeWithTimeZoneString) {
+        return o;
+      } else if (o instanceof Calendar) {
+        return TimeWithTimeZoneString.fromCalendarFields((Calendar) o);
+      } else {
+        throw new AssertionError("Value does not contain time zone");
+      }
     case TIME_WITH_LOCAL_TIME_ZONE:
       if (o instanceof TimeString) {
         return o;
@@ -1861,6 +1915,14 @@ public RexNode makeLambdaCall(RexNode expr, List<RexLambdaRef> parameters) {
       } else {
         return TimestampString.fromMillisSinceEpoch((Long) o);
       }
+    case TIMESTAMP_TZ:
+      if (o instanceof TimestampWithTimeZoneString) {
+        return o;
+      } else if (o instanceof Calendar) {
+        return TimestampWithTimeZoneString.fromCalendarFields((Calendar) o);
+      } else {
+        throw new AssertionError("Value does not contain time zone");
+      }
     default:
       return o;
     }
diff --git a/core/src/main/java/org/apache/calcite/rex/RexLiteral.java b/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
index 30f03669ed44..1e8cd76cd479 100644
--- a/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
+++ b/core/src/main/java/org/apache/calcite/rex/RexLiteral.java
@@ -39,7 +39,9 @@
 import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.Sarg;
 import org.apache.calcite.util.TimeString;
+import org.apache.calcite.util.TimeWithTimeZoneString;
 import org.apache.calcite.util.TimestampString;
+import org.apache.calcite.util.TimestampWithTimeZoneString;
 import org.apache.calcite.util.Util;
 
 import com.google.common.collect.ImmutableList;
@@ -334,13 +336,15 @@ public static boolean valueMatchesType(
     case DATE:
       return value instanceof DateString;
     case TIME:
-      return value instanceof TimeString;
     case TIME_WITH_LOCAL_TIME_ZONE:
       return value instanceof TimeString;
+    case TIME_TZ:
+      return value instanceof TimeWithTimeZoneString;
     case TIMESTAMP:
-      return value instanceof TimestampString;
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       return value instanceof TimestampString;
+    case TIMESTAMP_TZ:
+      return value instanceof TimestampWithTimeZoneString;
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
     case INTERVAL_MONTH:
@@ -696,11 +700,19 @@ private static void appendAsJava(@Nullable Comparable value, StringBuilder sb,
       assert value instanceof TimeString;
       sb.append(value.toString());
       break;
+    case TIME_TZ:
+      assert value instanceof TimeWithTimeZoneString;
+      sb.append(value);
+      break;
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       assert value instanceof TimestampString;
       sb.append(value.toString());
       break;
+    case TIMESTAMP_TZ:
+      assert value instanceof TimestampWithTimeZoneString;
+      sb.append(value);
+      break;
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
     case INTERVAL_MONTH:
@@ -958,10 +970,12 @@ public boolean isNull() {
     case DECIMAL:
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+    case TIMESTAMP_TZ:
       return getValueAs(Long.class);
     case DATE:
     case TIME:
     case TIME_WITH_LOCAL_TIME_ZONE:
+    case TIME_TZ:
       return getValueAs(Integer.class);
     default:
       return value;
@@ -1100,6 +1114,11 @@ public boolean isNull() {
         return clazz.cast(((TimeString) value).getMillisOfDay());
       }
       break;
+    case TIME_TZ:
+      if (clazz == Integer.class) {
+        return clazz.cast(((TimeWithTimeZoneString) value).getLocalTimeString().getMillisOfDay());
+      }
+      break;
     case TIMESTAMP:
       if (clazz == Long.class) {
         // Milliseconds since 1970-01-01 00:00:00
@@ -1109,6 +1128,16 @@ public boolean isNull() {
         return clazz.cast(((TimestampString) value).toCalendar());
       }
       break;
+    case TIMESTAMP_TZ:
+      if (clazz == Long.class) {
+        return clazz.cast(((TimestampWithTimeZoneString) value)
+            .getLocalTimestampString()
+            .getMillisSinceEpoch());
+      } else if (clazz == Calendar.class) {
+        TimestampWithTimeZoneString ts = (TimestampWithTimeZoneString) value;
+        return clazz.cast(ts.getLocalTimestampString().toCalendar(ts.getTimeZone()));
+      }
+      break;
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       if (clazz == Long.class) {
         // Milliseconds since 1970-01-01 00:00:00
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlAbstractDateTimeLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlAbstractDateTimeLiteral.java
index 7706c0b1ec9d..8d97af0f9f0e 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlAbstractDateTimeLiteral.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlAbstractDateTimeLiteral.java
@@ -56,7 +56,7 @@ protected SqlAbstractDateTimeLiteral(Object d, boolean tz,
   //~ Methods ----------------------------------------------------------------
 
   /** Converts this literal to a {@link TimestampString}. */
-  protected TimestampString getTimestamp() {
+  public TimestampString getTimestamp() {
     return (TimestampString) requireNonNull(value, "value");
   }
 
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlBasicTypeNameSpec.java b/core/src/main/java/org/apache/calcite/sql/SqlBasicTypeNameSpec.java
index 547bdfb22f4c..9b0434d91f02 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlBasicTypeNameSpec.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlBasicTypeNameSpec.java
@@ -158,9 +158,9 @@ public int getPrecision() {
     // instead of direct unparsing with enum name.
     // i.e. TIME_WITH_LOCAL_TIME_ZONE(3)
     // would be unparsed as "time(3) with local time zone".
-    final boolean isWithLocalTimeZone = isWithLocalTimeZoneDef(sqlTypeName);
-    if (isWithLocalTimeZone) {
-      writer.keyword(stripLocalTimeZoneDef(sqlTypeName).name());
+    final boolean isWithTimeZone = isWithTimeZoneDef(sqlTypeName);
+    if (isWithTimeZone) {
+      writer.keyword(stripTimeZoneDef(sqlTypeName).name());
     } else {
       writer.keyword(getTypeName().getSimple());
     }
@@ -176,8 +176,12 @@ public int getPrecision() {
       writer.endList(frame);
     }
 
-    if (isWithLocalTimeZone) {
-      writer.keyword("WITH LOCAL TIME ZONE");
+    if (isWithTimeZone) {
+      writer.keyword("WITH");
+      if (isWithLocalTimeZoneDef(sqlTypeName)) {
+        writer.keyword("LOCAL");
+      }
+      writer.keyword("TIME ZONE");
     }
 
     if (writer.getDialect().supportsCharSet() && charSetName != null) {
@@ -245,16 +249,23 @@ private static boolean isWithLocalTimeZoneDef(SqlTypeName typeName) {
     }
   }
 
+  private static boolean isWithTimeZoneDef(SqlTypeName typeName) {
+    return SqlTypeName.TZ_TYPES.contains(typeName);
+  }
+
   /**
-   * Remove the local time zone definition of the {@code typeName}.
+   * Remove the local time zone definition
+   * or the time zone definition of the {@code typeName}.
    *
    * @param typeName Type name
-   * @return new type name without local time zone definition
+   * @return new type name without (local) time zone definition
    */
-  private static SqlTypeName stripLocalTimeZoneDef(SqlTypeName typeName) {
+  private static SqlTypeName stripTimeZoneDef(SqlTypeName typeName) {
     switch (typeName) {
+    case TIME_TZ:
     case TIME_WITH_LOCAL_TIME_ZONE:
       return SqlTypeName.TIME;
+    case TIMESTAMP_TZ:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       return SqlTypeName.TIMESTAMP;
     default:
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlJdbcDataTypeName.java b/core/src/main/java/org/apache/calcite/sql/SqlJdbcDataTypeName.java
index eaf47de6ee7f..7046fee075fc 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlJdbcDataTypeName.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlJdbcDataTypeName.java
@@ -37,8 +37,10 @@ public enum SqlJdbcDataTypeName implements Symbolizable {
   SQL_DATE(SqlTypeName.DATE),
   SQL_TIME(SqlTypeName.TIME),
   SQL_TIME_WITH_LOCAL_TIME_ZONE(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE),
+  SQL_TIME_WITH_TIME_ZONE(SqlTypeName.TIME_TZ),
   SQL_TIMESTAMP(SqlTypeName.TIMESTAMP),
   SQL_TIMESTAMP_WITH_LOCAL_TIME_ZONE(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE),
+  SQL_TIMESTAMP_WITH_TIME_ZONE(SqlTypeName.TIMESTAMP_TZ),
   SQL_DECIMAL(SqlTypeName.DECIMAL),
   SQL_NUMERIC(SqlTypeName.DECIMAL),
   SQL_BOOLEAN(SqlTypeName.BOOLEAN),
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlLiteral.java
index 67c5d00d7b1e..ae41cbe54e96 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlLiteral.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlLiteral.java
@@ -37,7 +37,9 @@
 import org.apache.calcite.util.Litmus;
 import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.TimeString;
+import org.apache.calcite.util.TimeWithTimeZoneString;
 import org.apache.calcite.util.TimestampString;
+import org.apache.calcite.util.TimestampWithTimeZoneString;
 import org.apache.calcite.util.Util;
 
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -205,10 +207,15 @@ public static boolean valueMatchesType(
     case DATE:
       return value instanceof DateString;
     case TIME:
+    case TIME_WITH_LOCAL_TIME_ZONE:
       return value instanceof TimeString;
+    case TIME_TZ:
+      return value instanceof TimeWithTimeZoneString;
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       return value instanceof TimestampString;
+    case TIMESTAMP_TZ:
+      return value instanceof TimestampWithTimeZoneString;
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
     case INTERVAL_MONTH:
@@ -893,6 +900,14 @@ public static SqlTimestampLiteral createTimestamp(
     return new SqlTimestampLiteral(ts, precision, typeName, pos);
   }
 
+  /** Creates a TIMESTAMP WITH TIME ZONE literal. */
+  public static SqlTimestampTzLiteral createTimestamp(
+      TimestampWithTimeZoneString ts,
+      int precision,
+      SqlParserPos pos) {
+    return new SqlTimestampTzLiteral(ts, precision, pos);
+  }
+
   @Deprecated // to be removed before 2.0
   public static SqlTimeLiteral createTime(
       Calendar calendar,
@@ -908,6 +923,12 @@ public static SqlTimeLiteral createTime(
     return new SqlTimeLiteral(t, precision, false, pos);
   }
 
+  public static SqlTimeTzLiteral createTime(
+      TimeWithTimeZoneString t,
+      int precision,
+      SqlParserPos pos) {
+    return new SqlTimeTzLiteral(t, precision, pos);
+  }
   /**
    * Creates an interval literal.
    *
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlTimeTzLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlTimeTzLiteral.java
new file mode 100644
index 000000000000..19dd05ff6cea
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/SqlTimeTzLiteral.java
@@ -0,0 +1,70 @@
+/*
+ * 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;
+
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.util.TimeWithTimeZoneString;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Objects;
+
+/**
+ * A SQL literal representing a TIME WITH TIME ZONE value, for example <code>TIME WITH TIME ZONE
+ * '14:33:44.567 GMT+08'</code>.
+ *
+ * <p>Create values using {@link SqlLiteral#createTime}.
+ */
+public class SqlTimeTzLiteral extends SqlAbstractDateTimeLiteral {
+  //~ Constructors -----------------------------------------------------------
+
+  SqlTimeTzLiteral(TimeWithTimeZoneString t, int precision,
+                             SqlParserPos pos) {
+    super(t, true, SqlTypeName.TIME_TZ, precision, pos);
+    Preconditions.checkArgument(this.precision >= 0);
+  }
+
+  //~ Methods ----------------------------------------------------------------
+
+  /** Converts this literal to a {@link TimeWithTimeZoneString}. */
+  protected TimeWithTimeZoneString getTime() {
+    return (TimeWithTimeZoneString) Objects.requireNonNull(value, "value");
+  }
+
+  @Override public SqlTimeTzLiteral clone(SqlParserPos pos) {
+    return new SqlTimeTzLiteral(getTime(), precision, pos);
+  }
+
+  @Override public String toString() {
+    return "TIME WITH TIME ZONE '" + toFormattedString() + "'";
+  }
+
+  /**
+   * Returns e.g. '03:05:67.456 GMT+00:00'.
+   */
+  @Override public String toFormattedString() {
+    return getTime().toString(precision);
+  }
+
+  @Override public void unparse(
+      SqlWriter writer,
+      int leftPrec,
+      int rightPrec) {
+    writer.getDialect().unparseDateTimeLiteral(writer, this, leftPrec, rightPrec);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlTimestampLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlTimestampLiteral.java
index d70b677279fc..8d1e6ec6365f 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlTimestampLiteral.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlTimestampLiteral.java
@@ -26,7 +26,7 @@
 
 /**
  * A SQL literal representing a TIMESTAMP value, for example <code>TIMESTAMP
- * '1969-07-21 03:15 GMT'</code>.
+ * '1969-07-21 03:15'</code>.
  *
  * <p>Create values using {@link SqlLiteral#createTimestamp}.
  */
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlTimestampTzLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlTimestampTzLiteral.java
new file mode 100644
index 000000000000..0e7903802bdf
--- /dev/null
+++ b/core/src/main/java/org/apache/calcite/sql/SqlTimestampTzLiteral.java
@@ -0,0 +1,70 @@
+/*
+ * 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;
+
+import org.apache.calcite.sql.parser.SqlParserPos;
+import org.apache.calcite.sql.type.SqlTypeName;
+import org.apache.calcite.util.TimestampWithTimeZoneString;
+
+import com.google.common.base.Preconditions;
+
+import java.util.Objects;
+
+/**
+ * A SQL literal representing a TIMESTAMP WITH TIME ZONE value, for example <code>TIMESTAMP
+ * '1969-07-21 03:15 GMT+00:00'</code>.
+ *
+ * <p>Create values using {@link SqlLiteral#createTimestamp}.
+ */
+public class SqlTimestampTzLiteral extends SqlAbstractDateTimeLiteral {
+  //~ Constructors -----------------------------------------------------------
+
+  SqlTimestampTzLiteral(TimestampWithTimeZoneString ts, int precision, SqlParserPos pos) {
+    super(ts, false, SqlTypeName.TIMESTAMP_TZ, precision, pos);
+    Preconditions.checkArgument(this.precision >= 0);
+  }
+
+  //~ Methods ----------------------------------------------------------------
+
+  @Override public SqlTimestampTzLiteral clone(SqlParserPos pos) {
+    return new SqlTimestampTzLiteral(
+        getTimestampTz(), precision, pos);
+  }
+
+  @Override public String toString() {
+    return getTypeName() + " '" + toFormattedString() + "'";
+  }
+
+  @Override public String toFormattedString() {
+    TimestampWithTimeZoneString ts = getTimestampTz();
+    if (precision > 0) {
+      ts = ts.round(precision);
+    }
+    return ts.toString(precision);
+  }
+
+  TimestampWithTimeZoneString getTimestampTz() {
+    return (TimestampWithTimeZoneString) Objects.requireNonNull(value, "value");
+  }
+
+  @Override public void unparse(
+      SqlWriter writer,
+      int leftPrec,
+      int rightPrec) {
+    writer.getDialect().unparseDateTimeLiteral(writer, this, leftPrec, rightPrec);
+  }
+}
diff --git a/core/src/main/java/org/apache/calcite/sql/SqlUnknownLiteral.java b/core/src/main/java/org/apache/calcite/sql/SqlUnknownLiteral.java
index a6cbbbbf48d1..a0a811e07a25 100644
--- a/core/src/main/java/org/apache/calcite/sql/SqlUnknownLiteral.java
+++ b/core/src/main/java/org/apache/calcite/sql/SqlUnknownLiteral.java
@@ -57,10 +57,14 @@ public SqlLiteral resolve(SqlTypeName typeName) {
       return SqlParserUtil.parseDateLiteral(getValue(), pos);
     case TIME:
       return SqlParserUtil.parseTimeLiteral(getValue(), pos);
+    case TIME_TZ:
+      return SqlParserUtil.parseTimeTzLiteral(getValue(), pos);
     case TIMESTAMP:
       return SqlParserUtil.parseTimestampLiteral(getValue(), pos);
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
       return SqlParserUtil.parseTimestampWithLocalTimeZoneLiteral(getValue(), pos);
+    case TIMESTAMP_TZ:
+      return SqlParserUtil.parseTimestampTzLiteral(getValue(), pos);
     default:
       throw Util.unexpected(typeName);
     }
diff --git a/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java b/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
index ca3c0a708442..44fecaa05369 100644
--- a/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
+++ b/core/src/main/java/org/apache/calcite/sql/parser/SqlParserUtil.java
@@ -36,7 +36,9 @@
 import org.apache.calcite.sql.SqlPrefixOperator;
 import org.apache.calcite.sql.SqlSpecialOperator;
 import org.apache.calcite.sql.SqlTimeLiteral;
+import org.apache.calcite.sql.SqlTimeTzLiteral;
 import org.apache.calcite.sql.SqlTimestampLiteral;
+import org.apache.calcite.sql.SqlTimestampTzLiteral;
 import org.apache.calcite.sql.SqlUtil;
 import org.apache.calcite.sql.fun.SqlStdOperatorTable;
 import org.apache.calcite.sql.parser.impl.SqlParserImpl;
@@ -44,7 +46,9 @@
 import org.apache.calcite.util.DateString;
 import org.apache.calcite.util.PrecedenceClimbingParser;
 import org.apache.calcite.util.TimeString;
+import org.apache.calcite.util.TimeWithTimeZoneString;
 import org.apache.calcite.util.TimestampString;
+import org.apache.calcite.util.TimestampWithTimeZoneString;
 import org.apache.calcite.util.Util;
 import org.apache.calcite.util.trace.CalciteTrace;
 
@@ -65,6 +69,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.StringTokenizer;
+import java.util.TimeZone;
 import java.util.function.Predicate;
 import java.util.regex.Pattern;
 
@@ -352,6 +357,31 @@ public static SqlTimeLiteral parseTimeLiteral(String s, SqlParserPos pos) {
     return SqlLiteral.createTime(t, pt.getPrecision(), pos);
   }
 
+  public static SqlTimeTzLiteral parseTimeTzLiteral(
+      String s, SqlParserPos pos) {
+    // We expect the string to end in a timezone.
+    final int lastSpace = s.lastIndexOf(" ");
+    DateTimeUtils.PrecisionTime pt = null;
+    if (lastSpace >= 0) {
+      final String timeZone = s.substring(lastSpace + 1);
+      final String time = s.substring(0, lastSpace);
+
+      final TimeZone tz = TimeZone.getTimeZone(timeZone);
+      if (tz != null) {
+        pt =
+            DateTimeUtils.parsePrecisionDateTimeLiteral(time, Format.get().time, tz, -1);
+      }
+    }
+    if (pt == null) {
+      throw SqlUtil.newContextException(pos,
+          RESOURCE.illegalLiteral("TIME WITH TIME ZONE", s,
+              RESOURCE.badFormat(DateTimeUtils.TIME_FORMAT_STRING).str()));
+    }
+    final TimeWithTimeZoneString t = TimeWithTimeZoneString.fromCalendarFields(pt.getCalendar())
+        .withFraction(pt.getFraction());
+    return SqlLiteral.createTime(t, pt.getPrecision(), pos);
+  }
+
   public static SqlTimestampLiteral parseTimestampLiteral(String s,
       SqlParserPos pos) {
     return parseTimestampLiteral(SqlTypeName.TIMESTAMP, s, pos);
@@ -363,6 +393,25 @@ public static SqlTimestampLiteral parseTimestampWithLocalTimeZoneLiteral(
         pos);
   }
 
+  public static SqlTimestampTzLiteral parseTimestampTzLiteral(
+      String s, SqlParserPos pos) {
+    // We expect the string to end in a timezone.
+    int lastSpace = s.lastIndexOf(" ");
+    if (lastSpace >= 0) {
+      final String timeZone = s.substring(lastSpace + 1);
+      final String timestamp = s.substring(0, lastSpace);
+      TimeZone tz = TimeZone.getTimeZone(timeZone);
+      if (tz != null) {
+        SqlTimestampLiteral ts = parseTimestampLiteral(SqlTypeName.TIMESTAMP, timestamp, pos);
+        TimestampWithTimeZoneString tsz = new TimestampWithTimeZoneString(ts.getTimestamp(), tz);
+        return SqlLiteral.createTimestamp(tsz, ts.getPrec(), pos);
+      }
+    }
+    throw SqlUtil.newContextException(pos,
+        RESOURCE.illegalLiteral("TIMESTAMP WITH TIME ZONE", s,
+            RESOURCE.badFormat(DateTimeUtils.TIMESTAMP_FORMAT_STRING).str()));
+  }
+
   private static SqlTimestampLiteral parseTimestampLiteral(SqlTypeName typeName,
       String s, SqlParserPos pos) {
     final Format format = Format.get();
diff --git a/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java b/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
index 342284dd1587..386ed96fb915 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/ReturnTypes.java
@@ -376,6 +376,13 @@ public static SqlCall stripSeparator(SqlCall call) {
   public static final SqlReturnTypeInference TIMESTAMP_LTZ =
       explicit(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
 
+  /**
+   * Type-inference strategy whereby the result type of a call is TIMESTAMP
+   * WITH TIME ZONE.
+   */
+  public static final SqlReturnTypeInference TIMESTAMP_TZ =
+      explicit(SqlTypeName.TIMESTAMP_TZ);
+
   /**
    * Type-inference strategy whereby the result type of a call is nullable
    * TIMESTAMP WITH LOCAL TIME ZONE.
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
index 6167c4df0167..c77f0b121e22 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeAssignmentRule.java
@@ -175,6 +175,9 @@ private SqlTypeAssignmentRule(
     rules.add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE,
         EnumSet.of(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE));
 
+    // TIME WITH TIME ZONE is assignable from...
+    rules.add(SqlTypeName.TIME_TZ, EnumSet.of(SqlTypeName.TIME_TZ));
+
     // TIMESTAMP is assignable from ...
     rules.add(SqlTypeName.TIMESTAMP, EnumSet.of(SqlTypeName.TIMESTAMP));
 
@@ -182,6 +185,9 @@ private SqlTypeAssignmentRule(
     rules.add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE,
         EnumSet.of(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE));
 
+    // TIMESTAMP WITH TIME ZONE is assignable from...
+    rules.add(SqlTypeName.TIMESTAMP_TZ, EnumSet.of(SqlTypeName.TIMESTAMP_TZ));
+
     // GEOMETRY is assignable from ...
     rule.clear();
     rule.add(SqlTypeName.GEOMETRY);
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
index 7370c1db9e73..4ab42dfb0c7e 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeCoercionRule.java
@@ -120,6 +120,7 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
     rule.add(SqlTypeName.VARCHAR);
     rule.add(SqlTypeName.TIMESTAMP);
     rule.add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+    rule.add(SqlTypeName.TIMESTAMP_TZ);
 
     coerceRules.add(SqlTypeName.TINYINT, rule);
     coerceRules.add(SqlTypeName.SMALLINT, rule);
@@ -176,8 +177,11 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
             .add(SqlTypeName.BOOLEAN)
             .add(SqlTypeName.DATE)
             .add(SqlTypeName.TIME)
+            .add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIME_TZ)
             .add(SqlTypeName.TIMESTAMP)
             .add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIMESTAMP_TZ)
             .addAll(SqlTypeName.BINARY_TYPES)
             .addAll(SqlTypeName.NUMERIC_TYPES)
             .addAll(SqlTypeName.INTERVAL_TYPES)
@@ -191,8 +195,11 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
             .add(SqlTypeName.BOOLEAN)
             .add(SqlTypeName.DATE)
             .add(SqlTypeName.TIME)
+            .add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIME_TZ)
             .add(SqlTypeName.TIMESTAMP)
             .add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIMESTAMP_TZ)
             .addAll(SqlTypeName.BINARY_TYPES)
             .addAll(SqlTypeName.NUMERIC_TYPES)
             .addAll(SqlTypeName.INTERVAL_TYPES)
@@ -214,6 +221,7 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
         coerceRules.copyValues(SqlTypeName.DATE)
             .add(SqlTypeName.TIMESTAMP)
             .add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIMESTAMP_TZ)
             .add(SqlTypeName.CHAR)
             .add(SqlTypeName.VARCHAR)
             .addAll(SqlTypeName.BINARY_TYPES)
@@ -223,8 +231,10 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
     coerceRules.add(SqlTypeName.TIME,
         coerceRules.copyValues(SqlTypeName.TIME)
             .add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIME_TZ)
             .add(SqlTypeName.TIMESTAMP)
             .add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIMESTAMP_TZ)
             .add(SqlTypeName.CHAR)
             .add(SqlTypeName.VARCHAR)
             .addAll(SqlTypeName.BINARY_TYPES)
@@ -233,9 +243,24 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
     // TIME WITH LOCAL TIME ZONE is castable from...
     coerceRules.add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE,
         coerceRules.copyValues(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIME_TZ)
+            .add(SqlTypeName.TIME)
+            .add(SqlTypeName.TIMESTAMP)
+            .add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIMESTAMP_TZ)
+            .add(SqlTypeName.CHAR)
+            .add(SqlTypeName.VARCHAR)
+            .addAll(SqlTypeName.BINARY_TYPES)
+            .build());
+
+    // TIME WITH TIME ZONE is castable from...
+    coerceRules.add(SqlTypeName.TIME_TZ,
+        coerceRules.copyValues(SqlTypeName.TIME_TZ)
+            .add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
             .add(SqlTypeName.TIME)
             .add(SqlTypeName.TIMESTAMP)
             .add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIMESTAMP_TZ)
             .add(SqlTypeName.CHAR)
             .add(SqlTypeName.VARCHAR)
             .addAll(SqlTypeName.BINARY_TYPES)
@@ -245,9 +270,11 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
     coerceRules.add(SqlTypeName.TIMESTAMP,
         coerceRules.copyValues(SqlTypeName.TIMESTAMP)
             .add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIMESTAMP_TZ)
             .add(SqlTypeName.DATE)
             .add(SqlTypeName.TIME)
             .add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIME_TZ)
             .add(SqlTypeName.CHAR)
             .add(SqlTypeName.VARCHAR)
             .addAll(SqlTypeName.BINARY_TYPES)
@@ -257,10 +284,27 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
     // TIMESTAMP WITH LOCAL TIME ZONE is castable from...
     coerceRules.add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE,
         coerceRules.copyValues(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIMESTAMP_TZ)
+            .add(SqlTypeName.TIMESTAMP)
+            .add(SqlTypeName.DATE)
+            .add(SqlTypeName.TIME)
+            .add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIME_TZ)
+            .add(SqlTypeName.CHAR)
+            .add(SqlTypeName.VARCHAR)
+            .addAll(SqlTypeName.BINARY_TYPES)
+            .addAll(SqlTypeName.NUMERIC_TYPES)
+            .build());
+
+    // TIMESTAMP WITH TIME ZONE is castable from...
+    coerceRules.add(SqlTypeName.TIMESTAMP_TZ,
+        coerceRules.copyValues(SqlTypeName.TIMESTAMP_TZ)
+            .add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE)
             .add(SqlTypeName.TIMESTAMP)
             .add(SqlTypeName.DATE)
             .add(SqlTypeName.TIME)
             .add(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE)
+            .add(SqlTypeName.TIME_TZ)
             .add(SqlTypeName.CHAR)
             .add(SqlTypeName.VARCHAR)
             .addAll(SqlTypeName.BINARY_TYPES)
@@ -292,6 +336,7 @@ private SqlTypeCoercionRule(Map<SqlTypeName, ImmutableSet<SqlTypeName>> map) {
     rule.add(SqlTypeName.BOOLEAN);
     rule.add(SqlTypeName.TIMESTAMP);
     rule.add(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+    rule.add(SqlTypeName.TIMESTAMP_TZ);
 
     coerceRules.add(SqlTypeName.TINYINT, rule);
     coerceRules.add(SqlTypeName.SMALLINT, rule);
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
index 58b616798e53..050902238c0c 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeFamily.java
@@ -179,9 +179,13 @@ public Collection<SqlTypeName> getTypeNames() {
     case DATE:
       return ImmutableList.of(SqlTypeName.DATE);
     case TIME:
-      return ImmutableList.of(SqlTypeName.TIME, SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE);
+      return ImmutableList.of(SqlTypeName.TIME,
+          SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE,
+          SqlTypeName.TIME_TZ);
     case TIMESTAMP:
-      return ImmutableList.of(SqlTypeName.TIMESTAMP, SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+      return ImmutableList.of(SqlTypeName.TIMESTAMP,
+          SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE,
+          SqlTypeName.TIMESTAMP_TZ);
     case BOOLEAN:
       return SqlTypeName.BOOLEAN_TYPES;
     case INTERVAL_YEAR_MONTH:
diff --git a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
index 442e5ce77319..0c856e3ffa13 100644
--- a/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
+++ b/core/src/main/java/org/apache/calcite/sql/type/SqlTypeName.java
@@ -65,12 +65,16 @@ public enum SqlTypeName {
   DATE(PrecScale.NO_NO, false, Types.DATE, SqlTypeFamily.DATE),
   TIME(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIME,
       SqlTypeFamily.TIME),
-  TIME_WITH_LOCAL_TIME_ZONE(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.OTHER,
+  TIME_WITH_LOCAL_TIME_ZONE(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIME,
+      SqlTypeFamily.TIME),
+  TIME_TZ(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIME,
       SqlTypeFamily.TIME),
   TIMESTAMP(PrecScale.NO_NO | PrecScale.YES_NO, false, Types.TIMESTAMP,
       SqlTypeFamily.TIMESTAMP),
   TIMESTAMP_WITH_LOCAL_TIME_ZONE(PrecScale.NO_NO | PrecScale.YES_NO, false,
       Types.TIMESTAMP, SqlTypeFamily.TIMESTAMP),
+  TIMESTAMP_TZ(PrecScale.NO_NO | PrecScale.YES_NO, false,
+      Types.TIMESTAMP, SqlTypeFamily.TIMESTAMP),
   INTERVAL_YEAR(PrecScale.NO_NO, false, Types.OTHER,
       SqlTypeFamily.INTERVAL_YEAR_MONTH),
   INTERVAL_YEAR_MONTH(PrecScale.NO_NO, false, Types.OTHER,
@@ -159,7 +163,8 @@ public enum SqlTypeName {
           INTERVAL_DAY, INTERVAL_DAY_HOUR, INTERVAL_DAY_MINUTE,
           INTERVAL_DAY_SECOND, INTERVAL_HOUR, INTERVAL_HOUR_MINUTE,
           INTERVAL_HOUR_SECOND, INTERVAL_MINUTE, INTERVAL_MINUTE_SECOND,
-          INTERVAL_SECOND, TIME_WITH_LOCAL_TIME_ZONE, TIMESTAMP_WITH_LOCAL_TIME_ZONE,
+          INTERVAL_SECOND, TIME_WITH_LOCAL_TIME_ZONE, TIME_TZ,
+          TIMESTAMP_WITH_LOCAL_TIME_ZONE, TIMESTAMP_TZ,
           FLOAT, MULTISET, DISTINCT, STRUCTURED, ROW, CURSOR, COLUMN_LIST);
 
   public static final List<SqlTypeName> BOOLEAN_TYPES =
@@ -193,8 +198,13 @@ public enum SqlTypeName {
       ImmutableList.of(GEOMETRY);
 
   public static final List<SqlTypeName> DATETIME_TYPES =
-      ImmutableList.of(DATE, TIME, TIME_WITH_LOCAL_TIME_ZONE,
-          TIMESTAMP, TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+      ImmutableList.of(DATE, TIME, TIME_WITH_LOCAL_TIME_ZONE, TIME_TZ,
+          TIMESTAMP, TIMESTAMP_WITH_LOCAL_TIME_ZONE, TIMESTAMP_TZ);
+
+  /** Types that contain time zone information. */
+  public static final List<SqlTypeName> TZ_TYPES =
+      ImmutableList.of(TIME_WITH_LOCAL_TIME_ZONE, TIME_TZ,
+          TIMESTAMP_WITH_LOCAL_TIME_ZONE, TIMESTAMP_TZ);
 
   public static final Set<SqlTypeName> YEAR_INTERVAL_TYPES =
       Sets.immutableEnumSet(SqlTypeName.INTERVAL_YEAR,
@@ -309,7 +319,12 @@ public enum SqlTypeName {
    * matches the given name, or throws {@link IllegalArgumentException}; never
    * returns null. */
   public static SqlTypeName lookup(String tag) {
-    String tag2 = tag.replace(' ', '_');
+    // Special handling for TIME WITH TIME ZONE and
+    // TIMESTAMP WITH TIME ZONE, whose type names are TIME_TZ and TIMESTAMP_TZ.
+    // We know that the type name is always uppercase, because it is
+    // inserted in the tag by the parser.
+    final String tag1 = tag.replace("WITH TIME ZONE", "TZ");
+    final String tag2 = tag1.replace(' ', '_');
     return valueOf(tag2);
   }
 
@@ -776,8 +791,10 @@ public int getMinPrecision() {
     case BINARY:
     case TIME:
     case TIME_WITH_LOCAL_TIME_ZONE:
+    case TIME_TZ:
     case TIMESTAMP:
     case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
+    case TIMESTAMP_TZ:
       return 1;
     case INTERVAL_YEAR:
     case INTERVAL_YEAR_MONTH:
diff --git a/core/src/main/java/org/apache/calcite/sql2rel/SqlNodeToRexConverterImpl.java b/core/src/main/java/org/apache/calcite/sql2rel/SqlNodeToRexConverterImpl.java
index 313fda132c00..2b9912867992 100644
--- a/core/src/main/java/org/apache/calcite/sql2rel/SqlNodeToRexConverterImpl.java
+++ b/core/src/main/java/org/apache/calcite/sql2rel/SqlNodeToRexConverterImpl.java
@@ -32,6 +32,7 @@
 import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.TimeString;
 import org.apache.calcite.util.TimestampString;
+import org.apache.calcite.util.TimestampWithTimeZoneString;
 import org.apache.calcite.util.Util;
 
 import java.math.BigDecimal;
@@ -124,6 +125,10 @@ public class SqlNodeToRexConverterImpl implements SqlNodeToRexConverter {
       return rexBuilder.makeTimestampWithLocalTimeZoneLiteral(
           literal.getValueAs(TimestampString.class),
           ((SqlTimestampLiteral) literal).getPrec());
+    case TIMESTAMP_TZ:
+      return rexBuilder.makeTimestampTzLiteral(
+          literal.getValueAs(TimestampWithTimeZoneString.class),
+          ((SqlTimestampLiteral) literal).getPrec());
     case TIME:
       return rexBuilder.makeTimeLiteral(
           literal.getValueAs(TimeString.class),
diff --git a/core/src/main/java/org/apache/calcite/util/TimeWithTimeZoneString.java b/core/src/main/java/org/apache/calcite/util/TimeWithTimeZoneString.java
index a57e949cdc82..2087b79af631 100644
--- a/core/src/main/java/org/apache/calcite/util/TimeWithTimeZoneString.java
+++ b/core/src/main/java/org/apache/calcite/util/TimeWithTimeZoneString.java
@@ -74,6 +74,12 @@ public TimeWithTimeZoneString withMillis(int millis) {
     return withFraction(DateTimeStringUtils.pad(3, millis));
   }
 
+  /** Creates a TimeWithTimeZoneString from a Calendar. */
+  public static TimeWithTimeZoneString fromCalendarFields(Calendar calendar) {
+    TimeString ts = TimeString.fromCalendarFields(calendar);
+    return new TimeWithTimeZoneString(ts, calendar.getTimeZone());
+  }
+
   /** Sets the fraction field of a {@code TimeString} to a given number
    * of nanoseconds. Nukes the value set via {@link #withMillis(int)}.
    *
diff --git a/core/src/main/java/org/apache/calcite/util/TimestampString.java b/core/src/main/java/org/apache/calcite/util/TimestampString.java
index 45d7eb9cc1aa..c6c7c18adeb4 100644
--- a/core/src/main/java/org/apache/calcite/util/TimestampString.java
+++ b/core/src/main/java/org/apache/calcite/util/TimestampString.java
@@ -25,6 +25,7 @@
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.util.Calendar;
+import java.util.TimeZone;
 import java.util.regex.Pattern;
 
 import static com.google.common.base.Preconditions.checkArgument;
@@ -222,6 +223,10 @@ public Calendar toCalendar() {
     return Util.calendar(getMillisSinceEpoch());
   }
 
+  public Calendar toCalendar(TimeZone timeZone) {
+    return Util.calendar(getMillisSinceEpoch(), timeZone);
+  }
+
   /** Converts this TimestampString to a string, truncated or padded with
    * zeros to a given precision. */
   public String toString(int precision) {
diff --git a/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java b/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java
index 8e31656a65f7..e3c08bb7f19e 100644
--- a/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java
+++ b/core/src/main/java/org/apache/calcite/util/TimestampWithTimeZoneString.java
@@ -100,6 +100,12 @@ public TimestampWithTimeZoneString withFraction(String fraction) {
         localDateTime.withFraction(fraction), timeZone);
   }
 
+  /** Creates a TimestampWithTimeZoneString from a Calendar. */
+  public static TimestampWithTimeZoneString fromCalendarFields(Calendar calendar) {
+    TimestampString ts = TimestampString.fromCalendarFields(calendar);
+    return new TimestampWithTimeZoneString(ts, calendar.getTimeZone());
+  }
+
   public TimestampWithTimeZoneString withTimeZone(TimeZone timeZone) {
     if (this.timeZone.equals(timeZone)) {
       return this;
@@ -193,4 +199,7 @@ public TimestampString getLocalTimestampString() {
     return localDateTime;
   }
 
+  public TimeZone getTimeZone() {
+    return timeZone;
+  }
 }
diff --git a/core/src/main/java/org/apache/calcite/util/Util.java b/core/src/main/java/org/apache/calcite/util/Util.java
index 2beda0a1a4d2..0674009f7fa8 100644
--- a/core/src/main/java/org/apache/calcite/util/Util.java
+++ b/core/src/main/java/org/apache/calcite/util/Util.java
@@ -2582,8 +2582,7 @@ public static void asStringBuilder(Appendable appendable,
     }
   }
 
-  /** Creates a {@link Calendar} in the UTC time zone and root locale.
-   * Does not use the time zone or locale. */
+  /** Creates a {@link Calendar} in the UTC time zone and root locale. */
   public static Calendar calendar() {
     return Calendar.getInstance(DateTimeUtils.UTC_ZONE, Locale.ROOT);
   }
@@ -2596,6 +2595,13 @@ public static Calendar calendar(long millis) {
     return calendar;
   }
 
+  /** Creates a {@link Calendar} in the specified time zone. */
+  public static Calendar calendar(long millis, TimeZone timeZone) {
+    Calendar calendar = Calendar.getInstance(timeZone, Locale.ROOT);
+    calendar.setTimeInMillis(millis);
+    return calendar;
+  }
+
   /**
    * Returns a {@code Collector} that accumulates the input elements into a
    * Guava {@link ImmutableList} via a {@link ImmutableList.Builder}.
diff --git a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
index e0dce8bebec7..45c8935a9154 100644
--- a/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
+++ b/core/src/test/java/org/apache/calcite/jdbc/CalciteRemoteDriverTest.java
@@ -319,7 +319,7 @@ private static ResultSet getTableTypes(Connection connection) {
     CalciteAssert.hr()
         .with(CalciteRemoteDriverTest::getRemoteConnection)
         .metaData(CalciteRemoteDriverTest::getTypeInfo)
-        .returns(CalciteAssert.checkResultCount(is(41)));
+        .returns(CalciteAssert.checkResultCount(is(43)));
   }
 
   @Test void testRemoteTableTypes() {
diff --git a/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java b/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
index bcba21687d93..9db5f8ed076b 100644
--- a/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
+++ b/core/src/test/java/org/apache/calcite/rex/RexBuilderTest.java
@@ -39,6 +39,7 @@
 import org.apache.calcite.util.Litmus;
 import org.apache.calcite.util.NlsString;
 import org.apache.calcite.util.TimeString;
+import org.apache.calcite.util.TimeWithTimeZoneString;
 import org.apache.calcite.util.TimestampString;
 import org.apache.calcite.util.TimestampWithTimeZoneString;
 import org.apache.calcite.util.Util;
@@ -438,6 +439,77 @@ private void checkTimestampWithLocalTimeZone(RexLiteral literal) {
     assertThat(literal.getValue3() instanceof Long, is(true));
   }
 
+  /** Tests
+   * {@link RexBuilder#makeTimestampTzLiteral(TimestampWithTimeZoneString, int)}. */
+  @Test void testTimestampTzLiterals() {
+    final RelDataTypeFactory typeFactory =
+        new SqlTypeFactoryImpl(RelDataTypeSystem.DEFAULT);
+    final RelDataType timestampType =
+        typeFactory.createSqlType(SqlTypeName.TIMESTAMP_TZ);
+    final RelDataType timestampType3 =
+        typeFactory.createSqlType(SqlTypeName.TIMESTAMP_TZ, 3);
+    final RelDataType timestampType9 =
+        typeFactory.createSqlType(SqlTypeName.TIMESTAMP_TZ, 9);
+    final RelDataType timestampType18 =
+        typeFactory.createSqlType(SqlTypeName.TIMESTAMP_TZ, 18);
+    final RexBuilder builder = new RexBuilder(typeFactory);
+
+    // The new way
+    final TimestampWithTimeZoneString ts =
+        new TimestampWithTimeZoneString(1969, 7, 21, 2, 56, 15,
+            TimeZone.getTimeZone("PST").getID());
+    checkTimestampTz(builder.makeLiteral(ts, timestampType));
+
+    // Now with milliseconds
+    final TimestampWithTimeZoneString ts2 = ts.withMillis(56);
+    assertThat(ts2, hasToString("1969-07-21 02:56:15.056 PST"));
+    final RexLiteral literal2 =
+        builder.makeLiteral(ts2, timestampType3);
+    assertThat(literal2.getValue(), hasToString("1969-07-21 02:56:15.056 PST"));
+
+    // Now with nanoseconds
+    final TimestampWithTimeZoneString ts3 = ts.withNanos(56);
+    final RexLiteral literal3 =
+        builder.makeLiteral(ts3, timestampType9);
+    assertThat(literal3.getValueAs(TimestampWithTimeZoneString.class),
+        hasToString("1969-07-21 02:56:15 PST"));
+    final TimestampWithTimeZoneString ts3b = ts.withNanos(2345678);
+    final RexLiteral literal3b =
+        builder.makeLiteral(ts3b, timestampType9);
+    assertThat(literal3b.getValueAs(TimestampWithTimeZoneString.class),
+        hasToString("1969-07-21 02:56:15.002 PST"));
+
+    // Now with a very long fraction
+    final TimestampWithTimeZoneString ts4 = ts.withFraction("102030405060708090102");
+    final RexLiteral literal4 =
+        builder.makeLiteral(ts4, timestampType18);
+    assertThat(literal4.getValueAs(TimestampWithTimeZoneString.class),
+        hasToString("1969-07-21 02:56:15.102 PST"));
+
+    // toString
+    assertThat(ts2.round(1), hasToString("1969-07-21 02:56:15 PST"));
+    assertThat(ts2.round(2), hasToString("1969-07-21 02:56:15.05 PST"));
+    assertThat(ts2.round(3), hasToString("1969-07-21 02:56:15.056 PST"));
+    assertThat(ts2.round(4), hasToString("1969-07-21 02:56:15.056 PST"));
+
+    assertThat(ts2.toString(6), is("1969-07-21 02:56:15.056000 PST"));
+    assertThat(ts2.toString(1), is("1969-07-21 02:56:15.0 PST"));
+    assertThat(ts2.toString(0), is("1969-07-21 02:56:15 PST"));
+
+    assertThat(ts2.round(0), hasToString("1969-07-21 02:56:15 PST"));
+    assertThat(ts2.round(0).toString(0), is("1969-07-21 02:56:15 PST"));
+    assertThat(ts2.round(0).toString(1), is("1969-07-21 02:56:15.0 PST"));
+    assertThat(ts2.round(0).toString(2), is("1969-07-21 02:56:15.00 PST"));
+  }
+
+  private void checkTimestampTz(RexLiteral literal) {
+    assertThat(literal,
+        hasToString("1969-07-21 02:56:15 PST:TIMESTAMP_TZ(0)"));
+    assertThat(literal.getValue() instanceof TimestampWithTimeZoneString, is(true));
+    assertThat(literal.getValue2() instanceof Long, is(true));
+    assertThat(literal.getValue3() instanceof Long, is(true));
+  }
+
   /** Tests {@link RexBuilder#makeTimeLiteral(TimeString, int)}. */
   @Test void testTimeLiteral() {
     final RelDataTypeFactory typeFactory =
@@ -827,7 +899,11 @@ private static Stream<Arguments> testData4testMakeZeroLiteral() {
         type2rexLiteral.apply(typeFactory.createSqlType(SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE),
             relDataType -> new TimeString(0, 0, 0)),
         type2rexLiteral.apply(typeFactory.createSqlType(SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE),
-            relDataType -> new TimestampString(0, 1, 1, 0, 0, 0)));
+            relDataType -> new TimestampString(0, 1, 1, 0, 0, 0)),
+        type2rexLiteral.apply(typeFactory.createSqlType(SqlTypeName.TIME_TZ),
+            relDataType -> new TimeWithTimeZoneString(0, 0, 0, "GMT+00:00")),
+        type2rexLiteral.apply(typeFactory.createSqlType(SqlTypeName.TIMESTAMP_TZ),
+            relDataType -> new TimestampWithTimeZoneString(0, 1, 1, 0, 0, 0, "GMT+00:00")));
   }
 
   /** Test case for
diff --git a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java
index 5a0d965f990d..a85fff1bf064 100644
--- a/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java
+++ b/core/src/test/java/org/apache/calcite/sql/type/SqlTypeFactoryTest.java
@@ -284,7 +284,9 @@ private void checkPrecision(int p0, int p1, int expectedMax,
     checkCreateSqlTypeWithPrecision(f.typeFactory, SqlTypeName.TIME);
     checkCreateSqlTypeWithPrecision(f.typeFactory, SqlTypeName.TIMESTAMP);
     checkCreateSqlTypeWithPrecision(f.typeFactory, SqlTypeName.TIME_WITH_LOCAL_TIME_ZONE);
+    checkCreateSqlTypeWithPrecision(f.typeFactory, SqlTypeName.TIME_TZ);
     checkCreateSqlTypeWithPrecision(f.typeFactory, SqlTypeName.TIMESTAMP_WITH_LOCAL_TIME_ZONE);
+    checkCreateSqlTypeWithPrecision(f.typeFactory, SqlTypeName.TIMESTAMP_TZ);
   }
 
   private void checkCreateSqlTypeWithPrecision(
diff --git a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
index 1308aa9c1b80..21e2e91c63c8 100644
--- a/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
+++ b/core/src/test/java/org/apache/calcite/test/SqlValidatorTest.java
@@ -278,8 +278,11 @@ static SqlOperatorTable operatorTableFor(SqlLibrary library) {
         .fails("(?s).*Illegal TIME literal.*");
     expr("^TIMESTAMP '12-21-99, 12:30:00'^")
         .fails("(?s).*Illegal TIMESTAMP literal.*");
+
     expr("^TIMESTAMP WITH LOCAL TIME ZONE '12-21-99, 12:30:00'^")
         .fails("(?s).*Illegal TIMESTAMP WITH LOCAL TIME ZONE literal.*");
+    expr("^TIMESTAMP WITH TIME ZONE '12-21-99, 12:30:00'^")
+        .fails("(?s).*Illegal TIMESTAMP literal.*");
   }
 
   /** PostgreSQL and Redshift allow TIMESTAMP literals that contain only a
@@ -1310,12 +1313,16 @@ void testLikeAndSimilarFails() {
         .columnType("TIME(0) NOT NULL");
     expr("cast('abc' as time with local time zone)")
         .columnType("TIME_WITH_LOCAL_TIME_ZONE(0) NOT NULL");
+    expr("cast('abc' as time with time zone)")
+        .columnType("TIME_TZ(0) NOT NULL");
     expr("cast('abc' as time(3))")
         .columnType("TIME(3) NOT NULL");
     expr("cast('abc' as time(3) without time zone)")
         .columnType("TIME(3) NOT NULL");
     expr("cast('abc' as time(3) with local time zone)")
         .columnType("TIME_WITH_LOCAL_TIME_ZONE(3) NOT NULL");
+    expr("cast('abc' as time(3) with time zone)")
+        .columnType("TIME_TZ(3) NOT NULL");
     // test cast to timestamp type.
     expr("cast('abc' as timestamp)")
         .columnType("TIMESTAMP(0) NOT NULL");
@@ -1323,12 +1330,16 @@ void testLikeAndSimilarFails() {
         .columnType("TIMESTAMP(0) NOT NULL");
     expr("cast('abc' as timestamp with local time zone)")
         .columnType("TIMESTAMP_WITH_LOCAL_TIME_ZONE(0) NOT NULL");
+    expr("cast('abc' as timestamp with time zone)")
+        .columnType("TIMESTAMP_TZ(0) NOT NULL");
     expr("cast('abc' as timestamp(3))")
         .columnType("TIMESTAMP(3) NOT NULL");
     expr("cast('abc' as timestamp(3) without time zone)")
         .columnType("TIMESTAMP(3) NOT NULL");
     expr("cast('abc' as timestamp(3) with local time zone)")
         .columnType("TIMESTAMP_WITH_LOCAL_TIME_ZONE(3) NOT NULL");
+    expr("cast('abc' as timestamp(3) with time zone)")
+        .columnType("TIMESTAMP_TZ(3) NOT NULL");
   }
 
   @Test void testCastRegisteredType() {
diff --git a/site/_docs/reference.md b/site/_docs/reference.md
index 21edb544d266..d8712e52ab65 100644
--- a/site/_docs/reference.md
+++ b/site/_docs/reference.md
@@ -1167,9 +1167,11 @@ name will have been converted to upper case also.
 | VARBINARY(n), BINARY VARYING(n) | Variable-length binary string | As BINARY(n)
 | DATE        | Date                      | Example: DATE '1969-07-20'
 | TIME        | Time of day               | Example: TIME '20:17:40'
+| TIME WITH LOCAL TIME ZONE | Time of day with local time zone | Example: TIME WITH LOCAL TIME ZONE '20:17:40'
+| TIME WITH TIME ZONE | Time of day with time zone | Example: TIME '20:17:40 GMT+08'
 | TIMESTAMP [ WITHOUT TIME ZONE ] | Date and time | Example: TIMESTAMP '1969-07-20 20:17:40'
-| TIMESTAMP WITH LOCAL TIME ZONE | Date and time with local time zone | Example: TIMESTAMP '1969-07-20 20:17:40 America/Los Angeles'
-| TIMESTAMP WITH TIME ZONE | Date and time with time zone | Example: TIMESTAMP '1969-07-20 20:17:40 America/Los Angeles'
+| TIMESTAMP WITH LOCAL TIME ZONE | Date and time with local time zone | Example: TIMESTAMP WITH LOCAL TIME ZONE '1969-07-20 20:17:40'
+| TIMESTAMP WITH TIME ZONE | Date and time with time zone | Example: TIMESTAMP WITH TIME ZONE '1969-07-20 20:17:40 America/Los Angeles'
 | INTERVAL timeUnit [ TO timeUnit ] | Date time interval | Examples: INTERVAL '1-5' YEAR TO MONTH, INTERVAL '45' DAY, INTERVAL '1 2:34:56.789' DAY TO SECOND
 | GEOMETRY | Geometry | Examples: ST_GeomFromText('POINT (30 10)')
 
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 a8ed3e6e5ace..c5bce8bd41c3 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
@@ -1783,7 +1783,7 @@ void checkPeriodPredicate(Checker checker) {
         .ok("CEIL((`X` + INTERVAL '1:20' MINUTE TO SECOND) TO MILLENNIUM)");
   }
 
-  @Test void testCast() {
+  @Test public void testCast() {
     expr("cast(x as boolean)")
         .ok("CAST(`X` AS BOOLEAN)");
     expr("cast(x as integer)")
@@ -1798,10 +1798,14 @@ void checkPeriodPredicate(Checker checker) {
         .ok("CAST(`X` AS TIME)");
     expr("cast(x as time with local time zone)")
         .ok("CAST(`X` AS TIME WITH LOCAL TIME ZONE)");
+    expr("cast(x as time with time zone)")
+        .ok("CAST(`X` AS TIME WITH TIME ZONE)");
     expr("cast(x as timestamp without time zone)")
         .ok("CAST(`X` AS TIMESTAMP)");
     expr("cast(x as timestamp with local time zone)")
         .ok("CAST(`X` AS TIMESTAMP WITH LOCAL TIME ZONE)");
+    expr("cast(x as timestamp with time zone)")
+        .ok("CAST(`X` AS TIMESTAMP WITH TIME ZONE)");
     expr("cast(x as time(0))")
         .ok("CAST(`X` AS TIME(0))");
     expr("cast(x as time(0) without time zone)")
@@ -1846,14 +1850,6 @@ void checkPeriodPredicate(Checker checker) {
   }
 
   @Test void testCastFails() {
-    expr("cast(x as time with ^time^ zone)")
-        .fails("(?s).*Encountered \"time\" at .*");
-    expr("cast(x as time(0) with ^time^ zone)")
-        .fails("(?s).*Encountered \"time\" at .*");
-    expr("cast(x as timestamp with ^time^ zone)")
-        .fails("(?s).*Encountered \"time\" at .*");
-    expr("cast(x as timestamp(0) with ^time^ zone)")
-        .fails("(?s).*Encountered \"time\" at .*");
     expr("cast(x as varchar(10) ^with^ local time zone)")
         .fails("(?s).*Encountered \"with\" at line 1, column 23.\n.*");
     expr("cast(x as varchar(10) ^without^ time zone)")
@@ -5550,8 +5546,11 @@ private static Matcher<SqlNode> isCharLiteral(String s) {
     expr("^DATE '12/21/99'^").same();
     expr("^TIME '1230:33'^").same();
     expr("^TIME '12:00:00 PM'^").same();
+    expr("^TIME WITH LOCAL TIME ZONE '12:00:00 PM'^").same();
+    expr("^TIME WITH TIME ZONE '12:00:00 PM GMT+0:00'^").same();
     expr("TIMESTAMP '12-21-99, 12:30:00'").same();
     expr("TIMESTAMP WITH LOCAL TIME ZONE '12-21-99, 12:30:00'").same();
+    expr("TIMESTAMP WITH TIME ZONE '12-21-99, 12:30:00 GMT+0:00'").same();
     expr("DATETIME '12-21-99, 12:30:00'").same();
   }