diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml
index 278066a4c7..e69b3331b3 100644
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -6,11 +6,13 @@ on:
       - '**'
       - '!docs/**'
       - '!**/*.md'
+      - '!**/*.adoc'
   pull_request:
     paths:
       - '**'
       - '!docs/**'
-      - '!**.*.md'
+      - '!**/*.md'
+      - '!**/*.adoc'
 
 jobs:
   test:
diff --git a/CHANGELOG.md b/CHANGELOG.md
index d2af301d93..5ebe5a3546 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -39,12 +39,27 @@ Thank you to all who have contributed!
   The default is `~/.partiql/plugins` . Each implementer of a plugin should place a directory under the 
   plugins root containing the JAR corresponding with their plugin implementation. 
   Example: `~/.partiql/plugins/customPlugin/customPlugin.jar`
+- Adds serialization and deserialization between IonValue and `org.partiql.value`.
+- Adds `org.partiql.ast` package and usage documentation
+- Adds `org.partiql.parser` package and usage documentation
+- Adds PartiQL's Timestamp Data Model.
+- Adds support for Timestamp constructor call in Parser.
+- Parsing of label patterns within node and edge graph patterns now supports 
+  disjunction `|`, conjunction `&`, negation `!`, and grouping.
 
 ### Changed
 - Standardizes `org/partiql/cli/functions/QueryDDB` and other built-in functions by the new `ExprFunction` format.
 - **Breaking**: Redefines `org/partiql/lang/eval/ExprFunctionkt.call()` method by only invoking `callWithRequired` function.
 - **Breaking**: Redefines `org/partiql/lang/eval/builtins/DynamicLookupExprFunction` by merging `variadicParameter` into `requiredParameters` as a `StaticType.LIST`. `callWithVariadic` is now replaced by `callWithRequired`.
 - **Breaking**: Modifies `functions` property of `CompilerPipeline`, `StaticTypeInferencer` and  `StepContext` to be a `List` and not a `Map`.
+- Upgrades ion-java to 1.10.2.
+- **Breaking** (within experimental graph features): As part of extending 
+  the language of graph label patterns: 
+  - Changed the type of the field `label` in AST nodes 
+    `org.partiql.lang.domains.PartiqlAst.GraphMatchPatternPart.{Node,Edge}`, 
+    from `SymbolPrimitive` to new `GraphLabelSpec`.
+  - Changed the names of subclasses of ` org.partiql.lang.graph.LabelSpec`, 
+    from `OneOf` to `Name`, and from `Whatever` to `Wildcard`.
 
 ### Deprecated
 - Deprecates Map<String, ExprFunction> representation of functions in the `CompilerPipeline`
@@ -69,6 +84,8 @@ Thank you to all who have contributed!
 Thank you to all who have contributed!
 - @howero
 - @yuxtang-amazon
+- @yliuuuu
+- @<your-username>
 
 ## [0.12.0] - 2023-06-14
 
diff --git a/buildSrc/src/main/kotlin/partiql.versions.kt b/buildSrc/src/main/kotlin/partiql.versions.kt
index 19a37c4ece..10b01bd99f 100644
--- a/buildSrc/src/main/kotlin/partiql.versions.kt
+++ b/buildSrc/src/main/kotlin/partiql.versions.kt
@@ -31,7 +31,7 @@ object Versions {
     const val gson = "2.10.1"
     const val guava = "31.1-jre"
     const val ionElement = "1.0.0"
-    const val ionJava = "1.9.0"
+    const val ionJava = "1.10.2"
     const val ionSchema = "1.2.1"
     const val jansi = "2.4.0"
     const val jline = "3.21.0"
@@ -41,7 +41,7 @@ object Versions {
     const val kotlinxCollections = "0.3.5"
     const val picoCli = "4.7.0"
     const val kasechange = "1.3.0"
-    const val ktlint = "10.2.1"
+    const val ktlint = "11.5.0"
     const val pig = "0.6.2"
 
     // Testing
diff --git a/docs/wiki/_Sidebar.md b/docs/wiki/_Sidebar.md
index 3944f7ad6c..3cd6537bb0 100644
--- a/docs/wiki/_Sidebar.md
+++ b/docs/wiki/_Sidebar.md
@@ -21,6 +21,8 @@
   * [Further Reading](https://github.com/partiql/partiql-lang-kotlin/wiki/Further-Reading)
 * Clauses
   * [EXPLAIN](https://github.com/partiql/partiql-lang-kotlin/wiki/Explain)
+* Serde
+  * [PartiQL Value <> ION](https://github.com/partiql/partiql-lang-kotlin/wiki/Serde)
 * Upgrade Guides
   * [Upgrade Guide General](https://github.com/partiql/partiql-lang-kotlin/wiki/upgrade-guide)
   * [CLI Versions](https://github.com/partiql/partiql-lang-kotlin/wiki/cli-versions)
diff --git a/docs/wiki/documentation/Functions.md b/docs/wiki/documentation/Functions.md
index 9ad99a4ad0..57ea621151 100644
--- a/docs/wiki/documentation/Functions.md
+++ b/docs/wiki/documentation/Functions.md
@@ -22,7 +22,7 @@ CHAR_LENGTH(null)    -- `null`
 CHAR_LENGTH(missing) -- `null` (also returns `null`)
 ```
 
-### CAST 
+### CAST -- since v0.1.0
 
 Given a value and a target data type, attempt to coerce the value to the target data type. 
 
@@ -243,7 +243,7 @@ CAST([1,[2],3]    AS bag) -- <<1,[2],3>> (REPL does not display << >> and commas
 CAST(<<'a', 'b'>> AS bag) -- <<'a', 'b'>> (REPL does not display << >> and commas)
 ```
 
-### CHAR_LENGTH, CHARACTER_LENGTH
+### CHAR_LENGTH, CHARACTER_LENGTH -- since v0.1.0
 
 Counts the number of characters in the specified string, where 'character' is defined as a single unicode code point.
 
@@ -274,7 +274,7 @@ CHAR_LENGTH('😁😞😸😸') -- 4 (non-BMP unicode characters)
 CHAR_LENGTH('eࠫ')         -- 2 (because 'eࠫ' is two codepoints: the letter 'e' and combining character U+032B)
 ```
 
-### COALESCE
+### COALESCE -- since v0.1.0
 
 Evaluates the arguments in order and returns the first non unknown, i.e. first non-`null` or non-`missing`. This function 
 does **not** propagate `null` and `missing`.
@@ -304,7 +304,7 @@ COALESCE(null, 'string')   -- 'string'
 COALESCE(missing, 1)       -- 1
 ```
 
-### DATE_ADD
+### DATE_ADD -- since v0.1.0
 
 Given a data part, a quantity and a timestamp, returns an updated timestamp by altering datetime part by quantity
 
@@ -343,7 +343,7 @@ DATE_ADD(minute, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:05:05.006Z
 DATE_ADD(second, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:04:06.006Z
 ```
 
-### DATE_DIFF
+### DATE_DIFF -- since v0.1.0
 
 Given a datetime part and two valid timestamps returns the difference in datetime parts.
 
@@ -374,7 +374,7 @@ DATE_DIFF(day, `2010-01-01T23:00T`, `2010-01-02T01:00T`) -- 0 (need to be at lea
 ```
 
 
-### EXISTS
+### EXISTS -- since v0.1.0
 
 Given a PartiQL value returns `true` if and only if the value is a non-empty container(bag, sexp, list or struct), returns `false` otherwise. 
 
@@ -413,7 +413,7 @@ EXISTS(null)        -- error
 EXISTS(missing)     -- error
 ```
 
-### EXTRACT
+### EXTRACT -- since v0.1.0
 
 Given a datetime part and a datetime type returns then datetime's datetime part value. 
 
@@ -474,7 +474,7 @@ EXTRACT(TIMEZONE_MINUTE FROM TIME WITH TIME ZONE '23:12:59-08:30')  -- -30
 ```
 *Note* that `timezone_hour` and `timezone_minute` are **not supported** for `DATE` and `TIME` (without time zone) type. 
 
-### `FILTER_DISTINCT`
+### `FILTER_DISTINCT` -- since v0.7.0
 
 Signature
 : `FILTER_DISTINCT: Container -> Bag`
@@ -496,7 +496,7 @@ FILTER_DISTINCT(SEXP(0, 0, 1))              -- <<0, 1>>
 FILTER_DISTINCT({'a': 0, 'b': 0, 'c': 1})   -- <<0, 1>>
 ```
 
-### LOWER 
+### LOWER  -- since v0.1.0
 
 Given a string convert all upper case characters to lower case characters.
 
@@ -519,7 +519,7 @@ Examples
 LOWER('AbCdEfG!@#$') -- 'abcdefg!@#$'
 ```
 
-### MAKE_DATE
+### MAKE_DATE -- since v0.3.0
 
 Given the integer values for the year, month and day returns the associated date.
 
@@ -550,7 +550,7 @@ MAKE_DATE(missing, 02, 28)               -- null
 MAKE_DATE(2021, missing, 28)             -- null
 MAKE_DATE(2021, 02, missing)             -- null
 ```
-### MAKE_TIME
+### MAKE_TIME -- since v0.3.0
 
 Given the values for the hour (int), minute (int), second (BigDecimal) and optionally for timezone minutes (int) returns the associated time.
 
@@ -584,7 +584,7 @@ MAKE_TIME(21, 02, 28., null)             -- null
 MAKE_TIME(21, 02, 28., missing)          -- null
 ```
 
-### SIZE, CARDINALITY
+### SIZE -- since v0.1.0, CARDINALITY -- since v0.10.0
 
 Given any container data type (i.e., list, structure or bag) return the number of elements in the container. 
 
@@ -618,7 +618,7 @@ SIZE(`[{foo: 1}, {foo: 2}]`) -- 2
 SIZE(12)                     -- error
 ```
 
-### NULLIF
+### NULLIF -- since v0.1.0
 
 Given two expressions return `null` if the two expressions evaluate to the same value, else, returns the result of evaluating 
 the first expression 
@@ -653,7 +653,7 @@ NULLIF(missing, null)    -- null
 NULLIF(missing, missing) -- null
 ```
     
-### SUBSTRING
+### SUBSTRING -- since v0.1.0
 
 Given a string, a start index and optionally a length, returns the
 substring from the start index up to the end of the string, or, up to
@@ -694,7 +694,7 @@ SUBSTRING("1", -4, 0)          -- ""
 SUBSTRING("1234", 10, 10)      -- ""
 ```
     
-### TO_STRING
+### TO_STRING -- since v0.1.0
 
 Given a timestamp and a format pattern return a string representation of the timestamp in the given format. 
 
@@ -762,7 +762,7 @@ TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXXX')  -- "1969-07-20T2
 ```
        
     
-### TO_TIMESTAMP
+### TO_TIMESTAMP -- since v0.1.0
 
 Given a string convert it to a timestamp. This is the inverse operation of [`TO_STRING`](#to_string)
 
@@ -828,7 +828,7 @@ indicate minimum and maximum allowable values for offsets.) In practice this wil
 not abuse the offset portion of Timestamp because real-life offsets do not exceed +/- 12h.  
 
 
-### TRIM
+### TRIM -- since v0.1.0
  
 Trims leading and/or trailing characters from a String. 
 
@@ -858,7 +858,7 @@ TRIM(BOTH '😁' FROM '😁😁foobar😁😁')         -- 'foobar'
 TRIM(BOTH '12' FROM '1112211foobar22211122') -- 'foobar'
 ```
 
-### UPPER 
+### UPPER -- since v0.1.0
 
 Given a string convert all lower case characters to upper case characters.
 
@@ -881,7 +881,7 @@ Examples
 UPPER('AbCdEfG!@#$') -- 'ABCDEFG!@#$'
 ```    
 
-### UTCNOW 
+### UTCNOW -- since v0.1.0
 
 Returns the current time in UTC as a timestamp. 
 
@@ -901,7 +901,7 @@ Examples
 UTCNOW() -- 2017-10-13T16:02:11.123Z 
 ```
 
-### UNIX_TIMESTAMP
+### UNIX_TIMESTAMP -- since v0.2.6
 
 With no `timestamp` argument, returns the number of seconds since the last epoch ('1970-01-01 00:00:00' UTC).
 
@@ -941,7 +941,7 @@ UNIX_TIMESTAMP(`2020-01-01T00:00:00.100Z`)  -- 1577836800.1
 UNIX_TIMESTAMP(`1969T`)                     -- -31536000 (timestamp is before last epoch)
 ```
 
-### FROM_UNIXTIME
+### FROM_UNIXTIME -- since v0.2.6
 
 Converts the given unix epoch into a timestamp.
 
@@ -972,7 +972,7 @@ FROM_UNIXTIME(1577836800)   -- `2020-01-01T00:00:00-00:00`      (unix_timestamp
 
 ## Math Functions
 
-### CEIL / CEILING
+### CEIL / CEILING -- since v0.7.0
 
 Returns the nearest integer greater than or equal to the input.
 
@@ -990,7 +990,7 @@ CEIL(`-inf`) = `-inf` -- Float
 CEIL(`nan`) = `nan` -- Float
 ```
 
-### FLOOR
+### FLOOR -- since v0.10.0
 
 Returns the nearest integer less than or equal to the input.
 
@@ -1008,7 +1008,7 @@ FLOOR(`-inf`) = `-inf` -- Float
 FLOOR(`nan`) = `nan` -- Float
 ```
 
-### ABS
+### ABS -- since v0.10.0
 
 Returns the absolute value of the given number. 
 
@@ -1035,7 +1035,7 @@ abs(`-inf`) = `+inf`
 abs(`nan`) = `nan`
 ```
 
-### MOD
+### MOD -- since v0.10.0
 
 MOD operates on two exact numeric arguments with scale 0 (zero) and returns
 the modulus (remainder) of the first argument divided by the second argument as an exact numeric with scale 0 (zero).
@@ -1059,7 +1059,7 @@ mod(17, 1)     -- 0
 mod(17, 3)     -- 2
 ```
 
-### SQRT
+### SQRT -- since v0.10.0
 
 Returns the square root of the given number.
 
@@ -1085,7 +1085,7 @@ sqrt(`+inf`) = `+inf`
 sqrt(`nan`) = `nan`
 ```
 
-### LN
+### LN -- since v0.10.0
 
 Returns the natural log of the given number.
 
@@ -1118,7 +1118,7 @@ ln(`+inf`) = `+inf`
 ln(`nan`) = `nan`
 ```
 
-### EXP
+### EXP -- since v0.10.0
 
 Returns e^x for a given x.
 
@@ -1151,7 +1151,7 @@ exp(`-inf`) = `0e0`
 exp(`nan`) = `nan`
 ```
 
-### POWER
+### POWER -- since v0.10.0
 
 POW(x,y) return x^y.
 
@@ -1210,7 +1210,7 @@ pow(`nan`, 1) = `nan`
 pow(1, `+inf`) = `nan`
 ```
 
-### BIT_LENGTH
+### BIT_LENGTH -- since v0.10.0
 
 Returns the number of bits in the input string.
 
@@ -1227,7 +1227,7 @@ Examples
 bit_length('jose') -- 32
 ```
 
-### OCTET_LENGTH
+### OCTET_LENGTH -- since v0.10.0
 
 Returns the number of bytes in the input string.
 
@@ -1244,7 +1244,7 @@ Examples
 octet_length('jose') -- 4
 ```
 
-### POSITION
+### POSITION -- since v0.10.0
 
 Position determines the first position (counting from 1), if any, at which one string, str1, occurs within
 another, str2. If str1 is of length zero, then it occurs at position 1 (one) for any value of str2. If str1
@@ -1275,7 +1275,7 @@ position('yy' in 'xxyyxxyy')   -- 3
 ```
 
 
-### OVERLAY
+### OVERLAY -- since v0.10.0
 
 OVERLAY modifies a string argument by replacing a given substring of the string, which is specified by a given numeric 
 starting position and a given numeric length, with another string (called the replacement string). When the length of
@@ -1312,7 +1312,7 @@ overlay('hello' placing 'XX' from 2 for 1)      -- "hXXllo
 overlay('hello' placing 'XX' from 2 for 3)      -- "hXXo
 ```
 
-### TEXT_REPLACE
+### TEXT_REPLACE -- since v0.10.0
 
 In `string`, replaces all occurrences of substring `from` with another string `to`. 
 
@@ -1338,8 +1338,9 @@ text_replace('', '', 'XX')                     -- 'XX'
 <!--
 This is the template for writing documentations for an PartiQL built-in function. 
 
-There are 5 parts to a function's documentation 
+There are 6 parts to a function's documentation 
 
+1. Function name with the first release version (exclude -SNAPSHOT)
 1. One sentence statement -- much like the first sentence of a Java method's Javadoc
 1. Signature -- the type signature of the function should use data types already defined on define a local data type using a WHERE clause 
 1. Header -- function with formal parameters only that we will use in the next step 
@@ -1348,7 +1349,7 @@ There are 5 parts to a function's documentation
 
 Here is an example for the imaginary function `add` 
 
-### ADD
+### ADD -- since vX.Y.Z
 
 Given 1 or more values return ther sum 
 
diff --git a/docs/wiki/serde/PartiQLValue <> ION.md b/docs/wiki/serde/PartiQLValue <> ION.md
new file mode 100644
index 0000000000..cf8dde54f5
--- /dev/null
+++ b/docs/wiki/serde/PartiQLValue <> ION.md	
@@ -0,0 +1,81 @@
+>> PartiQL value is an experimental feature. This serde is not finalized and may contain bugs.
+
+# PartiQL Value <> ION
+This section talks about Serialization and Deserialization between PartiQL Value and Ion Value.
+
+
+## Write To Ion Value
+>> syntax shown in example column are for demostration purpose only
+
+| PartiQLValue Type  | Ion Value Type      | example                                                                                                                                                                                                                                                                             |
+|--------------------|---------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| BOOL               | BOOL                | bool true -> true; false -> false                                                                                                                                                                                                                                                   |
+| INT8               | INT                 | int8 3 -> 3                                                                                                                                                                                                                                                                         |
+| INT16              | INT                 | int16 314 -> 314                                                                                                                                                                                                                                                                    |
+| INT32              | INT                 | int32 31415 -> 31415                                                                                                                                                                                                                                                                |
+| INT64              | INT                 | int64 314159265358 -> 314159265358                                                                                                                                                                                                                                                  |
+ | INT                | INT                 | int 31415926535897932384 -> 31415926535897932384                                                                                                                                                                                                                                    |
+| DECIMAL            | DECIMAL             | decimal(3,2) 3.14 -> 3.14; decimal 3.1415925 -> 3.1415926                                                                                                                                                                                                                           |
+ | FLOAT32            | FLOAT               | **buggy** float32 0.33 -> 3.3e-1                                                                                                                                                                                                                                                    |
+| FLOAT64            | FLOAT               | float64 0.33 -> 3.3e-1                                                                                                                                                                                                                                                              |
+| CHAR               | STRING              | char 'a' -> "a"                                                                                                                                                                                                                                                                     |
+| STRING             | STRING              | string 'abc' -> "abc"                                                                                                                                                                                                                                                               |
+ | SYMBOL             | SYMBOL              | symbol "a" -> 'a'                                                                                                                                                                                                                                                                   |
+ | BINARY             | BLOB                | binary {{'binary'}} -> {{YmluYXJ5}}                                                                                                                                                                                                                                                 |
+| BYTE               | BLOB                | byte {'byte'} -> {{YQ==}}                                                                                                                                                                                                                                                           |
+| BLOB               | BLOB                | blob {'blob'} -> {{YmxvYg==}}                                                                                                                                                                                                                                                       |
+| CLOB               | CLOB                | clob {{'clob'}} -> {{"clob"}}                                                                                                                                                                                                                                                       |
+| DATE               | STRUCT              | date '2023-01-01' -> $date::{year:2023, month:1, day: 1}                                                                                                                                                                                                                            |
+| TIME               | STRUCT              | time '00:00:00.00' -> $time::{hour:0, minute: 0, second: 0.00}; time '00:00:00+00:00' -> $time::{hour: 0, minute: 0, second: 0., offset: 0}; time '00:00:00-00:00' -> $time::{hour: 0, minute: 0, second: 0., offset: null.int}                                                     |
+| TIMESTAMP          | STRUCT OR TIMESTAMP | timestamp '2023-01-01T00:00:00Z' -> 2023-01-01T00:00:00Z, timestamp '2023-01-01T00:00:00-00:00' -> 2023-01-01T00:00:00-00:00; \`2023-01-01\` -> 2023-01-01T00:00:00-00:00' timestamp '2023-01-01T00:00:00' -> $timestamp::{year:2023, month:1, day:1, hour:0, minute:0, second: 0.} |
+| INTERVAL           | TBD                 | TBD                                                                                                                                                                                                                                                                                 |
+| BAG                | LIST                | <<1,2,3>> -> $bag::[1,2,3]                                                                                                                                                                                                                                                          |
+| LIST               | LIST                | [1,2,3] -> [1,2,3]                                                                                                                                                                                                                                                                  |
+| SEXP               | SEXP                | sexp (1,2,3) -> (1,2,3)                                                                                                                                                                                                                                                             |
+| STRUCT             | STRUCT              | {'a': 1} -> {a : 1}                                                                                                                                                                                                                                                                 |
+| NULL               | NULL                | null -> null.null                                                                                                                                                                                                                                                                   | 
+| MISSING            | NULL                | missing -> $missing::null.null                                                                                                                                                                                                                                                      |
+| NULLABLE_BOOL      | BOOL                | null -> null.bool else same as BOOL                                                                                                                                                                                                                                                 |
+| NULLABLE_INT8      | INT                 | null -> null.INT else same as INT8                                                                                                                                                                                                                                                  |
+| NULLABLE_INT16     | INT                 | null -> null.INT else same as INT16                                                                                                                                                                                                                                                 |
+| NULLABLE_INT32     | INT                 | null -> null.INT else same as INT32                                                                                                                                                                                                                                                 |
+| NULLABLE_INT64     | INT                 | null -> null.INT else same as INT64                                                                                                                                                                                                                                                 |
+| NULLABLE_INT       | INT                 | null -> null.INT else same as INT                                                                                                                                                                                                                                                   |
+| NULLABLE_DECIMAL   | DECIMAL             | null -> null.DECIMAL else same as DECIMAL                                                                                                                                                                                                                                           |
+| NULLABLE_FLOAT32   | FLOAT               | null -> null.FLOAT else same as FLOAT32                                                                                                                                                                                                                                             | 
+| NULLABLE_FLOAT64   | FLOAT               | null -> null.FLOAT else same as FLOAT64                                                                                                                                                                                                                                             |
+  | NULLABLE_CHAR      | STRING              | null -> null.string else same as CHAR                                                                                                                                                                                                                                               |
+| NULLABLE_STRING    | STRING              | null -> null.string else same as STRING                                                                                                                                                                                                                                             |
+| NULLABLE_SYMBOL    | SYMBOL              | null -> null.symbol else same as SYMBOL                                                                                                                                                                                                                                             | 
+| NULLABLE_BINARY    | BLOB                | null -> null.blob else same as BINARY                                                                                                                                                                                                                                               |
+| NULLABLE_BYTE      | BLOB                | null -> null.blob else same as BYTE                                                                                                                                                                                                                                                 |
+| NULLABLE_BLOB      | BLOB                | null -> null.blob else same as BLOB                                                                                                                                                                                                                                                 | 
+| NULLABLE_CLOB      | CLOB                | null -> null.clob else same as CLOB                                                                                                                                                                                                                                                 |
+| NULLABLE_DATE      | STRUCT              | null -> $date::null.struct else same as DATE                                                                                                                                                                                                                                        |
+| NULLABLE_TIME      | STRUCT              | null -> $time::null.struct else same as TIME                                                                                                                                                                                                                                        | 
+| NULLABLE_TIMESTAMP | STRUCT OR TIMESTAMP | null -> null.timestamp else same as TIMESTAMP                                                                                                                                                                                                                                       | 
+| NULLABLE_INTERVAL  | TBD                 |                                                                                                                                                                                                                                                                                     |
+| NULLABLE_BAG       | LIST                | null -> $bag::null.list else same as BAG                                                                                                                                                                                                                                            | 
+| NULLABLE_LIST      | LIST                | null -> null.list else same as LIST                                                                                                                                                                                                                                                 | 
+| NULLABLE_SEXP      | SEXP                | null -> null.sexp else same as SEXP                                                                                                                                                                                                                                                 |
+| NULLABLE_STRUCT    | STRUCT              | null -> null.struct else same as STRUCT                                                                                                                                                                                                                                             |
+
+
+## Read From Ion Data
+PartiQL reserves some keywords which are used as Ion annotations to extend the Ion types. 
+To distinguish between generic Ion data and PartiQL data encoded as Ion, the reader has two modes: `IonGeneric` and `IonForPartiQL`. 
+
+### Ion Generic
+If using `IonGeneric` mode: The ion value annotations are always treated as annotations on PartiQL value. 
+
+For example:
+    - `$missing::null` will be treated as nullValue(annotations = ["missing"])
+
+### Ion For PartiQL
+When using `IonForPartiQL` mode, the **last** annotation is checked to see if this is an encoded PartiQL value. If the annotation is a PartiQL reserved keyword, then we validate and construct the PartiQL value.
+
+For example:
+- `$missing::null` will be treated as `missingValue(annotations = [])`
+- `a::b::$missing:null` will be treated as `missingValue(annotations = ["a", "b"])`
+- `a::$missing::b::null` will be treated as `nullValue(annotation = ["a", "$missing", "b"]`
+- `$missing::1` will cause an exception.
\ No newline at end of file
diff --git a/docs/wiki/tutorials/Pluggable Functions Tutorial.md b/docs/wiki/tutorials/Pluggable Functions Tutorial.md
new file mode 100644
index 0000000000..4fd6aab39b
--- /dev/null
+++ b/docs/wiki/tutorials/Pluggable Functions Tutorial.md	
@@ -0,0 +1,136 @@
+# Pluggable Functions Tutorial
+
+The PartiQL ecosystem has introduced a new method for integrating custom logic - Pluggable Functions. This system allows PartiQL users to implement and introduce their custom functions into the PartiQL Command Line Interface (CLI) without the need for extensive knowledge of the PartiQL codebase or build system.
+
+This document will guide you on creating custom functions and loading them to the PartiQL CLI. The functions created by you will be pluggable, meaning they can be integrated as needed, enhancing the functionality of the CLI without modifying the underlying code.
+
+## Step 1: Add Dependencies and Build Your Module
+
+To build your module, you can use build automation tools like Maven or Gradle. These tools will handle the dependency management and compilation process for you. Here's how you can specify the necessary dependencies:
+
+```Kotlin
+dependencies {
+implementation("org.partiql:partiql-spi:<latest_version>")
+implementation("org.partiql:partiql-types:<latest_version>")
+}
+```
+
+## Step 2: Create a Custom Function
+
+To create a custom function, you need to implement the `PartiQLFunction` interface. This interface allows you to define the function's behavior and its signature, including its name, return type, parameters, determinism, and optional description.
+
+Here's a basic template to help you start:
+
+```Kotlin
+import org.partiql.spi.connector.ConnectorSession
+import org.partiql.spi.function.PartiQLFunction
+import org.partiql.spi.function.PartiQLFunctionExperimental
+import org.partiql.types.PartiQLValueType
+import org.partiql.types.function.FunctionParameter
+import org.partiql.types.function.FunctionSignature
+import org.partiql.value.PartiQLValue
+import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.StringValue
+import org.partiql.value.stringValue
+
+@OptIn(PartiQLFunctionExperimental::class)
+object TrimLead : PartiQLFunction {
+    override val signature = FunctionSignature(
+        name = "trim_lead", // Specify your function name
+        returns = PartiQLValueType.STRING, // Specify the return type
+        parameters = listOf(
+        FunctionParameter.ValueParameter(name = "str", type = PartiQLValueType.STRING) // Specify parameters
+        ),
+        isDeterministic = true, // Specify determinism
+        description = "Trims leading whitespace of a [str]." // A brief description of your function
+    )
+
+    @OptIn(PartiQLValueExperimental::class)
+    override operator fun invoke(session: ConnectorSession, arguments: List<PartiQLValue>): PartiQLValue {
+        // Implement the function logic here
+        val str = (arguments[0] as? StringValue)?.string ?: ""
+        val processed = str.trimStart()
+        return stringValue(processed)
+    }
+}
+```
+
+Ensure that you replace the signature and function invoking with your actual implementations.
+
+## Step 3: Implement the Plugin Interface
+
+Next, you need to implement the `Plugin` interface in your code. This allows you to return a list of all the custom `PartiQLFunction` implementations you've created, using the `getFunctions()` method. This step is crucial as it allows the service loader to retrieve all your custom functions.
+
+Here's an example of a `Plugin` implementation:
+
+```Kotlin
+package org.partiql.plugins.mockdb
+
+import org.partiql.spi.Plugin
+import org.partiql.spi.connector.Connector
+import org.partiql.spi.function.PartiQLFunction
+
+public class LocalPlugin implements Plugin {
+    override fun getConnectorFactories(): List<Connector.Factory> = listOf()
+
+    @PartiQLFunctionExperimental
+    override fun getFunctions(): List<PartiQLFunction> = listOf(
+        TrimLead // Specify the functions
+    )
+}
+```
+
+## Step 4: Create Service Provider Configuration file
+
+In order for the Java's ServiceLoader to recognize your plugin and load your custom functions, you'll need to specify your `Plugin` implementation in a Service Provider Configuration file:
+
+1. In your project's main resources directory (usually `src/main/resources`), create a new directory named `META-INF/services`.
+
+2. Within this directory, create a new file named after the full interface name as `org.partiql.spi.Plugin`.
+
+3. Inside this file, write the fully qualified name of your Plugin implementation class. If you have multiple implementations, each should be listed on a new line.
+
+Here's an example if your `Plugin` implementation class is `org.partiql.plugins.mockdb.LocalPlugin`:
+```Kotlin
+org.partiql.plugins.mockdb.LocalPlugin
+```
+
+## Step 5: Package Your Functions into a .jar File
+
+Compile your function and `Plugin` implementation into bytecode and package it into a .jar file. This .jar file will act as a plugin for the PartiQL CLI.
+
+For example, if you are using Gradle, you can simply run `./gradlew build` to compile your module. And your .jar file can be found under `build/libs`.
+
+## Step 6: Load the Functions into CLI
+
+Each of your .jar files should be stored in its own subdirectory under the `plugins` directory, which itself is inside the .partiql directory in your home directory. Here's what the directory structure should look like:
+
+```
+~/.partiql/plugins
+    ├── firstPlugin
+    │   └── firstPlugin.jar
+    └── secondPlugin
+        └── secondPlugin.jar
+```
+
+In the example above, `firstPlugin.jar` and `secondPlugin.jar` are the plugins you've created, each in its own directory under `~/.partiql/plugins`.
+
+By default, the PartiQL CLI will search the `~/.partiql/plugins` directory for plugins. However, you can specify a different directory when starting the CLI with the `--plugins` option:
+
+```shell
+partiql --plugins /path/to/your/plugin/directory
+```
+
+With this command, the CLI will search for .jar files in the specified directory’s subdirectories and load them as plugins. This feature gives you the flexibility to organize your plugins in a manner that best suits your needs.
+
+## Step 7: Invoke Custom Functions in CLI
+
+To use the custom functions, you simply call them as you would any other function in the PartiQL CLI. For example, if you created a function named "trim_lead", you would invoke it like so:
+
+```shell
+partiql> trim_lead(string)
+```
+
+Please replace "string" with the actual string you want to trim.
+
+That's all there is to it! With this mechanism, you can introduce any number of custom functions to PartiQL, and these functions will be usable just like built-in functions, without the need to modify the PartiQL codebase. It's an excellent way to extend the capabilities of PartiQL and adapt it to the specific needs of your project or organization.
diff --git a/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinCommand.kt b/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinCommand.kt
index 5b997b74b9..06d31cb44f 100644
--- a/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinCommand.kt
+++ b/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinCommand.kt
@@ -46,6 +46,12 @@ class KotlinCommand : Callable<Int> {
     )
     var poems: List<String> = emptyList()
 
+    @CommandLine.Option(
+        names = ["--opt-in"],
+        description = ["Opt-in annotations to add to generated sources"],
+    )
+    var optIns: List<String> = emptyList()
+
     override fun call(): Int {
         val input = BufferedReader(FileInputStream(file).reader()).readText()
         val parser = SproutParser.default()
@@ -53,6 +59,7 @@ class KotlinCommand : Callable<Int> {
         val options = KotlinOptions(
             packageRoot = packageRoot,
             poems = poems,
+            optIns = optIns,
         )
         val generator = KotlinGenerator(options)
         val result = generator.generate(universe)
diff --git a/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinGenerator.kt b/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinGenerator.kt
index c768973bf0..13d0868f9f 100644
--- a/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinGenerator.kt
+++ b/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinGenerator.kt
@@ -1,5 +1,6 @@
 package org.partiql.sprout.generator.target.kotlin
 
+import com.squareup.kotlinpoet.AnnotationSpec
 import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.FunSpec
 import com.squareup.kotlinpoet.KModifier
@@ -56,7 +57,20 @@ class KotlinGenerator(private val options: KotlinOptions) : Generator<KotlinResu
             // Apply each poem
             poems.forEach { it.apply(this) }
             // Finalize each spec/builder
-            build(options.packageRoot).map { KotlinFileSpec(it) }
+            build(options.packageRoot).map {
+                if (options.optIns.isNotEmpty()) {
+                    val f = it.toBuilder()
+                    val optin = AnnotationSpec.builder(ClassName("kotlin", "OptIn"))
+                    options.optIns.forEach { o ->
+                        val i = o.lastIndexOf(".")
+                        optin.addMember("%T::class", ClassName(o.substring(0, i), o.substring(i + 1)))
+                    }
+                    f.addAnnotation(optin.build())
+                    KotlinFileSpec(f.build())
+                } else {
+                    KotlinFileSpec(it)
+                }
+            }
         }
         return KotlinResult(specs)
     }
diff --git a/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinOptions.kt b/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinOptions.kt
index 3a43dd5e92..f95928efe9 100644
--- a/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinOptions.kt
+++ b/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/KotlinOptions.kt
@@ -8,4 +8,5 @@ package org.partiql.sprout.generator.target.kotlin
 class KotlinOptions(
     val packageRoot: String,
     val poems: List<String>,
+    val optIns: List<String> = emptyList(),
 )
diff --git a/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/poems/KotlinUtilsPoem.kt b/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/poems/KotlinUtilsPoem.kt
index f0a8f0ebd3..9a5cf15e54 100644
--- a/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/poems/KotlinUtilsPoem.kt
+++ b/lib/sprout/src/main/kotlin/org/partiql/sprout/generator/target/kotlin/poems/KotlinUtilsPoem.kt
@@ -39,6 +39,7 @@ class KotlinUtilsPoem(symbols: KotlinSymbols) : KotlinPoem(symbols) {
     private val suppressUnused = AnnotationSpec.builder(Suppress::class)
         .useSiteTarget(AnnotationSpec.UseSiteTarget.FILE)
         .addMember("%S", "UNUSED_PARAMETER")
+        .addMember("%S", "UNUSED_VARIABLE")
         .build()
 
     // Not taking a dep on builder or visitor poems, as this is temporary
@@ -107,8 +108,8 @@ class KotlinUtilsPoem(symbols: KotlinSymbols) : KotlinPoem(symbols) {
     // Node N           -> visitN(node.n, ctx) as N
     // Node N?          -> node.n?.let { visitN(it, ctx) as N }
     // Collection<N>    -> rewrite(node, ctx, ::method)
-    // Collection?<N>   -> node.n?.let { rewrite(it, ctx, ::method) }
-    // Collection?<N?>  -> node.n?.let { rewrite(it, ctx, ::method) }
+    // Collection<N>?   -> node.n?.let { rewrite(it, ctx, ::method) }
+    // Collection<N?>?  -> node.n?.let { rewrite(it, ctx, ::method) }
     // Collection<N?>   -> rewrite(node, ctx, ::method)
 
     private fun KotlinNodeSpec.Product.rewriter(): FunSpec {
@@ -139,17 +140,25 @@ class KotlinUtilsPoem(symbols: KotlinSymbols) : KotlinPoem(symbols) {
                         (ref is TypeRef.List && isNode(ref.type)) -> {
                             // Collections
                             val method = (ref.type as TypeRef.Path).visitMethodName()
+                            val helper = when (ref.type.nullable) {
+                                true -> "_visitListNull"
+                                else -> "_visitList"
+                            }
                             when (ref.nullable) {
-                                true -> addStatement("val $name = $child?.let { _visitListNull(it, ctx, ::$method) }")
-                                false -> addStatement("val $name = _visitList($child, ctx, ::$method)")
+                                true -> addStatement("val $name = $child?.let { $helper(it, ctx, ::$method) }")
+                                false -> addStatement("val $name = $helper($child, ctx, ::$method)")
                             }
                         }
                         (ref is TypeRef.Set && isNode(ref.type)) -> {
                             // Collections
                             val method = (ref.type as TypeRef.Path).visitMethodName()
+                            val helper = when (ref.type.nullable) {
+                                true -> "_visitSetNull"
+                                else -> "_visitSet"
+                            }
                             when (ref.nullable) {
-                                true -> addStatement("val $name = $child?.let { _visitSetNull(it, ctx, ::$method) }")
-                                false -> addStatement("val $name = _visitSet($child, ctx, ::$method)")
+                                true -> addStatement("val $name = $child?.let { $helper(it, ctx, ::$method) }")
+                                false -> addStatement("val $name = $helper($child, ctx, ::$method)")
                             }
                         }
                         else -> {
diff --git a/partiql-ast/README.adoc b/partiql-ast/README.adoc
new file mode 100644
index 0000000000..40935b00b3
--- /dev/null
+++ b/partiql-ast/README.adoc
@@ -0,0 +1,364 @@
+= PartiQL AST
+
+The PartiQL AST package contains interfaces, data classes, and utilities for manipulating a syntax tree.
+
+NOTE: If you are on an older version of PartiQL, you can convert to the old AST via `.toLegacyAst()` in `org.partiql.ast.helpers`.
+
+== Interfaces
+
+The interfaces are generated from `resources/partiql_ast.ion` (details in `lib/sprout/README`)
+
+=== Node
+
+[source,kotlin]
+----
+public interface AstNode {
+
+    // Every node gets an _id for associating any metadata
+    public val _id: String
+
+    public val children: List<AstNode>
+
+    public fun <R, C> accept(visitor: AstVisitor<R, C>, ctx: C): R
+}
+----
+
+=== Example
+
+.Example Definition
+[source,ion]
+----
+expr::[
+ // ...
+ binary::{
+   op: [
+     PLUS, MINUS, TIMES, DIVIDE, MODULO, CONCAT,
+     AND, OR,
+     EQ, NE, GT, GTE, LT, LTE,
+   ],
+   lhs: expr,
+   rhs: expr,
+ },
+ // ...
+]
+----
+
+.Generated Interface
+[source,kotlin]
+----
+// Note: `Expr:AstNode` is a sealed interface of all expr variants
+
+public interface Binary : Expr {
+    public val op: Op
+    public val lhs: Expr
+    public val rhs: Expr
+
+    public fun copy(
+      op: Op = this.op,
+      lhs: Expr = this.lhs,
+      rhs: Expr = this.rhs,
+    ): Binary
+
+    public enum class Op {
+      PLUS,
+      MINUS,
+      TIMES,
+      DIVIDE,
+      MODULO,
+      CONCAT,
+      AND,
+      OR,
+      EQ,
+      NE,
+      GT,
+      GTE,
+      LT,
+      LTE,
+    }
+}
+----
+
+== Factory, DSL, and Builders
+
+The PartiQL AST library provides several creational patterns in `org.partiql.ast.builder` such as an abstract base factory, Kotlin DSL, and Java fluent-builders.
+These patterns enable customers to extend the AST to fit their needs, while providing a base which can be decorated appropriately.
+
+=== Factory Usage
+
+The factory is how you instantiate a node. The default factory can be called directly like,
+
+[source,kotlin]
+----
+import org.partiql.ast.Ast
+
+Ast.exprLit(int32Value(1))  // expr.lit
+----
+
+==== Custom Nodes
+
+Additionally, you can extend the abstract base factory and use it in builders as well as the DSL. This gives you full
+control over how your nodes are instantiated. If you are ambitious, you can implement your own versions of AST node interfaces and implement a base factory. This
+will allow you to create custom behaviors. For example, generated equals functions do not consider semantics. Perhaps
+we want to improve how we compare nodes? Here's an example that considers the case-sensitivity of identifiers.
+
+.Custom Node and Factory Example
+[source,kotlin]
+----
+public abstract class MyFactory : AstBaseFactory() {
+
+    override fun identifierSymbol(symbol: String, caseSensitivity: Identifier.CaseSensitivity): Identifier.Symbol {
+        return ComparableIdentifier(_id(), symbol, caseSensitivity)
+    }
+}
+
+class ComparableIdentifier(
+    override val _id: String,
+    override val symbol: String,
+    override val caseSensitivity: Identifier.CaseSensitivity,
+) : Identifier.Symbol {
+
+    // override copy, children
+
+    override fun equals(other: Any?): Boolean {
+        if (other == null || other !is Identifier.Symbol) return false // different type
+        if (other === this) return true // same object
+        return when (caseSensitivity) {
+            Identifier.CaseSensitivity.SENSITIVE -> this.symbol == other.symbol
+            Identifier.CaseSensitivity.INSENSITIVE -> this.symbol.lowercase() == other.symbol.lowercase()
+        }
+    }
+}
+----
+
+=== DSL Usage
+
+The DSL is useful from Kotlin and is some syntax sugar over fluent builders. Here is how its used:
+
+.Default Factory DSL Example
+[source,kotlin]
+----
+import org.partiql.ast.builder.ast
+
+// Tree for PartiQL `VALUES (1, 2)`
+ast {
+    exprCollection(Expr.Collection.Type.VALUES) {
+        values += exprLit(int32Value(1))
+        values += exprLit(int32Value(2))
+    }
+}
+
+// Tree for `SELECT a FROM T`
+ast {
+    exprSFW {
+        select = selectProject {
+            items += selectProjectItemExpression {
+                expr = exprVar {
+                    identifier = identifierSymbol("a", Identifier.CaseSensitivity.INSENSITIVE)
+                    scope = Expr.Var.Scope.DEFAULT
+                }
+            }
+        }
+        from = fromValue {
+            expr = v(symbol)
+            type = From.Value.Type.SCAN
+        }
+    }
+}
+----
+
+.Fancier DSL Usage
+[source,kotlin]
+----
+import org.partiql.ast.builder.ast
+import org.partiql.ast.builder.AstBuilder
+
+// define some helpers
+private fun AstBuilder.select(vararg s: String) = selectProject {
+    s.forEach {
+     items += selectProjectItemExpression(v(it))
+    }
+}
+
+private fun AstBuilder.table(symbol: String) = fromValue {
+    expr = v(symbol)
+    type = From.Value.Type.SCAN
+}
+
+private fun AstBuilder.v(symbol: String) = this.exprVar {
+    identifier = id(symbol)
+    scope = Expr.Var.Scope.DEFAULT
+}
+
+
+// Tree for `SELECT x, y, z FROM T`
+
+ast {
+    exprSFW {
+        select = select("x", "y", "z")
+        from = table("T")
+    }
+}
+----
+
+.Custom Factory DSL Example
+[source,kotlin]
+----
+import org.partiql.ast.builder.ast
+
+// This will instantiate your custom `ComparableIdentifier`. Nice!
+ast(myFactory) {
+    exprSFW {
+        select = select("x", "y", "z")
+        from = table("T")
+    }
+}
+----
+
+IMPORTANT: The last examples works because the DSL block closes over the factory with an AstBuilder. This means that
+the helper extensions or any DSL usage will use the provided factory!
+
+=== Builder Usage
+
+The DSL is not much more than Kotlin syntactic sugar over traditional fluent-builder classes. If you are coming from Java, these will be useful.
+Every node defines a static `builder()` function. Keeping with the previous example, let's see how we can inject our custom
+factory.
+
+[source,kotlin]
+----
+// instance of default IdentifierSymbolImpl
+val a = Identifier.Symbol.builder()
+         .symbol("HELLO")
+         .caseSensitivity(Identifier.CaseSensitivity.INSENSITIVE)
+         .build() // empty, build with default factory
+
+// instance of ComparableIdentifier
+val b = Identifier.Symbol.builder()
+         .symbol("hello")
+         .caseSensitivity(Identifier.CaseSensitivity.INSENSITIVE)
+         .build(myFactory) // nice!
+
+assert(b == a) // TRUE
+assert(a == b) // !! FALSE !! consider always using the same type of factory
+----
+
+== Visitor and Rewriter
+
+The PartiQL AST is a set of interfaces, so how might we extend these for our own purposes? We do not have pattern matching in Kotlin/Java, so we use the visitor pattern.
+
+The visitor pattern is effectively adding methods to each object with some compile safety. You define a behavior and use the node `accept` the behavior. The visitor provides an additional parameter `ctx: C` which is the equivalent of arguments to each method for your behavior.
+
+[source,kotlin]
+----
+public abstract class AstBaseVisitor<R, C> : AstVisitor<R, C> {
+
+    public override fun visit(node: AstNode, ctx: C): R = node.accept(this, ctx)
+
+    public open fun defaultVisit(node: AstNode, ctx: C): R {
+        for (child in node.children) {
+            child.accept(this, ctx)
+        }
+        return defaultReturn(node, ctx)
+    }
+
+    public abstract fun defaultReturn(node: AstNode, ctx: C): R
+}
+----
+
+For example, let's implement a `ToSimpleNameString(case: Case)` function on some basic nodes.
+
+[source,kotlin]
+----
+//
+// Usage:
+//  node.accept(ToSimpleNameString, Case.UPPER)
+//
+object ToSimpleNameString :  AstBaseVisitor<String, Case>() {
+
+    override fun defaultVisit(node: AstNode, ctx: Case) = defaultReturn(node, ctx)
+
+    override fun defaultReturn(node: AstNode, ctx: Case): String = when (ctx) {
+        Case.UPPER -> node::class.simpleName.uppercase()
+        Case.LOWER -> node::class.simpleName.lowercase()
+        Case.PASCAL -> node::class.simpleName
+        Case.SNAKE -> snakeCaseHelper(node::class.simpleName)
+    }
+
+    // Any other overrides you want!
+}
+----
+
+
+=== Folding
+
+Folding is straightforward by using either mutable context or an immutable accumulators. The structure you fold to is
+entirely dependent on your use case, but here is a simple example with a mutable list that you can generalize. Often times you may fold to an entirely new domain — or fold to the same domain which we'll cover in the rewriter.
+
+.Example "ClassName" Collector
+[source,kotlin]
+----
+// Traverse the tree collecting all node names
+object AstClassNameCollector  {
+
+    // Public static entry for Java style consumption
+    @JvmStatic
+    fun collect(node: AstNode): List<String> {
+        val acc = mutableListOf<String>()
+        node.accept(ToSimpleNameString, acc)
+        return acc
+    }
+
+    // Private implementation
+    private object ToSimpleNameString :  AstBaseVisitor<String?, MutableList<String>>() {
+
+        override fun defaultVisit(node: AstNode, ctx: MutableList<String>): String? {
+            node.children.forEach { child -> child.accept(this, ctx) } // traverse
+            defaultReturn(this, ctx)?.let { ctx.add(it) }
+        }
+
+        override fun defaultReturn(node: AstNode, ctx: MutableList<String>) = node::class.simpleName
+
+        // Any other overrides you want!
+    }
+}
+----
+
+=== Rewriter
+
+See `org.partiql.ast.util.AstRewriter`. This class facilitates rewriting an AST; you need only override the relevant methods for your rewriter.
+
+=== Tips
+
+- Each `visit` is a function call; adding state to a visitor is akin to global variables. _Consider keeping state in the context parameter_. This is beneficial because you state is naturally scoped via the call stack.
+- Sometimes state in a visitor makes an implementation much cleaner (go for it!). Just remember that the visitor might not be re-usable or idempotent.
+- Consider using singletons/objects for stateless visitors
+- Consider making your visitors private with a single public static entry point.
+- When you make a private visitor, you can rename the ctx parameter to something relevant. Use the `Suppress("PARAMETER_NAME_CHANGED_ON_OVERRIDE")` to make the linter to relax.
+- If writing and using Kotlin, consider adding an extension method to the base class. This _really_ makes it look like you've opened the classes (but really it's just a static method).
+
+=== Understanding Visitors
+
+I believe Robert Nystrom captured the misunderstanding of visitors quite well:
+
+[quote]
+____
+The Visitor pattern is the most widely misunderstood pattern in all of Design Patterns, which is really saying something when you look at the software architecture excesses of the past couple of decades.
+
+The trouble starts with terminology. The pattern isn’t about “visiting”, and the “accept” method in it doesn’t conjure up any helpful imagery either. Many think the pattern has to do with traversing trees, which isn’t the case at all. We are going to use it on a set of classes that are tree-like, but that’s a coincidence. As you’ll see, the pattern works as well on a single object.
+
+The Visitor pattern is really about approximating the functional style within an OOP language. It lets us add new columns to that table easily. We can define all of the behavior for a new operation on a set of types in one place, without having to touch the types themselves. It does this the same way we solve almost every problem in computer science: by adding a layer of indirection.
+
+-- Robert Nystrom, Crafting Interpreters
+____
+
+Additionally, see how the wiki page explicitly mentions pattern matching. Kotlin is interesting because we have something _like_ pattern matching, but the PartiQL AST library is intended for consumption from both Kotlin and Java.
+
+[quote]
+____
+A visitor pattern is a software design pattern and separates the algorithm from the object structure. Because of this separation new operations can be added to existing object structures without modifying the structures. It is one way to follow the open/closed principle in object-oriented programming and software engineering.
+
+In essence, the visitor allows adding new virtual functions to a family of classes, without modifying the classes. Instead, a visitor class is created that implements all of the appropriate specializations of the virtual function. The visitor takes the instance reference as input, and implements the goal through double dispatch.
+
+Programming languages with sum types and pattern matching obviate many of the benefits of the visitor pattern, as the visitor class is able to both easily branch on the type of the object and generate a compiler error if a new object type is defined which the visitor does not yet handle.
+
+https://en.wikipedia.org/wiki/Visitor_pattern
+____
diff --git a/partiql-ast/build.gradle.kts b/partiql-ast/build.gradle.kts
index 1df7d02100..0814ffaa75 100644
--- a/partiql-ast/build.gradle.kts
+++ b/partiql-ast/build.gradle.kts
@@ -22,6 +22,13 @@ plugins {
 dependencies {
     api(Deps.pigRuntime)
     api(Deps.ionElement)
+    api(project(":partiql-types"))
+}
+
+publish {
+    artifactId = "partiql-ast"
+    name = "PartiQL AST"
+    description = "PartiQL's Abstract Syntax Tree"
 }
 
 pig {
@@ -45,8 +52,22 @@ kotlin {
     explicitApi = null
 }
 
-publish {
-    artifactId = "partiql-ast"
-    name = "PartiQL AST"
-    description = "PartiQL's Abstract Syntax Tree"
+val generate = tasks.register<Exec>("generate") {
+    dependsOn(":lib:sprout:install")
+    workingDir(projectDir)
+    commandLine(
+        "../lib/sprout/build/install/sprout/bin/sprout", "generate", "kotlin",
+        "-o", "$buildDir/generated-src",
+        "-p", "org.partiql.ast",
+        "-u", "Ast",
+        "--poems", "visitor",
+        "--poems", "builder",
+        "--poems", "util",
+        "--opt-in", "org.partiql.value.PartiQLValueExperimental",
+        "./src/main/resources/partiql_ast.ion"
+    )
+}
+
+tasks.compileKotlin {
+    dependsOn(generate)
 }
diff --git a/partiql-ast/src/main/kotlin/org/partiql/ast/Ast.kt b/partiql-ast/src/main/kotlin/org/partiql/ast/Ast.kt
new file mode 100644
index 0000000000..380a924651
--- /dev/null
+++ b/partiql-ast/src/main/kotlin/org/partiql/ast/Ast.kt
@@ -0,0 +1,15 @@
+package org.partiql.ast
+
+import org.partiql.ast.builder.AstFactoryImpl
+
+/**
+ * Singleton instance of the default factory; also accessible via `AstFactory.DEFAULT`.
+ */
+object Ast : AstBaseFactory()
+
+/**
+ * AstBaseFactory can be used to create a factory which extends from the factory provided by AstFactory.DEFAULT.
+ */
+public abstract class AstBaseFactory : AstFactoryImpl() {
+    // internal default overrides here
+}
diff --git a/partiql-ast/src/main/kotlin/org/partiql/ast/helpers/ToIon.kt b/partiql-ast/src/main/kotlin/org/partiql/ast/helpers/ToIon.kt
new file mode 100644
index 0000000000..3bed70c0f3
--- /dev/null
+++ b/partiql-ast/src/main/kotlin/org/partiql/ast/helpers/ToIon.kt
@@ -0,0 +1,128 @@
+package org.partiql.ast.helpers
+
+import com.amazon.ion.Decimal
+import com.amazon.ion.Timestamp
+import com.amazon.ionelement.api.IonElement
+import com.amazon.ionelement.api.field
+import com.amazon.ionelement.api.ionBlob
+import com.amazon.ionelement.api.ionBool
+import com.amazon.ionelement.api.ionClob
+import com.amazon.ionelement.api.ionDecimal
+import com.amazon.ionelement.api.ionFloat
+import com.amazon.ionelement.api.ionInt
+import com.amazon.ionelement.api.ionListOf
+import com.amazon.ionelement.api.ionNull
+import com.amazon.ionelement.api.ionSexpOf
+import com.amazon.ionelement.api.ionString
+import com.amazon.ionelement.api.ionStructOf
+import com.amazon.ionelement.api.ionSymbol
+import com.amazon.ionelement.api.ionTimestamp
+import org.partiql.value.BlobValue
+import org.partiql.value.BoolValue
+import org.partiql.value.ClobValue
+import org.partiql.value.CollectionValue
+import org.partiql.value.DecimalValue
+import org.partiql.value.Float32Value
+import org.partiql.value.Float64Value
+import org.partiql.value.Int16Value
+import org.partiql.value.Int32Value
+import org.partiql.value.Int64Value
+import org.partiql.value.Int8Value
+import org.partiql.value.IntValue
+import org.partiql.value.ListValue
+import org.partiql.value.NullValue
+import org.partiql.value.PartiQLValue
+import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.ScalarValue
+import org.partiql.value.SexpValue
+import org.partiql.value.StringValue
+import org.partiql.value.StructValue
+import org.partiql.value.SymbolValue
+import org.partiql.value.TimestampValue
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.util.PartiQLValueBaseVisitor
+
+/**
+ * PartiQL Value .toIon helper; to be replaced by https://github.com/partiql/partiql-lang-kotlin/pull/1131/files
+ *
+ * TODO add `lower` mode, this just errors
+ */
+@OptIn(PartiQLValueExperimental::class)
+internal object ToIon : PartiQLValueBaseVisitor<IonElement, Unit>() {
+
+    private inline fun <T> ScalarValue<T>.toIon(block: ScalarValue<T>.() -> IonElement): IonElement {
+        val e = this.block()
+        return e.withAnnotations(this.annotations)
+    }
+
+    private inline fun CollectionValue<*>.toIon(block: CollectionValue<*>.(elements: List<IonElement>) -> IonElement): IonElement {
+        val elements = this.elements.map { it.accept(ToIon, Unit) }
+        val e = this.block(elements)
+        return e.withAnnotations(this.annotations)
+    }
+
+    override fun defaultVisit(v: PartiQLValue, ctx: Unit) = defaultReturn(v, ctx)
+
+    override fun defaultReturn(v: PartiQLValue, ctx: Unit) =
+        throw IllegalArgumentException("Cannot represent $v as Ion in strict mode")
+
+    override fun visitNull(v: NullValue, ctx: Unit) = ionNull().withAnnotations(v.annotations)
+
+    override fun visitBool(v: BoolValue, ctx: Unit) = v.toIon { ionBool(value) }
+
+    override fun visitInt8(v: Int8Value, ctx: Unit) = v.toIon { ionInt(value.toLong()) }
+
+    override fun visitInt16(v: Int16Value, ctx: Unit) = v.toIon { ionInt(value.toLong()) }
+
+    override fun visitInt32(v: Int32Value, ctx: Unit) = v.toIon { ionInt(value.toLong()) }
+
+    override fun visitInt64(v: Int64Value, ctx: Unit) = v.toIon { ionInt(value) }
+
+    // Call .toLong() because IonElement .equals() is failing with BigInteger (it's comparing by reference).
+    override fun visitInt(v: IntValue, ctx: Unit) = v.toIon { ionInt(value.toLong()) }
+
+    override fun visitDecimal(v: DecimalValue, ctx: Unit) = v.toIon { ionDecimal(Decimal.valueOf(value)) }
+
+    override fun visitFloat32(v: Float32Value, ctx: Unit) = v.toIon { ionFloat(value.toString().toDouble()) }
+
+    override fun visitFloat64(v: Float64Value, ctx: Unit) = v.toIon { ionFloat(value) }
+
+    override fun visitString(v: StringValue, ctx: Unit) = v.toIon { ionString(value) }
+
+    override fun visitSymbol(v: SymbolValue, ctx: Unit) = v.toIon { ionSymbol(value) }
+
+    override fun visitClob(v: ClobValue, ctx: Unit) = v.toIon { ionClob(value) }
+
+    override fun visitBlob(v: BlobValue, ctx: Unit) = v.toIon { ionBlob(value) }
+
+    override fun visitTimestamp(v: TimestampValue, ctx: Unit) = v.toIon {
+        val offset = when (val z = v.value.timeZone) {
+            TimeZone.UnknownTimeZone -> null
+            is TimeZone.UtcOffset -> z.totalOffsetMinutes
+            null -> 0
+        }
+        val timestamp = Timestamp.forSecond(
+            v.value.year,
+            v.value.month,
+            v.value.day,
+            v.value.hour,
+            v.value.minute,
+            v.value.decimalSecond,
+            offset,
+        )
+        ionTimestamp(timestamp)
+    }
+
+    override fun visitList(v: ListValue<*>, ctx: Unit) = v.toIon { elements -> ionListOf(elements) }
+
+    override fun visitSexp(v: SexpValue<*>, ctx: Unit) = v.toIon { elements -> ionSexpOf(elements) }
+
+    override fun visitStruct(v: StructValue<*>, ctx: Unit): IonElement {
+        val fields = v.fields.map {
+            val key = it.first
+            val value = it.second.accept(this, ctx)
+            field(key, value)
+        }
+        return ionStructOf(fields, v.annotations)
+    }
+}
diff --git a/partiql-ast/src/main/kotlin/org/partiql/ast/helpers/ToLegacyAst.kt b/partiql-ast/src/main/kotlin/org/partiql/ast/helpers/ToLegacyAst.kt
new file mode 100644
index 0000000000..6436203763
--- /dev/null
+++ b/partiql-ast/src/main/kotlin/org/partiql/ast/helpers/ToLegacyAst.kt
@@ -0,0 +1,1399 @@
+@file:OptIn(PartiQLValueExperimental::class)
+
+package org.partiql.ast.helpers
+
+import com.amazon.ion.Decimal
+import com.amazon.ionelement.api.DecimalElement
+import com.amazon.ionelement.api.FloatElement
+import com.amazon.ionelement.api.IntElement
+import com.amazon.ionelement.api.IntElementSize
+import com.amazon.ionelement.api.MetaContainer
+import com.amazon.ionelement.api.emptyMetaContainer
+import com.amazon.ionelement.api.ionDecimal
+import com.amazon.ionelement.api.ionFloat
+import com.amazon.ionelement.api.ionInt
+import com.amazon.ionelement.api.ionString
+import com.amazon.ionelement.api.ionSymbol
+import com.amazon.ionelement.api.metaContainerOf
+import org.partiql.ast.AstNode
+import org.partiql.ast.DatetimeField
+import org.partiql.ast.Expr
+import org.partiql.ast.From
+import org.partiql.ast.GraphMatch
+import org.partiql.ast.GroupBy
+import org.partiql.ast.Identifier
+import org.partiql.ast.Let
+import org.partiql.ast.OnConflict
+import org.partiql.ast.OrderBy
+import org.partiql.ast.Path
+import org.partiql.ast.Returning
+import org.partiql.ast.Select
+import org.partiql.ast.SetOp
+import org.partiql.ast.SetQuantifier
+import org.partiql.ast.Sort
+import org.partiql.ast.Statement
+import org.partiql.ast.TableDefinition
+import org.partiql.ast.Type
+import org.partiql.ast.visitor.AstBaseVisitor
+import org.partiql.lang.ast.IsListParenthesizedMeta
+import org.partiql.lang.ast.IsValuesExprMeta
+import org.partiql.lang.ast.Meta
+import org.partiql.lang.domains.PartiqlAst
+import org.partiql.value.DateValue
+import org.partiql.value.MissingValue
+import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.TimeValue
+import org.partiql.value.TimestampValue
+import org.partiql.value.datetime.TimeZone
+import java.math.BigDecimal
+import java.math.BigInteger
+
+/**
+ * Translates an [AstNode] tree to the legacy PIG AST.
+ *
+ * Optionally, you can provide a Map of MetaContainers to attach to the legacy AST nodes.
+ */
+public fun AstNode.toLegacyAst(metas: Map<String, MetaContainer> = emptyMap()): PartiqlAst.PartiqlAstNode {
+    val translator = AstTranslator(metas)
+    return accept(translator, Ctx())
+}
+
+/**
+ * Empty visitor method arguments
+ */
+private class Ctx
+
+/**
+ * Traverses an [AstNode] tree, folding to a [PartiqlAst.PartiqlAstNode] tree.
+ */
+@OptIn(PartiQLValueExperimental::class)
+private class AstTranslator(val metas: Map<String, MetaContainer>) : AstBaseVisitor<PartiqlAst.PartiqlAstNode, Ctx>() {
+
+    private val pig = PartiqlAst.BUILDER()
+
+    override fun defaultReturn(node: AstNode, ctx: Ctx): Nothing {
+        val fromClass = node::class.qualifiedName
+        val toClass = PartiqlAst.PartiqlAstNode::class.qualifiedName
+        throw IllegalArgumentException("$fromClass cannot be translated to $toClass")
+    }
+
+    override fun defaultVisit(node: AstNode, ctx: Ctx) = defaultReturn(node, ctx)
+
+    /**
+     * Attach Metas if-any
+     */
+    private inline fun <T : PartiqlAst.PartiqlAstNode> translate(
+        node: AstNode,
+        block: PartiqlAst.Builder.(metas: MetaContainer) -> T,
+    ): T {
+        val metas = metas[node._id] ?: emptyMetaContainer()
+        return pig.block(metas)
+    }
+
+    override fun visitStatement(node: Statement, ctx: Ctx) = super.visitStatement(node, ctx) as PartiqlAst.Statement
+
+    override fun visitStatementQuery(node: Statement.Query, ctx: Ctx) = translate(node) { metas ->
+        val expr = visitExpr(node.expr, ctx)
+        query(expr, metas)
+    }
+
+    override fun visitStatementExec(node: Statement.Exec, ctx: Ctx) = translate(node) { metas ->
+        val procedureName = node.procedure
+        val args = node.args.translate<PartiqlAst.Expr>(ctx)
+        exec(procedureName, args, metas)
+    }
+
+    override fun visitStatementExplain(node: Statement.Explain, ctx: Ctx) = translate(node) { metas ->
+        val target = visitStatementExplainTarget(node.target, ctx)
+        explain(target, metas)
+    }
+
+    override fun visitStatementExplainTarget(node: Statement.Explain.Target, ctx: Ctx) =
+        super.visitStatementExplainTarget(node, ctx) as PartiqlAst.ExplainTarget
+
+    override fun visitStatementExplainTargetDomain(node: Statement.Explain.Target.Domain, ctx: Ctx) =
+        translate(node) { metas ->
+            val statement = visitStatement(node.statement, ctx)
+            val type = node.type
+            val format = node.format
+            domain(statement, type, format, metas)
+        }
+
+    override fun visitStatementDDL(node: Statement.DDL, ctx: Ctx) = super.visit(node, ctx) as PartiqlAst.Statement.Ddl
+
+    override fun visitStatementDDLCreateTable(
+        node: Statement.DDL.CreateTable,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        if (node.name !is Identifier.Symbol) {
+            error("The legacy AST does not support qualified identifiers as table names")
+        }
+        val tableName = (node.name as Identifier.Symbol).symbol
+        val def = node.definition?.let { visitTableDefinition(it, ctx) }
+        ddl(createTable(tableName, def), metas)
+    }
+
+    override fun visitStatementDDLCreateIndex(
+        node: Statement.DDL.CreateIndex,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        if (node.index != null) {
+            error("The legacy AST does not support index names")
+        }
+        if (node.table !is Identifier.Symbol) {
+            error("The legacy AST does not support qualified identifiers as table names")
+        }
+        val tableName = visitIdentifierSymbol((node.table as Identifier.Symbol), ctx)
+        val fields = node.fields.map { visitPathUnpack(it, ctx) }
+        ddl(createIndex(tableName, fields), metas)
+    }
+
+    override fun visitStatementDDLDropTable(node: Statement.DDL.DropTable, ctx: Ctx) = translate(node) { metas ->
+        if (node.table !is Identifier.Symbol) {
+            error("The legacy AST does not support qualified identifiers as table names")
+        }
+        // !! Legacy AST "index_name" mix up !!
+        val tableName = visitIdentifierSymbol((node.table as Identifier.Symbol), ctx)
+        ddl(dropTable(tableName), metas)
+    }
+
+    override fun visitStatementDDLDropIndex(node: Statement.DDL.DropIndex, ctx: Ctx) = translate(node) { metas ->
+        if (node.index !is Identifier.Symbol) {
+            error("The legacy AST does not support qualified identifiers as index names")
+        }
+        if (node.table !is Identifier.Symbol) {
+            error("The legacy AST does not support qualified identifiers as table names")
+        }
+        // !! Legacy AST "table" mix up !!
+        val index = visitIdentifierSymbol(node.index as Identifier.Symbol, ctx)
+        // !! Legacy AST "keys" mix up !!
+        val table = visitIdentifierSymbol(node.table as Identifier.Symbol, ctx)
+        ddl(dropIndex(table, index), metas)
+    }
+
+    override fun visitTableDefinition(node: TableDefinition, ctx: Ctx) = translate(node) { metas ->
+        val parts = node.columns.translate<PartiqlAst.TableDefPart>(ctx)
+        tableDef(parts, metas)
+    }
+
+    override fun visitTableDefinitionColumn(node: TableDefinition.Column, ctx: Ctx) = translate(node) { metas ->
+        val name = node.name
+        val type = visitType(node.type, ctx)
+        val constraints = node.constraints.translate<PartiqlAst.ColumnConstraint>(ctx)
+        columnDeclaration(name, type, constraints, metas)
+    }
+
+    override fun visitTableDefinitionColumnConstraint(
+        node: TableDefinition.Column.Constraint,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val name = node.name
+        val def = when (node.body) {
+            is TableDefinition.Column.Constraint.Body.Check -> {
+                throw IllegalArgumentException("PIG AST does not support CHECK (<expr>) constraint")
+            }
+            is TableDefinition.Column.Constraint.Body.NotNull -> columnNotnull()
+            is TableDefinition.Column.Constraint.Body.Nullable -> columnNull()
+        }
+        columnConstraint(name, def, metas)
+    }
+
+    /**
+     * IDENTIFIERS / PATHS - Always expressions in legacy AST
+     */
+
+    override fun visitIdentifier(node: Identifier, ctx: Ctx) = when (node) {
+        is Identifier.Qualified -> visitIdentifierQualified(node, ctx)
+        is Identifier.Symbol -> visitIdentifierSymbolAsExpr(node)
+    }
+
+    override fun visitIdentifierSymbol(node: Identifier.Symbol, ctx: Ctx) = translate(node) { metas ->
+        val name = node.symbol
+        val case = node.caseSensitivity.toLegacyCaseSensitivity()
+        // !! NOT AN EXPRESSION!!
+        identifier(name, case, metas)
+    }
+
+    fun visitIdentifierSymbolAsExpr(node: Identifier.Symbol) = translate(node) { metas ->
+        val name = node.symbol
+        val case = node.caseSensitivity.toLegacyCaseSensitivity()
+        val scope = unqualified()
+        // !! ID EXPRESSION!!
+        id(name, case, scope, metas)
+    }
+
+    override fun visitIdentifierQualified(node: Identifier.Qualified, ctx: Ctx) = translate(node) { metas ->
+        // !! Legacy AST represents qualified identifiers as Expr.Path !!
+        val root = visitIdentifierSymbolAsExpr(node.root)
+        val steps = node.steps.map {
+            // Legacy AST wraps id twice and always uses CaseSensitive
+            val expr = visitIdentifierSymbolAsExpr(it)
+            pathExpr(expr, caseSensitive())
+        }
+        path(root, steps, metas)
+    }
+
+    override fun visitPath(node: Path, ctx: Ctx) = translate(node) { metas ->
+        val root = visitIdentifierSymbolAsExpr(node.root)
+        val steps = node.steps.translate<PartiqlAst.PathStep>(ctx)
+        path(root, steps, metas)
+    }
+
+    override fun visitPathStep(node: Path.Step, ctx: Ctx) = super.visitPathStep(node, ctx) as PartiqlAst.PathStep
+
+    override fun visitPathStepSymbol(node: Path.Step.Symbol, ctx: Ctx) = translate(node) { metas ->
+        // val index = visitIdentifierSymbolAsExpr(node.symbol, ctx)
+        val index = lit(ionString(node.symbol.symbol), metas)
+        val case = node.symbol.caseSensitivity.toLegacyCaseSensitivity()
+        pathExpr(index, case, metas)
+    }
+
+    override fun visitPathStepIndex(node: Path.Step.Index, ctx: Ctx) = translate(node) { metas ->
+        val index = lit(ionInt(node.index.toLong()))
+        val case = caseSensitive() // ???
+        pathExpr(index, case, metas)
+    }
+
+    /**
+     * EXPRESSIONS
+     */
+
+    override fun visitExpr(node: Expr, ctx: Ctx): PartiqlAst.Expr = super.visitExpr(node, ctx) as PartiqlAst.Expr
+
+    override fun visitExprLit(node: Expr.Lit, ctx: Ctx) = translate(node) { metas ->
+        when (val v = node.value) {
+            is MissingValue -> missing(metas)
+            is DateValue -> v.toLegacyAst(metas)
+            is TimeValue -> v.toLegacyAst(metas)
+            is TimestampValue -> v.toLegacyAst(metas)
+            else -> {
+                val ion = v.accept(ToIon, Unit) // v.toIon()
+                lit(ion, metas)
+            }
+        }
+    }
+
+    override fun visitExprIon(node: Expr.Ion, ctx: Ctx) = translate(node) { metas ->
+        lit(node.value, metas)
+    }
+
+    override fun visitExprVar(node: Expr.Var, ctx: Ctx) = translate(node) { metas ->
+        if (node.identifier is Identifier.Qualified) {
+            error("Qualified identifiers not allowed in legacy AST `id` variable references")
+        }
+        val v = node.identifier as Identifier.Symbol
+        val name = v.symbol
+        val case = v.caseSensitivity.toLegacyCaseSensitivity()
+        val qualifier = node.scope.toLegacyScope()
+        id(name, case, qualifier, metas)
+    }
+
+    override fun visitExprCall(node: Expr.Call, ctx: Ctx) = translate(node) { metas ->
+        if (node.function is Identifier.Qualified) {
+            error("Qualified identifiers are not allowed in legacy AST `call` function identifiers")
+        }
+        val funcName = (node.function as Identifier.Symbol).symbol.lowercase()
+        val args = node.args.translate<PartiqlAst.Expr>(ctx)
+        call(funcName, args, metas)
+    }
+
+    override fun visitExprAgg(node: Expr.Agg, ctx: Ctx) = translate(node) { metas ->
+        val setq = node.setq?.toLegacySetQuantifier() ?: all()
+        // Legacy AST translates COUNT(*) to COUNT(1)
+        if (node.function is Identifier.Symbol && (node.function as Identifier.Symbol).symbol == "COUNT_STAR") {
+            return callAgg(setq, "count", lit(ionInt(1)), metas)
+        }
+        // Default Case
+        if (node.args.size != 1) {
+            error("Legacy `call_agg` must have exactly one argument")
+        }
+        if (node.function is Identifier.Qualified) {
+            error("Qualified identifiers are not allowed in legacy AST `call_agg` function identifiers")
+        }
+        // Legacy parser/ast always inserts ALL quantifier
+        val funcName = (node.function as Identifier.Symbol).symbol.lowercase()
+        val arg = visitExpr(node.args[0], ctx)
+        callAgg(setq, funcName, arg, metas)
+    }
+
+    override fun visitExprUnary(node: Expr.Unary, ctx: Ctx) = translate(node) { metas ->
+        val arg = visitExpr(node.expr, ctx)
+        when (node.op) {
+            Expr.Unary.Op.NOT -> not(arg, metas)
+            Expr.Unary.Op.POS -> {
+                when {
+                    arg !is PartiqlAst.Expr.Lit -> pos(arg)
+                    arg.value is IntElement -> arg
+                    arg.value is FloatElement -> arg
+                    arg.value is DecimalElement -> arg
+                    else -> pos(arg)
+                }
+            }
+            Expr.Unary.Op.NEG -> {
+                when {
+                    arg !is PartiqlAst.Expr.Lit -> neg(arg, metas)
+                    arg.value is IntElement -> {
+                        val intValue = when (arg.value.integerSize) {
+                            IntElementSize.LONG -> ionInt(-arg.value.longValue)
+                            IntElementSize.BIG_INTEGER -> when (arg.value.bigIntegerValue) {
+                                Long.MAX_VALUE.toBigInteger() + (1L).toBigInteger() -> ionInt(Long.MIN_VALUE)
+                                else -> ionInt(arg.value.bigIntegerValue * BigInteger.valueOf(-1L))
+                            }
+                        }
+                        arg.copy(
+                            value = intValue.asAnyElement(),
+                            metas = metas,
+                        )
+                    }
+                    arg.value is FloatElement -> arg.copy(
+                        value = ionFloat(-(arg.value.doubleValue)).asAnyElement(),
+                        metas = metas,
+                    )
+                    arg.value is DecimalElement -> arg.copy(
+                        value = ionDecimal(Decimal.valueOf(-(arg.value.decimalValue))).asAnyElement(),
+                        metas = metas,
+                    )
+                    else -> neg(arg, metas)
+                }
+            }
+        }
+    }
+
+    override fun visitExprBinary(node: Expr.Binary, ctx: Ctx) = translate(node) { metas ->
+        val lhs = visitExpr(node.lhs, ctx)
+        val rhs = visitExpr(node.rhs, ctx)
+        val operands = listOf(lhs, rhs)
+        when (node.op) {
+            Expr.Binary.Op.PLUS -> plus(operands, metas)
+            Expr.Binary.Op.MINUS -> minus(operands, metas)
+            Expr.Binary.Op.TIMES -> times(operands, metas)
+            Expr.Binary.Op.DIVIDE -> divide(operands, metas)
+            Expr.Binary.Op.MODULO -> modulo(operands, metas)
+            Expr.Binary.Op.CONCAT -> concat(operands, metas)
+            Expr.Binary.Op.AND -> and(operands, metas)
+            Expr.Binary.Op.OR -> or(operands, metas)
+            Expr.Binary.Op.EQ -> eq(operands, metas)
+            Expr.Binary.Op.NE -> ne(operands, metas)
+            Expr.Binary.Op.GT -> gt(operands, metas)
+            Expr.Binary.Op.GTE -> gte(operands, metas)
+            Expr.Binary.Op.LT -> lt(operands, metas)
+            Expr.Binary.Op.LTE -> lte(operands, metas)
+        }
+    }
+
+    override fun visitExprPath(node: Expr.Path, ctx: Ctx) = translate(node) { metas ->
+        val root = visitExpr(node.root, ctx)
+        val steps = node.steps.map { visitExprPathStep(it, ctx) }
+        path(root, steps, metas)
+    }
+
+    override fun visitExprPathStep(node: Expr.Path.Step, ctx: Ctx) =
+        super.visitExprPathStep(node, ctx) as PartiqlAst.PathStep
+
+    override fun visitExprPathStepSymbol(node: Expr.Path.Step.Symbol, ctx: Ctx) = translate(node) { metas ->
+        val index = lit(ionString(node.symbol.symbol))
+        val case = node.symbol.caseSensitivity.toLegacyCaseSensitivity()
+        pathExpr(index, case, metas)
+    }
+
+    override fun visitExprPathStepIndex(node: Expr.Path.Step.Index, ctx: Ctx) = translate(node) { metas ->
+        val index = visitExpr(node.key, ctx)
+        // Legacy AST marks every index step as CaseSensitive
+        val case = when (index) {
+            is PartiqlAst.Expr.Id -> index.case
+            else -> PartiqlAst.CaseSensitivity.CaseSensitive()
+        }
+        pathExpr(index, case, metas)
+    }
+
+    override fun visitExprPathStepWildcard(node: Expr.Path.Step.Wildcard, ctx: Ctx) = translate(node) { metas ->
+        pathWildcard(metas)
+    }
+
+    override fun visitExprPathStepUnpivot(node: Expr.Path.Step.Unpivot, ctx: Ctx) = translate(node) { metas ->
+        pathUnpivot(metas)
+    }
+
+    override fun visitExprParameter(node: Expr.Parameter, ctx: Ctx) = translate(node) { metas ->
+        parameter(node.index.toLong(), metas)
+    }
+
+    override fun visitExprValues(node: Expr.Values, ctx: Ctx) = translate(node) { metas ->
+        val rows = node.rows.map { visitExprValuesRow(it, ctx) }
+        bag(rows, metas + metaContainerOf(IsValuesExprMeta.instance))
+    }
+
+    override fun visitExprValuesRow(node: Expr.Values.Row, ctx: Ctx) = translate(node) { metas ->
+        val exprs = node.items.translate<PartiqlAst.Expr>(ctx)
+        list(exprs, metas + metaContainerOf(IsListParenthesizedMeta))
+    }
+
+    override fun visitExprCollection(node: Expr.Collection, ctx: Ctx) = translate(node) { metas ->
+        val values = node.values.translate<PartiqlAst.Expr>(ctx)
+        when (node.type) {
+            Expr.Collection.Type.BAG -> bag(values, metas)
+            Expr.Collection.Type.ARRAY -> list(values, metas)
+            Expr.Collection.Type.VALUES -> list(values, metas + metaContainerOf(IsValuesExprMeta.instance))
+            Expr.Collection.Type.LIST -> list(values, metas + metaContainerOf(IsListParenthesizedMeta))
+            Expr.Collection.Type.SEXP -> sexp(values, metas)
+        }
+    }
+
+    override fun visitExprStruct(node: Expr.Struct, ctx: Ctx) = translate(node) { metas ->
+        val fields = node.fields.translate<PartiqlAst.ExprPair>(ctx)
+        struct(fields, metas)
+    }
+
+    override fun visitExprStructField(node: Expr.Struct.Field, ctx: Ctx) = translate(node) { metas ->
+        val first = visitExpr(node.name, ctx)
+        val second = visitExpr(node.value, ctx)
+        exprPair(first, second, metas)
+    }
+
+    override fun visitExprLike(node: Expr.Like, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val pattern = visitExpr(node.pattern, ctx)
+        val escape = visitOrNull<PartiqlAst.Expr>(node.escape, ctx)
+        if (node.not != null && node.not!!) {
+            not(like(value, pattern, escape), metas)
+        } else {
+            like(value, pattern, escape, metas)
+        }
+    }
+
+    override fun visitExprBetween(node: Expr.Between, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val from = visitExpr(node.from, ctx)
+        val to = visitExpr(node.to, ctx)
+        if (node.not != null && node.not!!) {
+            not(between(value, from, to), metas)
+        } else {
+            between(value, from, to, metas)
+        }
+    }
+
+    override fun visitExprInCollection(node: Expr.InCollection, ctx: Ctx) = translate(node) { metas ->
+        val lhs = visitExpr(node.lhs, ctx)
+        val rhs = visitExpr(node.rhs, ctx)
+        val operands = listOf(lhs, rhs)
+        if (node.not != null && node.not!!) {
+            not(inCollection(operands), metas)
+        } else {
+            inCollection(operands, metas)
+        }
+    }
+
+    override fun visitExprIsType(node: Expr.IsType, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val type = visitType(node.type, ctx)
+        if (node.not != null && node.not!!) {
+            not(isType(value, type), metas)
+        } else {
+            isType(value, type, metas)
+        }
+    }
+
+    override fun visitExprCase(node: Expr.Case, ctx: Ctx) = translate(node) { metas ->
+        val cases = exprPairList(node.branches.translate<PartiqlAst.ExprPair>(ctx))
+        val condition = visitOrNull<PartiqlAst.Expr>(node.expr, ctx)
+        val default = visitOrNull<PartiqlAst.Expr>(node.default, ctx)
+        when (condition) {
+            null -> searchedCase(cases, default, metas)
+            else -> simpleCase(condition, cases, default, metas)
+        }
+    }
+
+    override fun visitExprCaseBranch(node: Expr.Case.Branch, ctx: Ctx) = translate(node) { metas ->
+        val first = visitExpr(node.condition, ctx)
+        val second = visitExpr(node.expr, ctx)
+        exprPair(first, second, metas)
+    }
+
+    override fun visitExprCoalesce(node: Expr.Coalesce, ctx: Ctx) = translate(node) { metas ->
+        val args = node.args.translate<PartiqlAst.Expr>(ctx)
+        coalesce(args, metas)
+    }
+
+    override fun visitExprNullIf(node: Expr.NullIf, ctx: Ctx) = translate(node) { metas ->
+        val expr1 = visitExpr(node.value, ctx)
+        val expr2 = visitExpr(node.nullifier, ctx)
+        nullIf(expr1, expr2, metas)
+    }
+
+    override fun visitExprSubstring(node: Expr.Substring, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val start = visitOrNull<PartiqlAst.Expr>(node.start, ctx)
+        val length = visitOrNull<PartiqlAst.Expr>(node.length, ctx)
+        val operands = listOfNotNull(value, start, length)
+        call("substring", operands, metas)
+    }
+
+    override fun visitExprPosition(node: Expr.Position, ctx: Ctx) = translate(node) { metas ->
+        val lhs = visitExpr(node.lhs, ctx)
+        val rhs = visitExpr(node.rhs, ctx)
+        val operands = listOf(lhs, rhs)
+        call("position", operands, metas)
+    }
+
+    override fun visitExprTrim(node: Expr.Trim, ctx: Ctx) = translate(node) { metas ->
+        val operands = mutableListOf<PartiqlAst.Expr>()
+        // Legacy AST requires adding the spec as an argument
+        val spec = node.spec?.toString()?.lowercase()
+        val chars = node.chars?.let { visitExpr(it, ctx) }
+        val value = visitExpr(node.value, ctx)
+        if (spec != null) operands.add(lit(ionSymbol(spec)))
+        if (chars != null) operands.add(chars)
+        operands.add(value)
+        call("trim", operands, metas)
+    }
+
+    override fun visitExprOverlay(node: Expr.Overlay, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val overlay = visitExpr(node.overlay, ctx)
+        val start = visitExpr(node.start, ctx)
+        val length = visitOrNull<PartiqlAst.Expr>(node.length, ctx)
+        val operands = listOfNotNull(value, overlay, start, length)
+        call("overlay", operands, metas)
+    }
+
+    override fun visitExprExtract(node: Expr.Extract, ctx: Ctx) = translate(node) { metas ->
+        val field = node.field.toLegacyDatetimePart()
+        val source = visitExpr(node.source, ctx)
+        val operands = listOf(field, source)
+        call("extract", operands, metas)
+    }
+
+    override fun visitExprCast(node: Expr.Cast, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val asType = visitType(node.asType, ctx)
+        cast(value, asType, metas)
+    }
+
+    override fun visitExprCanCast(node: Expr.CanCast, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val asType = visitType(node.asType, ctx)
+        canCast(value, asType, metas)
+    }
+
+    override fun visitExprCanLosslessCast(node: Expr.CanLosslessCast, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val asType = visitType(node.asType, ctx)
+        canLosslessCast(value, asType, metas)
+    }
+
+    override fun visitExprDateAdd(node: Expr.DateAdd, ctx: Ctx) = translate(node) { metas ->
+        val field = node.field.toLegacyDatetimePart()
+        val lhs = visitExpr(node.lhs, ctx)
+        val rhs = visitExpr(node.rhs, ctx)
+        val operands = listOf(field, lhs, rhs)
+        call("date_add", operands, metas)
+    }
+
+    override fun visitExprDateDiff(node: Expr.DateDiff, ctx: Ctx) = translate(node) { metas ->
+        val field = node.field.toLegacyDatetimePart()
+        val lhs = visitExpr(node.lhs, ctx)
+        val rhs = visitExpr(node.rhs, ctx)
+        val operands = listOf(field, lhs, rhs)
+        call("date_diff", operands, metas)
+    }
+
+    override fun visitExprBagOp(node: Expr.BagOp, ctx: Ctx) = translate(node) { metas ->
+        val lhs = visitExpr(node.lhs, ctx)
+        val rhs = visitExpr(node.rhs, ctx)
+        val op = when (node.outer) {
+            true -> when (node.type.type) {
+                SetOp.Type.UNION -> outerUnion()
+                SetOp.Type.INTERSECT -> outerIntersect()
+                SetOp.Type.EXCEPT -> outerExcept()
+            }
+            else -> when (node.type.type) {
+                SetOp.Type.UNION -> union()
+                SetOp.Type.INTERSECT -> intersect()
+                SetOp.Type.EXCEPT -> except()
+            }
+        }
+        val setq = node.type.setq?.toLegacySetQuantifier() ?: distinct()
+        val operands = listOf(lhs, rhs)
+        bagOp(op, setq, operands, metas)
+    }
+
+    override fun visitExprMatch(node: Expr.Match, ctx: Ctx) = translate(node) { metas ->
+        val expr = visitExpr(node.expr, ctx)
+        val match = visitGraphMatch(node.pattern, ctx)
+        graphMatch(expr, match, metas)
+    }
+
+    override fun visitExprWindow(node: Expr.Window, ctx: Ctx) = translate(node) { metas ->
+        val funcName = node.function.name.lowercase()
+        val over = visitExprWindowOver(node.over, ctx)
+        val args = listOfNotNull(node.expression, node.offset, node.default).translate<PartiqlAst.Expr>(ctx)
+        callWindow(funcName, over, args, metas)
+    }
+
+    override fun visitExprWindowOver(node: Expr.Window.Over, ctx: Ctx) = translate(node) { metas ->
+        val partitionBy = node.partitions?.let {
+            val partitions = it.translate<PartiqlAst.Expr>(ctx)
+            windowPartitionList(partitions)
+        }
+        val orderBy = node.sorts?.let {
+            val sorts = it.translate<PartiqlAst.SortSpec>(ctx)
+            windowSortSpecList(sorts)
+        }
+        over(partitionBy, orderBy, metas)
+    }
+
+    override fun visitExprSessionAttribute(node: Expr.SessionAttribute, ctx: Ctx) = translate(node) { metas ->
+        sessionAttribute(node.attribute.name.lowercase(), metas)
+    }
+
+    /**
+     * SELECT-FROM-WHERE
+     */
+
+    override fun visitExprSFW(node: Expr.SFW, ctx: Ctx) = translate(node) { metas ->
+        var setq = when (val s = node.select) {
+            is Select.Pivot -> null
+            is Select.Project -> s.setq?.toLegacySetQuantifier()
+            is Select.Star -> s.setq?.toLegacySetQuantifier()
+            is Select.Value -> s.setq?.toLegacySetQuantifier()
+        }
+        // Legacy AST removes (setq (all))
+        if (setq != null && setq is PartiqlAst.SetQuantifier.All) {
+            setq = null
+        }
+        val project = visitSelect(node.select, ctx)
+        val from = visitFrom(node.from, ctx)
+        val fromLet = node.let?.let { visitLet(it, ctx) }
+        val where = node.where?.let { visitExpr(it, ctx) }
+        val groupBy = node.groupBy?.let { visitGroupBy(it, ctx) }
+        val having = node.having?.let { visitExpr(it, ctx) }
+        val orderBy = node.orderBy?.let { visitOrderBy(it, ctx) }
+        val limit = node.limit?.let { visitExpr(it, ctx) }
+        val offset = node.offset?.let { visitExpr(it, ctx) }
+        select(setq, project, from, fromLet, where, groupBy, having, orderBy, limit, offset, metas)
+    }
+
+    /**
+     * UNSUPPORTED in legacy AST
+     */
+    override fun visitExprSFWSetOp(node: Expr.SFW.SetOp, ctx: Ctx) = defaultVisit(node, ctx)
+
+    override fun visitSelect(node: Select, ctx: Ctx) = super.visitSelect(node, ctx) as PartiqlAst.Projection
+
+    override fun visitSelectStar(node: Select.Star, ctx: Ctx) = translate(node) { metas ->
+        projectStar(metas)
+    }
+
+    override fun visitSelectProject(node: Select.Project, ctx: Ctx) = translate(node) { metas ->
+        val items = node.items.translate<PartiqlAst.ProjectItem>(ctx)
+        projectList(items, metas)
+    }
+
+    override fun visitSelectProjectItem(node: Select.Project.Item, ctx: Ctx) =
+        super.visitSelectProjectItem(node, ctx) as PartiqlAst.ProjectItem
+
+    override fun visitSelectProjectItemAll(node: Select.Project.Item.All, ctx: Ctx) = translate(node) { metas ->
+        val expr = visitExpr(node.expr, ctx)
+        projectAll(expr, metas)
+    }
+
+    override fun visitSelectProjectItemExpression(node: Select.Project.Item.Expression, ctx: Ctx) =
+        translate(node) { metas ->
+            val expr = visitExpr(node.expr, ctx)
+            val alias = node.asAlias?.symbol
+            projectExpr(expr, alias, metas)
+        }
+
+    override fun visitSelectPivot(node: Select.Pivot, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.value, ctx)
+        val key = visitExpr(node.key, ctx)
+        projectPivot(value, key, metas)
+    }
+
+    override fun visitSelectValue(node: Select.Value, ctx: Ctx) = translate(node) { metas ->
+        val value = visitExpr(node.constructor, ctx)
+        projectValue(value, metas)
+    }
+
+    override fun visitFrom(node: From, ctx: Ctx) = super.visitFrom(node, ctx) as PartiqlAst.FromSource
+    override fun visitFromValue(node: From.Value, ctx: Ctx) = translate(node) { metas ->
+        val expr = visitExpr(node.expr, ctx)
+        val asAlias = node.asAlias?.symbol
+        val atAlias = node.atAlias?.symbol
+        val byAlias = node.byAlias?.symbol
+        when (node.type) {
+            From.Value.Type.SCAN -> scan(expr, asAlias, atAlias, byAlias, metas)
+            From.Value.Type.UNPIVOT -> unpivot(expr, asAlias, atAlias, byAlias, metas)
+        }
+    }
+
+    // Legacy AST models CROSS JOIN and COMMA-syntax CROSS JOIN as FULL JOIN
+    // Legacy AST does not have OUTER variants
+    override fun visitFromJoin(node: From.Join, ctx: Ctx) = translate(node) { metas ->
+        val type = when (node.type) {
+            From.Join.Type.INNER -> inner()
+            From.Join.Type.LEFT -> left()
+            From.Join.Type.LEFT_OUTER -> left()
+            From.Join.Type.RIGHT -> right()
+            From.Join.Type.RIGHT_OUTER -> right()
+            From.Join.Type.FULL -> full()
+            From.Join.Type.FULL_OUTER -> full()
+            From.Join.Type.CROSS -> full()
+            From.Join.Type.COMMA -> full()
+            null -> inner()
+        }
+        val lhs = visitFrom(node.lhs, ctx)
+        val rhs = visitFrom(node.rhs, ctx)
+        val condition = visitOrNull<PartiqlAst.Expr>(node.condition, ctx)
+        join(type, lhs, rhs, condition, metas)
+    }
+
+    override fun visitLet(node: Let, ctx: Ctx) = translate(node) { metas ->
+        val bindings = node.bindings.translate<PartiqlAst.LetBinding>(ctx)
+        let(bindings, metas)
+    }
+
+    override fun visitLetBinding(node: Let.Binding, ctx: Ctx) = translate(node) { metas ->
+        val expr = visitExpr(node.expr, ctx)
+        val name = node.asAlias?.symbol
+        letBinding(expr, name, metas)
+    }
+
+    override fun visitGroupBy(node: GroupBy, ctx: Ctx) = translate(node) { metas ->
+        val strategy = when (node.strategy) {
+            GroupBy.Strategy.FULL -> groupFull()
+            GroupBy.Strategy.PARTIAL -> groupPartial()
+        }
+        val keyList = groupKeyList(node.keys.translate<PartiqlAst.GroupKey>(ctx))
+        val groupAsAlias = node.asAlias?.symbol
+        groupBy(strategy, keyList, groupAsAlias, metas)
+    }
+
+    override fun visitGroupByKey(node: GroupBy.Key, ctx: Ctx) = translate(node) { metas ->
+        val expr = visitExpr(node.expr, ctx)
+        val asAlias = node.asAlias?.symbol
+        groupKey(expr, asAlias, metas)
+    }
+
+    override fun visitOrderBy(node: OrderBy, ctx: Ctx) = translate(node) { metas ->
+        val sortSpecs = node.sorts.translate<PartiqlAst.SortSpec>(ctx)
+        orderBy(sortSpecs, metas)
+    }
+
+    override fun visitSort(node: Sort, ctx: Ctx) = translate(node) { metas ->
+        val expr = visitExpr(node.expr, ctx)
+        val orderingSpec = when (node.dir) {
+            Sort.Dir.ASC -> asc()
+            Sort.Dir.DESC -> desc()
+            null -> null
+        }
+        val nullsSpec = when (node.nulls) {
+            Sort.Nulls.FIRST -> nullsFirst()
+            Sort.Nulls.LAST -> nullsLast()
+            null -> null
+        }
+        sortSpec(expr, orderingSpec, nullsSpec, metas)
+    }
+
+    /**
+     * UNSUPPORTED in legacy AST
+     */
+    override fun visitSetOp(node: SetOp, ctx: Ctx) = defaultVisit(node, ctx)
+
+    /**
+     * GPML
+     */
+
+    override fun visitGraphMatch(node: GraphMatch, ctx: Ctx) = translate(node) { metas ->
+        val selector = node.selector?.let { visitGraphMatchSelector(it, ctx) }
+        val patterns = node.patterns.translate<PartiqlAst.GraphMatchPattern>(ctx)
+        gpmlPattern(selector, patterns, metas)
+    }
+
+    override fun visitGraphMatchPattern(node: GraphMatch.Pattern, ctx: Ctx) = translate(node) { metas ->
+        val restrictor = when (node.restrictor) {
+            GraphMatch.Restrictor.TRAIL -> restrictorTrail()
+            GraphMatch.Restrictor.ACYCLIC -> restrictorAcyclic()
+            GraphMatch.Restrictor.SIMPLE -> restrictorSimple()
+            null -> null
+        }
+        val prefilter = node.prefilter?.let { visitExpr(it, ctx) }
+        val variable = node.variable
+        val quantifier = node.quantifier?.let { visitGraphMatchQuantifier(it, ctx) }
+        val parts = node.parts.translate<PartiqlAst.GraphMatchPatternPart>(ctx)
+        graphMatchPattern(restrictor, prefilter, variable, quantifier, parts, metas)
+    }
+
+    override fun visitGraphMatchPatternPart(node: GraphMatch.Pattern.Part, ctx: Ctx) =
+        super.visitGraphMatchPatternPart(node, ctx) as PartiqlAst.GraphMatchPatternPart
+
+    override fun visitGraphMatchPatternPartNode(node: GraphMatch.Pattern.Part.Node, ctx: Ctx) =
+        translate(node) { metas ->
+            val prefilter = node.prefilter?.let { visitExpr(it, ctx) }
+            val variable = node.variable
+            val label = node.label?.let { visitGraphMatchLabel(it, ctx) }
+            node(prefilter, variable, label, metas)
+        }
+
+    override fun visitGraphMatchPatternPartEdge(node: GraphMatch.Pattern.Part.Edge, ctx: Ctx) =
+        translate(node) { metas ->
+            val direction = when (node.direction) {
+                GraphMatch.Direction.LEFT -> edgeLeft()
+                GraphMatch.Direction.UNDIRECTED -> edgeUndirected()
+                GraphMatch.Direction.RIGHT -> edgeRight()
+                GraphMatch.Direction.LEFT_OR_UNDIRECTED -> edgeLeftOrUndirected()
+                GraphMatch.Direction.UNDIRECTED_OR_RIGHT -> edgeUndirectedOrRight()
+                GraphMatch.Direction.LEFT_OR_RIGHT -> edgeLeftOrRight()
+                GraphMatch.Direction.LEFT_UNDIRECTED_OR_RIGHT -> edgeLeftOrUndirectedOrRight()
+            }
+            val quantifier = node.quantifier?.let { visitGraphMatchQuantifier(it, ctx) }
+            val prefilter = node.prefilter?.let { visitExpr(it, ctx) }
+            val variable = node.variable
+            val label = node.label?.let { visitGraphMatchLabel(it, ctx) }
+            edge(direction, quantifier, prefilter, variable, label, metas)
+        }
+
+    override fun visitGraphMatchPatternPartPattern(node: GraphMatch.Pattern.Part.Pattern, ctx: Ctx) =
+        translate(node) { metas ->
+            pattern(visitGraphMatchPattern(node.pattern, ctx), metas)
+        }
+
+    override fun visitGraphMatchQuantifier(node: GraphMatch.Quantifier, ctx: Ctx) = translate(node) { metas ->
+        val lower = node.lower
+        val upper = node.upper
+        graphMatchQuantifier(lower, upper, metas)
+    }
+
+    override fun visitGraphMatchSelector(node: GraphMatch.Selector, ctx: Ctx) =
+        super.visitGraphMatchSelector(node, ctx) as PartiqlAst.GraphMatchSelector
+
+    override fun visitGraphMatchSelectorAnyShortest(node: GraphMatch.Selector.AnyShortest, ctx: Ctx) =
+        translate(node) { metas ->
+            selectorAnyShortest(metas)
+        }
+
+    override fun visitGraphMatchSelectorAllShortest(node: GraphMatch.Selector.AllShortest, ctx: Ctx) =
+        translate(node) { metas ->
+            selectorAllShortest(metas)
+        }
+
+    override fun visitGraphMatchSelectorAny(node: GraphMatch.Selector.Any, ctx: Ctx) = translate(node) { metas ->
+        selectorAny(metas)
+    }
+
+    override fun visitGraphMatchSelectorAnyK(node: GraphMatch.Selector.AnyK, ctx: Ctx) = translate(node) { metas ->
+        val k = node.k
+        selectorAnyK(k, metas)
+    }
+
+    override fun visitGraphMatchSelectorShortestK(
+        node: GraphMatch.Selector.ShortestK,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val k = node.k
+        selectorShortestK(k, metas)
+    }
+
+    override fun visitGraphMatchSelectorShortestKGroup(
+        node: GraphMatch.Selector.ShortestKGroup,
+        ctx: Ctx,
+    ) = translate(node) {
+        val k = node.k
+        selectorShortestKGroup(k)
+    }
+
+    override fun visitGraphMatchLabel(node: GraphMatch.Label, ctx: Ctx) =
+        super.visitGraphMatchLabel(node, ctx) as PartiqlAst.GraphLabelSpec
+
+    override fun visitGraphMatchLabelName(node: GraphMatch.Label.Name, ctx: Ctx) =
+        translate(node) { metas ->
+            graphLabelName(node.name, metas)
+        }
+
+    override fun visitGraphMatchLabelWildcard(node: GraphMatch.Label.Wildcard, ctx: Ctx) =
+        translate(node) { metas ->
+            graphLabelWildcard(metas)
+        }
+
+    override fun visitGraphMatchLabelNegation(node: GraphMatch.Label.Negation, ctx: Ctx) =
+        translate(node) { metas ->
+            val arg = visitGraphMatchLabel(node.arg, ctx)
+            graphLabelNegation(arg, metas)
+        }
+
+    override fun visitGraphMatchLabelConj(node: GraphMatch.Label.Conj, ctx: Ctx) =
+        translate(node) { metas ->
+            val lhs = visitGraphMatchLabel(node.lhs, ctx)
+            val rhs = visitGraphMatchLabel(node.rhs, ctx)
+            graphLabelConj(lhs, rhs, metas)
+        }
+
+    override fun visitGraphMatchLabelDisj(node: GraphMatch.Label.Disj, ctx: Ctx) =
+        translate(node) { metas ->
+            val lhs = visitGraphMatchLabel(node.lhs, ctx)
+            val rhs = visitGraphMatchLabel(node.rhs, ctx)
+            graphLabelDisj(lhs, rhs, metas)
+        }
+
+    /**
+     * DML
+     */
+
+    override fun visitStatementDML(node: Statement.DML, ctx: Ctx) =
+        super.visitStatementDML(node, ctx) as PartiqlAst.Statement
+
+    override fun visitStatementDMLInsert(node: Statement.DML.Insert, ctx: Ctx) = translate(node) { metas ->
+        val target = visitIdentifier(node.target, ctx)
+        val asAlias = node.asAlias?.symbol
+        val values = visitExpr(node.values, ctx)
+        val conflictAction = node.onConflict?.let { visitOnConflictAction(it.action, ctx) }
+        val op = insert(target, asAlias, values, conflictAction)
+        dml(dmlOpList(op), null, null, null, metas)
+    }
+
+    override fun visitStatementDMLInsertLegacy(
+        node: Statement.DML.InsertLegacy,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val target = visitPathUnpack(node.target, ctx)
+        val values = visitExpr(node.value, ctx)
+        val index = node.index?.let { visitExpr(it, ctx) }
+        val onConflict = node.conflictCondition?.let {
+            val condition = visitExpr(it, ctx)
+            onConflict(condition, doNothing())
+        }
+        val op = insertValue(target, values, index, onConflict)
+        dml(dmlOpList(op), null, null, null, metas)
+    }
+
+    override fun visitStatementDMLUpsert(node: Statement.DML.Upsert, ctx: Ctx) = translate(node) { metas ->
+        val target = visitIdentifier(node.target, ctx)
+        val asAlias = node.asAlias?.symbol
+        val values = visitExpr(node.values, ctx)
+        val conflictAction = doUpdate(excluded())
+        // UPSERT overloads legacy INSERT
+        val op = insert(target, asAlias, values, conflictAction)
+        dml(dmlOpList(op), null, null, null, metas)
+    }
+
+    override fun visitStatementDMLReplace(node: Statement.DML.Replace, ctx: Ctx) = translate(node) { metas ->
+        val target = visitIdentifier(node.target, ctx)
+        val asAlias = node.asAlias?.symbol
+        val values = visitExpr(node.values, ctx)
+        val conflictAction = doReplace(excluded())
+        // REPLACE overloads legacy INSERT
+        val op = insert(target, asAlias, values, conflictAction)
+        dml(dmlOpList(op), null, null, null, metas)
+    }
+
+    override fun visitStatementDMLUpdate(node: Statement.DML.Update, ctx: Ctx) = translate(node) { metas ->
+        // Current PartiQL.g4 grammar models a SET with no UPDATE target as valid DML command.
+        // We don't want the target to be nullable in the AST because it's not in the SQL grammar.
+        // val target = visitPathUnpack(node.target, ctx)
+        // val from = scan(target)
+        // UPDATE becomes multiple sets
+        val operations = node.assignments.map {
+            val assignment = visitStatementDMLUpdateAssignment(it, ctx)
+            set(assignment)
+        }
+        dml(dmlOpList(operations), null, null, null, metas)
+    }
+
+    override fun visitStatementDMLUpdateAssignment(
+        node: Statement.DML.Update.Assignment,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val target = visitPathUnpack(node.target, ctx)
+        val value = visitExpr(node.value, ctx)
+        assignment(target, value, metas)
+    }
+
+    override fun visitStatementDMLRemove(node: Statement.DML.Remove, ctx: Ctx) = translate(node) { metas ->
+        val target = visitPathUnpack(node.target, ctx)
+        val op = remove(target)
+        dml(dmlOpList(op), null, null, null, metas)
+    }
+
+    override fun visitStatementDMLDelete(node: Statement.DML.Delete, ctx: Ctx) = translate(node) { metas ->
+        val from = visitStatementDMLDeleteTarget(node.target, ctx)
+        val where = node.where?.let { visitExpr(it, ctx) }
+        val returning = node.returning?.let { visitReturning(it, ctx) }
+        val op = delete()
+        dml(dmlOpList(op), from, where, returning, metas)
+    }
+
+    override fun visitStatementDMLDeleteTarget(node: Statement.DML.Delete.Target, ctx: Ctx) = translate(node) { metas ->
+        val path = visitPathUnpack(node.path, ctx)
+        val asAlias = node.asAlias?.symbol
+        val atAlias = node.atAlias?.symbol
+        val byAlias = node.byAlias?.symbol
+        scan(path, asAlias, atAlias, byAlias, metas)
+    }
+
+    override fun visitStatementDMLBatchLegacy(node: Statement.DML.BatchLegacy, ctx: Ctx) = translate(node) { metas ->
+        val from = node.target?.let { visitFrom(it, ctx) }
+        val ops = node.ops.translate<PartiqlAst.DmlOpList>(ctx).flatMap { it.ops }
+        val where = node.where?.let { visitExpr(it, ctx) }
+        val returning = node.returning?.let { visitReturning(it, ctx) }
+        dml(dmlOpList(ops), from, where, returning, metas)
+    }
+
+    override fun visitStatementDMLBatchLegacyOp(node: Statement.DML.BatchLegacy.Op, ctx: Ctx) =
+        super.visitStatementDMLBatchLegacyOp(node, ctx) as PartiqlAst.DmlOpList
+
+    override fun visitStatementDMLBatchLegacyOpSet(
+        node: Statement.DML.BatchLegacy.Op.Set,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val ops = node.assignments.map {
+            val assignment = visitStatementDMLUpdateAssignment(it, ctx)
+            set(assignment)
+        }
+        dmlOpList(ops, metas)
+    }
+
+    override fun visitStatementDMLBatchLegacyOpRemove(
+        node: Statement.DML.BatchLegacy.Op.Remove,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val target = visitPathUnpack(node.target, ctx)
+        val ops = listOf(remove(target))
+        dmlOpList(ops, metas)
+    }
+
+    override fun visitStatementDMLBatchLegacyOpDelete(
+        node: Statement.DML.BatchLegacy.Op.Delete,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val ops = listOf(delete())
+        dmlOpList(ops, metas)
+    }
+
+    override fun visitStatementDMLBatchLegacyOpInsert(
+        node: Statement.DML.BatchLegacy.Op.Insert,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val target = visitIdentifier(node.target, ctx)
+        val asAlias = node.asAlias?.symbol
+        val values = visitExpr(node.values, ctx)
+        val conflictAction = node.onConflict?.let { visitOnConflictAction(it.action, ctx) }
+        dmlOpList(insert(target, asAlias, values, conflictAction, metas))
+    }
+
+    override fun visitStatementDMLBatchLegacyOpInsertLegacy(
+        node: Statement.DML.BatchLegacy.Op.InsertLegacy,
+        ctx: Ctx,
+    ) = translate(node) {
+        val target = visitPathUnpack(node.target, ctx)
+        val values = visitExpr(node.value, ctx)
+        val index = node.index?.let { visitExpr(it, ctx) }
+        val onConflict = node.conflictCondition?.let {
+            val condition = visitExpr(it, ctx)
+            onConflict(condition, doNothing())
+        }
+        dmlOpList(insertValue(target, values, index, onConflict))
+    }
+
+    override fun visitOnConflict(node: OnConflict, ctx: Ctx) = translate(node) { metas ->
+        val action = visitOnConflictAction(node.action, ctx)
+        if (node.target == null) {
+            // Legacy PartiQLPifVisitor doesn't respect the return type for the OnConflict rule
+            // - visitOnConflictLegacy returns an OnConflict node
+            // - visitOnConflict returns an OnConflict.Action
+            // Essentially, the on_conflict target appears in the grammar but not the PIG model
+            // Which means you technically can't use the #OnConflict alternative in certain contexts.
+            // We generally shouldn't have parser rule alternatives which are not variants of the same type.
+            throw IllegalArgumentException("PIG OnConflict (#OnConflictLegacy grammar rule) requires an expression")
+        }
+        val expr = visitOnConflictTarget(node.target!!, ctx)
+        onConflict(expr, action, metas)
+    }
+
+    override fun visitOnConflictTarget(node: OnConflict.Target, ctx: Ctx) =
+        super.visitOnConflictTarget(node, ctx) as PartiqlAst.Expr
+
+    override fun visitOnConflictTargetSymbols(
+        node: OnConflict.Target.Symbols,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val symbols = node.symbols.map {
+            if (it !is Identifier.Symbol) {
+                throw IllegalArgumentException("Legacy AST does not support qualified identifiers as index names")
+            }
+            lit(ionSymbol(it.symbol))
+        }
+        list(symbols, metas)
+    }
+
+    override fun visitOnConflictTargetConstraint(
+        node: OnConflict.Target.Constraint,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        if (node.constraint !is Identifier.Symbol) {
+            throw IllegalArgumentException("Legacy AST does not support qualified identifiers as a constraint name")
+        }
+        val constraint = (node.constraint as Identifier.Symbol).symbol
+        lit(ionSymbol(constraint), metas)
+    }
+
+    override fun visitOnConflictAction(node: OnConflict.Action, ctx: Ctx) =
+        super.visitOnConflictAction(node, ctx) as PartiqlAst.ConflictAction
+
+    override fun visitOnConflictActionDoReplace(
+        node: OnConflict.Action.DoReplace,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val value = excluded()
+        val condition = node.condition?.let { visitExpr(it, ctx) }
+        doReplace(value, condition, metas)
+    }
+
+    override fun visitOnConflictActionDoUpdate(
+        node: OnConflict.Action.DoUpdate,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        val value = excluded()
+        val condition = node.condition?.let { visitExpr(it, ctx) }
+        doUpdate(value, condition, metas)
+    }
+
+    override fun visitOnConflictActionDoNothing(
+        node: OnConflict.Action.DoNothing,
+        ctx: Ctx,
+    ) = translate(node) { metas ->
+        doNothing(metas)
+    }
+
+    override fun visitReturning(node: Returning, ctx: Ctx) = translate(node) { metas ->
+        val elems = node.columns.translate<PartiqlAst.ReturningElem>(ctx)
+        returningExpr(elems, metas)
+    }
+
+    override fun visitReturningColumn(node: Returning.Column, ctx: Ctx) = translate(node) {
+        // a fine example of `when` is `if`, not pattern matching
+        val mapping = when (node.status) {
+            Returning.Column.Status.MODIFIED -> when (node.age) {
+                Returning.Column.Age.OLD -> modifiedOld()
+                Returning.Column.Age.NEW -> modifiedNew()
+            }
+            Returning.Column.Status.ALL -> when (node.age) {
+                Returning.Column.Age.OLD -> allOld()
+                Returning.Column.Age.NEW -> allNew()
+            }
+        }
+        val column = visitReturningColumnValue(node.value, ctx)
+        returningElem(mapping, column)
+    }
+
+    override fun visitReturningColumnValue(node: Returning.Column.Value, ctx: Ctx) =
+        super.visitReturningColumnValue(node, ctx) as PartiqlAst.ColumnComponent
+
+    override fun visitReturningColumnValueWildcard(
+        node: Returning.Column.Value.Wildcard,
+        ctx: Ctx,
+    ) = translate(node) {
+        returningWildcard()
+    }
+
+    override fun visitReturningColumnValueExpression(
+        node: Returning.Column.Value.Expression,
+        ctx: Ctx,
+    ) = translate(node) {
+        val expr = visitExpr(node.expr, ctx)
+        returningColumn(expr)
+    }
+
+    /**
+     * TYPE
+     */
+
+    override fun visitType(node: Type, ctx: Ctx) = super.visitType(node, ctx) as PartiqlAst.Type
+
+    override fun visitTypeNullType(node: Type.NullType, ctx: Ctx) = translate(node) { metas -> nullType(metas) }
+
+    override fun visitTypeMissing(node: Type.Missing, ctx: Ctx) = translate(node) { metas -> missingType(metas) }
+
+    override fun visitTypeBool(node: Type.Bool, ctx: Ctx) = translate(node) { metas -> booleanType(metas) }
+
+    override fun visitTypeTinyint(node: Type.Tinyint, ctx: Ctx) =
+        throw IllegalArgumentException("TINYINT type not supported")
+
+    override fun visitTypeSmallint(node: Type.Smallint, ctx: Ctx) = translate(node) { metas -> smallintType(metas) }
+
+    override fun visitTypeInt2(node: Type.Int2, ctx: Ctx) = translate(node) { metas -> smallintType(metas) }
+
+    override fun visitTypeInt4(node: Type.Int4, ctx: Ctx) = translate(node) { metas -> integer4Type(metas) }
+
+    override fun visitTypeBigint(node: Type.Bigint, ctx: Ctx) = translate(node) { metas -> integer8Type(metas) }
+
+    override fun visitTypeInt8(node: Type.Int8, ctx: Ctx) = translate(node) { metas -> integer8Type(metas) }
+
+    override fun visitTypeInt(node: Type.Int, ctx: Ctx) = translate(node) { metas -> integerType(metas) }
+
+    override fun visitTypeReal(node: Type.Real, ctx: Ctx) = translate(node) { metas -> realType(metas) }
+
+    override fun visitTypeFloat32(node: Type.Float32, ctx: Ctx) = translate(node) { metas -> floatType(null, metas) }
+
+    override fun visitTypeFloat64(node: Type.Float64, ctx: Ctx) =
+        translate(node) { metas -> doublePrecisionType(metas) }
+
+    override fun visitTypeDecimal(node: Type.Decimal, ctx: Ctx) = translate(node) { metas ->
+        decimalType(
+            precision = node.precision?.toLong(),
+            scale = node.scale?.toLong(),
+            metas = metas,
+        )
+    }
+
+    override fun visitTypeNumeric(node: Type.Numeric, ctx: Ctx) = translate(node) { metas ->
+        numericType(
+            precision = node.precision?.toLong(),
+            scale = node.scale?.toLong(),
+            metas = metas,
+        )
+    }
+
+    override fun visitTypeChar(node: Type.Char, ctx: Ctx) =
+        translate(node) { metas -> characterType(node.length?.toLong(), metas) }
+
+    override fun visitTypeVarchar(node: Type.Varchar, ctx: Ctx) =
+        translate(node) { metas -> characterVaryingType(node.length?.toLong(), metas) }
+
+    override fun visitTypeString(node: Type.String, ctx: Ctx) = translate(node) { metas -> stringType(metas) }
+
+    override fun visitTypeSymbol(node: Type.Symbol, ctx: Ctx) = translate(node) { metas -> symbolType(metas) }
+
+    override fun visitTypeBit(node: Type.Bit, ctx: Ctx) = throw IllegalArgumentException("BIT type not supported")
+
+    override fun visitTypeBitVarying(node: Type.BitVarying, ctx: Ctx) =
+        throw IllegalArgumentException("BIT VARYING type not supported")
+
+    override fun visitTypeByteString(node: Type.ByteString, ctx: Ctx) =
+        throw IllegalArgumentException("BYTESTRING type not supported")
+
+    override fun visitTypeBlob(node: Type.Blob, ctx: Ctx) = translate(node) { metas -> blobType(metas) }
+
+    override fun visitTypeClob(node: Type.Clob, ctx: Ctx) = translate(node) { metas -> clobType(metas) }
+
+    override fun visitTypeDate(node: Type.Date, ctx: Ctx) = translate(node) { metas -> dateType(metas) }
+
+    override fun visitTypeTime(node: Type.Time, ctx: Ctx) =
+        translate(node) { metas -> timeType(node.precision?.toLong(), metas) }
+
+    override fun visitTypeTimeWithTz(node: Type.TimeWithTz, ctx: Ctx) =
+        translate(node) { metas -> timeWithTimeZoneType(node.precision?.toLong(), metas) }
+
+    override fun visitTypeTimestamp(node: Type.Timestamp, ctx: Ctx) =
+        translate(node) { metas -> timestampType(node.precision?.toLong(), metas) }
+
+    override fun visitTypeTimestampWithTz(node: Type.TimestampWithTz, ctx: Ctx) =
+        throw IllegalArgumentException("TIMESTAMP [WITH TIMEZONE] type not supported")
+
+    override fun visitTypeInterval(node: Type.Interval, ctx: Ctx) =
+        throw IllegalArgumentException("INTERVAL type not supported")
+
+    override fun visitTypeBag(node: Type.Bag, ctx: Ctx) = translate(node) { metas -> bagType(metas) }
+
+    override fun visitTypeList(node: Type.List, ctx: Ctx) = translate(node) { metas -> listType(metas) }
+
+    override fun visitTypeSexp(node: Type.Sexp, ctx: Ctx) = translate(node) { metas -> sexpType(metas) }
+
+    override fun visitTypeTuple(node: Type.Tuple, ctx: Ctx) = translate(node) { metas -> tupleType(metas) }
+
+    override fun visitTypeStruct(node: Type.Struct, ctx: Ctx) = translate(node) { metas -> structType(metas) }
+
+    override fun visitTypeAny(node: Type.Any, ctx: Ctx) = translate(node) { metas -> anyType(metas) }
+
+    override fun visitTypeCustom(node: Type.Custom, ctx: Ctx) =
+        translate(node) { metas -> customType(node.name.lowercase(), metas) }
+
+    /**
+     * HELPERS
+     */
+
+    private inline fun <reified S : PartiqlAst.PartiqlAstNode> List<AstNode>.translate(ctx: Ctx): List<S> =
+        this.map { visit(it, ctx) as S }
+
+    private inline fun <reified T : PartiqlAst.PartiqlAstNode> visitOrNull(node: AstNode?, ctx: Ctx): T? =
+        node?.let { visit(it, ctx) as T }
+
+    private fun Identifier.CaseSensitivity.toLegacyCaseSensitivity() = when (this) {
+        Identifier.CaseSensitivity.SENSITIVE -> PartiqlAst.CaseSensitivity.CaseSensitive()
+        Identifier.CaseSensitivity.INSENSITIVE -> PartiqlAst.CaseSensitivity.CaseInsensitive()
+    }
+
+    private fun Expr.Var.Scope.toLegacyScope() = when (this) {
+        Expr.Var.Scope.DEFAULT -> PartiqlAst.ScopeQualifier.Unqualified()
+        Expr.Var.Scope.LOCAL -> PartiqlAst.ScopeQualifier.LocalsFirst()
+    }
+
+    private fun SetQuantifier.toLegacySetQuantifier() = when (this) {
+        SetQuantifier.ALL -> PartiqlAst.SetQuantifier.All()
+        SetQuantifier.DISTINCT -> PartiqlAst.SetQuantifier.Distinct()
+    }
+
+    private fun DatetimeField.toLegacyDatetimePart(): PartiqlAst.Expr.Lit {
+        val symbol = this.toString().lowercase()
+        return pig.lit(ionSymbol(symbol))
+    }
+
+    // Legacy AST models targets as expressions
+    private fun visitPathUnpack(path: Path, ctx: Ctx): PartiqlAst.Expr {
+        val ex = visitPath(path, ctx)
+        return if (ex.steps.isEmpty()) ex.root else ex
+    }
+
+    private fun metaContainerOf(vararg metas: Meta): MetaContainer = metaContainerOf(metas.map { Pair(it.tag, it) })
+
+    // Time Value is not an Expr.Lit in the legacy AST; needs special treatment.
+    private fun TimeValue.toLegacyAst(metas: MetaContainer): PartiqlAst.Expr.LitTime {
+        val d = this.value.decimalSecond
+        val seconds = d.toLong()
+        val nano = d.subtract(BigDecimal(seconds)).scaleByPowerOfTen(9).toLong()
+        val time = pig.timeValue(
+            hour = this.value.hour.toLong(),
+            minute = this.value.minute.toLong(),
+            second = seconds,
+            nano = nano,
+            precision = this.value.decimalSecond.precision().toLong(),
+            withTimeZone = this.value.timeZone != null,
+            tzMinutes = this.value.timeZone?.let {
+                when (it) {
+                    is TimeZone.UtcOffset -> it.totalOffsetMinutes.toLong()
+                    else -> 0
+                }
+            },
+        )
+        return pig.litTime(time, metas)
+    }
+
+    // Timestamp Value is not an Expr.Lit in the legacy AST; needs special treatment.
+    private fun TimestampValue.toLegacyAst(metas: MetaContainer): PartiqlAst.Expr.Timestamp {
+        val timeZone = value.timeZone?.toLegacyAst(metas)
+        val precision = value.decimalSecond.precision().toLong()
+        return pig.timestamp(
+            pig.timestampValue(
+                value.year.toLong(), value.month.toLong(), value.day.toLong(),
+                value.hour.toLong(), value.minute.toLong(), ionDecimal(Decimal.valueOf(value.decimalSecond)),
+                timeZone, precision
+            )
+        )
+    }
+
+    // Date Value is not an Expr.Lit in the legacy AST; needs special treatment.
+    private fun DateValue.toLegacyAst(metas: MetaContainer): PartiqlAst.Expr.Date {
+        return pig.date(
+            year = this.value.year.toLong(),
+            month = this.value.month.toLong(),
+            day = this.value.day.toLong(),
+            metas = metas,
+        )
+    }
+
+    private fun TimeZone.toLegacyAst(metas: MetaContainer): PartiqlAst.Timezone {
+        return when (this) {
+            TimeZone.UnknownTimeZone -> pig.unknownTimezone(metas)
+            is TimeZone.UtcOffset -> pig.utcOffset(totalOffsetMinutes.toLong(), metas)
+        }
+    }
+}
diff --git a/partiql-ast/src/main/kotlin/org/partiql/ast/impl/.gitkeep b/partiql-ast/src/main/kotlin/org/partiql/ast/impl/.gitkeep
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/AggregateCallSiteListMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/AggregateCallSiteListMeta.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/AggregateCallSiteListMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/AggregateCallSiteListMeta.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/InternalMetas.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/InternalMetas.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/InternalMetas.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/InternalMetas.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsCountStarMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsCountStarMeta.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsCountStarMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsCountStarMeta.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsGroupAttributeReferenceMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsGroupAttributeReferenceMeta.kt
similarity index 92%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsGroupAttributeReferenceMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsGroupAttributeReferenceMeta.kt
index 2ee9989c20..7999101530 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsGroupAttributeReferenceMeta.kt
+++ b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsGroupAttributeReferenceMeta.kt
@@ -16,7 +16,7 @@ package org.partiql.lang.ast
 /**
  * Meta attached to an identifier when replacing the identifier with a reference to a group key variable declaration.
  */
-internal class IsGroupAttributeReferenceMeta private constructor() : Meta {
+class IsGroupAttributeReferenceMeta private constructor() : Meta {
     override val tag = TAG
 
     companion object {
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsImplictJoinMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsImplictJoinMeta.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsImplictJoinMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsImplictJoinMeta.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsIonLiteralMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsIonLiteralMeta.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsIonLiteralMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsIonLiteralMeta.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsListParenthesizedMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsListParenthesizedMeta.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsListParenthesizedMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsListParenthesizedMeta.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsOrderedMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsOrderedMeta.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsOrderedMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsOrderedMeta.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsPathIndexMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsPathIndexMeta.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsPathIndexMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsPathIndexMeta.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsTransformedOrderByAliasMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsTransformedOrderByAliasMeta.kt
similarity index 82%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsTransformedOrderByAliasMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsTransformedOrderByAliasMeta.kt
index b1487190e6..092320e570 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsTransformedOrderByAliasMeta.kt
+++ b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsTransformedOrderByAliasMeta.kt
@@ -14,11 +14,9 @@
 
 package org.partiql.lang.ast
 
-import org.partiql.lang.eval.visitors.OrderBySortSpecVisitorTransform
-
 /**
- * A [Meta] to help the [OrderBySortSpecVisitorTransform] to know when the OrderBy SortSpec has already been transformed. It
- * essentially helps to turn
+ * A [Meta] to help the OrderBySortSpecVisitorTransform to know when the OrderBy SortSpec has already been transformed.
+ * It essentially helps to turn
  *
  * ```SELECT a + 1 AS b FROM c ORDER BY b```
  *
@@ -30,6 +28,7 @@ import org.partiql.lang.eval.visitors.OrderBySortSpecVisitorTransform
  */
 class IsTransformedOrderByAliasMeta private constructor() : Meta {
     override val tag = TAG
+
     companion object {
         const val TAG = "\$is_transformed_order_by_alias"
 
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsValuesExprMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsValuesExprMeta.kt
similarity index 100%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/IsValuesExprMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/IsValuesExprMeta.kt
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/LegacyLogicalNotMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/LegacyLogicalNotMeta.kt
similarity index 53%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/LegacyLogicalNotMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/LegacyLogicalNotMeta.kt
index f3177fd39d..842e66a200 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/LegacyLogicalNotMeta.kt
+++ b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/LegacyLogicalNotMeta.kt
@@ -15,23 +15,9 @@
 package org.partiql.lang.ast
 
 /**
- * The old AST has nodes: `not_like`, `not_between` and `is_not` which are respectively paired with its
- * `like`, `between`, and `is` nodes.
- *
- * The new AST lacks the `not` version of these, instead wrapping the non-`not` versions of these notes in a `not`
- * n-ary expression to achieve the same semantics.
- *
- * For example:
- *  - Legacy:  (not_like <expr>)
- *  - New AST (will be something like):
- *              (nary
- *                  (op not)
- *                  (args (nary like <expr>))
- *                  (metas ((name LegacyLogicalNotMeta))))
- *
- * [LegacyLogicalNotMeta] is added to `(nary (op not) ...` node so that the [ToLegacyAstPass] knows to emit the
- * `not_like`, `not_between` or `is_not` s-expression nodes.
+ * A legacy meta that is no longer used.
  */
+@Deprecated("To be removed in the next minor version")
 class LegacyLogicalNotMeta private constructor() : Meta {
     override val tag = TAG
     companion object {
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/SourceLocationMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/SourceLocationMeta.kt
similarity index 88%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/SourceLocationMeta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/SourceLocationMeta.kt
index aa32f718d0..c0105845c9 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/SourceLocationMeta.kt
+++ b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/SourceLocationMeta.kt
@@ -16,8 +16,9 @@ package org.partiql.lang.ast
 
 import com.amazon.ion.IonWriter
 import com.amazon.ionelement.api.MetaContainer
+import com.amazon.ionelement.api.ionInt
+import com.amazon.ionelement.api.ionStructOf
 import com.amazon.ionelement.api.metaOrNull
-import org.partiql.lang.util.IonWriterContext
 
 /**
  * Represents a specific location within a source file.
@@ -28,13 +29,11 @@ data class SourceLocationMeta(val lineNum: Long, val charOffset: Long, val lengt
     override val tag = TAG
 
     override fun serialize(writer: IonWriter) {
-        IonWriterContext(writer).apply {
-            struct {
-                int("line_num", lineNum)
-                int("char_offset", charOffset)
-                int("length", length)
-            }
-        }
+        ionStructOf(
+            "line_num" to ionInt(lineNum),
+            "char_offset" to ionInt(charOffset),
+            "length" to ionInt(length),
+        ).writeTo(writer)
     }
 
     override fun equals(other: Any?): Boolean {
diff --git a/partiql-ast/src/main/kotlin/org/partiql/lang/ast/StaticTypeMeta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/StaticTypeMeta.kt
new file mode 100644
index 0000000000..f32f0dbfa3
--- /dev/null
+++ b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/StaticTypeMeta.kt
@@ -0,0 +1,17 @@
+package org.partiql.lang.ast
+
+import org.partiql.types.StaticType
+
+/**
+ * Represents a static type for an AST element.
+ */
+data class StaticTypeMeta(val type: StaticType) : Meta {
+
+    override fun toString() = type.toString()
+
+    override val tag = TAG
+
+    companion object {
+        const val TAG = "\$static_type"
+    }
+}
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/meta.kt b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/meta.kt
similarity index 96%
rename from partiql-lang/src/main/kotlin/org/partiql/lang/ast/meta.kt
rename to partiql-ast/src/main/kotlin/org/partiql/lang/ast/meta.kt
index d1bb88cbb4..0925b5afb3 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/ast/meta.kt
+++ b/partiql-ast/src/main/kotlin/org/partiql/lang/ast/meta.kt
@@ -16,8 +16,8 @@ package org.partiql.lang.ast
 
 import com.amazon.ion.IonWriter
 import com.amazon.ionelement.api.MetaContainer
+import com.amazon.ionelement.api.metaContainerOf
 import com.amazon.ionelement.api.plus
-import org.partiql.lang.domains.metaContainerOf
 
 /**
  * The [Meta] interface is implemented by classes that provide an object mapping view to AST meta nodes.
@@ -66,4 +66,4 @@ fun MetaContainer.find(tagName: String): Meta? = this[tagName] as Meta?
 
 fun MetaContainer.hasMeta(tagName: String) = this.containsKey(tagName)
 
-fun MetaContainer.add(meta: Meta): MetaContainer = this.plus(metaContainerOf(meta))
+fun MetaContainer.add(meta: Meta): MetaContainer = this.plus(metaContainerOf(meta.tag to meta))
diff --git a/partiql-ast/src/main/pig/partiql.ion b/partiql-ast/src/main/pig/partiql.ion
index 10a3803a61..86268df3c0 100644
--- a/partiql-ast/src/main/pig/partiql.ion
+++ b/partiql-ast/src/main/pig/partiql.ion
@@ -140,6 +140,7 @@ may then be further optimized by selecting better implementations of each operat
             // Constructors for DateTime types
             (date year::int month::int day::int)
             (lit_time value::time_value)
+            (timestamp value::timestamp_value)
 
             // Bag operators
             (bag_op op::bag_op_type quantifier::set_quantifier operands::(* expr 2))
@@ -178,6 +179,19 @@ may then be further optimized by selecting better implementations of each operat
         // Time
         (product time_value hour::int minute::int second::int nano::int precision::int with_time_zone::bool tz_minutes::(? int))
 
+        // Timestamp
+        (product timestamp_value year::int month::int day::int hour::int minute::int second::ion timezone::(? timezone) precision::(? int) )
+
+        (sum timezone
+             // Unknown time zone -00:00
+             (unknown_timezone)
+             // UTC offset ex: -01:30 -> tz_hour = -1, tz_minutes = -30, total offset minutes = -90
+             // tz_hour is in [-23, 23], timezone minutes is in [-59,59]
+             // we only need total offset minutes to model this property
+             (utc_offset offset_minutes::int)
+             // TODO: Timezone ID not support yet. Ex: US/Pacific
+        )
+
         // A "step" within a path expression; that is the components of the expression following the root.
         (sum path_step
             // `someRoot[<expr>]`, or `someRoot.someField` which is equivalent to `someRoot['someField']`.
@@ -257,13 +271,22 @@ may then be further optimized by selecting better implementations of each operat
              (edge_left_or_right)
              (edge_left_or_undirected_or_right))
 
+        // A label spec in a node pattern like `MATCH (x : <lab>)` or in an edge pattern like `MATCH −[t : <lab>]−>`
+        (sum graph_label_spec
+            (graph_label_name name::symbol)                   // as in `MATCH (x:Account)` or `MATCH -[x:Transfer]->`
+            (graph_label_wildcard)                            // as in `MATCH (x: %)`
+            (graph_label_negation arg::graph_label_spec)      // as in `MATCH (x: !Account)`
+            (graph_label_conj lhs::graph_label_spec rhs::graph_label_spec)   // as in `MATCH (x: City&Country)` - Monaco can do
+            (graph_label_disj lhs::graph_label_spec rhs::graph_label_spec)   // as in `MATCH (x: City|Country)` - either Paris or Germany will do
+        )
+
         // A part of a graph pattern
         (sum graph_match_pattern_part
              // A single node in a graph pattern.
              (node
                  prefilter::(? expr)   // an optional node pre-filter, e.g.: `WHERE c.name='Alarm'` in `MATCH (c WHERE c.name='Alarm')`
                  variable::(? symbol)  // the optional element variable of the node match, e.g.: `x` in `MATCH (x)`
-                 label::(* symbol 0))  // the optional label(s) to match for the node, e.g.: `Entity` in `MATCH (x:Entity)`
+                 label::(? graph_label_spec))  // the optional label spec to match for the node, e.g.: `Entity` in `MATCH (x:Entity)`
 
              // A single edge in a graph pattern.
              (edge
@@ -271,7 +294,8 @@ may then be further optimized by selecting better implementations of each operat
                  quantifier::(? graph_match_quantifier) // an optional quantifier for the entire pattern match, e.g. `{2,5}` in `MATCH (a:Account)−[:Transfer]−>{2,5}(b:Account)`
                  prefilter::(? expr)   // an optional edge pre-filter, e.g.: `WHERE t.capacity>100` in `MATCH −[t:hasSupply WHERE t.capacity>100]−>`
                  variable::(? symbol)  // the optional element variable of the edge match, e.g.: `t` in `MATCH −[t]−>`
-                 label::(* symbol 0))  // the optional label(s) to match for the edge. e.g.: `Target` in `MATCH −[t:Target]−>`
+                 label::(? graph_label_spec))  // the optional label spec to match for the edge. e.g.: `Target` in `MATCH −[t:Target]−>`
+
              // A sub-pattern.
              (pattern pattern::graph_match_pattern))
 
@@ -535,9 +559,6 @@ may then be further optimized by selecting better implementations of each operat
             // `NUMERIC[(<int> [, int])]`.  Elements are precision then scale.
             (numeric_type precision::(? int) scale::(? int))
 
-            // `TIMESTAMP`
-            (timestamp_type)
-
             // `CHAR(<int>)`
             (character_type length::(? int))
 
@@ -557,6 +578,8 @@ may then be further optimized by selecting better implementations of each operat
             // Note: This logic is implemented in SqlParser.
             (time_type precision::(? int))
             (time_with_time_zone_type precision::(? int))
+            (timestamp_type precision::(? int))
+            (timestamp_with_time_zone_type precision::(? int))
 
             (struct_type)
             (tuple_type)
diff --git a/partiql-ast/src/main/resources/partiql_ast.ion b/partiql-ast/src/main/resources/partiql_ast.ion
new file mode 100644
index 0000000000..e4cf854f28
--- /dev/null
+++ b/partiql-ast/src/main/resources/partiql_ast.ion
@@ -0,0 +1,801 @@
+imports::{ kotlin: [
+    ion::'com.amazon.ionelement.api.IonElement',
+    value::'org.partiql.value.PartiQLValue',
+  ],
+}
+
+statement::[
+
+  // PartiQL Expressions
+  query::{
+    expr: expr,
+  },
+
+  // Data Manipulation Language
+  d_m_l::[
+
+    // INSERT INTO <target> [AS <alias>] <values> [<on conflict>]
+    insert::{
+      target:       identifier,
+      values:       expr,
+      as_alias:     optional::'.identifier.symbol',
+      on_conflict:  optional::on_conflict,
+    },
+
+    // INSERT INTO <path> VALUE <expr> [AT <expr>] [<on conflict legacy>]
+    insert_legacy::{
+      target:             path,
+      value:              expr,
+      index:              optional::expr,
+      conflict_condition: optional::expr,
+    },
+
+    // UPSERT INTO <target> [<alias>] <values>
+    upsert::{
+      target:   identifier,
+      values:   expr,
+      as_alias: optional::'.identifier.symbol',
+    },
+
+    // REPLACE INTO <target> [AS <alias>] <values>
+    replace::{
+      target:   identifier,
+      values:   expr,
+      as_alias: optional::'.identifier.symbol',
+    },
+
+    // UPDATE <target> SET <set clause list> WHERE <expr>
+    update::{
+      target:      path,
+      assignments: list::[assignment],
+      _: [
+        assignment::{
+          target: path,
+          value:  expr,
+        },
+      ],
+    },
+
+    // REMOVE <path>
+    remove::{
+      target: path,
+    },
+
+    // DELETE [FROM [AS <symbol>] [AT <symbol>] [BY <symbol>]] <path> [ WHERE <expr> ] RETURNING ...
+    delete::{
+      target: {
+        path:     path,
+        as_alias: optional::'.identifier.symbol',
+        at_alias: optional::'.identifier.symbol',
+        by_alias: optional::'.identifier.symbol',
+      },
+      where:      optional::expr,
+      returning:  optional::returning,
+    },
+
+    // [UPDATE|FROM] <target> <dml base op>+ WHERE <expr> RETURNING <returning>
+    batch_legacy::{
+      ops:        list::[op],
+      target:     optional::from,
+      where:      optional::expr,
+      returning:  optional::returning,
+      _: [
+        op::[
+          insert::{
+            target:       identifier,
+            values:       expr,
+            as_alias:     optional::'.identifier.symbol',
+            on_conflict:  optional::on_conflict,
+          },
+          insert_legacy::{
+            target:             path,
+            value:              expr,
+            index:              optional::expr,
+            conflict_condition: optional::expr,
+          },
+          set::{
+            assignments: list::[assignment],
+          },
+          remove::{
+            target: path,
+          },
+          delete::{},
+        ],
+      ],
+    },
+  ],
+
+  // Data Definition Language
+  d_d_l::[
+
+    // CREATE TABLE <identifier> [<table_def>]
+    create_table::{
+      name:       identifier,
+      definition: optional::table_definition,
+    },
+
+    // CREATE INDEX [<identifier>] ON <identifier> (<path> [, <path>]...)
+    create_index::{
+      index:  optional::identifier,
+      table:  identifier,
+      fields: list::[path],
+    },
+
+    // DROP TABLE <identifier>
+    drop_table::{
+      table: identifier,
+    },
+
+    // DROP INDEX <identifier> ON <identifier>
+    drop_index::{
+      index:  identifier, // <identifier>[0]
+      table:  identifier, // <identifier>[1]
+    },
+  ],
+
+  // EXEC <symbol> [<expr>.*]
+  exec::{
+    procedure: string,
+    args: list::[expr],
+  },
+
+  // EXPLAIN
+  explain::{
+    target: [
+      domain::{
+        statement:  statement,
+        type:       optional::string,
+        format:     optional::string,
+      },
+    ],
+  },
+]
+
+// PartiQL Type AST nodes
+//
+// Several of these are the same "type", but have various syntax rules we wish to capture.
+//
+type::[
+  null_type::{},                                               // NULL
+  missing::{},                                                 // MISSING
+  bool::{},                                                    // BOOL
+  tinyint::{},                                                 // TINYINT
+  smallint::{},                                                // SMALLINT
+  int2::{},                                                    // INT2 | INTEGER2
+  int4::{},                                                    // INT4 | INTEGER4
+  bigint::{},                                                  // BIGINT
+  int8::{},                                                    // INT8
+  int::{},                                                     // INTEGER
+  real::{},                                                    // REAL
+  float32::{},                                                 // FLOAT
+  float64::{},                                                 // DOUBLE PRECISION
+  decimal::{                                                   // DECIMAL [([<int> [,<int>])]
+    precision:  optional::int,
+    scale:      optional::int,
+  },
+  numeric::{                                                   // NUMERIC [([<int> [,<int>])]
+    precision:  optional::int,
+    scale:      optional::int,
+  },
+  char::{ length: optional::int },                             // CHARACTER [(<int>)] | CHAR [(<int>)]
+  varchar::{ length: optional::int },                          // CHARACTER VARYING [(<int>)] | VARCHAR [(<int>)]
+  string::{ length: optional::int },                           // STRING
+  symbol::{},                                                  // SYMBOL
+  bit::{ length: optional::int },                              // BIT [(<int>)]
+  bit_varying::{ length: optional::int },                      // BIT_VARYING [(<int>)]
+  byte_string::{ length: optional::int },                      // BYTE [(<int>)]
+  blob::{ length: optional::int },                             // BLOB [(<int>)]
+  clob::{ length: optional::int },                             // CLOB [(<int>)]
+  date::{},                                                    // DATE
+  time::{ precision: optional::int },                          // TIME [(<int>)] [WITHOUT TIMEZONE]
+  time_with_tz::{ precision: optional::int },                  // TIME [(<int>)] WITH TIMEZONE
+  timestamp::{ precision: optional::int },                     // TIMESTAMP [(<int>)] [WITHOUT TIMEZONE]
+  timestamp_with_tz::{ precision: optional::int },             // TIMESTAMP [(<int>)] WITH TIMEZONE
+  interval::{ precision: optional::int },                      // INTERVAL
+  bag::{},                                                     // BAG
+  list::{},                                                    // LIST
+  sexp::{},                                                    // SEXP
+  tuple::{},                                                   // TUPLE
+  struct::{},                                                  // STRUCT
+  any::{},                                                     // ANY
+  custom::{ name: string },                                    // <symbol>
+]
+
+// Identifiers and Qualified Identifiers
+//----------------------------------------------
+// <identifier > ::= <id symbol> | <id path>
+//
+// <id symbol> ::=  <symbol>    // case-insensitive
+//               | "<symbol>"   // case-sensitive
+//
+// <id qualified> ::= <id symbol> ('.' <id symbol>)+;
+//
+identifier::[
+  symbol::{
+    symbol:           string,
+    case_sensitivity: case_sensitivity,
+  },
+  qualified::{
+    root:   symbol,
+    steps:  list::[symbol],
+  },
+  _::[
+    case_sensitivity::[
+      SENSITIVE,
+      INSENSITIVE,
+    ],
+  ],
+]
+
+// Path Literals
+//  - Much like qualified identifier but allowing bracket notation '[' <int> | <string> ']'
+//  - Not a variant of `identifier`, as path literals are not explicit in the specification.
+path::{
+  root:   '.identifier.symbol',
+  steps:  list::[step],
+  _: [
+    step::[
+      symbol::{
+        symbol: '.identifier.symbol',
+      },
+      index::{
+        index: int,
+      },
+    ],
+  ],
+}
+
+// [ ALL | DISTINCT ]
+set_quantifier::[
+  ALL,
+  DISTINCT,
+]
+
+// PartiQL Expression
+expr::[
+
+  // PartiQL Literal Value
+  lit::{
+    value: '.value',
+  },
+
+  // Ion Literal Value, ie `<ion>`
+  ion::{
+    value: '.ion',
+  },
+
+  // Variable Reference
+  var::{
+    identifier: identifier,
+    scope: [
+      DEFAULT,  //  x.y.z
+      LOCAL,    // @x.y.z
+    ],
+  },
+
+  // SQL Session Keywords (CURRENT_USER, CURRENT_ROLE, etc.)
+  session_attribute::{
+    attribute: [
+      CURRENT_USER,
+    ],
+  },
+
+  // Expression Paths
+  path::{
+    root:   expr,
+    steps:  list::[step],
+    _: [
+      step::[
+        symbol::{ symbol: '.identifier.symbol' },
+        index::{ key: expr },
+        wildcard::{},
+        unpivot::{},
+      ],
+    ],
+  },
+
+  // Scalar Function Call
+  call::{
+    function: identifier,
+    args:     list::[expr],
+  },
+
+  // Aggregate Function Call
+  agg::{
+    function: identifier,
+    args:     list::[expr],
+    setq:     optional::set_quantifier,
+  },
+
+  // Parameter `?`
+  parameter::{
+    index: int,
+  },
+
+  // Unary Operators
+  unary::{
+    op:   [ NOT, POS, NEG ],
+    expr: expr,
+  },
+
+  // Binary Operators
+  binary::{
+    op: [
+      PLUS, MINUS, TIMES, DIVIDE, MODULO, CONCAT,
+      AND, OR,
+      EQ, NE, GT, GTE, LT, LTE,
+    ],
+    lhs: expr,
+    rhs: expr,
+  },
+
+  // VALUES <row> (',' <row>)*
+  values::{
+    rows: list::[row],
+    _:[
+      row::{
+        items: list::[expr],
+      },
+    ],
+  },
+
+  // Collection Constructors
+  collection::{
+    type: [
+      BAG,    // << ... >>
+      ARRAY,  // [  ...  ]
+      VALUES, // (  ...  )
+      LIST,   // LIST ( ... )
+      SEXP,   // SEXP ( ... )
+     ],
+    values: list::[expr],
+  },
+
+  // Struct Constructor
+  struct::{
+    fields: list::[field],
+    _: [
+      field::{
+        name:   expr,
+        value:  expr,
+      },
+    ],
+  },
+
+  // SQL special form `[NOT] LIKE`
+  like::{
+    value:    expr,
+    pattern:  expr,
+    escape:   optional::expr,
+    not:      optional::bool,
+  },
+
+  // SQL special form `[NOT] BETWEEN`
+  between::{
+    value:  expr,
+    from:   expr,
+    to:     expr,
+    not:    optional::bool,
+  },
+
+  // SQL special form `[NOT] IN`
+  in_collection::{
+    lhs: expr,
+    rhs: expr,
+    not: optional::bool,
+  },
+
+  // PartiQL special form `IS [NOT]`
+  is_type::{
+    value:  expr,
+    type:   '.type',
+    not:    optional::bool,
+  },
+
+  // The simple and searched `case` switch SQL special form F261-01, F261-02
+  case::{
+    expr:     optional::expr,
+    branches: list::[branch],
+    default:  optional::expr,
+    _: [
+      branch::{
+        condition:  expr,
+        expr:       expr,
+      },
+    ],
+  },
+
+  // SQL special form F261-04 `COALESCE`
+  coalesce::{
+    args: list::[expr],
+  },
+
+  // SQL special form F261-03 `NULLIF`
+  null_if::{
+    value:      expr,
+    nullifier:  expr,
+  },
+
+  // SQL special form E021-06 `SUBSTRING ( <expr> [FROM <expr>] [FOR <expr>] )`
+  substring::{
+    value:  expr,           // <expr>[0]
+    start:  optional::expr, // <expr>[1]
+    length: optional::expr, // <expr>[2]
+  },
+
+  // SQL special form E021-11 `POSITION ( <expr> IN <expr> )`
+  position::{
+    lhs: expr,
+    rhs: expr,
+  },
+
+  // SQL special form E021-09 `TRIM ( [LEADING|TRAILING|BOTH] [<expr> FROM] <expr> )`
+  trim::{
+    value:  expr,                                  // <expr>[0]
+    chars:  optional::expr,                        // <expr>[1]
+    spec:   optional::[ LEADING, TRAILING, BOTH ], // <trim specification>
+  },
+
+  // SQL special form `OVERLAY ( <expr> PLACING <expr> FROM <expr> [FOR <expr>] )`
+  overlay::{
+    value:    expr,             // <expr>[0]
+    overlay:  expr,             // <expr>[1]
+    start:    expr,             // <expr>[2]
+    length:   optional::expr,   // <expr>[3]
+  },
+
+  // SQL special form `EXTRACT ( <extract field> FROM <extract source> )`
+  extract::{
+    field:  datetime_field,
+    source: expr,
+  },
+
+  // SQL special form F201 `CAST`
+  cast::{
+    value:    expr,
+    as_type:  '.type',
+  },
+
+  // PartiQL special form `CAN_CAST`
+  can_cast::{
+    value:    expr,
+    as_type:  '.type',
+  },
+
+  // PartiQL special form `CAN_LOSSLESS_CAST`
+  can_lossless_cast::{
+    value:    expr,
+    as_type:  '.type',
+  },
+
+  // PartiQL special form `DATE_ADD ( <datetime field> , <expr> , <expr>)`
+  date_add::{
+    field:  datetime_field,
+    lhs:    expr,
+    rhs:    expr,
+  },
+
+  // PartiQL special form `DATE_DIFF ( <datetime field> , <expr> , <expr>)`
+  date_diff::{
+    field:  datetime_field,
+    lhs:    expr,
+    rhs:    expr,
+  },
+
+  // PartiQL special form `[OUTER] (UNION|INTERSECT|EXCEPT) [ALL|DISTINCT]`
+  bag_op::{
+    type:   '.set_op',
+    lhs:    expr,
+    rhs:    expr,
+    outer:  optional::bool,
+  },
+
+  // The PartiQL `<sfw>` query expression, think SQL `<query specification>`
+  s_f_w::{
+    select:   select,              // oneof SELECT / SELECT VALUE / PIVOT
+    from:     from,
+    let:      optional::let,
+    where:    optional::expr,
+    group_by: optional::group_by,
+    having:   optional::expr,
+    set_op:   optional::{
+      type:    '.set_op',
+      operand: '.expr.s_f_w',
+    },
+    order_by: optional::order_by,
+    limit:    optional::expr,
+    offset:   optional::expr,
+  },
+
+  // GPML ( <expr> MATCH <pattern> )
+  match::{
+    expr:     expr,
+    pattern:  graph_match,
+  },
+
+  // [LAG|LEAD] ( <expr> [ <expr> [ <expr> ] ] )
+  //    OVER ([PARTITION BY <expr> [, <expr>]... ] [ORDER BY <sort_spec> [, <sort_spec>]... ])
+  window::{
+    function:   [ LAG, LEAD ],
+    expression: expr,           // <expr>[0]
+    offset:     optional::expr, // <expr>[1]
+    default:    optional::expr, // <expr>[2]
+    over: {
+      partitions: optional::list::[expr],
+      sorts:      optional::list::[sort],
+    },
+  },
+]
+
+// PartiQL SELECT Clause Variants — https://partiql.org/dql/select.html
+select::[
+
+  // SELECT [ALL|DISTINCT] *
+  star::{
+    setq: optional::set_quantifier,
+  },
+
+  // SELECT [ALL|DISTINCT] <select-list>
+  project::{
+    items:  list::[item],
+    setq:   optional::set_quantifier,
+    _: [
+      item::[
+        all::{ expr: expr },                                                  // <expr>.*
+        expression::{ expr: expr, as_alias: optional::'.identifier.symbol' }  // <expr> [as <identifier>]
+      ],
+    ],
+  },
+
+  // PIVOT <expr> AT <expr>
+  pivot::{
+    key:    expr, // <expr>[0]
+    value:  expr, // <expr>[1]
+  },
+
+  // SELECT [ALL|DISTINCT] VALUE <expr>
+  value::{
+    constructor:  expr,
+    setq:         optional::set_quantifier,
+  },
+]
+
+// PartiQL FROM Clause Variants — https://partiql.org/dql/from.html
+from::[
+
+  // FROM [UNPIVOT] <expr> [AS <identifier>] [AT <identifier>] [BY <identifier>]
+  value::{
+    expr:     expr,
+    type:     [ SCAN, UNPIVOT ],
+    as_alias: optional::'.identifier.symbol',
+    at_alias: optional::'.identifier.symbol',
+    by_alias: optional::'.identifier.symbol',
+  },
+
+  // TODO https://github.com/partiql/partiql-spec/issues/41
+  // TODO https://github.com/partiql/partiql-lang-kotlin/issues/1013
+  join::{
+    lhs:        from,
+    rhs:        from,
+    type:       optional::[
+                  INNER,
+                  LEFT,
+                  LEFT_OUTER,
+                  RIGHT,
+                  RIGHT_OUTER,
+                  FULL,
+                  FULL_OUTER,
+                  CROSS,
+                  COMMA,
+                ],
+    condition:  optional::expr,
+  },
+]
+
+let::{
+  bindings: list::[binding],
+  _: [
+    binding::{
+      expr:     expr,
+      as_alias: '.identifier.symbol',
+    },
+  ],
+}
+
+// GROUP BY Clause — https://partiql.org/dql/group_by.html
+group_by::{
+  strategy: [ FULL, PARTIAL ],
+  keys:     list::[key],
+  as_alias: optional::'.identifier.symbol',
+  _: [
+    key::{
+      expr:     expr,
+      as_alias: optional::'.identifier.symbol',
+    },
+  ],
+}
+
+// ORDER BY Clause — https://partiql.org/dql/order_by.html
+order_by::{
+  sorts: list::[sort],
+}
+
+// <expr> [ASC|DESC] [NULLS FIRST | NULLS LAST]
+sort::{
+  expr:   expr,
+  dir:    optional::[ ASC, DESC ],
+  nulls:  optional::[ FIRST, LAST ],
+}
+
+// (UNION|INTERSECT|EXCEPT) [ALL|DISTINCT]
+set_op::{
+  type: [ UNION, INTERSECT, EXCEPT ],
+  setq: optional::set_quantifier,
+}
+
+// Graph Match Nodes — https://partiql.org/gpml/graph_query.html
+graph_match::{
+  patterns: list::[pattern],
+  selector: optional::selector,
+
+  _: [
+    pattern::{
+      restrictor: optional::restrictor,
+      prefilter:  optional::expr,       // An optional pattern pre-filter, e.g.: `WHERE a.name=b.name` in `MATCH [(a)->(b) WHERE a.name=b.name]`
+      variable:   optional::string,     // The optional element variable of the pattern, e.g.: `p` in `MATCH p = (a) −[t]−> (b)`
+      quantifier: optional::quantifier, // An optional quantifier for the entire pattern match, e.g. `{2,5}` in `MATCH (a:Account)−[:Transfer]−>{2,5}(b:Account)`
+      parts:      list::[part],         // The ordered pattern parts
+      _: [
+        part::[
+          // A single node in a graph pattern
+          node::{
+            prefilter:  optional::expr,    // An optional node pre-filter, e.g.: `WHERE c.name='Alarm'` in `MATCH (c WHERE c.name='Alarm')`
+            variable:   optional::string,  // The optional element variable of the node match, e.g.: `x` in `MATCH (x)`
+            label:      optional::label,    // The optional label(s) to match for the node, e.g.: `Entity` in `MATCH (x:Entity)`
+          },
+          // A single edge in a graph pattern
+          edge::{
+            direction:  direction,            // Edge Direction
+            quantifier: optional::quantifier, // An optional quantifier for the entire pattern match, e.g. `{2,5}` in `MATCH (a:Account)−[:Transfer]−>{2,5}(b:Account)`
+            prefilter:  optional::expr,       // An optional edge pre-filter, e.g.: `WHERE t.capacity>100` in `MATCH −[t:hasSupply WHERE t.capacity>100]−>`
+            variable:   optional::string,     // The optional element variable of the edge match, e.g.: `t` in `MATCH −[t]−>`
+            label:      optional::label,      // The optional label spec to match for the edge. e.g.: `Target` in `MATCH −[t:Target]−>`
+          },
+          // A sub-pattern
+          pattern::{
+            pattern: '.graph_match.pattern'
+          },
+        ],
+      ],
+    },
+
+    // Edge Direction           // | Orientation               | Edge pattern | Abbreviation |
+    direction::[                // |---------------------------+--------------+--------------|
+      LEFT,                     // | Pointing left             | <−[ spec ]−  | <−           |
+      UNDIRECTED,               // | Undirected                | ~[ spec ]~   | ~            |
+      RIGHT,                    // | Pointing right            | −[ spec ]−>  | −>           |
+      LEFT_OR_UNDIRECTED,       // | Left or undirected        | <~[ spec ]~  | <~           |
+      UNDIRECTED_OR_RIGHT,      // | Undirected or right       | ~[ spec ]~>  | ~>           |
+      LEFT_OR_RIGHT,            // | Left or right             | <−[ spec ]−> | <−>          |
+      LEFT_UNDIRECTED_OR_RIGHT, // | Left, undirected or right | −[ spec ]−   | −            |
+    ],                          // Fig. 5 — https://arxiv.org/abs/2112.06217
+
+    // Path Restrictor        // | Keyword        | Description
+    restrictor::[             // |----------------+--------------
+      TRAIL,                  // | TRAIL          | No repeated edges.
+      ACYCLIC,                // | ACYCLIC        | No repeated nodes.
+      SIMPLE,                 // | SIMPLE         | No repeated nodes, except that the first and last nodes may be the same.
+    ],                        // Fig. 7 — https://arxiv.org/abs/2112.06217
+
+    // Graph Edge Quantifier (e.g., the `{2,5}` in `MATCH (x)->{2,5}(y)`)
+    quantifier::{
+      lower: long,
+      upper: optional::long,
+    },
+
+    // Path Selector
+    selector::[
+      any_shortest::{},               // ANY SHORTEST
+      all_shortest::{},               // ALL SHORTEST
+      any::{},                        // ANY
+      any_k::{ k: long },             // ANY k
+      shortest_k::{ k: long },        // SHORTEST k
+      shortest_k_group::{ k: long },  // SHORTEST k GROUP
+    ],                                // Fig. 8 — https://arxiv.org/abs/2112.06217
+
+    // A label spec in a node pattern like `MATCH (x : <lab>)` or in an edge pattern like `MATCH −[t : <lab>]−>`
+    label::[
+      name::{ name: string },          // as in `MATCH (x:Account)` or `MATCH -[x:Transfer]->`
+      wildcard::{},                    // as in `MATCH (x: %)`
+      negation::{arg: label},          // as in `MATCH (x: !Account)`
+      conj::{lhs: label, rhs: label},  // as in `MATCH (x: City&Country)` - Monaco can do
+      disj::{lhs: label, rhs: label},  // as in `MATCH (x: City|Country)` - either Paris or Germany will do
+    ],
+  ],
+}
+
+// LEGACY `ON CONFLICT WHERE <expr> <conflict_action>`
+//        `ON CONFLICT [<target>] <conflict_action>`
+on_conflict::{
+  target: optional::target,
+  action: action,
+
+  _: [
+    // <conflict target> ::= ( <index target> [, <index target>]... )
+    //                     | ( { <primary key> | <composite primary key> } )
+    //                     | ON CONSTRAINT <constraint name>
+    target::[
+      symbols::{
+        symbols: list::[identifier],
+      },
+      constraint::{
+        constraint: identifier,
+      },
+    ],
+
+    // <conflict action> ::= DO NOTHING
+    //                     | DO UPDATE <do update>
+    //                     | DO REPLACE <do replace>
+    action::[
+      do_nothing::{},
+      do_replace::{
+        condition: optional::expr,
+      },
+      do_update::{
+        condition: optional::expr,
+      },
+    ],
+  ]
+}
+
+// RETURNING returningColumn ( COMMA returningColumn )*
+returning::{
+  columns: list::[column],
+  _: [
+    column::{
+      status: [ MODIFIED, ALL ],
+      age:    [ OLD, NEW ],
+      value:  [
+        wildcard::{},
+        expression::{ expr: expr }
+      ],
+    },
+  ],
+}
+
+// `<column_name> <type> <column_constraint>*`
+// `( CONSTRAINT <column_constraint_name> )?  <column_constraint_def>`
+table_definition::{
+  columns: list::[column],
+  _: [
+    column::{
+      name:        string,
+      type:        '.type',
+      constraints: list::[constraint],
+      _: [
+        // TODO improve modeling language to avoid these wrapped unions
+        // Also, prefer not to nest more than twice
+        constraint::{
+          name: optional::string,
+          body: [
+            nullable::{},
+            not_null::{},
+            check::{ expr: expr },
+          ],
+        },
+      ],
+    },
+  ],
+}
+
+// SQL-99 Table 11
+datetime_field::[
+  YEAR,             // 0001-9999
+  MONTH,            // 01-12
+  DAY,              // 01-31
+  HOUR,             // 00-23
+  MINUTE,           // 00-59
+  SECOND,           // 00-61.9(N)
+  TIMEZONE_HOUR,    // -12-13
+  TIMEZONE_MINUTE,  // -59-59
+]
diff --git a/partiql-ast/src/test/kotlin/org/partiql/ast/helpers/ToLegacyAstTest.kt b/partiql-ast/src/test/kotlin/org/partiql/ast/helpers/ToLegacyAstTest.kt
new file mode 100644
index 0000000000..f6171b32fc
--- /dev/null
+++ b/partiql-ast/src/test/kotlin/org/partiql/ast/helpers/ToLegacyAstTest.kt
@@ -0,0 +1,721 @@
+@file:OptIn(PartiQLValueExperimental::class)
+
+package org.partiql.ast.helpers
+
+import com.amazon.ion.Decimal
+import com.amazon.ionelement.api.MetaContainer
+import com.amazon.ionelement.api.ionBool
+import com.amazon.ionelement.api.ionDecimal
+import com.amazon.ionelement.api.ionFloat
+import com.amazon.ionelement.api.ionInt
+import com.amazon.ionelement.api.ionNull
+import com.amazon.ionelement.api.ionString
+import com.amazon.ionelement.api.ionSymbol
+import com.amazon.ionelement.api.loadSingleElement
+import org.junit.jupiter.api.Assertions.assertEquals
+import org.junit.jupiter.api.parallel.Execution
+import org.junit.jupiter.api.parallel.ExecutionMode
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
+import org.partiql.ast.Ast
+import org.partiql.ast.AstNode
+import org.partiql.ast.Expr
+import org.partiql.ast.From
+import org.partiql.ast.GroupBy
+import org.partiql.ast.Identifier
+import org.partiql.ast.SetQuantifier
+import org.partiql.ast.Sort
+import org.partiql.ast.builder.AstBuilder
+import org.partiql.ast.builder.AstFactory
+import org.partiql.ast.builder.ast
+import org.partiql.lang.domains.PartiqlAst
+import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.blobValue
+import org.partiql.value.boolValue
+import org.partiql.value.clobValue
+import org.partiql.value.decimalValue
+import org.partiql.value.float32Value
+import org.partiql.value.float64Value
+import org.partiql.value.int16Value
+import org.partiql.value.int32Value
+import org.partiql.value.int64Value
+import org.partiql.value.int8Value
+import org.partiql.value.intValue
+import org.partiql.value.missingValue
+import org.partiql.value.nullValue
+import org.partiql.value.stringValue
+import org.partiql.value.symbolValue
+import java.math.BigDecimal
+import java.math.BigInteger
+import kotlin.test.assertFails
+
+/**
+ * Tests for translation of the org.partiql.ast.AstNode trees to org.partiql.lang.domains.PartiqlAst.AstNode trees.
+ *
+ * The `null` expression value is used extensively because we are testing single node structural translations.
+ * We don't want convoluted tests with deep trees. More complex tests are covered in end-to-end translation.
+ *
+ * Similarly, PartiqlAst.Identifier and Identifier nodes are avoided when their meaning doesn't matter.
+ * Scan of a string "table" is semantically different than the identifier with name 'table', but structurally
+ * it doesn't matter for testing where an arbitrary expression is used. Keep the tree shallow.
+ */
+class ToLegacyAstTest {
+
+    @ParameterizedTest
+    @MethodSource("literals")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testLiterals(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("ion")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testIon(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("identifiers")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testVars(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("calls")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testCalls(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("operators")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testOperators(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("paths")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testPaths(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("collections")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testCollections(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("types")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testTypes(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("specialForms")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testSpecialForms(case: Case) = case.assert()
+
+    @ParameterizedTest
+    @MethodSource("sfw")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testSfw(case: Case) = case.assert()
+
+    companion object {
+
+        private fun expect(expected: String, block: AstBuilder.() -> AstNode): Case {
+            val i = ast(AstFactory.DEFAULT, block)
+            val e = PartiqlAst.transform(loadSingleElement(expected))
+            return Case.Translate(i, e)
+        }
+
+        private fun fail(message: String, block: AstBuilder.() -> AstNode): Case {
+            val i = ast(AstFactory.DEFAULT, block)
+            return Case.Fail(i, message)
+        }
+
+        private val NULL = Ast.exprLit(nullValue())
+
+        // Shortcut to construct a "legacy-compatible" simple identifier
+        private fun id(name: String) = Ast.identifierSymbol(name, Identifier.CaseSensitivity.INSENSITIVE)
+
+        @JvmStatic
+        fun literals() = listOf(
+            expect("(lit null)") {
+                exprLit(nullValue())
+            },
+            expect("(missing)") {
+                exprLit(missingValue())
+            },
+            expect("(lit true)") {
+                exprLit(boolValue(true))
+            },
+            expect("(lit 1)") {
+                exprLit(int8Value(1))
+            },
+            expect("(lit 2)") {
+                exprLit(int16Value(2))
+            },
+            expect("(lit 3)") {
+                exprLit(int32Value(3))
+            },
+            expect("(lit 4)") {
+                exprLit(int64Value(4))
+            },
+            expect("(lit 5)") {
+                exprLit(intValue(BigInteger.valueOf(5)))
+            },
+            expect("(lit 1.1e0)") {
+                exprLit(float32Value(1.1f))
+            },
+            expect("(lit 1.2e0)") {
+                exprLit(float64Value(1.2))
+            },
+            expect("(lit 1.3)") {
+                exprLit(decimalValue(BigDecimal.valueOf(1.3)))
+            },
+            expect("""(lit "hello")""") {
+                exprLit(stringValue("hello"))
+            },
+            expect("""(lit 'hello')""") {
+                exprLit(symbolValue("hello"))
+            },
+            expect("""(lit {{ '''Hello'''    '''World''' }})""") {
+                exprLit(clobValue("HelloWorld".toByteArray()))
+            },
+            expect("""(lit {{ VG8gaW5maW5pdHkuLi4gYW5kIGJleW9uZCE= }})""") {
+                exprLit(blobValue("To infinity... and beyond!".toByteArray()))
+            },
+            // TODO detailed tests just for _DateTime_ types
+        )
+
+        @JvmStatic
+        fun ion() = listOf(
+            expect("(lit null)") {
+                exprIon(ionNull())
+            },
+            expect("(lit true)") {
+                exprIon(ionBool(true))
+            },
+            expect("(lit 1)") {
+                exprIon(ionInt(1))
+            },
+            expect("(lit 1.2e0)") {
+                exprIon(ionFloat(1.2))
+            },
+            expect("(lit 1.3)") {
+                exprIon(ionDecimal(Decimal.valueOf(1.3)))
+            },
+            expect("""(lit "hello")""") {
+                exprIon(ionString("hello"))
+            },
+            expect("""(lit 'hello')""") {
+                exprIon(ionSymbol("hello"))
+            },
+            // TODO detailed tests just for _DateTime_ types
+        )
+
+        @JvmStatic
+        fun identifiers() = listOf(
+            expect("(id 'a' (case_sensitive) (unqualified))") {
+                exprVar {
+                    identifier = identifierSymbol("a", Identifier.CaseSensitivity.SENSITIVE)
+                    scope = Expr.Var.Scope.DEFAULT
+                }
+            },
+            expect("(id 'a' (case_insensitive) (unqualified))") {
+                exprVar {
+                    identifier = identifierSymbol("a", Identifier.CaseSensitivity.INSENSITIVE)
+                    scope = Expr.Var.Scope.DEFAULT
+                }
+            },
+            expect("(id 'a' (case_sensitive) (locals_first))") {
+                exprVar {
+                    identifier = identifierSymbol("a", Identifier.CaseSensitivity.SENSITIVE)
+                    scope = Expr.Var.Scope.LOCAL
+                }
+            },
+            expect("(id 'a' (case_insensitive) (locals_first))") {
+                exprVar {
+                    identifier = identifierSymbol("a", Identifier.CaseSensitivity.INSENSITIVE)
+                    scope = Expr.Var.Scope.LOCAL
+                }
+            },
+            expect("(identifier 'a' (case_insensitive))") {
+                identifierSymbol("a", Identifier.CaseSensitivity.INSENSITIVE)
+            },
+            //
+            fail("Cannot translate qualified identifiers in variable references") {
+                exprVar {
+                    identifier = identifierQualified {
+                        root = identifierSymbol("a", Identifier.CaseSensitivity.INSENSITIVE)
+                        steps += identifierSymbol("b", Identifier.CaseSensitivity.INSENSITIVE)
+                    }
+                    scope = Expr.Var.Scope.LOCAL
+                }
+            }
+        )
+
+        @JvmStatic
+        fun calls() = listOf(
+            expect("(call 'a' (lit null))") {
+                exprCall {
+                    function = id("a")
+                    args += NULL
+                }
+            },
+            expect("(call_agg (all) 'a' (lit null))") {
+                exprAgg {
+                    function = id("a")
+                    args += NULL
+                }
+            },
+            expect("(call_agg (all) 'a' (lit null))") {
+                exprAgg {
+                    setq = SetQuantifier.ALL
+                    function = id("a")
+                    args += NULL
+                }
+            },
+            expect("(call_agg (distinct) 'a' (lit null))") {
+                exprAgg {
+                    setq = SetQuantifier.DISTINCT
+                    function = id("a")
+                    args += NULL
+                }
+            },
+            fail("Cannot translate `call_agg` with more than one argument") {
+                exprAgg {
+                    function = id("a")
+                    args += listOf(NULL, NULL)
+                }
+            },
+        )
+
+        @JvmStatic
+        fun operators() = listOf(
+            expect("(not (lit null))") {
+                exprUnary {
+                    op = Expr.Unary.Op.NOT
+                    expr = NULL
+                }
+            },
+            expect("(pos (lit null))") {
+                exprUnary {
+                    op = Expr.Unary.Op.POS
+                    expr = NULL
+                }
+            },
+            expect("(neg (lit null))") {
+                exprUnary {
+                    op = Expr.Unary.Op.NEG
+                    expr = NULL
+                }
+            },
+            // we don't really need to test _all_ binary operators
+            expect("(plus (lit null) (lit null))") {
+                exprBinary {
+                    op = Expr.Binary.Op.PLUS
+                    lhs = NULL
+                    rhs = NULL
+                }
+            },
+        )
+
+        @JvmStatic
+        fun paths() = listOf(
+            expect("(path (lit null) (path_expr (lit null) (case_sensitive)))") {
+                exprPath {
+                    root = NULL
+                    steps += exprPathStepIndex(NULL)
+                }
+            },
+            expect("(path (lit null) (path_wildcard))") {
+                exprPath {
+                    root = NULL
+                    steps += exprPathStepWildcard()
+                }
+            },
+            expect("(path (lit null) (path_unpivot))") {
+                exprPath {
+                    root = NULL
+                    steps += exprPathStepUnpivot()
+                }
+            },
+        )
+
+        @JvmStatic
+        fun collections() = listOf(
+            expect("(bag (lit null))") {
+                exprCollection(Expr.Collection.Type.BAG) {
+                    values += NULL
+                }
+            },
+            expect("(list (lit null))") {
+                exprCollection(Expr.Collection.Type.ARRAY) {
+                    values += NULL
+                }
+            },
+            expect("(list (lit null))") {
+                exprCollection(Expr.Collection.Type.VALUES) {
+                    values += NULL
+                }
+            },
+            expect("(list (lit null))") {
+                exprCollection(Expr.Collection.Type.LIST) {
+                    values += NULL
+                }
+            },
+            expect("(sexp (lit null))") {
+                exprCollection(Expr.Collection.Type.SEXP) {
+                    values += NULL
+                }
+            },
+            expect("(struct (expr_pair (lit null) (lit null)))") {
+                exprStruct {
+                    fields += exprStructField {
+                        name = NULL
+                        value = NULL
+                    }
+                }
+            },
+        )
+
+        @JvmStatic
+        fun types() = listOf(
+            // SQL
+            expect("(null_type)") { typeNullType() },
+            expect("(boolean_type)") { typeBool() },
+            expect("(smallint_type)") { typeSmallint() },
+            expect("(integer_type)") { typeInt() },
+            expect("(real_type)") { typeReal() },
+            expect("(float_type null)") { typeFloat32() },
+            expect("(double_precision_type)") { typeFloat64() },
+            expect("(decimal_type null null)") { typeDecimal() },
+            expect("(decimal_type 2 null)") { typeDecimal(2) },
+            expect("(decimal_type 2 1)") { typeDecimal(2, 1) },
+            expect("(numeric_type null null)") { typeNumeric() },
+            expect("(numeric_type 2 null)") { typeNumeric(2) },
+            expect("(numeric_type 2 1)") { typeNumeric(2, 1) },
+            expect("(timestamp_type null)") { typeTimestamp() },
+            expect("(timestamp_type 1)") { typeTimestamp(1) },
+            expect("(character_type null)") { typeChar() },
+            expect("(character_type 1)") { typeChar(1) },
+            expect("(character_varying_type null)") { typeVarchar() },
+            expect("(character_varying_type 1)") { typeVarchar(1) },
+            expect("(blob_type)") { typeBlob() },
+            expect("(clob_type)") { typeClob() },
+            expect("(date_type)") { typeDate() },
+            expect("(time_type null)") { typeTime() },
+            expect("(time_type 1)") { typeTime(1) },
+            expect("(time_with_time_zone_type null)") { typeTimeWithTz() },
+            expect("(time_with_time_zone_type 1)") { typeTimeWithTz(1) },
+            // PartiQL
+            expect("(missing_type)") { typeMissing() },
+            expect("(string_type)") { typeString() },
+            expect("(symbol_type)") { typeSymbol() },
+            expect("(struct_type)") { typeStruct() },
+            expect("(tuple_type)") { typeTuple() },
+            expect("(list_type)") { typeList() },
+            expect("(sexp_type)") { typeSexp() },
+            expect("(bag_type)") { typeBag() },
+            expect("(any_type)") { typeAny() },
+            // Other (??)
+            expect("(integer4_type)") { typeInt4() },
+            expect("(integer8_type)") { typeInt8() },
+            expect("(custom_type dog)") { typeCustom("dog") }
+            // LEGACY AST does not have TIMESTAMP or INTERVAL
+            // LEGACY AST does not have parameterized blob/clob
+        )
+
+        @JvmStatic
+        fun specialForms() = listOf(
+            expect("(like (lit 'a') (lit 'b') null)") {
+                exprLike {
+                    value = exprLit(symbolValue("a"))
+                    pattern = exprLit(symbolValue("b"))
+                }
+            },
+            expect("(like (lit 'a') (lit 'b') (lit 'c'))") {
+                exprLike {
+                    value = exprLit(symbolValue("a"))
+                    pattern = exprLit(symbolValue("b"))
+                    escape = exprLit(symbolValue("c"))
+                }
+            },
+            expect("(not (like (lit 'a') (lit 'b') (lit 'c')))") {
+                exprLike {
+                    value = exprLit(symbolValue("a"))
+                    pattern = exprLit(symbolValue("b"))
+                    escape = exprLit(symbolValue("c"))
+                    not = true
+                }
+            },
+            expect("(between (lit 'a') (lit 'b') (lit 'c'))") {
+                exprBetween {
+                    value = exprLit(symbolValue("a"))
+                    from = exprLit(symbolValue("b"))
+                    to = exprLit(symbolValue("c"))
+                }
+            },
+            expect("(not (between (lit 'a') (lit 'b') (lit 'c')))") {
+                exprBetween {
+                    value = exprLit(symbolValue("a"))
+                    from = exprLit(symbolValue("b"))
+                    to = exprLit(symbolValue("c"))
+                    not = true
+                }
+            },
+            expect("(in_collection (lit 'a') (lit 'b'))") {
+                exprInCollection {
+                    lhs = exprLit(symbolValue("a"))
+                    rhs = exprLit(symbolValue("b"))
+                }
+            },
+            expect("(not (in_collection (lit 'a') (lit 'b')))") {
+                exprInCollection {
+                    lhs = exprLit(symbolValue("a"))
+                    rhs = exprLit(symbolValue("b"))
+                    not = true
+                }
+            },
+            expect("(is_type (lit 'a') (any_type))") {
+                exprIsType {
+                    value = exprLit(symbolValue(("a")))
+                    type = typeAny()
+                }
+            },
+            expect("(not (is_type (lit 'a') (any_type)))") {
+                exprIsType {
+                    value = exprLit(symbolValue(("a")))
+                    type = typeAny()
+                    not = true
+                }
+            },
+            // TODO case
+            // TODO coalesce
+            // TODO nullif
+            // TODO substring
+            // TODO position
+            expect("""(call 'trim' (lit "xyz"))""") {
+                exprTrim {
+                    value = exprLit(stringValue("xyz"))
+                }
+            },
+            expect("""(call 'trim' (lit "xyz"))""") {
+                exprTrim {
+                    value = exprLit(stringValue("xyz"))
+                }
+            },
+            expect("""(call 'trim' (lit "xyz"))""") {
+                exprTrim {
+                    value = exprLit(stringValue("xyz"))
+                }
+            },
+            // TODO overlay
+            // TODO extract
+            // TODO cast
+            // TODO can_cast
+            // TODO can_lossless_cast
+            // TODO date_add
+            // TODO date_diff
+        )
+
+        @JvmStatic
+        fun sfw() = listOf(
+            // PROJECT Variants
+            expect("(project_star)") {
+                selectStar()
+            },
+            expect(
+                """
+                (project_list
+                    (project_all (id 'a' (case_sensitive) (unqualified)))
+                    (project_expr (lit 1) 'x')
+                )
+             """
+            ) {
+                selectProject {
+                    items += selectProjectItemAll {
+                        expr =
+                            exprVar(identifierSymbol("a", Identifier.CaseSensitivity.SENSITIVE), Expr.Var.Scope.DEFAULT)
+                    }
+                    items += selectProjectItemExpression {
+                        expr = exprLit(int32Value(1))
+                        asAlias = id("x")
+                    }
+                }
+            },
+            expect("(project_pivot (lit 1) (lit 2))") {
+                selectPivot {
+                    value = exprLit(int32Value(1))
+                    key = exprLit(int32Value(2))
+                }
+            },
+            expect("(project_value (lit null))") {
+                selectValue {
+                    constructor = NULL
+                }
+            },
+            // FROM_SOURCE Variants
+            expect("(scan (lit null) null null null)") {
+                fromValue {
+                    expr = NULL
+                    type = From.Value.Type.SCAN
+                }
+            },
+            expect("(scan (lit null) 'a' 'b' 'c')") {
+                fromValue {
+                    expr = NULL
+                    type = From.Value.Type.SCAN
+                    asAlias = id("a")
+                    atAlias = id("b")
+                    byAlias = id("c")
+                }
+            },
+            expect("(unpivot (lit null) null null null)") {
+                fromValue {
+                    expr = NULL
+                    type = From.Value.Type.UNPIVOT
+                }
+            },
+            expect("(unpivot (lit null) 'a' 'b' 'c')") {
+                fromValue {
+                    expr = NULL
+                    type = From.Value.Type.UNPIVOT
+                    asAlias = id("a")
+                    atAlias = id("b")
+                    byAlias = id("c")
+                }
+            },
+            expect(
+                """
+                (join (inner)
+                    (scan (lit "lhs") null null null)
+                    (scan (lit "rhs") null null null)
+                    null
+                )
+            """
+            ) {
+                fromJoin {
+                    type = From.Join.Type.INNER
+                    lhs = fromValue {
+                        expr = exprLit(stringValue("lhs"))
+                        type = From.Value.Type.SCAN
+                    }
+                    rhs = fromValue {
+                        expr = exprLit(stringValue("rhs"))
+                        type = From.Value.Type.SCAN
+                    }
+                }
+            },
+            expect(
+                """
+                (join (inner)
+                    (scan (lit "lhs") null null null)
+                    (scan (lit "rhs") null null null)
+                    (lit true)
+                )
+            """
+            ) {
+                fromJoin {
+                    // DEFAULT
+                    // type = From.Join.Type.INNER
+                    lhs = fromValue {
+                        expr = exprLit(stringValue("lhs"))
+                        type = From.Value.Type.SCAN
+                    }
+                    rhs = fromValue {
+                        expr = exprLit(stringValue("rhs"))
+                        type = From.Value.Type.SCAN
+                    }
+                    condition = exprLit(boolValue(true))
+                }
+            },
+            expect("(let (let_binding (lit null) 'x'))") {
+                let {
+                    bindings += letBinding {
+                        expr = NULL
+                        asAlias = id("x")
+                    }
+                }
+            },
+            expect(
+                """
+               (group_by (group_full)
+                    (group_key_list
+                        (group_key (lit "a") null)
+                        (group_key (lit "b") 'x')
+                    )
+                    null
+               )
+            """
+            ) {
+                groupBy {
+                    strategy = GroupBy.Strategy.FULL
+                    keys += groupByKey(exprLit(stringValue("a")), null)
+                    keys += groupByKey(exprLit(stringValue("b")), id("x"))
+                }
+            },
+            expect(
+                """
+               (group_by (group_partial)
+                    (group_key_list
+                        (group_key (lit "a") null)
+                        (group_key (lit "b") 'x')
+                    )
+                    'as'
+               )
+            """
+            ) {
+                groupBy {
+                    strategy = GroupBy.Strategy.PARTIAL
+                    keys += groupByKey(exprLit(stringValue("a")), null)
+                    keys += groupByKey(exprLit(stringValue("b")), id("x"))
+                    asAlias = id("as")
+                }
+            },
+            expect(
+                """
+               (order_by
+                    (sort_spec (lit "a") null null)
+                    (sort_spec (lit "b") (asc) (nulls_first))
+                    (sort_spec (lit "c") (asc) (nulls_last))
+                    (sort_spec (lit "d") (desc) (nulls_first))
+                    (sort_spec (lit "e") (desc) (nulls_last))
+               )
+            """
+            ) {
+                orderBy {
+                    sorts += sort(exprLit(stringValue("a")))
+                    sorts += sort(exprLit(stringValue("b")), Sort.Dir.ASC, Sort.Nulls.FIRST)
+                    sorts += sort(exprLit(stringValue("c")), Sort.Dir.ASC, Sort.Nulls.LAST)
+                    sorts += sort(exprLit(stringValue("d")), Sort.Dir.DESC, Sort.Nulls.FIRST)
+                    sorts += sort(exprLit(stringValue("e")), Sort.Dir.DESC, Sort.Nulls.LAST)
+                }
+            },
+        )
+    }
+
+    sealed class Case {
+
+        abstract fun assert()
+
+        class Translate(
+            private val input: AstNode,
+            private val expected: PartiqlAst.PartiqlAstNode,
+            private val metas: Map<String, MetaContainer> = emptyMap(),
+        ) : Case() {
+
+            override fun assert() {
+                val actual = input.toLegacyAst(metas)
+                val aIon = actual.toIonElement()
+                val eIon = expected.toIonElement()
+                assertEquals(eIon, aIon)
+            }
+        }
+
+        class Fail(
+            private val input: AstNode,
+            private val message: String,
+            private val metas: Map<String, MetaContainer> = emptyMap(),
+        ) : Case() {
+
+            override fun assert() {
+                assertFails(message) {
+                    input.toLegacyAst(metas)
+                }
+            }
+        }
+    }
+}
diff --git a/partiql-cli/src/main/kotlin/org/partiql/cli/utils/ServiceLoaderUtil.kt b/partiql-cli/src/main/kotlin/org/partiql/cli/utils/ServiceLoaderUtil.kt
index fd6884fa22..1b649ce707 100644
--- a/partiql-cli/src/main/kotlin/org/partiql/cli/utils/ServiceLoaderUtil.kt
+++ b/partiql-cli/src/main/kotlin/org/partiql/cli/utils/ServiceLoaderUtil.kt
@@ -63,7 +63,6 @@ import org.partiql.value.NullableListValue
 import org.partiql.value.NullableSexpValue
 import org.partiql.value.NullableStringValue
 import org.partiql.value.NullableSymbolValue
-import org.partiql.value.NullableTimeValue
 import org.partiql.value.PartiQLValue
 import org.partiql.value.PartiQLValueExperimental
 import org.partiql.value.SexpValue
@@ -77,6 +76,9 @@ import org.partiql.value.boolValue
 import org.partiql.value.charValue
 import org.partiql.value.clobValue
 import org.partiql.value.dateValue
+import org.partiql.value.datetime.DateTimeValue.date
+import org.partiql.value.datetime.DateTimeValue.time
+import org.partiql.value.datetime.TimeZone
 import org.partiql.value.decimalValue
 import org.partiql.value.float32Value
 import org.partiql.value.float64Value
@@ -95,8 +97,10 @@ import org.partiql.value.symbolValue
 import org.partiql.value.timeValue
 import java.math.BigDecimal
 import java.math.BigInteger
+import java.math.RoundingMode
 import java.net.URLClassLoader
 import java.nio.file.Path
+import java.time.DateTimeException
 import java.util.ServiceLoader
 import java.util.concurrent.locks.ReentrantLock
 import kotlin.concurrent.withLock
@@ -252,25 +256,38 @@ class ServiceLoaderUtil {
                 PartiQLValueType.CLOB -> (partiqlValue as? ClobValue)?.value?.let { newClob(it) }
                     ?: throw PartiQLtoExprValueTypeMismatchException("CLOB", partiqlValue.type)
 
-                PartiQLValueType.DATE -> (partiqlValue as? DateValue)?.value?.let { newDate(it) }
+                PartiQLValueType.DATE -> (partiqlValue as? DateValue)?.value?.let { newDate(it.year, it.month, it.day) }
                     ?: throw PartiQLtoExprValueTypeMismatchException("DATE", partiqlValue.type)
 
-                PartiQLValueType.TIME -> {
-                    val timeValue = partiqlValue as? TimeValue
-                    timeValue?.let { tv ->
-                        val value = tv.value
-                        val precision = tv.precision
-                        val offset = tv.offset
-                        val withzone = tv.withZone
-                        if (withzone) {
-                            offset?.let {
-                                newTime(Time.of(value, precision, it))
-                            }
-                        } else {
-                            newTime(Time.of(value, precision, null))
+                PartiQLValueType.TIME -> (partiqlValue as? TimeValue)?.value?.let { partiqlTime ->
+                    val fraction = partiqlTime.decimalSecond.remainder(BigDecimal.ONE)
+                    val precision =
+                        when {
+                            fraction.scale() > 9 -> throw DateTimeException("Precision greater than nano seconds not supported")
+                            else -> fraction.scale()
                         }
-                    } ?: throw PartiQLtoExprValueTypeMismatchException("TIME", partiqlValue.type)
-                }
+
+                    val tzMinutes = when (val tz = partiqlTime.timeZone) {
+                        is TimeZone.UnknownTimeZone -> 0 // Treat unknown offset as UTC (+00:00)
+                        is TimeZone.UtcOffset -> tz.totalOffsetMinutes
+                        else -> null
+                    }
+
+                    try {
+                        newTime(
+                            Time.of(
+                                partiqlTime.hour,
+                                partiqlTime.minute,
+                                partiqlTime.decimalSecond.setScale(0, RoundingMode.DOWN).toInt(),
+                                fraction.movePointRight(9).setScale(0, RoundingMode.DOWN).toInt(),
+                                precision,
+                                tzMinutes
+                            )
+                        )
+                    } catch (e: DateTimeException) {
+                        throw e
+                    }
+                } ?: throw PartiQLtoExprValueTypeMismatchException("TIME", partiqlValue.type)
 
                 PartiQLValueType.TIMESTAMP -> TODO()
                 // TODO: Implement
@@ -363,23 +380,38 @@ class ServiceLoaderUtil {
                 PartiQLValueType.NULLABLE_CLOB -> (partiqlValue as? NullableClobValue)?.value?.let { newClob(it) }
                     ?: ExprValue.nullValue
 
-                PartiQLValueType.NULLABLE_DATE -> (partiqlValue as? NullableDateValue)?.value?.let { newDate(it) }
+                PartiQLValueType.NULLABLE_DATE -> (partiqlValue as? NullableDateValue)?.value?.let { newDate(it.year, it.month, it.day) }
                     ?: ExprValue.nullValue
 
-                PartiQLValueType.NULLABLE_TIME -> {
-                    (partiqlValue as? NullableTimeValue)?.let { tv ->
-                        tv.value?.let { value ->
-                            val precision = tv.precision
-                            val offset = tv.offset
-                            val withzone = tv.withZone
-                            if (withzone) {
-                                offset?.let { offsetValue -> newTime(Time.of(value, precision, offsetValue)) } ?: null
-                            } else {
-                                newTime(Time.of(value, precision, null))
-                            }
+                PartiQLValueType.NULLABLE_TIME -> (partiqlValue as? TimeValue)?.value?.let { partiqlTime ->
+                    val fraction = partiqlTime.decimalSecond.remainder(BigDecimal.ONE)
+                    val precision =
+                        when {
+                            fraction.scale() > 9 -> throw DateTimeException("Precision greater than nano seconds not supported")
+                            else -> fraction.scale()
                         }
-                    } ?: ExprValue.nullValue
-                }
+
+                    val tzMinutes = when (val tz = partiqlTime.timeZone) {
+                        is TimeZone.UnknownTimeZone -> 0 // Treat unknown offset as UTC (+00:00)
+                        is TimeZone.UtcOffset -> tz.totalOffsetMinutes
+                        else -> null
+                    }
+
+                    try {
+                        newTime(
+                            Time.of(
+                                partiqlTime.hour,
+                                partiqlTime.minute,
+                                partiqlTime.decimalSecond.setScale(0, RoundingMode.DOWN).toInt(),
+                                fraction.movePointRight(9).setScale(0, RoundingMode.DOWN).toInt(),
+                                precision,
+                                tzMinutes
+                            )
+                        )
+                    } catch (e: DateTimeException) {
+                        throw e
+                    }
+                } ?: ExprValue.nullValue
 
                 PartiQLValueType.NULLABLE_TIMESTAMP -> TODO()
                 // TODO: Implement
@@ -397,17 +429,17 @@ class ServiceLoaderUtil {
                 PartiQLValueType.NULLABLE_INTERVAL -> TODO() // add nullable interval conversion
 
                 PartiQLValueType.NULLABLE_BAG -> {
-                    (partiqlValue as? NullableBagValue<*>)?.elements?.map { PartiQLtoExprValue(it) }
+                    (partiqlValue as? NullableBagValue<*>)?.promote()?.elements?.map { PartiQLtoExprValue(it) }
                         ?.let { newBag(it.asSequence()) } ?: ExprValue.nullValue
                 }
 
                 PartiQLValueType.NULLABLE_LIST -> {
-                    (partiqlValue as? NullableListValue<*>)?.elements?.map { PartiQLtoExprValue(it) }
+                    (partiqlValue as? NullableListValue<*>)?.promote()?.map { PartiQLtoExprValue(it) }
                         ?.let { newList(it.asSequence()) } ?: ExprValue.nullValue
                 }
 
                 PartiQLValueType.NULLABLE_SEXP -> {
-                    (partiqlValue as? NullableSexpValue<*>)?.elements?.map { PartiQLtoExprValue(it) }
+                    (partiqlValue as? NullableSexpValue<*>)?.promote()?.map { PartiQLtoExprValue(it) }
                         ?.let { newSexp(it.asSequence()) } ?: ExprValue.nullValue
                 }
 
@@ -488,11 +520,18 @@ class ServiceLoaderUtil {
                 }
                 PartiQLValueType.DATE -> {
                     checkType(ExprValueType.DATE)
-                    dateValue(exprValue.dateValue())
+                    dateValue(
+                        date(exprValue.dateValue().year, exprValue.dateValue().monthValue, exprValue.dateValue().dayOfMonth)
+                    )
                 }
                 PartiQLValueType.TIME -> {
                     checkType(ExprValueType.TIME)
-                    timeValue(exprValue.timeValue().localTime, exprValue.timeValue().precision, exprValue.timeValue().zoneOffset, true)
+                    timeValue(
+                        time(
+                            exprValue.timeValue().localTime.hour, exprValue.timeValue().localTime.minute, exprValue.timeValue().localTime.second, exprValue.timeValue().localTime.nano,
+                            exprValue.timeValue().timezoneMinute?.let { TimeZone.UtcOffset.of(it) } ?: null
+                        )
+                    )
                 }
                 PartiQLValueType.TIMESTAMP -> TODO()
                 PartiQLValueType.INTERVAL -> TODO()
@@ -594,12 +633,17 @@ class ServiceLoaderUtil {
                 }
                 PartiQLValueType.NULLABLE_DATE -> when (exprValue.type) {
                     ExprValueType.NULL -> nullValue()
-                    ExprValueType.DATE -> dateValue(exprValue.dateValue())
+                    ExprValueType.DATE -> dateValue(date(exprValue.dateValue().year, exprValue.dateValue().monthValue, exprValue.dateValue().dayOfMonth))
                     else -> throw ExprToPartiQLValueTypeMismatchException(PartiQLValueType.NULLABLE_DATE, ExprToPartiQLValueType(exprValue))
                 }
                 PartiQLValueType.NULLABLE_TIME -> when (exprValue.type) {
                     ExprValueType.NULL -> nullValue()
-                    ExprValueType.TIME -> timeValue(exprValue.timeValue().localTime, exprValue.timeValue().precision, exprValue.timeValue().zoneOffset, true)
+                    ExprValueType.TIME -> timeValue(
+                        time(
+                            exprValue.timeValue().localTime.hour, exprValue.timeValue().localTime.minute, exprValue.timeValue().localTime.second, exprValue.timeValue().localTime.nano,
+                            exprValue.timeValue().timezoneMinute?.let { TimeZone.UtcOffset.of(it) } ?: null
+                        )
+                    )
                     else -> throw ExprToPartiQLValueTypeMismatchException(PartiQLValueType.NULLABLE_TIME, ExprToPartiQLValueType(exprValue))
                 }
                 PartiQLValueType.NULLABLE_TIMESTAMP -> TODO()
diff --git a/partiql-lang/build.gradle.kts b/partiql-lang/build.gradle.kts
index 2168eb5fd3..43642bd51d 100644
--- a/partiql-lang/build.gradle.kts
+++ b/partiql-lang/build.gradle.kts
@@ -33,13 +33,13 @@ kotlin {
 
 dependencies {
     api(project(":partiql-ast"))
+    api(project(":partiql-parser"))
     api(project(":partiql-spi"))
     api(project(":partiql-types"))
     api(Deps.ionElement)
     api(Deps.ionJava)
     api(Deps.ionSchema)
     // libs are included in partiql-lang-kotlin JAR, but are not published independently yet.
-    libs(project(":partiql-parser"))
     libs(project(":partiql-plan"))
     implementation(Deps.antlrRuntime)
     implementation(Deps.csv)
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/errors/ErrorCode.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/errors/ErrorCode.kt
index 3d043897ce..91a1e6720e 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/errors/ErrorCode.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/errors/ErrorCode.kt
@@ -143,6 +143,13 @@ enum class ErrorCode(
         "invalid precision used for TIME type"
     ),
 
+    // TODO: We should combine this with the above
+    PARSE_INVALID_PRECISION_FOR_TIMESTAMP(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "invalid precision used for TIMESTAMP type"
+    ),
+
     PARSE_INVALID_DATE_STRING(
         ErrorCategory.PARSER,
         LOC_TOKEN,
@@ -155,6 +162,12 @@ enum class ErrorCode(
         "expected time string to be of the format HH:MM:SS[.dddd...][+|-HH:MM]"
     ),
 
+    PARSE_INVALID_DATETIME_STRING(
+        ErrorCategory.PARSER,
+        LOC_TOKEN,
+        "Invalid timestamp string"
+    ),
+
     PARSE_INVALID_TRIM_SPEC(
         ErrorCategory.PARSER,
         LOC_TOKEN,
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/eval/EvaluatingCompiler.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/eval/EvaluatingCompiler.kt
index e3b2cc99c6..791181936d 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/eval/EvaluatingCompiler.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/eval/EvaluatingCompiler.kt
@@ -474,6 +474,7 @@ internal class EvaluatingCompiler(
 
             is PartiqlAst.Expr.GraphMatch -> compileGraphMatch(expr, metas)
             is PartiqlAst.Expr.CallWindow -> TODO("Evaluating Compiler doesn't support window function")
+            is PartiqlAst.Expr.Timestamp -> TODO()
         }
     }
 
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/eval/physical/PhysicalPlanCompilerImpl.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/eval/physical/PhysicalPlanCompilerImpl.kt
index b39f334c46..9de5761451 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/eval/physical/PhysicalPlanCompilerImpl.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/eval/physical/PhysicalPlanCompilerImpl.kt
@@ -291,6 +291,7 @@ internal class PhysicalPlanCompilerImpl(
             is PartiqlPhysical.Expr.BindingsToValues -> compileBindingsToValues(expr)
             is PartiqlPhysical.Expr.Pivot -> compilePivot(expr, metas)
             is PartiqlPhysical.Expr.GraphMatch -> TODO("Physical compilation of GraphMatch expression")
+            is PartiqlPhysical.Expr.Timestamp -> TODO()
         }
     }
 
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/eval/visitors/SubqueryCoercionVisitorTransform.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/eval/visitors/SubqueryCoercionVisitorTransform.kt
index beb8fa1d14..969f5da980 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/eval/visitors/SubqueryCoercionVisitorTransform.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/eval/visitors/SubqueryCoercionVisitorTransform.kt
@@ -101,6 +101,7 @@ class SubqueryCoercionVisitorTransform : VisitorTransformBase() {
             is PartiqlAst.Expr.CanLosslessCast -> n
             is PartiqlAst.Expr.NullIf -> n
             is PartiqlAst.Expr.Coalesce -> n
+            is PartiqlAst.Expr.Timestamp -> TODO()
         }
     }
 
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/graph/GpmlTranslator.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/graph/GpmlTranslator.kt
index dcff6496bf..7c715b0541 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/graph/GpmlTranslator.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/graph/GpmlTranslator.kt
@@ -2,7 +2,6 @@ package org.partiql.lang.graph
 
 import org.partiql.lang.domains.PartiqlAst
 import org.partiql.lang.graph.GpmlTranslator.normalizeElemList
-import org.partiql.pig.runtime.SymbolPrimitive
 
 /** Translate an AST graph pattern into a "plan spec" to be executed by the graph engine.
  *  Currently, the only non-trivial aspect is making sure (in [normalizeElemList]) that node and edge elements alternate.
@@ -52,11 +51,12 @@ object GpmlTranslator {
         )
     }
 
-    fun translateLabels(labels: List<SymbolPrimitive>): LabelSpec {
-        return when (labels.size) {
-            0 -> LabelSpec.Whatever
-            1 -> LabelSpec.OneOf(labels[0].text)
-            else -> TODO("Not yet supported in evaluating a GPML graph element pattern: multiple/alternating labels")
+    fun translateLabels(labelSpec: PartiqlAst.GraphLabelSpec?): LabelSpec {
+        return when (labelSpec) {
+            null -> LabelSpec.Wildcard
+            is PartiqlAst.GraphLabelSpec.GraphLabelName -> LabelSpec.Name(labelSpec.name.text)
+            is PartiqlAst.GraphLabelSpec.GraphLabelWildcard -> LabelSpec.Wildcard
+            else -> TODO("Not yet supported graph label pattern: $labelSpec")
         }
     }
 
@@ -76,7 +76,7 @@ object GpmlTranslator {
      *  TODO: Deal with adjacent [NodeSpec]s -- by "unification" or prohibit.
      */
     fun normalizeElemList(elems: List<ElemSpec>): List<ElemSpec> {
-        val fillerNode = NodeSpec(null, LabelSpec.Whatever)
+        val fillerNode = NodeSpec(null, LabelSpec.Wildcard)
         val normalized = mutableListOf<ElemSpec>()
         var expectNode = true
         for (x in elems) {
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/graph/Graph.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/graph/Graph.kt
index 1d62535dfa..ee203423ac 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/graph/Graph.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/graph/Graph.kt
@@ -66,11 +66,11 @@ interface Graph {
  *  based on labels at them.
  */
 sealed class LabelSpec {
-    /** A graph element matches when one of its labels is [name].*/
-    data class OneOf(val name: String) : LabelSpec()
+    /** A graph element (node or edge) matches when its label set contains [name]. */
+    data class Name(val name: String) : LabelSpec()
 
-    /** A graph element always matches (even when it is not labeled at all).*/
-    object Whatever : LabelSpec()
+    /** A graph element matches as long as it has a label. */
+    object Wildcard : LabelSpec()
 
     // TODO: more LabelSpec features: alternation, negation, string patterns, ...
 }
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/graph/SimpleGraph.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/graph/SimpleGraph.kt
index 8d2fdf7123..cffda268e9 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/graph/SimpleGraph.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/graph/SimpleGraph.kt
@@ -35,8 +35,8 @@ class SimpleGraph(
 
     private fun labelsMatchSpec(labels: Set<String>, spec: LabelSpec): Boolean =
         when (spec) {
-            LabelSpec.Whatever -> true
-            is LabelSpec.OneOf -> labels.contains(spec.name)
+            LabelSpec.Wildcard -> true
+            is LabelSpec.Name -> labels.contains(spec.name)
         }
 
     private fun Graph.Elem.matches(labelSpec: LabelSpec): Boolean =
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/prettyprint/ASTPrettyPrinter.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/prettyprint/ASTPrettyPrinter.kt
index c2276105b5..87657084aa 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/prettyprint/ASTPrettyPrinter.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/prettyprint/ASTPrettyPrinter.kt
@@ -577,6 +577,7 @@ class ASTPrettyPrinter {
             )
             is PartiqlAst.Expr.GraphMatch -> TODO("Unsupported GraphMatch AST node")
             is PartiqlAst.Expr.CallWindow -> TODO("PrettyPrinter doesn't support Window Function yet.")
+            is PartiqlAst.Expr.Timestamp -> TODO()
         }
 
     private fun toRecursionTreeList(nodes: List<PartiqlAst.Expr>, attrOfParent: String? = null): List<RecursionTree> =
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/prettyprint/QueryPrettyPrinter.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/prettyprint/QueryPrettyPrinter.kt
index e66024154e..1fa489de4a 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/prettyprint/QueryPrettyPrinter.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/prettyprint/QueryPrettyPrinter.kt
@@ -328,11 +328,12 @@ class QueryPrettyPrinter {
             is PartiqlAst.Expr.CallWindow -> TODO()
             is PartiqlAst.Expr.GraphMatch -> TODO()
             is PartiqlAst.Expr.SessionAttribute -> writeSessionAttribute(node, sb)
+            is PartiqlAst.Expr.Timestamp -> TODO()
         }
     }
 
     private fun writeSessionAttribute(node: PartiqlAst.Expr.SessionAttribute, sb: StringBuilder) {
-        sb.append(node.value.text)
+        sb.append(node.value.text.uppercase())
     }
 
     /**
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/PartiQLParserBuilder.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/PartiQLParserBuilder.kt
index 330f4c4be5..b1537c2ece 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/PartiQLParserBuilder.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/PartiQLParserBuilder.kt
@@ -15,6 +15,7 @@
 package org.partiql.lang.syntax
 
 import org.partiql.lang.syntax.impl.PartiQLPigParser
+import org.partiql.lang.syntax.impl.PartiQLShimParser
 import org.partiql.lang.types.CustomType
 
 /**
@@ -29,12 +30,25 @@ import org.partiql.lang.types.CustomType
  */
 class PartiQLParserBuilder {
 
+    private var constructor: (customTypes: List<CustomType>) -> Parser = ::PartiQLPigParser
+
     companion object {
 
         @JvmStatic
         fun standard(): PartiQLParserBuilder {
             return PartiQLParserBuilder()
         }
+
+        @JvmStatic
+        fun experimental(): PartiQLParserBuilder {
+            val builder = PartiQLParserBuilder()
+            builder.constructor = { _ ->
+                // currently don't pass custom types
+                val delegate = org.partiql.parser.PartiQLParserBuilder.standard().build()
+                PartiQLShimParser(delegate)
+            }
+            return builder
+        }
     }
 
     private var customTypes: List<CustomType> = emptyList()
@@ -44,6 +58,6 @@ class PartiQLParserBuilder {
     }
 
     fun build(): Parser {
-        return PartiQLPigParser(this.customTypes)
+        return constructor(this.customTypes)
     }
 }
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/impl/PartiQLPigVisitor.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/impl/PartiQLPigVisitor.kt
index a505a8bc4a..8249d79c45 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/impl/PartiQLPigVisitor.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/impl/PartiQLPigVisitor.kt
@@ -35,8 +35,6 @@ import com.amazon.ionelement.api.ionSymbol
 import com.amazon.ionelement.api.loadSingleElement
 import org.antlr.v4.runtime.ParserRuleContext
 import org.antlr.v4.runtime.Token
-import org.antlr.v4.runtime.tree.ErrorNode
-import org.antlr.v4.runtime.tree.RuleNode
 import org.antlr.v4.runtime.tree.TerminalNode
 import org.partiql.lang.ast.IsCountStarMeta
 import org.partiql.lang.ast.IsImplictJoinMeta
@@ -54,6 +52,7 @@ import org.partiql.lang.errors.PropertyValueMap
 import org.partiql.lang.eval.EvaluationException
 import org.partiql.lang.eval.time.MAX_PRECISION_FOR_TIME
 import org.partiql.lang.syntax.ParserException
+import org.partiql.lang.syntax.util.DateTimeUtils
 import org.partiql.lang.types.CustomType
 import org.partiql.lang.util.DATE_PATTERN_REGEX
 import org.partiql.lang.util.bigDecimalOf
@@ -64,20 +63,62 @@ import org.partiql.lang.util.unaryMinus
 import org.partiql.parser.antlr.PartiQLBaseVisitor
 import org.partiql.parser.antlr.PartiQLParser
 import org.partiql.pig.runtime.SymbolPrimitive
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.TimeZone
 import java.math.BigInteger
 import java.time.LocalDate
 import java.time.LocalTime
 import java.time.OffsetTime
 import java.time.format.DateTimeFormatter
 import java.time.format.DateTimeParseException
-import kotlin.reflect.KClass
-import kotlin.reflect.cast
 
 /**
  * Extends ANTLR's generated [PartiQLBaseVisitor] to visit an ANTLR ParseTree and convert it into a PartiQL AST. This
  * class uses the [PartiqlAst.PartiqlAstNode] to represent all nodes within the new AST.
+ *
+ * When the grammar in PartiQL.g4 is extended with a new rule, one needs to override corresponding visitor methods
+ * in this class, in order to extend the transformation from an ANTLR parse tree into a [PartqlAst] tree.
+ * (Trivial implementations of these methods are generated into [PartiQLBaseVisitor].)
+ *
+ * For a rule of the form
+ * ```
+ * Aaa
+ *   :  B1 ... Bn ;
+ * ```
+ * it generates the `visitAaa(ctx: PartiQLParser.AaaContext ctx)` method,
+ * while for a rule of the form
+ * ```
+ * Aaa
+ *   : B1 ... Bn    # A1
+ *   | C1 ... Cm    # A2
+ *   ;
+ * ```
+ * it generates methods `visitA1(ctx: PartiQLParser.A1Context ctx)` and `visitA2(ctx: PartiQLParser.A2Context ctx)`,
+ * but not `visitAaa`.
+ * The context objects `ctx` provide access to the terminals and non-terminals (`Bi`, `Cj`) necessary for
+ * implementing the methods suitably.
+ *
+ * Conversely, when implementing the visitor for another rule that *references* `Aaa`,
+ *  - The visitor for a rule of the 1st form can be recursively invoked as `visitAaa(ctx.Aaa)`,
+ *    which usually returns an AST node of the desired type.
+ *  - For the rule of the 2nd form, as there is no `visitAaa`, one has to invoke `AbstractParseTreeVisitor.visit()`
+ *    and then cast the result to the expected AST type, doing something like
+ *    ```
+ *         visit(ctx.Aaa) as PartiqlAst.Aaa
+ *    ```
+ *    This delegates to `accept()` which, at run time, invokes the appropriate visitor (`visitA1` or `visitA2`).
+ *    However, any static guarantee is lost (in principle, `accept` can dispatch to any visitor of any rule
+ *    in the grammar), hence the need for the cast.
+ *
+ * Note: A rule of an intermediate form between the above two is allowed: when there are multiple alternative clauses,
+ * but no labels on the clauses. In this case, it generates `visitAaa` whose context object `ctx` provides access
+ * to the combined set of non-terminals of the rule's clauses -- which are then visible at nullable types.
+ * There could be clever ways of exploiting this, to avoid the dispatch via `visit()`.
  */
-internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), private val parameterIndexes: Map<Int, Int> = mapOf()) :
+internal class PartiQLPigVisitor(
+    val customTypes: List<CustomType> = listOf(),
+    private val parameterIndexes: Map<Int, Int> = mapOf()
+) :
     PartiQLBaseVisitor<PartiqlAst.PartiqlAstNode>() {
 
     companion object {
@@ -106,7 +147,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     override fun visitExprTermCurrentUser(ctx: PartiQLParser.ExprTermCurrentUserContext): PartiqlAst.Expr.SessionAttribute {
         val metas = ctx.CURRENT_USER().getSourceMetaContainer()
         return PartiqlAst.Expr.SessionAttribute(
-            value = SymbolPrimitive(ctx.CURRENT_USER().text, metas),
+            value = SymbolPrimitive(ctx.CURRENT_USER().text.toLowerCase(), metas),
             metas = metas
         )
     }
@@ -124,8 +165,13 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
                     throw option.param.error("Unknown EXPLAIN parameter.", ErrorCode.PARSE_UNEXPECTED_TOKEN, cause = ex)
                 }
                 when (parameter) {
-                    ExplainParameters.TYPE -> { type = parameter.getCompliantString(type, option.value) }
-                    ExplainParameters.FORMAT -> { format = parameter.getCompliantString(format, option.value) }
+                    ExplainParameters.TYPE -> {
+                        type = parameter.getCompliantString(type, option.value)
+                    }
+
+                    ExplainParameters.FORMAT -> {
+                        format = parameter.getCompliantString(format, option.value)
+                    }
                 }
             }
             explain(
@@ -155,7 +201,13 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     override fun visitSymbolPrimitive(ctx: PartiQLParser.SymbolPrimitiveContext) = PartiqlAst.build {
         val metas = ctx.ident.getSourceMetaContainer()
         when (ctx.ident.type) {
-            PartiQLParser.IDENTIFIER_QUOTED -> id(ctx.IDENTIFIER_QUOTED().getStringValue(), caseSensitive(), unqualified(), metas)
+            PartiQLParser.IDENTIFIER_QUOTED -> id(
+                ctx.IDENTIFIER_QUOTED().getStringValue(),
+                caseSensitive(),
+                unqualified(),
+                metas
+            )
+
             PartiQLParser.IDENTIFIER -> id(ctx.IDENTIFIER().getStringValue(), caseInsensitive(), unqualified(), metas)
             else -> throw ParserException("Invalid symbol reference.", ErrorCode.PARSE_INVALID_QUERY)
         }
@@ -196,20 +248,20 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitTableDef(ctx: PartiQLParser.TableDefContext) = PartiqlAst.build {
-        val parts = visitOrEmpty(ctx.tableDefPart(), PartiqlAst.TableDefPart::class)
+        val parts = ctx.tableDefPart().map { visit(it) as PartiqlAst.TableDefPart }
         tableDef(parts)
     }
 
     override fun visitColumnDeclaration(ctx: PartiQLParser.ColumnDeclarationContext) = PartiqlAst.build {
         val name = visitSymbolPrimitive(ctx.columnName().symbolPrimitive()).name.text
-        val type = visit(ctx.type(), PartiqlAst.Type::class)
+        val type = visit(ctx.type()) as PartiqlAst.Type
         val constrs = ctx.columnConstraint().map { visitColumnConstraint(it) }
         columnDeclaration(name, type, constrs)
     }
 
     override fun visitColumnConstraint(ctx: PartiQLParser.ColumnConstraintContext) = PartiqlAst.build {
         val name = ctx.columnConstraintName()?.let { visitSymbolPrimitive(it.symbolPrimitive()).name.text }
-        val def = visit(ctx.columnConstraintDef(), PartiqlAst.ColumnConstraintDef::class)
+        val def = visit(ctx.columnConstraintDef()) as PartiqlAst.ColumnConstraintDef
         columnConstraint(name, def)
     }
 
@@ -231,7 +283,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
 
     override fun visitExecCommand(ctx: PartiQLParser.ExecCommandContext) = PartiqlAst.build {
         val name = visitExpr(ctx.name).getStringValue(ctx.name.getStart())
-        val args = visitOrEmpty(ctx.args, PartiqlAst.Expr::class)
+        val args = ctx.args.map { visitExpr(it) }
         exec_(
             SymbolPrimitive(name.lowercase(), emptyMetaContainer()),
             args,
@@ -251,9 +303,9 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
             ctx.fromClause() != null -> ctx.fromClause()
             else -> throw ParserException("Unable to deduce from source in DML", ErrorCode.PARSE_INVALID_QUERY)
         }
-        val from = visitOrNull(sourceContext, PartiqlAst.FromSource::class)
-        val where = visitOrNull(ctx.whereClause(), PartiqlAst.Expr::class)
-        val returning = visitOrNull(ctx.returningClause(), PartiqlAst.ReturningExpr::class)
+        val from = sourceContext?.let { visit(it) as PartiqlAst.FromSource }
+        val where = ctx.whereClause()?.let { visitWhereClause(it) }
+        val returning = ctx.returningClause()?.let { visitReturningClause(it) }
         val operations = ctx.dmlBaseCommand().map { command -> getCommandList(visit(command)) }.flatten()
         dml(dmlOpList(operations, operations[0].metas), from, where, returning, metas = operations[0].metas)
     }
@@ -277,25 +329,31 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitDeleteCommand(ctx: PartiQLParser.DeleteCommandContext) = PartiqlAst.build {
-        val from = visit(ctx.fromClauseSimple(), PartiqlAst.FromSource::class)
-        val where = visitOrNull(ctx.whereClause(), PartiqlAst.Expr::class)
-        val returning = visitOrNull(ctx.returningClause(), PartiqlAst.ReturningExpr::class)
-        dml(dmlOpList(delete(ctx.DELETE().getSourceMetaContainer()), metas = ctx.DELETE().getSourceMetaContainer()), from, where, returning, ctx.DELETE().getSourceMetaContainer())
+        val from = visit(ctx.fromClauseSimple()) as PartiqlAst.FromSource
+        val where = ctx.whereClause()?.let { visitWhereClause(it) }
+        val returning = ctx.returningClause()?.let { visitReturningClause(it) }
+        dml(
+            dmlOpList(delete(ctx.DELETE().getSourceMetaContainer()), metas = ctx.DELETE().getSourceMetaContainer()),
+            from,
+            where,
+            returning,
+            ctx.DELETE().getSourceMetaContainer()
+        )
     }
 
     override fun visitInsertStatementLegacy(ctx: PartiQLParser.InsertStatementLegacyContext) = PartiqlAst.build {
         val metas = ctx.INSERT().getSourceMetaContainer()
         val target = visitPathSimple(ctx.pathSimple())
-        val index = visitOrNull(ctx.pos, PartiqlAst.Expr::class)
+        val index = ctx.pos?.let { visitExpr(it) }
         val onConflict = ctx.onConflictLegacy()?.let { visitOnConflictLegacy(it) }
-        insertValue(target, visit(ctx.value, PartiqlAst.Expr::class), index, onConflict, metas)
+        insertValue(target, visitExpr(ctx.value), index, onConflict, metas)
     }
 
     override fun visitInsertStatement(ctx: PartiQLParser.InsertStatementContext) = PartiqlAst.build {
         insert(
             target = visitSymbolPrimitive(ctx.symbolPrimitive()),
-            asAlias = visitOrNull(ctx.asIdent(), PartiqlAst.Expr.Id::class)?.name?.text,
-            values = visit(ctx.value, PartiqlAst.Expr::class),
+            asAlias = ctx.asIdent()?.let { visitAsIdent(it).name.text },
+            values = visitExpr(ctx.value),
             conflictAction = ctx.onConflict()?.let { visitOnConflict(it) },
             metas = ctx.INSERT().getSourceMetaContainer()
         )
@@ -304,8 +362,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     override fun visitReplaceCommand(ctx: PartiQLParser.ReplaceCommandContext) = PartiqlAst.build {
         insert(
             target = visitSymbolPrimitive(ctx.symbolPrimitive()),
-            asAlias = visitOrNull(ctx.asIdent(), PartiqlAst.Expr.Id::class)?.name?.text,
-            values = visit(ctx.value, PartiqlAst.Expr::class),
+            asAlias = ctx.asIdent()?.let { visitAsIdent(it).name.text },
+            values = visitExpr(ctx.value),
             conflictAction = doReplace(excluded()),
             metas = ctx.REPLACE().getSourceMetaContainer()
         )
@@ -315,8 +373,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     override fun visitUpsertCommand(ctx: PartiQLParser.UpsertCommandContext) = PartiqlAst.build {
         insert(
             target = visitSymbolPrimitive(ctx.symbolPrimitive()),
-            asAlias = visitOrNull(ctx.asIdent(), PartiqlAst.Expr.Id::class)?.name?.text,
-            values = visit(ctx.value, PartiqlAst.Expr::class),
+            asAlias = ctx.asIdent()?.let { visitAsIdent(it).name.text },
+            values = visitExpr(ctx.value),
             conflictAction = doUpdate(excluded()),
             metas = ctx.UPSERT().getSourceMetaContainer()
         )
@@ -326,12 +384,18 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     override fun visitInsertCommandReturning(ctx: PartiQLParser.InsertCommandReturningContext) = PartiqlAst.build {
         val metas = ctx.INSERT().getSourceMetaContainer()
         val target = visitPathSimple(ctx.pathSimple())
-        val index = visitOrNull(ctx.pos, PartiqlAst.Expr::class)
+        val index = ctx.pos?.let { visitExpr(it) }
         val onConflictLegacy = ctx.onConflictLegacy()?.let { visitOnConflictLegacy(it) }
-        val returning = visitOrNull(ctx.returningClause(), PartiqlAst.ReturningExpr::class)
+        val returning = ctx.returningClause()?.let { visitReturningClause(it) }
         dml(
             dmlOpList(
-                insertValue(target, visit(ctx.value, PartiqlAst.Expr::class), index = index, onConflict = onConflictLegacy, ctx.INSERT().getSourceMetaContainer()),
+                insertValue(
+                    target,
+                    visitExpr(ctx.value),
+                    index = index,
+                    onConflict = onConflictLegacy,
+                    ctx.INSERT().getSourceMetaContainer()
+                ),
                 metas = metas
             ),
             returning = returning,
@@ -340,7 +404,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitReturningClause(ctx: PartiQLParser.ReturningClauseContext) = PartiqlAst.build {
-        val elements = visitOrEmpty(ctx.returningColumn(), PartiqlAst.ReturningElem::class)
+        val elements = ctx.returningColumn().map { visit(it) as PartiqlAst.ReturningElem }
         returningExpr(elements, ctx.RETURNING().getSourceMetaContainer())
     }
 
@@ -363,11 +427,15 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitOnConflict(ctx: PartiQLParser.OnConflictContext) = PartiqlAst.build {
-        visit(ctx.conflictAction(), PartiqlAst.ConflictAction::class)
+        visitConflictAction(ctx.conflictAction())
     }
 
     override fun visitOnConflictLegacy(ctx: PartiQLParser.OnConflictLegacyContext) = PartiqlAst.build {
-        onConflict(expr = visitExpr(ctx.expr()), conflictAction = doNothing(), metas = ctx.ON().getSourceMetaContainer())
+        onConflict(
+            expr = visitExpr(ctx.expr()),
+            conflictAction = doNothing(),
+            metas = ctx.ON().getSourceMetaContainer()
+        )
     }
 
     override fun visitConflictAction(ctx: PartiQLParser.ConflictActionContext) = PartiqlAst.build {
@@ -384,7 +452,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
             ctx.EXCLUDED() != null -> excluded()
             else -> TODO("DO REPLACE doesn't support values other than `EXCLUDED` yet.")
         }
-        val condition = visitOrNull(ctx.condition, PartiqlAst.Expr::class)
+        val condition = ctx.condition?.let { visitExpr(it) }
         doReplace(value, condition)
     }
 
@@ -393,14 +461,14 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
             ctx.EXCLUDED() != null -> excluded()
             else -> TODO("DO UPDATE doesn't support values other than `EXCLUDED` yet.")
         }
-        val condition = visitOrNull(ctx.condition, PartiqlAst.Expr::class)
+        val condition = ctx.condition?.let { visitExpr(it) }
         doUpdate(value, condition)
     }
 
     override fun visitPathSimple(ctx: PartiQLParser.PathSimpleContext) = PartiqlAst.build {
         val root = visitSymbolPrimitive(ctx.symbolPrimitive())
         if (ctx.pathSimpleSteps().isEmpty()) return@build root
-        val steps = visitOrEmpty(ctx.pathSimpleSteps(), PartiqlAst.PathStep::class)
+        val steps = ctx.pathSimpleSteps().map { visit(it) as PartiqlAst.PathStep }
         path(root, steps, root.metas)
     }
 
@@ -412,10 +480,11 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         pathExpr(visitSymbolPrimitive(ctx.symbolPrimitive()), caseSensitive())
     }
 
-    override fun visitPathSimpleDotSymbol(ctx: PartiQLParser.PathSimpleDotSymbolContext) = getSymbolPathExpr(ctx.symbolPrimitive())
+    override fun visitPathSimpleDotSymbol(ctx: PartiQLParser.PathSimpleDotSymbolContext) =
+        getSymbolPathExpr(ctx.symbolPrimitive())
 
     override fun visitSetCommand(ctx: PartiQLParser.SetCommandContext) = PartiqlAst.build {
-        val assignments = visitOrEmpty(ctx.setAssignment(), PartiqlAst.DmlOp.Set::class)
+        val assignments = ctx.setAssignment().map { visitSetAssignment(it) }
         val newSets = assignments.map { assignment -> assignment.copy(metas = ctx.SET().getSourceMetaContainer()) }
         dmlOpList(newSets, ctx.SET().getSourceMetaContainer())
     }
@@ -424,7 +493,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         set(assignment(visitPathSimple(ctx.pathSimple()), visitExpr(ctx.expr())))
     }
 
-    override fun visitUpdateClause(ctx: PartiQLParser.UpdateClauseContext) = visit(ctx.tableBaseReference(), PartiqlAst.FromSource::class)
+    override fun visitUpdateClause(ctx: PartiQLParser.UpdateClauseContext) =
+        visit(ctx.tableBaseReference()) as PartiqlAst.FromSource
 
     /**
      *
@@ -433,23 +503,24 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      */
 
     override fun visitDql(ctx: PartiQLParser.DqlContext) = PartiqlAst.build {
-        val query = visit(ctx.expr(), PartiqlAst.Expr::class)
+        val query = visitExpr(ctx.expr())
         query(query, query.metas)
     }
 
-    override fun visitQueryBase(ctx: PartiQLParser.QueryBaseContext) = visit(ctx.exprSelect(), PartiqlAst.Expr::class)
+    override fun visitQueryBase(ctx: PartiQLParser.QueryBaseContext) =
+        visit(ctx.exprSelect()) as PartiqlAst.Expr
 
     override fun visitSfwQuery(ctx: PartiQLParser.SfwQueryContext) = PartiqlAst.build {
-        val projection = visit(ctx.select, PartiqlAst.Projection::class)
+        val projection = visit(ctx.select) as PartiqlAst.Projection
         val strategy = getSetQuantifierStrategy(ctx.select)
         val from = visitFromClause(ctx.from)
-        val order = visitOrNull(ctx.order, PartiqlAst.OrderBy::class)
-        val group = visitOrNull(ctx.group, PartiqlAst.GroupBy::class)
-        val limit = visitOrNull(ctx.limit, PartiqlAst.Expr::class)
-        val offset = visitOrNull(ctx.offset, PartiqlAst.Expr::class)
-        val where = visitOrNull(ctx.where, PartiqlAst.Expr::class)
-        val having = visitOrNull(ctx.having, PartiqlAst.Expr::class)
-        val let = visitOrNull(ctx.let, PartiqlAst.Let::class)
+        val order = ctx.order?.let { visitOrderByClause(it) }
+        val group = ctx.group?.let { visitGroupClause(it) }
+        val limit = ctx.limit?.let { visitLimitClause(it) }
+        val offset = ctx.offset?.let { visitOffsetByClause(it) }
+        val where = ctx.where?.let { visitWhereClauseSelect(it) }
+        val having = ctx.having?.let { visitHavingClause(it) }
+        val let = ctx.let?.let { visitLetClause(it) }
         val metas = ctx.selectClause().getMetas()
         select(
             project = projection,
@@ -472,18 +543,23 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      *
      */
 
-    override fun visitSetQuantifierStrategy(ctx: PartiQLParser.SetQuantifierStrategyContext?): PartiqlAst.SetQuantifier? = when {
-        ctx == null -> null
-        ctx.DISTINCT() != null -> PartiqlAst.SetQuantifier.Distinct()
-        ctx.ALL() != null -> PartiqlAst.SetQuantifier.All()
-        else -> null
-    }
+    override fun visitSetQuantifierStrategy(ctx: PartiQLParser.SetQuantifierStrategyContext?): PartiqlAst.SetQuantifier? =
+        when {
+            ctx == null -> null
+            ctx.DISTINCT() != null -> PartiqlAst.SetQuantifier.Distinct()
+            ctx.ALL() != null -> PartiqlAst.SetQuantifier.All()
+            else -> null
+        }
 
     override fun visitSelectAll(ctx: PartiQLParser.SelectAllContext) = PartiqlAst.build {
         projectStar(ctx.ASTERISK().getSourceMetaContainer())
     }
 
-    override fun visitSelectItems(ctx: PartiQLParser.SelectItemsContext) = convertProjectionItems(ctx.projectionItems(), ctx.SELECT().getSourceMetaContainer())
+    override fun visitSelectItems(ctx: PartiQLParser.SelectItemsContext) =
+        PartiqlAst.build {
+            val projections = ctx.projectionItems().projectionItem().map { visitProjectionItem(it) }
+            projectList(projections, ctx.SELECT().getSourceMetaContainer())
+        }
 
     override fun visitSelectPivot(ctx: PartiQLParser.SelectPivotContext) = PartiqlAst.build {
         projectPivot(visitExpr(ctx.at), visitExpr(ctx.pivot))
@@ -494,8 +570,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitProjectionItem(ctx: PartiQLParser.ProjectionItemContext) = PartiqlAst.build {
-        val expr = visit(ctx.expr(), PartiqlAst.Expr::class)
-        val alias = visitOrNull(ctx.symbolPrimitive(), PartiqlAst.Expr.Id::class)?.name
+        val expr = visitExpr(ctx.expr())
+        val alias = ctx.symbolPrimitive()?.let { visitSymbolPrimitive(it).name }
         if (expr is PartiqlAst.Expr.Path) convertPathToProjectionItem(expr, alias)
         else projectExpr_(expr, asAlias = alias, expr.metas)
     }
@@ -506,20 +582,24 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      *
      */
 
-    override fun visitLimitClause(ctx: PartiQLParser.LimitClauseContext): PartiqlAst.Expr = visit(ctx.arg, PartiqlAst.Expr::class)
+    override fun visitLimitClause(ctx: PartiQLParser.LimitClauseContext): PartiqlAst.Expr =
+        visit(ctx.arg) as PartiqlAst.Expr
 
     override fun visitExpr(ctx: PartiQLParser.ExprContext): PartiqlAst.Expr {
         checkThreadInterrupted()
-        return visit(ctx.exprBagOp(), PartiqlAst.Expr::class)
+        return visit(ctx.exprBagOp()) as PartiqlAst.Expr
     }
 
-    override fun visitOffsetByClause(ctx: PartiQLParser.OffsetByClauseContext) = visit(ctx.arg, PartiqlAst.Expr::class)
+    override fun visitOffsetByClause(ctx: PartiQLParser.OffsetByClauseContext) =
+        visit(ctx.arg) as PartiqlAst.Expr
 
     override fun visitWhereClause(ctx: PartiQLParser.WhereClauseContext) = visitExpr(ctx.arg)
 
-    override fun visitWhereClauseSelect(ctx: PartiQLParser.WhereClauseSelectContext) = visit(ctx.arg, PartiqlAst.Expr::class)
+    override fun visitWhereClauseSelect(ctx: PartiQLParser.WhereClauseSelectContext) =
+        visit(ctx.arg) as PartiqlAst.Expr
 
-    override fun visitHavingClause(ctx: PartiQLParser.HavingClauseContext) = visit(ctx.arg, PartiqlAst.Expr::class)
+    override fun visitHavingClause(ctx: PartiQLParser.HavingClauseContext) =
+        visit(ctx.arg) as PartiqlAst.Expr
 
     /**
      *
@@ -528,12 +608,12 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      */
 
     override fun visitLetClause(ctx: PartiQLParser.LetClauseContext) = PartiqlAst.build {
-        val letBindings = visitOrEmpty(ctx.letBinding(), PartiqlAst.LetBinding::class)
+        val letBindings = ctx.letBinding().map { visitLetBinding(it) }
         let(letBindings)
     }
 
     override fun visitLetBinding(ctx: PartiQLParser.LetBindingContext) = PartiqlAst.build {
-        val expr = visit(ctx.expr(), PartiqlAst.Expr::class)
+        val expr = visitExpr(ctx.expr())
         val metas = ctx.symbolPrimitive().getSourceMetaContainer()
         letBinding_(expr, convertSymbolPrimitive(ctx.symbolPrimitive())!!, metas)
     }
@@ -545,13 +625,13 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      */
 
     override fun visitOrderByClause(ctx: PartiQLParser.OrderByClauseContext) = PartiqlAst.build {
-        val sortSpecs = visitOrEmpty(ctx.orderSortSpec(), PartiqlAst.SortSpec::class)
+        val sortSpecs = ctx.orderSortSpec().map { visitOrderSortSpec(it) }
         val metas = ctx.ORDER().getSourceMetaContainer()
         orderBy(sortSpecs, metas)
     }
 
     override fun visitOrderSortSpec(ctx: PartiQLParser.OrderSortSpecContext) = PartiqlAst.build {
-        val expr = visit(ctx.expr(), PartiqlAst.Expr::class)
+        val expr = visitExpr(ctx.expr())
         val orderSpec = when {
             ctx.dir == null -> null
             ctx.dir.type == PartiQLParser.ASC -> asc()
@@ -575,9 +655,9 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
 
     override fun visitGroupClause(ctx: PartiQLParser.GroupClauseContext) = PartiqlAst.build {
         val strategy = if (ctx.PARTIAL() != null) groupPartial() else groupFull()
-        val keys = visitOrEmpty(ctx.groupKey(), PartiqlAst.GroupKey::class)
+        val keys = ctx.groupKey().map { visitGroupKey(it) }
         val keyList = groupKeyList(keys)
-        val alias = visitOrNull(ctx.groupAlias(), PartiqlAst.Expr.Id::class).toPigSymbolPrimitive()
+        val alias = ctx.groupAlias()?.let { visitGroupAlias(it).toPigSymbolPrimitive() }
         groupBy_(strategy, keyList = keyList, groupAsAlias = alias, ctx.GROUP().getSourceMetaContainer())
     }
 
@@ -589,7 +669,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      *  This is to match the functionality of SqlParser, but this should likely be adjusted.
      */
     override fun visitGroupKey(ctx: PartiQLParser.GroupKeyContext) = PartiqlAst.build {
-        val expr = visit(ctx.key, PartiqlAst.Expr::class)
+        val expr = visit(ctx.key) as PartiqlAst.Expr
         val possibleLiteral = when (expr) {
             is PartiqlAst.Expr.Pos -> expr.expr
             is PartiqlAst.Expr.Neg -> expr.expr
@@ -604,7 +684,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
                 ErrorCode.PARSE_UNSUPPORTED_LITERALS_GROUPBY
             )
         }
-        val alias = visitOrNull(ctx.symbolPrimitive(), PartiqlAst.Expr.Id::class).toPigSymbolPrimitive()
+        val alias = ctx.symbolPrimitive()?.let { visitSymbolPrimitive(it).toPigSymbolPrimitive() }
         groupKey_(expr, asAlias = alias, expr.metas)
     }
 
@@ -615,8 +695,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      */
 
     override fun visitIntersect(ctx: PartiQLParser.IntersectContext) = PartiqlAst.build {
-        val lhs = visit(ctx.lhs, PartiqlAst.Expr::class)
-        val rhs = visit(ctx.rhs, PartiqlAst.Expr::class)
+        val lhs = visit(ctx.lhs) as PartiqlAst.Expr
+        val rhs = visit(ctx.rhs) as PartiqlAst.Expr
         val quantifier = if (ctx.ALL() != null) all() else distinct()
         val (intersect, metas) = when (ctx.OUTER()) {
             null -> intersect() to ctx.INTERSECT().getSourceMetaContainer()
@@ -626,8 +706,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitExcept(ctx: PartiQLParser.ExceptContext) = PartiqlAst.build {
-        val lhs = visit(ctx.lhs, PartiqlAst.Expr::class)
-        val rhs = visit(ctx.rhs, PartiqlAst.Expr::class)
+        val lhs = visit(ctx.lhs) as PartiqlAst.Expr
+        val rhs = visit(ctx.rhs) as PartiqlAst.Expr
         val quantifier = if (ctx.ALL() != null) all() else distinct()
         val (except, metas) = when (ctx.OUTER()) {
             null -> except() to ctx.EXCEPT().getSourceMetaContainer()
@@ -637,8 +717,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitUnion(ctx: PartiQLParser.UnionContext) = PartiqlAst.build {
-        val lhs = visit(ctx.lhs, PartiqlAst.Expr::class)
-        val rhs = visit(ctx.rhs, PartiqlAst.Expr::class)
+        val lhs = visit(ctx.lhs) as PartiqlAst.Expr
+        val rhs = visit(ctx.rhs) as PartiqlAst.Expr
         val quantifier = if (ctx.ALL() != null) all() else distinct()
         val (union, metas) = when (ctx.OUTER()) {
             null -> union() to ctx.UNION().getSourceMetaContainer()
@@ -654,25 +734,26 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      */
 
     override fun visitGpmlPattern(ctx: PartiQLParser.GpmlPatternContext) = PartiqlAst.build {
-        val selector = visitOrNull(ctx.matchSelector(), PartiqlAst.GraphMatchSelector::class)
+        val selector = ctx.matchSelector()?.let { visit(it) as PartiqlAst.GraphMatchSelector }
         val pattern = visitMatchPattern(ctx.matchPattern())
         gpmlPattern(selector, listOf(pattern))
     }
 
     override fun visitGpmlPatternList(ctx: PartiQLParser.GpmlPatternListContext) = PartiqlAst.build {
-        val selector = visitOrNull(ctx.matchSelector(), PartiqlAst.GraphMatchSelector::class)
+        val selector = ctx.matchSelector()?.let { visit(it) as PartiqlAst.GraphMatchSelector }
         val patterns = ctx.matchPattern().map { pattern -> visitMatchPattern(pattern) }
         gpmlPattern(selector, patterns)
     }
 
     override fun visitMatchPattern(ctx: PartiQLParser.MatchPatternContext) = PartiqlAst.build {
-        val parts = visitOrEmpty(ctx.graphPart(), PartiqlAst.GraphMatchPatternPart::class)
-        val restrictor = visitOrNull(ctx.restrictor, PartiqlAst.GraphMatchRestrictor::class)
-        val variable = visitOrNull(ctx.variable, PartiqlAst.Expr.Id::class)?.name
+        val parts = ctx.graphPart().map { visit(it) as PartiqlAst.GraphMatchPatternPart }
+        val restrictor = ctx.restrictor?.let { visitPatternRestrictor(it) }
+        val variable = ctx.variable?.let { visitPatternPathVariable(it).name }
         graphMatchPattern_(parts = parts, restrictor = restrictor, variable = variable)
     }
 
-    override fun visitPatternPathVariable(ctx: PartiQLParser.PatternPathVariableContext) = visitSymbolPrimitive(ctx.symbolPrimitive())
+    override fun visitPatternPathVariable(ctx: PartiQLParser.PatternPathVariableContext) =
+        visitSymbolPrimitive(ctx.symbolPrimitive())
 
     override fun visitSelectorBasic(ctx: PartiQLParser.SelectorBasicContext) = PartiqlAst.build {
         val metas = ctx.mod.getSourceMetaContainer()
@@ -700,37 +781,72 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         }
     }
 
-    override fun visitPatternPartLabel(ctx: PartiQLParser.PatternPartLabelContext) = visitSymbolPrimitive(ctx.symbolPrimitive())
+    override fun visitLabelSpecOr(ctx: PartiQLParser.LabelSpecOrContext): PartiqlAst.GraphLabelSpec =
+        PartiqlAst.build {
+            val lhs = visit(ctx.labelSpec()) as PartiqlAst.GraphLabelSpec
+            val rhs = visit(ctx.labelTerm()) as PartiqlAst.GraphLabelSpec
+            graphLabelDisj(lhs, rhs, ctx.VERTBAR().getSourceMetaContainer())
+        }
+
+    override fun visitLabelTermAnd(ctx: PartiQLParser.LabelTermAndContext): PartiqlAst.GraphLabelSpec =
+        PartiqlAst.build {
+            val lhs = visit(ctx.labelTerm()) as PartiqlAst.GraphLabelSpec
+            val rhs = visit(ctx.labelFactor()) as PartiqlAst.GraphLabelSpec
+            graphLabelConj(lhs, rhs, ctx.AMPERSAND().getSourceMetaContainer())
+        }
+
+    override fun visitLabelFactorNot(ctx: PartiQLParser.LabelFactorNotContext) = PartiqlAst.build {
+        val arg = visit(ctx.labelPrimary()) as PartiqlAst.GraphLabelSpec
+        graphLabelNegation(arg, ctx.BANG().getSourceMetaContainer())
+    }
+
+    override fun visitLabelPrimaryName(ctx: PartiQLParser.LabelPrimaryNameContext) = PartiqlAst.build {
+        val x = visitSymbolPrimitive(ctx.symbolPrimitive())
+        graphLabelName_(x.name, x.metas)
+    }
+
+    override fun visitLabelPrimaryWild(ctx: PartiQLParser.LabelPrimaryWildContext) = PartiqlAst.build {
+        graphLabelWildcard(ctx.PERCENT().getSourceMetaContainer())
+    }
+
+    override fun visitLabelPrimaryParen(ctx: PartiQLParser.LabelPrimaryParenContext) =
+        visit(ctx.labelSpec()) as PartiqlAst.GraphLabelSpec
 
     override fun visitPattern(ctx: PartiQLParser.PatternContext) = PartiqlAst.build {
-        val restrictor = visitOrNull(ctx.restrictor, PartiqlAst.GraphMatchRestrictor::class)
-        val variable = visitOrNull(ctx.variable, PartiqlAst.Expr.Id::class)?.name
-        val prefilter = visitOrNull(ctx.where, PartiqlAst.Expr::class)
-        val quantifier = visitOrNull(ctx.quantifier, PartiqlAst.GraphMatchQuantifier::class)
-        val parts = visitOrEmpty(ctx.graphPart(), PartiqlAst.GraphMatchPatternPart::class)
+        val restrictor = ctx.restrictor?.let { visitPatternRestrictor(it) }
+        val variable = ctx.variable?.let { visitPatternPathVariable(it).name }
+        val prefilter = ctx.where?.let { visitWhereClause(it) }
+        val quantifier = ctx.quantifier?.let { visitPatternQuantifier(it) }
+        val parts = ctx.graphPart().map { visit(it) as PartiqlAst.GraphMatchPatternPart }
         pattern(
-            graphMatchPattern_(parts = parts, variable = variable, restrictor = restrictor, quantifier = quantifier, prefilter = prefilter)
+            graphMatchPattern_(
+                parts = parts,
+                variable = variable,
+                restrictor = restrictor,
+                quantifier = quantifier,
+                prefilter = prefilter
+            )
         )
     }
 
     override fun visitEdgeAbbreviated(ctx: PartiQLParser.EdgeAbbreviatedContext) = PartiqlAst.build {
         val direction = visitEdgeAbbrev(ctx.edgeAbbrev())
-        val quantifier = visitOrNull(ctx.quantifier, PartiqlAst.GraphMatchQuantifier::class)
+        val quantifier = ctx.quantifier?.let { visitPatternQuantifier(it) }
         edge(direction = direction, quantifier = quantifier)
     }
 
     override fun visitEdgeWithSpec(ctx: PartiQLParser.EdgeWithSpecContext) = PartiqlAst.build {
-        val quantifier = visitOrNull(ctx.quantifier, PartiqlAst.GraphMatchQuantifier::class)
-        val edge = visitOrNull(ctx.edgeWSpec(), PartiqlAst.GraphMatchPatternPart.Edge::class)
+        val quantifier = ctx.quantifier?.let { visitPatternQuantifier(it) }
+        val edge = ctx.edgeWSpec()?.let { visit(it) as PartiqlAst.GraphMatchPatternPart.Edge }
         edge!!.copy(quantifier = quantifier)
     }
 
     override fun visitEdgeSpec(ctx: PartiQLParser.EdgeSpecContext) = PartiqlAst.build {
         val placeholderDirection = edgeRight()
-        val variable = visitOrNull(ctx.symbolPrimitive(), PartiqlAst.Expr.Id::class)?.name
-        val prefilter = visitOrNull(ctx.whereClause(), PartiqlAst.Expr::class)
-        val label = visitOrNull(ctx.patternPartLabel(), PartiqlAst.Expr.Id::class)?.name
-        edge_(direction = placeholderDirection, variable = variable, prefilter = prefilter, label = listOfNotNull(label))
+        val variable = ctx.symbolPrimitive()?.let { visitSymbolPrimitive(it).name }
+        val prefilter = ctx.whereClause()?.let { visitWhereClause(it) }
+        val label = ctx.labelSpec()?.let { visit(it) as PartiqlAst.GraphLabelSpec }
+        edge_(direction = placeholderDirection, variable = variable, prefilter = prefilter, label = label)
     }
 
     override fun visitEdgeSpecLeft(ctx: PartiQLParser.EdgeSpecLeftContext) = PartiqlAst.build {
@@ -748,10 +864,11 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         edge.copy(direction = edgeLeftOrRight())
     }
 
-    override fun visitEdgeSpecUndirectedBidirectional(ctx: PartiQLParser.EdgeSpecUndirectedBidirectionalContext) = PartiqlAst.build {
-        val edge = visitEdgeSpec(ctx.edgeSpec())
-        edge.copy(direction = edgeLeftOrUndirectedOrRight())
-    }
+    override fun visitEdgeSpecUndirectedBidirectional(ctx: PartiQLParser.EdgeSpecUndirectedBidirectionalContext) =
+        PartiqlAst.build {
+            val edge = visitEdgeSpec(ctx.edgeSpec())
+            edge.copy(direction = edgeLeftOrUndirectedOrRight())
+        }
 
     override fun visitEdgeSpecUndirected(ctx: PartiQLParser.EdgeSpecUndirectedContext) = PartiqlAst.build {
         val edge = visitEdgeSpec(ctx.edgeSpec())
@@ -791,10 +908,10 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitNode(ctx: PartiQLParser.NodeContext) = PartiqlAst.build {
-        val variable = visitOrNull(ctx.symbolPrimitive(), PartiqlAst.Expr.Id::class)?.name
-        val prefilter = visitOrNull(ctx.whereClause(), PartiqlAst.Expr::class)
-        val label = visitOrNull(ctx.patternPartLabel(), PartiqlAst.Expr.Id::class)?.name
-        node_(variable = variable, prefilter = prefilter, label = listOfNotNull(label))
+        val variable = ctx.symbolPrimitive()?.let { visitSymbolPrimitive(it).name }
+        val prefilter = ctx.whereClause()?.let { visitWhereClause(it) }
+        val label = ctx.labelSpec()?.let { visit(it) as PartiqlAst.GraphLabelSpec }
+        node_(variable = variable, prefilter = prefilter, label = label)
     }
 
     override fun visitPatternRestrictor(ctx: PartiQLParser.PatternRestrictorContext) = PartiqlAst.build {
@@ -813,62 +930,84 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      *
      */
 
-    override fun visitFromClause(ctx: PartiQLParser.FromClauseContext) = visit(ctx.tableReference(), PartiqlAst.FromSource::class)
+    override fun visitFromClause(ctx: PartiQLParser.FromClauseContext) =
+        visit(ctx.tableReference()) as PartiqlAst.FromSource
 
     override fun visitTableBaseRefClauses(ctx: PartiQLParser.TableBaseRefClausesContext) = PartiqlAst.build {
-        val expr = visit(ctx.source, PartiqlAst.Expr::class)
-        val (asAlias, atAlias, byAlias) = visitNullableItems(listOf(ctx.asIdent(), ctx.atIdent(), ctx.byIdent()), PartiqlAst.Expr.Id::class)
-        scan_(expr, asAlias = asAlias.toPigSymbolPrimitive(), byAlias = byAlias.toPigSymbolPrimitive(), atAlias = atAlias.toPigSymbolPrimitive(), metas = expr.metas)
+        val expr = visit(ctx.source) as PartiqlAst.Expr
+        scan_(
+            expr,
+            asAlias = ctx.asIdent()?.let { visitAsIdent(it).toPigSymbolPrimitive() },
+            atAlias = ctx.atIdent()?.let { visitAtIdent(it).toPigSymbolPrimitive() },
+            byAlias = ctx.byIdent()?.let { visitByIdent(it).toPigSymbolPrimitive() },
+            metas = expr.metas
+        )
     }
 
     override fun visitTableBaseRefMatch(ctx: PartiQLParser.TableBaseRefMatchContext) = PartiqlAst.build {
-        val expr = visit(ctx.source, PartiqlAst.Expr::class)
-        val (asAlias, atAlias, byAlias) = visitNullableItems(listOf(ctx.asIdent(), ctx.atIdent(), ctx.byIdent()), PartiqlAst.Expr.Id::class)
-        scan_(expr, asAlias = asAlias.toPigSymbolPrimitive(), byAlias = byAlias.toPigSymbolPrimitive(), atAlias = atAlias.toPigSymbolPrimitive(), metas = expr.metas)
+        val expr = visit(ctx.source) as PartiqlAst.Expr
+        scan_(
+            expr,
+            asAlias = ctx.asIdent()?.let { visitAsIdent(it).toPigSymbolPrimitive() },
+            atAlias = ctx.atIdent()?.let { visitAtIdent(it).toPigSymbolPrimitive() },
+            byAlias = ctx.byIdent()?.let { visitByIdent(it).toPigSymbolPrimitive() },
+            metas = expr.metas
+        )
     }
 
     override fun visitFromClauseSimpleExplicit(ctx: PartiQLParser.FromClauseSimpleExplicitContext) = PartiqlAst.build {
         val expr = visitPathSimple(ctx.pathSimple())
-        val (asAlias, atAlias, byAlias) = visitNullableItems(listOf(ctx.asIdent(), ctx.atIdent(), ctx.byIdent()), PartiqlAst.Expr.Id::class)
-        scan_(expr, asAlias = asAlias.toPigSymbolPrimitive(), byAlias = byAlias.toPigSymbolPrimitive(), atAlias = atAlias.toPigSymbolPrimitive(), metas = expr.metas)
+        scan_(
+            expr,
+            asAlias = ctx.asIdent()?.let { visitAsIdent(it).toPigSymbolPrimitive() },
+            atAlias = ctx.atIdent()?.let { visitAtIdent(it).toPigSymbolPrimitive() },
+            byAlias = ctx.byIdent()?.let { visitByIdent(it).toPigSymbolPrimitive() },
+            metas = expr.metas
+        )
     }
 
     override fun visitTableUnpivot(ctx: PartiQLParser.TableUnpivotContext) = PartiqlAst.build {
         val expr = visitExpr(ctx.expr())
         val metas = ctx.UNPIVOT().getSourceMetaContainer()
-        val (asAlias, atAlias, byAlias) = visitNullableItems(listOf(ctx.asIdent(), ctx.atIdent(), ctx.byIdent()), PartiqlAst.Expr.Id::class)
-        unpivot_(expr, asAlias = asAlias.toPigSymbolPrimitive(), atAlias = atAlias.toPigSymbolPrimitive(), byAlias = byAlias.toPigSymbolPrimitive(), metas)
+        unpivot_(
+            expr,
+            asAlias = ctx.asIdent()?.let { visitAsIdent(it).toPigSymbolPrimitive() },
+            atAlias = ctx.atIdent()?.let { visitAtIdent(it).toPigSymbolPrimitive() },
+            byAlias = ctx.byIdent()?.let { visitByIdent(it).toPigSymbolPrimitive() },
+            metas
+        )
     }
 
     override fun visitTableCrossJoin(ctx: PartiQLParser.TableCrossJoinContext) = PartiqlAst.build {
-        val lhs = visit(ctx.lhs, PartiqlAst.FromSource::class)
+        val lhs = visit(ctx.lhs) as PartiqlAst.FromSource
         val joinType = visitJoinType(ctx.joinType())
-        val rhs = visit(ctx.rhs, PartiqlAst.FromSource::class)
+        val rhs = visit(ctx.rhs) as PartiqlAst.FromSource
         val metas = metaContainerOf(IsImplictJoinMeta.instance) + joinType.metas
         join(joinType, lhs, rhs, metas = metas)
     }
 
     override fun visitTableQualifiedJoin(ctx: PartiQLParser.TableQualifiedJoinContext) = PartiqlAst.build {
-        val lhs = visit(ctx.lhs, PartiqlAst.FromSource::class)
+        val lhs = visit(ctx.lhs) as PartiqlAst.FromSource
         val joinType = visitJoinType(ctx.joinType())
-        val rhs = visit(ctx.rhs, PartiqlAst.FromSource::class)
-        val condition = visitOrNull(ctx.joinSpec(), PartiqlAst.Expr::class)
+        val rhs = visit(ctx.rhs) as PartiqlAst.FromSource
+        val condition = ctx.joinSpec()?.let { visitJoinSpec(it) }
         join(joinType, lhs, rhs, condition, metas = joinType.metas)
     }
 
     override fun visitTableBaseRefSymbol(ctx: PartiQLParser.TableBaseRefSymbolContext) = PartiqlAst.build {
-        val expr = visit(ctx.source, PartiqlAst.Expr::class)
-        val name = visitOrNull(ctx.symbolPrimitive(), PartiqlAst.Expr.Id::class)
-        scan_(expr, name.toPigSymbolPrimitive(), metas = expr.metas)
+        val expr = visit(ctx.source) as PartiqlAst.Expr
+        val name = ctx.symbolPrimitive()?.let { visitSymbolPrimitive(it).toPigSymbolPrimitive() }
+        scan_(expr, name, metas = expr.metas)
     }
 
     override fun visitFromClauseSimpleImplicit(ctx: PartiQLParser.FromClauseSimpleImplicitContext) = PartiqlAst.build {
         val path = visitPathSimple(ctx.pathSimple())
-        val name = visitOrNull(ctx.symbolPrimitive(), PartiqlAst.Expr.Id::class)?.name
+        val name = ctx.symbolPrimitive()?.let { visitSymbolPrimitive(it).name }
         scan_(path, name, metas = path.metas)
     }
 
-    override fun visitTableWrapped(ctx: PartiQLParser.TableWrappedContext): PartiqlAst.PartiqlAstNode = visit(ctx.tableReference())
+    override fun visitTableWrapped(ctx: PartiQLParser.TableWrappedContext): PartiqlAst.PartiqlAstNode =
+        visit(ctx.tableReference())
 
     override fun visitJoinSpec(ctx: PartiQLParser.JoinSpecContext) = visitExpr(ctx.expr())
 
@@ -885,7 +1024,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         }
     }
 
-    override fun visitJoinRhsTableJoined(ctx: PartiQLParser.JoinRhsTableJoinedContext) = visit(ctx.tableReference(), PartiqlAst.FromSource::class)
+    override fun visitJoinRhsTableJoined(ctx: PartiQLParser.JoinRhsTableJoinedContext) =
+        visit(ctx.tableReference()) as PartiqlAst.FromSource
 
     /**
      * SIMPLE EXPRESSIONS
@@ -897,13 +1037,17 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
 
     override fun visitNot(ctx: PartiQLParser.NotContext) = visitUnaryOperation(ctx.rhs, ctx.op, null)
 
-    override fun visitMathOp00(ctx: PartiQLParser.MathOp00Context): PartiqlAst.PartiqlAstNode = visitBinaryOperation(ctx.lhs, ctx.rhs, ctx.op, ctx.parent)
+    override fun visitMathOp00(ctx: PartiQLParser.MathOp00Context): PartiqlAst.PartiqlAstNode =
+        visitBinaryOperation(ctx.lhs, ctx.rhs, ctx.op, ctx.parent)
 
-    override fun visitMathOp01(ctx: PartiQLParser.MathOp01Context): PartiqlAst.PartiqlAstNode = visitBinaryOperation(ctx.lhs, ctx.rhs, ctx.op, ctx.parent)
+    override fun visitMathOp01(ctx: PartiQLParser.MathOp01Context): PartiqlAst.PartiqlAstNode =
+        visitBinaryOperation(ctx.lhs, ctx.rhs, ctx.op, ctx.parent)
 
-    override fun visitMathOp02(ctx: PartiQLParser.MathOp02Context): PartiqlAst.PartiqlAstNode = visitBinaryOperation(ctx.lhs, ctx.rhs, ctx.op, ctx.parent)
+    override fun visitMathOp02(ctx: PartiQLParser.MathOp02Context): PartiqlAst.PartiqlAstNode =
+        visitBinaryOperation(ctx.lhs, ctx.rhs, ctx.op, ctx.parent)
 
-    override fun visitValueExpr(ctx: PartiQLParser.ValueExprContext) = visitUnaryOperation(ctx.rhs, ctx.sign, ctx.parent)
+    override fun visitValueExpr(ctx: PartiQLParser.ValueExprContext) =
+        visitUnaryOperation(ctx.rhs, ctx.sign, ctx.parent)
 
     /**
      *
@@ -911,7 +1055,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      *
      */
 
-    override fun visitPredicateComparison(ctx: PartiQLParser.PredicateComparisonContext) = visitBinaryOperation(ctx.lhs, ctx.rhs, ctx.op)
+    override fun visitPredicateComparison(ctx: PartiQLParser.PredicateComparisonContext) =
+        visitBinaryOperation(ctx.lhs, ctx.rhs, ctx.op)
 
     /**
      * Note: This predicate can take a wrapped expression on the RHS, and it will wrap it in a LIST. However, if the
@@ -925,9 +1070,9 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
                 possibleRhs
             else list(possibleRhs, metas = possibleRhs.metas + metaContainerOf(IsListParenthesizedMeta))
         } else {
-            visit(ctx.rhs, PartiqlAst.Expr::class)
+            visit(ctx.rhs) as PartiqlAst.Expr
         }
-        val lhs = visit(ctx.lhs, PartiqlAst.Expr::class)
+        val lhs = visit(ctx.lhs) as PartiqlAst.Expr
         val args = listOf(lhs, rhs)
         val inCollection = inCollection(args, ctx.IN().getSourceMetaContainer())
         if (ctx.NOT() == null) return@build inCollection
@@ -935,23 +1080,23 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitPredicateIs(ctx: PartiQLParser.PredicateIsContext) = PartiqlAst.build {
-        val lhs = visit(ctx.lhs, PartiqlAst.Expr::class)
-        val rhs = visit(ctx.type(), PartiqlAst.Type::class)
+        val lhs = visit(ctx.lhs) as PartiqlAst.Expr
+        val rhs = visit(ctx.type()) as PartiqlAst.Type
         val isType = isType(lhs, rhs, ctx.IS().getSourceMetaContainer())
         if (ctx.NOT() == null) return@build isType
         not(isType, ctx.NOT().getSourceMetaContainer() + metaContainerOf(LegacyLogicalNotMeta.instance))
     }
 
     override fun visitPredicateBetween(ctx: PartiQLParser.PredicateBetweenContext) = PartiqlAst.build {
-        val args = visitOrEmpty(listOf(ctx.lhs, ctx.lower, ctx.upper), PartiqlAst.Expr::class)
+        val args = listOf(ctx.lhs, ctx.lower, ctx.upper).map { visit(it) as PartiqlAst.Expr }
         val between = between(args[0], args[1], args[2], ctx.BETWEEN().getSourceMetaContainer())
         if (ctx.NOT() == null) return@build between
         not(between, ctx.NOT().getSourceMetaContainer() + metaContainerOf(LegacyLogicalNotMeta.instance))
     }
 
     override fun visitPredicateLike(ctx: PartiQLParser.PredicateLikeContext) = PartiqlAst.build {
-        val args = visitOrEmpty(listOf(ctx.lhs, ctx.rhs), PartiqlAst.Expr::class)
-        val escape = visitOrNull(ctx.escape, PartiqlAst.Expr::class)
+        val args = listOf(ctx.lhs, ctx.rhs).map { visit(it) as PartiqlAst.Expr }
+        val escape = ctx.escape?.let { visitExpr(it) }
         val like = like(args[0], args[1], escape, ctx.LIKE().getSourceMetaContainer())
         if (ctx.NOT() == null) return@build like
         not(like, metas = ctx.NOT().getSourceMetaContainer() + metaContainerOf(LegacyLogicalNotMeta.instance))
@@ -963,21 +1108,24 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      *
      */
 
-    override fun visitExprTermWrappedQuery(ctx: PartiQLParser.ExprTermWrappedQueryContext) = visit(ctx.expr(), PartiqlAst.Expr::class)
+    override fun visitExprTermWrappedQuery(ctx: PartiQLParser.ExprTermWrappedQueryContext) =
+        visitExpr(ctx.expr())
 
-    override fun visitVariableIdentifier(ctx: PartiQLParser.VariableIdentifierContext): PartiqlAst.PartiqlAstNode = PartiqlAst.build {
-        val metas = ctx.ident.getSourceMetaContainer()
-        val qualifier = if (ctx.qualifier == null) unqualified() else localsFirst()
-        val sensitivity = if (ctx.ident.type == PartiQLParser.IDENTIFIER) caseInsensitive() else caseSensitive()
-        id(ctx.ident.getStringValue(), sensitivity, qualifier, metas)
-    }
+    override fun visitVariableIdentifier(ctx: PartiQLParser.VariableIdentifierContext): PartiqlAst.PartiqlAstNode =
+        PartiqlAst.build {
+            val metas = ctx.ident.getSourceMetaContainer()
+            val qualifier = if (ctx.qualifier == null) unqualified() else localsFirst()
+            val sensitivity = if (ctx.ident.type == PartiQLParser.IDENTIFIER) caseInsensitive() else caseSensitive()
+            id(ctx.ident.getStringValue(), sensitivity, qualifier, metas)
+        }
 
-    override fun visitVariableKeyword(ctx: PartiQLParser.VariableKeywordContext): PartiqlAst.PartiqlAstNode = PartiqlAst.build {
-        val keyword = ctx.nonReservedKeywords().start.text
-        val metas = ctx.start.getSourceMetaContainer()
-        val qualifier = ctx.qualifier?.let { localsFirst() } ?: unqualified()
-        id(keyword, caseInsensitive(), qualifier, metas)
-    }
+    override fun visitVariableKeyword(ctx: PartiQLParser.VariableKeywordContext): PartiqlAst.PartiqlAstNode =
+        PartiqlAst.build {
+            val keyword = ctx.nonReservedKeywords().start.text
+            val metas = ctx.start.getSourceMetaContainer()
+            val qualifier = ctx.qualifier?.let { localsFirst() } ?: unqualified()
+            id(keyword, caseInsensitive(), qualifier, metas)
+        }
 
     override fun visitParameter(ctx: PartiQLParser.ParameterContext) = PartiqlAst.build {
         val parameterIndex = parameterIndexes[ctx.QUESTION_MARK().symbol.tokenIndex]
@@ -986,7 +1134,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitSequenceConstructor(ctx: PartiQLParser.SequenceConstructorContext) = PartiqlAst.build {
-        val expressions = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val expressions = ctx.expr().map { visitExpr(it) }
         val metas = ctx.datatype.getSourceMetaContainer()
         when (ctx.datatype.type) {
             PartiQLParser.LIST -> list(expressions, metas)
@@ -1002,7 +1150,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitPathStepIndexExpr(ctx: PartiQLParser.PathStepIndexExprContext) = PartiqlAst.build {
-        val expr = visit(ctx.key, PartiqlAst.Expr::class)
+        val expr = visitExpr(ctx.key)
         val metas = expr.metas + metaContainerOf(IsPathIndexMeta.instance)
         pathExpr(expr, PartiqlAst.CaseSensitivity.CaseSensitive(), metas)
     }
@@ -1030,17 +1178,17 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitValues(ctx: PartiQLParser.ValuesContext) = PartiqlAst.build {
-        val rows = visitOrEmpty(ctx.valueRow(), PartiqlAst.Expr.List::class)
+        val rows = ctx.valueRow().map { visitValueRow(it) }
         bag(rows, ctx.VALUES().getSourceMetaContainer() + metaContainerOf(IsValuesExprMeta.instance))
     }
 
     override fun visitValueRow(ctx: PartiQLParser.ValueRowContext) = PartiqlAst.build {
-        val expressions = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val expressions = ctx.expr().map { visitExpr(it) }
         list(expressions, metas = ctx.PAREN_LEFT().getSourceMetaContainer() + metaContainerOf(IsListParenthesizedMeta))
     }
 
     override fun visitValueList(ctx: PartiQLParser.ValueListContext) = PartiqlAst.build {
-        val expressions = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val expressions = ctx.expr().map { visitExpr(it) }
         list(expressions, metas = ctx.PAREN_LEFT().getSourceMetaContainer() + metaContainerOf(IsListParenthesizedMeta))
     }
 
@@ -1058,7 +1206,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     }
 
     override fun visitCoalesce(ctx: PartiQLParser.CoalesceContext) = PartiqlAst.build {
-        val expressions = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val expressions = ctx.expr().map { visitExpr(it) }
         val metas = ctx.COALESCE().getSourceMetaContainer()
         coalesce(expressions, metas)
     }
@@ -1067,7 +1215,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         val pairs = ctx.whens.indices.map { i ->
             exprPair(visitExpr(ctx.whens[i]), visitExpr(ctx.thens[i]))
         }
-        val elseExpr = visitOrNull(ctx.else_, PartiqlAst.Expr::class)
+        val elseExpr = ctx.else_?.let { visitExpr(it) }
         val caseMeta = ctx.CASE().getSourceMetaContainer()
         when (ctx.case_) {
             null -> searchedCase(exprPairList(pairs), elseExpr, metas = caseMeta)
@@ -1077,35 +1225,35 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
 
     override fun visitCast(ctx: PartiQLParser.CastContext) = PartiqlAst.build {
         val expr = visitExpr(ctx.expr())
-        val type = visit(ctx.type(), PartiqlAst.Type::class)
+        val type = visit(ctx.type()) as PartiqlAst.Type
         val metas = ctx.CAST().getSourceMetaContainer()
         cast(expr, type, metas)
     }
 
     override fun visitCanCast(ctx: PartiQLParser.CanCastContext) = PartiqlAst.build {
         val expr = visitExpr(ctx.expr())
-        val type = visit(ctx.type(), PartiqlAst.Type::class)
+        val type = visit(ctx.type()) as PartiqlAst.Type
         val metas = ctx.CAN_CAST().getSourceMetaContainer()
         canCast(expr, type, metas)
     }
 
     override fun visitCanLosslessCast(ctx: PartiQLParser.CanLosslessCastContext) = PartiqlAst.build {
         val expr = visitExpr(ctx.expr())
-        val type = visit(ctx.type(), PartiqlAst.Type::class)
+        val type = visit(ctx.type()) as PartiqlAst.Type
         val metas = ctx.CAN_LOSSLESS_CAST().getSourceMetaContainer()
         canLosslessCast(expr, type, metas)
     }
 
     override fun visitFunctionCallIdent(ctx: PartiQLParser.FunctionCallIdentContext) = PartiqlAst.build {
         val name = ctx.name.getString().lowercase()
-        val args = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val args = ctx.expr().map { visitExpr(it) }
         val metas = ctx.name.getSourceMetaContainer()
         call(name, args = args, metas = metas)
     }
 
     override fun visitFunctionCallReserved(ctx: PartiQLParser.FunctionCallReservedContext) = PartiqlAst.build {
         val name = ctx.name.text.lowercase()
-        val args = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val args = ctx.expr().map { visitExpr(it) }
         val metas = ctx.name.getSourceMetaContainer()
         call(name, args = args, metas = metas)
     }
@@ -1115,26 +1263,26 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
             throw ctx.dt.err("Expected one of: ${DateTimePart.values()}", ErrorCode.PARSE_EXPECTED_DATE_TIME_PART)
         }
         val datetimePart = lit(ionSymbol(ctx.dt.text))
-        val secondaryArgs = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val secondaryArgs = ctx.expr().map { visitExpr(it) }
         val args = listOf(datetimePart) + secondaryArgs
         val metas = ctx.func.getSourceMetaContainer()
         call(ctx.func.text.lowercase(), args, metas)
     }
 
     override fun visitSubstring(ctx: PartiQLParser.SubstringContext) = PartiqlAst.build {
-        val args = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val args = ctx.expr().map { visitExpr(it) }
         val metas = ctx.SUBSTRING().getSourceMetaContainer()
         call(ctx.SUBSTRING().text.lowercase(), args, metas)
     }
 
     override fun visitPosition(ctx: PartiQLParser.PositionContext) = PartiqlAst.build {
-        val args = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val args = ctx.expr().map { visitExpr(it) }
         val metas = ctx.POSITION().getSourceMetaContainer()
         call(ctx.POSITION().text.lowercase(), args, metas)
     }
 
     override fun visitOverlay(ctx: PartiQLParser.OverlayContext) = PartiqlAst.build {
-        val args = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val args = ctx.expr().map { visitExpr(it) }
         val metas = ctx.OVERLAY().getSourceMetaContainer()
         call(ctx.OVERLAY().text.lowercase(), args, metas)
     }
@@ -1150,10 +1298,11 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
 
     override fun visitExtract(ctx: PartiQLParser.ExtractContext) = PartiqlAst.build {
         if (DateTimePart.safeValueOf(ctx.IDENTIFIER().text) == null) {
-            throw ctx.IDENTIFIER().err("Expected one of: ${DateTimePart.values()}", ErrorCode.PARSE_EXPECTED_DATE_TIME_PART)
+            throw ctx.IDENTIFIER()
+                .err("Expected one of: ${DateTimePart.values()}", ErrorCode.PARSE_EXPECTED_DATE_TIME_PART)
         }
         val datetimePart = lit(ionSymbol(ctx.IDENTIFIER().text))
-        val timeExpr = visit(ctx.rhs, PartiqlAst.Expr::class)
+        val timeExpr = visitExpr(ctx.rhs)
         val args = listOf(datetimePart, timeExpr)
         val metas = ctx.EXTRACT().getSourceMetaContainer()
         call(ctx.EXTRACT().text.lowercase(), args, metas)
@@ -1176,9 +1325,11 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
                 if (isTrimSpec) ctx.mod.toSymbol() to null
                 else null to id(possibleModText!!, caseInsensitive(), unqualified(), ctx.mod.getSourceMetaContainer())
             }
+
             ctx.mod == null && ctx.sub != null -> {
                 null to visitExpr(ctx.sub)
             }
+
             ctx.mod != null && ctx.sub != null -> {
                 if (isTrimSpec) ctx.mod.toSymbol() to visitExpr(ctx.sub)
                 // todo we need to decide if it should be an evaluator error or a parser error
@@ -1192,6 +1343,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
                     )
                 }
             }
+
             else -> null to null
         }
 
@@ -1216,7 +1368,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      */
 
     override fun visitLagLeadFunction(ctx: PartiQLParser.LagLeadFunctionContext) = PartiqlAst.build {
-        val args = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val args = ctx.expr().map { visitExpr(it) }
         val over = visitOver(ctx.over())
         // LAG and LEAD will require a Window ORDER BY
         if (over.orderBy == null) {
@@ -1231,20 +1383,24 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         val metas = ctx.func.getSourceMetaContainer()
         callWindow(ctx.func.text.lowercase(), over, args, metas)
     }
+
     override fun visitOver(ctx: PartiQLParser.OverContext) = PartiqlAst.build {
-        val windowPartitionList = if (ctx.windowPartitionList() != null) visitWindowPartitionList(ctx.windowPartitionList()) else null
-        val windowSortSpecList = if (ctx.windowSortSpecList() != null) visitWindowSortSpecList(ctx.windowSortSpecList()) else null
+        val windowPartitionList =
+            if (ctx.windowPartitionList() != null) visitWindowPartitionList(ctx.windowPartitionList()) else null
+        val windowSortSpecList =
+            if (ctx.windowSortSpecList() != null) visitWindowSortSpecList(ctx.windowSortSpecList()) else null
         val metas = ctx.OVER().getSourceMetaContainer()
         over(windowPartitionList, windowSortSpecList, metas)
     }
+
     override fun visitWindowPartitionList(ctx: PartiQLParser.WindowPartitionListContext) = PartiqlAst.build {
-        val args = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val args = ctx.expr().map { visitExpr(it) }
         val metas = ctx.PARTITION().getSourceMetaContainer()
         windowPartitionList(args, metas)
     }
 
     override fun visitWindowSortSpecList(ctx: PartiQLParser.WindowSortSpecListContext) = PartiqlAst.build {
-        val sortSpecList = visitOrEmpty(ctx.orderSortSpec(), PartiqlAst.SortSpec::class)
+        val sortSpecList = ctx.orderSortSpec().map { visitOrderSortSpec(it) }
         val metas = ctx.ORDER().getSourceMetaContainer()
         windowSortSpecList(sortSpecList, metas)
     }
@@ -1256,7 +1412,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      */
 
     override fun visitBag(ctx: PartiQLParser.BagContext) = PartiqlAst.build {
-        val exprList = visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class)
+        val exprList = ctx.expr().map { visitExpr(it) }
         bag(exprList, ctx.ANGLE_DOUBLE_LEFT().getSourceMetaContainer())
     }
 
@@ -1276,7 +1432,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
 
     override fun visitArray(ctx: PartiQLParser.ArrayContext) = PartiqlAst.build {
         val metas = ctx.BRACKET_LEFT().getSourceMetaContainer()
-        list(visitOrEmpty(ctx.expr(), PartiqlAst.Expr::class), metas)
+        list(ctx.expr().map { visitExpr(it) }, metas)
     }
 
     override fun visitLiteralNull(ctx: PartiQLParser.LiteralNullContext) = PartiqlAst.build {
@@ -1318,7 +1474,8 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
     override fun visitLiteralDate(ctx: PartiQLParser.LiteralDateContext) = PartiqlAst.build {
         val dateString = ctx.LITERAL_STRING().getStringValue()
         if (DATE_PATTERN_REGEX.matches(dateString).not()) {
-            throw ctx.LITERAL_STRING().err("Expected DATE string to be of the format yyyy-MM-dd", ErrorCode.PARSE_INVALID_DATE_STRING)
+            throw ctx.LITERAL_STRING()
+                .err("Expected DATE string to be of the format yyyy-MM-dd", ErrorCode.PARSE_INVALID_DATE_STRING)
         }
         try {
             LocalDate.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE)
@@ -1339,8 +1496,16 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         }
     }
 
+    override fun visitLiteralTimestamp(ctx: PartiQLParser.LiteralTimestampContext): PartiqlAst.PartiqlAstNode {
+        val (timestamp, precision) = getTimestampStringAndPrecision(ctx.LITERAL_STRING(), ctx.LITERAL_INTEGER())
+        return when (ctx.WITH()) {
+            null -> getTimestampDynamic(timestamp, precision, ctx.LITERAL_STRING())
+            else -> getTimestampWithTimezone(timestamp, precision, ctx.LITERAL_STRING())
+        }
+    }
+
     override fun visitTuple(ctx: PartiQLParser.TupleContext) = PartiqlAst.build {
-        val pairs = visitOrEmpty(ctx.pair(), PartiqlAst.ExprPair::class)
+        val pairs = ctx.pair().map { visitPair(it) }
         val metas = ctx.BRACE_LEFT().getSourceMetaContainer()
         struct(pairs, metas)
     }
@@ -1375,7 +1540,6 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
             PartiQLParser.BIGINT -> integer8Type(metas)
             PartiQLParser.REAL -> realType(metas)
             PartiQLParser.DOUBLE -> doublePrecisionType(metas)
-            PartiQLParser.TIMESTAMP -> timestampType(metas)
             PartiQLParser.CHAR -> characterType(metas = metas)
             PartiQLParser.CHARACTER -> characterType(metas = metas)
             PartiQLParser.MISSING -> missingType(metas)
@@ -1431,8 +1595,15 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         if (precision != null && (precision < 0 || precision > MAX_PRECISION_FOR_TIME)) {
             throw ctx.precision.err("Unsupported precision", ErrorCode.PARSE_INVALID_PRECISION_FOR_TIME)
         }
-        if (ctx.WITH() == null) return@build timeType(precision)
-        timeWithTimeZoneType(precision)
+        val hasTimeZone = ctx.WITH() != null
+        when (ctx.datatype.type) {
+            PartiQLParser.TIME -> if (hasTimeZone) timeWithTimeZoneType(precision) else timeType(precision)
+            PartiQLParser.TIMESTAMP -> if (hasTimeZone) timestampWithTimeZoneType(precision) else timestampType(
+                precision
+            )
+
+            else -> throw ParserException("Unknown datatype", ErrorCode.PARSE_UNEXPECTED_TOKEN, PropertyValueMap())
+        }
     }
 
     override fun visitTypeCustom(ctx: PartiQLParser.TypeCustomContext) = PartiqlAst.build {
@@ -1445,47 +1616,12 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         customType_(SymbolPrimitive(customName, metas), metas)
     }
 
-    /**
-     * NOT OVERRIDDEN
-     * Explicitly defining the override helps by showing the user (via the IDE) which methods remain to be overridden.
-     */
-
-    override fun visitTerminal(node: TerminalNode?): PartiqlAst.PartiqlAstNode = super.visitTerminal(node)
-    override fun shouldVisitNextChild(node: RuleNode?, currentResult: PartiqlAst.PartiqlAstNode?) = super.shouldVisitNextChild(node, currentResult)
-    override fun visitErrorNode(node: ErrorNode?): PartiqlAst.PartiqlAstNode = super.visitErrorNode(node)
-    override fun visitChildren(node: RuleNode?): PartiqlAst.PartiqlAstNode = super.visitChildren(node)
-    override fun visitExprPrimaryBase(ctx: PartiQLParser.ExprPrimaryBaseContext?): PartiqlAst.PartiqlAstNode = super.visitExprPrimaryBase(ctx)
-    override fun visitExprTermBase(ctx: PartiQLParser.ExprTermBaseContext?): PartiqlAst.PartiqlAstNode = super.visitExprTermBase(ctx)
-    override fun visitCollection(ctx: PartiQLParser.CollectionContext?): PartiqlAst.PartiqlAstNode = super.visitCollection(ctx)
-    override fun visitPredicateBase(ctx: PartiQLParser.PredicateBaseContext?): PartiqlAst.PartiqlAstNode = super.visitPredicateBase(ctx)
-    override fun visitTableNonJoin(ctx: PartiQLParser.TableNonJoinContext?): PartiqlAst.PartiqlAstNode = super.visitTableNonJoin(ctx)
-    override fun visitTableRefBase(ctx: PartiQLParser.TableRefBaseContext?): PartiqlAst.PartiqlAstNode = super.visitTableRefBase(ctx)
-    override fun visitJoinRhsBase(ctx: PartiQLParser.JoinRhsBaseContext?): PartiqlAst.PartiqlAstNode = super.visitJoinRhsBase(ctx)
-    override fun visitConflictTarget(ctx: PartiQLParser.ConflictTargetContext?): PartiqlAst.PartiqlAstNode = super.visitConflictTarget(ctx)
-
     /**
      *
      * HELPER METHODS
      *
      */
 
-    private fun <T : PartiqlAst.PartiqlAstNode> visitOrEmpty(ctx: List<ParserRuleContext>?, clazz: KClass<T>): List<T> = when {
-        ctx.isNullOrEmpty() -> emptyList()
-        else -> ctx.map { clazz.cast(visit(it)) }
-    }
-
-    private fun <T : PartiqlAst.PartiqlAstNode> visitNullableItems(ctx: List<ParserRuleContext>?, clazz: KClass<T>): List<T?> = when {
-        ctx.isNullOrEmpty() -> emptyList()
-        else -> ctx.map { visitOrNull(it, clazz) }
-    }
-
-    private fun <T : PartiqlAst.PartiqlAstNode> visitOrNull(ctx: ParserRuleContext?, clazz: KClass<T>): T? = when (ctx) {
-        null -> null
-        else -> clazz.cast(visit(ctx))
-    }
-
-    private fun <T : PartiqlAst.PartiqlAstNode> visit(ctx: ParserRuleContext, clazz: KClass<T>): T = clazz.cast(visit(ctx))
-
     private fun TerminalNode?.getSourceMetaContainer(): MetaContainer {
         if (this == null) return emptyMetaContainer()
         val metas = this.getSourceMetas()
@@ -1505,9 +1641,14 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         return SourceLocationMeta(this.line.toLong(), this.charPositionInLine.toLong() + 1, length.toLong())
     }
 
-    private fun visitBinaryOperation(lhs: ParserRuleContext?, rhs: ParserRuleContext?, op: Token?, parent: ParserRuleContext? = null) = PartiqlAst.build {
-        if (parent != null) return@build visit(parent, PartiqlAst.Expr::class)
-        val args = visitOrEmpty(listOf(lhs!!, rhs!!), PartiqlAst.Expr::class)
+    private fun visitBinaryOperation(
+        lhs: ParserRuleContext?,
+        rhs: ParserRuleContext?,
+        op: Token?,
+        parent: ParserRuleContext? = null
+    ) = PartiqlAst.build {
+        if (parent != null) return@build visit(parent) as PartiqlAst.Expr
+        val args = listOf(lhs!!, rhs!!).map { visit(it) as PartiqlAst.Expr }
         val metas = op.getSourceMetaContainer()
         when (op!!.type) {
             PartiQLParser.AND -> and(args, metas)
@@ -1528,47 +1669,54 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         }
     }
 
-    private fun visitUnaryOperation(operand: ParserRuleContext?, op: Token?, parent: ParserRuleContext? = null) = PartiqlAst.build {
-        if (parent != null) return@build visit(parent, PartiqlAst.Expr::class)
-        val arg = visit(operand!!, PartiqlAst.Expr::class)
-        val metas = op.getSourceMetaContainer()
-        when (op!!.type) {
-            PartiQLParser.PLUS -> {
-                when {
-                    arg !is PartiqlAst.Expr.Lit -> pos(arg, metas)
-                    arg.value is IntElement -> arg
-                    arg.value is FloatElement -> arg
-                    arg.value is DecimalElement -> arg
-                    else -> pos(arg, metas)
+    private fun visitUnaryOperation(operand: ParserRuleContext?, op: Token?, parent: ParserRuleContext? = null) =
+        PartiqlAst.build {
+            if (parent != null) return@build visit(parent) as PartiqlAst.Expr
+            val arg = visit(operand!!) as PartiqlAst.Expr
+            val metas = op.getSourceMetaContainer()
+            when (op!!.type) {
+                PartiQLParser.PLUS -> {
+                    when {
+                        arg !is PartiqlAst.Expr.Lit -> pos(arg, metas)
+                        arg.value is IntElement -> arg
+                        arg.value is FloatElement -> arg
+                        arg.value is DecimalElement -> arg
+                        else -> pos(arg, metas)
+                    }
                 }
-            }
-            PartiQLParser.MINUS -> {
-                when {
-                    arg !is PartiqlAst.Expr.Lit -> neg(arg, metas)
-                    arg.value is IntElement -> {
-                        val intValue = when (arg.value.integerSize) {
-                            IntElementSize.LONG -> ionInt(-arg.value.longValue)
-                            IntElementSize.BIG_INTEGER -> when (arg.value.bigIntegerValue) {
-                                Long.MAX_VALUE.toBigInteger() + (1L).toBigInteger() -> ionInt(Long.MIN_VALUE)
-                                else -> ionInt(arg.value.bigIntegerValue * BigInteger.valueOf(-1L))
+
+                PartiQLParser.MINUS -> {
+                    when {
+                        arg !is PartiqlAst.Expr.Lit -> neg(arg, metas)
+                        arg.value is IntElement -> {
+                            val intValue = when (arg.value.integerSize) {
+                                IntElementSize.LONG -> ionInt(-arg.value.longValue)
+                                IntElementSize.BIG_INTEGER -> when (arg.value.bigIntegerValue) {
+                                    Long.MAX_VALUE.toBigInteger() + (1L).toBigInteger() -> ionInt(Long.MIN_VALUE)
+                                    else -> ionInt(arg.value.bigIntegerValue * BigInteger.valueOf(-1L))
+                                }
                             }
+                            arg.copy(value = intValue.asAnyElement())
                         }
-                        arg.copy(value = intValue.asAnyElement())
+
+                        arg.value is FloatElement -> arg.copy(value = ionFloat(-(arg.value.doubleValue)).asAnyElement())
+                        arg.value is DecimalElement -> arg.copy(value = ionDecimal(-(arg.value.decimalValue)).asAnyElement())
+                        else -> neg(arg, metas)
                     }
-                    arg.value is FloatElement -> arg.copy(value = ionFloat(-(arg.value.doubleValue)).asAnyElement())
-                    arg.value is DecimalElement -> arg.copy(value = ionDecimal(-(arg.value.decimalValue)).asAnyElement())
-                    else -> neg(arg, metas)
                 }
+
+                PartiQLParser.NOT -> not(arg, metas)
+                else -> throw ParserException("Unknown unary operator", ErrorCode.PARSE_INVALID_QUERY)
             }
-            PartiQLParser.NOT -> not(arg, metas)
-            else -> throw ParserException("Unknown unary operator", ErrorCode.PARSE_INVALID_QUERY)
         }
-    }
 
     private fun PartiQLParser.SymbolPrimitiveContext.getSourceMetaContainer() = when (this.ident.type) {
         PartiQLParser.IDENTIFIER -> this.IDENTIFIER().getSourceMetaContainer()
         PartiQLParser.IDENTIFIER_QUOTED -> this.IDENTIFIER_QUOTED().getSourceMetaContainer()
-        else -> throw ParserException("Unable to get identifier's source meta-container.", ErrorCode.PARSE_INVALID_QUERY)
+        else -> throw ParserException(
+            "Unable to get identifier's source meta-container.",
+            ErrorCode.PARSE_INVALID_QUERY
+        )
     }
 
     private fun PartiqlAst.Expr.getStringValue(token: Token? = null): String = when (this) {
@@ -1578,16 +1726,18 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
                 is SymbolElement -> this.value.symbolValue.lowercase()
                 is StringElement -> this.value.stringValue.lowercase()
                 else ->
-                    this.value.stringValueOrNull ?: throw token.err("Unable to pass the string value", ErrorCode.PARSE_UNEXPECTED_TOKEN)
+                    this.value.stringValueOrNull ?: throw token.err(
+                        "Unable to pass the string value",
+                        ErrorCode.PARSE_UNEXPECTED_TOKEN
+                    )
             }
         }
+
         else -> throw token.err("Unable to get value", ErrorCode.PARSE_UNEXPECTED_TOKEN)
     }
 
-    private fun PartiqlAst.Expr.Id?.toPigSymbolPrimitive(): SymbolPrimitive? = when (this) {
-        null -> null
-        else -> this.name.copy(metas = this.metas)
-    }
+    private fun PartiqlAst.Expr.Id.toPigSymbolPrimitive(): SymbolPrimitive =
+        this.name.copy(metas = this.metas)
 
     private fun PartiqlAst.Expr.Id.toIdentifier(): PartiqlAst.Identifier {
         val name = this.name.text
@@ -1612,6 +1762,7 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
                     cause = e
                 )
             }
+
             else -> integerNode.text.toInteger().toLong()
         }
         if (precision < 0 || precision > MAX_PRECISION_FOR_TIME) {
@@ -1624,24 +1775,31 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
      * Parses a [timeString] using [OffsetTime] and converts to a [PartiqlAst.Expr.LitTime]. If unable to parse, parses
      * using [getLocalTime].
      */
-    private fun getOffsetTime(timeString: String, precision: Long, stringNode: TerminalNode, timeNode: TerminalNode) = PartiqlAst.build {
-        try {
-            val time: OffsetTime = OffsetTime.parse(timeString)
-            litTime(
-                timeValue(
-                    time.hour.toLong(), time.minute.toLong(), time.second.toLong(), time.nano.toLong(),
-                    precision, true, (time.offset.totalSeconds / 60).toLong()
+    private fun getOffsetTime(timeString: String, precision: Long, stringNode: TerminalNode, timeNode: TerminalNode) =
+        PartiqlAst.build {
+            try {
+                val time: OffsetTime = OffsetTime.parse(timeString)
+                litTime(
+                    timeValue(
+                        time.hour.toLong(), time.minute.toLong(), time.second.toLong(), time.nano.toLong(),
+                        precision, true, (time.offset.totalSeconds / 60).toLong()
+                    )
                 )
-            )
-        } catch (e: DateTimeParseException) {
-            getLocalTime(timeString, true, precision, stringNode, timeNode)
+            } catch (e: DateTimeParseException) {
+                getLocalTime(timeString, true, precision, stringNode, timeNode)
+            }
         }
-    }
 
     /**
      * Parses a [timeString] using [LocalTime] and converts to a [PartiqlAst.Expr.LitTime]
      */
-    private fun getLocalTime(timeString: String, withTimeZone: Boolean, precision: Long, stringNode: TerminalNode, timeNode: TerminalNode) = PartiqlAst.build {
+    private fun getLocalTime(
+        timeString: String,
+        withTimeZone: Boolean,
+        precision: Long,
+        stringNode: TerminalNode,
+        timeNode: TerminalNode
+    ) = PartiqlAst.build {
         val time: LocalTime
         val formatter = when (withTimeZone) {
             false -> DateTimeFormatter.ISO_TIME
@@ -1662,16 +1820,82 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         )
     }
 
+    private fun getTimestampStringAndPrecision(
+        stringNode: TerminalNode,
+        integerNode: TerminalNode?
+    ): Pair<String, Long?> {
+        val timestampString = stringNode.getStringValue()
+        val precision = when (integerNode) {
+            null -> return timestampString to null
+            else -> integerNode.text.toInteger().toLong()
+        }
+        if (precision < 0) {
+            throw integerNode.err("Precision out of bounds", ErrorCode.PARSE_INVALID_PRECISION_FOR_TIMESTAMP)
+        }
+        return timestampString to precision
+    }
+
+    /**
+     * Parse Timestamp based on the existence of Time zone
+     */
+    private fun getTimestampDynamic(
+        timestampString: String,
+        precision: Long?,
+        node: TerminalNode
+    ) = PartiqlAst.build {
+        val timestamp =
+            try {
+                DateTimeUtils.parseTimestamp(timestampString)
+            } catch (e: DateTimeException) {
+                throw node.err("Invalid Date Time Literal", ErrorCode.PARSE_INVALID_DATETIME_STRING, cause = e)
+            }
+        val timeZone = timestamp.timeZone?.let { getTimeZone(it) }
+        timestamp(
+            timestampValue(
+                timestamp.year.toLong(), timestamp.month.toLong(), timestamp.day.toLong(),
+                timestamp.hour.toLong(), timestamp.minute.toLong(), ionDecimal(Decimal.valueOf(timestamp.decimalSecond)),
+                timeZone, precision
+            )
+        )
+    }
+
+    private fun getTimestampWithTimezone(
+        timestampString: String,
+        precision: Long?,
+        node: TerminalNode
+    ) = PartiqlAst.build {
+        val timestamp = try {
+            DateTimeUtils.parseTimestamp(timestampString)
+        } catch (e: DateTimeException) {
+            throw node.err("Invalid Date Time Literal", ErrorCode.PARSE_INVALID_DATETIME_STRING, cause = e)
+        }
+        if (timestamp.timeZone == null)
+            throw node.err(
+                "Invalid Date Time Literal, expect Time Zone for Type Timestamp With Time Zone",
+                ErrorCode.PARSE_INVALID_DATETIME_STRING
+            )
+        val timeZone = timestamp.timeZone?.let { getTimeZone(it) }
+        timestamp(
+            timestampValue(
+                timestamp.year.toLong(), timestamp.month.toLong(), timestamp.day.toLong(),
+                timestamp.hour.toLong(), timestamp.minute.toLong(), ionDecimal(Decimal.valueOf(timestamp.decimalSecond)),
+                timeZone, precision
+            )
+        )
+    }
+
+    private fun getTimeZone(timeZone: TimeZone) = PartiqlAst.build {
+        when (timeZone) {
+            TimeZone.UnknownTimeZone -> unknownTimezone()
+            is TimeZone.UtcOffset -> utcOffset(timeZone.totalOffsetMinutes.toLong())
+        }
+    }
+
     private fun convertSymbolPrimitive(sym: PartiQLParser.SymbolPrimitiveContext?): SymbolPrimitive? = when (sym) {
         null -> null
         else -> SymbolPrimitive(sym.getString(), sym.getSourceMetaContainer())
     }
 
-    private fun convertProjectionItems(ctx: PartiQLParser.ProjectionItemsContext, metas: MetaContainer) = PartiqlAst.build {
-        val projections = visitOrEmpty(ctx.projectionItem(), PartiqlAst.ProjectItem::class)
-        projectList(projections, metas)
-    }
-
     private fun PartiQLParser.SelectClauseContext.getMetas(): MetaContainer = when (this) {
         is PartiQLParser.SelectAllContext -> this.SELECT().getSourceMetaContainer()
         is PartiQLParser.SelectItemsContext -> this.SELECT().getSourceMetaContainer()
@@ -1734,7 +1958,11 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
 
         when {
             path.steps.last() is PartiqlAst.PathStep.PathUnpivot && steps.isEmpty() -> projectAll(path.root, path.metas)
-            path.steps.last() is PartiqlAst.PathStep.PathUnpivot -> projectAll(path(path.root, steps, path.metas), path.metas)
+            path.steps.last() is PartiqlAst.PathStep.PathUnpivot -> projectAll(
+                path(path.root, steps, path.metas),
+                path.metas
+            )
+
             else -> projectExpr_(path, asAlias = alias, path.metas)
         }
     }
@@ -1749,14 +1977,15 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         else -> throw this.err("Unsupported token for grabbing string value.", ErrorCode.PARSE_INVALID_QUERY)
     }
 
-    private fun getStrategy(strategy: PartiQLParser.SetQuantifierStrategyContext?, default: PartiqlAst.SetQuantifier) = PartiqlAst.build {
-        when {
-            strategy == null -> default
-            strategy.DISTINCT() != null -> distinct()
-            strategy.ALL() != null -> all()
-            else -> default
+    private fun getStrategy(strategy: PartiQLParser.SetQuantifierStrategyContext?, default: PartiqlAst.SetQuantifier) =
+        PartiqlAst.build {
+            when {
+                strategy == null -> default
+                strategy.DISTINCT() != null -> distinct()
+                strategy.ALL() != null -> all()
+                else -> default
+            }
         }
-    }
 
     private fun getStrategy(strategy: PartiQLParser.SetQuantifierStrategyContext?): PartiqlAst.SetQuantifier? {
         return when {
@@ -1790,10 +2019,12 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
                 lit(ionString(ctx.IDENTIFIER_QUOTED().getStringValue())), caseSensitive(),
                 metas = ctx.IDENTIFIER_QUOTED().getSourceMetaContainer()
             )
+
             ctx.IDENTIFIER() != null -> pathExpr(
                 lit(ionString(ctx.IDENTIFIER().text)), caseInsensitive(),
                 metas = ctx.IDENTIFIER().getSourceMetaContainer()
             )
+
             else -> throw ParserException("Unable to get symbol's text.", ErrorCode.PARSE_INVALID_QUERY)
         }
     }
@@ -1821,7 +2052,10 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
         if (value !is IntElement)
             throw token.err("Expected an integer value.", ErrorCode.PARSE_MALFORMED_PARSE_TREE)
         if (value.integerSize == IntElementSize.BIG_INTEGER || value.longValue > Int.MAX_VALUE || value.longValue < Int.MIN_VALUE)
-            throw token.err("Type parameter exceeded maximum value", ErrorCode.PARSE_TYPE_PARAMETER_EXCEEDED_MAXIMUM_VALUE)
+            throw token.err(
+                "Type parameter exceeded maximum value",
+                ErrorCode.PARSE_TYPE_PARAMETER_EXCEEDED_MAXIMUM_VALUE
+            )
     }
 
     private enum class ExplainParameters {
@@ -1830,10 +2064,24 @@ internal class PartiQLPigVisitor(val customTypes: List<CustomType> = listOf(), p
 
         fun getCompliantString(target: String?, input: Token): String = when (target) {
             null -> input.text!!
-            else -> throw input.error("Cannot set EXPLAIN parameter ${this.name} multiple times.", ErrorCode.PARSE_UNEXPECTED_TOKEN)
+            else -> throw input.error(
+                "Cannot set EXPLAIN parameter ${this.name} multiple times.",
+                ErrorCode.PARSE_UNEXPECTED_TOKEN
+            )
         }
     }
 
-    private fun TerminalNode?.err(msg: String, code: ErrorCode, ctx: PropertyValueMap = PropertyValueMap(), cause: Throwable? = null) = this.error(msg, code, ctx, cause)
-    private fun Token?.err(msg: String, code: ErrorCode, ctx: PropertyValueMap = PropertyValueMap(), cause: Throwable? = null) = this.error(msg, code, ctx, cause)
+    private fun TerminalNode?.err(
+        msg: String,
+        code: ErrorCode,
+        ctx: PropertyValueMap = PropertyValueMap(),
+        cause: Throwable? = null
+    ) = this.error(msg, code, ctx, cause)
+
+    private fun Token?.err(
+        msg: String,
+        code: ErrorCode,
+        ctx: PropertyValueMap = PropertyValueMap(),
+        cause: Throwable? = null
+    ) = this.error(msg, code, ctx, cause)
 }
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/impl/PartiQLShimParser.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/impl/PartiQLShimParser.kt
new file mode 100644
index 0000000000..6c5c63ae56
--- /dev/null
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/impl/PartiQLShimParser.kt
@@ -0,0 +1,89 @@
+package org.partiql.lang.syntax.impl
+
+import com.amazon.ion.system.IonSystemBuilder
+import com.amazon.ionelement.api.MetaContainer
+import org.partiql.ast.helpers.toLegacyAst
+import org.partiql.lang.ast.SourceLocationMeta
+import org.partiql.lang.domains.PartiqlAst
+import org.partiql.lang.domains.metaContainerOf
+import org.partiql.lang.errors.ErrorCode
+import org.partiql.lang.errors.Property
+import org.partiql.lang.errors.PropertyValueMap
+import org.partiql.lang.syntax.Parser
+import org.partiql.lang.syntax.ParserException
+import org.partiql.parser.PartiQLLexerException
+import org.partiql.parser.PartiQLParser
+import org.partiql.parser.PartiQLParserException
+import org.partiql.parser.SourceLocations
+
+/**
+ * Implementation of [Parser] which uses a [org.partiql.ast.AstNode] tree, then translates to the legacy interface.
+ *
+ * @property delegate
+ */
+internal class PartiQLShimParser(
+    private val delegate: PartiQLParser,
+) : Parser {
+
+    // required for PropertyValueMap debug information
+    private val ion = IonSystemBuilder.standard().build()
+
+    override fun parseAstStatement(source: String): PartiqlAst.Statement {
+        val result = try {
+            delegate.parse(source)
+        } catch (ex: PartiQLLexerException) {
+            throw ex.shim()
+        } catch (ex: PartiQLParserException) {
+            throw ex.shim()
+        }
+        val statement = try {
+            val metas = result.locations.toMetas()
+            result.root.toLegacyAst(metas)
+        } catch (ex: Exception) {
+            throw ParserException(
+                message = ex.message ?: "",
+                errorCode = ErrorCode.PARSE_INVALID_QUERY,
+                cause = ex,
+            )
+        }
+        if (statement !is PartiqlAst.Statement) {
+            throw ParserException(
+                message = "Expected statement, got ${statement::class.qualifiedName}",
+                errorCode = ErrorCode.PARSE_INVALID_QUERY,
+            )
+        }
+        return statement
+    }
+
+    /**
+     * The legacy parser tests assert on ParserExcept, not LexerException.
+     */
+    private fun PartiQLLexerException.shim(): ParserException {
+        val ctx = PropertyValueMap()
+        ctx[Property.LINE_NUMBER] = location.line.toLong()
+        ctx[Property.COLUMN_NUMBER] = location.offset.toLong()
+        ctx[Property.TOKEN_STRING] = token
+        ctx[Property.TOKEN_DESCRIPTION] = tokenType
+        ctx[Property.TOKEN_VALUE] = ion.newSymbol(token)
+        return ParserException(message, ErrorCode.PARSE_UNEXPECTED_TOKEN, ctx, cause)
+    }
+
+    private fun PartiQLParserException.shim(): ParserException {
+        val ctx = PropertyValueMap()
+        ctx[Property.LINE_NUMBER] = location.line.toLong()
+        ctx[Property.COLUMN_NUMBER] = location.offset.toLong()
+        ctx[Property.TOKEN_DESCRIPTION] = tokenType
+        ctx[Property.TOKEN_VALUE] = ion.newSymbol(token)
+        return ParserException(message, ErrorCode.PARSE_UNEXPECTED_TOKEN, ctx, cause)
+    }
+
+    private fun SourceLocations.toMetas(): Map<String, MetaContainer> = mapValues {
+        metaContainerOf(
+            SourceLocationMeta(
+                lineNum = it.value.line.toLong(),
+                charOffset = it.value.offset.toLong(),
+                length = it.value.lengthLegacy.toLong(),
+            )
+        )
+    }
+}
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/util/DateTimeUtils.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/util/DateTimeUtils.kt
new file mode 100644
index 0000000000..ec349d24c0
--- /dev/null
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/syntax/util/DateTimeUtils.kt
@@ -0,0 +1,76 @@
+package org.partiql.lang.syntax.util
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeValue
+import org.partiql.value.datetime.Time
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.Timestamp
+import java.math.BigDecimal
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+
+internal object DateTimeUtils {
+    private val DATE_PATTERN: Pattern = Pattern.compile("(?<year>\\d{4,})-(?<month>\\d{2,})-(?<day>\\d{2,})")
+    private val TIME_PATTERN: Pattern = Pattern.compile("(?<hour>\\d{2,}):(?<minute>\\d{2,}):(?<second>\\d{2,})(?:\\.(?<fraction>\\d+))?\\s*(?<timezone>([+-]\\d\\d:\\d\\d)|(?<utc>[Zz]))?")
+    private val SQL_TIMESTAMP_DATE_TIME_DELIMITER = "\\s+".toRegex()
+    private val RFC8889_TIMESTAMP_DATE_TIME_DELIMITER = "[Tt]".toRegex()
+    private val TIMESTAMP_PATTERN = "(?<date>$DATE_PATTERN)($SQL_TIMESTAMP_DATE_TIME_DELIMITER|$RFC8889_TIMESTAMP_DATE_TIME_DELIMITER)(?<time>$TIME_PATTERN)".toRegex().toPattern()
+
+    internal fun parseDateLiteral(dateString: String): Date {
+        val matcher: Matcher = DATE_PATTERN.matcher(dateString)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expected Date Format to be in YYYY-MM-DD, received $dateString"
+        )
+        val year = matcher.group("year").toInt()
+        val month = matcher.group("month").toInt()
+        val day = matcher.group("day").toInt()
+        return DateTimeValue.date(year, month, day)
+    }
+
+    internal fun parseTimeLiteral(timeString: String): Time {
+        val matcher: Matcher = TIME_PATTERN.matcher(timeString)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expect TIME Format to be in HH-mm-ss.ddd+[+|-][hh:mm|z], received $timeString"
+        )
+        try {
+            val hour = matcher.group("hour").toInt()
+            val minute = matcher.group("minute").toInt()
+            val wholeSecond = matcher.group("second").toLong()
+            val fractionPart = matcher.group("fraction")?.let { BigDecimal(".$it") } ?: BigDecimal.ZERO
+            val second = BigDecimal.valueOf(wholeSecond).add(fractionPart)
+            val timeZoneString = matcher.group("timezone") ?: null
+            if (timeZoneString != null) {
+                matcher.group("utc")?.let { return DateTimeValue.time(hour, minute, second, TimeZone.UtcOffset.of(0)) }
+                val timeZone = getTimeZoneComponent(timeZoneString)
+                return DateTimeValue.time(hour, minute, second, timeZone)
+            }
+            return DateTimeValue.time(hour, minute, second)
+        } catch (e: IllegalStateException) {
+            throw DateTimeException(e.localizedMessage)
+        } catch (e: IllegalArgumentException) {
+            throw DateTimeException(e.localizedMessage)
+        }
+    }
+
+    fun parseTimestamp(timestampString: String): Timestamp {
+        val matcher: Matcher = TIMESTAMP_PATTERN.matcher(timestampString)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expected TIMESTAMP Format should be in YYYY-MM-DD[\\s|T]hh:mm:ss.ddd+[hh:mm|z], received $timestampString"
+        )
+        val date = parseDateLiteral(matcher.group("date"))
+        val time = parseTimeLiteral(matcher.group("time"))
+        return DateTimeValue.timestamp(date, time)
+    }
+
+    private fun getTimeZoneComponent(timezone: String): TimeZone {
+        val tzSign = timezone.substring(0, 1).first()
+        val tzHour = timezone.substring(1, 3).toInt()
+        val tzMinute = timezone.substring(4, 6).toInt()
+        return when {
+            tzSign == '-' && tzHour == 0 && tzMinute == 0 -> TimeZone.UnknownTimeZone
+            tzSign == '-' -> TimeZone.UtcOffset.of(-tzHour, -tzMinute)
+            else -> TimeZone.UtcOffset.of(tzHour, tzMinute)
+        }
+    }
+}
diff --git a/partiql-lang/src/main/kotlin/org/partiql/lang/types/PartiqlPhysicalTypeExtensions.kt b/partiql-lang/src/main/kotlin/org/partiql/lang/types/PartiqlPhysicalTypeExtensions.kt
index 41d4f25a58..41026cd5a5 100644
--- a/partiql-lang/src/main/kotlin/org/partiql/lang/types/PartiqlPhysicalTypeExtensions.kt
+++ b/partiql-lang/src/main/kotlin/org/partiql/lang/types/PartiqlPhysicalTypeExtensions.kt
@@ -109,4 +109,6 @@ internal fun PartiqlPhysical.Type.toTypedOpParameter(customTypedOpParameters: Ma
         is PartiqlPhysical.Type.TimeWithTimeZoneType -> TypedOpParameter(
             TimeType(this.precision?.value?.toInt(), withTimeZone = true)
         )
+
+        is PartiqlPhysical.Type.TimestampWithTimeZoneType -> TODO()
     }
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/ast/passes/StatementRedactorTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/ast/passes/StatementRedactorTest.kt
index 0275ff08f4..5b315b3ffe 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/ast/passes/StatementRedactorTest.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/ast/passes/StatementRedactorTest.kt
@@ -43,7 +43,12 @@ class StatementRedactorTest : PartiQLParserTestBase() {
      * Return true if the parsed results of input [statement] is the same as input [ast]
      */
     private fun validateInputAstParsedFromInputStatement(statement: String, ast: PartiqlAst.Statement): Boolean {
-        return parser.parseAstStatement(statement) == ast
+        targets.forEach { target ->
+            if (target.parser.parseAstStatement(statement) != ast) {
+                return false
+            }
+        }
+        return true
     }
 
     @Test
@@ -404,23 +409,23 @@ class StatementRedactorTest : PartiQLParserTestBase() {
     )
 
     @Test
-    fun testDefaultArguments() {
+    fun testDefaultArguments(): Unit = forEachTarget {
         val originalStatement = "SELECT * FROM tb WHERE hk = 1 AND begins_with(Attr, 'foo', bar)"
         val expectedRedactedStatement = "SELECT * FROM tb WHERE hk = ***(Redacted) AND begins_with(Attr, ***(Redacted), bar)"
-        val redactedStatement1 = redact(originalStatement, super.parser.parseAstStatement(originalStatement))
+        val redactedStatement1 = redact(originalStatement, parser.parseAstStatement(originalStatement))
         assertEquals(expectedRedactedStatement, redactedStatement1)
 
-        val redactedStatement2 = redact(originalStatement, super.parser.parseAstStatement(originalStatement), providedSafeFieldNames = emptySet())
+        val redactedStatement2 = redact(originalStatement, parser.parseAstStatement(originalStatement), providedSafeFieldNames = emptySet())
         assertEquals(expectedRedactedStatement, redactedStatement2)
 
-        val redactedStatement3 = redact(originalStatement, super.parser.parseAstStatement(originalStatement), userDefinedFunctionRedactionConfig = emptyMap())
+        val redactedStatement3 = redact(originalStatement, parser.parseAstStatement(originalStatement), userDefinedFunctionRedactionConfig = emptyMap())
         assertEquals(expectedRedactedStatement, redactedStatement3)
     }
 
     @Test
-    fun testInputStatementAstMismatch() {
+    fun testInputStatementAstMismatch() = forEachTarget {
         val inputStatement = "SELECT * FROM tb WHERE nonKey = 'a'"
-        val inputAst = super.parser.parseAstStatement("SELECT * FROM tb WHERE hk = 1 AND nonKey = 'a'")
+        val inputAst = parser.parseAstStatement("SELECT * FROM tb WHERE hk = 1 AND nonKey = 'a'")
         assertFalse(validateInputAstParsedFromInputStatement(inputStatement, inputAst))
 
         try {
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/errors/WindowRelatedParserErrorsTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/errors/WindowRelatedParserErrorsTest.kt
deleted file mode 100644
index 9ffd017c9a..0000000000
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/errors/WindowRelatedParserErrorsTest.kt
+++ /dev/null
@@ -1,65 +0,0 @@
-package org.partiql.lang.errors
-
-import org.junit.Test
-import org.partiql.lang.syntax.PartiQLParserTestBase
-import org.partiql.lang.util.getAntlrDisplayString
-import org.partiql.parser.antlr.PartiQLParser
-
-// TODO: move this to [ParserErrorsTest] once https://github.com/partiql/partiql-docs/issues/31 is resolved and a RFC is approved
-
-class WindowRelatedParserErrorsTest : PartiQLParserTestBase() {
-    @Test
-    fun lagWithoutOrderBy() {
-        checkInputThrowingParserException(
-            "SELECT lag(a) OVER () FROM b",
-            ErrorCode.PARSE_EXPECTED_WINDOW_ORDER_BY,
-            mapOf(
-                Property.LINE_NUMBER to 1L,
-                Property.COLUMN_NUMBER to 8L,
-                Property.TOKEN_DESCRIPTION to PartiQLParser.LAG.getAntlrDisplayString(),
-                Property.TOKEN_VALUE to ion.newSymbol("lag")
-            )
-        )
-    }
-
-    @Test
-    fun lagWrongNumberOfParameter() {
-        checkInputThrowingParserException(
-            "SELECT lag(a,b,c,d) OVER (ORDER BY e) FROM f",
-            ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            mapOf(
-                Property.LINE_NUMBER to 1L,
-                Property.COLUMN_NUMBER to 17L,
-                Property.TOKEN_DESCRIPTION to PartiQLParser.COMMA.getAntlrDisplayString(),
-                Property.TOKEN_VALUE to ion.newSymbol(",")
-            )
-        )
-    }
-
-    fun leadWithoutOrderBy() {
-        checkInputThrowingParserException(
-            "SELECT lead(a) OVER () FROM b",
-            ErrorCode.PARSE_EXPECTED_WINDOW_ORDER_BY,
-            mapOf(
-                Property.LINE_NUMBER to 1L,
-                Property.COLUMN_NUMBER to 8L,
-                Property.TOKEN_DESCRIPTION to PartiQLParser.LAG.getAntlrDisplayString(),
-                Property.TOKEN_VALUE to ion.newSymbol("lag")
-            )
-        )
-    }
-
-    @Test
-    fun leadWrongNumberOfParameter() {
-        checkInputThrowingParserException(
-            "SELECT lead(a,b,c,d) OVER (ORDER BY e) FROM f",
-            ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            mapOf(
-                Property.LINE_NUMBER to 1L,
-                Property.COLUMN_NUMBER to 18L,
-                Property.TOKEN_DESCRIPTION to PartiQLParser.COMMA.getAntlrDisplayString(),
-                Property.TOKEN_VALUE to ion.newSymbol(",")
-            )
-        )
-    }
-}
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/TypedNullTests.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/TypedNullTests.kt
new file mode 100644
index 0000000000..6734c4bd47
--- /dev/null
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/TypedNullTests.kt
@@ -0,0 +1,57 @@
+package org.partiql.lang.eval
+
+import com.amazon.ion.IonSystem
+import com.amazon.ion.system.IonSystemBuilder
+import org.junit.Test
+import org.partiql.lang.CompilerPipeline
+
+/**
+ * The following tests demonstrate the current typed null behavior and tracks possible regressions in future commits.
+ * This behavior is what the Kotlin implementation defines and is subject to change pending resolution of
+ * https://github.com/partiql/partiql-spec/issues/61.
+ */
+class TypedNullTests : EvaluatorTestBase() {
+    // Round-tripped typed nulls (IonValue -> ExprValue -> IonValue) results in same typed null value
+    @Test
+    fun typedNullIonValueExprValueRoundTrip() {
+        val ion: IonSystem = IonSystemBuilder.standard().build()
+        val ionValue = ion.singleValue("null.int")
+        val exprValue = ExprValue.of(ionValue)
+        val roundTripped = exprValue.toIonValue(ion)
+        assertEquals(ionValue, roundTripped)
+    }
+
+    // Evaluated typed nulls converted to an IonValue preserve the typed null.
+    @Test
+    fun typedNullIonLiteralEvaluation() {
+        val pipeline = CompilerPipeline.standard()
+        val ionValueAsString = "null.int"
+        val expr = pipeline.compile("`$ionValueAsString`")
+        val session = EvaluationSession.standard()
+        val result = expr.eval(session)
+        val ionValueRoundtripped = result.toIonValue(ion)
+        assertEquals(ion.singleValue(ionValueAsString), ionValueRoundtripped)
+    }
+
+    // Evaluated typed nulls in an SFW projection. Converting result to an IonValue preserves the typed null.
+    @Test
+    fun typedNullInSFW() {
+        val pipeline = CompilerPipeline.standard()
+        val expr = pipeline.compile("SELECT t.a FROM [{'a': `null.int`}] AS t")
+        val session = EvaluationSession.standard()
+        val result = expr.eval(session)
+        val ionValueRoundtripped = result.toIonValue(ion)
+        assertEquals(ion.singleValue("\$bag::[{a: null.int}]"), ionValueRoundtripped)
+    }
+
+    // Evaluated typed nulls in an arithmetic expression will NOT preserve the type when converting back to IonValue.
+    @Test
+    fun typedNullInArithmeticOperation() {
+        val pipeline = CompilerPipeline.standard()
+        val expr = pipeline.compile("`null.int` + `null.int`")
+        val session = EvaluationSession.standard()
+        val result = expr.eval(session)
+        val ionValueRoundtripped = result.toIonValue(ion)
+        assertEquals(ion.singleValue("null"), ionValueRoundtripped)
+    }
+}
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/AggregateSupportVisitorTransformTests.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/AggregateSupportVisitorTransformTests.kt
index 0c95529723..b49114c42b 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/AggregateSupportVisitorTransformTests.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/AggregateSupportVisitorTransformTests.kt
@@ -24,9 +24,13 @@ import org.partiql.lang.ast.AggregateCallSiteListMeta
 import org.partiql.lang.ast.AggregateRegisterIdMeta
 import org.partiql.lang.ast.SourceLocationMeta
 import org.partiql.lang.domains.PartiqlAst
+import org.partiql.lang.syntax.PartiQLParserBuilder
 import org.partiql.lang.util.ArgumentsProviderBase
 
 class AggregateSupportVisitorTransformTests : VisitorTransformTestBase() {
+
+    private val parser = PartiQLParserBuilder.standard().build()
+
     private val transformer = AggregateSupportVisitorTransform()
 
     data class AggSupportTestCase(val query: String, val expectedCallAggs: List<Pair<String, Int>>)
@@ -37,7 +41,7 @@ class AggregateSupportVisitorTransformTests : VisitorTransformTestBase() {
      */
     private fun String.parseAndTransformQuery(): PartiqlAst.Expr.Select {
         val query = this
-        val statement = super.parser.parseAstStatement(query)
+        val statement = parser.parseAstStatement(query)
         val transformedNode = (transformer).transformStatement(statement) as PartiqlAst.Statement.Query
         return (transformedNode.expr) as PartiqlAst.Expr.Select
     }
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/StaticTypeInferenceVisitorTransformTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/StaticTypeInferenceVisitorTransformTest.kt
index 9cc7bb3648..c827e6ffa6 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/StaticTypeInferenceVisitorTransformTest.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/StaticTypeInferenceVisitorTransformTest.kt
@@ -164,7 +164,7 @@ class StaticTypeInferenceVisitorTransformTest : VisitorTransformTestBase() {
     @MethodSource("parametersForAggFunctionTests")
     fun aggFunctionTests(tc: TestCase) = runTest(tc)
 
-    private fun runTest(tc: TestCase) {
+    private fun runTest(tc: TestCase) = forEachTarget {
         val globalBindings = Bindings.ofMap(tc.globals)
         val ion = IonSystemBuilder.standard().build()
         val inferencer = StaticTypeInferencer(
@@ -175,7 +175,7 @@ class StaticTypeInferenceVisitorTransformTest : VisitorTransformTestBase() {
 
         val defaultVisitorTransforms = basicVisitorTransforms()
         val staticTypeVisitorTransform = StaticTypeVisitorTransform(ion, globalBindings)
-        val originalStatement = parse(tc.originalSql).let {
+        val originalStatement = parser.parseAstStatement(tc.originalSql).let {
             // We always pass the query under test through all of the basic VisitorTransforms primarily because we need
             // FromSourceAliasVisitorTransform to execute first but also to help ensure the queries we're testing
             // make sense when they're all run.
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/StaticTypeVisitorTransformTests.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/StaticTypeVisitorTransformTests.kt
index bb829bad79..ddd9e0cfa0 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/StaticTypeVisitorTransformTests.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/StaticTypeVisitorTransformTests.kt
@@ -975,7 +975,7 @@ class StaticTypeVisitorTransformTests : VisitorTransformTestBase() {
 
     private fun runSTRTest(
         tc: STRTestCase
-    ) {
+    ): Unit = forEachTarget {
         val globalBindings = Bindings.ofMap(tc.globals)
         val transformer = StaticTypeVisitorTransform(ion, globalBindings, tc.constraints)
 
@@ -983,7 +983,7 @@ class StaticTypeVisitorTransformTests : VisitorTransformTestBase() {
         // FromSourceAliasVisitorTransform to execute first but also to help ensure the queries we're testing
         // make sense when they're all run.
         val defaultTransforms = basicVisitorTransforms()
-        val originalAst = defaultTransforms.transformStatement(parse(tc.originalSql))
+        val originalAst = defaultTransforms.transformStatement(parser.parseAstStatement(tc.originalSql))
 
         val transformedAst = try {
             transformer.transformStatement(originalAst)
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/VisitorTransformTestBase.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/VisitorTransformTestBase.kt
index 8dd19ee862..2cd73ff1bd 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/VisitorTransformTestBase.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/eval/visitors/VisitorTransformTestBase.kt
@@ -100,14 +100,14 @@ abstract class VisitorTransformTestBase : PartiQLParserTestBase() {
         assertEquals("The expected AST must match the transformed AST", tc.expected, actualStatement)
     }
 
-    protected fun runErrorTest(tc: TransformErrorTestCase, transform: PartiqlAst.VisitorTransform) {
+    protected fun runErrorTest(tc: TransformErrorTestCase, transform: PartiqlAst.VisitorTransform): Unit = forEachTarget {
 
         val ex = assertThrowsSqlException(
             EvaluatorTestFailureReason.EXPECTED_SQL_EXCEPTION_BUT_THERE_WAS_NONE,
             { tc.testDetails() }
         ) {
             val ast = org.junit.jupiter.api.assertDoesNotThrow("Parsing Original SQL") {
-                this.parser.parseAstStatement(tc.query)
+                parser.parseAstStatement(tc.query)
             }
             transform.transformStatement(ast)
         }
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/prettyprint/QueryPrettyPrinterTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/prettyprint/QueryPrettyPrinterTest.kt
index cb16bc0abf..e5e6e9ee35 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/prettyprint/QueryPrettyPrinterTest.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/prettyprint/QueryPrettyPrinterTest.kt
@@ -915,7 +915,7 @@ class QueryPrettyPrinterTest {
     fun checkCurrentUserMixedCase() {
         checkPrettyPrintQuery(
             query = "CURRENT_user",
-            expected = "CURRENT_user"
+            expected = "CURRENT_USER"
         )
     }
 
@@ -925,7 +925,7 @@ class QueryPrettyPrinterTest {
             query = "SELECT * FROM [ CURRENT_user ]",
             expected = """
                 SELECT *
-                FROM [ CURRENT_user ]
+                FROM [ CURRENT_USER ]
             """.trimIndent()
         )
     }
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserCastTests.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserCastTests.kt
index 489ba962b7..442b81f646 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserCastTests.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserCastTests.kt
@@ -12,6 +12,8 @@ import org.partiql.lang.util.ArgumentsProviderBase
 
 class PartiQLParserCastTests : PartiQLParserTestBase() {
 
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     @ParameterizedTest
     @ArgumentsSource(ConfiguredCastArguments::class)
     fun configuredCast(configuredCastCase: ConfiguredCastParseTest) = configuredCastCase.assertCase()
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserCorrelatedJoinTests.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserCorrelatedJoinTests.kt
index ff9ccf1e54..86b0ec3be7 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserCorrelatedJoinTests.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserCorrelatedJoinTests.kt
@@ -5,6 +5,9 @@ import org.partiql.lang.domains.PartiqlAst
 import org.partiql.lang.domains.id
 
 class PartiQLParserCorrelatedJoinTests : PartiQLParserTestBase() {
+
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     private fun PartiqlAst.Builder.callFWithS() =
         call("f", id("s", caseInsensitive(), unqualified()))
 
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserDateTimeTests.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserDateTimeTests.kt
index 4a88b6419b..404658a73b 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserDateTimeTests.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserDateTimeTests.kt
@@ -1,9 +1,11 @@
 package org.partiql.lang.syntax
 
+import com.amazon.ion.Decimal
 import com.amazon.ion.IonValue
-import junitparams.Parameters
-import junitparams.naming.TestCaseName
-import org.junit.Test
+import com.amazon.ionelement.api.ionDecimal
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
+import org.partiql.lang.ION
 import org.partiql.lang.domains.PartiqlAst
 import org.partiql.lang.domains.id
 import org.partiql.lang.errors.ErrorCode
@@ -14,645 +16,1264 @@ import org.partiql.parser.antlr.PartiQLParser
 
 class PartiQLParserDateTimeTests : PartiQLParserTestBase() {
 
-    data class DateTimeTestCase(val source: String, val skipTest: Boolean = false, val block: PartiqlAst.Builder.() -> PartiqlAst.PartiqlAstNode)
-    data class ErrorTimeTestCase(val source: String, val errorCode: ErrorCode, val ctx: Map<Property, Any>, val skipTest: Boolean = false)
+    // TODO we do not model precision within the expression node
+    // For example, TIME (0) WITH TIME ZONE '23:59:59.123456789'` will have precision 0 which means
+    // the underlying literal value does not preserve the extraneous places.
+    // We should consider preserving the AST exactly as is text.
+    // override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT)
 
-    @Test
-    @Parameters
-    fun dateLiteralTests(tc: DateTimeTestCase) =
-        if (!tc.skipTest) {
-            assertExpression(tc.source, expectedPigBuilder = tc.block)
-        } else {
-            // Skip test, do nothing
-        }
+    data class DateTimeTestCase(
+        val source: String,
+        val skipTest: Boolean = false,
+        val block: PartiqlAst.Builder.() -> PartiqlAst.PartiqlAstNode,
+    )
+
+    data class ErrorDateTimeTestCase(
+        val source: String,
+        val errorCode: ErrorCode,
+        val ctx: Map<Property, Any>,
+        val skipTest: Boolean = false,
+    )
+
+    companion object {
+        @JvmStatic
+        fun parametersForDateLiteralTests() = listOf(
+            DateTimeTestCase("DATE '2012-02-29'") {
+                date(2012, 2, 29)
+            },
+            DateTimeTestCase("DATE'1992-11-30'") {
+                date(1992, 11, 30)
+            },
+            DateTimeTestCase("DATE '9999-03-01'") {
+                date(9999, 3, 1)
+            },
+            DateTimeTestCase("DATE '0000-01-01'") {
+                date(0, 1, 1)
+            },
+            DateTimeTestCase("DATE '0000-02-29'") {
+                date(0, 2, 29)
+            },
+            DateTimeTestCase("DATE '0000-02-29'") {
+                date(0, 2, 29)
+            },
+            DateTimeTestCase("SELECT DATE '2021-03-10' FROM foo") {
+                select(
+                    project = projectList(projectExpr(date(2021, 3, 10))),
+                    from = scan(id("foo"))
+                )
+            },
+        )
+
+        @JvmStatic
+        fun parameterForTimeLiteralTests() = listOf(
+            DateTimeTestCase("TIME '02:30:59'") {
+                litTime(timeValue(2, 30, 59, 0, 0, false, null))
+            },
+            DateTimeTestCase("TIME (3) '12:59:31'") {
+                litTime(timeValue(12, 59, 31, 0, 3, false, null))
+            },
+            DateTimeTestCase("TIME '23:59:59.9999'") {
+                litTime(timeValue(23, 59, 59, 999900000, 4, false, null))
+            },
+            DateTimeTestCase("TIME (7) '23:59:59.123456789'") {
+                litTime(timeValue(23, 59, 59, 123456789, 7, false, null))
+            },
+            DateTimeTestCase("TIME (9) '23:59:59.123456789'") {
+                litTime(timeValue(23, 59, 59, 123456789, 9, false, null))
+            },
+            DateTimeTestCase("TIME (0) '23:59:59.123456789'") {
+                litTime(timeValue(23, 59, 59, 123456789, 0, false, null))
+            },
+            DateTimeTestCase("TIME '02:30:59-05:30'") {
+                litTime(timeValue(2, 30, 59, 0, 0, false, null))
+            },
+            DateTimeTestCase("TIME '02:30:59+05:30'") {
+                litTime(timeValue(2, 30, 59, 0, 0, false, null))
+            },
+            DateTimeTestCase("TIME '02:30:59-14:39'") {
+                litTime(timeValue(2, 30, 59, 0, 0, false, null))
+            },
+            DateTimeTestCase("TIME '02:30:59+00:00'") {
+                litTime(timeValue(2, 30, 59, 0, 0, false, null))
+            },
+            DateTimeTestCase("TIME '02:30:59-00:00'") {
+                litTime(timeValue(2, 30, 59, 0, 0, false, null))
+            },
+            DateTimeTestCase("TIME (3) '12:59:31+10:30'") {
+                litTime(timeValue(12, 59, 31, 0, 3, false, null))
+            },
+            DateTimeTestCase("TIME (0) '00:00:00+00:00'") {
+                litTime(timeValue(0, 0, 0, 0, 0, false, null))
+            },
+            DateTimeTestCase("TIME (0) '00:00:00-00:00'") {
+                litTime(timeValue(0, 0, 0, 0, 0, false, null))
+            },
+            DateTimeTestCase("TIME '23:59:59.9999-11:59'") {
+                litTime(timeValue(23, 59, 59, 999900000, 4, false, null))
+            },
+            DateTimeTestCase("TIME '23:59:59.99990-11:59'") {
+                litTime(timeValue(23, 59, 59, 999900000, 5, false, null))
+            },
+            DateTimeTestCase("TIME (5) '23:59:59.9999-11:59'") {
+                litTime(timeValue(23, 59, 59, 999900000, 5, false, null))
+            },
+            DateTimeTestCase("TIME (7) '23:59:59.123456789+01:00'") {
+                litTime(timeValue(23, 59, 59, 123456789, 7, false, null))
+            },
+            DateTimeTestCase("TIME (9) '23:59:59.123456789-14:50'") {
+                litTime(timeValue(23, 59, 59, 123456789, 9, false, null))
+            },
+            DateTimeTestCase("TIME (0) '23:59:59.123456789-18:00'") {
+                litTime(timeValue(23, 59, 59, 123456789, 0, false, null))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '02:30:59'") {
+                litTime(timeValue(2, 30, 59, 0, 0, true, null))
+            },
+            DateTimeTestCase("TIME (3) WITH TIME ZONE '12:59:31'") {
+                litTime(timeValue(12, 59, 31, 0, 3, true, null))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.9999'") {
+                litTime(timeValue(23, 59, 59, 999900000, 4, true, null))
+            },
+            DateTimeTestCase("TIME (7) WITH TIME ZONE '23:59:59.123456789'") {
+                litTime(timeValue(23, 59, 59, 123456789, 7, true, null))
+            },
+            DateTimeTestCase("TIME (9) WITH TIME ZONE '23:59:59.123456789'") {
+                litTime(timeValue(23, 59, 59, 123456789, 9, true, null))
+            },
+            DateTimeTestCase("TIME (0) WITH TIME ZONE '23:59:59.123456789'") {
+                litTime(timeValue(23, 59, 59, 123456789, 0, true, null))
+            },
+            DateTimeTestCase("TIME (0) WITH TIME ZONE '00:00:00+00:00'") {
+                litTime(timeValue(0, 0, 0, 0, 0, true, 0))
+            },
+            DateTimeTestCase("TIME (0) WITH TIME ZONE '00:00:00.0000-00:00'") {
+                litTime(timeValue(0, 0, 0, 0, 0, true, 0))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '02:30:59.1234500-05:30'") {
+                litTime(timeValue(2, 30, 59, 123450000, 7, true, -330))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '02:30:59+05:30'") {
+                litTime(timeValue(2, 30, 59, 0, 0, true, 330))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '02:30:59-14:39'") {
+                litTime(timeValue(2, 30, 59, 0, 0, true, -879))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.9999-11:59'") {
+                litTime(timeValue(23, 59, 59, 999900000, 4, true, -719))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.99990-11:59'") {
+                litTime(timeValue(23, 59, 59, 999900000, 5, true, -719))
+            },
+            DateTimeTestCase("TIME (5) WITH TIME ZONE '23:59:59.9999-11:59'") {
+                litTime(timeValue(23, 59, 59, 999900000, 5, true, -719))
+            },
+            DateTimeTestCase("TIME (7) WITH TIME ZONE '23:59:59.123456789+01:00'") {
+                litTime(timeValue(23, 59, 59, 123456789, 7, true, 60))
+            },
+            DateTimeTestCase("TIME (9) WITH TIME ZONE '23:59:59.123456789-14:50'") {
+                litTime(timeValue(23, 59, 59, 123456789, 9, true, -890))
+            },
+            DateTimeTestCase("TIME (0) WITH TIME ZONE '23:59:59.123456789-18:00'") {
+                litTime(timeValue(23, 59, 59, 123456789, 0, true, -1080))
+            },
+            // TODO: These tests should pass. Check https://github.com/partiql/partiql-lang-kotlin/issues/395
+            DateTimeTestCase("TIME '23:59:59.1234567890'", skipTest = true) {
+                litTime(timeValue(23, 59, 59, 123456789, 9, false, null))
+            },
+            DateTimeTestCase("TIME '23:59:59.1234567899'", skipTest = true) {
+                litTime(timeValue(23, 59, 59, 123456790, 9, false, null))
+            },
+            DateTimeTestCase("TIME '23:59:59.1234567890+18:00'", skipTest = true) {
+                litTime(timeValue(23, 59, 59, 123456789, 9, false, null))
+            },
+            DateTimeTestCase("TIME '23:59:59.1234567899+18:00'", skipTest = true) {
+                litTime(timeValue(23, 59, 59, 123456790, 9, false, null))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.1234567890'", skipTest = true) {
+                litTime(timeValue(23, 59, 59, 123456789, 9, true, null))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.1234567899'", skipTest = true) {
+                litTime(timeValue(23, 59, 59, 123456790, 9, true, null))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.1234567890+18:00'", skipTest = true) {
+                litTime(timeValue(23, 59, 59, 123456789, 9, true, 1080))
+            },
+            DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.1234567899+18:00'", skipTest = true) {
+                litTime(timeValue(23, 59, 59, 123456790, 9, true, 1080))
+            }
+        )
 
-    private fun createErrorCaseForTime(source: String, errorCode: ErrorCode, line: Long, col: Long, tokenType: Int, tokenValue: IonValue, skipTest: Boolean = false): ErrorTimeTestCase {
-        val displayTokenType = tokenType.getAntlrDisplayString()
-        val ctx = mapOf(
-            Property.LINE_NUMBER to line,
-            Property.COLUMN_NUMBER to col,
-            Property.TOKEN_DESCRIPTION to displayTokenType,
-            Property.TOKEN_VALUE to tokenValue
+        @JvmStatic
+        fun parameterForTimestampLiteralTests() = listOf(
+            // TIMESTAMP WITHOUT TIME ZONE
+            DateTimeTestCase("TIMESTAMP '2023-01-02 03:04:05'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        null, null
+                    )
+                )
+            },
+            DateTimeTestCase("TIMESTAMP '2023-01-02 03:04:05.678'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.678")).asAnyElement(),
+                        null, null
+                    )
+                )
+            },
+            DateTimeTestCase("TIMESTAMP '2023-01-02 03:04:05.678901234567890'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.678901234567890")).asAnyElement(),
+                        null, null
+                    )
+                )
+            },
+            DateTimeTestCase("TIMESTAMP(1) '2023-01-02 03:04:05.678901234567890'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.678901234567890")).asAnyElement(),
+                        null, 1
+                    )
+                )
+            },
+            // TIMESTAMP WITH TIME ZONE
+            DateTimeTestCase("TIMESTAMP '2023-01-02 03:04:05+06:07'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        utcOffset(367L), null
+                    )
+                )
+            },
+            DateTimeTestCase("TIMESTAMP '2023-01-02 03:04:05-06:07'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        utcOffset(-367L), null
+                    )
+                )
+            },
+            DateTimeTestCase("TIMESTAMP '2023-01-02 03:04:05-00:00'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        unknownTimezone(), null,
+                    )
+                )
+            },
+            // multiple space
+            DateTimeTestCase("TIMESTAMP '2023-01-02    03:04:05-00:00'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        unknownTimezone(), null
+                    )
+                )
+            },
+            // T as delimiter
+            DateTimeTestCase("TIMESTAMP '2023-01-02T03:04:05-00:00'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        unknownTimezone(), null
+                    )
+                )
+            },
+            // t as delimiter
+            DateTimeTestCase("TIMESTAMP '2023-01-02t03:04:05-00:00'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        unknownTimezone(), null
+                    )
+                )
+            },
+            // Z for UTC
+            DateTimeTestCase("TIMESTAMP '2023-01-02 03:04:05Z'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        utcOffset(0L), null
+                    )
+                )
+            },
+            // z for UTC
+            DateTimeTestCase("TIMESTAMP '2023-01-02 03:04:05z'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        utcOffset(0L), null
+                    )
+                )
+            },
+            DateTimeTestCase("TIMESTAMP '2023-01-02T03:04:05Z'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        utcOffset(0L), null
+                    )
+                )
+            },
+            DateTimeTestCase("TIMESTAMP '2023-01-02t03:04:05z'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        utcOffset(0L), null
+                    )
+                )
+            },
+            DateTimeTestCase("TIMESTAMP WITH TIME ZONE '2023-01-02T03:04:05Z'") {
+                timestamp(
+                    timestampValue(
+                        2023, 1, 2,
+                        3, 4, ionDecimal(Decimal.valueOf("5.")).asAnyElement(),
+                        utcOffset(0L), null
+                    )
+                )
+            },
         )
-        return ErrorTimeTestCase(source, errorCode, ctx, skipTest)
+
+        @JvmStatic
+        fun parametersForTimeParserErrorTests() = listOf(
+            createErrorCaseForDateTime(
+                source = "TIME",
+                line = 1L,
+                col = 5L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.EOF,
+                tokenValue = ION.newSymbol("EOF")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME 123",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_INTEGER,
+                tokenValue = ION.newInt(123)
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME 'time_string'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("time_string")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME 123.23",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_DECIMAL,
+                tokenValue = ION.singleValue("123.23")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME `2012-12-12`",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.ION_CLOSURE,
+                tokenValue = ION.singleValue("2012-12-12")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '2012-12-12'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2012-12-12")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '12'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("12")
+            ),
+            // This is a valid time string in PostgreSQL
+            createErrorCaseForDateTime(
+                source = "TIME '12:30'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("12:30")
+            ),
+            // This is a valid time string in PostgreSQL
+            createErrorCaseForDateTime(
+                source = "TIME '34:59'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("34:59")
+            ),
+            // This is a valid time string in PostgreSQL
+            createErrorCaseForDateTime(
+                source = "TIME '59.12345'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("59.12345")
+            ),
+            // This is a valid time string in PostgreSQL
+            createErrorCaseForDateTime(
+                source = "TIME '1:30:38'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("1:30:38")
+            ),
+            // This is a valid time string in PostgreSQL
+            createErrorCaseForDateTime(
+                source = "TIME '1:30:38'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("1:30:38")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '12:59:61.0000'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("12:59:61.0000")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '12.123:45.123:54.123'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("12.123:45.123:54.123")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '-19:45:13'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("-19:45:13")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '24:00:00'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("24:00:00")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '23:59:59.99999 05:30'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59.99999 05:30")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '23:59:59+05:30.00'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59+05:30.00")
+            ),
+            // TODO: Investigate why the build fails in GH actions for these two tests.
+            createErrorCaseForDateTime(
+                source = "TIME '23:59:59+24:00'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59+24:00"),
+                skipTest = true
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME '23:59:59-24:00'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59-24:00"),
+                skipTest = true
+            ),
+            // This is a valid time string in PostgreSQL
+            createErrorCaseForDateTime(
+                source = "TIME '08:59:59.99999 AM'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("08:59:59.99999 AM")
+            ),
+            // This is a valid time string in PostgreSQL
+            createErrorCaseForDateTime(
+                source = "TIME '08:59:59.99999 PM'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("08:59:59.99999 PM")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME ( '23:59:59.99999'",
+                line = 1L,
+                col = 8L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59.99999"),
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME () '23:59:59.99999'",
+                line = 1L,
+                col = 7L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.PAREN_RIGHT,
+                tokenValue = ION.newSymbol(")")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME [4] '23:59:59.99999'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.BRACKET_LEFT,
+                tokenValue = ION.newSymbol("[")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME {4} '23:59:59.99999'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.BRACE_LEFT,
+                tokenValue = ION.newSymbol("{")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME 4 '23:59:59.99999'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_INTEGER,
+                tokenValue = ION.newInt(4)
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME ('4') '23:59:59.99999'",
+                line = 1L,
+                col = 7L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("4"),
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME (-1) '23:59:59.99999'",
+                line = 1L,
+                col = 7L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.MINUS,
+                tokenValue = ION.newSymbol("-")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME (10) '23:59:59.99999'",
+                line = 1L,
+                col = 7L,
+                errorCode = ErrorCode.PARSE_INVALID_PRECISION_FOR_TIME,
+                tokenType = PartiQLParser.LITERAL_INTEGER,
+                tokenValue = ION.newInt(10)
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME ('four') '23:59:59.99999'",
+                line = 1L,
+                col = 7L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("four")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE",
+                line = 1L,
+                col = 20L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.EOF,
+                tokenValue = ION.newSymbol("EOF")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '12:20'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("12:20")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '34:59'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("34:59")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '59.12345'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("59.12345")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '12:20'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("12:20")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIMEZONE '23:59:59.99999'",
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                line = 1L,
+                col = 11L,
+                tokenType = PartiQLParser.IDENTIFIER,
+                tokenValue = ION.newSymbol("TIMEZONE")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH_TIME_ZONE '23:59:59.99999'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.IDENTIFIER,
+                tokenValue = ION.newSymbol("WITH_TIME_ZONE")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITHTIMEZONE '23:59:59.99999'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.IDENTIFIER,
+                tokenValue = ION.newSymbol("WITHTIMEZONE")
+            ),
+            // PartiQL doesn't support "WITHOUT TIME ZONE" yet. TIME '<time_string>' is in effect the same as TIME WITHOUT TIME ZONE '<time_string>'
+            createErrorCaseForDateTime(
+                source = "TIME WITHOUT TIME ZONE '23:59:59.99999'",
+                line = 1L,
+                col = 6L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.IDENTIFIER,
+                tokenValue = ION.newSymbol("WITHOUT")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME PHONE '23:59:59.99999'",
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                errorContext = mapOf(
+                    Property.LINE_NUMBER to 1L,
+                    Property.COLUMN_NUMBER to 16L,
+                    Property.TOKEN_DESCRIPTION to PartiQLParser.IDENTIFIER.getAntlrDisplayString(),
+                    Property.TOKEN_VALUE to ION.newSymbol("PHONE")
+                )
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH (4) TIME ZONE '23:59:59.99999'",
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                errorContext = mapOf(
+                    Property.LINE_NUMBER to 1L,
+                    Property.COLUMN_NUMBER to 11L,
+                    Property.TOKEN_DESCRIPTION to PartiQLParser.PAREN_LEFT.getAntlrDisplayString(),
+                    Property.TOKEN_VALUE to ION.newSymbol("(")
+                )
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME (4) ZONE '23:59:59.99999'",
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                errorContext = mapOf(
+                    Property.LINE_NUMBER to 1L,
+                    Property.COLUMN_NUMBER to 16L,
+                    Property.TOKEN_DESCRIPTION to PartiQLParser.PAREN_LEFT.getAntlrDisplayString(),
+                    Property.TOKEN_VALUE to ION.newSymbol("(")
+                )
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE (4) '23:59:59.99999'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.PAREN_LEFT,
+                tokenValue = ION.newSymbol("(")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE 'time_string'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("time_string")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '23:59:59+18:00.00'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59+18:00.00")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '23:59:59-18:00.00'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59-18:00.00")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '23:59:59+18:01'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59+18:01")
+            ),
+            // time zone offset out of range
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '23:59:59-18:01'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59-18:01")
+            ),
+            // time zone offset out of range
+            createErrorCaseForDateTime(
+                source = "TIME ('4') WITH TIME ZONE '23:59:59-18:01'",
+                line = 1L,
+                col = 7L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("4"),
+            ),
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '23:59:59-18-01'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59-18-01")
+            ),
+            // This is valid in PostgreSQL.
+            createErrorCaseForDateTime(
+                source = "TIME WITH TIME ZONE '23:59:59 PST'",
+                line = 1L,
+                col = 21L,
+                errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("23:59:59 PST")
+            )
+        )
+
+        @JvmStatic
+        fun parametersForTimestampParserErrorTests() = listOf(
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP",
+                line = 1L,
+                col = 10L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.EOF,
+                tokenValue = ION.newSymbol("EOF")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP 123",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_INTEGER,
+                tokenValue = ION.newInt(123)
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP 'timestamp_string'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("timestamp_string")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP 123.23",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_DECIMAL,
+                tokenValue = ION.singleValue("123.23")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP `2012-12-12`",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.ION_CLOSURE,
+                tokenValue = ION.singleValue("2012-12-12")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2012-12-12'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2012-12-12")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '12'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("12")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '12:30'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("12:30")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 34:59'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 34:59")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2021-01-02 59.12345'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2021-01-02 59.12345")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-01 1:30:38'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-01 1:30:38")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 12:59:61.0000'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 12:59:61.0000")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 12.123:45.123:54.123'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 12.123:45.123:54.123")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 -19:45:13'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 -19:45:13")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 24:00:00'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 24:00:00")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 23:59:59.99999 05:30'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59.99999 05:30")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 23:59:59+05:30.00'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59+05:30.00")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 23:59:59+24:00'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59+24:00"),
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 23:59:59-24:00'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59-24:00"),
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 08:59:59.99999 AM'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 08:59:59.99999 AM")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP '2023-01-02 08:59:59.99999 PM'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 08:59:59.99999 PM")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP ( '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 13L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59.99999"),
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP () '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 12L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.PAREN_RIGHT,
+                tokenValue = ION.newSymbol(")")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP [4] '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.BRACKET_LEFT,
+                tokenValue = ION.newSymbol("[")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP {4} '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.BRACE_LEFT,
+                tokenValue = ION.newSymbol("{")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP 4 '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_INTEGER,
+                tokenValue = ION.newInt(4)
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP ('4') '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 12L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("4"),
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP (-1) '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 12L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.MINUS,
+                tokenValue = ION.newSymbol("-")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP ('four') '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 12L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("four")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE",
+                line = 1L,
+                col = 25L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.EOF,
+                tokenValue = ION.newSymbol("EOF")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 12:20'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 12:20")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 34:59'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 34:59")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 59.12345'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 59.12345")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 12:20'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 12:20")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIMEZONE '2023-01-02 23:59:59.99999'",
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                line = 1L,
+                col = 16L,
+                tokenType = PartiQLParser.IDENTIFIER,
+                tokenValue = ION.newSymbol("TIMEZONE")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH_TIME_ZONE '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.IDENTIFIER,
+                tokenValue = ION.newSymbol("WITH_TIME_ZONE")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITHTIMEZONE '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.IDENTIFIER,
+                tokenValue = ION.newSymbol("WITHTIMEZONE")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITHOUT TIME ZONE '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 11L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.IDENTIFIER,
+                tokenValue = ION.newSymbol("WITHOUT")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME PHONE '2023-01-02 23:59:59.99999'",
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                errorContext = mapOf(
+                    Property.LINE_NUMBER to 1L,
+                    Property.COLUMN_NUMBER to 21L,
+                    Property.TOKEN_DESCRIPTION to PartiQLParser.IDENTIFIER.getAntlrDisplayString(),
+                    Property.TOKEN_VALUE to ION.newSymbol("PHONE")
+                )
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH (4) TIME ZONE '2023-01-02 23:59:59.99999'",
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                errorContext = mapOf(
+                    Property.LINE_NUMBER to 1L,
+                    Property.COLUMN_NUMBER to 16L,
+                    Property.TOKEN_DESCRIPTION to PartiQLParser.PAREN_LEFT.getAntlrDisplayString(),
+                    Property.TOKEN_VALUE to ION.newSymbol("(")
+                )
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME (4) ZONE '2023-01-02 23:59:59.99999'",
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                errorContext = mapOf(
+                    Property.LINE_NUMBER to 1L,
+                    Property.COLUMN_NUMBER to 21L,
+                    Property.TOKEN_DESCRIPTION to PartiQLParser.PAREN_LEFT.getAntlrDisplayString(),
+                    Property.TOKEN_VALUE to ION.newSymbol("(")
+                )
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE (4) '2023-01-02 23:59:59.99999'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.PAREN_LEFT,
+                tokenValue = ION.newSymbol("(")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE 'timestamp_string'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("timestamp_string")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 23:59:59+18:00.00'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59+18:00.00")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 23:59:59-18:00.00'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59-18:00.00")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 23:59:59+24:01'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59+24:01")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 23:59:59-24:01'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59-24:01")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP ('4') WITH TIME ZONE '2023-01-02 23:59:59-24:01'",
+                line = 1L,
+                col = 12L,
+                errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("4"),
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 23:59:59 PST'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59 PST")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02 23:59:59'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02 23:59:59")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02TT23:59:59'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02TT23:59:59")
+            ),
+            createErrorCaseForDateTime(
+                source = "TIMESTAMP WITH TIME ZONE '2023-01-02T23:59:59Zz'",
+                line = 1L,
+                col = 26L,
+                errorCode = ErrorCode.PARSE_INVALID_DATETIME_STRING,
+                tokenType = PartiQLParser.LITERAL_STRING,
+                tokenValue = ION.newString("2023-01-02T23:59:59Zz")
+            )
+        )
+
+        private fun createErrorCaseForDateTime(
+            source: String,
+            errorCode: ErrorCode,
+            line: Long,
+            col: Long,
+            tokenType: Int,
+            tokenValue: IonValue,
+            skipTest: Boolean = false,
+        ): ErrorDateTimeTestCase {
+            val displayTokenType = tokenType.getAntlrDisplayString()
+            val ctx = mapOf(
+                Property.LINE_NUMBER to line,
+                Property.COLUMN_NUMBER to col,
+                Property.TOKEN_DESCRIPTION to displayTokenType,
+                Property.TOKEN_VALUE to tokenValue
+            )
+            return ErrorDateTimeTestCase(source, errorCode, ctx, skipTest)
+        }
+
+        private fun createErrorCaseForDateTime(source: String, errorCode: ErrorCode, errorContext: Map<Property, Any>) =
+            ErrorDateTimeTestCase(source, errorCode, errorContext)
     }
 
-    private fun runErrorTimeTestCase(tc: ErrorTimeTestCase) {
+    private fun runDateTimeTest(tc: DateTimeTestCase) = if (!tc.skipTest) {
+        assertExpression(tc.source, expectedPigBuilder = tc.block)
+    } else {
+        // Skip test, do nothing
+    }
+
+    @ParameterizedTest
+    @MethodSource("parametersForDateLiteralTests")
+    fun dateLiteralTests(tc: DateTimeTestCase) = runDateTimeTest(tc)
+
+    @ParameterizedTest
+    @MethodSource("parameterForTimeLiteralTests")
+    fun timeLiteralTests(tc: DateTimeTestCase) = runDateTimeTest(tc)
+
+    @ParameterizedTest
+    @MethodSource("parameterForTimestampLiteralTests")
+    fun timestampLiteralTests(tc: DateTimeTestCase) = runDateTimeTest(tc)
+
+    private fun runErrorTimeTestCase(tc: ErrorDateTimeTestCase) {
         if (!tc.skipTest) {
             checkInputThrowingParserException(
                 tc.source,
                 tc.errorCode,
-                tc.ctx
+                tc.ctx,
+                assertContext = false,
             )
         }
     }
 
-    fun parametersForDateLiteralTests() = listOf(
-        DateTimeTestCase("DATE '2012-02-29'") {
-            date(2012, 2, 29)
-        },
-        DateTimeTestCase("DATE'1992-11-30'") {
-            date(1992, 11, 30)
-        },
-        DateTimeTestCase("DATE '9999-03-01'") {
-            date(9999, 3, 1)
-        },
-        DateTimeTestCase("DATE '0000-01-01'") {
-            date(0, 1, 1)
-        },
-        DateTimeTestCase("DATE '0000-02-29'") {
-            date(0, 2, 29)
-        },
-        DateTimeTestCase("DATE '0000-02-29'") {
-            date(0, 2, 29)
-        },
-        DateTimeTestCase("SELECT DATE '2021-03-10' FROM foo") {
-            select(
-                project = projectList(projectExpr(date(2021, 3, 10))),
-                from = scan(id("foo"))
-            )
-        },
-        DateTimeTestCase("TIME '02:30:59'") {
-            litTime(timeValue(2, 30, 59, 0, 0, false, null))
-        },
-        DateTimeTestCase("TIME (3) '12:59:31'") {
-            litTime(timeValue(12, 59, 31, 0, 3, false, null))
-        },
-        DateTimeTestCase("TIME '23:59:59.9999'") {
-            litTime(timeValue(23, 59, 59, 999900000, 4, false, null))
-        },
-        DateTimeTestCase("TIME (7) '23:59:59.123456789'") {
-            litTime(timeValue(23, 59, 59, 123456789, 7, false, null))
-        },
-        DateTimeTestCase("TIME (9) '23:59:59.123456789'") {
-            litTime(timeValue(23, 59, 59, 123456789, 9, false, null))
-        },
-        DateTimeTestCase("TIME (0) '23:59:59.123456789'") {
-            litTime(timeValue(23, 59, 59, 123456789, 0, false, null))
-        },
-        DateTimeTestCase("TIME '02:30:59-05:30'") {
-            litTime(timeValue(2, 30, 59, 0, 0, false, null))
-        },
-        DateTimeTestCase("TIME '02:30:59+05:30'") {
-            litTime(timeValue(2, 30, 59, 0, 0, false, null))
-        },
-        DateTimeTestCase("TIME '02:30:59-14:39'") {
-            litTime(timeValue(2, 30, 59, 0, 0, false, null))
-        },
-        DateTimeTestCase("TIME '02:30:59+00:00'") {
-            litTime(timeValue(2, 30, 59, 0, 0, false, null))
-        },
-        DateTimeTestCase("TIME '02:30:59-00:00'") {
-            litTime(timeValue(2, 30, 59, 0, 0, false, null))
-        },
-        DateTimeTestCase("TIME (3) '12:59:31+10:30'") {
-            litTime(timeValue(12, 59, 31, 0, 3, false, null))
-        },
-        DateTimeTestCase("TIME (0) '00:00:00+00:00'") {
-            litTime(timeValue(0, 0, 0, 0, 0, false, null))
-        },
-        DateTimeTestCase("TIME (0) '00:00:00-00:00'") {
-            litTime(timeValue(0, 0, 0, 0, 0, false, null))
-        },
-        DateTimeTestCase("TIME '23:59:59.9999-11:59'") {
-            litTime(timeValue(23, 59, 59, 999900000, 4, false, null))
-        },
-        DateTimeTestCase("TIME '23:59:59.99990-11:59'") {
-            litTime(timeValue(23, 59, 59, 999900000, 5, false, null))
-        },
-        DateTimeTestCase("TIME (5) '23:59:59.9999-11:59'") {
-            litTime(timeValue(23, 59, 59, 999900000, 5, false, null))
-        },
-        DateTimeTestCase("TIME (7) '23:59:59.123456789+01:00'") {
-            litTime(timeValue(23, 59, 59, 123456789, 7, false, null))
-        },
-        DateTimeTestCase("TIME (9) '23:59:59.123456789-14:50'") {
-            litTime(timeValue(23, 59, 59, 123456789, 9, false, null))
-        },
-        DateTimeTestCase("TIME (0) '23:59:59.123456789-18:00'") {
-            litTime(timeValue(23, 59, 59, 123456789, 0, false, null))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '02:30:59'") {
-            litTime(timeValue(2, 30, 59, 0, 0, true, null))
-        },
-        DateTimeTestCase("TIME (3) WITH TIME ZONE '12:59:31'") {
-            litTime(timeValue(12, 59, 31, 0, 3, true, null))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.9999'") {
-            litTime(timeValue(23, 59, 59, 999900000, 4, true, null))
-        },
-        DateTimeTestCase("TIME (7) WITH TIME ZONE '23:59:59.123456789'") {
-            litTime(timeValue(23, 59, 59, 123456789, 7, true, null))
-        },
-        DateTimeTestCase("TIME (9) WITH TIME ZONE '23:59:59.123456789'") {
-            litTime(timeValue(23, 59, 59, 123456789, 9, true, null))
-        },
-        DateTimeTestCase("TIME (0) WITH TIME ZONE '23:59:59.123456789'") {
-            litTime(timeValue(23, 59, 59, 123456789, 0, true, null))
-        },
-        DateTimeTestCase("TIME (0) WITH TIME ZONE '00:00:00+00:00'") {
-            litTime(timeValue(0, 0, 0, 0, 0, true, 0))
-        },
-        DateTimeTestCase("TIME (0) WITH TIME ZONE '00:00:00.0000-00:00'") {
-            litTime(timeValue(0, 0, 0, 0, 0, true, 0))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '02:30:59.1234500-05:30'") {
-            litTime(timeValue(2, 30, 59, 123450000, 7, true, -330))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '02:30:59+05:30'") {
-            litTime(timeValue(2, 30, 59, 0, 0, true, 330))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '02:30:59-14:39'") {
-            litTime(timeValue(2, 30, 59, 0, 0, true, -879))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.9999-11:59'") {
-            litTime(timeValue(23, 59, 59, 999900000, 4, true, -719))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.99990-11:59'") {
-            litTime(timeValue(23, 59, 59, 999900000, 5, true, -719))
-        },
-        DateTimeTestCase("TIME (5) WITH TIME ZONE '23:59:59.9999-11:59'") {
-            litTime(timeValue(23, 59, 59, 999900000, 5, true, -719))
-        },
-        DateTimeTestCase("TIME (7) WITH TIME ZONE '23:59:59.123456789+01:00'") {
-            litTime(timeValue(23, 59, 59, 123456789, 7, true, 60))
-        },
-        DateTimeTestCase("TIME (9) WITH TIME ZONE '23:59:59.123456789-14:50'") {
-            litTime(timeValue(23, 59, 59, 123456789, 9, true, -890))
-        },
-        DateTimeTestCase("TIME (0) WITH TIME ZONE '23:59:59.123456789-18:00'") {
-            litTime(timeValue(23, 59, 59, 123456789, 0, true, -1080))
-        },
-        // TODO: These tests should pass. Check https://github.com/partiql/partiql-lang-kotlin/issues/395
-        DateTimeTestCase("TIME '23:59:59.1234567890'", skipTest = true) {
-            litTime(timeValue(23, 59, 59, 123456789, 9, false, null))
-        },
-        DateTimeTestCase("TIME '23:59:59.1234567899'", skipTest = true) {
-            litTime(timeValue(23, 59, 59, 123456790, 9, false, null))
-        },
-        DateTimeTestCase("TIME '23:59:59.1234567890+18:00'", skipTest = true) {
-            litTime(timeValue(23, 59, 59, 123456789, 9, false, null))
-        },
-        DateTimeTestCase("TIME '23:59:59.1234567899+18:00'", skipTest = true) {
-            litTime(timeValue(23, 59, 59, 123456790, 9, false, null))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.1234567890'", skipTest = true) {
-            litTime(timeValue(23, 59, 59, 123456789, 9, true, null))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.1234567899'", skipTest = true) {
-            litTime(timeValue(23, 59, 59, 123456790, 9, true, null))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.1234567890+18:00'", skipTest = true) {
-            litTime(timeValue(23, 59, 59, 123456789, 9, true, 1080))
-        },
-        DateTimeTestCase("TIME WITH TIME ZONE '23:59:59.1234567899+18:00'", skipTest = true) {
-            litTime(timeValue(23, 59, 59, 123456790, 9, true, 1080))
-        }
-    )
-
-    private fun createErrorCaseForTime(source: String, errorCode: ErrorCode, errorContext: Map<Property, Any>) = ErrorTimeTestCase(source, errorCode, errorContext)
-
-    fun parametersForTimeParserErrorTests() = listOf(
-        createErrorCaseForTime(
-            source = "TIME",
-            line = 1L,
-            col = 5L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.EOF,
-            tokenValue = ion.newSymbol("EOF")
-        ),
-        createErrorCaseForTime(
-            source = "TIME 123",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.LITERAL_INTEGER,
-            tokenValue = ion.newInt(123)
-        ),
-        createErrorCaseForTime(
-            source = "TIME 'time_string'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("time_string")
-        ),
-        createErrorCaseForTime(
-            source = "TIME 123.23",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.LITERAL_DECIMAL,
-            tokenValue = ion.singleValue("123.23")
-        ),
-        createErrorCaseForTime(
-            source = "TIME `2012-12-12`",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.ION_CLOSURE,
-            tokenValue = ion.singleValue("2012-12-12")
-        ),
-        createErrorCaseForTime(
-            source = "TIME '2012-12-12'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("2012-12-12")
-        ),
-        createErrorCaseForTime(
-            source = "TIME '12'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("12")
-        ),
-        // This is a valid time string in PostgreSQL
-        createErrorCaseForTime(
-            source = "TIME '12:30'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("12:30")
-        ),
-        // This is a valid time string in PostgreSQL
-        createErrorCaseForTime(
-            source = "TIME '34:59'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("34:59")
-        ),
-        // This is a valid time string in PostgreSQL
-        createErrorCaseForTime(
-            source = "TIME '59.12345'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("59.12345")
-        ),
-        // This is a valid time string in PostgreSQL
-        createErrorCaseForTime(
-            source = "TIME '1:30:38'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("1:30:38")
-        ),
-        // This is a valid time string in PostgreSQL
-        createErrorCaseForTime(
-            source = "TIME '1:30:38'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("1:30:38")
-        ),
-        createErrorCaseForTime(
-            source = "TIME '12:59:61.0000'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("12:59:61.0000")
-        ),
-        createErrorCaseForTime(
-            source = "TIME '12.123:45.123:54.123'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("12.123:45.123:54.123")
-        ),
-        createErrorCaseForTime(
-            source = "TIME '-19:45:13'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("-19:45:13")
-        ),
-        createErrorCaseForTime(
-            source = "TIME '24:00:00'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("24:00:00")
-        ),
-        createErrorCaseForTime(
-            source = "TIME '23:59:59.99999 05:30'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59.99999 05:30")
-        ),
-        createErrorCaseForTime(
-            source = "TIME '23:59:59+05:30.00'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59+05:30.00")
-        ),
-        // TODO: Investigate why the build fails in GH actions for these two tests.
-        createErrorCaseForTime(
-            source = "TIME '23:59:59+24:00'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59+24:00"),
-            skipTest = true
-        ),
-        createErrorCaseForTime(
-            source = "TIME '23:59:59-24:00'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59-24:00"),
-            skipTest = true
-        ),
-        // This is a valid time string in PostgreSQL
-        createErrorCaseForTime(
-            source = "TIME '08:59:59.99999 AM'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("08:59:59.99999 AM")
-        ),
-        // This is a valid time string in PostgreSQL
-        createErrorCaseForTime(
-            source = "TIME '08:59:59.99999 PM'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("08:59:59.99999 PM")
-        ),
-        createErrorCaseForTime(
-            source = "TIME ( '23:59:59.99999'",
-            line = 1L,
-            col = 8L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59.99999"),
-        ),
-        createErrorCaseForTime(
-            source = "TIME () '23:59:59.99999'",
-            line = 1L,
-            col = 7L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.PAREN_RIGHT,
-            tokenValue = ion.newSymbol(")")
-        ),
-        createErrorCaseForTime(
-            source = "TIME [4] '23:59:59.99999'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.BRACKET_LEFT,
-            tokenValue = ion.newSymbol("[")
-        ),
-        createErrorCaseForTime(
-            source = "TIME {4} '23:59:59.99999'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.BRACE_LEFT,
-            tokenValue = ion.newSymbol("{")
-        ),
-        createErrorCaseForTime(
-            source = "TIME 4 '23:59:59.99999'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.LITERAL_INTEGER,
-            tokenValue = ion.newInt(4)
-        ),
-        createErrorCaseForTime(
-            source = "TIME ('4') '23:59:59.99999'",
-            line = 1L,
-            col = 7L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("4"),
-        ),
-        createErrorCaseForTime(
-            source = "TIME (-1) '23:59:59.99999'",
-            line = 1L,
-            col = 7L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.MINUS,
-            tokenValue = ion.newSymbol("-")
-        ),
-        createErrorCaseForTime(
-            source = "TIME (10) '23:59:59.99999'",
-            line = 1L,
-            col = 7L,
-            errorCode = ErrorCode.PARSE_INVALID_PRECISION_FOR_TIME,
-            tokenType = PartiQLParser.LITERAL_INTEGER,
-            tokenValue = ion.newInt(10)
-        ),
-        createErrorCaseForTime(
-            source = "TIME ('four') '23:59:59.99999'",
-            line = 1L,
-            col = 7L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("four")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE",
-            line = 1L,
-            col = 20L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.EOF,
-            tokenValue = ion.newSymbol("EOF")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '12:20'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("12:20")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '34:59'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("34:59")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '59.12345'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("59.12345")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '12:20'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("12:20")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIMEZONE '23:59:59.99999'",
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            line = 1L,
-            col = 11L,
-            tokenType = PartiQLParser.IDENTIFIER,
-            tokenValue = ion.newSymbol("TIMEZONE")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH_TIME_ZONE '23:59:59.99999'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.IDENTIFIER,
-            tokenValue = ion.newSymbol("WITH_TIME_ZONE")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITHTIMEZONE '23:59:59.99999'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.IDENTIFIER,
-            tokenValue = ion.newSymbol("WITHTIMEZONE")
-        ),
-        // PartiQL doesn't support "WITHOUT TIME ZONE" yet. TIME '<time_string>' is in effect the same as TIME WITHOUT TIME ZONE '<time_string>'
-        createErrorCaseForTime(
-            source = "TIME WITHOUT TIME ZONE '23:59:59.99999'",
-            line = 1L,
-            col = 6L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.IDENTIFIER,
-            tokenValue = ion.newSymbol("WITHOUT")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME PHONE '23:59:59.99999'",
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            errorContext = mapOf(
-                Property.LINE_NUMBER to 1L,
-                Property.COLUMN_NUMBER to 16L,
-                Property.TOKEN_DESCRIPTION to PartiQLParser.IDENTIFIER.getAntlrDisplayString(),
-                Property.TOKEN_VALUE to ion.newSymbol("PHONE")
-            )
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH (4) TIME ZONE '23:59:59.99999'",
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            errorContext = mapOf(
-                Property.LINE_NUMBER to 1L,
-                Property.COLUMN_NUMBER to 11L,
-                Property.TOKEN_DESCRIPTION to PartiQLParser.PAREN_LEFT.getAntlrDisplayString(),
-                Property.TOKEN_VALUE to ion.newSymbol("(")
-            )
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME (4) ZONE '23:59:59.99999'",
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            errorContext = mapOf(
-                Property.LINE_NUMBER to 1L,
-                Property.COLUMN_NUMBER to 16L,
-                Property.TOKEN_DESCRIPTION to PartiQLParser.PAREN_LEFT.getAntlrDisplayString(),
-                Property.TOKEN_VALUE to ion.newSymbol("(")
-            )
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE (4) '23:59:59.99999'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.PAREN_LEFT,
-            tokenValue = ion.newSymbol("(")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE 'time_string'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("time_string")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '23:59:59+18:00.00'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59+18:00.00")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '23:59:59-18:00.00'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59-18:00.00")
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '23:59:59+18:01'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59+18:01")
-        ),
-        // time zone offset out of range
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '23:59:59-18:01'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59-18:01")
-        ),
-        // time zone offset out of range
-        createErrorCaseForTime(
-            source = "TIME ('4') WITH TIME ZONE '23:59:59-18:01'",
-            line = 1L,
-            col = 7L,
-            errorCode = ErrorCode.PARSE_UNEXPECTED_TOKEN,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("4"),
-        ),
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '23:59:59-18-01'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59-18-01")
-        ),
-        // This is valid in PostgreSQL.
-        createErrorCaseForTime(
-            source = "TIME WITH TIME ZONE '23:59:59 PST'",
-            line = 1L,
-            col = 21L,
-            errorCode = ErrorCode.PARSE_INVALID_TIME_STRING,
-            tokenType = PartiQLParser.LITERAL_STRING,
-            tokenValue = ion.newString("23:59:59 PST")
-        )
-    )
+    @ParameterizedTest
+    @MethodSource("parametersForTimeParserErrorTests")
+    fun timeParserErrorTests(tc: ErrorDateTimeTestCase) = runErrorTimeTestCase(tc)
 
-    @Test
-    @Parameters
-    @TestCaseName("{method} {0}")
-    fun timeParserErrorTests(tc: ErrorTimeTestCase) = runErrorTimeTestCase(tc)
+    @ParameterizedTest
+    @MethodSource("parametersForTimestampParserErrorTests")
+    fun timestampParserErrorTests(tc: ErrorDateTimeTestCase) = runErrorTimeTestCase(tc)
 }
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserExplainTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserExplainTest.kt
index ace137b975..86e1c03b77 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserExplainTest.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserExplainTest.kt
@@ -26,6 +26,8 @@ import org.partiql.parser.antlr.PartiQLParser
 
 class PartiQLParserExplainTest : PartiQLParserTestBase() {
 
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     data class ParserTestCase(
         val description: String? = null,
         val query: String,
@@ -45,7 +47,7 @@ class PartiQLParserExplainTest : PartiQLParserTestBase() {
 
     @ArgumentsSource(ErrorTestProvider::class)
     @ParameterizedTest
-    fun errorTests(tc: ParserErrorTestCase) = checkInputThrowingParserException(tc.query, tc.code, tc.context)
+    fun errorTests(tc: ParserErrorTestCase) = checkInputThrowingParserException(tc.query, tc.code, tc.context, assertContext = false)
 
     class SuccessTestProvider : ArgumentsProviderBase() {
         override fun getParameters() = listOf(
@@ -145,7 +147,7 @@ class PartiQLParserExplainTest : PartiQLParserTestBase() {
                     Property.COLUMN_NUMBER to 36L,
                     Property.TOKEN_DESCRIPTION to PartiQLParser.EOF.getAntlrDisplayString(),
                     Property.TOKEN_VALUE to ION.newSymbol("EOF")
-                )
+                ),
             ),
             ParserErrorTestCase(
                 description = "Setting option twice",
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserJoinTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserJoinTest.kt
index 4154e6c983..7e198be3cf 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserJoinTest.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserJoinTest.kt
@@ -7,6 +7,9 @@ import org.partiql.lang.domains.PartiqlAst
 import org.partiql.lang.domains.id
 
 class PartiQLParserJoinTest : PartiQLParserTestBase() {
+
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     private val projectX = PartiqlAst.build { projectList(projectExpr(id("x"))) }
 
     private fun PartiqlAst.Builder.selectWithOneJoin(
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserMatchTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserMatchTest.kt
index 252683d54f..d45c4a4fb1 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserMatchTest.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserMatchTest.kt
@@ -3,7 +3,6 @@ package org.partiql.lang.syntax
 import com.amazon.ionelement.api.ionBool
 import com.amazon.ionelement.api.ionInt
 import com.amazon.ionelement.api.ionString
-import org.junit.Ignore
 import org.junit.Test
 import org.partiql.lang.domains.PartiqlAst
 import org.partiql.lang.domains.id
@@ -11,6 +10,8 @@ import kotlin.test.assertFailsWith
 
 class PartiQLParserMatchTest : PartiQLParserTestBase() {
 
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     @Test
     fun loneMatchExpr1path() = assertExpression(
         "(MyGraph MATCH (x))"
@@ -60,7 +61,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                             node(
                                 prefilter = null,
                                 variable = "x",
-                                label = listOf()
                             )
                         )
                     ),
@@ -88,7 +88,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                             node(
                                 prefilter = null,
                                 variable = "x",
-                                label = listOf()
                             )
                         )
                     )
@@ -212,7 +211,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     )
                                 )
                             )
@@ -240,7 +238,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     )
                                 )
                             )
@@ -267,7 +264,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     )
                                 )
                             )
@@ -294,7 +290,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                             node(
                                                 prefilter = null,
                                                 variable = "x",
-                                                label = listOf()
                                             )
                                         )
                                     )
@@ -368,7 +363,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = "x",
-                                        label = listOf()
                                     )
                                 )
                             )
@@ -399,7 +393,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = "x",
-                                        label = listOf("Label")
+                                        label = graphLabelName("Label")
                                     )
                                 )
                             )
@@ -434,7 +428,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                         quantifier = null,
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     )
                                 )
                             )
@@ -464,7 +457,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                         quantifier = null,
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     ),
                                 )
                             ),
@@ -473,7 +465,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     )
                                 )
                             )
@@ -501,7 +492,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     )
                                 )
                             ),
@@ -512,7 +502,6 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                         quantifier = null,
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     )
                                 )
                             )
@@ -525,7 +514,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     }
 
     val simpleGraphAST =
-        { direction: PartiqlAst.GraphMatchDirection, quantifier: PartiqlAst.GraphMatchQuantifier?, variable: String?, label: List<String>? ->
+        { direction: PartiqlAst.GraphMatchDirection, quantifier: PartiqlAst.GraphMatchQuantifier?, variable: String?, label: String? ->
             PartiqlAst.build {
                 select(
                     project = projectList(projectExpr(id("a")), projectExpr(id("b"))),
@@ -540,19 +529,19 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                             node(
                                                 prefilter = null,
                                                 variable = "a",
-                                                label = listOf("A")
+                                                label = graphLabelName("A")
                                             ),
                                             edge(
                                                 direction = direction,
                                                 quantifier = quantifier,
                                                 prefilter = null,
                                                 variable = variable,
-                                                label = label ?: emptyList()
+                                                label = label?.let { graphLabelName(it) }
                                             ),
                                             node(
                                                 prefilter = null,
                                                 variable = "b",
-                                                label = listOf("B")
+                                                label = graphLabelName("B")
                                             ),
                                         )
                                     )
@@ -569,7 +558,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     fun rightDirected() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A) -[e:E]-> (b:B)",
     ) {
-        simpleGraphAST(edgeRight(), null, "e", listOf("E"))
+        simpleGraphAST(edgeRight(), null, "e", "E")
     }
 
     @Test
@@ -583,7 +572,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     fun leftDirected() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A) <-[e:E]- (b:B)",
     ) {
-        simpleGraphAST(edgeLeft(), null, "e", listOf("E"))
+        simpleGraphAST(edgeLeft(), null, "e", "E")
     }
 
     @Test
@@ -597,7 +586,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     fun undirected() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A) ~[e:E]~ (b:B)",
     ) {
-        simpleGraphAST(edgeUndirected(), null, "e", listOf("E"))
+        simpleGraphAST(edgeUndirected(), null, "e", "E")
     }
 
     @Test
@@ -611,7 +600,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     fun rightOrUnDirected() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A) ~[e:E]~> (b:B)",
     ) {
-        simpleGraphAST(edgeUndirectedOrRight(), null, "e", listOf("E"))
+        simpleGraphAST(edgeUndirectedOrRight(), null, "e", "E")
     }
 
     @Test
@@ -625,7 +614,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     fun leftOrUnDirected() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A) <~[e:E]~ (b:B)",
     ) {
-        simpleGraphAST(edgeLeftOrUndirected(), null, "e", listOf("E"))
+        simpleGraphAST(edgeLeftOrUndirected(), null, "e", "E")
     }
 
     @Test
@@ -639,7 +628,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     fun leftOrRight() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A) <-[e:E]-> (b:B)",
     ) {
-        simpleGraphAST(edgeLeftOrRight(), null, "e", listOf("E"))
+        simpleGraphAST(edgeLeftOrRight(), null, "e", "E")
     }
 
     @Test
@@ -653,7 +642,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     fun leftOrRightOrUndirected() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A) -[e:E]- (b:B)",
     ) {
-        simpleGraphAST(edgeLeftOrUndirectedOrRight(), null, "e", listOf("E"))
+        simpleGraphAST(edgeLeftOrUndirectedOrRight(), null, "e", "E")
     }
 
     @Test
@@ -667,28 +656,28 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
     fun quantifierStar() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A)-[:edge]->*(b:B)",
     ) {
-        simpleGraphAST(edgeRight(), graphMatchQuantifier(lower = 0, upper = null), null, listOf("edge"))
+        simpleGraphAST(edgeRight(), graphMatchQuantifier(lower = 0, upper = null), null, "edge")
     }
 
     @Test
     fun quantifierPlus() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A)<-[:edge]-+(b:B)",
     ) {
-        simpleGraphAST(edgeLeft(), graphMatchQuantifier(lower = 1, upper = null), null, listOf("edge"))
+        simpleGraphAST(edgeLeft(), graphMatchQuantifier(lower = 1, upper = null), null, "edge")
     }
 
     @Test
     fun quantifierM() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A)~[:edge]~{5,}(b:B)",
     ) {
-        simpleGraphAST(edgeUndirected(), graphMatchQuantifier(lower = 5, upper = null), null, listOf("edge"))
+        simpleGraphAST(edgeUndirected(), graphMatchQuantifier(lower = 5, upper = null), null, "edge")
     }
 
     @Test
     fun quantifierMN() = assertExpression(
         "SELECT a,b FROM g MATCH (a:A)-[e:edge]-{2,6}(b:B)",
     ) {
-        simpleGraphAST(edgeLeftOrUndirectedOrRight(), graphMatchQuantifier(lower = 2, upper = 6), "e", listOf("edge"))
+        simpleGraphAST(edgeLeftOrUndirectedOrRight(), graphMatchQuantifier(lower = 2, upper = 6), "e", "edge")
     }
 
     @Test
@@ -744,19 +733,19 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = "the_a",
-                                        label = listOf("a")
+                                        label = graphLabelName("a")
                                     ),
                                     edge(
                                         direction = edgeRight(),
                                         quantifier = null,
                                         prefilter = null,
                                         variable = "the_y",
-                                        label = listOf("y")
+                                        label = graphLabelName("y")
                                     ),
                                     node(
                                         prefilter = null,
                                         variable = "the_b",
-                                        label = listOf("b")
+                                        label = graphLabelName("b")
                                     ),
                                 )
                             )
@@ -792,19 +781,17 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = "a",
-                                        label = listOf()
                                     ),
                                     edge(
                                         direction = edgeRight(),
                                         quantifier = null,
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf("has")
+                                        label = graphLabelName("has")
                                     ),
                                     node(
                                         prefilter = null,
                                         variable = "x",
-                                        label = listOf()
                                     ),
                                 )
                             ),
@@ -813,19 +800,17 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = "x",
-                                        label = listOf()
                                     ),
                                     edge(
                                         direction = edgeRight(),
                                         quantifier = null,
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf("contains")
+                                        label = graphLabelName("contains")
                                     ),
                                     node(
                                         prefilter = null,
                                         variable = "b",
-                                        label = listOf()
                                     ),
                                 )
                             )
@@ -855,31 +840,28 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     node(
                                         prefilter = null,
                                         variable = "a",
-                                        label = listOf()
                                     ),
                                     edge(
                                         direction = edgeRight(),
                                         quantifier = null,
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf("has")
+                                        label = graphLabelName("has")
                                     ),
                                     node(
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf()
                                     ),
                                     edge(
                                         direction = edgeRight(),
                                         quantifier = null,
                                         prefilter = null,
                                         variable = null,
-                                        label = listOf("contains")
+                                        label = graphLabelName("contains")
                                     ),
                                     node(
                                         prefilter = null,
                                         variable = "b",
-                                        label = listOf()
                                     ),
                                 )
                             )
@@ -907,16 +889,16 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     parts = listOf(
                                         node(
                                             variable = "a",
-                                            label = listOf("A")
+                                            label = graphLabelName("A")
                                         ),
                                         edge(
                                             direction = edgeRight(),
                                             variable = "e",
-                                            label = listOf("E")
+                                            label = graphLabelName("E")
                                         ),
                                         node(
                                             variable = "b",
-                                            label = listOf("B")
+                                            label = graphLabelName("B")
                                         ),
                                     )
                                 )
@@ -953,16 +935,16 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                                 parts = listOf(
                                                     node(
                                                         variable = "a",
-                                                        label = listOf("A")
+                                                        label = graphLabelName("A")
                                                     ),
                                                     edge(
                                                         direction = edgeRight(),
                                                         variable = "e",
-                                                        label = listOf("Edge")
+                                                        label = graphLabelName("Edge")
                                                     ),
                                                     node(
                                                         variable = "b",
-                                                        label = listOf("A")
+                                                        label = graphLabelName("A")
                                                     ),
                                                 ),
                                             )
@@ -995,7 +977,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     parts = listOf(
                                         node(
                                             variable = "a",
-                                            label = listOf("A")
+                                            label = graphLabelName("A")
                                         ),
                                         pattern(
                                             graphMatchPattern(
@@ -1005,7 +987,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                                     edge(
                                                         direction = edgeRight(),
                                                         variable = "e",
-                                                        label = listOf("Edge")
+                                                        label = graphLabelName("Edge")
                                                     ),
                                                     node(),
                                                 )
@@ -1013,7 +995,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                         ),
                                         node(
                                             variable = "b",
-                                            label = listOf("B")
+                                            label = graphLabelName("B")
                                         ),
                                     )
                                 )
@@ -1040,7 +1022,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     parts = listOf(
                                         node(
                                             variable = "a",
-                                            label = listOf("A")
+                                            label = graphLabelName("A")
                                         ),
                                         pattern(
                                             graphMatchPattern(
@@ -1049,14 +1031,14 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                                     edge(
                                                         direction = edgeRight(),
                                                         variable = "e",
-                                                        label = listOf("Edge")
+                                                        label = graphLabelName("Edge")
                                                     ),
                                                 )
                                             )
                                         ),
                                         node(
                                             variable = "b",
-                                            label = listOf("B")
+                                            label = graphLabelName("B")
                                         ),
                                     )
                                 )
@@ -1099,7 +1081,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                     parts = listOf(
                                         node(
                                             variable = "p",
-                                            label = listOf("Post"),
+                                            label = graphLabelName("Post"),
                                             prefilter = eq(
                                                 path(id("p"), pathExpr(lit(ionString("isFlagged")), caseInsensitive())),
                                                 lit(ionBool(true))
@@ -1107,11 +1089,11 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                         ),
                                         edge(
                                             direction = edgeLeft(),
-                                            label = listOf("createdPost")
+                                            label = graphLabelName("createdPost")
                                         ),
                                         node(
                                             variable = "u",
-                                            label = listOf("Usr"),
+                                            label = graphLabelName("Usr"),
                                             prefilter = and(
                                                 eq(
                                                     path(
@@ -1128,11 +1110,11 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                         ),
                                         edge(
                                             direction = edgeRight(),
-                                            label = listOf("createdComment")
+                                            label = graphLabelName("createdComment")
                                         ),
                                         node(
                                             variable = "c",
-                                            label = listOf("Comment"),
+                                            label = graphLabelName("Comment"),
                                             prefilter =
                                             eq(
                                                 path(id("c"), pathExpr(lit(ionString("isFlagged")), caseInsensitive())),
@@ -1177,7 +1159,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                         edge(
                                             direction = edgeRight(),
                                             variable = "t",
-                                            label = listOf("Transfer"),
+                                            label = graphLabelName("Transfer"),
                                             quantifier = graphMatchQuantifier(0)
                                         ),
                                         node(
@@ -1244,7 +1226,7 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
                                         edge(
                                             direction = edgeRight(),
                                             variable = "t",
-                                            label = listOf("Transfer"),
+                                            label = graphLabelName("Transfer"),
                                             quantifier = graphMatchQuantifier(0)
                                         ),
                                         node(
@@ -1411,45 +1393,139 @@ class PartiQLParserMatchTest : PartiQLParserTestBase() {
         }
     }
 
-    // TODO label combinators
+    /** "SELECT x FROM g MATCH (x:$[spec])" */
+    fun astSelectNodeWithLabelSpec(spec: PartiqlAst.GraphLabelSpec) = PartiqlAst.build {
+        select(
+            project = projectList(projectExpr(expr = id("x"))),
+            from = scan(
+                expr = graphMatch(
+                    expr = id("g"),
+                    gpmlPattern = gpmlPattern(
+                        patterns = listOf(
+                            graphMatchPattern(
+                                parts = listOf(
+                                    node(
+                                        prefilter = null,
+                                        variable = "x",
+                                        label = spec,
+                                    )
+                                )
+                            )
+                        )
+                    )
+                )
+            )
+        )
+    }
+
+    @Test
+    fun labelSimpleNamed() = assertExpression(
+        "SELECT x FROM g MATCH (x:A)"
+    ) {
+        astSelectNodeWithLabelSpec(spec = graphLabelName("A"))
+    }
+
     @Test
-    @Ignore
     fun labelDisjunction() = assertExpression(
         "SELECT x FROM g MATCH (x:Label|OtherLabel)",
     ) {
-        TODO()
+        astSelectNodeWithLabelSpec(
+            spec = graphLabelDisj(graphLabelName("Label"), graphLabelName("OtherLabel"))
+        )
     }
 
     @Test
-    @Ignore
     fun labelConjunction() = assertExpression(
         "SELECT x FROM g MATCH (x:Label&OtherLabel)",
     ) {
-        TODO()
+        astSelectNodeWithLabelSpec(
+            spec = graphLabelConj(graphLabelName("Label"), graphLabelName("OtherLabel"))
+        )
     }
 
     @Test
-    @Ignore
     fun labelNegation() = assertExpression(
         "SELECT x FROM g MATCH (x:!Label)",
     ) {
-        TODO()
+        astSelectNodeWithLabelSpec(spec = graphLabelNegation(graphLabelName("Label")))
     }
 
     @Test
-    @Ignore
     fun labelWildcard() = assertExpression(
         "SELECT x FROM g MATCH (x:%)",
     ) {
-        TODO()
+        astSelectNodeWithLabelSpec(spec = graphLabelWildcard())
     }
 
+    val astLabelCombo = PartiqlAst.build {
+        astSelectNodeWithLabelSpec(
+            spec = graphLabelDisj(
+                graphLabelDisj(
+                    graphLabelDisj(
+                        graphLabelName("L1"),
+                        graphLabelConj(graphLabelName("L2"), graphLabelName("L3"))
+                    ),
+                    graphLabelNegation(graphLabelName("L4"))
+                ),
+                graphLabelConj(graphLabelName("L5"), graphLabelWildcard())
+            )
+        )
+    }
     @Test
-    @Ignore
     fun labelCombo() = assertExpression(
-        "SELECT x FROM g MATCH (x: L1|L2&L3|!L4|(L5&%)",
+        "SELECT x FROM g MATCH (x: L1|L2&L3|!L4|(L5&%))",
+    ) { astLabelCombo }
+
+    @Test
+    fun labelComboParens() = assertExpression(
+        "SELECT x FROM g MATCH (x: ((L1 | (L2&L3)) | !L4) | (L5&%))",
+    ) { astLabelCombo }
+
+    /** (g MATCH <-[:$[spec]]-> ) */
+    fun astMatchEdgeWithLabelSpec(spec: PartiqlAst.GraphLabelSpec) = PartiqlAst.build {
+        graphMatch(
+            expr = id("g"),
+            gpmlPattern = gpmlPattern(
+                patterns = listOf(
+                    graphMatchPattern(
+                        parts = listOf(
+                            edge(
+                                direction = edgeLeftOrRight(),
+                                prefilter = null,
+                                variable = null,
+                                label = spec,
+                            )
+                        )
+                    )
+                )
+            )
+        )
+    }
+
+    @Test
+    fun edgeLabelSimpleNamed() = assertExpression(
+        "(g MATCH <-[:City]->)"
+    ) {
+        astMatchEdgeWithLabelSpec(graphLabelName("City"))
+    }
+
+    @Test
+    fun edgeLabelOrAnd() = assertExpression(
+        "(g MATCH <-[ : Country | City & Sovereign ]->)"
+    ) {
+        astMatchEdgeWithLabelSpec(
+            graphLabelDisj(
+                graphLabelName("Country"),
+                graphLabelConj(graphLabelName("City"), graphLabelName("Sovereign"))
+            )
+        )
+    }
+
+    @Test
+    fun edgeLabelUnlabeled() = assertExpression(
+        "(g MATCH <-[:!%]->)"
     ) {
-        TODO()
+        astMatchEdgeWithLabelSpec(graphLabelNegation(graphLabelWildcard()))
     }
 
     // TODO group variables (e.g., `MATCH ... WHERE SUM()...`)
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserMetaTests.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserMetaTests.kt
index b7a71a06bc..e3f7105011 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserMetaTests.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserMetaTests.kt
@@ -6,28 +6,30 @@ import org.partiql.lang.domains.PartiqlAst
 
 internal class PartiQLParserMetaTests : PartiQLParserTestBase() {
 
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     @Test
-    fun listParenthesized() {
+    fun listParenthesized(): Unit = forEachTarget {
         val query = "(0, 1, 2)"
-        val ast = parse(query) as PartiqlAst.Statement.Query
+        val ast = parser.parseAstStatement(query) as PartiqlAst.Statement.Query
         val list = ast.expr as PartiqlAst.Expr.List
 
         assert(list.metas.containsKey(IsListParenthesizedMeta.tag))
     }
 
     @Test
-    fun listParenthesizedNot() {
+    fun listParenthesizedNot(): Unit = forEachTarget {
         val query = "[0, 1, 2]"
-        val ast = parse(query) as PartiqlAst.Statement.Query
+        val ast = parser.parseAstStatement(query) as PartiqlAst.Statement.Query
         val list = ast.expr as PartiqlAst.Expr.List
 
         assert(list.metas.containsKey(IsListParenthesizedMeta.tag).not())
     }
 
     @Test
-    fun inListParenthesized() {
+    fun inListParenthesized(): Unit = forEachTarget {
         val query = "0 IN (0, 1, 2)"
-        val ast = parse(query) as PartiqlAst.Statement.Query
+        val ast = parser.parseAstStatement(query) as PartiqlAst.Statement.Query
         val inCollection = ast.expr as PartiqlAst.Expr.InCollection
         val list = inCollection.operands[1] as PartiqlAst.Expr.List
 
@@ -35,9 +37,9 @@ internal class PartiQLParserMetaTests : PartiQLParserTestBase() {
     }
 
     @Test
-    fun inListParenthesizedNot() {
+    fun inListParenthesizedNot(): Unit = forEachTarget {
         val query = "0 IN [0, 1, 2]"
-        val ast = parse(query) as PartiqlAst.Statement.Query
+        val ast = parser.parseAstStatement(query) as PartiqlAst.Statement.Query
         val inCollection = ast.expr as PartiqlAst.Expr.InCollection
         val list = inCollection.operands[1] as PartiqlAst.Expr.List
 
@@ -45,9 +47,9 @@ internal class PartiQLParserMetaTests : PartiQLParserTestBase() {
     }
 
     @Test
-    fun inListParenthesizedSingleElement() {
+    fun inListParenthesizedSingleElement(): Unit = forEachTarget {
         val query = "0 IN (0)"
-        val ast = parse(query) as PartiqlAst.Statement.Query
+        val ast = parser.parseAstStatement(query) as PartiqlAst.Statement.Query
         val inCollection = ast.expr as PartiqlAst.Expr.InCollection
         val list = inCollection.operands[1] as PartiqlAst.Expr.List
 
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserPrecedenceTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserPrecedenceTest.kt
index be23232b32..7a0caa51d4 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserPrecedenceTest.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserPrecedenceTest.kt
@@ -22,6 +22,8 @@ import org.partiql.lang.domains.PartiqlAst
 
 class PartiQLParserPrecedenceTest : PartiQLParserTestBase() {
 
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     @Test
     @Parameters
     @TestCaseName("{0}")
@@ -1083,18 +1085,22 @@ class PartiQLParserPrecedenceTest : PartiQLParserTestBase() {
     )
 
     private fun runTest(pair: Pair<String, String>) {
-        val (source, expectedAst) = pair
+        targets.forEach { target ->
+            val (source, expectedAst) = pair
 
-        val expectedExpr = PartiqlAst.transform(ion.singleValue(expectedAst).toIonElement()) as PartiqlAst.Expr
-        val expectedStatement = PartiqlAst.build { query(expectedExpr) }
+            val expectedExpr = PartiqlAst.transform(ion.singleValue(expectedAst).toIonElement()) as PartiqlAst.Expr
+            val expectedStatement = PartiqlAst.build { query(expectedExpr) }
 
-        val actualStatement = parser.parseAstStatement(source)
-        assertEquals(expectedStatement, actualStatement)
+            val actualStatement = target.parser.parseAstStatement(source)
+            assertEquals(expectedStatement, actualStatement)
+        }
     }
 
     private fun assertFailure(case: String) {
-        assertThrows(ParserException::class.java) {
-            parser.parseAstStatement(case)
+        targets.forEach { target ->
+            assertThrows(ParserException::class.java) {
+                target.parser.parseAstStatement(case)
+            }
         }
     }
 }
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserTest.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserTest.kt
index 07bb1c38a6..717d8fd820 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserTest.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserTest.kt
@@ -33,15 +33,12 @@ import org.partiql.parser.antlr.PartiQLParser
 import kotlin.concurrent.thread
 
 /**
- * Originally just meant to test the parser, this class now tests several different things because
- * the same test cases can be used for all three:
- *
- * - Parsing of query to PIG-generated ast
- * - Conversion of PIG-generated ast to [ExprNode].
- * - Conversion of [ExprNode] to legacy and new s-exp ASTs.
+ * Test parsing of query to PIG-generated AST
  */
 class PartiQLParserTest : PartiQLParserTestBase() {
 
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     // ****************************************
     // literals
     // ****************************************
@@ -438,6 +435,7 @@ class PartiQLParserTest : PartiQLParserTestBase() {
            (path_expr (lit "b") (case_insensitive))
            (path_expr (lit "c") (case_insensitive)))""".trimMargin()
     )
+
     @Test
     fun dot_case_3_insensitive_components() = assertExpression(
         "a.b.c.d",
@@ -474,6 +472,7 @@ class PartiQLParserTest : PartiQLParserTestBase() {
         """(path (id a (case_insensitive) (unqualified))
            (path_expr (lit 5) (case_sensitive)))""".trimMargin()
     )
+
     @Test
     fun pathWith3SquareBrackets() = assertExpression(
         """a[5]['b'][(a + 3)]""",
@@ -940,13 +939,13 @@ class PartiQLParserTest : PartiQLParserTestBase() {
     @Test
     fun currentUserUpperCase() = assertExpression(
         "CURRENT_USER",
-        "(session_attribute CURRENT_USER)"
+        "(session_attribute current_user)"
     )
 
     @Test
     fun currentUserMixedCase() = assertExpression(
         "CURRENT_user",
-        "(session_attribute CURRENT_user)"
+        "(session_attribute current_user)"
     )
 
     @Test
@@ -1580,48 +1579,52 @@ class PartiQLParserTest : PartiQLParserTestBase() {
     }
 
     @Test
-    fun orderByAscWithNullsSpec() = assertExpression("SELECT x FROM tb ORDER BY rk1 asc NULLS FIRST, rk2 asc NULLS LAST") {
-        select(
-            project = projectX,
-            from = scan(id("tb")),
-            order = orderBy(
-                listOf(
-                    sortSpec(id("rk1"), asc(), nullsFirst()),
-                    sortSpec(id("rk2"), asc(), nullsLast())
+    fun orderByAscWithNullsSpec() =
+        assertExpression("SELECT x FROM tb ORDER BY rk1 asc NULLS FIRST, rk2 asc NULLS LAST") {
+            select(
+                project = projectX,
+                from = scan(id("tb")),
+                order = orderBy(
+                    listOf(
+                        sortSpec(id("rk1"), asc(), nullsFirst()),
+                        sortSpec(id("rk2"), asc(), nullsLast())
+                    )
                 )
             )
-        )
-    }
+        }
 
     @Test
-    fun orderByDescWithNullsSpec() = assertExpression("SELECT x FROM tb ORDER BY rk1 desc NULLS FIRST, rk2 desc NULLS LAST") {
-        select(
-            project = projectX,
-            from = scan(id("tb")),
-            order = orderBy(
-                listOf(
-                    sortSpec(id("rk1"), desc(), nullsFirst()),
-                    sortSpec(id("rk2"), desc(), nullsLast())
+    fun orderByDescWithNullsSpec() =
+        assertExpression("SELECT x FROM tb ORDER BY rk1 desc NULLS FIRST, rk2 desc NULLS LAST") {
+            select(
+                project = projectX,
+                from = scan(id("tb")),
+                order = orderBy(
+                    listOf(
+                        sortSpec(id("rk1"), desc(), nullsFirst()),
+                        sortSpec(id("rk2"), desc(), nullsLast())
+                    )
                 )
             )
-        )
-    }
+        }
 
     @Test
-    fun orderByWithOrderingAndNullsSpec() = assertExpression("SELECT x FROM tb ORDER BY rk1 desc NULLS FIRST, rk2 asc NULLS LAST, rk3 desc NULLS LAST, rk4 asc NULLS FIRST") {
-        select(
-            project = projectX,
-            from = scan(id("tb")),
-            order = orderBy(
-                listOf(
-                    sortSpec(id("rk1"), desc(), nullsFirst()),
-                    sortSpec(id("rk2"), asc(), nullsLast()),
-                    sortSpec(id("rk3"), desc(), nullsLast()),
-                    sortSpec(id("rk4"), asc(), nullsFirst())
+    fun orderByWithOrderingAndNullsSpec() =
+        assertExpression("SELECT x FROM tb ORDER BY rk1 desc NULLS FIRST, rk2 asc NULLS LAST, rk3 desc NULLS LAST, rk4 asc NULLS FIRST") {
+            select(
+                project = projectX,
+                from = scan(id("tb")),
+                order = orderBy(
+                    listOf(
+                        sortSpec(id("rk1"), desc(), nullsFirst()),
+                        sortSpec(id("rk2"), asc(), nullsLast()),
+                        sortSpec(id("rk3"), desc(), nullsLast()),
+                        sortSpec(id("rk4"), asc(), nullsFirst())
+                    )
                 )
             )
-        )
-    }
+        }
+
     // ****************************************
     // GROUP BY and GROUP PARTIAL BY
     // ****************************************
@@ -4308,33 +4311,38 @@ class PartiQLParserTest : PartiQLParserTestBase() {
 
     @Test
     fun rootSelectNodeHasSourceLocation() {
-        val ast = parse("select 1 from dogs")
-        assertEquals(SourceLocationMeta(1L, 1L, 6L), ast.metas.sourceLocation)
+        targets.forEach { target ->
+            val ast = target.parser.parseAstStatement("select 1 from dogs")
+            assertEquals(SourceLocationMeta(1L, 1L, 6L), ast.metas.sourceLocation)
+        }
     }
 
     @Test
     fun semicolonAtEndOfQueryHasNoEffect() {
-        val query = "SELECT * FROM <<1>>"
-        val withSemicolon = parse("$query;")
-        val withoutSemicolon = parse(query)
-
-        assertEquals(withoutSemicolon, withSemicolon)
+        targets.forEach { target ->
+            val query = "SELECT * FROM <<1>>"
+            val withSemicolon = target.parser.parseAstStatement("$query;")
+            val withoutSemicolon = target.parser.parseAstStatement(query)
+            assertEquals(withoutSemicolon, withSemicolon)
+        }
     }
 
     @Test
     fun semicolonAtEndOfLiteralHasNoEffect() {
-        val withSemicolon = parse("1;")
-        val withoutSemicolon = parse("1")
-
-        assertEquals(withoutSemicolon, withSemicolon)
+        targets.forEach { target ->
+            val withSemicolon = target.parser.parseAstStatement("1;")
+            val withoutSemicolon = target.parser.parseAstStatement("1")
+            assertEquals(withoutSemicolon, withSemicolon)
+        }
     }
 
     @Test
     fun semicolonAtEndOfExpressionHasNoEffect() {
-        val withSemicolon = parse("(1+1);")
-        val withoutSemicolon = parse("(1+1)")
-
-        assertEquals(withoutSemicolon, withSemicolon)
+        targets.forEach { target ->
+            val withSemicolon = target.parser.parseAstStatement("(1+1);")
+            val withoutSemicolon = target.parser.parseAstStatement("(1+1)")
+            assertEquals(withoutSemicolon, withSemicolon)
+        }
     }
 
     // ****************************************
@@ -4478,7 +4486,10 @@ class PartiQLParserTest : PartiQLParserTestBase() {
     fun execMultipleArg() = assertExpression(
         "EXEC foo 'bar0', `1d0`, 2, [3]"
     ) {
-        exec("foo", listOf(lit(ionString("bar0")), lit(ionDecimal(Decimal.valueOf(1))), lit(ionInt(2)), list(lit(ionInt(3)))))
+        exec(
+            "foo",
+            listOf(lit(ionString("bar0")), lit(ionDecimal(Decimal.valueOf(1))), lit(ionInt(2)), list(lit(ionInt(3))))
+        )
     }
 
     @Test
@@ -4511,10 +4522,10 @@ class PartiQLParserTest : PartiQLParserTestBase() {
     }
 
     @Test
-    fun manyNestedNotPerformanceRegressionTest() {
+    fun manyNestedNotPerformanceRegressionTest(): Unit = forEachTarget {
         val startTime = System.currentTimeMillis()
         val t = thread {
-            parse(
+            parser.parseAstStatement(
                 """
                 not not not not not not not not not not not not not not not not not not not not not not not not 
                 not not not not not not not not not not not not not not not not not not not not not not not not 
@@ -4544,7 +4555,7 @@ class PartiQLParserTest : PartiQLParserTestBase() {
     }
 
     @Test
-    fun testOrderByMetas() {
+    fun testOrderByMetas(): Unit = forEachTarget {
         // Arrange
         val query = "SELECT * FROM << { 'x': 2 } >> ORDER BY x"
         val expected = SourceLocationMeta(1, 32, 5)
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserTestBase.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserTestBase.kt
index 78abf0d5ae..2887e75301 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserTestBase.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserTestBase.kt
@@ -34,9 +34,20 @@ import org.partiql.pig.runtime.toIonElement
 
 abstract class PartiQLParserTestBase : TestBase() {
 
-    val parser = PartiQLParserBuilder().customTypes(CUSTOM_TEST_TYPES).build()
+    /**
+     * We can change the parser target for an entire test suite by overriding this list.
+     */
+    open val targets = arrayOf(ParserTarget.DEFAULT)
+
+    /**
+     * Executes a test block for each target.
+     */
+    inline fun forEachTarget(block: ParserTarget.() -> Unit) = targets.forEach { it.block() }
 
-    protected fun parse(source: String): PartiqlAst.Statement = parser.parseAstStatement(source)
+    enum class ParserTarget(val parser: Parser) {
+        DEFAULT(PartiQLParserBuilder().customTypes(CUSTOM_TEST_TYPES).build()),
+        EXPERIMENTAL(PartiQLParserBuilder.experimental().customTypes(CUSTOM_TEST_TYPES).build()),
+    }
 
     private fun assertSexpEquals(
         expectedValue: IonValue,
@@ -60,7 +71,7 @@ abstract class PartiQLParserTestBase : TestBase() {
     protected fun assertExpression(
         source: String,
         expectedPigAst: String,
-    ) {
+    ): Unit = forEachTarget {
         val actualStatement = parser.parseAstStatement(source)
         val expectedIonSexp = loadIonSexp(expectedPigAst)
 
@@ -141,14 +152,19 @@ abstract class PartiQLParserTestBase : TestBase() {
     protected fun checkInputThrowingParserException(
         input: String,
         errorCode: ErrorCode,
-        expectErrorContextValues: Map<Property, Any>
-    ) {
+        expectErrorContextValues: Map<Property, Any>,
+        targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT),
+        assertContext: Boolean = true,
+    ): Unit = forEachTarget {
         softAssert {
             try {
                 parser.parseAstStatement(input)
                 fail("Expected ParserException but there was no Exception")
-            } catch (pex: ParserException) {
-                checkErrorAndErrorContext(errorCode, pex, expectErrorContextValues)
+            } catch (ex: ParserException) {
+                // split parser target does not use ErrorCode
+                if (assertContext && (this@forEachTarget == ParserTarget.EXPERIMENTAL)) {
+                    checkErrorAndErrorContext(errorCode, ex, expectErrorContextValues)
+                }
             } catch (ex: Exception) {
                 fail("Expected ParserException but a different exception was thrown \n\t  $ex")
             }
diff --git a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserWindowTests.kt b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserWindowTests.kt
index ce6dca7e02..1fa0d05adf 100644
--- a/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserWindowTests.kt
+++ b/partiql-lang/src/test/kotlin/org/partiql/lang/syntax/PartiQLParserWindowTests.kt
@@ -1,8 +1,15 @@
 package org.partiql.lang.syntax
 
 import org.junit.Test
+import org.partiql.lang.errors.ErrorCode
+import org.partiql.lang.errors.Property
+import org.partiql.lang.util.getAntlrDisplayString
+import org.partiql.parser.antlr.PartiQLParser
 
 class PartiQLParserWindowTests : PartiQLParserTestBase() {
+
+    override val targets: Array<ParserTarget> = arrayOf(ParserTarget.DEFAULT, ParserTarget.EXPERIMENTAL)
+
     // TODO: In the future when we support custom-defined window frame, we will need to change this
     @Test
     fun lagWithInlinePartitionBYOrderBy() = assertExpression(
@@ -231,4 +238,62 @@ class PartiQLParserWindowTests : PartiQLParserTestBase() {
                     null)))
         """
     )
+
+    @Test
+    fun lagWithoutOrderBy() {
+        checkInputThrowingParserException(
+            "SELECT lag(a) OVER () FROM b",
+            ErrorCode.PARSE_EXPECTED_WINDOW_ORDER_BY,
+            mapOf(
+                Property.LINE_NUMBER to 1L,
+                Property.COLUMN_NUMBER to 8L,
+                Property.TOKEN_DESCRIPTION to PartiQLParser.LAG.getAntlrDisplayString(),
+                Property.TOKEN_VALUE to ion.newSymbol("lag")
+            ),
+            assertContext = false,
+        )
+    }
+
+    @Test
+    fun lagWrongNumberOfParameter() {
+        checkInputThrowingParserException(
+            "SELECT lag(a,b,c,d) OVER (ORDER BY e) FROM f",
+            ErrorCode.PARSE_UNEXPECTED_TOKEN,
+            mapOf(
+                Property.LINE_NUMBER to 1L,
+                Property.COLUMN_NUMBER to 17L,
+                Property.TOKEN_DESCRIPTION to PartiQLParser.COMMA.getAntlrDisplayString(),
+                Property.TOKEN_VALUE to ion.newSymbol(",")
+            )
+        )
+    }
+
+    @Test
+    fun leadWithoutOrderBy() {
+        checkInputThrowingParserException(
+            "SELECT lead(a) OVER () FROM b",
+            ErrorCode.PARSE_EXPECTED_WINDOW_ORDER_BY,
+            mapOf(
+                Property.LINE_NUMBER to 1L,
+                Property.COLUMN_NUMBER to 8L,
+                Property.TOKEN_DESCRIPTION to PartiQLParser.LAG.getAntlrDisplayString(),
+                Property.TOKEN_VALUE to ion.newSymbol("lag")
+            ),
+            assertContext = false,
+        )
+    }
+
+    @Test
+    fun leadWrongNumberOfParameter() {
+        checkInputThrowingParserException(
+            "SELECT lead(a,b,c,d) OVER (ORDER BY e) FROM f",
+            ErrorCode.PARSE_UNEXPECTED_TOKEN,
+            mapOf(
+                Property.LINE_NUMBER to 1L,
+                Property.COLUMN_NUMBER to 18L,
+                Property.TOKEN_DESCRIPTION to PartiQLParser.COMMA.getAntlrDisplayString(),
+                Property.TOKEN_VALUE to ion.newSymbol(",")
+            )
+        )
+    }
 }
diff --git a/partiql-parser/README.adoc b/partiql-parser/README.adoc
new file mode 100644
index 0000000000..b416c6a0b3
--- /dev/null
+++ b/partiql-parser/README.adoc
@@ -0,0 +1,66 @@
+= PartiQL Parser
+
+The PartiQL Parser can be used to parse PartiQL queries into an AST (`org.partiql.ast`).
+This interface expands the legacy `org.partiql.syntax.Parser` interface allowing for a richer return type as well as the latest AST.
+
+== Interfaces
+
+[source,kotlin]
+----
+// PartiQLParser.kt
+
+public interface PartiQLParser {
+
+    @Throws(PartiQLSyntaxException::class, InterruptedException::class)
+    public fun parse(source: String): Result
+
+    public data class Result(
+        val source: String,
+        val root: AstNode,
+        val locations: SourceLocations,
+    )
+}
+
+// Exceptions.kt
+
+/**
+ * Generic PartiQLParser Syntax Exception
+ */
+public open class PartiQLSyntaxException(
+    override val message: String,
+    override val cause: Throwable? = null,
+    public val location: SourceLocation = SourceLocation.UNKNOWN,
+) : Exception()
+
+/**
+ * PartiQLParser Exception upon lexing.
+ */
+public class PartiQLLexerException(
+    public val token: String,
+    public val tokenType: String,
+    message: String = "",
+    cause: Throwable? = null,
+    location: SourceLocation = SourceLocation.UNKNOWN,
+) : PartiQLSyntaxException(message, cause, location)
+
+/**
+ * PartiQLParser Exception upon parsing.
+ */
+public class PartiQLParserException(
+    public val rule: String,
+    public val token: String,
+    public val tokenType: String,
+    message: String = "",
+    cause: Throwable? = null,
+    location: SourceLocation = SourceLocation.UNKNOWN,
+) : PartiQLSyntaxException(message, cause, location)
+
+----
+
+== Usage
+
+[source,kotlin]
+----
+val parser = PartiQLParserBuilder.standard().build()
+val ast = parser.parse("SELECT a FROM T")
+----
diff --git a/partiql-parser/build.gradle.kts b/partiql-parser/build.gradle.kts
index 51cb9e9c37..7c72a2f9df 100644
--- a/partiql-parser/build.gradle.kts
+++ b/partiql-parser/build.gradle.kts
@@ -15,12 +15,13 @@
 plugins {
     id(Plugins.antlr)
     id(Plugins.conventions)
-    // id(Plugins.publish)
+    id(Plugins.publish)
 }
 
 dependencies {
     antlr(Deps.antlr)
-    implementation(project(":partiql-ast"))
+    api(project(":partiql-ast"))
+    api(project(":partiql-types"))
     implementation(Deps.ionElement)
     implementation(Deps.antlrRuntime)
 }
@@ -51,8 +52,8 @@ tasks.processResources {
     }
 }
 
-// publish {
-//     artifactId = "partiql-parser"
-//     name = "PartiQL Parser"
-//     description = "PartiQL's Parser"
-// }
+publish {
+    artifactId = "partiql-parser"
+    name = "PartiQL Parser"
+    description = "PartiQL's Parser"
+}
diff --git a/partiql-parser/src/main/antlr/PartiQL.g4 b/partiql-parser/src/main/antlr/PartiQL.g4
index c12296c152..b7b0561bf2 100644
--- a/partiql-parser/src/main/antlr/PartiQL.g4
+++ b/partiql-parser/src/main/antlr/PartiQL.g4
@@ -380,7 +380,7 @@ patternRestrictor    // Should be TRAIL / ACYCLIC / SIMPLE
     : restrictor=IDENTIFIER;
 
 node
-    : PAREN_LEFT symbolPrimitive? patternPartLabel? whereClause? PAREN_RIGHT;
+    : PAREN_LEFT symbolPrimitive? ( COLON labelSpec )? whereClause? PAREN_RIGHT;
 
 edge
     : edgeWSpec quantifier=patternQuantifier?    # EdgeWithSpec
@@ -408,10 +408,28 @@ edgeWSpec
     ;
 
 edgeSpec
-    : BRACKET_LEFT symbolPrimitive? patternPartLabel? whereClause? BRACKET_RIGHT;
+    : BRACKET_LEFT symbolPrimitive? ( COLON labelSpec )? whereClause? BRACKET_RIGHT;
 
-patternPartLabel
-    : COLON symbolPrimitive;
+labelSpec
+    : labelSpec VERTBAR labelTerm        # LabelSpecOr
+    | labelTerm                          # LabelSpecTerm
+    ;
+
+labelTerm
+    : labelTerm AMPERSAND labelFactor    # LabelTermAnd
+    | labelFactor                        # LabelTermFactor
+    ;
+
+labelFactor
+    : BANG labelPrimary                  # LabelFactorNot
+    | labelPrimary                       # LabelFactorPrimary
+    ;
+
+labelPrimary
+    : symbolPrimitive                    # LabelPrimaryName
+    | PERCENT                            # LabelPrimaryWild
+    | PAREN_LEFT labelSpec PAREN_RIGHT   # LabelPrimaryParen
+    ;
 
 edgeAbbrev
     : TILDE
@@ -737,18 +755,19 @@ literal
     | ION_CLOSURE                                                                         # LiteralIon
     | DATE LITERAL_STRING                                                                 # LiteralDate
     | TIME ( PAREN_LEFT LITERAL_INTEGER PAREN_RIGHT )? (WITH TIME ZONE)? LITERAL_STRING   # LiteralTime
+    | TIMESTAMP ( PAREN_LEFT LITERAL_INTEGER PAREN_RIGHT )? (WITH TIME ZONE)? LITERAL_STRING   # LiteralTimestamp
     ;
 
 type
     : datatype=(
         NULL | BOOL | BOOLEAN | SMALLINT | INTEGER2 | INT2 | INTEGER | INT | INTEGER4 | INT4
-        | INTEGER8 | INT8 | BIGINT | REAL | TIMESTAMP | CHAR | CHARACTER | MISSING
+        | INTEGER8 | INT8 | BIGINT | REAL | CHAR | CHARACTER | MISSING
         | STRING | SYMBOL | BLOB | CLOB | DATE | STRUCT | TUPLE | LIST | SEXP | BAG | ANY
       )                                                                                                                # TypeAtomic
     | datatype=DOUBLE PRECISION                                                                                        # TypeAtomic
     | datatype=(CHARACTER|CHAR|FLOAT|VARCHAR) ( PAREN_LEFT arg0=LITERAL_INTEGER PAREN_RIGHT )?                         # TypeArgSingle
     | CHARACTER VARYING ( PAREN_LEFT arg0=LITERAL_INTEGER PAREN_RIGHT )?                                               # TypeVarChar
     | datatype=(DECIMAL|DEC|NUMERIC) ( PAREN_LEFT arg0=LITERAL_INTEGER ( COMMA arg1=LITERAL_INTEGER )? PAREN_RIGHT )?  # TypeArgDouble
-    | TIME ( PAREN_LEFT precision=LITERAL_INTEGER PAREN_RIGHT )? (WITH TIME ZONE)?                                     # TypeTimeZone
+    | datatype=(TIME|TIMESTAMP) ( PAREN_LEFT precision=LITERAL_INTEGER PAREN_RIGHT )? (WITH TIME ZONE)?                # TypeTimeZone
     | symbolPrimitive                                                                                                  # TypeCustom
     ;
diff --git a/partiql-parser/src/main/antlr/PartiQLTokens.g4 b/partiql-parser/src/main/antlr/PartiQLTokens.g4
index 9cc6e7d158..dd0f561246 100644
--- a/partiql-parser/src/main/antlr/PartiQLTokens.g4
+++ b/partiql-parser/src/main/antlr/PartiQLTokens.g4
@@ -326,6 +326,9 @@ PERCENT: '%';
 AT_SIGN: '@';
 TILDE: '~';
 ASTERISK: '*';
+VERTBAR: '|';
+AMPERSAND: '&';
+BANG: '!';
 LT_EQ: '<=';
 GT_EQ: '>=';
 EQ: '=';
diff --git a/partiql-parser/src/main/kotlin/org/partiql/parser/Exceptions.kt b/partiql-parser/src/main/kotlin/org/partiql/parser/Exceptions.kt
new file mode 100644
index 0000000000..67edf1d4f6
--- /dev/null
+++ b/partiql-parser/src/main/kotlin/org/partiql/parser/Exceptions.kt
@@ -0,0 +1,83 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.parser
+
+/**
+ * PartiQLParser Syntax Exception
+ *
+ * @property message
+ * @property cause
+ * @property location
+ */
+public open class PartiQLSyntaxException(
+    override val message: String,
+    override val cause: Throwable? = null,
+    public val location: SourceLocation = SourceLocation.UNKNOWN,
+) : Exception() {
+
+    internal companion object {
+
+        internal fun wrap(cause: Throwable) = when (cause) {
+            is PartiQLSyntaxException -> cause
+            is StackOverflowError -> PartiQLSyntaxException(
+                message = """
+                    |Input query too large. This error typically occurs when there are several nested
+                    |expressions/predicates and can usually be fixed by simplifying expressions.
+                    """.trimMargin(),
+                cause = cause,
+            )
+            is InterruptedException -> cause
+            else -> PartiQLSyntaxException("Unhandled exception.", cause)
+        }
+    }
+}
+
+/**
+ * PartiQLParser Exception upon lexing.
+ *
+ * @property token — Debug token where the Exception occurred
+ * @constructor
+ *
+ * @param message
+ * @param cause
+ * @param location
+ */
+public class PartiQLLexerException(
+    public val token: String,
+    public val tokenType: String,
+    message: String = "",
+    cause: Throwable? = null,
+    location: SourceLocation = SourceLocation.UNKNOWN,
+) : PartiQLSyntaxException(message, cause, location)
+
+/**
+ * PartiQLParser Exception upon parsing.
+ *
+ * @property rule   Debug rule where the Exception occurred
+ * @property token  Debug token where the Exception occurred
+ * @constructor
+ *
+ * @param message
+ * @param cause
+ * @param location
+ */
+public class PartiQLParserException(
+    public val rule: String,
+    public val token: String,
+    public val tokenType: String,
+    message: String = "",
+    cause: Throwable? = null,
+    location: SourceLocation = SourceLocation.UNKNOWN,
+) : PartiQLSyntaxException(message, cause, location)
diff --git a/partiql-parser/src/main/kotlin/org/partiql/parser/PartiQLParser.kt b/partiql-parser/src/main/kotlin/org/partiql/parser/PartiQLParser.kt
new file mode 100644
index 0000000000..9274e8c66e
--- /dev/null
+++ b/partiql-parser/src/main/kotlin/org/partiql/parser/PartiQLParser.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.parser
+
+import org.partiql.ast.AstNode
+
+public interface PartiQLParser {
+
+    @Throws(PartiQLSyntaxException::class, InterruptedException::class)
+    public fun parse(source: String): Result
+
+    public data class Result(
+        val source: String,
+        val root: AstNode,
+        val locations: SourceLocations,
+    )
+}
diff --git a/partiql-parser/src/main/kotlin/org/partiql/parser/PartiQLParserBuilder.kt b/partiql-parser/src/main/kotlin/org/partiql/parser/PartiQLParserBuilder.kt
new file mode 100644
index 0000000000..56318f47f6
--- /dev/null
+++ b/partiql-parser/src/main/kotlin/org/partiql/parser/PartiQLParserBuilder.kt
@@ -0,0 +1,35 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.parser
+
+import org.partiql.parser.impl.PartiQLParserDefault
+
+/**
+ * A builder class to instantiate a [PartiQLParser].
+ */
+public class PartiQLParserBuilder {
+
+    public companion object {
+
+        @JvmStatic
+        public fun standard(): PartiQLParserBuilder {
+            return PartiQLParserBuilder()
+        }
+    }
+
+    public fun build(): PartiQLParser {
+        return PartiQLParserDefault()
+    }
+}
diff --git a/partiql-parser/src/main/kotlin/org/partiql/parser/SourceLocation.kt b/partiql-parser/src/main/kotlin/org/partiql/parser/SourceLocation.kt
new file mode 100644
index 0000000000..521934f30c
--- /dev/null
+++ b/partiql-parser/src/main/kotlin/org/partiql/parser/SourceLocation.kt
@@ -0,0 +1,44 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.parser
+
+/**
+ * SourceLocation represents the span of a given grammar rule; which corresponds to an AST subtree.
+ *
+ * TODO Fix Source Location Tests https://github.com/partiql/partiql-lang-kotlin/issues/1114
+ * Unfortunately several mistakes were made that are hard to undo altogether. The legacy parser incorrectly
+ * used the first token length rather than rule span for source location length. Then we have asserted on these
+ * incorrect SourceLocations in many unit tests unrelated to SourceLocations.
+ *
+ * @property line
+ * @property offset
+ * @property length
+ * @property lengthLegacy
+ */
+public data class SourceLocation(
+    public val line: Int,
+    public val offset: Int,
+    public val length: Int,
+    public val lengthLegacy: Int = 0,
+) {
+
+    public companion object {
+
+        /**
+         * This is a flag for backwards compatibility when converting to the legacy AST.
+         */
+        public val UNKNOWN: SourceLocation = SourceLocation(-1, -1, -1)
+    }
+}
diff --git a/partiql-parser/src/main/kotlin/org/partiql/parser/SourceLocations.kt b/partiql-parser/src/main/kotlin/org/partiql/parser/SourceLocations.kt
new file mode 100644
index 0000000000..5d7c2ce4ae
--- /dev/null
+++ b/partiql-parser/src/main/kotlin/org/partiql/parser/SourceLocations.kt
@@ -0,0 +1,49 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.parser
+
+/**
+ * Each node is hashable and has a unique identifier. Metadata is kept externally.
+ * Delegate once we are on Kotlin 1.7
+ */
+public class SourceLocations private constructor(
+    private val delegate: Map<String, SourceLocation>
+) : Map<String, SourceLocation> {
+
+    override val entries: Set<Map.Entry<String, SourceLocation>> = delegate.entries
+
+    override val keys: Set<String> = delegate.keys
+
+    override val size: Int = delegate.size
+
+    override val values: Collection<SourceLocation> = delegate.values
+
+    override fun containsKey(key: String): Boolean = delegate.containsKey(key)
+
+    override fun containsValue(value: SourceLocation): Boolean = delegate.containsValue(value)
+
+    override fun get(key: String): SourceLocation? = delegate[key]
+
+    override fun isEmpty(): Boolean = delegate.isEmpty()
+
+    internal class Mutable {
+
+        private val delegate = mutableMapOf<String, SourceLocation>()
+
+        operator fun set(id: String, value: SourceLocation) = delegate.put(id, value)
+
+        fun toMap() = SourceLocations(delegate)
+    }
+}
diff --git a/partiql-parser/src/main/kotlin/org/partiql/parser/impl/PartiQLParserDefault.kt b/partiql-parser/src/main/kotlin/org/partiql/parser/impl/PartiQLParserDefault.kt
new file mode 100644
index 0000000000..860a711ca6
--- /dev/null
+++ b/partiql-parser/src/main/kotlin/org/partiql/parser/impl/PartiQLParserDefault.kt
@@ -0,0 +1,2031 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.parser.impl
+
+import com.amazon.ionelement.api.IntElement
+import com.amazon.ionelement.api.IntElementSize
+import com.amazon.ionelement.api.IonElement
+import com.amazon.ionelement.api.IonElementException
+import com.amazon.ionelement.api.loadSingleElement
+import org.antlr.v4.runtime.BailErrorStrategy
+import org.antlr.v4.runtime.BaseErrorListener
+import org.antlr.v4.runtime.CharStreams
+import org.antlr.v4.runtime.CommonTokenStream
+import org.antlr.v4.runtime.ParserRuleContext
+import org.antlr.v4.runtime.RecognitionException
+import org.antlr.v4.runtime.Recognizer
+import org.antlr.v4.runtime.Token
+import org.antlr.v4.runtime.TokenSource
+import org.antlr.v4.runtime.TokenStream
+import org.antlr.v4.runtime.atn.PredictionMode
+import org.antlr.v4.runtime.misc.ParseCancellationException
+import org.antlr.v4.runtime.tree.TerminalNode
+import org.partiql.ast.Ast
+import org.partiql.ast.AstNode
+import org.partiql.ast.DatetimeField
+import org.partiql.ast.Expr
+import org.partiql.ast.From
+import org.partiql.ast.GraphMatch
+import org.partiql.ast.GroupBy
+import org.partiql.ast.Identifier
+import org.partiql.ast.Let
+import org.partiql.ast.OnConflict
+import org.partiql.ast.Path
+import org.partiql.ast.Returning
+import org.partiql.ast.Select
+import org.partiql.ast.SetOp
+import org.partiql.ast.SetQuantifier
+import org.partiql.ast.Sort
+import org.partiql.ast.Statement
+import org.partiql.ast.TableDefinition
+import org.partiql.ast.Type
+import org.partiql.ast.builder.AstFactory
+import org.partiql.parser.PartiQLLexerException
+import org.partiql.parser.PartiQLParser
+import org.partiql.parser.PartiQLParserException
+import org.partiql.parser.PartiQLSyntaxException
+import org.partiql.parser.SourceLocation
+import org.partiql.parser.SourceLocations
+import org.partiql.parser.antlr.PartiQLBaseVisitor
+import org.partiql.parser.impl.util.DateTimeUtils
+import org.partiql.value.NumericValue
+import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.StringValue
+import org.partiql.value.boolValue
+import org.partiql.value.dateValue
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeValue
+import org.partiql.value.decimalValue
+import org.partiql.value.int64Value
+import org.partiql.value.intValue
+import org.partiql.value.missingValue
+import org.partiql.value.nullValue
+import org.partiql.value.stringValue
+import org.partiql.value.timeValue
+import org.partiql.value.timestampValue
+import java.math.BigDecimal
+import java.math.BigInteger
+import java.math.MathContext
+import java.math.RoundingMode
+import java.nio.channels.ClosedByInterruptException
+import java.nio.charset.StandardCharsets
+import java.time.LocalDate
+import java.time.format.DateTimeFormatter
+import java.time.format.DateTimeParseException
+import org.partiql.parser.antlr.PartiQLParser as GeneratedParser
+import org.partiql.parser.antlr.PartiQLTokens as GeneratedLexer
+
+/**
+ * ANTLR Based Implementation of a PartiQLParser
+ *
+ * SLL Prediction Mode
+ * -------------------
+ * The [PredictionMode.SLL] mode uses the [BailErrorStrategy]. The [GeneratedParser], upon seeing a syntax error,
+ * will throw a [ParseCancellationException] due to the [GeneratedParser.getErrorHandler]
+ * being a [BailErrorStrategy]. The purpose of this is to throw syntax errors as quickly as possible once encountered.
+ * As noted by the [PredictionMode.SLL] documentation, to guarantee results, it is useful to follow up a failed parse
+ * by parsing with [PredictionMode.LL]. See the JavaDocs for [PredictionMode.SLL] and [BailErrorStrategy] for more.
+ *
+ * LL Prediction Mode
+ * ------------------
+ * The [PredictionMode.LL] mode is capable of parsing all valid inputs for a grammar,
+ * but is slower than [PredictionMode.SLL]. Upon seeing a syntax error, this parser throws a [PartiQLParserException].
+ */
+internal class PartiQLParserDefault : PartiQLParser {
+
+    @Throws(PartiQLSyntaxException::class, InterruptedException::class)
+    override fun parse(source: String): PartiQLParser.Result {
+        try {
+            return PartiQLParserDefault.parse(source)
+        } catch (throwable: Throwable) {
+            throw PartiQLSyntaxException.wrap(throwable)
+        }
+    }
+
+    companion object {
+
+        /**
+         * To reduce latency costs, the [PartiQLParserDefault] attempts to use [PredictionMode.SLL] and falls back to
+         * [PredictionMode.LL] if a [ParseCancellationException] is thrown by the [BailErrorStrategy].
+         */
+        private fun parse(source: String): PartiQLParser.Result = try {
+            parse(source, PredictionMode.SLL)
+        } catch (ex: ParseCancellationException) {
+            parse(source, PredictionMode.LL)
+        }
+
+        /**
+         * Parses an input string [source] using the given prediction mode.
+         */
+        private fun parse(source: String, mode: PredictionMode): PartiQLParser.Result {
+            val tokens = createTokenStream(source)
+            val parser = InterruptibleParser(tokens)
+            parser.reset()
+            parser.removeErrorListeners()
+            parser.interpreter.predictionMode = mode
+            when (mode) {
+                PredictionMode.SLL -> parser.errorHandler = BailErrorStrategy()
+                PredictionMode.LL -> parser.addErrorListener(ParseErrorListener())
+                else -> throw IllegalArgumentException("Unsupported parser mode: $mode")
+            }
+            val tree = parser.root()
+            return Visitor.translate(source, tokens, tree)
+        }
+
+        private fun createTokenStream(source: String): CountingTokenStream {
+            val queryStream = source.byteInputStream(StandardCharsets.UTF_8)
+            val inputStream = try {
+                CharStreams.fromStream(queryStream)
+            } catch (ex: ClosedByInterruptException) {
+                throw InterruptedException()
+            }
+            val handler = TokenizeErrorListener()
+            val lexer = GeneratedLexer(inputStream)
+            lexer.removeErrorListeners()
+            lexer.addErrorListener(handler)
+            return CountingTokenStream(lexer)
+        }
+    }
+
+    /**
+     * Catches Lexical errors (unidentified tokens) and throws a [PartiQLParserException]
+     */
+    private class TokenizeErrorListener : BaseErrorListener() {
+        @Throws(PartiQLParserException::class)
+        override fun syntaxError(
+            recognizer: Recognizer<*, *>?,
+            offendingSymbol: Any?,
+            line: Int,
+            charPositionInLine: Int,
+            msg: String,
+            e: RecognitionException?
+        ) {
+            if (offendingSymbol is Token) {
+                val token = offendingSymbol.text
+                val tokenType = GeneratedParser.VOCABULARY.getSymbolicName(offendingSymbol.type)
+                throw PartiQLLexerException(
+                    token = token,
+                    tokenType = tokenType,
+                    message = msg,
+                    cause = e,
+                    location = SourceLocation(
+                        line = line,
+                        offset = charPositionInLine + 1,
+                        length = token.length,
+                        lengthLegacy = token.length,
+                    ),
+                )
+            } else {
+                throw IllegalArgumentException("Offending symbol is not a Token.")
+            }
+        }
+    }
+
+    /**
+     * Catches Parser errors (malformed syntax) and throws a [PartiQLParserException]
+     */
+    private class ParseErrorListener : BaseErrorListener() {
+
+        private val rules = GeneratedParser.ruleNames.asList()
+
+        @Throws(PartiQLParserException::class)
+        override fun syntaxError(
+            recognizer: Recognizer<*, *>?,
+            offendingSymbol: Any,
+            line: Int,
+            charPositionInLine: Int,
+            msg: String,
+            e: RecognitionException?
+        ) {
+            if (offendingSymbol is Token) {
+                val rule = e?.ctx?.toString(rules) ?: "UNKNOWN"
+                val token = offendingSymbol.text
+                val tokenType = GeneratedParser.VOCABULARY.getSymbolicName(offendingSymbol.type)
+                throw PartiQLParserException(
+                    rule = rule,
+                    token = token,
+                    tokenType = tokenType,
+                    message = msg,
+                    cause = e,
+                    location = SourceLocation(
+                        line = line,
+                        offset = charPositionInLine + 1,
+                        length = msg.length,
+                        lengthLegacy = offendingSymbol.text.length,
+                    ),
+                )
+            } else {
+                throw IllegalArgumentException("Offending symbol is not a Token.")
+            }
+        }
+    }
+
+    /**
+     * A wrapped [GeneratedParser] to allow thread interruption during parse.
+     */
+    internal class InterruptibleParser(input: TokenStream) : GeneratedParser(input) {
+        override fun enterRule(localctx: ParserRuleContext?, state: Int, ruleIndex: Int) {
+            if (Thread.interrupted()) {
+                throw InterruptedException()
+            }
+            super.enterRule(localctx, state, ruleIndex)
+        }
+    }
+
+    /**
+     * This token stream creates [parameterIndexes], which is a map, where the keys represent the
+     * indexes of all [GeneratedLexer.QUESTION_MARK]'s and the values represent their relative index amongst all other
+     * [GeneratedLexer.QUESTION_MARK]'s.
+     */
+    internal open class CountingTokenStream(tokenSource: TokenSource) : CommonTokenStream(tokenSource) {
+        // TODO: Research use-case of parameters and implementation -- see https://github.com/partiql/partiql-docs/issues/23
+        val parameterIndexes = mutableMapOf<Int, Int>()
+        private var parametersFound = 0
+        override fun LT(k: Int): Token? {
+            val token = super.LT(k)
+            token?.let {
+                if (it.type == GeneratedLexer.QUESTION_MARK && parameterIndexes.containsKey(token.tokenIndex).not()) {
+                    parameterIndexes[token.tokenIndex] = ++parametersFound
+                }
+            }
+            return token
+        }
+    }
+
+    /**
+     * Translate an ANTLR ParseTree to a PartiQL
+     */
+    @OptIn(PartiQLValueExperimental::class)
+    private class Visitor(
+        private val locations: SourceLocations.Mutable,
+        private val parameters: Map<Int, Int> = mapOf(),
+    ) : PartiQLBaseVisitor<AstNode>() {
+
+        // Use default factory
+        private val factory = Ast
+
+        companion object {
+
+            private val rules = GeneratedParser.ruleNames.asList()
+
+            /**
+             * Expose an (internal) friendly entry point into the traversal; mostly for keeping mutable state contained.
+             */
+            fun translate(
+                source: String,
+                tokens: CountingTokenStream,
+                tree: GeneratedParser.RootContext
+            ): PartiQLParser.Result {
+                val locations = SourceLocations.Mutable()
+                val visitor = Visitor(locations, tokens.parameterIndexes)
+                val root = visitor.visitAs<AstNode>(tree)
+                return PartiQLParser.Result(
+                    source = source,
+                    root = root,
+                    locations = locations.toMap(),
+                )
+            }
+
+            fun error(
+                ctx: ParserRuleContext,
+                message: String,
+                cause: Throwable? = null,
+            ) = PartiQLParserException(
+                rule = ctx.toStringTree(rules),
+                token = ctx.start.text,
+                tokenType = GeneratedParser.VOCABULARY.getSymbolicName(ctx.start.type),
+                message = message,
+                cause = cause,
+                location = SourceLocation(
+                    line = ctx.start.line,
+                    offset = ctx.start.charPositionInLine + 1,
+                    length = ctx.stop.stopIndex - ctx.start.startIndex,
+                    lengthLegacy = ctx.start.text.length,
+                ),
+            )
+
+            fun error(
+                token: Token,
+                message: String,
+                cause: Throwable? = null,
+            ) = PartiQLLexerException(
+                token = token.text,
+                tokenType = GeneratedParser.VOCABULARY.getSymbolicName(token.type),
+                message = message,
+                cause = cause,
+                location = SourceLocation(
+                    line = token.line,
+                    offset = token.charPositionInLine + 1,
+                    length = token.stopIndex - token.startIndex,
+                    lengthLegacy = token.text.length,
+                ),
+            )
+
+            internal val DATE_PATTERN_REGEX = Regex("\\d\\d\\d\\d-\\d\\d-\\d\\d")
+
+            internal val GENERIC_TIME_REGEX = Regex("\\d\\d:\\d\\d:\\d\\d(\\.\\d*)?([+|-]\\d\\d:\\d\\d)?")
+        }
+
+        /**
+         * Each visit attaches source locations from the given parse tree node; constructs nodes via the factory.
+         */
+        private inline fun <T : AstNode> translate(ctx: ParserRuleContext, block: AstFactory.() -> T): T {
+            val node = factory.block()
+            if (ctx.start != null) {
+                locations[node._id] = SourceLocation(
+                    line = ctx.start.line,
+                    offset = ctx.start.charPositionInLine + 1,
+                    length = (ctx.stop?.stopIndex ?: ctx.start.stopIndex) - ctx.start.startIndex + 1,
+                    lengthLegacy = ctx.start.text.length, // LEGACY LENGTH
+                )
+            }
+            return node
+        }
+
+        /**
+         *
+         * TOP LEVEL
+         *
+         */
+
+        override fun visitQueryDql(ctx: GeneratedParser.QueryDqlContext): AstNode = visitDql(ctx.dql())
+
+        override fun visitQueryDml(ctx: GeneratedParser.QueryDmlContext): AstNode = visit(ctx.dml())
+
+        override fun visitRoot(ctx: GeneratedParser.RootContext) = translate(ctx) {
+            when (ctx.EXPLAIN()) {
+                null -> visit(ctx.statement()) as Statement
+                else -> {
+                    var type: String? = null
+                    var format: String? = null
+                    ctx.explainOption().forEach { option ->
+                        val parameter = try {
+                            ExplainParameters.valueOf(option.param.text.uppercase())
+                        } catch (ex: java.lang.IllegalArgumentException) {
+                            throw error(option.param, "Unknown EXPLAIN parameter.", ex)
+                        }
+                        when (parameter) {
+                            ExplainParameters.TYPE -> {
+                                type = parameter.getCompliantString(type, option.value)
+                            }
+                            ExplainParameters.FORMAT -> {
+                                format = parameter.getCompliantString(format, option.value)
+                            }
+                        }
+                    }
+                    statementExplain(
+                        target = statementExplainTargetDomain(
+                            statement = visit(ctx.statement()) as Statement,
+                            type = type,
+                            format = format,
+                        ),
+                    )
+                }
+            }
+        }
+
+        /**
+         *
+         * COMMON USAGES
+         *
+         */
+
+        override fun visitAsIdent(ctx: GeneratedParser.AsIdentContext) = visitSymbolPrimitive(ctx.symbolPrimitive())
+
+        override fun visitAtIdent(ctx: GeneratedParser.AtIdentContext) = visitSymbolPrimitive(ctx.symbolPrimitive())
+
+        override fun visitByIdent(ctx: GeneratedParser.ByIdentContext) = visitSymbolPrimitive(ctx.symbolPrimitive())
+
+        override fun visitSymbolPrimitive(ctx: GeneratedParser.SymbolPrimitiveContext) = translate(ctx) {
+            when (ctx.ident.type) {
+                GeneratedParser.IDENTIFIER_QUOTED -> identifierSymbol(
+                    ctx.IDENTIFIER_QUOTED().getStringValue(),
+                    Identifier.CaseSensitivity.SENSITIVE,
+                )
+                GeneratedParser.IDENTIFIER -> identifierSymbol(
+                    ctx.IDENTIFIER().getStringValue(),
+                    Identifier.CaseSensitivity.INSENSITIVE,
+                )
+                else -> throw error(ctx, "Invalid symbol reference.")
+            }
+        }
+
+        /**
+         *
+         * DATA DEFINITION LANGUAGE (DDL)
+         *
+         */
+
+        override fun visitQueryDdl(ctx: GeneratedParser.QueryDdlContext): AstNode = visitDdl(ctx.ddl())
+
+        override fun visitDropTable(ctx: GeneratedParser.DropTableContext) = translate(ctx) {
+            val table = visitSymbolPrimitive(ctx.tableName().symbolPrimitive())
+            statementDDLDropTable(table)
+        }
+
+        override fun visitDropIndex(ctx: GeneratedParser.DropIndexContext) = translate(ctx) {
+            val table = visitSymbolPrimitive(ctx.on)
+            val index = visitSymbolPrimitive(ctx.target)
+            statementDDLDropIndex(index, table)
+        }
+
+        override fun visitCreateTable(ctx: GeneratedParser.CreateTableContext) = translate(ctx) {
+            val table = visitSymbolPrimitive(ctx.tableName().symbolPrimitive())
+            val definition = ctx.tableDef()?.let { visitTableDef(it) }
+            statementDDLCreateTable(table, definition)
+        }
+
+        override fun visitCreateIndex(ctx: GeneratedParser.CreateIndexContext) = translate(ctx) {
+            // TODO add index name to ANTLR grammar
+            val name: Identifier? = null
+            val table = visitSymbolPrimitive(ctx.symbolPrimitive())
+            val fields = ctx.pathSimple().map { path -> visitPathSimple(path) }
+            statementDDLCreateIndex(name, table, fields)
+        }
+
+        override fun visitTableDef(ctx: GeneratedParser.TableDefContext) = translate(ctx) {
+            // Column Definitions are the only thing we currently allow as table definition parts
+            val columns = ctx.tableDefPart().filterIsInstance<GeneratedParser.ColumnDeclarationContext>().map {
+                visitColumnDeclaration(it)
+            }
+            tableDefinition(columns)
+        }
+
+        override fun visitColumnDeclaration(ctx: GeneratedParser.ColumnDeclarationContext) = translate(ctx) {
+            val name = symbolToString(ctx.columnName().symbolPrimitive())
+            val type = visit(ctx.type()) as Type
+            val constraints = ctx.columnConstraint().map {
+                visitColumnConstraint(it)
+            }
+            tableDefinitionColumn(name, type, constraints)
+        }
+
+        override fun visitColumnConstraint(ctx: GeneratedParser.ColumnConstraintContext) = translate(ctx) {
+            val identifier = ctx.columnConstraintName()?.let { symbolToString(it.symbolPrimitive()) }
+            val body = visit(ctx.columnConstraintDef()) as TableDefinition.Column.Constraint.Body
+            tableDefinitionColumnConstraint(identifier, body)
+        }
+
+        override fun visitColConstrNotNull(ctx: GeneratedParser.ColConstrNotNullContext) = translate(ctx) {
+            tableDefinitionColumnConstraintBodyNotNull()
+        }
+
+        override fun visitColConstrNull(ctx: GeneratedParser.ColConstrNullContext) = translate(ctx) {
+            tableDefinitionColumnConstraintBodyNullable()
+        }
+
+        /**
+         *
+         * EXECUTE
+         *
+         */
+
+        override fun visitQueryExec(ctx: GeneratedParser.QueryExecContext) = visitExecCommand(ctx.execCommand())
+
+        /**
+         * TODO EXEC accepts an `expr` as the procedure name so we have to unpack the string.
+         *  - https://github.com/partiql/partiql-lang-kotlin/issues/707
+         */
+        override fun visitExecCommand(ctx: GeneratedParser.ExecCommandContext) = translate(ctx) {
+            val expr = visitExpr(ctx.name)
+            if (expr !is Expr.Var || expr.identifier !is Identifier.Symbol) {
+                throw error(ctx, "EXEC procedure must be a symbol identifier")
+            }
+            val procedure = (expr.identifier as Identifier.Symbol).symbol
+            val args = visitOrEmpty<Expr>(ctx.args)
+            statementExec(procedure, args)
+        }
+
+        /**
+         *
+         * DATA MANIPULATION LANGUAGE (DML)
+         *
+         */
+
+        /**
+         * The PartiQL grammars allows for multiple DML commands in one UPDATE statement.
+         * This function unwraps DML commands to the more limited DML.BatchLegacy.Op commands.
+         */
+        override fun visitDmlBaseWrapper(ctx: GeneratedParser.DmlBaseWrapperContext) = translate(ctx) {
+            val table = when {
+                ctx.updateClause() != null -> ctx.updateClause().tableBaseReference()
+                ctx.fromClause() != null -> ctx.fromClause().tableReference()
+                else -> throw error(ctx, "Expected UPDATE <table> or FROM <table>")
+            }
+            val from = visitOrNull<From>(table)
+            var returning: Returning? = null
+            val ops = ctx.dmlBaseCommand().map {
+                val op = visitDmlBaseCommand(it)
+                when (op) {
+                    is Statement.DML.Update -> statementDMLBatchLegacyOpSet(op.assignments)
+                    is Statement.DML.Remove -> statementDMLBatchLegacyOpRemove(op.target)
+                    is Statement.DML.Delete -> statementDMLBatchLegacyOpDelete()
+                    is Statement.DML.Insert -> statementDMLBatchLegacyOpInsert(
+                        op.target, op.values, op.asAlias, op.onConflict
+                    )
+                    is Statement.DML.InsertLegacy -> statementDMLBatchLegacyOpInsertLegacy(
+                        op.target, op.value, op.index, op.conflictCondition
+                    )
+                    is Statement.DML.BatchLegacy -> {
+                        // UNPACK InsertLegacy with returning
+                        assert(op.ops.size == 1) { "wrapped batch op can only have one item" }
+                        returning = op.returning
+                        op.ops[0]
+                    }
+                    else -> throw error(ctx, "Invalid DML operator in BatchLegacy update")
+                }
+            }
+            val where = ctx.whereClause()?.let { visitExpr(it.expr()) }
+            // outer returning
+            if (ctx.returningClause() != null) {
+                returning = visitReturningClause(ctx.returningClause()!!)
+            }
+            statementDMLBatchLegacy(ops, from, where, returning)
+        }
+
+        override fun visitDmlDelete(ctx: GeneratedParser.DmlDeleteContext) = visitDeleteCommand(ctx.deleteCommand())
+
+        override fun visitDmlInsertReturning(ctx: GeneratedParser.DmlInsertReturningContext): Statement.DML =
+            super.visit(ctx.insertCommandReturning()) as Statement.DML
+
+        override fun visitDmlBase(ctx: GeneratedParser.DmlBaseContext) =
+            super.visitDmlBaseCommand(ctx.dmlBaseCommand()) as Statement.DML
+
+        override fun visitDmlBaseCommand(ctx: GeneratedParser.DmlBaseCommandContext) =
+            super.visitDmlBaseCommand(ctx) as Statement.DML
+
+        override fun visitRemoveCommand(ctx: GeneratedParser.RemoveCommandContext) = translate(ctx) {
+            val target = visitPathSimple(ctx.pathSimple())
+            statementDMLRemove(target)
+        }
+
+        override fun visitDeleteCommand(ctx: GeneratedParser.DeleteCommandContext) = translate(ctx) {
+            val from = visitAs<Statement.DML.Delete.Target>(ctx.fromClauseSimple())
+            val where = ctx.whereClause()?.let { visitExpr(it.arg) }
+            val returning = ctx.returningClause()?.let { visitReturningClause(it) }
+            statementDMLDelete(from, where, returning)
+        }
+
+        /**
+         * Legacy INSERT with RETURNING clause is not represented in the AST as this grammar ..
+         * .. only exists for backwards compatibility. The RETURNING clause is ignored.
+         *
+         * TODO remove insertCommandReturning grammar rule
+         *  - https://github.com/partiql/partiql-lang-kotlin/issues/698
+         *  - https://github.com/partiql/partiql-lang-kotlin/issues/708
+         */
+        override fun visitInsertCommandReturning(ctx: GeneratedParser.InsertCommandReturningContext) = translate(ctx) {
+            val target = visitPathSimple(ctx.pathSimple())
+            val value = visitExpr(ctx.value)
+            val index = visitOrNull<Expr>(ctx.pos)
+            val conflictCondition = ctx.onConflictLegacy()?.let { visitOnConflictLegacy(it) }
+            if (ctx.returningClause() != null) {
+                val returning = visitReturningClause(ctx.returningClause()!!)
+                val insert = statementDMLBatchLegacyOpInsertLegacy(target, value, index, conflictCondition)
+                statementDMLBatchLegacy(listOf(insert), null, null, returning)
+            } else {
+                statementDMLInsertLegacy(target, value, index, conflictCondition)
+            }
+        }
+
+        override fun visitInsertStatementLegacy(ctx: GeneratedParser.InsertStatementLegacyContext) = translate(ctx) {
+            val target = visitPathSimple(ctx.pathSimple())
+            val value = visitExpr(ctx.value)
+            val index = visitOrNull<Expr>(ctx.pos)
+            val conflictCondition = ctx.onConflictLegacy()?.let { visitOnConflictLegacy(it) }
+            statementDMLInsertLegacy(target, value, index, conflictCondition)
+        }
+
+        override fun visitInsertStatement(ctx: GeneratedParser.InsertStatementContext) = translate(ctx) {
+            val target = visitSymbolPrimitive(ctx.symbolPrimitive())
+            val values = visitExpr(ctx.value)
+            val asAlias = visitOrNull<Identifier.Symbol>(ctx.asIdent())
+            val onConflict = ctx.onConflict()?.let { visitOnConflictClause(it) }
+            statementDMLInsert(target, values, asAlias, onConflict)
+        }
+
+        override fun visitReplaceCommand(ctx: GeneratedParser.ReplaceCommandContext) = translate(ctx) {
+            val target = visitSymbolPrimitive(ctx.symbolPrimitive())
+            val values = visitExpr(ctx.value)
+            val asAlias = visitOrNull<Identifier.Symbol>(ctx.asIdent())
+            statementDMLReplace(target, values, asAlias)
+        }
+
+        override fun visitUpsertCommand(ctx: GeneratedParser.UpsertCommandContext) = translate(ctx) {
+            val target = visitSymbolPrimitive(ctx.symbolPrimitive())
+            val values = visitExpr(ctx.value)
+            val asAlias = visitOrNull<Identifier.Symbol>(ctx.asIdent())
+            statementDMLUpsert(target, values, asAlias)
+        }
+
+        override fun visitReturningClause(ctx: GeneratedParser.ReturningClauseContext) = translate(ctx) {
+            val columns = visitOrEmpty<Returning.Column>(ctx.returningColumn())
+            returning(columns)
+        }
+
+        override fun visitReturningColumn(ctx: GeneratedParser.ReturningColumnContext) = translate(ctx) {
+            val status = when (ctx.status.type) {
+                GeneratedParser.MODIFIED -> Returning.Column.Status.MODIFIED
+                GeneratedParser.ALL -> Returning.Column.Status.ALL
+                else -> throw error(ctx.status, "Expected MODIFIED or ALL")
+            }
+            val age = when (ctx.age.type) {
+                GeneratedParser.OLD -> Returning.Column.Age.OLD
+                GeneratedParser.NEW -> Returning.Column.Age.NEW
+                else -> throw error(ctx.status, "Expected OLD or NEW")
+            }
+            val value = when (ctx.ASTERISK()) {
+                null -> returningColumnValueExpression(visitExpr(ctx.expr()))
+                else -> returningColumnValueWildcard()
+            }
+            returningColumn(status, age, value)
+        }
+
+        private fun visitOnConflictClause(ctx: GeneratedParser.OnConflictContext) = ctx.accept(this) as OnConflict
+
+        override fun visitOnConflict(ctx: GeneratedParser.OnConflictContext) = translate(ctx) {
+            val target = ctx.conflictTarget()?.let { visitConflictTarget(it) }
+            val action = visitConflictAction(ctx.conflictAction())
+            onConflict(target, action)
+        }
+
+        /**
+         * TODO Remove this when we remove INSERT LEGACY as no other conflict actions are allowed in PartiQL.g4.
+         */
+        override fun visitOnConflictLegacy(ctx: GeneratedParser.OnConflictLegacyContext) = translate(ctx) {
+            visitExpr(ctx.expr())
+        }
+
+        override fun visitConflictTarget(ctx: GeneratedParser.ConflictTargetContext) = translate(ctx) {
+            if (ctx.constraintName() != null) {
+                onConflictTargetConstraint(visitSymbolPrimitive(ctx.constraintName().symbolPrimitive()))
+            } else {
+                val symbols = ctx.symbolPrimitive().map { visitSymbolPrimitive(it) }
+                onConflictTargetSymbols(symbols)
+            }
+        }
+
+        override fun visitConflictAction(ctx: GeneratedParser.ConflictActionContext) = when {
+            ctx.NOTHING() != null -> translate(ctx) { onConflictActionDoNothing() }
+            ctx.REPLACE() != null -> visitDoReplace(ctx.doReplace())
+            ctx.UPDATE() != null -> visitDoUpdate(ctx.doUpdate())
+            else -> throw error(ctx, "ON CONFLICT only supports `DO REPLACE` and `DO NOTHING` actions at the moment.")
+        }
+
+        override fun visitDoReplace(ctx: GeneratedParser.DoReplaceContext) = translate(ctx) {
+            val condition = ctx.condition?.let { visitExpr(it) }
+            onConflictActionDoReplace(condition)
+        }
+
+        override fun visitDoUpdate(ctx: GeneratedParser.DoUpdateContext) = translate(ctx) {
+            val condition = ctx.condition?.let { visitExpr(it) }
+            onConflictActionDoUpdate(condition)
+        }
+
+        override fun visitPathSimple(ctx: GeneratedParser.PathSimpleContext) = translate(ctx) {
+            val root = visitSymbolPrimitive(ctx.symbolPrimitive())
+            val steps = visitOrEmpty<Path.Step>(ctx.pathSimpleSteps())
+            path(root, steps)
+        }
+
+        override fun visitPathSimpleLiteral(ctx: GeneratedParser.PathSimpleLiteralContext) = translate(ctx) {
+            val v = visit(ctx.literal())
+            if (v !is Expr.Lit) {
+                throw error(ctx, "Expected a path element literal")
+            }
+            when (val i = v.value) {
+                is NumericValue<*> -> pathStepIndex(i.int)
+                is StringValue -> pathStepSymbol(
+                    identifierSymbol(
+                        i.value, Identifier.CaseSensitivity.SENSITIVE
+                    )
+                )
+                else -> throw error(ctx, "Expected an integer or string literal, found literal ${i.type}")
+            }
+        }
+
+        override fun visitPathSimpleSymbol(ctx: GeneratedParser.PathSimpleSymbolContext) = translate(ctx) {
+            val identifier = visitSymbolPrimitive(ctx.symbolPrimitive())
+            pathStepSymbol(identifier)
+        }
+
+        override fun visitPathSimpleDotSymbol(ctx: GeneratedParser.PathSimpleDotSymbolContext) = translate(ctx) {
+            val identifier = visitSymbolPrimitive(ctx.symbolPrimitive())
+            pathStepSymbol(identifier)
+        }
+
+        /**
+         * TODO current PartiQL.g4 grammar models a SET with no UPDATE target as valid DML command.
+         */
+        override fun visitSetCommand(ctx: GeneratedParser.SetCommandContext) = translate(ctx) {
+            // We put a blank target, because we'll have to unpack this.
+            val target = path(
+                root = identifierSymbol("_blank", Identifier.CaseSensitivity.INSENSITIVE),
+                steps = emptyList(),
+            )
+            val assignments = visitOrEmpty<Statement.DML.Update.Assignment>(ctx.setAssignment())
+            statementDMLUpdate(target, assignments)
+        }
+
+        override fun visitSetAssignment(ctx: GeneratedParser.SetAssignmentContext) = translate(ctx) {
+            val target = visitPathSimple(ctx.pathSimple())
+            val value = visitExpr(ctx.expr())
+            statementDMLUpdateAssignment(target, value)
+        }
+
+        /**
+         *
+         * DATA QUERY LANGUAGE (DQL)
+         *
+         */
+
+        override fun visitDql(ctx: GeneratedParser.DqlContext) = translate(ctx) {
+            val expr = visitAs<Expr>(ctx.expr())
+            statementQuery(expr)
+        }
+
+        override fun visitQueryBase(ctx: GeneratedParser.QueryBaseContext): AstNode = visit(ctx.exprSelect())
+
+        override fun visitSfwQuery(ctx: GeneratedParser.SfwQueryContext) = translate(ctx) {
+            val select = visit(ctx.select) as Select
+            val from = visitFromClause(ctx.from)
+            val let = visitOrNull<Let>(ctx.let)
+            val where = visitOrNull<Expr>(ctx.where)
+            val groupBy = ctx.group?.let { visitGroupClause(it) }
+            val having = visitOrNull<Expr>(ctx.having?.arg)
+            // TODO Add SQL UNION, INTERSECT, EXCEPT to PartiQL.g4
+            val setOp: Expr.SFW.SetOp? = null
+            val orderBy = ctx.order?.let { visitOrderByClause(it) }
+            val limit = visitOrNull<Expr>(ctx.limit?.arg)
+            val offset = visitOrNull<Expr>(ctx.offset?.arg)
+            exprSFW(select, from, let, where, groupBy, having, setOp, orderBy, limit, offset)
+        }
+
+        /**
+         *
+         * SELECT & PROJECTIONS
+         *
+         */
+
+        override fun visitSelectAll(ctx: GeneratedParser.SelectAllContext) = translate(ctx) {
+            val quantifier = convertSetQuantifier(ctx.setQuantifierStrategy())
+            selectStar(quantifier)
+        }
+
+        override fun visitSelectItems(ctx: GeneratedParser.SelectItemsContext) = translate(ctx) {
+            val items = visitOrEmpty<Select.Project.Item>(ctx.projectionItems().projectionItem())
+            val setq = convertSetQuantifier(ctx.setQuantifierStrategy())
+            selectProject(items, setq)
+        }
+
+        override fun visitSelectPivot(ctx: GeneratedParser.SelectPivotContext) = translate(ctx) {
+            val key = visitExpr(ctx.pivot)
+            val value = visitExpr(ctx.at)
+            selectPivot(key, value)
+        }
+
+        override fun visitSelectValue(ctx: GeneratedParser.SelectValueContext) = translate(ctx) {
+            val constructor = visitExpr(ctx.expr())
+            val setq = convertSetQuantifier(ctx.setQuantifierStrategy())
+            selectValue(constructor, setq)
+        }
+
+        override fun visitProjectionItem(ctx: GeneratedParser.ProjectionItemContext) = translate(ctx) {
+            val expr = visitExpr(ctx.expr())
+            val alias = ctx.symbolPrimitive()?.let { visitSymbolPrimitive(it) }
+            if (expr is Expr.Path) {
+                convertPathToProjectionItem(ctx, expr, alias)
+            } else {
+                selectProjectItemExpression(expr, alias)
+            }
+        }
+
+        /**
+         *
+         * SIMPLE CLAUSES
+         *
+         */
+
+        override fun visitLimitClause(ctx: GeneratedParser.LimitClauseContext): Expr = visitAs<Expr>(ctx.arg)
+
+        override fun visitExpr(ctx: GeneratedParser.ExprContext): Expr {
+            if (Thread.interrupted()) {
+                throw InterruptedException()
+            }
+            return visitAs<Expr>(ctx.exprBagOp())
+        }
+
+        override fun visitOffsetByClause(ctx: GeneratedParser.OffsetByClauseContext) = visitAs<Expr>(ctx.arg)
+
+        override fun visitWhereClause(ctx: GeneratedParser.WhereClauseContext) = visitExpr(ctx.arg)
+
+        override fun visitWhereClauseSelect(ctx: GeneratedParser.WhereClauseSelectContext) = visitAs<Expr>(ctx.arg)
+
+        override fun visitHavingClause(ctx: GeneratedParser.HavingClauseContext) = visitAs<Expr>(ctx.arg)
+
+        /**
+         *
+         * LET CLAUSE
+         *
+         */
+
+        override fun visitLetClause(ctx: GeneratedParser.LetClauseContext) = translate(ctx) {
+            val bindings = visitOrEmpty<Let.Binding>(ctx.letBinding())
+            let(bindings)
+        }
+
+        override fun visitLetBinding(ctx: GeneratedParser.LetBindingContext) = translate(ctx) {
+            val expr = visitAs<Expr>(ctx.expr())
+            val alias = visitSymbolPrimitive(ctx.symbolPrimitive())
+            letBinding(expr, alias)
+        }
+
+        /**
+         *
+         * ORDER BY CLAUSE
+         *
+         */
+
+        override fun visitOrderByClause(ctx: GeneratedParser.OrderByClauseContext) = translate(ctx) {
+            val sorts = visitOrEmpty<Sort>(ctx.orderSortSpec())
+            orderBy(sorts)
+        }
+
+        override fun visitOrderSortSpec(ctx: GeneratedParser.OrderSortSpecContext) = translate(ctx) {
+            val expr = visitAs<Expr>(ctx.expr())
+            val dir = when {
+                ctx.dir == null -> null
+                ctx.dir.type == GeneratedParser.ASC -> Sort.Dir.ASC
+                ctx.dir.type == GeneratedParser.DESC -> Sort.Dir.DESC
+                else -> throw error(ctx.dir, "Invalid ORDER BY direction; expected ASC or DESC")
+            }
+            val nulls = when {
+                ctx.nulls == null -> null
+                ctx.nulls.type == GeneratedParser.FIRST -> Sort.Nulls.FIRST
+                ctx.nulls.type == GeneratedParser.LAST -> Sort.Nulls.LAST
+                else -> throw error(ctx.nulls, "Invalid ORDER BY null ordering; expected FIRST or LAST")
+            }
+            sort(expr, dir, nulls)
+        }
+
+        /**
+         *
+         * GROUP BY CLAUSE
+         *
+         */
+
+        override fun visitGroupClause(ctx: GeneratedParser.GroupClauseContext) = translate(ctx) {
+            val strategy = if (ctx.PARTIAL() != null) GroupBy.Strategy.PARTIAL else GroupBy.Strategy.FULL
+            val keys = visitOrEmpty<GroupBy.Key>(ctx.groupKey())
+            val alias = ctx.groupAlias()?.symbolPrimitive()?.let { visitSymbolPrimitive(it) }
+            groupBy(strategy, keys, alias)
+        }
+
+        override fun visitGroupKey(ctx: GeneratedParser.GroupKeyContext) = translate(ctx) {
+            val expr = visitAs<Expr>(ctx.key)
+            val alias = ctx.symbolPrimitive()?.let { visitSymbolPrimitive(it) }
+            groupByKey(expr, alias)
+        }
+
+        /**
+         *
+         * BAG OPERATIONS
+         *
+         */
+
+        override fun visitIntersect(ctx: GeneratedParser.IntersectContext) = translate(ctx) {
+            val setq = when {
+                ctx.ALL() != null -> SetQuantifier.ALL
+                ctx.DISTINCT() != null -> SetQuantifier.DISTINCT
+                else -> null
+            }
+            val op = setOp(SetOp.Type.INTERSECT, setq)
+            val lhs = visitAs<Expr>(ctx.lhs)
+            val rhs = visitAs<Expr>(ctx.rhs)
+            val outer = ctx.OUTER() != null
+            exprBagOp(op, lhs, rhs, outer)
+        }
+
+        override fun visitExcept(ctx: GeneratedParser.ExceptContext) = translate(ctx) {
+            val setq = when {
+                ctx.ALL() != null -> SetQuantifier.ALL
+                ctx.DISTINCT() != null -> SetQuantifier.DISTINCT
+                else -> null
+            }
+            val op = setOp(SetOp.Type.EXCEPT, setq)
+            val lhs = visitAs<Expr>(ctx.lhs)
+            val rhs = visitAs<Expr>(ctx.rhs)
+            val outer = ctx.OUTER() != null
+            exprBagOp(op, lhs, rhs, outer)
+        }
+
+        override fun visitUnion(ctx: GeneratedParser.UnionContext) = translate(ctx) {
+            val setq = when {
+                ctx.ALL() != null -> SetQuantifier.ALL
+                ctx.DISTINCT() != null -> SetQuantifier.DISTINCT
+                else -> null
+            }
+            val op = setOp(SetOp.Type.UNION, setq)
+            val lhs = visitAs<Expr>(ctx.lhs)
+            val rhs = visitAs<Expr>(ctx.rhs)
+            val outer = ctx.OUTER() != null
+            exprBagOp(op, lhs, rhs, outer)
+        }
+
+        /**
+         *
+         * GRAPH PATTERN MANIPULATION LANGUAGE (GPML)
+         *
+         */
+
+        override fun visitGpmlPattern(ctx: GeneratedParser.GpmlPatternContext) = translate(ctx) {
+            val pattern = visitMatchPattern(ctx.matchPattern())
+            val selector = visitOrNull<GraphMatch.Selector>(ctx.matchSelector())
+            graphMatch(listOf(pattern), selector)
+        }
+
+        override fun visitGpmlPatternList(ctx: GeneratedParser.GpmlPatternListContext) = translate(ctx) {
+            val patterns = ctx.matchPattern().map { pattern -> visitMatchPattern(pattern) }
+            val selector = visitOrNull<GraphMatch.Selector>(ctx.matchSelector())
+            graphMatch(patterns, selector)
+        }
+
+        override fun visitMatchPattern(ctx: GeneratedParser.MatchPatternContext) = translate(ctx) {
+            val parts = visitOrEmpty<GraphMatch.Pattern.Part>(ctx.graphPart())
+            val restrictor = ctx.restrictor?.let {
+                when (ctx.restrictor.text.lowercase()) {
+                    "trail" -> GraphMatch.Restrictor.TRAIL
+                    "acyclic" -> GraphMatch.Restrictor.ACYCLIC
+                    "simple" -> GraphMatch.Restrictor.SIMPLE
+                    else -> throw error(ctx.restrictor, "Unrecognized pattern restrictor")
+                }
+            }
+            val variable = visitOrNull<Identifier.Symbol>(ctx.variable)?.symbol
+            graphMatchPattern(restrictor, null, variable, null, parts)
+        }
+
+        override fun visitPatternPathVariable(ctx: GeneratedParser.PatternPathVariableContext) =
+            visitSymbolPrimitive(ctx.symbolPrimitive())
+
+        override fun visitSelectorBasic(ctx: GeneratedParser.SelectorBasicContext) = translate(ctx) {
+            when (ctx.mod.type) {
+                GeneratedParser.ANY -> graphMatchSelectorAnyShortest()
+                GeneratedParser.ALL -> graphMatchSelectorAllShortest()
+                else -> throw error(ctx, "Unsupported match selector.")
+            }
+        }
+
+        override fun visitSelectorAny(ctx: GeneratedParser.SelectorAnyContext) = translate(ctx) {
+            when (ctx.k) {
+                null -> graphMatchSelectorAny()
+                else -> graphMatchSelectorAnyK(ctx.k.text.toLong())
+            }
+        }
+
+        override fun visitSelectorShortest(ctx: GeneratedParser.SelectorShortestContext) = translate(ctx) {
+            val k = ctx.k.text.toLong()
+            when (ctx.GROUP()) {
+                null -> graphMatchSelectorShortestK(k)
+                else -> graphMatchSelectorShortestKGroup(k)
+            }
+        }
+
+        override fun visitLabelSpecOr(ctx: GeneratedParser.LabelSpecOrContext) = translate(ctx) {
+            val lhs = visit(ctx.labelSpec()) as GraphMatch.Label
+            val rhs = visit(ctx.labelTerm()) as GraphMatch.Label
+            graphMatchLabelDisj(lhs, rhs)
+        }
+
+        override fun visitLabelTermAnd(ctx: GeneratedParser.LabelTermAndContext) = translate(ctx) {
+            val lhs = visit(ctx.labelTerm()) as GraphMatch.Label
+            val rhs = visit(ctx.labelFactor()) as GraphMatch.Label
+            graphMatchLabelConj(lhs, rhs)
+        }
+
+        override fun visitLabelFactorNot(ctx: GeneratedParser.LabelFactorNotContext) = translate(ctx) {
+            val arg = visit(ctx.labelPrimary()) as GraphMatch.Label
+            graphMatchLabelNegation(arg)
+        }
+
+        override fun visitLabelPrimaryName(ctx: GeneratedParser.LabelPrimaryNameContext) = translate(ctx) {
+            val x = visitSymbolPrimitive(ctx.symbolPrimitive())
+            graphMatchLabelName(x.symbol)
+        }
+
+        override fun visitLabelPrimaryWild(ctx: GeneratedParser.LabelPrimaryWildContext) = translate(ctx) {
+            graphMatchLabelWildcard()
+        }
+
+        override fun visitLabelPrimaryParen(ctx: GeneratedParser.LabelPrimaryParenContext) =
+            visit(ctx.labelSpec()) as GraphMatch.Label
+
+        override fun visitPattern(ctx: GeneratedParser.PatternContext) = translate(ctx) {
+            val restrictor = visitRestrictor(ctx.restrictor)
+            val variable = visitOrNull<Identifier.Symbol>(ctx.variable)?.symbol
+            val prefilter = ctx.where?.let { visitExpr(it.expr()) }
+            val quantifier = ctx.quantifier?.let { visitPatternQuantifier(it) }
+            val parts = visitOrEmpty<GraphMatch.Pattern.Part>(ctx.graphPart())
+            graphMatchPattern(restrictor, prefilter, variable, quantifier, parts)
+        }
+
+        override fun visitEdgeAbbreviated(ctx: GeneratedParser.EdgeAbbreviatedContext) = translate(ctx) {
+            val direction = visitEdge(ctx.edgeAbbrev())
+            val quantifier = visitOrNull<GraphMatch.Quantifier>(ctx.quantifier)
+            graphMatchPatternPartEdge(direction, quantifier, null, null, null)
+        }
+
+        override fun visitEdgeWithSpec(ctx: GeneratedParser.EdgeWithSpecContext) = translate(ctx) {
+            val quantifier = visitOrNull<GraphMatch.Quantifier>(ctx.quantifier)
+            val edge = visitOrNull<GraphMatch.Pattern.Part.Edge>(ctx.edgeWSpec())
+            edge!!.copy(quantifier = quantifier)
+        }
+
+        override fun visitEdgeSpec(ctx: GeneratedParser.EdgeSpecContext) = translate(ctx) {
+            val placeholderDirection = GraphMatch.Direction.RIGHT
+            val variable = visitOrNull<Identifier.Symbol>(ctx.symbolPrimitive())?.symbol
+            val prefilter = ctx.whereClause()?.let { visitExpr(it.expr()) }
+            val label = visitOrNull<GraphMatch.Label>(ctx.labelSpec())
+            graphMatchPatternPartEdge(placeholderDirection, null, prefilter, variable, label)
+        }
+
+        override fun visitEdgeSpecLeft(ctx: GeneratedParser.EdgeSpecLeftContext): AstNode {
+            val edge = visitEdgeSpec(ctx.edgeSpec())
+            return edge.copy(direction = GraphMatch.Direction.LEFT)
+        }
+
+        override fun visitEdgeSpecRight(ctx: GeneratedParser.EdgeSpecRightContext): AstNode {
+            val edge = visitEdgeSpec(ctx.edgeSpec())
+            return edge.copy(direction = GraphMatch.Direction.RIGHT)
+        }
+
+        override fun visitEdgeSpecBidirectional(ctx: GeneratedParser.EdgeSpecBidirectionalContext): AstNode {
+            val edge = visitEdgeSpec(ctx.edgeSpec())
+            return edge.copy(direction = GraphMatch.Direction.LEFT_OR_RIGHT)
+        }
+
+        override fun visitEdgeSpecUndirectedBidirectional(ctx: GeneratedParser.EdgeSpecUndirectedBidirectionalContext): AstNode {
+            val edge = visitEdgeSpec(ctx.edgeSpec())
+            return edge.copy(direction = GraphMatch.Direction.LEFT_UNDIRECTED_OR_RIGHT)
+        }
+
+        override fun visitEdgeSpecUndirected(ctx: GeneratedParser.EdgeSpecUndirectedContext): AstNode {
+            val edge = visitEdgeSpec(ctx.edgeSpec())
+            return edge.copy(direction = GraphMatch.Direction.UNDIRECTED)
+        }
+
+        override fun visitEdgeSpecUndirectedLeft(ctx: GeneratedParser.EdgeSpecUndirectedLeftContext): AstNode {
+            val edge = visitEdgeSpec(ctx.edgeSpec())
+            return edge.copy(direction = GraphMatch.Direction.LEFT_OR_UNDIRECTED)
+        }
+
+        override fun visitEdgeSpecUndirectedRight(ctx: GeneratedParser.EdgeSpecUndirectedRightContext): AstNode {
+            val edge = visitEdgeSpec(ctx.edgeSpec())
+            return edge.copy(direction = GraphMatch.Direction.UNDIRECTED_OR_RIGHT)
+        }
+
+        private fun visitEdge(ctx: GeneratedParser.EdgeAbbrevContext): GraphMatch.Direction = when {
+            ctx.TILDE() != null && ctx.ANGLE_RIGHT() != null -> GraphMatch.Direction.UNDIRECTED_OR_RIGHT
+            ctx.TILDE() != null && ctx.ANGLE_LEFT() != null -> GraphMatch.Direction.LEFT_OR_UNDIRECTED
+            ctx.TILDE() != null -> GraphMatch.Direction.UNDIRECTED
+            ctx.MINUS() != null && ctx.ANGLE_LEFT() != null && ctx.ANGLE_RIGHT() != null -> GraphMatch.Direction.LEFT_OR_RIGHT
+            ctx.MINUS() != null && ctx.ANGLE_LEFT() != null -> GraphMatch.Direction.LEFT
+            ctx.MINUS() != null && ctx.ANGLE_RIGHT() != null -> GraphMatch.Direction.RIGHT
+            ctx.MINUS() != null -> GraphMatch.Direction.LEFT_UNDIRECTED_OR_RIGHT
+            else -> throw error(ctx, "Unsupported edge type")
+        }
+
+        override fun visitGraphPart(ctx: GeneratedParser.GraphPartContext): GraphMatch.Pattern.Part {
+            val part = super.visitGraphPart(ctx)
+            if (part is GraphMatch.Pattern) {
+                return translate(ctx) { graphMatchPatternPartPattern(part) }
+            }
+            return part as GraphMatch.Pattern.Part
+        }
+
+        override fun visitPatternQuantifier(ctx: GeneratedParser.PatternQuantifierContext) = translate(ctx) {
+            when {
+                ctx.quant == null -> graphMatchQuantifier(ctx.lower.text.toLong(), ctx.upper?.text?.toLong())
+                ctx.quant.type == GeneratedParser.PLUS -> graphMatchQuantifier(1L, null)
+                ctx.quant.type == GeneratedParser.ASTERISK -> graphMatchQuantifier(0L, null)
+                else -> throw error(ctx, "Unsupported quantifier")
+            }
+        }
+
+        override fun visitNode(ctx: GeneratedParser.NodeContext) = translate(ctx) {
+            val variable = visitOrNull<Identifier.Symbol>(ctx.symbolPrimitive())?.symbol
+            val prefilter = ctx.whereClause()?.let { visitExpr(it.expr()) }
+            val label = visitOrNull<GraphMatch.Label>(ctx.labelSpec())
+            graphMatchPatternPartNode(prefilter, variable, label)
+        }
+
+        private fun visitRestrictor(ctx: GeneratedParser.PatternRestrictorContext?): GraphMatch.Restrictor? {
+            if (ctx == null) return null
+            return when (ctx.restrictor.text.lowercase()) {
+                "trail" -> GraphMatch.Restrictor.TRAIL
+                "acyclic" -> GraphMatch.Restrictor.ACYCLIC
+                "simple" -> GraphMatch.Restrictor.SIMPLE
+                else -> throw error(ctx, "Unrecognized pattern restrictor")
+            }
+        }
+
+        /**
+         *
+         * TABLE REFERENCES & JOINS & FROM CLAUSE
+         *
+         */
+
+        override fun visitFromClause(ctx: GeneratedParser.FromClauseContext) = visitAs<From>(ctx.tableReference())
+
+        override fun visitTableBaseRefClauses(ctx: GeneratedParser.TableBaseRefClausesContext) = translate(ctx) {
+            val expr = visitAs<Expr>(ctx.source)
+            val asAlias = ctx.asIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            val atAlias = ctx.atIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            val byAlias = ctx.byIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            fromValue(expr, From.Value.Type.SCAN, asAlias, atAlias, byAlias)
+        }
+
+        override fun visitTableBaseRefMatch(ctx: GeneratedParser.TableBaseRefMatchContext) = translate(ctx) {
+            val expr = visitAs<Expr>(ctx.source)
+            val asAlias = ctx.asIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            val atAlias = ctx.atIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            val byAlias = ctx.byIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            fromValue(expr, From.Value.Type.SCAN, asAlias, atAlias, byAlias)
+        }
+
+        /**
+         * TODO Remove as/at/by aliases from DELETE command grammar in PartiQL.g4
+         */
+        override fun visitFromClauseSimpleExplicit(ctx: GeneratedParser.FromClauseSimpleExplicitContext) =
+            translate(ctx) {
+                val path = visitPathSimple(ctx.pathSimple())
+                val asAlias = ctx.asIdent()?.let { visitAsIdent(it) }
+                val atAlias = ctx.atIdent()?.let { visitAtIdent(it) }
+                val byAlias = ctx.byIdent()?.let { visitByIdent(it) }
+                statementDMLDeleteTarget(path, asAlias, atAlias, byAlias)
+            }
+
+        /**
+         * TODO Remove fromClauseSimple rule from DELETE command grammar in PartiQL.g4
+         */
+        override fun visitFromClauseSimpleImplicit(ctx: GeneratedParser.FromClauseSimpleImplicitContext) =
+            translate(ctx) {
+                val path = visitPathSimple(ctx.pathSimple())
+                val asAlias = visitSymbolPrimitive(ctx.symbolPrimitive())
+                statementDMLDeleteTarget(path, asAlias, null, null)
+            }
+
+        override fun visitTableUnpivot(ctx: GeneratedParser.TableUnpivotContext) = translate(ctx) {
+            val expr = visitAs<Expr>(ctx.expr())
+            val asAlias = ctx.asIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            val atAlias = ctx.atIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            val byAlias = ctx.byIdent()?.let { visitSymbolPrimitive(it.symbolPrimitive()) }
+            fromValue(expr, From.Value.Type.UNPIVOT, asAlias, atAlias, byAlias)
+        }
+
+        override fun visitTableCrossJoin(ctx: GeneratedParser.TableCrossJoinContext) = translate(ctx) {
+            val lhs = visitAs<From>(ctx.lhs)
+            val rhs = visitAs<From>(ctx.rhs)
+            val type = convertJoinType(ctx.joinType())
+            fromJoin(lhs, rhs, type, null)
+        }
+
+        private fun convertJoinType(ctx: GeneratedParser.JoinTypeContext?): From.Join.Type? {
+            if (ctx == null) return null
+            return when (ctx.mod.type) {
+                GeneratedParser.INNER -> From.Join.Type.INNER
+                GeneratedParser.LEFT -> when (ctx.OUTER()) {
+                    null -> From.Join.Type.LEFT
+                    else -> From.Join.Type.LEFT_OUTER
+                }
+                GeneratedParser.RIGHT -> when (ctx.OUTER()) {
+                    null -> From.Join.Type.RIGHT
+                    else -> From.Join.Type.RIGHT_OUTER
+                }
+                GeneratedParser.FULL -> when (ctx.OUTER()) {
+                    null -> From.Join.Type.FULL
+                    else -> From.Join.Type.FULL_OUTER
+                }
+                GeneratedParser.OUTER -> {
+                    // TODO https://github.com/partiql/partiql-spec/issues/41
+                    // TODO https://github.com/partiql/partiql-lang-kotlin/issues/1013
+                    From.Join.Type.FULL_OUTER
+                }
+                else -> null
+            }
+        }
+
+        override fun visitTableQualifiedJoin(ctx: GeneratedParser.TableQualifiedJoinContext) = translate(ctx) {
+            val lhs = visitAs<From>(ctx.lhs)
+            val rhs = visitAs<From>(ctx.rhs)
+            val type = convertJoinType(ctx.joinType())
+            val condition = ctx.joinSpec()?.let { visitExpr(it.expr()) }
+            fromJoin(lhs, rhs, type, condition)
+        }
+
+        override fun visitTableBaseRefSymbol(ctx: GeneratedParser.TableBaseRefSymbolContext) = translate(ctx) {
+            val expr = visitAs<Expr>(ctx.source)
+            val asAlias = visitSymbolPrimitive(ctx.symbolPrimitive())
+            fromValue(expr, From.Value.Type.SCAN, asAlias, null, null)
+        }
+
+        override fun visitTableWrapped(ctx: GeneratedParser.TableWrappedContext): AstNode = visit(ctx.tableReference())
+
+        override fun visitJoinSpec(ctx: GeneratedParser.JoinSpecContext) = visitExpr(ctx.expr())
+
+        override fun visitJoinRhsTableJoined(ctx: GeneratedParser.JoinRhsTableJoinedContext) =
+            visitAs<From>(ctx.tableReference())
+
+        /**
+         * SIMPLE EXPRESSIONS
+         */
+
+        override fun visitOr(ctx: GeneratedParser.OrContext) = translate(ctx) {
+            convertBinaryExpr(ctx.lhs, ctx.rhs, Expr.Binary.Op.OR)
+        }
+
+        override fun visitAnd(ctx: GeneratedParser.AndContext) = translate(ctx) {
+            convertBinaryExpr(ctx.lhs, ctx.rhs, Expr.Binary.Op.AND)
+        }
+
+        override fun visitNot(ctx: GeneratedParser.NotContext) = translate(ctx) {
+            val expr = visit(ctx.exprNot()) as Expr
+            exprUnary(Expr.Unary.Op.NOT, expr)
+        }
+
+        override fun visitMathOp00(ctx: GeneratedParser.MathOp00Context) = translate(ctx) {
+            if (ctx.parent != null) return@translate visit(ctx.parent)
+            convertBinaryExpr(ctx.lhs, ctx.rhs, convertBinaryOp(ctx.op))
+        }
+
+        override fun visitMathOp01(ctx: GeneratedParser.MathOp01Context) = translate(ctx) {
+            if (ctx.parent != null) return@translate visit(ctx.parent)
+            convertBinaryExpr(ctx.lhs, ctx.rhs, convertBinaryOp(ctx.op))
+        }
+
+        override fun visitMathOp02(ctx: GeneratedParser.MathOp02Context) = translate(ctx) {
+            if (ctx.parent != null) return@translate visit(ctx.parent)
+            convertBinaryExpr(ctx.lhs, ctx.rhs, convertBinaryOp(ctx.op))
+        }
+
+        override fun visitValueExpr(ctx: GeneratedParser.ValueExprContext) = translate(ctx) {
+            if (ctx.parent != null) return@translate visit(ctx.parent)
+            val expr = visit(ctx.rhs) as Expr
+            exprUnary(convertUnaryOp(ctx.sign), expr)
+        }
+
+        private fun convertBinaryExpr(lhs: ParserRuleContext, rhs: ParserRuleContext, op: Expr.Binary.Op): Expr {
+            val l = visit(lhs) as Expr
+            val r = visit(rhs) as Expr
+            return factory.exprBinary(op, l, r)
+        }
+
+        private fun convertBinaryOp(token: Token) = when (token.type) {
+            GeneratedParser.AND -> Expr.Binary.Op.AND
+            GeneratedParser.OR -> Expr.Binary.Op.OR
+            GeneratedParser.ASTERISK -> Expr.Binary.Op.TIMES
+            GeneratedParser.SLASH_FORWARD -> Expr.Binary.Op.DIVIDE
+            GeneratedParser.PLUS -> Expr.Binary.Op.PLUS
+            GeneratedParser.MINUS -> Expr.Binary.Op.MINUS
+            GeneratedParser.PERCENT -> Expr.Binary.Op.MODULO
+            GeneratedParser.CONCAT -> Expr.Binary.Op.CONCAT
+            GeneratedParser.ANGLE_LEFT -> Expr.Binary.Op.LT
+            GeneratedParser.LT_EQ -> Expr.Binary.Op.LTE
+            GeneratedParser.ANGLE_RIGHT -> Expr.Binary.Op.GT
+            GeneratedParser.GT_EQ -> Expr.Binary.Op.GTE
+            GeneratedParser.NEQ -> Expr.Binary.Op.NE
+            GeneratedParser.EQ -> Expr.Binary.Op.EQ
+            else -> throw error(token, "Invalid binary operator")
+        }
+
+        private fun convertUnaryOp(token: Token) = when (token.type) {
+            GeneratedParser.PLUS -> Expr.Unary.Op.POS
+            GeneratedParser.MINUS -> Expr.Unary.Op.NEG
+            GeneratedParser.NOT -> Expr.Unary.Op.NOT
+            else -> throw error(token, "Invalid unary operator")
+        }
+
+        /**
+         *
+         * PREDICATES
+         *
+         */
+
+        override fun visitPredicateComparison(ctx: GeneratedParser.PredicateComparisonContext) = translate(ctx) {
+            val op = convertBinaryOp(ctx.op)
+            convertBinaryExpr(ctx.lhs, ctx.rhs, op)
+        }
+
+        /**
+         * TODO Fix the IN collection grammar, also label alternative forms
+         *  - https://github.com/partiql/partiql-lang-kotlin/issues/1115
+         *   - https://github.com/partiql/partiql-lang-kotlin/issues/1113
+         */
+        override fun visitPredicateIn(ctx: GeneratedParser.PredicateInContext) = translate(ctx) {
+            val lhs = visitAs<Expr>(ctx.lhs)
+            val rhs = visitAs<Expr>(ctx.rhs ?: ctx.expr()).let {
+                // Wrap rhs in an array unless it's a query or already a collection
+                if (it is Expr.SFW || it is Expr.Collection || ctx.PAREN_LEFT() == null) {
+                    it
+                } else {
+                    // IN ( expr )
+                    exprCollection(Expr.Collection.Type.LIST, listOf(it))
+                }
+            }
+            val not = ctx.NOT() != null
+            exprInCollection(lhs, rhs, not)
+        }
+
+        override fun visitPredicateIs(ctx: GeneratedParser.PredicateIsContext) = translate(ctx) {
+            val value = visitAs<Expr>(ctx.lhs)
+            val type = visitAs<Type>(ctx.type())
+            val not = ctx.NOT() != null
+            exprIsType(value, type, not)
+        }
+
+        override fun visitPredicateBetween(ctx: GeneratedParser.PredicateBetweenContext) = translate(ctx) {
+            val value = visitAs<Expr>(ctx.lhs)
+            val lower = visitAs<Expr>(ctx.lower)
+            val upper = visitAs<Expr>(ctx.upper)
+            val not = ctx.NOT() != null
+            exprBetween(value, lower, upper, not)
+        }
+
+        override fun visitPredicateLike(ctx: GeneratedParser.PredicateLikeContext) = translate(ctx) {
+            val value = visitAs<Expr>(ctx.lhs)
+            val pattern = visitAs<Expr>(ctx.rhs)
+            val escape = visitOrNull<Expr>(ctx.escape)
+            val not = ctx.NOT() != null
+            exprLike(value, pattern, escape, not)
+        }
+
+        /**
+         *
+         * PRIMARY EXPRESSIONS
+         *
+         */
+
+        override fun visitExprTermWrappedQuery(ctx: GeneratedParser.ExprTermWrappedQueryContext): AstNode =
+            visit(ctx.expr())
+
+        override fun visitVariableIdentifier(ctx: GeneratedParser.VariableIdentifierContext) = translate(ctx) {
+            val symbol = ctx.ident.getStringValue()
+            val case = when (ctx.ident.type) {
+                GeneratedParser.IDENTIFIER -> Identifier.CaseSensitivity.INSENSITIVE
+                else -> Identifier.CaseSensitivity.SENSITIVE
+            }
+            val scope = when (ctx.qualifier) {
+                null -> Expr.Var.Scope.DEFAULT
+                else -> Expr.Var.Scope.LOCAL
+            }
+            exprVar(identifierSymbol(symbol, case), scope)
+        }
+
+        override fun visitVariableKeyword(ctx: GeneratedParser.VariableKeywordContext) = translate(ctx) {
+            val symbol = ctx.key.text
+            val case = Identifier.CaseSensitivity.INSENSITIVE
+            val scope = when (ctx.qualifier) {
+                null -> Expr.Var.Scope.DEFAULT
+                else -> Expr.Var.Scope.LOCAL
+            }
+            exprVar(identifierSymbol(symbol, case), scope)
+        }
+
+        override fun visitParameter(ctx: GeneratedParser.ParameterContext) = translate(ctx) {
+            val index = parameters[ctx.QUESTION_MARK().symbol.tokenIndex] ?: throw error(
+                ctx,
+                "Unable to find index of parameter."
+            )
+            exprParameter(index)
+        }
+
+        override fun visitSequenceConstructor(ctx: GeneratedParser.SequenceConstructorContext) = translate(ctx) {
+            val expressions = visitOrEmpty<Expr>(ctx.expr())
+            val type = when (ctx.datatype.type) {
+                GeneratedParser.LIST -> Expr.Collection.Type.LIST
+                GeneratedParser.SEXP -> Expr.Collection.Type.SEXP
+                else -> throw error(ctx.datatype, "Invalid sequence type")
+            }
+            exprCollection(type, expressions)
+        }
+
+        override fun visitExprPrimaryPath(ctx: GeneratedParser.ExprPrimaryPathContext) = translate(ctx) {
+            val base = visitAs<Expr>(ctx.exprPrimary())
+            val steps = ctx.pathStep().map { visit(it) as Expr.Path.Step }
+            exprPath(base, steps)
+        }
+
+        override fun visitPathStepIndexExpr(ctx: GeneratedParser.PathStepIndexExprContext) = translate(ctx) {
+            val key = visitAs<Expr>(ctx.key)
+            exprPathStepIndex(key)
+        }
+
+        override fun visitPathStepDotExpr(ctx: GeneratedParser.PathStepDotExprContext) = translate(ctx) {
+            val symbol = visitSymbolPrimitive(ctx.symbolPrimitive())
+            exprPathStepSymbol(symbol)
+        }
+
+        override fun visitPathStepIndexAll(ctx: GeneratedParser.PathStepIndexAllContext) = translate(ctx) {
+            exprPathStepWildcard()
+        }
+
+        override fun visitPathStepDotAll(ctx: GeneratedParser.PathStepDotAllContext) = translate(ctx) {
+            exprPathStepUnpivot()
+        }
+
+        override fun visitValues(ctx: GeneratedParser.ValuesContext) = translate(ctx) {
+            val rows = visitOrEmpty<Expr.Collection>(ctx.valueRow())
+            exprCollection(Expr.Collection.Type.BAG, rows)
+        }
+
+        override fun visitValueRow(ctx: GeneratedParser.ValueRowContext) = translate(ctx) {
+            val expressions = visitOrEmpty<Expr>(ctx.expr())
+            exprCollection(Expr.Collection.Type.LIST, expressions)
+        }
+
+        override fun visitValueList(ctx: GeneratedParser.ValueListContext) = translate(ctx) {
+            val expressions = visitOrEmpty<Expr>(ctx.expr())
+            exprCollection(Expr.Collection.Type.LIST, expressions)
+        }
+
+        override fun visitExprGraphMatchMany(ctx: GeneratedParser.ExprGraphMatchManyContext) = translate(ctx) {
+            val graph = visit(ctx.exprPrimary()) as Expr
+            val pattern = visitGpmlPatternList(ctx.gpmlPatternList())
+            exprMatch(graph, pattern)
+        }
+
+        override fun visitExprGraphMatchOne(ctx: GeneratedParser.ExprGraphMatchOneContext) = translate(ctx) {
+            val graph = visit(ctx.exprPrimary()) as Expr
+            val pattern = visitGpmlPattern(ctx.gpmlPattern())
+            exprMatch(graph, pattern)
+        }
+
+        override fun visitExprTermCurrentUser(ctx: GeneratedParser.ExprTermCurrentUserContext) = translate(ctx) {
+            exprSessionAttribute(Expr.SessionAttribute.Attribute.CURRENT_USER)
+        }
+
+        /**
+         *
+         * FUNCTIONS
+         *
+         */
+
+        override fun visitNullIf(ctx: GeneratedParser.NullIfContext) = translate(ctx) {
+            val value = visitExpr(ctx.expr(0))
+            val nullifier = visitExpr(ctx.expr(1))
+            exprNullIf(value, nullifier)
+        }
+
+        override fun visitCoalesce(ctx: GeneratedParser.CoalesceContext) = translate(ctx) {
+            val expressions = visitOrEmpty<Expr>(ctx.expr())
+            exprCoalesce(expressions)
+        }
+
+        override fun visitCaseExpr(ctx: GeneratedParser.CaseExprContext) = translate(ctx) {
+            val expr = ctx.case_?.let { visitExpr(it) }
+            val branches = ctx.whens.indices.map { i ->
+                // consider adding locations
+                val w = visitExpr(ctx.whens[i])
+                val t = visitExpr(ctx.thens[i])
+                exprCaseBranch(w, t)
+            }
+            val default = ctx.else_?.let { visitExpr(it) }
+            exprCase(expr, branches, default)
+        }
+
+        override fun visitCast(ctx: GeneratedParser.CastContext) = translate(ctx) {
+            val expr = visitExpr(ctx.expr())
+            val type = visitAs<Type>(ctx.type())
+            exprCast(expr, type)
+        }
+
+        override fun visitCanCast(ctx: GeneratedParser.CanCastContext) = translate(ctx) {
+            val expr = visitExpr(ctx.expr())
+            val type = visitAs<Type>(ctx.type())
+            exprCanCast(expr, type)
+        }
+
+        override fun visitCanLosslessCast(ctx: GeneratedParser.CanLosslessCastContext) = translate(ctx) {
+            val expr = visitExpr(ctx.expr())
+            val type = visitAs<Type>(ctx.type())
+            exprCanLosslessCast(expr, type)
+        }
+
+        override fun visitFunctionCallIdent(ctx: GeneratedParser.FunctionCallIdentContext) = translate(ctx) {
+            val function = visitSymbolPrimitive(ctx.name)
+            val args = visitOrEmpty<Expr>(ctx.expr())
+            exprCall(function, args)
+        }
+
+        override fun visitFunctionCallReserved(ctx: GeneratedParser.FunctionCallReservedContext) = translate(ctx) {
+            val function = ctx.name.text.toIdentifier()
+            val args = visitOrEmpty<Expr>(ctx.expr())
+            exprCall(function, args)
+        }
+
+        /**
+         *
+         * FUNCTIONS WITH SPECIAL FORMS
+         *
+         */
+
+        override fun visitDateFunction(ctx: GeneratedParser.DateFunctionContext) = translate(ctx) {
+            val field = try {
+                DatetimeField.valueOf(ctx.dt.text.uppercase())
+            } catch (ex: IllegalArgumentException) {
+                throw error(ctx.dt, "Expected one of: ${DatetimeField.values().joinToString()}", ex)
+            }
+            val lhs = visitExpr(ctx.expr(0))
+            val rhs = visitExpr(ctx.expr(1))
+            when {
+                ctx.DATE_ADD() != null -> exprDateAdd(field, lhs, rhs)
+                ctx.DATE_DIFF() != null -> exprDateDiff(field, lhs, rhs)
+                else -> throw error(ctx, "Expected DATE_ADD or DATE_DIFF")
+            }
+        }
+
+        /**
+         * TODO Add labels to each alternative, https://github.com/partiql/partiql-lang-kotlin/issues/1113
+         */
+        override fun visitSubstring(ctx: GeneratedParser.SubstringContext) = translate(ctx) {
+            if (ctx.FROM() == null) {
+                // normal form
+                val function = "SUBSTRING".toIdentifier()
+                val args = visitOrEmpty<Expr>(ctx.expr())
+                exprCall(function, args)
+            } else {
+                // special form
+                val value = visitExpr(ctx.expr(0))
+                val start = visitOrNull<Expr>(ctx.expr(1))
+                val length = visitOrNull<Expr>(ctx.expr(2))
+                exprSubstring(value, start, length)
+            }
+        }
+
+        /**
+         * TODO Add labels to each alternative, https://github.com/partiql/partiql-lang-kotlin/issues/1113
+         */
+        override fun visitPosition(ctx: GeneratedParser.PositionContext) = translate(ctx) {
+            if (ctx.IN() == null) {
+                // normal form
+                val function = "POSITION".toIdentifier()
+                val args = visitOrEmpty<Expr>(ctx.expr())
+                exprCall(function, args)
+            } else {
+                // special form
+                val lhs = visitExpr(ctx.expr(0))
+                val rhs = visitExpr(ctx.expr(1))
+                exprPosition(lhs, rhs)
+            }
+        }
+
+        /**
+         * TODO Add labels to each alternative, https://github.com/partiql/partiql-lang-kotlin/issues/1113
+         */
+        override fun visitOverlay(ctx: GeneratedParser.OverlayContext) = translate(ctx) {
+            if (ctx.PLACING() == null) {
+                // normal form
+                val function = "OVERLAY".toIdentifier()
+                val args = visitOrEmpty<Expr>(ctx.expr())
+                exprCall(function, args)
+            } else {
+                // special form
+                val value = visitExpr(ctx.expr(0))
+                val overlay = visitExpr(ctx.expr(1))
+                val start = visitExpr(ctx.expr(2))
+                val length = visitOrNull<Expr>(ctx.expr(3))
+                exprOverlay(value, overlay, start, length)
+            }
+        }
+
+        /**
+         * COUNT(*)
+         */
+        override fun visitCountAll(ctx: GeneratedParser.CountAllContext) = translate(ctx) {
+            val function = "COUNT_STAR".toIdentifier()
+            exprAgg(function, emptyList(), SetQuantifier.ALL)
+        }
+
+        override fun visitExtract(ctx: GeneratedParser.ExtractContext) = translate(ctx) {
+            val field = try {
+                DatetimeField.valueOf(ctx.IDENTIFIER().text.uppercase())
+            } catch (ex: IllegalArgumentException) {
+                throw error(ctx.IDENTIFIER().symbol, "Expected one of: ${DatetimeField.values().joinToString()}", ex)
+            }
+            val source = visitExpr(ctx.expr())
+            exprExtract(field, source)
+        }
+
+        override fun visitTrimFunction(ctx: GeneratedParser.TrimFunctionContext) = translate(ctx) {
+            val spec = ctx.mod?.let {
+                try {
+                    Expr.Trim.Spec.valueOf(it.text.uppercase())
+                } catch (ex: IllegalArgumentException) {
+                    throw error(it, "Expected on of: ${Expr.Trim.Spec.values().joinToString()}", ex)
+                }
+            }
+            val (chars, value) = when (ctx.expr().size) {
+                1 -> null to visitExpr(ctx.expr(0))
+                2 -> visitExpr(ctx.expr(0)) to visitExpr(ctx.expr(1))
+                else -> throw error(ctx, "Expected one or two TRIM expression arguments")
+            }
+            exprTrim(value, chars, spec)
+        }
+
+        override fun visitAggregateBase(ctx: GeneratedParser.AggregateBaseContext) = translate(ctx) {
+            val function = ctx.func.text.toIdentifier()
+            val args = listOf(visitExpr(ctx.expr()))
+            val setq = convertSetQuantifier(ctx.setQuantifierStrategy())
+            exprAgg(function, args, setq)
+        }
+
+        /**
+         * Window Functions
+         */
+
+        override fun visitLagLeadFunction(ctx: GeneratedParser.LagLeadFunctionContext) = translate(ctx) {
+            val function = when {
+                ctx.LAG() != null -> Expr.Window.Function.LAG
+                ctx.LEAD() != null -> Expr.Window.Function.LEAD
+                else -> throw error(ctx, "Expected LAG or LEAD")
+            }
+            val expression = visitExpr(ctx.expr(0))
+            val offset = visitOrNull<Expr>(ctx.expr(1))
+            val default = visitOrNull<Expr>(ctx.expr(2))
+            val over = visitOver(ctx.over())
+            if (over.sorts == null) {
+                throw error(ctx.over(), "$function requires Window ORDER BY")
+            }
+            exprWindow(function, expression, offset, default, over)
+        }
+
+        override fun visitOver(ctx: GeneratedParser.OverContext) = translate(ctx) {
+            val partitions = ctx.windowPartitionList()?.let { visitOrEmpty<Expr>(it.expr()) }
+            val sorts = ctx.windowSortSpecList()?.let { visitOrEmpty<Sort>(it.orderSortSpec()) }
+            exprWindowOver(partitions, sorts)
+        }
+
+        /**
+         *
+         * LITERALS
+         *
+         */
+
+        override fun visitBag(ctx: GeneratedParser.BagContext) = translate(ctx) {
+            val expressions = visitOrEmpty<Expr>(ctx.expr())
+            exprCollection(Expr.Collection.Type.BAG, expressions)
+        }
+
+        override fun visitLiteralDecimal(ctx: GeneratedParser.LiteralDecimalContext) = translate(ctx) {
+            val decimal = try {
+                val v = ctx.LITERAL_DECIMAL().text.trim()
+                BigDecimal(v, MathContext(38, RoundingMode.HALF_EVEN))
+            } catch (e: NumberFormatException) {
+                throw error(ctx, "Invalid decimal literal", e)
+            }
+            exprLit(decimalValue(decimal))
+        }
+
+        override fun visitArray(ctx: GeneratedParser.ArrayContext) = translate(ctx) {
+            val expressions = visitOrEmpty<Expr>(ctx.expr())
+            exprCollection(Expr.Collection.Type.ARRAY, expressions)
+        }
+
+        override fun visitLiteralNull(ctx: GeneratedParser.LiteralNullContext) = translate(ctx) {
+            exprLit(nullValue())
+        }
+
+        override fun visitLiteralMissing(ctx: GeneratedParser.LiteralMissingContext) = translate(ctx) {
+            exprLit(missingValue())
+        }
+
+        override fun visitLiteralTrue(ctx: GeneratedParser.LiteralTrueContext) = translate(ctx) {
+            exprLit(boolValue(true))
+        }
+
+        override fun visitLiteralFalse(ctx: GeneratedParser.LiteralFalseContext) = translate(ctx) {
+            exprLit(boolValue(false))
+        }
+
+        override fun visitLiteralIon(ctx: GeneratedParser.LiteralIonContext) = translate(ctx) {
+            val value = try {
+                loadSingleElement(ctx.ION_CLOSURE().getStringValue())
+            } catch (e: IonElementException) {
+                throw error(ctx, "Unable to parse Ion value.", e)
+            }
+            exprIon(value)
+        }
+
+        override fun visitLiteralString(ctx: GeneratedParser.LiteralStringContext) = translate(ctx) {
+            val value = ctx.LITERAL_STRING().getStringValue()
+            exprLit(stringValue(value))
+        }
+
+        override fun visitLiteralInteger(ctx: GeneratedParser.LiteralIntegerContext) = translate(ctx) {
+            val n = ctx.LITERAL_INTEGER().text.toInt()
+            val v = try {
+                int64Value(n.toLong())
+            } catch (_: java.lang.NumberFormatException) {
+                intValue(n.toBigInteger())
+            }
+            exprLit(v)
+        }
+
+        override fun visitLiteralDate(ctx: GeneratedParser.LiteralDateContext) = translate(ctx) {
+            val pattern = ctx.LITERAL_STRING().symbol
+            val dateString = ctx.LITERAL_STRING().getStringValue()
+            if (DATE_PATTERN_REGEX.matches(dateString).not()) {
+                throw error(pattern, "Expected DATE string to be of the format yyyy-MM-dd")
+            }
+            val value = try {
+                LocalDate.parse(dateString, DateTimeFormatter.ISO_LOCAL_DATE)
+            } catch (e: DateTimeParseException) {
+                throw error(pattern, e.localizedMessage, e)
+            } catch (e: IndexOutOfBoundsException) {
+                throw error(pattern, e.localizedMessage, e)
+            }
+            val date = DateTimeValue.date(value.year, value.monthValue, value.dayOfMonth)
+            exprLit(dateValue(date))
+        }
+
+        override fun visitLiteralTime(ctx: GeneratedParser.LiteralTimeContext) = translate(ctx) {
+            val (timeString, precision) = getTimeStringAndPrecision(ctx.LITERAL_STRING(), ctx.LITERAL_INTEGER())
+            val time = try {
+                DateTimeUtils.parseTimeLiteral(timeString)
+            } catch (e: DateTimeException) {
+                throw error(ctx, "Invalid Date Time Literal", e)
+            }
+            val value = time.toPrecision(precision)
+            exprLit(timeValue(value))
+        }
+
+        override fun visitLiteralTimestamp(ctx: GeneratedParser.LiteralTimestampContext) = translate(ctx) {
+            val (timeString, precision) = getTimeStringAndPrecision(ctx.LITERAL_STRING(), ctx.LITERAL_INTEGER())
+            val timestamp = try {
+                DateTimeUtils.parseTimestamp(timeString)
+            } catch (e: DateTimeException) {
+                throw error(ctx, "Invalid Date Time Literal", e)
+            }
+            val value = timestamp.toPrecision(precision)
+            exprLit(timestampValue(value))
+        }
+
+        override fun visitTuple(ctx: GeneratedParser.TupleContext) = translate(ctx) {
+            val fields = ctx.pair().map {
+                val k = visitExpr(it.lhs)
+                val v = visitExpr(it.rhs)
+                exprStructField(k, v)
+            }
+            exprStruct(fields)
+        }
+
+        /**
+         *
+         * TYPES
+         *
+         */
+
+        override fun visitTypeAtomic(ctx: GeneratedParser.TypeAtomicContext) = translate(ctx) {
+            when (ctx.datatype.type) {
+                GeneratedParser.NULL -> typeNullType()
+                GeneratedParser.BOOL, GeneratedParser.BOOLEAN -> typeBool()
+                GeneratedParser.SMALLINT, GeneratedParser.INT2, GeneratedParser.INTEGER2 -> typeInt2()
+                GeneratedParser.INT4, GeneratedParser.INTEGER4 -> typeInt4()
+                GeneratedParser.BIGINT, GeneratedParser.INT8, GeneratedParser.INTEGER8 -> typeInt8()
+                GeneratedParser.INT, GeneratedParser.INTEGER -> typeInt()
+                GeneratedParser.FLOAT -> typeFloat32()
+                GeneratedParser.DOUBLE -> typeFloat64()
+                GeneratedParser.REAL -> typeReal()
+                GeneratedParser.TIMESTAMP -> typeTimestamp(null)
+                GeneratedParser.CHAR, GeneratedParser.CHARACTER -> typeChar(null)
+                GeneratedParser.MISSING -> typeMissing()
+                GeneratedParser.STRING -> typeString(null)
+                GeneratedParser.SYMBOL -> typeSymbol()
+                // TODO https://github.com/partiql/partiql-lang-kotlin/issues/1125
+                GeneratedParser.BLOB -> typeBlob(null)
+                GeneratedParser.CLOB -> typeClob(null)
+                GeneratedParser.DATE -> typeDate()
+                GeneratedParser.STRUCT -> typeStruct()
+                GeneratedParser.TUPLE -> typeTuple()
+                GeneratedParser.LIST -> typeList()
+                GeneratedParser.SEXP -> typeSexp()
+                GeneratedParser.BAG -> typeBag()
+                GeneratedParser.ANY -> typeAny()
+                else -> throw error(ctx, "Unknown atomic type.")
+            }
+        }
+
+        override fun visitTypeVarChar(ctx: GeneratedParser.TypeVarCharContext) = translate(ctx) {
+            val n = ctx.arg0?.text?.toInt()
+            typeVarchar(n)
+        }
+
+        override fun visitTypeArgSingle(ctx: GeneratedParser.TypeArgSingleContext) = translate(ctx) {
+            val n = ctx.arg0?.text?.toInt()
+            when (ctx.datatype.type) {
+                GeneratedParser.FLOAT -> when (n) {
+                    32 -> typeFloat32()
+                    64 -> typeFloat64()
+                    else -> throw error(ctx.datatype, "Invalid FLOAT precision. Expected 32 or 64")
+                }
+                GeneratedParser.CHAR, GeneratedParser.CHARACTER -> typeChar(n)
+                GeneratedParser.VARCHAR -> typeVarchar(n)
+                else -> throw error(ctx.datatype, "Invalid datatype")
+            }
+        }
+
+        override fun visitTypeArgDouble(ctx: GeneratedParser.TypeArgDoubleContext) = translate(ctx) {
+            val arg0 = ctx.arg0?.text?.toInt()
+            val arg1 = ctx.arg1?.text?.toInt()
+            when (ctx.datatype.type) {
+                GeneratedParser.DECIMAL, GeneratedParser.DEC -> typeDecimal(arg0, arg1)
+                GeneratedParser.NUMERIC -> typeNumeric(arg0, arg1)
+                else -> throw error(ctx.datatype, "Invalid datatype")
+            }
+        }
+
+        override fun visitTypeTimeZone(ctx: GeneratedParser.TypeTimeZoneContext) = translate(ctx) {
+            val precision = ctx.precision?.let {
+                val p = ctx.precision.text.toInt()
+                if (p < 0 || 9 < p) throw error(ctx.precision, "Unsupported time precision")
+                p
+            }
+            when (ctx.ZONE()) {
+                null -> typeTime(precision)
+                else -> typeTimeWithTz(precision)
+            }
+        }
+
+        override fun visitTypeCustom(ctx: GeneratedParser.TypeCustomContext) = translate(ctx) {
+            typeCustom(ctx.text.uppercase())
+        }
+
+        private inline fun <reified T : AstNode> visitOrEmpty(ctx: List<ParserRuleContext>?): List<T> = when {
+            ctx.isNullOrEmpty() -> emptyList()
+            else -> ctx.map { visit(it) as T }
+        }
+
+        private inline fun <reified T : AstNode> visitOrNull(ctx: ParserRuleContext?): T? = ctx?.let { it.accept(this) as T }
+
+        private inline fun <reified T : AstNode> visitAs(ctx: ParserRuleContext): T = visit(ctx) as T
+
+        /**
+         * Visiting a symbol to get a string, skip the wrapping, unwrapping, and location tracking.
+         */
+        private fun symbolToString(ctx: GeneratedParser.SymbolPrimitiveContext) = when (ctx.ident.type) {
+            GeneratedParser.IDENTIFIER_QUOTED -> ctx.IDENTIFIER_QUOTED().getStringValue()
+            GeneratedParser.IDENTIFIER -> ctx.IDENTIFIER().getStringValue()
+            else -> throw error(ctx, "Invalid symbol reference.")
+        }
+
+        /**
+         * Convert [ALL|DISTINCT] to SetQuantifier Enum
+         */
+        private fun convertSetQuantifier(ctx: GeneratedParser.SetQuantifierStrategyContext?): SetQuantifier? = when {
+            ctx == null -> null
+            ctx.ALL() != null -> SetQuantifier.ALL
+            ctx.DISTINCT() != null -> SetQuantifier.DISTINCT
+            else -> throw error(ctx, "Expected set quantifier ALL or DISTINCT")
+        }
+
+        /**
+         * With the <string> and <int> nodes of a literal time expression, returns the parsed string and precision.
+         * TIME (<int>)? (WITH TIME ZONE)? <string>
+         */
+        private fun getTimeStringAndPrecision(
+            stringNode: TerminalNode,
+            integerNode: TerminalNode?
+        ): Pair<String, Int> {
+            val timeString = stringNode.getStringValue()
+            val precision = when (integerNode) {
+                null -> {
+                    try {
+                        getPrecisionFromTimeString(timeString)
+                    } catch (e: Exception) {
+                        throw error(stringNode.symbol, "Unable to parse precision.", e)
+                    }
+                }
+                else -> {
+                    val p = integerNode.text.toBigInteger().toInt()
+                    if (p < 0 || 9 < p) throw error(integerNode.symbol, "Precision out of bounds")
+                    p
+                }
+            }
+            return timeString to precision
+        }
+
+        private fun getPrecisionFromTimeString(timeString: String): Int {
+            val matcher = GENERIC_TIME_REGEX.toPattern().matcher(timeString)
+            if (!matcher.find()) {
+                throw IllegalArgumentException("Time string does not match the format 'HH:MM:SS[.ddd....][+|-HH:MM]'")
+            }
+            val fraction = matcher.group(1)?.removePrefix(".")
+            return fraction?.length ?: 0
+        }
+
+        /**
+         * Converts a Path expression into a Projection Item (either ALL or EXPR). Note: A Projection Item only allows a
+         * subset of a typical Path expressions. See the following examples.
+         *
+         * Examples of valid projections are:
+         *
+         * ```partiql
+         *      SELECT * FROM foo
+         *      SELECT foo.* FROM foo
+         *      SELECT f.* FROM foo as f
+         *      SELECT foo.bar.* FROM foo
+         *      SELECT f.bar.* FROM foo as f
+         * ```
+         * Also validates that the expression is valid for select list context. It does this by making
+         * sure that expressions looking like the following do not appear:
+         *
+         * ```partiql
+         *      SELECT foo[*] FROM foo
+         *      SELECT f.*.bar FROM foo as f
+         *      SELECT foo[1].* FROM foo
+         *      SELECT foo.*.bar FROM foo
+         * ```
+         */
+        protected fun convertPathToProjectionItem(ctx: ParserRuleContext, path: Expr.Path, alias: Identifier.Symbol?) =
+            translate(ctx) {
+                val steps = mutableListOf<Expr.Path.Step>()
+                var containsIndex = false
+                path.steps.forEachIndexed { index, step ->
+                    // Only last step can have a '.*'
+                    if (step is Expr.Path.Step.Unpivot && index != path.steps.lastIndex) {
+                        throw error(ctx, "Projection item cannot unpivot unless at end.")
+                    }
+                    // No step can have an indexed wildcard: '[*]'
+                    if (step is Expr.Path.Step.Wildcard) {
+                        throw error(ctx, "Projection item cannot index using wildcard.")
+                    }
+                    // TODO If the last step is '.*', no indexing is allowed
+                    // if (step.metas.containsKey(IsPathIndexMeta.TAG)) {
+                    //     containsIndex = true
+                    // }
+                    if (step !is Expr.Path.Step.Unpivot) {
+                        steps.add(step)
+                    }
+                }
+                if (path.steps.last() is Expr.Path.Step.Unpivot && containsIndex) {
+                    throw error(ctx, "Projection item use wildcard with any indexing.")
+                }
+                when {
+                    path.steps.last() is Expr.Path.Step.Unpivot && steps.isEmpty() -> {
+                        selectProjectItemAll(path.root)
+                    }
+                    path.steps.last() is Expr.Path.Step.Unpivot -> {
+                        selectProjectItemAll(factory.exprPath(path.root, steps))
+                    }
+                    else -> {
+                        selectProjectItemExpression(path, alias)
+                    }
+                }
+            }
+
+        private fun TerminalNode.getStringValue(): String = this.symbol.getStringValue()
+
+        private fun Token.getStringValue(): String = when (this.type) {
+            GeneratedParser.IDENTIFIER -> this.text
+            GeneratedParser.IDENTIFIER_QUOTED -> this.text.removePrefix("\"").removeSuffix("\"").replace("\"\"", "\"")
+            GeneratedParser.LITERAL_STRING -> this.text.removePrefix("'").removeSuffix("'").replace("''", "'")
+            GeneratedParser.ION_CLOSURE -> this.text.removePrefix("`").removeSuffix("`")
+            else -> throw error(this, "Unsupported token for grabbing string value.")
+        }
+
+        private fun String.toIdentifier(): Identifier.Symbol = factory.identifierSymbol(
+            symbol = this,
+            caseSensitivity = Identifier.CaseSensitivity.INSENSITIVE,
+        )
+
+        private fun String.toBigInteger() = BigInteger(this, 10)
+
+        private fun assertIntegerElement(token: Token?, value: IonElement?) {
+            if (value == null || token == null) return
+            if (value !is IntElement) throw error(token, "Expected an integer value.")
+            if (value.integerSize == IntElementSize.BIG_INTEGER || value.longValue > Int.MAX_VALUE || value.longValue < Int.MIN_VALUE) throw error(
+                token, "Type parameter exceeded maximum value"
+            )
+        }
+
+        private enum class ExplainParameters {
+            TYPE, FORMAT;
+
+            fun getCompliantString(target: String?, input: Token): String = when (target) {
+                null -> input.text!!
+                else -> throw error(input, "Cannot set EXPLAIN parameter ${this.name} multiple times.")
+            }
+        }
+    }
+}
diff --git a/partiql-parser/src/main/kotlin/org/partiql/parser/impl/util/DateTimeUtils.kt b/partiql-parser/src/main/kotlin/org/partiql/parser/impl/util/DateTimeUtils.kt
new file mode 100644
index 0000000000..ea4b9a1a70
--- /dev/null
+++ b/partiql-parser/src/main/kotlin/org/partiql/parser/impl/util/DateTimeUtils.kt
@@ -0,0 +1,76 @@
+package org.partiql.parser.impl.util
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeValue
+import org.partiql.value.datetime.Time
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.Timestamp
+import java.math.BigDecimal
+import java.util.regex.Matcher
+import java.util.regex.Pattern
+
+internal object DateTimeUtils {
+    private val DATE_PATTERN: Pattern = Pattern.compile("(?<year>\\d{4,})-(?<month>\\d{2,})-(?<day>\\d{2,})")
+    private val TIME_PATTERN: Pattern = Pattern.compile("(?<hour>\\d{2,}):(?<minute>\\d{2,}):(?<second>\\d{2,})(?:\\.(?<fraction>\\d+))?\\s*(?<timezone>([+-]\\d\\d:\\d\\d)|(?<utc>[Zz]))?")
+    private val SQL_TIMESTAMP_DATE_TIME_DELIMITER = "\\s+".toRegex()
+    private val RFC8889_TIMESTAMP_DATE_TIME_DELIMITER = "[Tt]".toRegex()
+    private val TIMESTAMP_PATTERN = "(?<date>$DATE_PATTERN)($SQL_TIMESTAMP_DATE_TIME_DELIMITER|$RFC8889_TIMESTAMP_DATE_TIME_DELIMITER)(?<time>$TIME_PATTERN)".toRegex().toPattern()
+
+    internal fun parseDateLiteral(dateString: String): Date {
+        val matcher: Matcher = DATE_PATTERN.matcher(dateString)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expected Date Format to be in YYYY-MM-DD, received $dateString"
+        )
+        val year = matcher.group("year").toInt()
+        val month = matcher.group("month").toInt()
+        val day = matcher.group("day").toInt()
+        return DateTimeValue.date(year, month, day)
+    }
+
+    internal fun parseTimeLiteral(timeString: String): Time {
+        val matcher: Matcher = TIME_PATTERN.matcher(timeString)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expect TIME Format to be in HH-mm-ss.ddd+[+|-][hh:mm|z], received $timeString"
+        )
+        try {
+            val hour = matcher.group("hour").toInt()
+            val minute = matcher.group("minute").toInt()
+            val wholeSecond = matcher.group("second").toLong()
+            val fractionPart = matcher.group("fraction")?.let { BigDecimal(".$it") } ?: BigDecimal.ZERO
+            val second = BigDecimal.valueOf(wholeSecond).add(fractionPart)
+            val timeZoneString = matcher.group("timezone") ?: null
+            if (timeZoneString != null) {
+                matcher.group("utc")?.let { return DateTimeValue.time(hour, minute, second, TimeZone.UtcOffset.of(0)) }
+                val timeZone = getTimeZoneComponent(timeZoneString)
+                return DateTimeValue.time(hour, minute, second, timeZone)
+            }
+            return DateTimeValue.time(hour, minute, second)
+        } catch (e: IllegalStateException) {
+            throw DateTimeException(e.localizedMessage)
+        } catch (e: IllegalArgumentException) {
+            throw DateTimeException(e.localizedMessage)
+        }
+    }
+
+    fun parseTimestamp(timestampString: String): Timestamp {
+        val matcher: Matcher = TIMESTAMP_PATTERN.matcher(timestampString)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expected TIMESTAMP Format should be in YYYY-MM-DD[\\s|T]hh:mm:ss.ddd+[hh:mm|z], received $timestampString"
+        )
+        val date = parseDateLiteral(matcher.group("date"))
+        val time = parseTimeLiteral(matcher.group("time"))
+        return DateTimeValue.timestamp(date, time)
+    }
+
+    private fun getTimeZoneComponent(timezone: String): TimeZone {
+        val tzSign = timezone.substring(0, 1).first()
+        val tzHour = timezone.substring(1, 3).toInt()
+        val tzMinute = timezone.substring(4, 6).toInt()
+        return when {
+            tzSign == '-' && tzHour == 0 && tzMinute == 0 -> TimeZone.UnknownTimeZone
+            tzSign == '-' -> TimeZone.UtcOffset.of(-tzHour, -tzMinute)
+            else -> TimeZone.UtcOffset.of(tzHour, tzMinute)
+        }
+    }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/PartiQL.kt b/partiql-types/src/main/kotlin/org/partiql/value/PartiQL.kt
index a04e94f226..a6fea4f9bf 100644
--- a/partiql-types/src/main/kotlin/org/partiql/value/PartiQL.kt
+++ b/partiql-types/src/main/kotlin/org/partiql/value/PartiQL.kt
@@ -18,6 +18,9 @@
 package org.partiql.value
 
 import kotlinx.collections.immutable.toPersistentList
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.Time
+import org.partiql.value.datetime.Timestamp
 import org.partiql.value.impl.BagValueImpl
 import org.partiql.value.impl.BinaryValueImpl
 import org.partiql.value.impl.BlobValueImpl
@@ -70,10 +73,6 @@ import org.partiql.value.impl.TimeValueImpl
 import org.partiql.value.impl.TimestampValueImpl
 import java.math.BigDecimal
 import java.math.BigInteger
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-import java.time.ZoneOffset
 import java.util.BitSet
 
 /**
@@ -310,7 +309,7 @@ public fun blobValue(
 @JvmOverloads
 @PartiQLValueExperimental
 public fun dateValue(
-    value: LocalDate,
+    value: Date,
     annotations: Annotations = emptyList(),
 ): DateValue = DateValueImpl(value, annotations.toPersistentList())
 
@@ -324,12 +323,9 @@ public fun dateValue(
 @JvmOverloads
 @PartiQLValueExperimental
 public fun timeValue(
-    value: LocalTime,
-    precision: Int = 0,
-    offset: ZoneOffset? = null,
-    withZone: Boolean = false,
+    value: Time,
     annotations: Annotations = emptyList(),
-): TimeValue = TimeValueImpl(value, precision, offset, withZone, annotations.toPersistentList())
+): TimeValue = TimeValueImpl(value, annotations.toPersistentList())
 
 /**
  * TIMESTAMP type value.
@@ -341,12 +337,9 @@ public fun timeValue(
 @JvmOverloads
 @PartiQLValueExperimental
 public fun timestampValue(
-    value: LocalDateTime,
-    precision: Int = 0,
-    offset: ZoneOffset? = null,
-    withZone: Boolean = false,
+    value: Timestamp,
     annotations: Annotations = emptyList(),
-): TimestampValue = TimestampValueImpl(value, precision, offset, withZone, annotations.toPersistentList())
+): TimestampValue = TimestampValueImpl(value, annotations.toPersistentList())
 
 /**
  * INTERVAL type value.
@@ -680,7 +673,7 @@ public fun nullableBlobValue(
 @JvmOverloads
 @PartiQLValueExperimental
 public fun nullableDateValue(
-    value: LocalDate? = null,
+    value: Date? = null,
     annotations: Annotations = emptyList(),
 ): NullableDateValue = NullableDateValueImpl(value, annotations.toPersistentList())
 
@@ -694,37 +687,9 @@ public fun nullableDateValue(
 @JvmOverloads
 @PartiQLValueExperimental
 public fun nullableTimeValue(
+    value: Time? = null,
     annotations: Annotations = emptyList(),
-): NullableTimeValue = NullableTimeValueImpl(null, 0, null, false, annotations.toPersistentList())
-
-/**
- * UNION(NULL, TIME) type value.
- *
- * @param value
- * @param annotations
- * @return
- */
-@JvmOverloads
-@PartiQLValueExperimental
-public fun nullableTimeValue(
-    value: LocalTime,
-    precision: Int = 0,
-    offset: ZoneOffset? = null,
-    withZone: Boolean = false,
-    annotations: Annotations = emptyList(),
-): NullableTimeValue = NullableTimeValueImpl(value, precision, offset, withZone, annotations.toPersistentList())
-
-/**
- * UNION(NULL, TIMESTAMP) type value.
- *
- * @param annotations
- * @return
- */
-@JvmOverloads
-@PartiQLValueExperimental
-public fun nullableTimestampValue(
-    annotations: Annotations = emptyList(),
-): NullableTimestampValue = NullableTimestampValueImpl(null, 0, null, false, annotations.toPersistentList())
+): NullableTimeValue = NullableTimeValueImpl(value, annotations.toPersistentList())
 
 /**
  * UNION(NULL, TIMESTAMP) type value.
@@ -736,16 +701,13 @@ public fun nullableTimestampValue(
 @JvmOverloads
 @PartiQLValueExperimental
 public fun nullableTimestampValue(
-    value: LocalDateTime,
-    precision: Int = 0,
-    offset: ZoneOffset? = null,
-    withZone: Boolean = false,
+    value: Timestamp? = null,
     annotations: Annotations = emptyList(),
 ): NullableTimestampValue =
-    NullableTimestampValueImpl(value, precision, offset, withZone, annotations.toPersistentList())
+    NullableTimestampValueImpl(value, annotations.toPersistentList())
 
 /**
- * UNION(NULL, TIMESTAMP) type value.
+ * UNION(NULL, INTERVAL) type value.
  *
  * @param value
  * @param annotations
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/PartiQLValue.kt b/partiql-types/src/main/kotlin/org/partiql/value/PartiQLValue.kt
index d1f49e86ae..97887e5870 100644
--- a/partiql-types/src/main/kotlin/org/partiql/value/PartiQLValue.kt
+++ b/partiql-types/src/main/kotlin/org/partiql/value/PartiQLValue.kt
@@ -15,13 +15,12 @@
 package org.partiql.value
 
 import org.partiql.types.PartiQLValueType
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.Time
+import org.partiql.value.datetime.Timestamp
 import org.partiql.value.util.PartiQLValueVisitor
 import java.math.BigDecimal
 import java.math.BigInteger
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-import java.time.ZoneOffset
 import java.util.BitSet
 
 internal typealias Annotations = List<String>
@@ -325,7 +324,7 @@ public abstract class BlobValue : ScalarValue<ByteArray> {
 }
 
 @PartiQLValueExperimental
-public abstract class DateValue : ScalarValue<LocalDate> {
+public abstract class DateValue : ScalarValue<Date> {
 
     override val type: PartiQLValueType = PartiQLValueType.DATE
 
@@ -337,19 +336,10 @@ public abstract class DateValue : ScalarValue<LocalDate> {
 }
 
 @PartiQLValueExperimental
-public abstract class TimeValue : ScalarValue<LocalTime> {
+public abstract class TimeValue : ScalarValue<Time> {
 
     override val type: PartiQLValueType = PartiQLValueType.TIME
 
-    // TEMPORARY
-    public abstract val precision: Int
-
-    // TEMPORARY
-    public abstract val offset: ZoneOffset?
-
-    // TEMPORARY
-    public abstract val withZone: Boolean
-
     abstract override fun copy(annotations: Annotations): TimeValue
 
     abstract override fun withAnnotations(annotations: Annotations): TimeValue
@@ -358,19 +348,10 @@ public abstract class TimeValue : ScalarValue<LocalTime> {
 }
 
 @PartiQLValueExperimental
-public abstract class TimestampValue : ScalarValue<LocalDateTime> {
+public abstract class TimestampValue : ScalarValue<Timestamp> {
 
     override val type: PartiQLValueType = PartiQLValueType.TIMESTAMP
 
-    // TEMPORARY
-    public abstract val precision: Int
-
-    // TEMPORARY
-    public abstract val offset: ZoneOffset?
-
-    // TEMPORARY
-    public abstract val withZone: Boolean
-
     abstract override fun copy(annotations: Annotations): TimestampValue
 
     abstract override fun withAnnotations(annotations: Annotations): TimestampValue
@@ -465,11 +446,10 @@ public sealed interface NullableScalarValue<T> : PartiQLValue {
 }
 
 @PartiQLValueExperimental
-public sealed interface NullableCollectionValue<T : PartiQLValue> : PartiQLValue, Collection<T> {
-
-    public override val size: Int
+public sealed interface NullableCollectionValue<T : PartiQLValue> : PartiQLValue {
+    public fun isNull(): Boolean
 
-    public val elements: Collection<T>?
+    public fun promote(): CollectionValue<T>
 
     override fun copy(annotations: Annotations): NullableCollectionValue<T>
 
@@ -717,7 +697,7 @@ public abstract class NullableBlobValue : NullableScalarValue<ByteArray> {
 }
 
 @PartiQLValueExperimental
-public abstract class NullableDateValue : NullableScalarValue<LocalDate> {
+public abstract class NullableDateValue : NullableScalarValue<Date> {
 
     override val type: PartiQLValueType = PartiQLValueType.NULLABLE_DATE
 
@@ -729,19 +709,10 @@ public abstract class NullableDateValue : NullableScalarValue<LocalDate> {
 }
 
 @PartiQLValueExperimental
-public abstract class NullableTimeValue : NullableScalarValue<LocalTime> {
+public abstract class NullableTimeValue : NullableScalarValue<Time> {
 
     override val type: PartiQLValueType = PartiQLValueType.NULLABLE_TIME
 
-    // TEMPORARY
-    public abstract val precision: Int
-
-    // TEMPORARY
-    public abstract val offset: ZoneOffset?
-
-    // TEMPORARY
-    public abstract val withZone: Boolean
-
     abstract override fun copy(annotations: Annotations): NullableTimeValue
 
     abstract override fun withAnnotations(annotations: Annotations): NullableTimeValue
@@ -750,19 +721,10 @@ public abstract class NullableTimeValue : NullableScalarValue<LocalTime> {
 }
 
 @PartiQLValueExperimental
-public abstract class NullableTimestampValue : NullableScalarValue<LocalDateTime> {
+public abstract class NullableTimestampValue : NullableScalarValue<Timestamp> {
 
     override val type: PartiQLValueType = PartiQLValueType.NULLABLE_TIMESTAMP
 
-    // TEMPORARY
-    public abstract val precision: Int
-
-    // TEMPORARY
-    public abstract val offset: ZoneOffset?
-
-    // TEMPORARY
-    public abstract val withZone: Boolean
-
     abstract override fun copy(annotations: Annotations): NullableTimestampValue
 
     abstract override fun withAnnotations(annotations: Annotations): NullableTimestampValue
@@ -787,6 +749,8 @@ public abstract class NullableBagValue<T : PartiQLValue> : NullableCollectionVal
 
     override val type: PartiQLValueType = PartiQLValueType.NULLABLE_BAG
 
+    abstract override fun promote(): BagValue<T>
+
     abstract override fun copy(annotations: Annotations): NullableBagValue<T>
 
     abstract override fun withAnnotations(annotations: Annotations): NullableBagValue<T>
@@ -799,6 +763,8 @@ public abstract class NullableListValue<T : PartiQLValue> : NullableCollectionVa
 
     override val type: PartiQLValueType = PartiQLValueType.NULLABLE_LIST
 
+    abstract override fun promote(): ListValue<T>
+
     abstract override fun copy(annotations: Annotations): NullableListValue<T>
 
     abstract override fun withAnnotations(annotations: Annotations): NullableListValue<T>
@@ -811,6 +777,8 @@ public abstract class NullableSexpValue<T : PartiQLValue> : NullableCollectionVa
 
     override val type: PartiQLValueType = PartiQLValueType.NULLABLE_SEXP
 
+    abstract override fun promote(): SexpValue<T>
+
     abstract override fun copy(annotations: Annotations): NullableSexpValue<T>
 
     abstract override fun withAnnotations(annotations: Annotations): NullableSexpValue<T>
@@ -819,9 +787,10 @@ public abstract class NullableSexpValue<T : PartiQLValue> : NullableCollectionVa
 }
 
 @PartiQLValueExperimental
-public abstract class NullableStructValue<T : PartiQLValue> : PartiQLValue, Collection<Pair<String, T>> {
+public abstract class NullableStructValue<T : PartiQLValue> : PartiQLValue {
+    public abstract fun isNull(): Boolean
 
-    public abstract val fields: List<Pair<String, T>>?
+    public abstract fun promote(): StructValue<T>
 
     override val type: PartiQLValueType = PartiQLValueType.NULLABLE_STRUCT
 
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTime.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTime.kt
new file mode 100644
index 0000000000..97381148c6
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTime.kt
@@ -0,0 +1,560 @@
+package org.partiql.value.datetime
+
+import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
+import java.math.BigDecimal
+import kotlin.jvm.Throws
+
+/**
+ * Superclass for all classes representing datetime values.
+ */
+public sealed interface DateTime {
+    /**
+     * Year field of date time object
+     */
+    public val year: Int?
+
+    /**
+     * Month field of date time object
+     */
+    public val month: Int?
+
+    /**
+     * Day field of date time object
+     */
+    public val day: Int?
+
+    /**
+     * Hour field of date time object
+     */
+    public val hour: Int?
+
+    /**
+     * Minute field of date time object
+     */
+    public val minute: Int?
+
+    /**
+     * Second field of date time object.
+     * This field includes second fraction.
+     */
+    public val decimalSecond: BigDecimal?
+
+    /**
+     * Time zone field of date time object. See [TimeZone]
+     */
+    public val timeZone: TimeZone?
+
+    /**
+     * Equals method.
+     * Two [DateTime] values are considered equals if and only if all the fields are equals.
+     */
+    public override fun equals(other: Any?): Boolean
+
+    public override fun hashCode(): Int
+
+    public override fun toString(): String
+}
+
+/**
+ * Superclass for all implementations representing date value.
+ * Date represents a calendar system, (i.e., 2023-06-01).
+ * It does not include information on time or timezone, instead, it is meant to represent a specific date on calendar.
+ * For example, 2022-11-25 (black friday in 2022).
+ * The valid range are from 0001-01-01 to 9999-12-31
+ * The [day] must be valid for the year and month, otherwise an exception will be thrown.
+ */
+public sealed interface Date : DateTime, Comparable<Date> {
+
+    public override val year: Int
+    public override val month: Int
+    public override val day: Int
+
+    /**
+     * Hour field for [Date] value is always null.
+     */
+    public override val hour: Int?
+        get() = null
+
+    /**
+     * Minute field for [Date] value is always null.
+     */
+    public override val minute: Int?
+        get() = null
+
+    /**
+     * Second field for [Date] value is always null.
+     */
+    public override val decimalSecond: BigDecimal?
+        get() = null
+
+    /**
+     * Timezone field for [Date] value is always null.
+     */
+    public override val timeZone: TimeZone?
+        get() = null
+
+    // Operation
+    /**
+     * Construct a [Timestamp] value by appending [time] to this [Date] value.
+     */
+    public fun atTime(time: Time): Timestamp
+
+    /**
+     * Returns a [Date] value with the specified number of days added.
+     * The month and year fields may be changed as necessary to ensure the result remains valid.
+     * [days] can be negative.
+     */
+    public fun plusDays(days: Long): Date
+
+    /**
+     * Returns a [Date] value with the specified number of months added.
+     * The month and year fields may be changed as necessary to ensure the result remains valid.
+     * [months] can be negative.
+     */
+    public fun plusMonths(months: Long): Date
+
+    /**
+     * Returns a [Date] value with the specified number of months added.
+     * [years] can be negative.
+     */
+    public fun plusYear(years: Long): Date
+
+    /**
+     * Comparison method for [Date] value.
+     *
+     * Since [Date] value has no concept of time zone, they are compared as calendar date.
+     */
+    public override fun compareTo(other: Date): Int =
+        DateTimeComparator.compareTo(this, other)
+}
+
+/**
+ * Superclass for all implementations representing time value.
+ * See [TimeWithTimeZone] and [TimeWithoutTimeZone]
+ */
+public sealed interface Time : DateTime, Comparable<Time> {
+    /**
+     * Year field for [Time] is always null
+     */
+    public override val year: Int?
+        get() = null
+
+    /**
+     * Month field for [Time] is always null
+     */
+    public override val month: Int?
+        get() = null
+
+    /**
+     * Day field for [Time] is always null
+     */
+    public override val day: Int?
+        get() = null
+
+    /**
+     * Hour as it would appear on local clock
+     */
+    public override val hour: Int
+
+    /**
+     * Minute as it would appear on local clock
+     */
+    public override val minute: Int
+
+    /**
+     * Second as it would appear on local clock
+     *
+     * Fraction of second is included and support arbitrary digits up to system limit
+     */
+    public override val decimalSecond: BigDecimal
+
+    /**
+     * Null if the value is a [TimeWithoutTimeZone]
+     */
+    public override val timeZone: TimeZone?
+
+    /**
+     * Duration of time in second between midnight (00:00:00) to the given time
+     * It only depends on clock time (i.e., hour, minutes, time field).
+     */
+    public val elapsedSecond: BigDecimal
+
+    // Operation
+    /**
+     * Returns a [Time] value with the specified number of hours added.
+     * The calculation wraps around midnight.
+     * [hours] can be negative.
+     * This operation only depends on clock time.
+     */
+    public fun plusHours(hours: Long): Time
+
+    /**
+     * Returns a [Time] value with the specified number of hours added.
+     * The calculation wraps around midnight.
+     * Hour Field may change as necessary to ensure a valid result.
+     * [minutes] can be negative.
+     * This operation only depends on clock time.
+     */
+    public fun plusMinutes(minutes: Long): Time
+
+    /**
+     * Returns a [Time] value with the specified number of hours added.
+     * The calculation wraps around midnight.
+     * Hour and Minute Field may change as necessary to ensure a valid result.
+     * [seconds] can be negative.
+     * This operation only depends on clock time.
+     */
+    public fun plusSeconds(seconds: BigDecimal): Time
+
+    /**
+     * Convenient wrapper that allows to enter a long value as second quantity
+     */
+    public fun plusSeconds(seconds: Long): Time
+
+    /**
+     * Returns a [Time] object with [precision] number of digits in second fraction.
+     * This operation only depends on clock time.
+     */
+    public fun toPrecision(precision: Int): Time
+
+    /**
+     * Returns a [Timestamp] object.
+     * The year, month, day fields comes from the [date] parameter,
+     * The hour, minute, second, and timezone fields comes from the time object.
+     */
+    public fun atDate(date: Date): Timestamp
+
+    /**
+     * Compares two [Time] value.
+     * 1. If both are [TimeWithTimeZone], then it is to convert them to their respective UTC equivalent (normalizing to +00:00),
+     *   then comparing each of the field.
+     * 2. If both are [TimeWithoutTimeZone], then we compare each of the field in order.
+     */
+    public override fun compareTo(other: Time): Int =
+        DateTimeComparator.compareTo(this, other)
+}
+
+/**
+ * Superclass for all implementations representing time value.
+ * See [TimestampWithTimeZone] and [TimestampWithoutTimeZone]
+ */
+public sealed interface Timestamp : DateTime, Comparable<Timestamp> {
+
+    public override val year: Int
+    public override val month: Int
+    public override val day: Int
+    public override val hour: Int
+    public override val minute: Int
+    public override val decimalSecond: BigDecimal
+    public override val timeZone: TimeZone?
+
+    // Operation
+    /**
+     * Returns a [Timestamp] value with the specified number of years added.
+     * [years] can be negative.
+     */
+    public fun plusYear(years: Long): Timestamp
+
+    /**
+     * Returns a [Timestamp] value with the specified number of years added.
+     * Year fields may be changed to ensure the correctness of the result.
+     * [months] can be negative.
+     */
+    public fun plusMonths(months: Long): Timestamp
+
+    /**
+     * Returns a [Timestamp] value with the specified number of days added.
+     * Year, Month fields may be changed to ensure the correctness of the result.
+     * [days] can be negative.
+     */
+    public fun plusDays(days: Long): Timestamp
+
+    /**
+     * Returns a [Timestamp] value with the specified number of hours added.
+     * Year, Month, Day fields may be changed to ensure the correctness of the result.
+     * [hours] can be negative.
+     */
+    public fun plusHours(hours: Long): Timestamp
+
+    /**
+     * Returns a [Timestamp] value with the specified number of minutes added.
+     * Year, Month, Day, Hour fields may be changed to ensure the correctness of the result.
+     * [minutes] can be negative.
+     */
+    public fun plusMinutes(minutes: Long): Timestamp
+
+    /**
+     * Returns a [Timestamp] value with the specified number of minutes added.
+     * Year, Month, Day, Hour, Minute fields may be changed to ensure the correctness of the result.
+     * [seconds] can be negative.
+     */
+    public fun plusSeconds(seconds: BigDecimal): Timestamp
+
+    /**
+     * Convenient wrapper for entering long value as [seconds]
+     */
+    public fun plusSeconds(seconds: Long): Timestamp
+
+    /**
+     * Returns a [Timestamp] value with [precision] number of digits in second fraction.
+     */
+    public fun toPrecision(precision: Int): Timestamp
+
+    /**
+     * Returns a [Date] value by extracting [year], [month], [day] field
+     */
+    public fun toDate(): Date = DateTimeValue.date(this.year, this.month, this.day)
+
+    /**
+     * Returns a [Time] value by extracting [hour], [minute], [decimalSecond], and [timeZone].
+     */
+    public fun toTime(): Time
+
+    /**
+     * Comparison method for timestamp value
+     * If both value are [TimestampWithTimeZone]:
+     *    The two value are considered equivalent if they refer to the same point in time.
+     * If both value are timestamp without timezone:
+     *      The two value are consider equivalent if all the fields (exclude precision) are equivalent.
+     *      Another way to interpret this is, two timestamp without timezone are equivalent
+     *          if and only if they are equivalent when converted to the same time zone.
+     * If one value is timestamp with time zone and the other is timestamp without time zone:
+     *      Error.
+     *      One may not directly compare a timestamp value with timezone to a timestamp value without time zone.
+     */
+    public override fun compareTo(other: Timestamp): Int =
+        DateTimeComparator.compareTo(this, other)
+}
+
+/**
+ * Superclass for all implementation representing date value
+ */
+public abstract class DateImpl : Date, Comparable<Date> {
+    public final override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other?.javaClass != javaClass) return false
+        other as DateImpl
+        if (this.year != other.year) return false
+        if (this.month != other.month) return false
+        if (this.day != other.day) return false
+        return true
+    }
+
+    public final override fun hashCode(): Int =
+        year.hashCode() + month.hashCode() + day.hashCode()
+
+    public final override fun toString(): String =
+        "${this.javaClass.simpleName}(year=$year, month=$month, day=$day)"
+}
+
+/**
+ * Superclass for all implementations representing a time with time zone value.
+ * Informally, [TimeWithTimeZone] represents an orientation of a clock attached with timezone offset information.
+ */
+public abstract class TimeWithTimeZone : Time {
+    public abstract override val timeZone: TimeZone
+    public abstract override fun plusHours(hours: Long): TimeWithTimeZone
+    public abstract override fun plusMinutes(minutes: Long): TimeWithTimeZone
+    public abstract override fun plusSeconds(seconds: BigDecimal): TimeWithTimeZone
+    public final override fun plusSeconds(seconds: Long): Time = plusSeconds(seconds.toBigDecimal())
+    public final override fun toPrecision(precision: Int): TimeWithTimeZone =
+        DateTimePrecisionChanger.toPrecision(precision, this) as TimeWithTimeZone
+    public abstract override fun atDate(date: Date): TimestampWithTimeZone
+
+    /**
+     * Returns a [TimeWithoutTimeZone] object, assuming the local time is in [timeZone].
+     * The intention of the function is to get a clock time in the [timeZone].
+     */
+    public abstract fun toTimeWithoutTimeZone(timeZone: TimeZone): TimeWithoutTimeZone
+
+    /**
+     * Returns a [TimeWithTimeZone] object, assuming the desiredZone is [timeZone]
+     * The intention of this function is to get the same instant of time in the desired zone.
+     */
+    public abstract fun atTimeZone(timeZone: TimeZone): TimeWithTimeZone
+    public final override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other?.javaClass != javaClass) return false
+        other as TimeWithTimeZone
+        if (this.hour != other.hour) return false
+        if (this.minute != other.minute) return false
+        if (this.decimalSecond != other.decimalSecond) return false
+        if (this.timeZone != other.timeZone) return false
+        return true
+    }
+    public final override fun hashCode(): Int =
+        hour.hashCode() + minute.hashCode() + decimalSecond.hashCode() + timeZone.hashCode()
+    public final override fun toString(): String =
+        "${this.javaClass.simpleName}(hour=$hour, minute=$minute, second=$decimalSecond, timeZone=$timeZone)"
+}
+
+/**
+ * Superclass for all implementations representing time without time zone value
+ * Informally, [TimeWithoutTimeZone] represents a particular orientation of a clock
+ * which will represent different instances of "time" based on the timezone.
+ */
+public abstract class TimeWithoutTimeZone : Time {
+    public final override val timeZone: TimeZone? = null
+    public abstract override fun plusHours(hours: Long): TimeWithoutTimeZone
+    public abstract override fun plusMinutes(minutes: Long): TimeWithoutTimeZone
+    public abstract override fun plusSeconds(seconds: BigDecimal): TimeWithoutTimeZone
+    public abstract override fun atDate(date: Date): TimestampWithoutTimeZone
+
+    /**
+     * Returns a [TimeWithTimeZone] object, assuming the current [TimeWithoutTimeZone] object is in [timeZone].
+     * The intention of this function is to append time zone information.
+     */
+    public abstract fun withTimeZone(timeZone: TimeZone): TimeWithTimeZone
+
+    public final override fun plusSeconds(seconds: Long): Time = plusSeconds(seconds.toBigDecimal())
+    public final override fun toPrecision(precision: Int): TimeWithoutTimeZone =
+        DateTimePrecisionChanger.toPrecision(precision, this) as TimeWithoutTimeZone
+
+    public final override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other?.javaClass != javaClass) return false
+        other as TimeWithoutTimeZone
+        if (this.hour != other.hour) return false
+        if (this.minute != other.minute) return false
+        if (this.decimalSecond != other.decimalSecond) return false
+        return true
+    }
+
+    public final override fun hashCode(): Int =
+        hour.hashCode() + minute.hashCode() + decimalSecond.hashCode()
+
+    public final override fun toString(): String =
+        "${this.javaClass.simpleName}(hour=$hour, minute=$minute, second=$decimalSecond)"
+}
+
+/**
+ * Superclass for all implementations representing timestamp with time zone value.
+ * A [TimestampWithTimeZone] is a instant in the timeline.
+ */
+public abstract class TimestampWithTimeZone : Timestamp {
+    public abstract override val timeZone: TimeZone
+
+    public abstract val ionRaw: com.amazon.ion.Timestamp?
+
+    /**
+     * Returns an Ion Equivalent Timestamp
+     * [ionTimestampValue] takes care of the precision,
+     * the ion representation will have exact precision of the backing partiQL value.
+     * TODO: Move this to serde package.
+     */
+    @get:Throws(DateTimeException::class)
+    public val ionTimestampValue: com.amazon.ion.Timestamp by lazy {
+        when (val timeZone = this.timeZone) {
+            TimeZone.UnknownTimeZone -> com.amazon.ion.Timestamp.forSecond(
+                this.year, this.month, this.day,
+                this.hour, this.minute, this.decimalSecond,
+                com.amazon.ion.Timestamp.UNKNOWN_OFFSET
+            )
+
+            is TimeZone.UtcOffset -> com.amazon.ion.Timestamp.forSecond(
+                this.year, this.month, this.day,
+                this.hour, this.minute, this.decimalSecond,
+                timeZone.totalOffsetMinutes
+            )
+        }
+    }
+
+    /**
+     * Returns a BigDecimal representing the instant in time that is
+     * the number of Seconds (*including* any fractional Seconds) from the epoch.
+     * If the instant is before 1970-01-01T00:00:00Z, then the result will be negative.
+     */
+    public abstract val epochSecond: BigDecimal
+
+    public val epochMillis: BigDecimal by lazy {
+        epochSecond.movePointRight(3)
+    }
+
+    public abstract override fun plusYear(years: Long): TimestampWithTimeZone
+    public abstract override fun plusMonths(months: Long): TimestampWithTimeZone
+    public abstract override fun plusDays(days: Long): TimestampWithTimeZone
+    public abstract override fun plusHours(hours: Long): TimestampWithTimeZone
+    public abstract override fun plusMinutes(minutes: Long): TimestampWithTimeZone
+    public abstract override fun plusSeconds(seconds: BigDecimal): TimestampWithTimeZone
+    public final override fun plusSeconds(seconds: Long): TimestampWithTimeZone =
+        plusSeconds(seconds.toBigDecimal())
+    public final override fun toPrecision(precision: Int): TimestampWithTimeZone =
+        DateTimePrecisionChanger.toPrecision(precision, this) as TimestampWithTimeZone
+
+    /**
+     * Returns a [TimestampWithoutTimeZone] object, assuming the local time is in [timeZone].
+     */
+    public abstract fun toTimeWithoutTimeZone(timeZone: TimeZone): TimestampWithoutTimeZone
+
+    /**
+     * Returns a [TimestampWithTimeZone] object, assuming the desiredZone is [timeZone]
+     * The intention of this function is to get the same instant of time in the desired zone.
+     */
+    public abstract fun atTimeZone(timeZone: TimeZone): TimestampWithTimeZone
+    public final override fun toTime(): TimeWithTimeZone =
+        DateTimeValue.time(hour, minute, decimalSecond, timeZone) as TimeWithTimeZone
+
+    public final override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other?.javaClass != javaClass) return false
+        other as TimestampWithTimeZone
+        if (this.year != other.year) return false
+        if (this.month != other.month) return false
+        if (this.day != other.day) return false
+        if (this.hour != other.hour) return false
+        if (this.minute != other.minute) return false
+        if (this.decimalSecond != other.decimalSecond) return false
+        if (this.timeZone != other.timeZone) return false
+        return true
+    }
+
+    public final override fun hashCode(): Int =
+        year.hashCode() + month.hashCode() + day.hashCode() + hour.hashCode() + minute.hashCode() + decimalSecond.hashCode() + timeZone.hashCode()
+
+    public final override fun toString(): String =
+        "${this.javaClass.simpleName}(year=$year, month=$month, day=$day, hour=$hour, minute=$minute, second=$decimalSecond, timeZone=$timeZone)"
+}
+
+/**
+ * Superclass for all implementations representing timestamp without time zone value.
+ * A [TimestampWithoutTimeZone] is not an instant in the timeline, the same value may refer to different instant in timeline at different time zone.
+ */
+public abstract class TimestampWithoutTimeZone : Timestamp {
+    public override val timeZone: TimeZone? = null
+    public abstract override fun plusYear(years: Long): TimestampWithoutTimeZone
+    public abstract override fun plusMonths(months: Long): TimestampWithoutTimeZone
+    public abstract override fun plusDays(days: Long): TimestampWithoutTimeZone
+    public abstract override fun plusHours(hours: Long): TimestampWithoutTimeZone
+    public abstract override fun plusMinutes(minutes: Long): TimestampWithoutTimeZone
+    public abstract override fun plusSeconds(seconds: BigDecimal): TimestampWithoutTimeZone
+    public override fun plusSeconds(seconds: Long): TimestampWithoutTimeZone =
+        plusSeconds(seconds.toBigDecimal())
+    public final override fun toPrecision(precision: Int): TimestampWithoutTimeZone =
+        DateTimePrecisionChanger.toPrecision(precision, this) as TimestampWithoutTimeZone
+
+    /**
+     * Returns a [TimestampWithTimeZone] object, assuming the current [TimestampWithoutTimeZone] value is in [timeZone].
+     * The intention of this function is to append time zone information.
+     */
+    public abstract fun withTimeZone(timeZone: TimeZone): TimestampWithTimeZone
+    public final override fun toTime(): TimeWithoutTimeZone =
+        DateTimeValue.time(this.hour, this.minute, this.decimalSecond) as TimeWithoutTimeZone
+    public final override fun equals(other: Any?): Boolean {
+        if (this === other) return true
+        if (other?.javaClass != javaClass) return false
+        other as TimestampWithoutTimeZone
+        if (this.year != other.year) return false
+        if (this.month != other.month) return false
+        if (this.day != other.day) return false
+        if (this.hour != other.hour) return false
+        if (this.minute != other.minute) return false
+        if (this.decimalSecond != other.decimalSecond) return false
+        return true
+    }
+
+    public final override fun hashCode(): Int =
+        year.hashCode() + month.hashCode() + day.hashCode() + hour.hashCode() + minute.hashCode() + decimalSecond.hashCode()
+
+    public final override fun toString(): String =
+        "${this.javaClass.simpleName}(year=$year, month=$month, day=$day, hour=$hour, minute=$minute, second=$decimalSecond)"
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeComparator.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeComparator.kt
new file mode 100644
index 0000000000..0858f79d81
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeComparator.kt
@@ -0,0 +1,84 @@
+package org.partiql.value.datetime
+
+internal object DateTimeComparator {
+
+    fun compareTo(left: Date, right: Date): Int {
+        var cmp = left.year.compareTo(right.year)
+        if (cmp == 0) {
+            cmp = left.month.compareTo(right.month)
+            if (cmp == 0) {
+                cmp = left.day.compareTo(right.day)
+            }
+        }
+        return cmp
+    }
+
+    fun compareTo(left: TimeWithoutTimeZone, right: TimeWithoutTimeZone): Int {
+        var cmp = left.hour.compareTo(right.hour)
+        if (cmp == 0) {
+            cmp = left.minute.compareTo(right.minute)
+            if (cmp == 0) {
+                cmp = left.decimalSecond.compareTo(right.decimalSecond)
+            }
+        }
+        return cmp
+    }
+
+    fun compareTo(left: TimeWithTimeZone, right: TimeWithTimeZone): Int {
+        val leftUtc = left.toTimeWithoutTimeZone(TimeZone.UtcOffset.of(0))
+        val rightUtc = right.toTimeWithoutTimeZone(TimeZone.UtcOffset.of(0))
+        return compareTo(leftUtc, rightUtc)
+    }
+
+    fun compareTo(left: TimestampWithoutTimeZone, right: TimestampWithoutTimeZone): Int {
+        var cmp = compareTo(left.toDate(), right.toDate())
+        if (cmp == 0) {
+            cmp = compareTo(left.toTime(), right.toTime())
+        }
+        return cmp
+    }
+
+    fun compareTo(left: TimestampWithTimeZone, right: TimestampWithTimeZone): Int {
+        var cmp = compareTo(left.toDate(), right.toDate())
+        if (cmp == 0) {
+            cmp = compareTo(left.toTime(), right.toTime())
+        }
+        return cmp
+    }
+
+    fun compareTo(left: Time, right: Time) =
+        when (left) {
+            is TimeWithTimeZone -> {
+                when (right) {
+                    is TimeWithTimeZone -> compareTo(left, right)
+                    is TimeWithoutTimeZone ->
+                        throw DateTimeException("Can not compare Time With Time Zone Value and Time Without Time Zone value")
+                }
+            }
+            is TimeWithoutTimeZone -> {
+                when (right) {
+                    is TimeWithTimeZone ->
+                        throw DateTimeException("Can not compare Time With Time Zone Value and Time Without Time Zone value")
+                    is TimeWithoutTimeZone -> compareTo(left, right)
+                }
+            }
+        }
+
+    fun compareTo(left: Timestamp, right: Timestamp) =
+        when (left) {
+            is TimestampWithTimeZone -> {
+                when (right) {
+                    is TimestampWithTimeZone -> compareTo(left, right)
+                    is TimestampWithoutTimeZone ->
+                        throw DateTimeException("Can not compare Timestamp With Time Zone Value and Timestamp Without Time Zone value")
+                }
+            }
+            is TimestampWithoutTimeZone -> {
+                when (right) {
+                    is TimestampWithTimeZone ->
+                        throw DateTimeException("Can not compare Timestamp With Time Zone Value and Timestamp Without Time Zone value")
+                    is TimestampWithoutTimeZone -> compareTo(left, right)
+                }
+            }
+        }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeException.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeException.kt
new file mode 100644
index 0000000000..075bda21c5
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeException.kt
@@ -0,0 +1,23 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.value.datetime
+
+/**
+ * This is the overall exception an application should catch during run-time.
+ */
+public class DateTimeException(
+    public override val message: String? = null,
+    public override val cause: Throwable? = null
+) : RuntimeException()
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt
new file mode 100644
index 0000000000..5a9825db2e
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt
@@ -0,0 +1,109 @@
+package org.partiql.value.datetime
+
+import org.partiql.value.datetime.DateTimeValue.time
+import org.partiql.value.datetime.DateTimeValue.timestamp
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.time.LocalTime
+
+internal object DateTimePrecisionChanger {
+
+    fun toPrecision(precision: Int, dateTime: DateTime) =
+        when (dateTime) {
+            // this should not be called
+            is DateImpl -> throw IllegalArgumentException("Date has no concept of precision")
+            // making the compiler happy, and we don't need to use the double colon
+            is Time -> {
+                val scale = dateTime.decimalSecond.scale()
+                when {
+                    precision == scale -> dateTime
+                    precision < scale -> roundToPrecision(precision, dateTime)
+                    else -> paddingToPrecision(precision, dateTime)
+                }
+            }
+            is Timestamp -> {
+                val scale = dateTime.decimalSecond.scale()
+                when {
+                    precision == scale -> dateTime
+                    precision < scale -> roundToPrecision(precision, dateTime)
+                    else -> paddingToPrecision(precision, dateTime)
+                }
+            }
+        }
+
+    private fun paddingToPrecision(precision: Int, dateTime: DateTime): DateTime =
+        when (dateTime) {
+            is Time ->
+                time(dateTime.hour, dateTime.minute, dateTime.decimalSecond.setScale(precision), dateTime.timeZone)
+            is Timestamp ->
+                timestamp(
+                    dateTime.year, dateTime.month, dateTime.day,
+                    dateTime.hour, dateTime.minute, dateTime.decimalSecond.setScale(precision), dateTime.timeZone
+                )
+            // Shall never be reached, making the compiler happy
+            is DateImpl -> dateTime
+        }
+
+    private fun roundToPrecision(precision: Int, dateTime: DateTime): DateTime =
+        when (dateTime) {
+            // Shall never be reached, making the compiler happy
+            is DateImpl -> dateTime
+            is Time -> {
+                if (isHighPrecision(dateTime.decimalSecond)) {
+                    handleHighPrecisionRounding(dateTime, precision)
+                } else {
+                    handleLowPrecisionRounding(dateTime, precision)
+                }
+            }
+            is Timestamp -> {
+                val time = dateTime.toTime()
+                val date = dateTime.toDate()
+                val roundedTime = if (isHighPrecision(dateTime.decimalSecond)) {
+                    handleHighPrecisionRounding(time, precision)
+                } else {
+                    handleLowPrecisionRounding(time, precision)
+                }
+                when ((time.elapsedSecond - roundedTime.elapsedSecond).abs() > BigDecimal.ONE) {
+                    true -> timestamp(date.plusDays(1L), roundedTime)
+                    false -> {
+                        timestamp(date, roundedTime)
+                    }
+                }
+            }
+        }
+
+    private val isHighPrecision: (decimal: BigDecimal) -> Boolean = { it.scale() > 9 }
+
+    private fun handleHighPrecisionRounding(dateTime: Time, precision: Int): Time {
+        var rounded = dateTime.elapsedSecond.setScale(precision, RoundingMode.HALF_UP)
+        var newHours = 0
+        var newMinutes = 0
+        val secondsInHour = BigDecimal.valueOf(DateTimeUtil.SECONDS_IN_HOUR)
+        val secondsInMin = BigDecimal.valueOf(DateTimeUtil.SECONDS_IN_MINUTE)
+
+        if (rounded >= secondsInHour) {
+            val totalHours = rounded.divide(secondsInHour, 0, RoundingMode.DOWN)
+            rounded = rounded.subtract(totalHours.multiply(secondsInHour))
+            newHours = totalHours.intValueExact() % 24
+        }
+        if (rounded >= secondsInMin) {
+            val totalMinutes = rounded.divide(secondsInMin, 0, RoundingMode.DOWN)
+            rounded = rounded.subtract(totalMinutes.multiply(secondsInMin))
+            newMinutes = totalMinutes.intValueExact() % 60
+        }
+        return time(newHours, newMinutes, rounded, dateTime.timeZone)
+    }
+
+    private fun handleLowPrecisionRounding(dateTime: Time, precision: Int): Time {
+        val wholeSecondBD = dateTime.decimalSecond.setScale(0, RoundingMode.DOWN)
+        val decimalNano = dateTime.decimalSecond.minus(wholeSecondBD)
+        val wholeSecond = wholeSecondBD.intValueExact()
+        val nano = decimalNano.movePointRight(9).intValueExact()
+        val rounded = decimalNano.setScale(precision, RoundingMode.HALF_UP).movePointRight(9).intValueExact()
+        val diff = rounded - nano
+        val originalLocalTime = LocalTime.of(dateTime.hour, dateTime.minute, wholeSecond, nano)
+        val newDateTime = originalLocalTime.plusNanos(diff.toLong())
+        val newDecimalSecond = newDateTime.nano.toBigDecimal().movePointLeft(9).stripTrailingZeros().setScale(precision) + newDateTime.second.toBigDecimal()
+        return time(newDateTime.hour, newDateTime.minute, newDecimalSecond, dateTime.timeZone)
+    }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeUtil.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeUtil.kt
new file mode 100644
index 0000000000..ef1e4b2996
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeUtil.kt
@@ -0,0 +1,52 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.value.datetime
+
+import java.math.BigDecimal
+import java.util.regex.Pattern
+
+internal object DateTimeUtil {
+    internal val DATETIME_PATTERN = Pattern.compile(
+        "(?<year>[-+]?\\d{4,})-(?<month>\\d{1,2})-(?<day>\\d{1,2})" +
+            "(?: (?<hour>\\d{1,2}):(?<minute>\\d{1,2})(?::(?<decimalSecond>\\d{1,2})(?:\\.(?<fraction>\\d+))?)?)?" +
+            "\\s*(?<timezone>[+-]\\d\\d:\\d\\d)?"
+    )
+
+    internal val DATE_PATTERN = Pattern.compile("(?<year>\\d{4,})-(?<month>\\d{2,})-(?<day>\\d{2,})")
+
+    internal val TIME_PATTERN =
+        Pattern.compile("(?<hour>\\d{2,}):(?<minute>\\d{2,}):(?<decimalSecond>\\d{2,})(?:\\.(?<fraction>\\d+))?\\s*(?<timezone>[+-]\\d\\d:\\d\\d)?")
+
+    internal const val MILLIS_IN_SECOND: Long = 1000
+    internal const val MILLIS_IN_MINUTE = 60 * MILLIS_IN_SECOND
+    internal const val MILLIS_IN_HOUR = 60 * MILLIS_IN_MINUTE
+    internal const val MILLIS_IN_DAY = 24 * MILLIS_IN_HOUR
+    internal const val SECONDS_IN_MINUTE = 60L
+    internal const val SECONDS_IN_HOUR = 60 * SECONDS_IN_MINUTE
+    internal const val SECONDS_IN_DAY = 24 * SECONDS_IN_HOUR
+    internal const val MAX_TIME_ZONE_HOURS: Int = 23
+    internal const val MAX_TIME_ZONE_MINUTES: Int = 59
+    internal const val MAX_TOTAL_OFFSET_MINUTES: Int = MAX_TIME_ZONE_HOURS * 60 + MAX_TIME_ZONE_MINUTES
+    internal const val NANOS_IN_SECOND: Long = 1_000_000_000L
+    internal const val JAVA_MAX_OFFSET: Int = 18 * 60 // java offset valid range -18:00 to 18:00
+
+    // In date time, we should only concern with BigDecimal, Int, and Long
+    internal fun Number.toBigDecimal(): BigDecimal = when (this) {
+        is BigDecimal -> this
+        is Long -> BigDecimal.valueOf(this)
+        is Int -> BigDecimal.valueOf(this.toLong())
+        else -> throw IllegalArgumentException("can not convert $this to BigDecimal")
+    }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeValue.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeValue.kt
new file mode 100644
index 0000000000..9984d5fe7d
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/DateTimeValue.kt
@@ -0,0 +1,155 @@
+package org.partiql.value.datetime
+
+import org.partiql.value.datetime.DateTimeUtil.JAVA_MAX_OFFSET
+import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
+import org.partiql.value.datetime.impl.LocalTimeHighPrecision
+import org.partiql.value.datetime.impl.LocalTimeLowPrecision
+import org.partiql.value.datetime.impl.LocalTimestampHighPrecision
+import org.partiql.value.datetime.impl.LocalTimestampLowPrecision
+import org.partiql.value.datetime.impl.OffsetTimeHighPrecision
+import org.partiql.value.datetime.impl.OffsetTimeLowPrecision
+import org.partiql.value.datetime.impl.OffsetTimestampHighPrecision
+import org.partiql.value.datetime.impl.OffsetTimestampLowPrecision
+import org.partiql.value.datetime.impl.SqlDate
+import java.math.BigDecimal
+import kotlin.math.absoluteValue
+
+public object DateTimeValue {
+
+    public val nowZ: TimestampWithTimeZone = OffsetTimestampLowPrecision.nowZ()
+
+    @JvmOverloads
+    public fun timestamp(
+        year: Int,
+        month: Int,
+        day: Int,
+        hour: Int,
+        minute: Int,
+        second: BigDecimal,
+        timeZone: TimeZone? = null
+    ): Timestamp =
+        when (timeZone) {
+            TimeZone.UnknownTimeZone -> {
+                if (second.scale() <= 9) {
+                    OffsetTimestampLowPrecision.of(year, month, day, hour, minute, second, timeZone)
+                } else {
+                    OffsetTimestampHighPrecision.of(year, month, day, hour, minute, second, timeZone)
+                }
+            }
+            is TimeZone.UtcOffset -> {
+                if (timeZone.totalOffsetMinutes.absoluteValue > JAVA_MAX_OFFSET) {
+                    OffsetTimestampHighPrecision.of(year, month, day, hour, minute, second, timeZone)
+                } else if (second.scale() <= 9) {
+                    OffsetTimestampLowPrecision.of(year, month, day, hour, minute, second, timeZone)
+                } else {
+                    OffsetTimestampHighPrecision.of(year, month, day, hour, minute, second, timeZone)
+                }
+            }
+
+            null -> {
+                if (second.scale() <= 9) LocalTimestampLowPrecision.of(year, month, day, hour, minute, second)
+                else LocalTimestampHighPrecision.of(year, month, day, hour, minute, second)
+            }
+        }
+
+    @JvmOverloads
+    public fun timestamp(
+        year: Int,
+        month: Int,
+        day: Int,
+        hour: Int,
+        minute: Int,
+        second: Int,
+        timeZone: TimeZone? = null
+    ): Timestamp =
+        timestamp(year, month, day, hour, minute, second.toBigDecimal(), timeZone)
+
+    public fun timestamp(date: Date, time: Time): Timestamp =
+        when (time) {
+            is TimeWithTimeZone -> timestamp(
+                date.year,
+                date.month,
+                date.day,
+                time.hour,
+                time.minute,
+                time.decimalSecond,
+                time.timeZone
+            )
+
+            is TimeWithoutTimeZone -> timestamp(
+                date.year,
+                date.month,
+                date.day,
+                time.hour,
+                time.minute,
+                time.decimalSecond
+            )
+        }
+
+    public fun timestamp(ionTimestamp: com.amazon.ion.Timestamp): TimestampWithTimeZone =
+        if (ionTimestamp.decimalSecond.scale() <= 9) {
+            OffsetTimestampLowPrecision.forIonTimestamp(ionTimestamp)
+        } else {
+            OffsetTimestampHighPrecision.forIonTimestamp(ionTimestamp)
+        }
+
+    @JvmOverloads
+    public fun time(
+        hour: Int,
+        minute: Int,
+        second: BigDecimal,
+        timeZone: TimeZone? = null
+    ): Time =
+        when (timeZone) {
+            TimeZone.UnknownTimeZone -> {
+                if (second.scale() <= 9) {
+                    OffsetTimeLowPrecision.of(hour, minute, second, timeZone)
+                } else {
+                    OffsetTimeHighPrecision.of(hour, minute, second, timeZone)
+                }
+            }
+            is TimeZone.UtcOffset -> {
+                if (timeZone.totalOffsetMinutes.absoluteValue > JAVA_MAX_OFFSET) {
+                    OffsetTimeHighPrecision.of(hour, minute, second, timeZone)
+                } else if (second.scale() <= 9) {
+                    OffsetTimeLowPrecision.of(hour, minute, second, timeZone)
+                } else {
+                    OffsetTimeHighPrecision.of(hour, minute, second, timeZone)
+                }
+            }
+
+            null -> {
+                if (second.scale() <= 9) LocalTimeLowPrecision.of(hour, minute, second)
+                else LocalTimeHighPrecision.of(hour, minute, second)
+            }
+        }
+
+    @JvmOverloads
+    public fun time(
+        hour: Int,
+        minute: Int,
+        second: Int,
+        timeZone: TimeZone? = null
+    ): Time =
+        time(hour, minute, second.toBigDecimal(), timeZone)
+
+    @JvmOverloads
+    public fun time(
+        hour: Int,
+        minute: Int,
+        second: Int,
+        nano: Int,
+        timeZone: TimeZone?
+    ): Time {
+        val decimalSecond = second.toBigDecimal().plus(nano.toBigDecimal().movePointLeft(9))
+        return time(hour, minute, decimalSecond, timeZone)
+    }
+
+    @JvmStatic
+    public fun date(
+        year: Int,
+        month: Int,
+        day: Int
+    ): Date =
+        SqlDate.of(year, month, day)
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/TimeZone.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/TimeZone.kt
new file mode 100644
index 0000000000..04aa978e5c
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/TimeZone.kt
@@ -0,0 +1,64 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.value.datetime
+
+import org.partiql.value.datetime.DateTimeUtil.MAX_TIME_ZONE_HOURS
+import org.partiql.value.datetime.DateTimeUtil.MAX_TIME_ZONE_MINUTES
+import org.partiql.value.datetime.DateTimeUtil.MAX_TOTAL_OFFSET_MINUTES
+import kotlin.math.abs
+
+public sealed class TimeZone {
+    /**
+     * [RFC 3339](https://www.ietf.org/rfc/rfc3339.html): Unknown offset
+     */
+    public object UnknownTimeZone : TimeZone()
+
+    /**
+     * Utc offset is modeled by the difference in **total minutes**
+     * between Coordinated Universal Time (UTC) and local time, at a particular place.
+     */
+    public data class UtcOffset private constructor(val totalOffsetMinutes: Int) : TimeZone() {
+        val tzHour: Int by lazy {
+            this.totalOffsetMinutes / 60
+        }
+
+        val tzMinute: Int by lazy {
+            this.totalOffsetMinutes - this.tzHour * 60
+        }
+        public companion object {
+
+            /**
+             * Construct a UtcOffset with both timezone hour and time zone minute.
+             * Notice if the time zone is a negative offset, then both [tzHour] and [tzMinute] needs to be negative.
+             */
+            @JvmStatic
+            @Throws(DateTimeException::class)
+            public fun of(tzHour: Int, tzMinute: Int): UtcOffset {
+                if (abs(tzHour) > MAX_TIME_ZONE_HOURS) throw DateTimeException("Except Timezone Hour to be less than 24, but received $tzHour")
+                if (abs(tzMinute) > MAX_TIME_ZONE_MINUTES) throw DateTimeException("Except Timezone Minute to be less than 60, but received $tzMinute")
+                return UtcOffset(tzHour * 60 + tzMinute)
+            }
+
+            @JvmStatic
+            @Throws(DateTimeException::class)
+            public fun of(totalOffsetMinutes: Int): UtcOffset {
+                if (abs(totalOffsetMinutes) > MAX_TOTAL_OFFSET_MINUTES) throw DateTimeException("Expect total offset Minutes to be less than or equal to $MAX_TOTAL_OFFSET_MINUTES, but received $totalOffsetMinutes")
+                return UtcOffset(totalOffsetMinutes)
+            }
+        }
+    }
+
+    // TODO: add support for named Time zone (EST, PST, etc)
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt
new file mode 100644
index 0000000000..b443fc3ab1
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt
@@ -0,0 +1,70 @@
+package org.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeUtil
+import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
+import org.partiql.value.datetime.TimeWithTimeZone
+import org.partiql.value.datetime.TimeWithoutTimeZone
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.TimestampWithoutTimeZone
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.time.temporal.ChronoField
+
+internal class LocalTimeHighPrecision private constructor(
+    override val hour: Int,
+    override val minute: Int,
+    override val decimalSecond: BigDecimal,
+    _elapsedSecond: BigDecimal? = null
+) : TimeWithoutTimeZone() {
+    companion object {
+        fun of(
+            hour: Int,
+            minute: Int,
+            decimalSecond: BigDecimal,
+            elapsedSeconds: BigDecimal? = null
+        ): LocalTimeHighPrecision {
+            try {
+                ChronoField.HOUR_OF_DAY.checkValidValue(hour.toLong())
+                ChronoField.MINUTE_OF_HOUR.checkValidValue(minute.toLong())
+                // round down the decimalSecond to check
+                ChronoField.SECOND_OF_MINUTE.checkValidValue(decimalSecond.setScale(0, RoundingMode.DOWN).toLong())
+                return LocalTimeHighPrecision(hour, minute, decimalSecond, elapsedSeconds)
+            } catch (e: java.time.DateTimeException) {
+                throw DateTimeException(e.localizedMessage, e)
+            }
+        }
+
+        fun forSeconds(elapsedSeconds: BigDecimal): LocalTimeHighPrecision {
+            val wholeSecond = elapsedSeconds.setScale(0, RoundingMode.DOWN).longValueExact()
+            val fraction = elapsedSeconds.minus(BigDecimal.valueOf(wholeSecond))
+            var total = wholeSecond
+            val hour = total / DateTimeUtil.SECONDS_IN_HOUR
+            total -= hour * DateTimeUtil.SECONDS_IN_HOUR
+            val minute = total / DateTimeUtil.SECONDS_IN_MINUTE
+            total -= minute * DateTimeUtil.SECONDS_IN_MINUTE
+            return of(hour.toInt(), minute.toInt(), fraction.plus(BigDecimal.valueOf(total)), elapsedSeconds)
+        }
+    }
+
+    override val elapsedSecond: BigDecimal by lazy {
+        _elapsedSecond
+            ?: (BigDecimal.valueOf(this.hour * DateTimeUtil.SECONDS_IN_HOUR + this.minute * DateTimeUtil.SECONDS_IN_MINUTE) + this.decimalSecond)
+    }
+
+    override fun plusHours(hours: Long): TimeWithoutTimeZone =
+        forSeconds(this.elapsedSecond.plus((hours * DateTimeUtil.SECONDS_IN_HOUR).toBigDecimal()))
+
+    override fun plusMinutes(minutes: Long): TimeWithoutTimeZone =
+        forSeconds(this.elapsedSecond.plus((minutes * DateTimeUtil.SECONDS_IN_MINUTE).toBigDecimal()))
+
+    override fun plusSeconds(seconds: BigDecimal): TimeWithoutTimeZone =
+        forSeconds(this.elapsedSecond.plus(seconds))
+
+    override fun atDate(date: Date): TimestampWithoutTimeZone =
+        LocalTimestampHighPrecision.forDateTime(date, this)
+
+    override fun withTimeZone(timeZone: TimeZone): TimeWithTimeZone =
+        OffsetTimeHighPrecision.of(hour, minute, decimalSecond, timeZone)
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt
new file mode 100644
index 0000000000..c25e684e9d
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt
@@ -0,0 +1,88 @@
+package org.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeUtil
+import org.partiql.value.datetime.TimeWithTimeZone
+import org.partiql.value.datetime.TimeWithoutTimeZone
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.TimestampWithoutTimeZone
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.time.LocalTime
+import kotlin.math.max
+
+internal class LocalTimeLowPrecision private constructor(
+    private val localTime: LocalTime,
+    _hour: Int? = null,
+    _minute: Int? = null,
+    _decimalSecond: BigDecimal? = null,
+) : TimeWithoutTimeZone() {
+    companion object {
+        /**
+         * Creates a [TimeWithTimeZone] value.
+         * If using this API, the precision will be nanosecond (i.e., exactly 9 digits in second fraction)
+         */
+        fun forNano(hour: Int, minute: Int, second: Int, nanoOfSecond: Int): LocalTimeLowPrecision {
+            try {
+                return LocalTimeLowPrecision(LocalTime.of(hour, minute, second, nanoOfSecond))
+            } catch (e: java.time.DateTimeException) {
+                throw DateTimeException(e.localizedMessage)
+            }
+        }
+
+        fun of(hour: Int, minute: Int, decimalSecond: BigDecimal): LocalTimeLowPrecision {
+            val wholeSecond = decimalSecond.setScale(0, RoundingMode.DOWN)
+            val nano = decimalSecond.minus(wholeSecond).movePointRight(9)
+            return forNano(hour, minute, wholeSecond.intValueExact(), nano.intValueExact()).let {
+                LocalTimeLowPrecision(it.localTime, hour, minute, decimalSecond)
+            }
+        }
+    }
+
+    override val hour: Int = _hour ?: localTime.hour
+    override val minute: Int = _minute ?: localTime.minute
+
+    /**
+     * Whole second.
+     */
+    internal val second: Int = localTime.second
+
+    /**
+     * Nano of second.
+     */
+    internal val nano: Int = localTime.nano
+    override val decimalSecond: BigDecimal =
+        _decimalSecond ?: BigDecimal.valueOf(second.toLong()).plus(BigDecimal.valueOf(nano.toLong(), 9))
+    override val elapsedSecond: BigDecimal by lazy {
+        BigDecimal.valueOf(this.hour * DateTimeUtil.SECONDS_IN_HOUR + this.minute * DateTimeUtil.SECONDS_IN_MINUTE) + this.decimalSecond
+    }
+
+    override fun plusHours(hours: Long): TimeWithoutTimeZone =
+        localTime.plusHours(hours).let {
+            of(it.hour, it.minute, decimalSecond)
+        }
+
+    override fun plusMinutes(minutes: Long): TimeWithoutTimeZone =
+        localTime.plusMinutes(minutes).let {
+            of(it.hour, it.minute, decimalSecond)
+        }
+
+    override fun plusSeconds(seconds: BigDecimal): TimeWithoutTimeZone =
+        if (seconds.scale() > 9) {
+            LocalTimeHighPrecision.of(hour, minute, decimalSecond).plusSeconds(seconds)
+        } else {
+            val wholeSecond = seconds.setScale(0, RoundingMode.DOWN)
+            val nano = seconds.minus(wholeSecond).let { it.movePointRight(it.scale()) }
+            val newTime = localTime.plusSeconds(wholeSecond.longValueExact()).plusNanos(nano.longValueExact())
+            val newDecimalSecond = newTime.second.toBigDecimal() + newTime.nano.toBigDecimal().movePointLeft(9)
+            val roundedDecimalSecond = newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
+            of(newTime.hour, newTime.minute, roundedDecimalSecond)
+        }
+
+    override fun atDate(date: Date): TimestampWithoutTimeZone =
+        LocalTimestampLowPrecision.forDateTime(date, this)
+
+    override fun withTimeZone(timeZone: TimeZone): TimeWithTimeZone =
+        OffsetTimeLowPrecision.of(hour, minute, decimalSecond, timeZone)
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt
new file mode 100644
index 0000000000..dcf7138de4
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt
@@ -0,0 +1,113 @@
+package org.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
+import org.partiql.value.datetime.TimeWithoutTimeZone
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.TimestampWithTimeZone
+import org.partiql.value.datetime.TimestampWithoutTimeZone
+import java.math.BigDecimal
+import java.math.RoundingMode
+
+/**
+ * A Timestamp without time zone value implementation.
+ *
+ * This implementation supports arbitrary precision upto system limit.
+ */
+internal class LocalTimestampHighPrecision private constructor(
+    override val year: Int,
+    override val month: Int,
+    override val day: Int,
+    override val hour: Int,
+    override val minute: Int,
+    override val decimalSecond: BigDecimal,
+    _date: Date? = null,
+    _time: TimeWithoutTimeZone? = null
+) : TimestampWithoutTimeZone() {
+    companion object {
+        /**
+         * Construct a timestamp value using date time field.
+         *
+         * @param year Year field
+         * @param month Month field
+         * @param day Day field
+         * @param hour Hour field
+         * @param decimalSecond Second field, include fraction decimalSecond
+         */
+        fun of(
+            year: Int,
+            month: Int,
+            day: Int,
+            hour: Int,
+            minute: Int,
+            decimalSecond: BigDecimal
+        ): LocalTimestampHighPrecision {
+            val date = SqlDate.of(year, month, day)
+            val time = LocalTimeHighPrecision.of(hour, minute, decimalSecond)
+            return forDateTime(date, time)
+        }
+
+        /**
+         * Construct a timestamp without time zone value using its date component and time component.
+         *
+         * Notes the time component can not have time zone.
+         */
+        @JvmStatic
+        fun forDateTime(date: Date, time: TimeWithoutTimeZone): LocalTimestampHighPrecision =
+            LocalTimestampHighPrecision(
+                date.year, date.month, date.day,
+                time.hour, time.minute, time.decimalSecond.toBigDecimal(),
+                date, time
+            )
+    }
+
+    private val date: Date = _date ?: SqlDate.of(year, month, day)
+
+    private val time: TimeWithoutTimeZone = _time ?: LocalTimeHighPrecision.of(hour, minute, decimalSecond)
+
+    override fun plusYear(years: Long): TimestampWithoutTimeZone =
+        forDateTime(this.date.plusYear(years), this.time)
+
+    override fun plusMonths(months: Long): TimestampWithoutTimeZone =
+        forDateTime(this.date.plusMonths(months), this.time)
+
+    override fun plusDays(days: Long): TimestampWithoutTimeZone =
+        forDateTime(this.date.plusDays(days), this.time)
+
+    override fun plusHours(hours: Long): TimestampWithoutTimeZone {
+        val rawHour = this.hour + hours
+        val daysToCarry = if (rawHour >= 0) rawHour / 24 else rawHour / 24 - 1
+        val afterHour = (rawHour % 24).toInt().let { if (it < 0) it + 24 else it }
+        return forDateTime(date.plusDays(daysToCarry), LocalTimeHighPrecision.of(afterHour, minute, decimalSecond))
+    }
+
+    override fun plusMinutes(minutes: Long): TimestampWithoutTimeZone {
+        val rawMinute = this.minute + minutes
+        val hoursToCarry = if (rawMinute >= 0) rawMinute / 60 else rawMinute / 60 - 1
+        val afterMinute = (rawMinute % 60).toInt().let { if (it < 0) it + 60 else it }
+        return this.plusHours(hoursToCarry)
+            .let { of(it.year, it.month, it.day, it.hour, afterMinute, it.decimalSecond) }
+    }
+
+    override fun plusSeconds(seconds: BigDecimal): TimestampWithoutTimeZone {
+        val rawSecond = decimalSecond.plus(seconds)
+        val minutesToCarry = if (rawSecond >= BigDecimal.ZERO) {
+            rawSecond.div(BigDecimal.valueOf(60L))
+        } else {
+            rawSecond.div(BigDecimal.valueOf(60L)).minus(BigDecimal.ONE)
+        }.setScale(0, RoundingMode.DOWN).longValueExact()
+        val afterSecond =
+            rawSecond
+                .rem(BigDecimal.valueOf(60L))
+                .let {
+                    if (it < BigDecimal.ZERO) it.add(BigDecimal.valueOf(60L))
+                    else it
+                }
+        return this.plusMonths(minutesToCarry).let { of(it.year, it.month, it.day, it.hour, it.minute, afterSecond) }
+    }
+
+    override fun withTimeZone(timeZone: TimeZone): TimestampWithTimeZone =
+        OffsetTimestampHighPrecision.of(
+            year, month, day, hour, minute, decimalSecond, timeZone
+        )
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt
new file mode 100644
index 0000000000..ddd57b761a
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt
@@ -0,0 +1,96 @@
+package org.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.TimestampWithTimeZone
+import org.partiql.value.datetime.TimestampWithoutTimeZone
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.time.LocalDateTime
+import kotlin.math.max
+
+internal class LocalTimestampLowPrecision private constructor(
+    private val localDateTime: LocalDateTime,
+    _year: Int? = null,
+    _month: Int? = null,
+    _day: Int? = null,
+    _hour: Int? = null,
+    _minute: Int? = null,
+    _decimalSecond: BigDecimal? = null
+) : TimestampWithoutTimeZone() {
+    companion object {
+        fun of(
+            year: Int,
+            month: Int,
+            day: Int,
+            hour: Int,
+            minute: Int,
+            decimalSecond: BigDecimal
+        ): LocalTimestampLowPrecision {
+            val time = LocalTimeLowPrecision.of(hour, minute, decimalSecond)
+            val localDateTime = LocalDateTime.of(
+                year, month, day,
+                time.hour, time.minute, time.second, time.nano
+            )
+            return LocalTimestampLowPrecision(localDateTime, year, month, day, hour, minute, decimalSecond)
+        }
+
+        @JvmStatic
+        fun forDateTime(date: Date, time: LocalTimeLowPrecision): LocalTimestampLowPrecision {
+            val localDateTime = LocalDateTime.of(
+                date.year, date.month, date.day,
+                time.hour, time.minute, time.second, time.nano
+            )
+            return LocalTimestampLowPrecision(localDateTime)
+        }
+    }
+
+    override val year: Int = _year ?: localDateTime.year
+    override val month: Int = _month ?: localDateTime.monthValue
+    override val day: Int = _day ?: localDateTime.dayOfMonth
+    override val hour: Int = _hour ?: localDateTime.hour
+    override val minute: Int = _minute ?: localDateTime.minute
+    override val decimalSecond: BigDecimal =
+        _decimalSecond ?: BigDecimal.valueOf(localDateTime.second.toLong()).plus(BigDecimal.valueOf(localDateTime.nano.toLong(), 9))
+
+    override fun plusYear(years: Long): TimestampWithoutTimeZone =
+        localDateTime.plusYears(years).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond)
+        }
+
+    override fun plusMonths(months: Long): TimestampWithoutTimeZone =
+        localDateTime.plusMonths(months).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond)
+        }
+
+    override fun plusDays(days: Long): TimestampWithoutTimeZone =
+        localDateTime.plusDays(days).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond)
+        }
+
+    override fun plusHours(hours: Long): TimestampWithoutTimeZone =
+        localDateTime.plusHours(hours).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond)
+        }
+
+    override fun plusMinutes(minutes: Long): TimestampWithoutTimeZone =
+        localDateTime.plusMinutes(minutes).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond)
+        }
+
+    override fun plusSeconds(seconds: BigDecimal): TimestampWithoutTimeZone =
+        if (seconds.scale() > 9) {
+            LocalTimestampHighPrecision.of(year, month, day, hour, minute, decimalSecond).plusSeconds(seconds)
+        } else {
+            val wholeSecond = seconds.setScale(0, RoundingMode.DOWN)
+            val nano = seconds.minus(wholeSecond).let { it.movePointRight(it.scale()) }
+            val newTime = localDateTime.plusSeconds(wholeSecond.longValueExact()).plusNanos(nano.longValueExact())
+            // the real precision of this operation, should be max(original_value.decimalSecond.precision, seconds.precision)
+            val newDecimalSecond = newTime.second.toBigDecimal() + newTime.nano.toBigDecimal().movePointLeft(9)
+            val roundedDecimalSecond = newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
+            of(newTime.year, newTime.monthValue, newTime.dayOfMonth, newTime.hour, newTime.minute, roundedDecimalSecond)
+        }
+
+    override fun withTimeZone(timeZone: TimeZone): TimestampWithTimeZone =
+        OffsetTimestampLowPrecision.of(year, month, day, hour, minute, decimalSecond, timeZone)
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt
new file mode 100644
index 0000000000..87e70a1cbe
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt
@@ -0,0 +1,89 @@
+package org.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeUtil
+import org.partiql.value.datetime.DateTimeUtil.SECONDS_IN_HOUR
+import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
+import org.partiql.value.datetime.TimeWithTimeZone
+import org.partiql.value.datetime.TimeWithoutTimeZone
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.TimestampWithTimeZone
+import java.math.BigDecimal
+
+internal class OffsetTimeHighPrecision private constructor(
+    override val hour: Int,
+    override val minute: Int,
+    override val decimalSecond: BigDecimal,
+    override val timeZone: TimeZone,
+    _localTime: LocalTimeHighPrecision,
+    _elapsedSecond: BigDecimal? = null
+) : TimeWithTimeZone() {
+
+    companion object {
+        fun of(
+            hour: Int,
+            minute: Int,
+            decimalSecond: BigDecimal,
+            timeZone: TimeZone
+        ): OffsetTimeHighPrecision {
+            try {
+                val localTime = LocalTimeHighPrecision.of(hour, minute, decimalSecond)
+                return OffsetTimeHighPrecision(localTime.hour, localTime.minute, localTime.decimalSecond, timeZone, localTime)
+            } catch (e: java.time.DateTimeException) {
+                throw DateTimeException(e.localizedMessage, e)
+            }
+        }
+
+        fun forSeconds(elapsedSeconds: BigDecimal, timeZone: TimeZone): OffsetTimeHighPrecision {
+            val localTime = LocalTimeHighPrecision.forSeconds(elapsedSeconds)
+            return OffsetTimeHighPrecision(
+                localTime.hour, localTime.minute, localTime.decimalSecond,
+                timeZone, localTime, elapsedSeconds
+            )
+        }
+    }
+
+    override val elapsedSecond: BigDecimal by lazy {
+        _elapsedSecond ?: _localTime.elapsedSecond
+    }
+
+    override fun plusHours(hours: Long): TimeWithTimeZone =
+        forSeconds(this.elapsedSecond.plus((hours * SECONDS_IN_HOUR).toBigDecimal()), timeZone)
+
+    override fun plusMinutes(minutes: Long): TimeWithTimeZone =
+        forSeconds(this.elapsedSecond.plus((minutes * DateTimeUtil.SECONDS_IN_MINUTE).toBigDecimal()), timeZone)
+
+    override fun plusSeconds(seconds: BigDecimal): TimeWithTimeZone =
+        forSeconds(this.elapsedSecond.plus(seconds.toBigDecimal()), timeZone)
+
+    override fun atDate(date: Date): TimestampWithTimeZone =
+        OffsetTimestampHighPrecision.forDateTime(date, this)
+
+    override fun toTimeWithoutTimeZone(timeZone: TimeZone): TimeWithoutTimeZone =
+        this.atTimeZone(timeZone).let {
+            LocalTimeHighPrecision.of(it.hour, it.minute, it.decimalSecond)
+        }
+
+    override fun atTimeZone(timeZone: TimeZone): TimeWithTimeZone =
+        when (val valueTimeZone = this.timeZone) {
+            TimeZone.UnknownTimeZone -> {
+                when (timeZone) {
+                    TimeZone.UnknownTimeZone -> this
+                    is TimeZone.UtcOffset -> of(
+                        hour, minute, decimalSecond,
+                        TimeZone.UtcOffset.of(0)
+                    ).atTimeZone(timeZone)
+                }
+            }
+
+            is TimeZone.UtcOffset -> {
+                val utc = this.plusMinutes(-valueTimeZone.totalOffsetMinutes.toLong())
+                when (timeZone) {
+                    TimeZone.UnknownTimeZone -> of(utc.hour, utc.minute, utc.decimalSecond, timeZone)
+                    is TimeZone.UtcOffset -> utc.plusMinutes(timeZone.totalOffsetMinutes.toLong())
+                        .let { of(it.hour, it.minute, it.decimalSecond, timeZone) }
+                }
+            }
+        }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt
new file mode 100644
index 0000000000..e99e7e384e
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt
@@ -0,0 +1,115 @@
+package org.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeUtil
+import org.partiql.value.datetime.TimeWithTimeZone
+import org.partiql.value.datetime.TimeWithoutTimeZone
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.TimestampWithTimeZone
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.time.OffsetTime
+import java.time.ZoneOffset
+import kotlin.math.max
+
+internal class OffsetTimeLowPrecision private constructor(
+    private val offsetTime: OffsetTime,
+    private val isUnknownTimeZone: Boolean,
+    _hour: Int? = null,
+    _minute: Int? = null,
+    _decimalSecond: BigDecimal? = null,
+    _timeZone: TimeZone? = null
+) : TimeWithTimeZone() {
+    companion object {
+        fun of(
+            hour: Int,
+            minute: Int,
+            second: Int,
+            nanoOfSecond: Int,
+            timeZone: TimeZone
+        ): OffsetTimeLowPrecision {
+            try {
+                return when (timeZone) {
+                    TimeZone.UnknownTimeZone ->
+                        OffsetTimeLowPrecision(
+                            OffsetTime.of(hour, minute, second, nanoOfSecond, ZoneOffset.UTC),
+                            true
+                        )
+
+                    is TimeZone.UtcOffset -> OffsetTimeLowPrecision(
+                        OffsetTime.of(
+                            hour, minute, second, nanoOfSecond,
+                            ZoneOffset.ofTotalSeconds(timeZone.totalOffsetMinutes * 60)
+                        ),
+                        false
+                    )
+                }
+            } catch (e: java.time.DateTimeException) {
+                throw DateTimeException(e.localizedMessage)
+            }
+        }
+
+        fun of(hour: Int, minute: Int, decimalSecond: BigDecimal, timeZone: TimeZone): OffsetTimeLowPrecision {
+            val wholeSecond = decimalSecond.setScale(0, RoundingMode.DOWN)
+            val nano = decimalSecond.minus(wholeSecond).let { it.movePointRight(it.scale()) }
+            return of(hour, minute, wholeSecond.intValueExact(), nano.intValueExact(), timeZone).let {
+                OffsetTimeLowPrecision(it.offsetTime, it.isUnknownTimeZone, it.hour, it.minute, decimalSecond, timeZone)
+            }
+        }
+    }
+
+    override val hour: Int = _hour ?: offsetTime.hour
+    override val minute: Int = _minute ?: offsetTime.minute
+    override val decimalSecond: BigDecimal =
+        _decimalSecond
+            ?: BigDecimal.valueOf(offsetTime.second.toLong()).plus(BigDecimal.valueOf(offsetTime.nano.toLong(), 9))
+    override val timeZone: TimeZone =
+        _timeZone
+            ?: if (isUnknownTimeZone) TimeZone.UnknownTimeZone else TimeZone.UtcOffset.of(offsetTime.offset.totalSeconds / 60)
+    override val elapsedSecond: BigDecimal by lazy {
+        BigDecimal.valueOf(this.hour * DateTimeUtil.SECONDS_IN_HOUR + this.minute * DateTimeUtil.SECONDS_IN_MINUTE) + this.decimalSecond
+    }
+
+    override fun plusHours(hours: Long): TimeWithTimeZone =
+        offsetTime.plusHours(hours).let {
+            of(it.hour, it.minute, decimalSecond, timeZone)
+        }
+
+    override fun plusMinutes(minutes: Long): TimeWithTimeZone =
+        offsetTime.plusMinutes(minutes).let {
+            of(it.hour, it.minute, decimalSecond, timeZone)
+        }
+
+    override fun plusSeconds(seconds: BigDecimal): TimeWithTimeZone =
+        if (seconds.scale() > 9) {
+            OffsetTimeHighPrecision.of(hour, minute, decimalSecond, timeZone).plusSeconds(seconds)
+        } else {
+            val wholeSecond = seconds.setScale(0, RoundingMode.DOWN)
+            val nano = seconds.minus(wholeSecond).let { it.movePointRight(it.scale()) }
+            val newTime = offsetTime.plusSeconds(wholeSecond.longValueExact()).plusNanos(nano.longValueExact())
+            val newDecimalSecond = newTime.second.toBigDecimal() + newTime.nano.toBigDecimal().movePointLeft(9)
+            val roundedDecimalSecond = newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
+            of(newTime.hour, newTime.minute, roundedDecimalSecond, timeZone)
+        }
+
+    override fun atDate(date: Date): TimestampWithTimeZone =
+        OffsetTimestampLowPrecision.forDateTime(date, this)
+
+    override fun toTimeWithoutTimeZone(timeZone: TimeZone): TimeWithoutTimeZone {
+        val local = when (timeZone) {
+            TimeZone.UnknownTimeZone -> offsetTime.withOffsetSameInstant(ZoneOffset.UTC)
+            is TimeZone.UtcOffset -> offsetTime.withOffsetSameInstant(ZoneOffset.ofTotalSeconds(timeZone.totalOffsetMinutes * 60))
+        }
+        // Second field should be intact from this operation
+        return LocalTimeLowPrecision.of(local.hour, local.minute, this.decimalSecond)
+    }
+
+    override fun atTimeZone(timeZone: TimeZone): TimeWithTimeZone {
+        val local = when (timeZone) {
+            TimeZone.UnknownTimeZone -> offsetTime.withOffsetSameInstant(ZoneOffset.UTC)
+            is TimeZone.UtcOffset -> offsetTime.withOffsetSameInstant(ZoneOffset.ofTotalSeconds(timeZone.totalOffsetMinutes * 60))
+        }
+        return of(local.hour, local.minute, this.decimalSecond, timeZone)
+    }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt
new file mode 100644
index 0000000000..531daf2423
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt
@@ -0,0 +1,217 @@
+package org.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeUtil.SECONDS_IN_DAY
+import org.partiql.value.datetime.DateTimeUtil.SECONDS_IN_HOUR
+import org.partiql.value.datetime.DateTimeUtil.SECONDS_IN_MINUTE
+import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
+import org.partiql.value.datetime.TimeWithTimeZone
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.TimestampWithTimeZone
+import org.partiql.value.datetime.TimestampWithoutTimeZone
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.time.LocalDate
+import java.time.ZoneOffset
+
+internal class OffsetTimestampHighPrecision private constructor(
+    override val year: Int,
+    override val month: Int,
+    override val day: Int,
+    override val hour: Int,
+    override val minute: Int,
+    override val decimalSecond: BigDecimal,
+    override val timeZone: TimeZone,
+    _inputIonTimestamp: com.amazon.ion.Timestamp? = null,
+    _epochSecond: BigDecimal? = null,
+    _date: Date?,
+    _time: TimeWithTimeZone?,
+) : TimestampWithTimeZone() {
+    companion object {
+        /**
+         * Construct a timestamp value using date time field and a given precision.
+         *
+         * @param year Year field
+         * @param month Month field
+         * @param day Day field
+         * @param hour Hour field
+         * @param second Second field, include fraction decimalSecond
+         * @param timeZone TimeZone field, see [TimeZone], null value indicates a timestamp without timezone value.
+         */
+        fun of(
+            year: Int,
+            month: Int,
+            day: Int,
+            hour: Int,
+            minute: Int,
+            second: BigDecimal,
+            timeZone: TimeZone
+        ): OffsetTimestampHighPrecision {
+            val date = SqlDate.of(year, month, day)
+            val time = OffsetTimeHighPrecision.of(hour, minute, second, timeZone)
+            return forDateTime(date, time)
+        }
+
+        /**
+         * The intention of this API is to create a Timestamp using a Date and a Time component.
+         * It is assumed that the time component has already been rounded,
+         * meaning this API will not be responsible, if the rounding requires carrying in to day field.
+         */
+        @JvmStatic
+        fun forDateTime(date: Date, time: TimeWithTimeZone): OffsetTimestampHighPrecision =
+            OffsetTimestampHighPrecision(
+                date.year, date.month, date.day,
+                time.hour, time.minute, time.decimalSecond.toBigDecimal(),
+                time.timeZone, null, null, date, time
+            )
+
+        /**
+         * Construct a PartiQL timestamp based on an Ion Timestamp.
+         * The created timestamp always has [TimeZone] and arbitrary precision.
+         * Notice that Ion Value allows for "lower precision", year, month, etc.
+         * For example, `2023T` is a valid ion timestamp with year precision.
+         * This method always returns a "full timestamp expression", i.e., 2023-01-01T00:00:00.
+         * At the moment there is no intention on preserving this.
+         */
+        @JvmStatic
+        fun forIonTimestamp(ionTs: com.amazon.ion.Timestamp): OffsetTimestampHighPrecision {
+            val timestamp = when (ionTs.localOffset) {
+                null ->
+                    OffsetTimestampHighPrecision(
+                        ionTs.year, ionTs.month, ionTs.day,
+                        ionTs.hour, ionTs.minute, ionTs.decimalSecond,
+                        TimeZone.UnknownTimeZone, ionTs,
+                        null, null, null
+                    )
+
+                else ->
+                    OffsetTimestampHighPrecision(
+                        ionTs.year, ionTs.month, ionTs.day,
+                        ionTs.hour, ionTs.minute, ionTs.decimalSecond,
+                        TimeZone.UtcOffset.of(ionTs.localOffset), ionTs,
+                        null, null, null
+                    )
+            }
+            return timestamp
+        }
+
+        /**
+         * Returns a timestamp based on epoch decimalSecond.
+         *
+         * The resulting timestamp is always a timestamp with timezone,
+         * this is because epoch decimalSecond by definition refers to a point in time.
+         * and timestamp without time zone does not refer to a point forEpochSecond time.
+         */
+        @JvmStatic
+        fun forEpochSecond(
+            epochSeconds: BigDecimal,
+            timeZone: TimeZone = TimeZone.UnknownTimeZone,
+        ): OffsetTimestampHighPrecision {
+            val offsetDateTime =
+                java.time.Instant.ofEpochSecond(epochSeconds.setScale(0, RoundingMode.DOWN).longValueExact()).atOffset(
+                    ZoneOffset.UTC
+                )
+            val year = offsetDateTime.year
+            val month = offsetDateTime.monthValue
+            val day = offsetDateTime.dayOfMonth
+            val hour = offsetDateTime.hour
+            val minute = offsetDateTime.minute
+            val wholeSecond = offsetDateTime.second
+            val fractionSecond =
+                epochSeconds.minus(BigDecimal.valueOf(epochSeconds.setScale(0, RoundingMode.DOWN).longValueExact()))
+            return of(
+                year, month, day,
+                hour, minute,
+                fractionSecond.add(BigDecimal.valueOf(wholeSecond.toLong())),
+                timeZone
+            ).let {
+                OffsetTimestampHighPrecision(
+                    it.year, it.month, it.day,
+                    it.hour, it.minute, it.decimalSecond,
+                    it.timeZone, null,
+                    epochSeconds, null, null
+                )
+            }
+        }
+    }
+
+    @Deprecated("We will not store raw Ion Timestamp Value in the next release.")
+    override val ionRaw: com.amazon.ion.Timestamp? = _inputIonTimestamp
+    override val epochSecond: BigDecimal by lazy {
+        _epochSecond ?: when (val timeZone = this.timeZone) {
+            TimeZone.UnknownTimeZone -> getUTCEpoch(0)
+            is TimeZone.UtcOffset -> getUTCEpoch(timeZone.totalOffsetMinutes)
+        }
+    }
+    internal val date = _date ?: SqlDate.of(year, month, day)
+    internal val time = _time ?: OffsetTimeHighPrecision.of(this.hour, this.minute, this.decimalSecond, this.timeZone)
+
+    override fun plusYear(years: Long): TimestampWithTimeZone =
+        forDateTime(this.date.plusYear(years), this.time)
+
+    override fun plusMonths(months: Long): TimestampWithTimeZone =
+        forDateTime(this.date.plusMonths(months), this.time)
+
+    override fun plusDays(days: Long): TimestampWithTimeZone =
+        forDateTime(this.date.plusDays(days), this.time)
+
+    override fun plusHours(hours: Long): TimestampWithTimeZone =
+        forEpochSecond(this.epochSecond.plus((hours * SECONDS_IN_HOUR).toBigDecimal()), timeZone)
+
+    override fun plusMinutes(minutes: Long): TimestampWithTimeZone =
+        forEpochSecond(this.epochSecond.plus((minutes * SECONDS_IN_MINUTE).toBigDecimal()), timeZone)
+
+    override fun plusSeconds(seconds: BigDecimal): TimestampWithTimeZone =
+        forEpochSecond(this.epochSecond.plus(seconds.toBigDecimal()), timeZone)
+
+    override fun toTimeWithoutTimeZone(timeZone: TimeZone): TimestampWithoutTimeZone =
+        this.atTimeZone(timeZone).let {
+            LocalTimestampHighPrecision.of(it.year, it.month, it.day, it.hour, it.minute, it.decimalSecond)
+        }
+
+    override fun atTimeZone(timeZone: TimeZone): TimestampWithTimeZone =
+        when (val valueTimeZone = this.timeZone) {
+            TimeZone.UnknownTimeZone -> {
+                when (timeZone) {
+                    TimeZone.UnknownTimeZone -> this
+                    is TimeZone.UtcOffset -> of(
+                        year, month, day, hour, minute, decimalSecond, TimeZone.UtcOffset.of(0)
+                    ).atTimeZone(timeZone)
+                }
+            }
+
+            is TimeZone.UtcOffset -> {
+                val utc = this.plusMinutes(-valueTimeZone.totalOffsetMinutes.toLong())
+                when (timeZone) {
+                    TimeZone.UnknownTimeZone -> of(
+                        utc.year, utc.month, utc.day,
+                        utc.hour, utc.minute, utc.decimalSecond,
+                        timeZone
+                    )
+                    is TimeZone.UtcOffset -> utc.plusMinutes(timeZone.totalOffsetMinutes.toLong())
+                        .let { of(it.year, it.month, it.day, it.hour, it.minute, it.decimalSecond, timeZone) }
+                }
+            }
+        }
+
+    private fun getUTCEpoch(totalOffsetMinutes: Int): BigDecimal {
+        val epochDay = LocalDate.of(year, month, day).toEpochDay()
+        // Deal with time zone first, so we delay big decimal op
+        val adjustForTimeZoneInSecond = epochDay * SECONDS_IN_DAY - totalOffsetMinutes * SECONDS_IN_MINUTE
+
+        return BigDecimal.valueOf(adjustForTimeZoneInSecond).plus(this.time.elapsedSecond)
+    }
+
+    internal fun copy(
+        _inputIonTimestamp: com.amazon.ion.Timestamp? = null,
+        _epochSecond: BigDecimal? = null,
+        _date: Date? = null,
+        _time: TimeWithTimeZone? = null
+    ) =
+        OffsetTimestampHighPrecision(
+            this.year, this.month, this.day,
+            this.hour, this.minute, this.decimalSecond, this.timeZone,
+            _inputIonTimestamp ?: this.ionTimestampValue, _epochSecond ?: this.epochSecond,
+            _date ?: this.date, _time ?: this.time
+        )
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt
new file mode 100644
index 0000000000..eafe58d549
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt
@@ -0,0 +1,212 @@
+package org.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeUtil.JAVA_MAX_OFFSET
+import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
+import org.partiql.value.datetime.TimeWithTimeZone
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.Timestamp
+import org.partiql.value.datetime.TimestampWithTimeZone
+import org.partiql.value.datetime.TimestampWithoutTimeZone
+import java.math.BigDecimal
+import java.math.RoundingMode
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
+import kotlin.math.absoluteValue
+import kotlin.math.max
+
+internal class OffsetTimestampLowPrecision(
+    val offsetDateTime: OffsetDateTime,
+    val isUnknownTimeZone: Boolean,
+    _year: Int? = null,
+    _month: Int? = null,
+    _day: Int? = null,
+    _hour: Int? = null,
+    _minute: Int? = null,
+    _decimalSecond: BigDecimal? = null,
+    _timeZone: TimeZone? = null,
+    _inputIonTimestamp: com.amazon.ion.Timestamp? = null
+) : TimestampWithTimeZone() {
+
+    companion object {
+        fun of(
+            year: Int,
+            month: Int,
+            day: Int,
+            hour: Int,
+            minute: Int,
+            second: Int,
+            nanoOfSecond: Int,
+            timeZone: TimeZone,
+        ): OffsetTimestampLowPrecision {
+            try {
+                return when (timeZone) {
+                    TimeZone.UnknownTimeZone ->
+                        OffsetTimestampLowPrecision(
+                            OffsetDateTime.of(year, month, day, hour, minute, second, nanoOfSecond, ZoneOffset.UTC),
+                            true,
+                            year, month, day, hour, minute, null, timeZone, null
+                        )
+
+                    is TimeZone.UtcOffset -> OffsetTimestampLowPrecision(
+                        OffsetDateTime.of(
+                            year, month, day,
+                            hour, minute, second, nanoOfSecond,
+                            ZoneOffset.ofTotalSeconds(timeZone.totalOffsetMinutes * 60)
+                        ),
+                        false,
+                        year, month, day, hour, minute, null, timeZone, null
+                    )
+                }
+            } catch (e: java.time.DateTimeException) {
+                throw DateTimeException(e.localizedMessage)
+            }
+        }
+
+        fun of(
+            year: Int,
+            month: Int,
+            day: Int,
+            hour: Int,
+            minute: Int,
+            decimalSecond: BigDecimal,
+            timeZone: TimeZone
+        ): OffsetTimestampLowPrecision {
+            val wholeSecond = decimalSecond.setScale(0, RoundingMode.DOWN)
+            val nano = decimalSecond.minus(wholeSecond).movePointRight(9)
+            return of(year, month, day, hour, minute, wholeSecond.intValueExact(), nano.intValueExact(), timeZone).let {
+                OffsetTimestampLowPrecision(
+                    it.offsetDateTime, it.isUnknownTimeZone,
+                    year, month, day,
+                    hour, minute, decimalSecond,
+                    timeZone, null
+                )
+            }
+        }
+
+        fun forDateTime(date: Date, time: TimeWithTimeZone): OffsetTimestampLowPrecision {
+            return of(date.year, date.month, date.day, time.hour, time.minute, time.decimalSecond, time.timeZone)
+        }
+
+        fun forIonTimestamp(ionTs: com.amazon.ion.Timestamp): TimestampWithTimeZone {
+            val timestamp = when {
+                ionTs.localOffset == null ->
+                    of(
+                        ionTs.year, ionTs.month, ionTs.day,
+                        ionTs.hour, ionTs.minute, ionTs.decimalSecond,
+                        TimeZone.UnknownTimeZone
+                    ).copy(_inputIonTimestamp = ionTs)
+                ionTs.localOffset.absoluteValue > JAVA_MAX_OFFSET ->
+                    OffsetTimestampHighPrecision.of(
+                        ionTs.year, ionTs.month, ionTs.day,
+                        ionTs.hour, ionTs.minute, ionTs.decimalSecond,
+                        TimeZone.UtcOffset.of(ionTs.localOffset)
+                    ).copy(_inputIonTimestamp = ionTs)
+                else ->
+                    of(
+                        ionTs.year, ionTs.month, ionTs.day,
+                        ionTs.hour, ionTs.minute, ionTs.decimalSecond,
+                        TimeZone.UtcOffset.of(ionTs.localOffset)
+                    ).copy(_inputIonTimestamp = ionTs)
+            }
+            return timestamp
+        }
+
+        @JvmStatic
+        fun nowZ() =
+            OffsetTimestampLowPrecision(OffsetDateTime.now(ZoneOffset.UTC), false)
+    }
+
+    override val year: Int = _year ?: offsetDateTime.year
+    override val month: Int = _month ?: offsetDateTime.monthValue
+    override val day: Int = _day ?: offsetDateTime.dayOfMonth
+    override val hour: Int = _hour ?: offsetDateTime.hour
+    override val minute: Int = _minute ?: offsetDateTime.minute
+    override val decimalSecond: BigDecimal =
+        _decimalSecond
+            ?: BigDecimal.valueOf(offsetDateTime.second.toLong())
+                .plus(BigDecimal.valueOf(offsetDateTime.nano.toLong(), 9))
+    override val timeZone: TimeZone =
+        _timeZone
+            ?: if (isUnknownTimeZone) TimeZone.UnknownTimeZone else TimeZone.UtcOffset.of(offsetDateTime.offset.totalSeconds / 60)
+    override val ionRaw: com.amazon.ion.Timestamp? = _inputIonTimestamp
+    val second: Int = offsetDateTime.second
+    val nano: Int = offsetDateTime.nano
+    override val epochSecond: BigDecimal by lazy {
+        (offsetDateTime.toEpochSecond() - second).toBigDecimal() + decimalSecond
+    }
+
+    override fun plusYear(years: Long): TimestampWithTimeZone =
+        offsetDateTime.plusYears(years).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond, timeZone)
+        }
+
+    override fun plusMonths(months: Long): TimestampWithTimeZone =
+        offsetDateTime.plusMonths(months).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond, timeZone)
+        }
+
+    override fun plusDays(days: Long): TimestampWithTimeZone =
+        offsetDateTime.plusDays(days).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond, timeZone)
+        }
+
+    override fun plusHours(hours: Long): TimestampWithTimeZone =
+        offsetDateTime.plusHours(hours).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond, timeZone)
+        }
+
+    override fun plusMinutes(minutes: Long): TimestampWithTimeZone =
+        offsetDateTime.plusMinutes(minutes).let {
+            of(it.year, it.monthValue, it.dayOfMonth, it.hour, it.minute, decimalSecond, timeZone)
+        }
+
+    override fun plusSeconds(seconds: BigDecimal): TimestampWithTimeZone =
+        if (seconds.scale() > 9) {
+            OffsetTimestampHighPrecision.of(year, month, day, hour, minute, decimalSecond, timeZone).plusSeconds(seconds)
+        } else {
+            val wholeSecond = seconds.setScale(0, RoundingMode.DOWN)
+            val nano = seconds.minus(wholeSecond).let { it.movePointRight(it.scale()) }
+            val newTime = offsetDateTime.plusSeconds(wholeSecond.longValueExact()).plusNanos(nano.longValueExact())
+            // the real precision of this operation, should be max(original_value.decimalSecond.precision, seconds.precision)
+            val newDecimalSecond = newTime.second.toBigDecimal() + newTime.nano.toBigDecimal().movePointLeft(9)
+            val roundedDecimalSecond =
+                newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
+            of(newTime.year, newTime.monthValue, newTime.dayOfMonth, newTime.hour, newTime.minute, roundedDecimalSecond, timeZone)
+        }
+
+    override fun toTimeWithoutTimeZone(timeZone: TimeZone): TimestampWithoutTimeZone {
+        val local = when (timeZone) {
+            TimeZone.UnknownTimeZone -> offsetDateTime.withOffsetSameInstant(ZoneOffset.UTC)
+            is TimeZone.UtcOffset -> offsetDateTime.withOffsetSameInstant(ZoneOffset.ofTotalSeconds(timeZone.totalOffsetMinutes * 60))
+        }
+        // Second field should be intact from this operation
+        return LocalTimestampLowPrecision.of(local.year, local.monthValue, local.dayOfMonth, local.hour, local.minute, decimalSecond)
+    }
+
+    override fun atTimeZone(timeZone: TimeZone): TimestampWithTimeZone {
+        val local = when (timeZone) {
+            TimeZone.UnknownTimeZone -> offsetDateTime.withOffsetSameInstant(ZoneOffset.UTC)
+            is TimeZone.UtcOffset -> offsetDateTime.withOffsetSameInstant(ZoneOffset.ofTotalSeconds(timeZone.totalOffsetMinutes * 60))
+        }
+        return of(local.year, local.monthValue, local.dayOfMonth, local.hour, local.minute, this.decimalSecond, timeZone)
+    }
+
+    internal fun copy(
+        _year: Int? = null,
+        _month: Int? = null,
+        _day: Int? = null,
+        _hour: Int? = null,
+        _minute: Int? = null,
+        _decimalSecond: BigDecimal? = null,
+        _timeZone: TimeZone? = null,
+        _inputIonTimestamp: com.amazon.ion.Timestamp? = null
+    ) =
+        OffsetTimestampLowPrecision(
+            this.offsetDateTime, this.isUnknownTimeZone,
+            _year ?: this.year, _month ?: this.month, _day ?: this.day,
+            _hour ?: this.hour, _minute ?: this.minute, _decimalSecond ?: this.decimalSecond,
+            _timeZone ?: this.timeZone, _inputIonTimestamp ?: this.ionRaw
+        )
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/SqlDate.kt b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/SqlDate.kt
new file mode 100644
index 0000000000..d405e2a514
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/datetime/impl/SqlDate.kt
@@ -0,0 +1,70 @@
+/*
+ * Copyright Amazon.com, Inc. or its affiliates.  All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License").
+ * You may not use this file except in compliance with the License.
+ * A copy of the License is located at:
+ *
+ *      http://aws.amazon.com/apache2.0/
+ *
+ * or in the "license" file accompanying this file. This file 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.partiql.value.datetime.impl
+
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.DateImpl
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeValue.timestamp
+import org.partiql.value.datetime.Time
+import org.partiql.value.datetime.Timestamp
+import java.time.LocalDate
+import kotlin.jvm.Throws
+
+internal data class SqlDate private constructor(
+    val localDate: LocalDate
+) : DateImpl() {
+    companion object {
+        /**
+         * Construct a Date object using
+         */
+        @JvmStatic
+        @Throws(DateTimeException::class)
+        fun of(year: Int, month: Int, day: Int): Date {
+            if (year < 1 || year > 9999)
+                throw DateTimeException("Expect Year Field to be between 1 to 9999, but received $year")
+            try {
+                return SqlDate(LocalDate.of(year, month, day))
+            } catch (e: java.time.DateTimeException) {
+                throw DateTimeException(e.localizedMessage, e)
+            }
+        }
+    }
+
+    override val year: Int = localDate.year
+
+    override val month: Int = localDate.monthValue
+
+    override val day: Int = localDate.dayOfMonth
+
+    override fun atTime(time: Time): Timestamp = timestamp(this, time)
+
+    // Operation
+    override fun plusDays(days: Long): Date =
+        this.localDate.plusDays(days)
+            .let { newDate ->
+                of(newDate.year, newDate.monthValue, newDate.dayOfMonth)
+            }
+    override fun plusMonths(months: Long): Date =
+        this.localDate.plusMonths(months)
+            .let { newDate ->
+                of(newDate.year, newDate.monthValue, newDate.dayOfMonth)
+            }
+    override fun plusYear(years: Long): Date =
+        this.localDate.plusYears(years)
+            .let { newDate ->
+                of(newDate.year, newDate.monthValue, newDate.dayOfMonth)
+            }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/impl/PartiQLValueImpl.kt b/partiql-types/src/main/kotlin/org/partiql/value/impl/PartiQLValueImpl.kt
index c9493970ed..d4461226ad 100644
--- a/partiql-types/src/main/kotlin/org/partiql/value/impl/PartiQLValueImpl.kt
+++ b/partiql-types/src/main/kotlin/org/partiql/value/impl/PartiQLValueImpl.kt
@@ -46,13 +46,12 @@ import org.partiql.value.StructValue
 import org.partiql.value.SymbolValue
 import org.partiql.value.TimeValue
 import org.partiql.value.TimestampValue
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.Time
+import org.partiql.value.datetime.Timestamp
 import org.partiql.value.util.PartiQLValueVisitor
 import java.math.BigDecimal
 import java.math.BigInteger
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-import java.time.ZoneOffset
 import java.util.BitSet
 
 @Suppress("FunctionName")
@@ -294,7 +293,7 @@ internal data class BlobValueImpl(
 }
 
 internal data class DateValueImpl(
-    override val value: LocalDate,
+    override val value: Date,
     override val annotations: PersistentList<String>,
 ) : DateValue() {
     override fun copy(annotations: Annotations) = DateValueImpl(value, annotations.toPersistentList())
@@ -307,13 +306,10 @@ internal data class DateValueImpl(
 }
 
 internal data class TimeValueImpl(
-    override val value: LocalTime,
-    override val precision: Int,
-    override val offset: ZoneOffset?,
-    override val withZone: Boolean,
+    override val value: Time,
     override val annotations: PersistentList<String>,
 ) : TimeValue() {
-    override fun copy(annotations: Annotations) = TimeValueImpl(value, precision, offset, withZone, annotations.toPersistentList())
+    override fun copy(annotations: Annotations) = TimeValueImpl(value, annotations.toPersistentList())
 
     override fun withAnnotations(annotations: Annotations): TimeValue = _withAnnotations(annotations)
 
@@ -323,13 +319,10 @@ internal data class TimeValueImpl(
 }
 
 internal data class TimestampValueImpl(
-    override val value: LocalDateTime,
-    override val precision: Int,
-    override val offset: ZoneOffset?,
-    override val withZone: Boolean,
+    override val value: Timestamp,
     override val annotations: PersistentList<String>,
 ) : TimestampValue() {
-    override fun copy(annotations: Annotations) = TimestampValueImpl(value, precision, offset, withZone, annotations.toPersistentList())
+    override fun copy(annotations: Annotations) = TimestampValueImpl(value, annotations.toPersistentList())
 
     override fun withAnnotations(annotations: Annotations): TimestampValue = _withAnnotations(annotations)
 
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/impl/PartiQLValueNullableImpl.kt b/partiql-types/src/main/kotlin/org/partiql/value/impl/PartiQLValueNullableImpl.kt
index d905af3514..4c9f0d95e3 100644
--- a/partiql-types/src/main/kotlin/org/partiql/value/impl/PartiQLValueNullableImpl.kt
+++ b/partiql-types/src/main/kotlin/org/partiql/value/impl/PartiQLValueNullableImpl.kt
@@ -17,9 +17,9 @@
 package org.partiql.value.impl
 
 import kotlinx.collections.immutable.PersistentList
-import kotlinx.collections.immutable.toImmutableList
 import kotlinx.collections.immutable.toPersistentList
 import org.partiql.value.Annotations
+import org.partiql.value.BagValue
 import org.partiql.value.MissingValue
 import org.partiql.value.NullValue
 import org.partiql.value.NullableBagValue
@@ -48,13 +48,12 @@ import org.partiql.value.NullableTimeValue
 import org.partiql.value.NullableTimestampValue
 import org.partiql.value.PartiQLValue
 import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.datetime.Date
+import org.partiql.value.datetime.Time
+import org.partiql.value.datetime.Timestamp
 import org.partiql.value.util.PartiQLValueVisitor
 import java.math.BigDecimal
 import java.math.BigInteger
-import java.time.LocalDate
-import java.time.LocalDateTime
-import java.time.LocalTime
-import java.time.ZoneOffset
 import java.util.BitSet
 
 internal data class NullValueImpl(
@@ -318,7 +317,7 @@ internal data class NullableBlobValueImpl(
     override fun equals(other: Any?): Boolean {
         if (this === other) return true
         if (javaClass != other?.javaClass) return false
-        other as NullableClobValueImpl
+        other as NullableBlobValueImpl
         if (value != null) {
             if (other.value == null) return false
             if (!value.contentEquals(other.value)) return false
@@ -334,7 +333,7 @@ internal data class NullableBlobValueImpl(
 }
 
 internal data class NullableDateValueImpl(
-    override val value: LocalDate?,
+    override val value: Date?,
     override val annotations: PersistentList<String>,
 ) : NullableDateValue() {
     override fun copy(annotations: Annotations) = NullableDateValueImpl(value, annotations.toPersistentList())
@@ -347,14 +346,11 @@ internal data class NullableDateValueImpl(
 }
 
 internal data class NullableTimeValueImpl(
-    override val value: LocalTime?,
-    override val precision: Int,
-    override val offset: ZoneOffset?,
-    override val withZone: Boolean,
+    override val value: Time?,
     override val annotations: PersistentList<String>,
 ) : NullableTimeValue() {
     override fun copy(annotations: Annotations) =
-        NullableTimeValueImpl(value, precision, offset, withZone, annotations.toPersistentList())
+        NullableTimeValueImpl(value, annotations.toPersistentList())
 
     override fun withAnnotations(annotations: Annotations): NullableTimeValue = _withAnnotations(annotations)
 
@@ -364,14 +360,11 @@ internal data class NullableTimeValueImpl(
 }
 
 internal data class NullableTimestampValueImpl(
-    override val value: LocalDateTime?,
-    override val precision: Int,
-    override val offset: ZoneOffset?,
-    override val withZone: Boolean,
+    override val value: Timestamp?,
     override val annotations: PersistentList<String>,
 ) : NullableTimestampValue() {
     override fun copy(annotations: Annotations) =
-        NullableTimestampValueImpl(value, precision, offset, withZone, annotations.toPersistentList())
+        NullableTimestampValueImpl(value, annotations.toPersistentList())
 
     override fun withAnnotations(annotations: Annotations): NullableTimestampValue = _withAnnotations(annotations)
 
@@ -398,18 +391,9 @@ internal data class NullableBagValueImpl<T : PartiQLValue>(
     private val delegate: PersistentList<T>?,
     override val annotations: PersistentList<String>,
 ) : NullableBagValue<T>() {
+    override fun isNull(): Boolean = delegate == null
 
-    override fun contains(element: T) = delegate!!.contains(element)
-
-    override fun containsAll(elements: Collection<T>) = delegate!!.containsAll(elements)
-
-    override fun isEmpty() = delegate!!.isEmpty()
-
-    override fun iterator() = delegate!!.iterator()
-
-    override val size = delegate!!.size
-
-    override val elements = delegate!!.toImmutableList()
+    override fun promote(): BagValue<T> = BagValueImpl(delegate!!, annotations)
 
     override fun copy(annotations: Annotations) = NullableBagValueImpl(delegate, annotations.toPersistentList())
 
@@ -424,18 +408,9 @@ internal data class NullableListValueImpl<T : PartiQLValue>(
     private val delegate: PersistentList<T>?,
     override val annotations: PersistentList<String>,
 ) : NullableListValue<T>() {
+    override fun isNull() = delegate == null
 
-    override fun contains(element: T) = delegate!!.contains(element)
-
-    override fun containsAll(elements: Collection<T>) = delegate!!.containsAll(elements)
-
-    override fun isEmpty() = delegate!!.isEmpty()
-
-    override fun iterator() = delegate!!.iterator()
-
-    override val size = delegate!!.size
-
-    override val elements = delegate!!.toImmutableList()
+    override fun promote() = ListValueImpl(delegate!!, annotations)
 
     override fun copy(annotations: Annotations) = NullableListValueImpl(delegate, annotations.toPersistentList())
 
@@ -451,17 +426,9 @@ internal data class NullableSexpValueImpl<T : PartiQLValue>(
     override val annotations: PersistentList<String>,
 ) : NullableSexpValue<T>() {
 
-    override fun contains(element: T) = delegate!!.contains(element)
-
-    override fun containsAll(elements: Collection<T>) = delegate!!.containsAll(elements)
-
-    override fun isEmpty() = delegate!!.isEmpty()
-
-    override fun iterator() = delegate!!.iterator()
-
-    override val size = delegate!!.size
+    override fun isNull(): Boolean = delegate == null
 
-    override val elements = delegate!!.toImmutableList()
+    override fun promote() = SexpValueImpl(delegate!!, annotations)
 
     override fun copy(annotations: Annotations) = NullableSexpValueImpl(delegate, annotations.toPersistentList())
 
@@ -476,18 +443,9 @@ internal data class NullableStructValueImpl<T : PartiQLValue>(
     private val values: PersistentList<Pair<String, T>>?,
     override val annotations: PersistentList<String>,
 ) : NullableStructValue<T>() {
+    override fun isNull(): Boolean = values == null
 
-    override val fields = values!!.toImmutableList()
-
-    override val size = values!!.size
-
-    override fun isEmpty() = values!!.isEmpty()
-
-    override fun iterator(): Iterator<Pair<String, T>> = values!!.iterator()
-
-    override fun containsAll(elements: Collection<Pair<String, T>>) = values!!.containsAll(elements)
-
-    override fun contains(element: Pair<String, T>) = values!!.contains(element)
+    override fun promote() = StructValueImpl(values!!, annotations)
 
     override fun copy(annotations: Annotations) = NullableStructValueImpl(values, annotations.toPersistentList())
 
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueIonReader.kt b/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueIonReader.kt
new file mode 100644
index 0000000000..cb405729bc
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueIonReader.kt
@@ -0,0 +1,651 @@
+package org.partiql.value.io
+
+import com.amazon.ion.IonReader
+import com.amazon.ion.IonType
+import com.amazon.ion.system.IonReaderBuilder
+import org.partiql.types.PartiQLValueType
+import org.partiql.value.DecimalValue
+import org.partiql.value.IntValue
+import org.partiql.value.NullableIntValue
+import org.partiql.value.PartiQLValue
+import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.bagValue
+import org.partiql.value.blobValue
+import org.partiql.value.boolValue
+import org.partiql.value.clobValue
+import org.partiql.value.dateValue
+import org.partiql.value.datetime.DateTimeValue
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.decimalValue
+import org.partiql.value.float64Value
+import org.partiql.value.intValue
+import org.partiql.value.listValue
+import org.partiql.value.missingValue
+import org.partiql.value.nullValue
+import org.partiql.value.nullableBagValue
+import org.partiql.value.nullableBlobValue
+import org.partiql.value.nullableBoolValue
+import org.partiql.value.nullableClobValue
+import org.partiql.value.nullableDateValue
+import org.partiql.value.nullableDecimalValue
+import org.partiql.value.nullableFloat64Value
+import org.partiql.value.nullableIntValue
+import org.partiql.value.nullableListValue
+import org.partiql.value.nullableSexpValue
+import org.partiql.value.nullableStringValue
+import org.partiql.value.nullableStructValue
+import org.partiql.value.nullableSymbolValue
+import org.partiql.value.nullableTimeValue
+import org.partiql.value.nullableTimestampValue
+import org.partiql.value.sexpValue
+import org.partiql.value.stringValue
+import org.partiql.value.structValue
+import org.partiql.value.symbolValue
+import org.partiql.value.timeValue
+import org.partiql.value.timestampValue
+import java.io.IOException
+import java.io.InputStream
+import java.math.BigDecimal
+
+/**
+ * Make an arbitrary call on partiql value read
+ * PartiQL generated annotation must be closed to the value
+ *
+ * For example:
+ * In `IonForPartiQL` mode: if the input is $time::$day::$time{...}
+ * The reader will attempt to create a time value
+ *
+ */
+@OptIn(PartiQLValueExperimental::class)
+internal class PartiQLValueIonReader(
+    private val ionReader: IonReader,
+    private val sourceDataFormat: PartiQLValueIonReaderBuilder.SourceDataFormat
+) : PartiQLValueReader {
+    private enum class PARTIQL_ANNOTATION(val annotation: String) {
+        MISSING_ANNOTATION("\$missing"),
+        BAG_ANNOTATION("\$bag"),
+        DATE_ANNOTATION("\$date"),
+        TIME_ANNOTATION("\$time"),
+        TIMESTAMP_ANNOTATION("\$timestamp"),
+        GRAPH_ANNOTATION("\$graph")
+    }
+
+    @Throws(IOException::class)
+    override fun read(): PartiQLValue {
+        val value = if (ionReader.next() != null) {
+            fromIon(ionReader)
+        } else {
+            throw IOException("End of File.")
+        }
+        return value
+    }
+
+    override fun close() {
+        ionReader.close()
+    }
+
+    private fun fromIon(reader: IonReader): PartiQLValue =
+        when (sourceDataFormat) {
+            PartiQLValueIonReaderBuilder.SourceDataFormat.IonGeneric -> fromIonGeneric(reader)
+            PartiQLValueIonReaderBuilder.SourceDataFormat.IonForPartiQL -> fromIonForPartiQL(reader)
+        }
+
+    private fun fromIonGeneric(reader: IonReader): PartiQLValue =
+        when (reader.type) {
+            IonType.NULL -> {
+                nullValue(reader.typeAnnotations.toList())
+            }
+
+            IonType.BOOL -> {
+                if (reader.isNullValue) {
+                    nullableBoolValue(null, reader.typeAnnotations.toList())
+                } else {
+                    boolValue(reader.booleanValue(), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.INT -> {
+                if (reader.isNullValue) {
+                    nullableIntValue(null, reader.typeAnnotations.toList())
+                } else {
+                    intValue(reader.bigIntegerValue(), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.FLOAT -> {
+                if (reader.isNullValue) {
+                    nullableFloat64Value(null, reader.typeAnnotations.toList())
+                } else {
+                    float64Value(reader.doubleValue(), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.DECIMAL -> {
+                if (reader.isNullValue) {
+                    nullableDecimalValue(null, reader.typeAnnotations.toList())
+                } else {
+                    decimalValue(reader.bigDecimalValue(), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.TIMESTAMP -> {
+                if (reader.isNullValue) {
+                    nullableTimestampValue(null, reader.typeAnnotations.toList())
+                } else {
+                    timestampValue(DateTimeValue.timestamp(reader.timestampValue()), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.SYMBOL -> {
+                if (reader.isNullValue) {
+                    nullableSymbolValue(null, reader.typeAnnotations.toList())
+                } else {
+                    symbolValue(reader.stringValue(), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.STRING -> {
+                if (reader.isNullValue) {
+                    nullableStringValue(null, reader.typeAnnotations.toList())
+                } else {
+                    stringValue(reader.stringValue(), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.CLOB -> {
+                if (reader.isNullValue) {
+                    nullableClobValue(null, reader.typeAnnotations.toList())
+                } else {
+                    clobValue(reader.newBytes(), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.BLOB -> {
+                if (reader.isNullValue) {
+                    nullableBlobValue(null, reader.typeAnnotations.toList())
+                } else {
+                    blobValue(reader.newBytes(), reader.typeAnnotations.toList())
+                }
+            }
+
+            IonType.LIST -> {
+                val annotations = reader.typeAnnotations.toList()
+                reader.stepIn()
+                val elements = mutableListOf<PartiQLValue>().also { elements ->
+                    reader.loadEachValue {
+                        elements.add(fromIon(reader))
+                    }
+                }
+                reader.stepOut()
+                listValue(elements.toList(), annotations)
+            }
+
+            IonType.SEXP -> {
+                val annotation = reader.typeAnnotations.toList()
+                reader.stepIn()
+                val elements = mutableListOf<PartiQLValue>().also { elements ->
+                    reader.loadEachValue {
+                        elements.add(fromIon(reader))
+                    }
+                }
+                reader.stepOut()
+                sexpValue(elements.toList(), annotation)
+            }
+
+            IonType.STRUCT -> {
+                val annotations = reader.typeAnnotations.toList()
+                reader.stepIn()
+                val elements = mutableListOf<Pair<String, PartiQLValue>>().also { elements ->
+                    reader.loadEachValue {
+                        val element = reader.fieldName to fromIon(reader)
+                        elements.add(element)
+                    }
+                }
+                reader.stepOut()
+                structValue(elements.toList(), annotations)
+            }
+
+            IonType.DATAGRAM -> throw IllegalArgumentException("Datagram not supported")
+        }
+
+    // We have to check if an inappropriate annotation exists
+    // for example: $missing::1
+    // this makes the code not very easy to maintain as we potentially can add more reserved annotation
+    // I made the deliberate decision to list out all branches so we don't accidentally forget one in the future...
+    private fun fromIonForPartiQL(reader: IonReader): PartiQLValue {
+        val annotations = reader.typeAnnotations.toList()
+        val lastAnnotation = getPartiQLReservedAnnotation(annotations)
+        return when (reader.type) {
+            IonType.NULL -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> missingValue(annotations.dropLast(1))
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> nullableBagValue<PartiQLValue>(null, annotations.dropLast(1))
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> nullableDateValue(null, annotations.dropLast(1))
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> nullableTimeValue(null, annotations.dropLast(1))
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> nullableTimestampValue(null, annotations.dropLast(1))
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> TODO("Graph not yet implemented")
+                    null -> nullValue(annotations)
+                }
+            }
+
+            IonType.BOOL -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Bool Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Bool Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Bool Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Bool Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Bool Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with Bool Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableBoolValue(null, annotations)
+                        } else {
+                            boolValue(reader.booleanValue(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.INT -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Int Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Int Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Int Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Int Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Int Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with Int Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableIntValue(null, annotations)
+                        } else {
+                            intValue(reader.bigIntegerValue(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.FLOAT -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Float Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Float Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Float Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Float Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Float Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with Float Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableFloat64Value(null, annotations)
+                        } else {
+                            float64Value(reader.doubleValue(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.DECIMAL -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Decimal Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Decimal Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Decimal Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Decimal Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Decimal Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with Decimal Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableDecimalValue(null, annotations)
+                        } else {
+                            decimalValue(reader.bigDecimalValue(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.TIMESTAMP -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Timestamp Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Timestamp Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Timestamp Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Timestamp Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Timestamp Value, we except Timestamp annotation to be used with Ion Struct")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with Timestamp Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableTimestampValue(null, annotations)
+                        } else {
+                            timestampValue(DateTimeValue.timestamp(reader.timestampValue()), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.SYMBOL -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Symbol Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Symbol Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Symbol Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Symbol Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Symbol Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with Symbol Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableSymbolValue(null, annotations)
+                        } else {
+                            symbolValue(reader.stringValue(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.STRING -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with String Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with String Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with String Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with String Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with String Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with String Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableStringValue(null, annotations)
+                        } else {
+                            stringValue(reader.stringValue(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.CLOB -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Clob Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Clob Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Clob Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Clob Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Clob Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with Clob Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableClobValue(null, annotations)
+                        } else {
+                            clobValue(reader.newBytes(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.BLOB -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Blob Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Blob Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Blob Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Blob Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Blob Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> throw IllegalArgumentException("GRAPH_ANNOTATION with Blob Value")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableBlobValue(null, annotations)
+                        } else {
+                            blobValue(reader.newBytes(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.LIST -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with List Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> {
+                        if (reader.isNullValue) {
+                            nullableBagValue<PartiQLValue>(null, annotations.dropLast(1))
+                        } else {
+                            reader.stepIn()
+                            val elements = mutableListOf<PartiQLValue>().also { elements ->
+                                reader.loadEachValue {
+                                    elements.add(fromIon(reader))
+                                }
+                            }
+                            reader.stepOut()
+                            bagValue(elements.toList(), annotations.dropLast(1))
+                        }
+                    }
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with List Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with List Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with List Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> TODO("Not yet implemented")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableListValue<PartiQLValue>(null, annotations)
+                        } else {
+                            reader.stepIn()
+                            val elements = mutableListOf<PartiQLValue>().also { elements ->
+                                reader.loadEachValue {
+                                    elements.add(fromIon(reader))
+                                }
+                            }
+                            reader.stepOut()
+                            listValue(elements.toList(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.SEXP -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Sexp Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Sexp Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> throw IllegalArgumentException("DATE_ANNOTATION with Sexp Value")
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> throw IllegalArgumentException("TIME_ANNOTATION with Sexp Value")
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> throw IllegalArgumentException("TIMESTAMP_ANNOTATION with Sexp Value")
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> TODO("Not yet implemented")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableSexpValue<PartiQLValue>(null, annotations)
+                        } else {
+                            reader.stepIn()
+                            val elements = mutableListOf<PartiQLValue>().also { elements ->
+                                reader.loadEachValue {
+                                    elements.add(fromIon(reader))
+                                }
+                            }
+                            reader.stepOut()
+                            sexpValue(elements.toList(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.STRUCT -> {
+                when (lastAnnotation) {
+                    PARTIQL_ANNOTATION.MISSING_ANNOTATION -> throw IllegalArgumentException("MISSING_ANNOTATION with Struct Value")
+                    PARTIQL_ANNOTATION.BAG_ANNOTATION -> throw IllegalArgumentException("BAG_ANNOTATION with Struct Value")
+                    PARTIQL_ANNOTATION.DATE_ANNOTATION -> {
+                        if (reader.isNullValue) {
+                            nullableDateValue(null, annotations.dropLast(1))
+                        } else {
+                            reader.stepIn()
+                            val map = mutableMapOf<String, Any?>()
+                            checkRequiredFieldNameAndPut(reader, map, "year", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "month", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "day", PartiQLValueType.INT)
+                            if (reader.next() != null) {
+                                throw IllegalArgumentException("excess field in struct")
+                            }
+                            reader.stepOut()
+                            dateValue(DateTimeValue.date(map["year"] as Int, map["month"] as Int, map["day"] as Int), annotations.dropLast(1))
+                        }
+                    }
+                    PARTIQL_ANNOTATION.TIME_ANNOTATION -> {
+                        if (reader.isNullValue) {
+                            nullableTimeValue(null, annotations.dropLast(1))
+                        } else {
+                            reader.stepIn()
+                            val map = mutableMapOf<String, Any?>()
+                            checkRequiredFieldNameAndPut(reader, map, "hour", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "minute", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "second", PartiQLValueType.DECIMAL)
+                            checkOptionalFieldNameAndPut(reader, map, "offset", PartiQLValueType.NULLABLE_INT)
+                            // check remaining
+                            if (reader.next() != null) {
+                                throw IllegalArgumentException("excess field in struct")
+                            }
+                            reader.stepOut()
+                            val offset = if (!map.containsKey("offset")) {
+                                null
+                            } else if (map["offset"] == null) {
+                                TimeZone.UnknownTimeZone
+                            } else {
+                                TimeZone.UtcOffset.of(map["offset"] as Int)
+                            }
+                            timeValue(
+                                DateTimeValue.time(
+                                    map["hour"] as Int, map["minute"] as Int, map["second"] as BigDecimal,
+                                    offset
+                                ),
+                                annotations.dropLast(1)
+                            )
+                        }
+                    }
+                    PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> {
+                        if (reader.isNullValue) {
+                            nullableTimestampValue(null, annotations.dropLast(1))
+                        } else {
+                            reader.stepIn()
+                            val map = mutableMapOf<String, Any?>()
+                            // check fields
+                            checkRequiredFieldNameAndPut(reader, map, "year", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "month", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "day", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "hour", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "minute", PartiQLValueType.INT)
+                            checkRequiredFieldNameAndPut(reader, map, "second", PartiQLValueType.DECIMAL)
+                            // check remaining
+                            if (reader.next() != null) {
+                                throw IllegalArgumentException("excess field in struct")
+                            }
+                            reader.stepOut()
+                            timestampValue(
+                                DateTimeValue.timestamp(
+                                    map["year"] as Int, map["month"] as Int, map["day"] as Int,
+                                    map["hour"] as Int, map["minute"] as Int, map["second"] as BigDecimal,
+                                    null
+                                ),
+                                annotations.dropLast(1)
+                            )
+                        }
+                    }
+                    PARTIQL_ANNOTATION.GRAPH_ANNOTATION -> TODO("Not yet implemented")
+                    null -> {
+                        if (reader.isNullValue) {
+                            nullableStructValue<PartiQLValue>(null, annotations)
+                        } else {
+                            reader.stepIn()
+                            val elements = mutableListOf<Pair<String, PartiQLValue>>().also { elements ->
+                                reader.loadEachValue {
+                                    val element = reader.fieldName to fromIon(reader)
+                                    elements.add(element)
+                                }
+                            }
+                            reader.stepOut()
+                            structValue(elements.toList(), annotations)
+                        }
+                    }
+                }
+            }
+
+            IonType.DATAGRAM -> throw IllegalArgumentException("Datagram not supported")
+        }
+    }
+
+    private fun <T> IonReader.loadEachValue(block: () -> T) {
+        while (this.next() != null) {
+            block()
+        }
+    }
+
+    private fun getPartiQLReservedAnnotation(partiqlAnnotation: List<String>) =
+        partiqlAnnotation.lastOrNull()?.let { lastAnnotation ->
+            PARTIQL_ANNOTATION.values().find { it.annotation == lastAnnotation }
+        }
+
+    private fun checkRequiredFieldNameAndPut(reader: IonReader, destination: MutableMap<String, Any?>, expectedField: String, expectedType: PartiQLValueType) {
+        if (reader.next() == null) {
+            throw IllegalArgumentException("missing $expectedField field")
+        }
+        if (reader.fieldName == expectedField) {
+            checkAndPut(reader, destination, expectedField, expectedType)
+        }
+    }
+
+    private fun checkOptionalFieldNameAndPut(reader: IonReader, destination: MutableMap<String, Any?>, expectedField: String, expectedType: PartiQLValueType) {
+        if (reader.next() != null) {
+            checkAndPut(reader, destination, expectedField, expectedType)
+        }
+    }
+
+    private fun checkAndPut(reader: IonReader, destination: MutableMap<String, Any?>, expectedField: String, expectedType: PartiQLValueType) {
+        if (reader.fieldName == expectedField) {
+            val k = reader.fieldName
+            val v = fromIon(reader)
+            when (expectedType) {
+                PartiQLValueType.INT -> destination[k] = (v as IntValue).value.intValueExact()
+                PartiQLValueType.DECIMAL -> destination[k] = (v as DecimalValue).value
+                PartiQLValueType.NULLABLE_INT -> {
+                    when (v.type) {
+                        PartiQLValueType.INT -> destination[k] = (v as IntValue).value.intValueExact()
+                        PartiQLValueType.NULLABLE_INT -> destination[k] = (v as NullableIntValue).value?.intValueExact()
+                        else -> throw IllegalArgumentException("expect $expectedField to have type of INT or NULL")
+                    }
+                }
+                else -> throw IllegalArgumentException("$expectedField should be either INT OR DECIMAL")
+            }
+        } else {
+            throw IllegalArgumentException("expect $expectedField, but received ${reader.fieldName}")
+        }
+    }
+}
+
+@OptIn(PartiQLValueExperimental::class)
+public class PartiQLValueIonReaderBuilder private constructor(
+    private var sourceDataFormat: SourceDataFormat = SourceDataFormat.IonForPartiQL,
+    private var ionReaderBuilder: IonReaderBuilder,
+) {
+    public enum class SourceDataFormat {
+        /**
+         * The ion value annotations are always treated as annotations on PartiQL value.
+         * For example, $missing::null will be treated as nullValue(annotations = ["missing"])
+         */
+        IonGeneric,
+
+        /**
+         * We examine the **last** annotation before convert to PartiQL Value.
+         * If the annotation is PartiQL reserved, we validate Semantics and the constructed PartiQL value may be different.
+         * For example:
+         *   - $missing::null will be treated as missingValue(annotations = [])
+         *   - a::b::$missing:null will be treated as missingValue(annotations = ["a", "b"])
+         *   - a::$missing::b::null will be treated as nullValue(annotation = ["a", "$missing", "b"]
+         *   - $missing::1 will cause an exception.
+         */
+        IonForPartiQL
+    }
+
+    public companion object {
+        @JvmStatic
+        public fun standard(): PartiQLValueIonReaderBuilder = PartiQLValueIonReaderBuilder(
+            sourceDataFormat = SourceDataFormat.IonForPartiQL,
+            ionReaderBuilder = IonReaderBuilder.standard()
+        )
+    }
+
+    public fun build(inputStream: InputStream): PartiQLValueReader =
+        PartiQLValueIonReader(
+            ionReader = ionReaderBuilder.build(inputStream),
+            sourceDataFormat = sourceDataFormat
+        )
+
+    public fun sourceDataFormat(sourceDataFormat: SourceDataFormat): PartiQLValueIonReaderBuilder = this.apply {
+        this.sourceDataFormat = sourceDataFormat
+    }
+
+    public fun ionReaderBuilder(ionReaderBuilder: IonReaderBuilder): PartiQLValueIonReaderBuilder = this.apply {
+        this.ionReaderBuilder = ionReaderBuilder
+    }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueIonWriter.kt b/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueIonWriter.kt
new file mode 100644
index 0000000000..787da3e3db
--- /dev/null
+++ b/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueIonWriter.kt
@@ -0,0 +1,414 @@
+package org.partiql.value.io
+
+import com.amazon.ion.Decimal
+import com.amazon.ion.IonWriter
+import com.amazon.ion.system.IonBinaryWriterBuilder
+import com.amazon.ion.system.IonTextWriterBuilder
+import com.amazon.ion.system.IonWriterBuilder
+import com.amazon.ionelement.api.ElementType
+import com.amazon.ionelement.api.IonElement
+import com.amazon.ionelement.api.field
+import com.amazon.ionelement.api.ionBlob
+import com.amazon.ionelement.api.ionBool
+import com.amazon.ionelement.api.ionClob
+import com.amazon.ionelement.api.ionDecimal
+import com.amazon.ionelement.api.ionFloat
+import com.amazon.ionelement.api.ionInt
+import com.amazon.ionelement.api.ionListOf
+import com.amazon.ionelement.api.ionNull
+import com.amazon.ionelement.api.ionSexpOf
+import com.amazon.ionelement.api.ionString
+import com.amazon.ionelement.api.ionStructOf
+import com.amazon.ionelement.api.ionSymbol
+import com.amazon.ionelement.api.ionTimestamp
+import org.partiql.value.BagValue
+import org.partiql.value.BinaryValue
+import org.partiql.value.BlobValue
+import org.partiql.value.BoolValue
+import org.partiql.value.ByteValue
+import org.partiql.value.CharValue
+import org.partiql.value.ClobValue
+import org.partiql.value.CollectionValue
+import org.partiql.value.DateValue
+import org.partiql.value.DecimalValue
+import org.partiql.value.Float32Value
+import org.partiql.value.Float64Value
+import org.partiql.value.Int16Value
+import org.partiql.value.Int32Value
+import org.partiql.value.Int64Value
+import org.partiql.value.Int8Value
+import org.partiql.value.IntValue
+import org.partiql.value.IntervalValue
+import org.partiql.value.ListValue
+import org.partiql.value.MissingValue
+import org.partiql.value.NullValue
+import org.partiql.value.NullableBagValue
+import org.partiql.value.NullableBinaryValue
+import org.partiql.value.NullableBlobValue
+import org.partiql.value.NullableBoolValue
+import org.partiql.value.NullableByteValue
+import org.partiql.value.NullableCharValue
+import org.partiql.value.NullableClobValue
+import org.partiql.value.NullableDateValue
+import org.partiql.value.NullableDecimalValue
+import org.partiql.value.NullableFloat32Value
+import org.partiql.value.NullableFloat64Value
+import org.partiql.value.NullableInt16Value
+import org.partiql.value.NullableInt32Value
+import org.partiql.value.NullableInt64Value
+import org.partiql.value.NullableInt8Value
+import org.partiql.value.NullableIntValue
+import org.partiql.value.NullableIntervalValue
+import org.partiql.value.NullableListValue
+import org.partiql.value.NullableScalarValue
+import org.partiql.value.NullableSexpValue
+import org.partiql.value.NullableStringValue
+import org.partiql.value.NullableStructValue
+import org.partiql.value.NullableSymbolValue
+import org.partiql.value.NullableTimeValue
+import org.partiql.value.NullableTimestampValue
+import org.partiql.value.PartiQLValue
+import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.ScalarValue
+import org.partiql.value.SexpValue
+import org.partiql.value.StringValue
+import org.partiql.value.StructValue
+import org.partiql.value.SymbolValue
+import org.partiql.value.TimeValue
+import org.partiql.value.TimestampValue
+import org.partiql.value.binaryValue
+import org.partiql.value.blobValue
+import org.partiql.value.boolValue
+import org.partiql.value.byteValue
+import org.partiql.value.charValue
+import org.partiql.value.clobValue
+import org.partiql.value.dateValue
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.TimestampWithTimeZone
+import org.partiql.value.datetime.TimestampWithoutTimeZone
+import org.partiql.value.decimalValue
+import org.partiql.value.float32Value
+import org.partiql.value.float64Value
+import org.partiql.value.int16Value
+import org.partiql.value.int32Value
+import org.partiql.value.int64Value
+import org.partiql.value.int8Value
+import org.partiql.value.intValue
+import org.partiql.value.io.PartiQLValueIonWriter.ToIon.toIon
+import org.partiql.value.stringValue
+import org.partiql.value.symbolValue
+import org.partiql.value.timeValue
+import org.partiql.value.timestampValue
+import org.partiql.value.util.PartiQLValueBaseVisitor
+import java.io.OutputStream
+
+@OptIn(PartiQLValueExperimental::class)
+internal class PartiQLValueIonWriter(
+    private val ionWriter: IonWriter,
+) : PartiQLValueWriter {
+
+    companion object {
+        const val MISSING_ANNOTATION = "\$missing"
+        const val BAG_ANNOTATION = "\$bag"
+        const val DATE_ANNOTATION = "\$date"
+        const val TIME_ANNOTATION = "\$time"
+        // PartiQL's timestamp without time zone does not fit in ion generic timestamp
+        const val TIMESTAMP_ANNOTATION = "\$timestamp"
+        const val GRAPH_ANNOTATION = "\$graph"
+    }
+
+    override fun append(value: PartiQLValue): PartiQLValueWriter {
+        ToIon.visit(value, Unit).writeTo(ionWriter)
+        return this
+    }
+
+    override fun close() {
+        ionWriter.close()
+    }
+
+    private object ToIon : PartiQLValueBaseVisitor<IonElement, Unit>() {
+
+        override fun defaultVisit(v: PartiQLValue, ctx: Unit) = defaultReturn(v, ctx)
+
+        override fun defaultReturn(v: PartiQLValue, ctx: Unit): Nothing =
+            throw IllegalArgumentException("Cannot represent $v as Ion")
+
+        private inline fun <T> ScalarValue<T>.toIon(block: ScalarValue<T>.() -> IonElement): IonElement {
+            val e = this.block()
+            return e.withAnnotations(this.annotations)
+        }
+
+        private inline fun <T> NullableScalarValue<T>.toIon(block: NullableScalarValue<T>.() -> IonElement): IonElement {
+            val e = this.block()
+            return e.withAnnotations(this.annotations)
+        }
+
+        private inline fun CollectionValue<*>.toIon(block: CollectionValue<*>.(elements: List<IonElement>) -> IonElement): IonElement {
+            val elements = this.elements.map { it.accept(ToIon, Unit) }
+            val e = this.block(elements)
+            return e.withAnnotations(this.annotations)
+        }
+
+        override fun visitNull(v: NullValue, ctx: Unit): IonElement = ionNull().withAnnotations(v.annotations)
+
+        override fun visitMissing(v: MissingValue, ctx: Unit): IonElement = ionNull().withAnnotations(
+            v.annotations + listOf(
+                MISSING_ANNOTATION
+            )
+        )
+
+        override fun visitBool(v: BoolValue, ctx: Unit): IonElement = v.toIon { ionBool(value) }
+
+        override fun visitNullableBool(v: NullableBoolValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.BOOL) }
+            else -> visitBool(boolValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitInt8(v: Int8Value, ctx: Unit): IonElement = v.toIon { ionInt(value.toLong()) }
+
+        override fun visitNullableInt8(v: NullableInt8Value, ctx: Unit): IonElement = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.INT) }
+            else -> visitInt8(int8Value(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitInt16(v: Int16Value, ctx: Unit): IonElement = v.toIon { ionInt(value.toLong()) }
+
+        override fun visitNullableInt16(v: NullableInt16Value, ctx: Unit): IonElement = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.INT) }
+            else -> visitInt16(int16Value(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitInt32(v: Int32Value, ctx: Unit): IonElement = v.toIon { ionInt(value.toLong()) }
+
+        override fun visitNullableInt32(v: NullableInt32Value, ctx: Unit): IonElement = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.INT) }
+            else -> visitInt32(int32Value(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitInt64(v: Int64Value, ctx: Unit): IonElement = v.toIon { ionInt(value) }
+
+        override fun visitNullableInt64(v: NullableInt64Value, ctx: Unit): IonElement = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.INT) }
+            else -> visitInt64(int64Value(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitInt(v: IntValue, ctx: Unit): IonElement = v.toIon { ionInt(value.toLong()) }
+
+        override fun visitNullableInt(v: NullableIntValue, ctx: Unit): IonElement = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.INT) }
+            else -> visitInt(intValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitDecimal(v: DecimalValue, ctx: Unit): IonElement =
+            v.toIon { ionDecimal(Decimal.valueOf(value)) }
+
+        override fun visitNullableDecimal(v: NullableDecimalValue, ctx: Unit): IonElement = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.DECIMAL) }
+            else -> visitDecimal(decimalValue(v.value!!, v.annotations), ctx)
+        }
+
+        // TODO : This is wrong. Ion float is 64 bit, when we cast the 32 bit float to double, we deliver false promise
+        override fun visitFloat32(v: Float32Value, ctx: Unit): IonElement =
+            v.toIon { ionFloat(value.toString().toDouble()) }
+
+        override fun visitNullableFloat32(v: NullableFloat32Value, ctx: Unit): IonElement = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.FLOAT) }
+
+            else -> visitFloat32(float32Value(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitFloat64(v: Float64Value, ctx: Unit): IonElement = v.toIon { ionFloat(value) }
+
+        override fun visitNullableFloat64(v: NullableFloat64Value, ctx: Unit): IonElement = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.FLOAT) }
+            else -> visitFloat64(float64Value(v.value!!, v.annotations), ctx)
+        }
+
+        // TODO: Revisit
+        override fun visitChar(v: CharValue, ctx: Unit): IonElement = v.toIon { ionString(value.toString()) }
+
+        override fun visitNullableChar(v: NullableCharValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.STRING) }
+            else -> visitChar(charValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitString(v: StringValue, ctx: Unit): IonElement = v.toIon { ionString(value) }
+
+        override fun visitNullableString(v: NullableStringValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.STRING) }
+            else -> visitString(stringValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitSymbol(v: SymbolValue, ctx: Unit): IonElement = v.toIon { ionSymbol(value) }
+
+        override fun visitNullableSymbol(v: NullableSymbolValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.SYMBOL) }
+            else -> visitSymbol(symbolValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitClob(v: ClobValue, ctx: Unit): IonElement = v.toIon { ionClob(value) }
+
+        override fun visitNullableClob(v: NullableClobValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.CLOB) }
+            else -> visitClob(clobValue(v.value!!, v.annotations), ctx)
+        }
+
+        // TODO: Revisit
+        override fun visitBinary(v: BinaryValue, ctx: Unit): IonElement = v.toIon { ionBlob(value.toByteArray()) }
+
+        override fun visitNullableBinary(v: NullableBinaryValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.BLOB) }
+            else -> visitBinary(binaryValue(v.value!!, v.annotations), ctx)
+        }
+
+        // TODO: Revisit
+        override fun visitByte(v: ByteValue, ctx: Unit): IonElement = v.toIon { ionBlob(ByteArray(1) { value }) }
+
+        override fun visitNullableByte(v: NullableByteValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.BLOB) }
+            else -> visitByte(byteValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitBlob(v: BlobValue, ctx: Unit): IonElement = v.toIon { ionBlob(v.value) }
+
+        override fun visitNullableBlob(v: NullableBlobValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.BLOB) }
+            else -> visitBlob(blobValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitDate(v: DateValue, ctx: Unit): IonElement = v.toIon {
+            val date = v.value
+            ionStructOf(
+                field("year", ionInt(date.year.toLong())),
+                field("month", ionInt(date.month.toLong())),
+                field("day", ionInt(date.day.toLong()))
+            )
+        }.withAnnotations(DATE_ANNOTATION)
+
+        override fun visitNullableDate(v: NullableDateValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.STRUCT) }.withAnnotations(DATE_ANNOTATION)
+            else -> visitDate(dateValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitTime(v: TimeValue, ctx: Unit): IonElement =
+            v.toIon {
+                when (val timeZone = v.value.timeZone) {
+                    TimeZone.UnknownTimeZone ->
+                        ionStructOf(
+                            field("hour", ionInt(v.value.hour.toLong())),
+                            field("minute", ionInt(v.value.minute.toLong())),
+                            field("second", ionDecimal(Decimal.valueOf(v.value.decimalSecond))),
+                            field("offset", ionNull(ElementType.INT)),
+                        )
+                    is TimeZone.UtcOffset ->
+                        ionStructOf(
+                            field("hour", ionInt(v.value.hour.toLong())),
+                            field("minute", ionInt(v.value.minute.toLong())),
+                            field("second", ionDecimal(Decimal.valueOf(v.value.decimalSecond))),
+                            field("offset", ionInt(timeZone.totalOffsetMinutes.toLong()))
+                        )
+                    null ->
+                        ionStructOf(
+                            field("hour", ionInt(v.value.hour.toLong())),
+                            field("minute", ionInt(v.value.minute.toLong())),
+                            field("second", ionDecimal(Decimal.valueOf(v.value.decimalSecond)))
+                        )
+                }
+            }.withAnnotations(TIME_ANNOTATION)
+
+        override fun visitNullableTime(v: NullableTimeValue, ctx: Unit) = when (v.value) {
+            null -> v.toIon { ionNull(ElementType.STRUCT) }.withAnnotations(TIME_ANNOTATION)
+            else -> visitTime(timeValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitTimestamp(v: TimestampValue, ctx: Unit): IonElement =
+            when (val timestamp = v.value) {
+                is TimestampWithTimeZone -> v.toIon { ionTimestamp(timestamp.ionTimestampValue) }
+                is TimestampWithoutTimeZone -> v.toIon {
+                    ionStructOf(
+                        field("year", ionInt(timestamp.year.toLong())),
+                        field("month", ionInt(timestamp.month.toLong())),
+                        field("day", ionInt(timestamp.day.toLong())),
+                        field("hour", ionInt(timestamp.hour.toLong())),
+                        field("minute", ionInt(timestamp.minute.toLong())),
+                        field("second", ionDecimal(Decimal.valueOf(timestamp.decimalSecond)))
+                    )
+                }.withAnnotations(TIMESTAMP_ANNOTATION)
+            }
+
+        override fun visitNullableTimestamp(v: NullableTimestampValue, ctx: Unit) = when (v.value) {
+            // TODO: we actually don't know if this is a timestamp with timezone or timestamp without timezone
+            //  Should we care?
+            null -> v.toIon { ionNull(ElementType.TIMESTAMP) }
+            else -> visitTimestamp(timestampValue(v.value!!, v.annotations), ctx)
+        }
+
+        override fun visitInterval(v: IntervalValue, ctx: Unit): IonElement = TODO("Not Yet supported")
+
+        override fun visitNullableInterval(v: NullableIntervalValue, ctx: Unit) = TODO("Not yet supported")
+
+        override fun visitBag(v: BagValue<*>, ctx: Unit): IonElement =
+            v.toIon { elements -> ionListOf(elements) }.withAnnotations(BAG_ANNOTATION)
+
+        override fun visitNullableBag(v: NullableBagValue<*>, ctx: Unit) = when (v.isNull()) {
+            true -> ionNull(ElementType.LIST).withAnnotations(v.annotations).withAnnotations(BAG_ANNOTATION)
+            false -> visitBag(v.promote(), ctx)
+        }
+
+        override fun visitList(v: ListValue<*>, ctx: Unit): IonElement = v.toIon { elements -> ionListOf(elements) }
+
+        override fun visitNullableList(v: NullableListValue<*>, ctx: Unit) = when (v.isNull()) {
+            true -> ionNull(ElementType.LIST).withAnnotations(v.annotations)
+            false -> visitList(v.promote(), ctx)
+        }
+
+        override fun visitSexp(v: SexpValue<*>, ctx: Unit): IonElement = v.toIon { elements -> ionSexpOf(elements) }
+
+        override fun visitNullableSexp(v: NullableSexpValue<*>, ctx: Unit) =
+            when (v.isNull()) {
+                true -> ionNull(ElementType.SEXP).withAnnotations(v.annotations)
+                false -> visitSexp(v.promote(), ctx)
+            }
+
+        override fun visitStruct(v: StructValue<*>, ctx: Unit): IonElement {
+            val fields = v.fields.map {
+                val k = it.first
+                val v = it.second.accept(this, ctx)
+                field(k, v)
+            }
+            return ionStructOf(fields, v.annotations)
+        }
+
+        override fun visitNullableStruct(v: NullableStructValue<*>, ctx: Unit): IonElement = when (v.isNull()) {
+            true -> ionNull(ElementType.STRUCT, v.annotations)
+            false -> visitStruct(v.promote(), ctx)
+        }
+    }
+}
+
+@OptIn(PartiQLValueExperimental::class)
+public class PartiQLValueIonWriterBuilder private constructor(
+    private var ionWriterBuilder: IonWriterBuilder,
+) {
+
+    public companion object {
+        @JvmStatic
+        public fun standardIonTextBuilder(): PartiQLValueIonWriterBuilder = PartiQLValueIonWriterBuilder(
+            ionWriterBuilder = IonTextWriterBuilder.standard()
+        )
+
+        @JvmStatic
+        public fun standardIonBinaryBuilder(): PartiQLValueIonWriterBuilder = PartiQLValueIonWriterBuilder(
+            ionWriterBuilder = IonBinaryWriterBuilder.standard()
+        )
+    }
+
+    public fun build(output: OutputStream): PartiQLValueWriter =
+        PartiQLValueIonWriter(
+            ionWriter = ionWriterBuilder.build(output),
+        )
+
+    public fun ionWriterBuilder(ionWriterBuilder: IonWriterBuilder): PartiQLValueIonWriterBuilder = this.apply {
+        this.ionWriterBuilder = ionWriterBuilder
+    }
+}
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueTextWriter.kt b/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueTextWriter.kt
index 802bf9a6ea..73dc8303da 100644
--- a/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueTextWriter.kt
+++ b/partiql-types/src/main/kotlin/org/partiql/value/io/PartiQLValueTextWriter.kt
@@ -51,7 +51,6 @@ import org.partiql.value.SexpValue
 import org.partiql.value.StringValue
 import org.partiql.value.StructValue
 import org.partiql.value.SymbolValue
-import org.partiql.value.bagValue
 import org.partiql.value.boolValue
 import org.partiql.value.charValue
 import org.partiql.value.decimalValue
@@ -62,10 +61,7 @@ import org.partiql.value.int32Value
 import org.partiql.value.int64Value
 import org.partiql.value.int8Value
 import org.partiql.value.intValue
-import org.partiql.value.listValue
-import org.partiql.value.sexpValue
 import org.partiql.value.stringValue
-import org.partiql.value.structValue
 import org.partiql.value.symbolValue
 import org.partiql.value.util.PartiQLValueBaseVisitor
 import java.io.PrintStream
@@ -295,24 +291,24 @@ internal class PartiQLValueTextWriter(
             else -> visitSymbol(symbolValue(v.value!!, v.annotations), ctx)
         }
 
-        override fun visitNullableBag(v: NullableBagValue<*>, ctx: Format?) = when (v.elements) {
-            null -> "null"
-            else -> visitBag(bagValue(v.elements!!.toList(), v.annotations), ctx)
+        override fun visitNullableBag(v: NullableBagValue<*>, ctx: Format?) = when (v.isNull()) {
+            true -> "null"
+            false -> visitBag(v.promote(), ctx)
         }
 
-        override fun visitNullableList(v: NullableListValue<*>, ctx: Format?) = when (v.elements) {
-            null -> "null"
-            else -> visitList(listValue(v.elements!!.toList(), v.annotations), ctx)
+        override fun visitNullableList(v: NullableListValue<*>, ctx: Format?) = when (v.isNull()) {
+            true -> "null"
+            false -> visitList(v.promote(), ctx)
         }
 
-        override fun visitNullableSexp(v: NullableSexpValue<*>, ctx: Format?) = when (v.elements) {
-            null -> "null"
-            else -> visitSexp(sexpValue(v.elements!!.toList(), v.annotations), ctx)
+        override fun visitNullableSexp(v: NullableSexpValue<*>, ctx: Format?) = when (v.isNull()) {
+            true -> "null"
+            false -> visitSexp(v.promote(), ctx)
         }
 
-        override fun visitNullableStruct(v: NullableStructValue<*>, ctx: Format?) = when (v.fields) {
-            null -> "null"
-            else -> visitStruct(structValue(v.fields!!.toList(), v.annotations), ctx)
+        override fun visitNullableStruct(v: NullableStructValue<*>, ctx: Format?) = when (v.isNull()) {
+            true -> "null"
+            false -> visitStruct(v.promote(), ctx)
         }
     }
 }
diff --git a/partiql-types/src/main/kotlin/org/partiql/value/util/PartiQLValueBaseVisitor.kt b/partiql-types/src/main/kotlin/org/partiql/value/util/PartiQLValueBaseVisitor.kt
index 78aa3cca3e..9938e7b1f9 100644
--- a/partiql-types/src/main/kotlin/org/partiql/value/util/PartiQLValueBaseVisitor.kt
+++ b/partiql-types/src/main/kotlin/org/partiql/value/util/PartiQLValueBaseVisitor.kt
@@ -87,10 +87,14 @@ public abstract class PartiQLValueBaseVisitor<R, C> : PartiQLValueVisitor<R, C>
                 v.fields.forEach { it.second.accept(this, ctx) }
             }
             is NullableCollectionValue<*> -> {
-                v.elements?.forEach { it.accept(this, ctx) }
+                if (!v.isNull()) {
+                    v.promote().elements.forEach { it.accept(this, ctx) }
+                }
             }
             is NullableStructValue<*> -> {
-                v.fields?.forEach { it.second.accept(this, ctx) }
+                if (!v.isNull()) {
+                    v.promote().fields.forEach { it.second.accept(this, ctx) }
+                }
             }
             else -> {}
         }
diff --git a/partiql-types/src/test/kotlin/org/partiql/datetime/TimestampTest.kt b/partiql-types/src/test/kotlin/org/partiql/datetime/TimestampTest.kt
new file mode 100644
index 0000000000..f005c52a26
--- /dev/null
+++ b/partiql-types/src/test/kotlin/org/partiql/datetime/TimestampTest.kt
@@ -0,0 +1,915 @@
+package org.partiql.datetime
+
+import com.amazon.ionelement.api.ionTimestamp
+import org.junit.jupiter.api.assertThrows
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
+import org.partiql.value.datetime.DateTimeException
+import org.partiql.value.datetime.DateTimeValue
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.Timestamp
+import org.partiql.value.datetime.TimestampWithTimeZone
+import org.partiql.value.datetime.TimestampWithoutTimeZone
+import java.math.BigDecimal
+import kotlin.test.assertEquals
+import com.amazon.ion.Timestamp as TimestampIon
+
+class TimestampTest {
+
+    sealed class TimestampTestCase(
+        open val name: String
+    )
+
+    data class SuccessCaseWithKnownTimeZone(
+        override val name: String,
+        val year: Int,
+        val month: Int,
+        val day: Int,
+        val hour: Int,
+        val minute: Int,
+        val second: BigDecimal,
+        val tzHour: Int,
+        val tzMinute: Int,
+        val precision: Int?,
+        val expectedTimestamp: Timestamp,
+        val expectedIonEquivalent: TimestampIon
+    ) : TimestampTestCase("Success Case With Known Time Zone - $name")
+
+    data class SuccessCaseWithUnknownTimeZone(
+        override val name: String,
+        val year: Int,
+        val month: Int,
+        val day: Int,
+        val hour: Int,
+        val minute: Int,
+        val second: BigDecimal,
+        val precision: Int?,
+        val expectedTimestamp: Timestamp,
+        val expectedIonEquivalent: TimestampIon
+    ) : TimestampTestCase("Success Case With Unknown Time Zone - $name")
+
+    data class SuccessCaseWithNoTimeZone(
+        override val name: String,
+        val year: Int,
+        val month: Int,
+        val day: Int,
+        val hour: Int,
+        val minute: Int,
+        val second: BigDecimal,
+        val precision: Int?,
+        val expectedTimestamp: Timestamp
+    ) : TimestampTestCase("Success Case With No Time Zone - $name")
+
+    data class EqualsAndCompareToTest(
+        val timestamp1: Timestamp,
+        val timestamp2: Timestamp,
+        val expectedEqualsRes: Boolean,
+        val expectedCompareToRes: Int
+    ) : TimestampTestCase("$timestamp1.equals($timestamp2) : $expectedEqualsRes; $timestamp1.compareTo($timestamp2) : $expectedEqualsRes;")
+
+    data class FailedTest(
+        override val name: String,
+        val statement: () -> Any
+    ) : TimestampTestCase(name)
+
+    @ParameterizedTest
+    @MethodSource("allTestCases")
+    fun runTests(tc: TimestampTestCase) {
+        when (tc) {
+            is SuccessCaseWithKnownTimeZone -> testSuccessCaseWithKnownTimeZone(tc)
+            is SuccessCaseWithNoTimeZone -> testSuccessCaseWithNoTimeZone(tc)
+            is SuccessCaseWithUnknownTimeZone -> testSuccessCaseWithUnknownTimeZone(tc)
+            is EqualsAndCompareToTest -> testEqualsAndCompareToTest(tc)
+            is FailedTest -> testFailedTestCases(tc)
+        }
+    }
+
+    private fun testSuccessCaseWithKnownTimeZone(tc: SuccessCaseWithKnownTimeZone) {
+        val actualTimestamp = DateTimeValue.timestamp(
+            tc.year, tc.month, tc.day,
+            tc.hour, tc.minute, tc.second, TimeZone.UtcOffset.of(tc.tzHour, tc.tzMinute)
+        ).let {
+            if (tc.precision != null) it.toPrecision(tc.precision)
+            else it
+        } as TimestampWithTimeZone
+
+        assert(tc.expectedTimestamp == actualTimestamp) {
+            """
+                Expected PartiQL Timestamp : ${tc.expectedTimestamp},
+                Actual PartiQL Timestamp   : $actualTimestamp
+            """.trimIndent()
+        }
+        assert(tc.expectedIonEquivalent == actualTimestamp.ionTimestampValue) {
+            """
+                Expected Ion Timestamp : ${tc.expectedIonEquivalent},
+                Actual Ion Timestamp   : ${actualTimestamp.ionTimestampValue}
+            """.trimIndent()
+        }
+        assert(tc.expectedIonEquivalent.decimalMillis == actualTimestamp.epochMillis) {
+            """
+                Expected epoch in Millis : ${tc.expectedIonEquivalent.decimalMillis},
+                Actual epoch in Millis   : ${actualTimestamp.epochMillis}
+            """.trimIndent()
+        }
+        val timestampFromIon = DateTimeValue.timestamp(tc.expectedIonEquivalent)
+        // ion Timestamp all arbitrary position
+        val expectedTimestampInArbitraryPrecision =
+            tc.expectedTimestamp
+        assert(timestampFromIon == expectedTimestampInArbitraryPrecision) {
+            """
+                Expected Timestamp From Ion : $expectedTimestampInArbitraryPrecision,
+                Actual Timestamp From Ion : $timestampFromIon
+            """.trimIndent()
+        }
+    }
+
+    private fun testSuccessCaseWithNoTimeZone(tc: SuccessCaseWithNoTimeZone) {
+        val actualTimestamp = DateTimeValue.timestamp(
+            tc.year, tc.month, tc.day,
+            tc.hour, tc.minute, tc.second
+        ).let {
+            if (tc.precision != null) it.toPrecision(tc.precision)
+            else it
+        } as TimestampWithoutTimeZone
+        assertEquals(tc.expectedTimestamp, actualTimestamp)
+    }
+
+    private fun testSuccessCaseWithUnknownTimeZone(tc: SuccessCaseWithUnknownTimeZone) {
+        val actualTimestamp = DateTimeValue.timestamp(
+            tc.year, tc.month, tc.day,
+            tc.hour, tc.minute, tc.second, TimeZone.UnknownTimeZone
+        ).let {
+            if (tc.precision != null) it.toPrecision(tc.precision)
+            else it
+        } as TimestampWithTimeZone
+
+        assert(tc.expectedTimestamp == actualTimestamp) {
+            """
+                Expected PartiQL Timestamp : ${tc.expectedTimestamp},
+                Actual PartiQL Timestamp   : $actualTimestamp
+            """.trimIndent()
+        }
+        assert(tc.expectedIonEquivalent == actualTimestamp.ionTimestampValue) {
+            """
+                Expected Ion Timestamp : ${tc.expectedIonEquivalent},
+                Actual Ion Timestamp   : ${actualTimestamp.ionTimestampValue}
+            """.trimIndent()
+        }
+        assert(tc.expectedIonEquivalent.decimalMillis == actualTimestamp.epochMillis) {
+            """
+                Expected epoch in Millis : ${tc.expectedIonEquivalent.decimalMillis},
+                Actual epoch in Millis   : ${actualTimestamp.epochMillis}
+            """.trimIndent()
+        }
+        val timestampFromIon = DateTimeValue.timestamp(tc.expectedIonEquivalent)
+        // ion Timestamp all arbitrary position
+        val expectedTimestampInArbitraryPrecision = tc.expectedTimestamp
+        assert(timestampFromIon == expectedTimestampInArbitraryPrecision) {
+            """
+                Expected Timestamp From Ion : $expectedTimestampInArbitraryPrecision,
+                Actual Timestamp From Ion : $timestampFromIon
+            """.trimIndent()
+        }
+    }
+
+    private fun testEqualsAndCompareToTest(tc: EqualsAndCompareToTest) {
+        // Equals
+        assert((tc.timestamp1 == tc.timestamp2) == tc.expectedEqualsRes) {
+            """
+                Timestamp 1 : ${tc.timestamp1},
+                Timestamp 2 : ${tc.timestamp2},
+                Expected Equals method result : ${tc.expectedEqualsRes}
+                Actual Equals method result : ${tc.timestamp1 == tc.timestamp2}
+            """.trimIndent()
+        }
+        // Compare To:
+        assert((tc.timestamp1.compareTo(tc.timestamp2)) == tc.expectedCompareToRes) {
+            """
+                Timestamp 1 : ${tc.timestamp1},
+                Timestamp 2 : ${tc.timestamp2},
+                Expected Equals method result : ${when (tc.expectedCompareToRes) {0 -> "Equals" 1 -> "More" else -> "Less"}}
+                Actual Equals method result : ${when (tc.timestamp1.compareTo(tc.timestamp2)) {0 -> "Equals" 1 -> "More" else -> "Less"}}
+            """.trimIndent()
+        }
+    }
+
+    private fun testFailedTestCases(tc: FailedTest) {
+        assertThrows<DateTimeException> {
+            tc.statement()
+        }
+    }
+
+    companion object {
+        private final val LESS = -1
+        private final val EQUALS = 0
+        private final val MORE = 1
+
+        private val successCaseWithKnownTimeZone = listOf(
+            SuccessCaseWithKnownTimeZone(
+                "Unix Zero",
+                1970, 1, 1, 0, 0, BigDecimal.ZERO, 0, 0, null,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.ZERO, TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T00:00:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Unix Zero with fraction decimalSecond",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), 0, 0, null,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 3), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T00:00:00.000Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Unix zero with precision",
+                1970, 1, 1, 0, 0, BigDecimal.ZERO, 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.ZERO, TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T00:00:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Rounding - truncate",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T00:00:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Rounding - up",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(999999, 5), 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(10, 0), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T00:00:10Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Rounding - carry to minute",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(599, 1), 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 1, BigDecimal.valueOf(0, 0), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T00:01:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Rounding - carry to hour",
+                1970, 1, 1, 0, 59, BigDecimal.valueOf(599, 1), 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(1, 0, BigDecimal.valueOf(0, 0), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T01:00:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Rounding - carry to day",
+                1970, 1, 1, 23, 59, BigDecimal.valueOf(599, 1), 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 2),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-02T00:00:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Rounding - carry to month",
+                1970, 1, 31, 23, 59, BigDecimal.valueOf(599, 1), 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 2, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-02-01T00:00:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Rounding - carry to year",
+                1970, 12, 31, 23, 59, BigDecimal.valueOf(599, 1), 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1971, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1971-01-01T00:00:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "Rounding - padding zeros",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(1, 0), 0, 0, 5,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(100000, 5), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T00:00:01.00000Z").timestampValue
+            ),
+            // large precision
+            SuccessCaseWithKnownTimeZone(
+                "Large precision",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 20), 0, 0, 20,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 20), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1970-01-01T00:00:00.00000000000000000000Z").timestampValue
+            ),
+            // negative epoch
+            // May be Ion has a bug?
+            // Expected epoch in Millis : -23225270400000,
+            // Actual epoch in Millis   : -23225875200000
+            // SuccessCaseWithKnownTimeZone(
+            //    1234, 1, 1, 0,0, BigDecimal.valueOf(0,3), 0, 0, 0,
+            //    Timestamp.of(
+            //        DateTimeValue.date(1234, 1, 1),
+            //        DateTimeValue.time(0,0, BigDecimal.valueOf(0,0), TimeZone.UtcOffset.of(0))
+            // ),
+            // ionTimestamp("1234-01-01T00:00:00Z").timestampValue
+            // ),
+            SuccessCaseWithKnownTimeZone(
+                "Negative epoch",
+                1901, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), 0, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1901, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UtcOffset.of(0))
+                ),
+                ionTimestamp("1901-01-01T00:00:00Z").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "With time zone hour",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), -7, 0, 3,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 3), TimeZone.UtcOffset.of(-7, 0))
+                ),
+                ionTimestamp("1970-01-01T00:00:00.000-07:00").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "With time zone large hour",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), -23, 0, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.ZERO, TimeZone.UtcOffset.of(-23, 0))
+                ),
+                ionTimestamp("1970-01-01T00:00:00-23:00").timestampValue
+            ),
+            SuccessCaseWithKnownTimeZone(
+                "With time zone minute",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), -23, -59, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.ZERO, TimeZone.UtcOffset.of(-23, -59))
+                ),
+                ionTimestamp("1970-01-01T00:00:00-23:59").timestampValue
+            ),
+        )
+
+        private val successCaseWithUnKnownTimeZone = listOf(
+            SuccessCaseWithUnknownTimeZone(
+                "Unix zero with unknown time zone",
+                1970, 1, 1, 0, 0, BigDecimal.ZERO, null,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.ZERO, TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T00:00:00-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Unix zero with unknown time zone - with fraction",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), null,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 3), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T00:00:00.000-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Unix zero with unknown time zone with precision ",
+                1970, 1, 1, 0, 0, BigDecimal.ZERO, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.ZERO, TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T00:00:00-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Rounding - truncate",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T00:00:00-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Rounding - up",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(999999, 5), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(10, 0), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T00:00:10-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Rounding - carry to minute",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 1, BigDecimal.valueOf(0, 0), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T00:01:00-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Rounding - carry to hour",
+                1970, 1, 1, 0, 59, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(1, 0, BigDecimal.valueOf(0, 0), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T01:00:00-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Rounding - rounding carry to day",
+                1970, 1, 1, 23, 59, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 2),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-02T00:00:00-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Rounding - rounding carry to month",
+                1970, 1, 31, 23, 59, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 2, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-02-01T00:00:00-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Rounding - rounding carry to year",
+                1970, 12, 31, 23, 59, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1971, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1971-01-01T00:00:00-00:00").timestampValue
+            ),
+            SuccessCaseWithUnknownTimeZone(
+                "Large precision",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 20), 20,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 20), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T00:00:00.00000000000000000000-00:00").timestampValue
+            ),
+            // negative epoch
+            // May be Ion has a bug?
+            // Expected epoch in Millis : -23225270400000,
+            // Actual epoch in Millis   : -23225875200000
+            // SuccessCaseWithUnknownTimeZone(
+            //    1234, 1, 1, 0,0, BigDecimal.valueOf(0,3), 0,
+            //    Timestamp.of(
+            //        DateTimeValue.date(1234, 1, 1),
+            //        DateTimeValue.time(0,0, BigDecimal.valueOf(0,0), TimeZone.UnknownTimeZone)
+            // ),
+            // ionTimestamp("1234-01-01T00:00:00-00:00").timestampValue
+            // ),
+            SuccessCaseWithUnknownTimeZone(
+                "Negative epoch",
+                1901, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1901, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1901-01-01T00:00:00-00:00").timestampValue
+            ),
+            // padding
+            SuccessCaseWithUnknownTimeZone(
+                "Padding zero",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(1, 0), 5,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(100000, 5), TimeZone.UnknownTimeZone)
+                ),
+                ionTimestamp("1970-01-01T00:00:01.00000-00:00").timestampValue
+            ),
+        )
+
+        private val successCaseWithNoTimeZone = listOf(
+            SuccessCaseWithNoTimeZone(
+                "Unix zero",
+                1970, 1, 1, 0, 0, BigDecimal.ZERO, null,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.ZERO, null)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Unix zero - with fraction",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), null,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 3), null)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Unix zero with precision",
+                1970, 1, 1, 0, 0, BigDecimal.ZERO, 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.ZERO,)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Rounding - truncate",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Rounding - up",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(999999, 5), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(10, 0),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Rounding - carry to minute",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 1, BigDecimal.valueOf(0, 0),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Rounding - carry to hour",
+                1970, 1, 1, 0, 59, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(1, 0, BigDecimal.valueOf(0, 0),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Rounding - carry to day",
+                1970, 1, 1, 23, 59, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 2),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Rounding - carry to month",
+                1970, 1, 31, 23, 59, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 2, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Rounding - carry to year",
+                1970, 12, 31, 23, 59, BigDecimal.valueOf(599, 1), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1971, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Large precision",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(0, 20), 20,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 20),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Negative epoch",
+                1234, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0))
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Negative epoch",
+                1901, 1, 1, 0, 0, BigDecimal.valueOf(0, 3), 0,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1901, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 0),)
+                ),
+            ),
+            SuccessCaseWithNoTimeZone(
+                "Padding zeros",
+                1970, 1, 1, 0, 0, BigDecimal.valueOf(1, 0), 5,
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1970, 1, 1),
+                    DateTimeValue.time(0, 0, BigDecimal.valueOf(100000, 5),)
+                ),
+            ),
+        )
+
+        private val equalsAndCompareToTestcase = listOf(
+            // No Timezone
+            // equals
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L))
+                ),
+                true,
+                EQUALS
+            ),
+            // different fraction
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(90L, 1))
+                ),
+                false,
+                EQUALS
+            ),
+            // larger
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(5, 8, BigDecimal.valueOf(9L))
+                ),
+                false,
+                MORE
+            ),
+            // Less
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(10, 8, BigDecimal.valueOf(9L))
+                ),
+                false,
+                LESS
+            ),
+
+            // Known / Unknown time zone
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                true,
+                EQUALS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                true,
+                EQUALS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                false,
+                EQUALS
+            ),
+            // fraction precision
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(90L, 1), TimeZone.UtcOffset.of(0))
+                ),
+                false,
+                EQUALS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(90L, 1), TimeZone.UnknownTimeZone)
+                ),
+                false,
+                EQUALS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                false,
+                EQUALS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                false,
+                EQUALS
+            ),
+            // Time Zone Hour
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(8, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(1, 0))
+                ),
+                false,
+                EQUALS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(8, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(1, 0))
+                ),
+                false,
+                EQUALS
+            ),
+            // Time zone hour minute
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(8, 38, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(1, 30))
+                ),
+                false,
+                EQUALS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(8, 38, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(1, 30))
+                ),
+                false,
+                EQUALS
+            ),
+
+            // larger
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(5, 38, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                false,
+                MORE
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(5, 38, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                false,
+                MORE
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(5, 38, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                false,
+                MORE
+            ),
+            // less
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(5, 38, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                false,
+                LESS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(5, 38, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                false,
+                LESS
+            ),
+            EqualsAndCompareToTest(
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(5, 38, BigDecimal.valueOf(9L), TimeZone.UnknownTimeZone)
+                ),
+                DateTimeValue.timestamp(
+                    DateTimeValue.date(1234, 5, 6),
+                    DateTimeValue.time(7, 8, BigDecimal.valueOf(9L), TimeZone.UtcOffset.of(0))
+                ),
+                false,
+                LESS
+            ),
+        )
+
+        private val failedTestCases = listOf(
+            // day
+            FailedTest("Year more than for digits") { DateTimeValue.date(12345, 1, 1) },
+            FailedTest("Month more than two digits") { DateTimeValue.date(1234, 123, 1) },
+            FailedTest("Day more than two digits") { DateTimeValue.date(1234, 12, 123) },
+            FailedTest("Year less than zero") { DateTimeValue.date(-1234, 12, 1) },
+            FailedTest("Month less than zero") { DateTimeValue.date(1234, -12, 1) },
+            FailedTest("Day less than zero") { DateTimeValue.date(1234, -12, -1) },
+            FailedTest("Month > 12") { DateTimeValue.date(1234, 13, 1) },
+            FailedTest("Day > 31") { DateTimeValue.date(1234, 1, 32) },
+            FailedTest("not leap") { DateTimeValue.date(2023, 2, 29) },
+            // time
+            FailedTest("hour 3 digits") { DateTimeValue.time(123, 1, BigDecimal.ZERO) },
+            FailedTest("minute 3 digits") { DateTimeValue.time(12, 111, BigDecimal.ZERO) },
+            FailedTest("whole decimalSecond large than 2") { DateTimeValue.time(12, 1, BigDecimal.valueOf(1000L, 1)) },
+            FailedTest("Timezone hour more than 3 digits") { DateTimeValue.time(12, 1, BigDecimal.ZERO, TimeZone.UtcOffset.of(100, 0)) },
+            FailedTest("Time zone minutes more than 3 digits") { DateTimeValue.time(12, 1, BigDecimal.ZERO, TimeZone.UtcOffset.of(1, 100)) },
+            FailedTest("Hour more than 24") { DateTimeValue.time(25, 1, BigDecimal.ZERO) },
+            FailedTest("Minute more than 60") { DateTimeValue.time(12, 61, BigDecimal.ZERO) },
+            FailedTest("Second more than 60") { DateTimeValue.time(12, 1, BigDecimal.valueOf(61L)) },
+
+            // Timestamp comparison
+            FailedTest("Compare with time zone and without time zone") {
+                DateTimeValue.timestamp(1234, 5, 6, 7, 8, BigDecimal.ZERO)
+                    .compareTo(DateTimeValue.timestamp(1234, 5, 6, 7, 8, BigDecimal.ZERO, TimeZone.UtcOffset.of(0)))
+            }
+        )
+
+        @JvmStatic
+        fun allTestCases() =
+            successCaseWithKnownTimeZone + successCaseWithUnKnownTimeZone + successCaseWithNoTimeZone + equalsAndCompareToTestcase + failedTestCases
+    }
+}
diff --git a/partiql-types/src/test/kotlin/org/partiql/value/io/PartiQLValueIonSerdeTest.kt b/partiql-types/src/test/kotlin/org/partiql/value/io/PartiQLValueIonSerdeTest.kt
new file mode 100644
index 0000000000..dd09471ed7
--- /dev/null
+++ b/partiql-types/src/test/kotlin/org/partiql/value/io/PartiQLValueIonSerdeTest.kt
@@ -0,0 +1,624 @@
+package org.partiql.value.io
+
+import com.amazon.ion.IonValue
+import com.amazon.ion.system.IonBinaryWriterBuilder
+import com.amazon.ion.system.IonReaderBuilder
+import com.amazon.ion.system.IonSystemBuilder
+import com.amazon.ion.system.IonTextWriterBuilder
+import com.amazon.ionelement.api.toIonElement
+import com.amazon.ionelement.api.toIonValue
+import org.junit.jupiter.api.parallel.Execution
+import org.junit.jupiter.api.parallel.ExecutionMode
+import org.junit.jupiter.params.ParameterizedTest
+import org.junit.jupiter.params.provider.MethodSource
+import org.partiql.value.Annotations
+import org.partiql.value.PartiQLValue
+import org.partiql.value.PartiQLValueExperimental
+import org.partiql.value.bagValue
+import org.partiql.value.boolValue
+import org.partiql.value.charValue
+import org.partiql.value.dateValue
+import org.partiql.value.datetime.DateTimeValue
+import org.partiql.value.datetime.TimeZone
+import org.partiql.value.datetime.Timestamp
+import org.partiql.value.decimalValue
+import org.partiql.value.float32Value
+import org.partiql.value.float64Value
+import org.partiql.value.int16Value
+import org.partiql.value.int32Value
+import org.partiql.value.int64Value
+import org.partiql.value.int8Value
+import org.partiql.value.intValue
+import org.partiql.value.listValue
+import org.partiql.value.missingValue
+import org.partiql.value.nullValue
+import org.partiql.value.nullableBagValue
+import org.partiql.value.nullableBlobValue
+import org.partiql.value.nullableBoolValue
+import org.partiql.value.nullableClobValue
+import org.partiql.value.nullableDateValue
+import org.partiql.value.nullableDecimalValue
+import org.partiql.value.nullableFloat64Value
+import org.partiql.value.nullableIntValue
+import org.partiql.value.nullableListValue
+import org.partiql.value.nullableSexpValue
+import org.partiql.value.nullableStringValue
+import org.partiql.value.nullableStructValue
+import org.partiql.value.nullableSymbolValue
+import org.partiql.value.nullableTimeValue
+import org.partiql.value.nullableTimestampValue
+import org.partiql.value.sexpValue
+import org.partiql.value.stringValue
+import org.partiql.value.structValue
+import org.partiql.value.symbolValue
+import org.partiql.value.timeValue
+import org.partiql.value.timestampValue
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.PrintStream
+import java.math.BigDecimal
+import java.math.BigInteger
+import kotlin.test.assertEquals
+
+@OptIn(PartiQLValueExperimental::class)
+class PartiQLValueIonSerdeTest {
+
+    @ParameterizedTest
+    @MethodSource("nulls")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testNulls(case: Case) = assert(case)
+
+    @ParameterizedTest
+    @MethodSource("scalars")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testScalars(case: Case) = assert(case)
+
+    @ParameterizedTest
+    @MethodSource("collections")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testCollections(case: Case) = assert(case)
+
+    @ParameterizedTest
+    @MethodSource("annotations")
+    @Execution(ExecutionMode.CONCURRENT)
+    fun testAnnotations(case: Case) = assert(case)
+
+    companion object {
+        private val ION = IonSystemBuilder.standard().build()
+
+        private val annotations: Annotations = listOf("x", "y")
+
+        private fun oneWayTrip(partiQLValueBefore: PartiQLValue, ionValue: IonValue, partiQLValueAfter: PartiQLValue) =
+            Case.OneWayTrip(partiQLValueBefore, ionValue, partiQLValueAfter)
+
+        private fun roundTrip(partiQLValue: PartiQLValue, ionValue: IonValue) = Case.RoundTrip(partiQLValue, ionValue)
+
+        @JvmStatic
+        fun nulls() = listOf(
+            // absent value
+            roundTrip(
+                nullValue(),
+                ION.newNull()
+            ),
+            roundTrip(
+                missingValue(),
+                ION.newNull().apply { addTypeAnnotation("\$missing") }
+            ),
+            // bool.null
+            roundTrip(
+                nullableBoolValue(),
+                ION.newNullBool()
+            ),
+            // int.null
+            roundTrip(
+                nullableIntValue(),
+                ION.newNullInt()
+            ),
+            // float.null
+            roundTrip(
+                nullableFloat64Value(),
+                ION.newNullFloat()
+            ),
+            // Decimal.null
+            roundTrip(
+                nullableDecimalValue(),
+                ION.newNullDecimal()
+            ),
+            // timestamp.null
+            roundTrip(
+                nullableTimestampValue(),
+                ION.newNullTimestamp()
+            ),
+            // symbol.null
+            roundTrip(
+                nullableSymbolValue(),
+                ION.newNullSymbol()
+            ),
+            // string.null
+            roundTrip(
+                nullableStringValue(),
+                ION.newNullString()
+            ),
+            // Clob.null
+            roundTrip(
+                nullableClobValue(),
+                ION.newNullClob(),
+            ),
+            // blob.null
+            roundTrip(
+                nullableBlobValue(),
+                ION.newNullBlob()
+            ),
+            // list.null
+            roundTrip(
+                nullableListValue<PartiQLValue>(),
+                ION.newNullList()
+            ),
+            // Sexp.null
+            roundTrip(
+                nullableSexpValue<PartiQLValue>(),
+                ION.newNullSexp()
+            ),
+            // struct.null
+            roundTrip(
+                nullableStructValue<PartiQLValue>(),
+                ION.newNullStruct()
+            ),
+            // $bag::list.null
+            roundTrip(
+                nullableBagValue<PartiQLValue>(),
+                ION.newNullList().apply {
+                    addTypeAnnotation("\$bag")
+                }
+            ),
+            // $date::struct.null
+            roundTrip(
+                nullableDateValue(),
+                ION.newNullStruct().apply {
+                    addTypeAnnotation("\$date")
+                }
+            ),
+            // $time::struct.null
+            roundTrip(
+                nullableTimeValue(),
+                ION.newNullStruct().apply {
+                    addTypeAnnotation("\$time")
+                }
+            ),
+        )
+
+        @JvmStatic
+        fun scalars() = listOf(
+            roundTrip(
+                boolValue(true),
+                ION.newBool(true)
+            ),
+            roundTrip(
+                boolValue(false),
+                ION.newBool(false)
+            ),
+            oneWayTrip(
+                int8Value(1),
+                ION.newInt(1),
+                intValue(BigInteger.ONE)
+            ),
+            oneWayTrip(
+                int16Value(1),
+                ION.newInt(1),
+                intValue(BigInteger.ONE)
+            ),
+            oneWayTrip(
+                int32Value(1),
+                ION.newInt(1),
+                intValue(BigInteger.ONE)
+            ),
+            oneWayTrip(
+                int64Value(1),
+                ION.newInt(1),
+                intValue(BigInteger.ONE)
+            ),
+            roundTrip(
+                intValue(BigInteger.valueOf(1)),
+                ION.newInt(1),
+            ),
+            roundTrip(
+                decimalValue(BigDecimal("123.456")),
+                ION.newDecimal(BigDecimal("123.456")),
+            ),
+            roundTrip(
+                decimalValue(BigDecimal("0.456")),
+                ION.newDecimal(BigDecimal("0.456")),
+            ),
+            oneWayTrip(
+                float32Value(123.0f),
+                ION.newFloat(123.0f.toString().toDouble()),
+                float64Value(123.0)
+            ),
+            oneWayTrip(
+                float32Value(123f),
+                ION.newFloat(123f.toString().toDouble()),
+                float64Value(123.0)
+            ),
+            roundTrip(
+                float64Value(123.0),
+                ION.newFloat(123.0.toString().toDouble())
+            ),
+            roundTrip(
+                float64Value(123.toDouble()),
+                ION.newFloat(123),
+            ),
+            oneWayTrip(
+                charValue('C'),
+                ION.newString("C"),
+                stringValue("C")
+            ),
+            roundTrip(
+                stringValue("word"),
+                ION.newString("word")
+            ),
+            roundTrip(
+                stringValue("word\nword"),
+                ION.newString("word\nword")
+            ),
+            roundTrip(
+                symbolValue("x"),
+                ION.newSymbol("x"),
+            ),
+            roundTrip(
+                symbolValue("f.x"),
+                ION.newSymbol("f.x"),
+            ),
+            roundTrip(
+                dateValue(DateTimeValue.date(2023, 6, 1)),
+                ION.newEmptyStruct().apply {
+                    add("year", ION.newInt(2023L))
+                    add("month", ION.newInt(6L))
+                    add("day", ION.newInt(1L))
+                    addTypeAnnotation("\$date")
+                }
+            ),
+            // time without time zone
+            roundTrip(
+                timeValue(DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 2))),
+                ION.newEmptyStruct().apply {
+                    add("hour", ION.newInt(0L))
+                    add("minute", ION.newInt(0L))
+                    add("second", ION.newDecimal(BigDecimal.valueOf(0, 2)))
+                    addTypeAnnotation("\$time")
+                }
+            ),
+            // time with unknown time zone
+            roundTrip(
+                timeValue(DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 2), TimeZone.UnknownTimeZone)),
+                ION.newEmptyStruct().apply {
+                    add("hour", ION.newInt(0L))
+                    add("minute", ION.newInt(0L))
+                    add("second", ION.newDecimal(BigDecimal.valueOf(0, 2)))
+                    add("offset", ION.newNullInt())
+                    addTypeAnnotation("\$time")
+                }
+            ),
+            // time with time zone
+            roundTrip(
+                timeValue(DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 2), TimeZone.UtcOffset.of(10))),
+                ION.newEmptyStruct().apply {
+                    add("hour", ION.newInt(0L))
+                    add("minute", ION.newInt(0L))
+                    add("second", ION.newDecimal(BigDecimal.valueOf(0, 2)))
+                    add("offset", ION.newInt(10L))
+                    addTypeAnnotation("\$time")
+                }
+            ),
+            roundTrip(
+                timeValue(DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 2), TimeZone.UtcOffset.of(-100))),
+                ION.newEmptyStruct().apply {
+                    add("hour", ION.newInt(0L))
+                    add("minute", ION.newInt(0L))
+                    add("second", ION.newDecimal(BigDecimal.valueOf(0, 2)))
+                    add("offset", ION.newInt(-100L))
+                    addTypeAnnotation("\$time")
+                }
+            ),
+            roundTrip(
+                timestampValue(
+                    DateTimeValue.timestamp(
+                        DateTimeValue.date(2023, 6, 1),
+                        DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 2), null)
+                    )
+                ),
+                ION.newEmptyStruct().apply {
+                    add("year", ION.newInt(2023L))
+                    add("month", ION.newInt(6L))
+                    add("day", ION.newInt(1L))
+                    add("hour", ION.newInt(0L))
+                    add("minute", ION.newInt(0L))
+                    add("second", ION.newDecimal(BigDecimal.valueOf(0, 2)))
+                    addTypeAnnotation("\$timestamp")
+                }
+            ),
+            roundTrip(
+                timestampValue(
+                    DateTimeValue.timestamp(
+                        DateTimeValue.date(2023, 6, 1),
+                        DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 2), TimeZone.UnknownTimeZone)
+                    )
+                ),
+                ION.newTimestamp(com.amazon.ion.Timestamp.forSecond(2023, 6, 1, 0, 0, BigDecimal.valueOf(0, 2), null))
+            ),
+            roundTrip(
+                timestampValue(
+                    DateTimeValue.timestamp(
+                        DateTimeValue.date(2023, 6, 1),
+                        DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 2), TimeZone.UtcOffset.of(10))
+                    )
+                ),
+                ION.newTimestamp(com.amazon.ion.Timestamp.forSecond(2023, 6, 1, 0, 0, BigDecimal.valueOf(0, 2), 10))
+            ),
+            roundTrip(
+                timestampValue(
+                    DateTimeValue.timestamp(
+                        DateTimeValue.date(2023, 6, 1),
+                        DateTimeValue.time(0, 0, BigDecimal.valueOf(0, 2), TimeZone.UtcOffset.of(-100))
+                    )
+                ),
+                ION.newTimestamp(com.amazon.ion.Timestamp.forSecond(2023, 6, 1, 0, 0, BigDecimal.valueOf(0, 2), -100))
+            )
+
+            // TODO CLOB
+            // TODO BINARY
+            // TODO BYTE
+            // TODO BLOB
+            // TODO INTERVAL
+        )
+
+        @JvmStatic
+        fun collections() = listOf(
+            roundTrip(
+                bagValue(emptyList()),
+                ION.newEmptyList().apply { addTypeAnnotation("\$bag") },
+            ),
+            roundTrip(
+                listValue(emptyList()),
+                ION.newEmptyList()
+            ),
+            roundTrip(
+                sexpValue(emptyList()),
+                ION.newEmptySexp()
+            ),
+            oneWayTrip(
+                bagValue(
+                    listOf(
+                        int32Value(1),
+                        int32Value(2),
+                        int32Value(3),
+                    )
+                ),
+                ION.newList(
+                    ION.newInt(1),
+                    ION.newInt(2),
+                    ION.newInt(3)
+                ).apply { addTypeAnnotation("\$bag") },
+                bagValue(
+                    listOf(
+                        intValue(BigInteger.ONE),
+                        intValue(BigInteger.valueOf(2L)),
+                        intValue(BigInteger.valueOf(3L)),
+                    )
+                )
+            ),
+            roundTrip(
+                listValue(
+                    listOf(
+                        stringValue("a"),
+                        stringValue("b"),
+                        stringValue("c"),
+                    )
+                ),
+                ION.newList(
+                    ION.newString("a"),
+                    ION.newString("b"),
+                    ION.newString("c")
+                )
+            ),
+            oneWayTrip(
+                sexpValue(
+                    listOf(
+                        int32Value(1),
+                        int32Value(2),
+                        int32Value(3),
+                    )
+                ),
+                ION.newSexp(
+                    ION.newInt(1),
+                    ION.newInt(2),
+                    ION.newInt(3)
+                ),
+                sexpValue(
+                    listOf(
+                        intValue(BigInteger.ONE),
+                        intValue(BigInteger.valueOf(2L)),
+                        intValue(BigInteger.valueOf(3L)),
+                    )
+                )
+            ),
+            oneWayTrip(
+                structValue(
+                    listOf(
+                        "a" to int32Value(1),
+                        "b" to stringValue("x"),
+                    )
+                ),
+                ION.newEmptyStruct()
+                    .apply {
+                        add("a", ION.newInt(1))
+                        add("b", ION.newString("x"))
+                    },
+                structValue(
+                    listOf(
+                        "a" to intValue(BigInteger.ONE),
+                        "b" to stringValue("x"),
+                    )
+                ),
+            )
+        )
+
+        @JvmStatic
+        fun nestedCollections(): List<Case> = TODO()
+
+        @JvmStatic
+        fun annotations(): List<Case> = scalars().map { toAnnotated(it) } + collections().map { toAnnotated(it) } + nulls().map { toAnnotated(it) }
+
+        private fun toAnnotated(case: Case): Case =
+            when (case) {
+                is Case.OneWayTrip -> {
+                    val partiQLValueBeforeAnnotation = case.partiQLValueBefore.annotations
+                    val ionValueAnnotation = case.ionValueForPartiQL.typeAnnotations.toList()
+                    val partiQLValueAfterAnnotation = case.partiQLValueAfter.annotations
+                    Case.OneWayTrip(
+                        case.partiQLValueBefore.withoutAnnotations()
+                            .withAnnotations(annotations + partiQLValueBeforeAnnotation),
+                        case.ionValueForPartiQL.toIonElement()
+                            .withoutAnnotations()
+                            .withAnnotations(annotations + ionValueAnnotation)
+                            .toIonValue(ION),
+                        case.partiQLValueAfter
+                            .withoutAnnotations()
+                            .withAnnotations(annotations + partiQLValueAfterAnnotation)
+                    )
+                }
+
+                is Case.RoundTrip -> {
+                    val partiQLValueBeforeAnnotation = case.partiQLValueBefore.annotations
+                    val ionValueAnnotation = case.ionValue.typeAnnotations.toList()
+                    Case.RoundTrip(
+                        case.partiQLValueBefore.withoutAnnotations()
+                            .withAnnotations(annotations + partiQLValueBeforeAnnotation),
+                        case.ionValue.toIonElement()
+                            .withoutAnnotations()
+                            .withAnnotations(annotations + ionValueAnnotation)
+                            .toIonValue(ION),
+                    )
+                }
+            }
+    }
+
+    // This class test use [IonForPartiQL] as source format
+    sealed class Case() {
+        data class OneWayTrip(
+            val partiQLValueBefore: PartiQLValue,
+            val ionValueForPartiQL: IonValue,
+            val partiQLValueAfter: PartiQLValue,
+        ) : Case()
+
+        data class RoundTrip(
+            val partiQLValueBefore: PartiQLValue,
+            val ionValue: IonValue,
+        ) : Case()
+    }
+
+    // If the test is round trip enabled, then
+    // 1. test partiql value before to ion binary/ ion text
+    // 2. test ion to partiql value before
+    private fun assert(tc: Case) {
+        when (tc) {
+            // if the test shall be one way trip
+            // then we test on:
+            // 1. PartiQL value before to Ion text/binary
+            // 2. Ion to PartiQL Value after
+            // 3. PartiQL Value after to ion
+            //    -- No further divergent should appear.
+            is Case.OneWayTrip -> {
+                assertToIon(tc.partiQLValueBefore, tc.ionValueForPartiQL)
+                assertRoundTrip(tc.partiQLValueAfter, tc.ionValueForPartiQL)
+            }
+
+            is Case.RoundTrip -> {
+                assertRoundTrip(tc.partiQLValueBefore, tc.ionValue)
+            }
+        }
+    }
+
+    private fun assertRoundTrip(pValue: PartiQLValue, iValue: IonValue) {
+        try {
+            assertToIon(pValue, iValue)
+        } catch (e: AssertionError) {
+            val message = """
+                        From PartiQL To Ion Failed: 
+                        original PartiQL Value: $pValue,
+                        ${e.message}
+            """.trimIndent()
+            throw AssertionError(message)
+        }
+        try {
+            assertToPartiQL(iValue, pValue)
+        } catch (e: AssertionError) {
+            val message = """
+                        From Ion To PartiQL Failed: 
+                        original ion Value: $iValue,
+                        ${e.message}
+            """.trimIndent()
+            throw AssertionError(message)
+        }
+    }
+
+    private fun assertToPartiQL(iValue: IonValue, pValue: PartiQLValue) {
+        val out = ByteArrayOutputStream()
+        val reader = IonReaderBuilder.standard().build(iValue)
+        val writer = IonTextWriterBuilder.standard().build(out)
+        writer.writeValues(reader)
+        val input = ByteArrayInputStream(out.toByteArray())
+        val ionForPartiQL =
+            PartiQLValueIonReaderBuilder
+                .standard().build(input)
+        val actual = ionForPartiQL.read()
+        assertEquals(
+            pValue, actual,
+            """PartiQLValue Assertion Failed
+                    | Expected : $pValue
+                    | Actual: $actual
+                """.trimMargin()
+        )
+    }
+
+    private fun assertToIon(pValue: PartiQLValue, iValue: IonValue) {
+        assertToIonBinary(pValue, iValue)
+        assertToIonText(pValue, iValue)
+    }
+
+    private fun assertToIonText(pValue: PartiQLValue, iValue: IonValue) {
+        val bufferForPartiQL = ByteArrayOutputStream()
+        val textWriter = PartiQLValueIonWriterBuilder.standardIonTextBuilder().build(bufferForPartiQL)
+        textWriter.append(pValue)
+        val actual = bufferForPartiQL.toString()
+        val bufferForIon = ByteArrayOutputStream()
+        val ionTextWriter = IonTextWriterBuilder.standard().build(bufferForIon)
+        ionTextWriter.writeValues(IonReaderBuilder.standard().build(iValue))
+        PrintStream(bufferForPartiQL)
+        val expected = bufferForIon.toString()
+        assertEquals(
+            expected, actual,
+            """Ion Text assertion Failed:
+                   | Expected : $expected,
+                   | Actual : $actual
+                """.trimMargin()
+        )
+    }
+
+    private fun assertToIonBinary(pValue: PartiQLValue, iValue: IonValue) {
+        val bufferForPartiQL = ByteArrayOutputStream()
+        val binaryWriter = PartiQLValueIonWriterBuilder.standardIonBinaryBuilder().build(bufferForPartiQL)
+        binaryWriter.append(pValue)
+        val actual = bufferForPartiQL.toString()
+        val bufferForIon = ByteArrayOutputStream()
+        val ionBinaryWriter = IonBinaryWriterBuilder.standard().build(bufferForIon)
+        ionBinaryWriter.writeValues(IonReaderBuilder.standard().build(iValue))
+        val expected = bufferForIon.toString()
+        assertEquals(
+            expected, actual,
+            """Ion Binary assertion Failed:
+                    | Expected : $expected,
+                    | Actual : $actual
+                """.trimMargin()
+        )
+    }
+}
diff --git a/partiql-types/src/test/kotlin/org/partiql/value/io/PartiQLValueTextWriterTest.kt b/partiql-types/src/test/kotlin/org/partiql/value/io/PartiQLValueTextWriterTest.kt
index 13404fd72d..3b54305e79 100644
--- a/partiql-types/src/test/kotlin/org/partiql/value/io/PartiQLValueTextWriterTest.kt
+++ b/partiql-types/src/test/kotlin/org/partiql/value/io/PartiQLValueTextWriterTest.kt
@@ -24,6 +24,7 @@ import org.partiql.value.intValue
 import org.partiql.value.listValue
 import org.partiql.value.missingValue
 import org.partiql.value.nullValue
+import org.partiql.value.nullableBagValue
 import org.partiql.value.nullableBoolValue
 import org.partiql.value.nullableCharValue
 import org.partiql.value.nullableDecimalValue
@@ -34,7 +35,10 @@ import org.partiql.value.nullableInt32Value
 import org.partiql.value.nullableInt64Value
 import org.partiql.value.nullableInt8Value
 import org.partiql.value.nullableIntValue
+import org.partiql.value.nullableListValue
+import org.partiql.value.nullableSexpValue
 import org.partiql.value.nullableStringValue
+import org.partiql.value.nullableStructValue
 import org.partiql.value.nullableSymbolValue
 import org.partiql.value.sexpValue
 import org.partiql.value.stringValue
@@ -375,6 +379,23 @@ class PartiQLValueTextWriterTest {
                 ),
                 expected = "(1 2 3)",
             ),
+            // nullable collections
+            case(
+                value = nullableBagValue<PartiQLValue>(null),
+                expected = "null",
+            ),
+            case(
+                value = nullableListValue<PartiQLValue>(null),
+                expected = "null",
+            ),
+            case(
+                value = nullableSexpValue<PartiQLValue>(null),
+                expected = "null",
+            ),
+            case(
+                value = nullableStructValue<PartiQLValue>(null),
+                expected = "null",
+            ),
         )
 
         @JvmStatic