diff --git a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rex/CastTable.kt b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rex/CastTable.kt
index 8f994fa1c7..b7709866b5 100644
--- a/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rex/CastTable.kt
+++ b/partiql-eval/src/main/kotlin/org/partiql/eval/internal/operator/rex/CastTable.kt
@@ -30,10 +30,12 @@ import org.partiql.types.PType.TIMEZ
 import org.partiql.types.PType.TINYINT
 import org.partiql.types.PType.VARCHAR
 import org.partiql.types.PType.VARIANT
-import org.partiql.value.datetime.DateTimeValue
 import java.math.BigDecimal
 import java.math.BigInteger
 import java.math.RoundingMode
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.ZoneOffset
 
 /**
  * Represent the cast operation. This casts an input [Datum] to the target [PType] (returning a potentially new [Datum]).
@@ -103,9 +105,9 @@ internal object CastTable {
         registerString()
         registerBag()
         registerList()
-        registerTimestamp()
         registerDate()
         registerTime()
+        registerTimestamp()
         registerVariant()
     }
 
@@ -442,57 +444,41 @@ internal object CastTable {
         register(ARRAY, ARRAY) { x, _ -> x }
     }
 
-    /**
-     * TODO: Flush this out.
-     */
-    private fun registerTimestamp() {
-        // WITHOUT TZ
-        register(TIMESTAMP, VARCHAR) { x, t -> Datum.varchar(x.timestamp.toString(), t.length) }
-        register(TIMESTAMP, CHAR) { x, t -> Datum.character(x.timestamp.toString(), t.length) }
-        register(TIMESTAMP, CLOB) { x, t -> Datum.clob(x.timestamp.toString().toByteArray(), t.length) }
-        register(TIMESTAMP, STRING) { x, _ -> Datum.string(x.timestamp.toString()) }
-        register(TIMESTAMP, TIMESTAMP) { x, _ -> Datum.timestamp(x.timestamp) }
-        register(TIMESTAMP, TIMESTAMPZ) { x, _ -> Datum.timestamp(x.timestamp) }
-        register(TIMESTAMP, TIME) { x, _ -> Datum.time(x.timestamp.toTime()) }
-        register(TIMESTAMP, DATE) { x, _ -> Datum.date(x.timestamp.toDate()) }
-        // WITH TZ
-        register(TIMESTAMPZ, VARCHAR) { x, t -> Datum.varchar(x.timestamp.toString(), t.length) }
-        register(TIMESTAMPZ, CHAR) { x, t -> Datum.character(x.timestamp.toString(), t.length) }
-        register(TIMESTAMPZ, CLOB) { x, t -> Datum.clob(x.timestamp.toString().toByteArray(), t.length) }
-        register(TIMESTAMPZ, STRING) { x, _ -> Datum.string(x.timestamp.toString()) }
-        register(TIMESTAMPZ, TIMESTAMP) { x, _ -> Datum.timestamp(x.timestamp) }
-        register(TIMESTAMPZ, TIMESTAMPZ) { x, _ -> Datum.timestamp(x.timestamp) }
-        register(TIMESTAMPZ, TIME) { x, _ -> Datum.time(x.timestamp.toTime()) }
-        register(TIMESTAMPZ, DATE) { x, _ -> Datum.date(x.timestamp.toDate()) }
-    }
     private fun registerDate() {
-        register(DATE, VARCHAR) { x, t -> Datum.varchar(x.date.toString(), t.length) }
-        register(DATE, CHAR) { x, t -> Datum.character(x.date.toString(), t.length) }
-        register(DATE, CLOB) { x, t -> Datum.clob(x.date.toString().toByteArray(), t.length) }
-        register(DATE, STRING) { x, _ -> Datum.string(x.date.toString()) }
-        register(DATE, DATE) { x, _ -> Datum.date(x.date) }
-        register(DATE, TIMESTAMP) { x, _ -> Datum.timestamp(DateTimeValue.timestamp(x.date, DateTimeValue.time(0, 0, 0))) }
-        register(DATE, TIMESTAMPZ) { x, _ -> Datum.timestamp(DateTimeValue.timestamp(x.date, DateTimeValue.time(0, 0, 0))) }
+        register(DATE, STRING) { x, _ -> Datum.string(x.localDate.toString()) }
+        register(DATE, DATE) { x, _ -> Datum.date(x.localDate) }
+        register(DATE, TIMESTAMP) { x, _ -> Datum.timestamp(x.localDate.atTime(LocalTime.MIN), 0) }
+        register(DATE, TIMESTAMPZ) { x, _ -> Datum.timestampz(x.localDate.atTime(LocalTime.MIN).atOffset(ZoneOffset.UTC), 0) }
     }
 
     private fun registerTime() {
         // WITHOUT TZ
-        register(TIME, VARCHAR) { x, t -> Datum.varchar(x.time.toString(), t.length) }
-        register(TIME, CHAR) { x, t -> Datum.character(x.time.toString(), t.length) }
-        register(TIME, CLOB) { x, t -> Datum.clob(x.time.toString().toByteArray(), t.length) }
-        register(TIME, STRING) { x, _ -> Datum.string(x.time.toString()) }
-        register(TIME, TIME) { x, _ -> Datum.time(x.time) }
-        register(TIME, TIMESTAMP) { x, _ -> Datum.timestamp(DateTimeValue.timestamp(DateTimeValue.date(1970, 1, 1), x.time)) }
-        register(TIME, TIMESTAMPZ) { x, _ -> Datum.timestamp(DateTimeValue.timestamp(DateTimeValue.date(1970, 1, 1), x.time)) }
+        register(TIME, STRING) { x, _ -> Datum.string(x.localTime.toString()) }
+        register(TIME, TIME) { x, t -> Datum.time(x.localTime, t.precision) }
+        register(TIME, TIMEZ) { x, t -> Datum.timez(x.localTime.atOffset(ZoneOffset.UTC), t.precision) }
+        register(TIME, TIMESTAMP) { x, t -> Datum.timestamp(x.localTime.atDate(LocalDate.now()), t.precision) }
+        register(TIME, TIMESTAMPZ) { x, t -> Datum.timestampz(x.localTime.atDate(LocalDate.now()).atOffset(ZoneOffset.UTC), t.precision) }
+        // WITH TZ
+        register(TIMEZ, STRING) { x, _ -> Datum.string(x.offsetTime.toString()) }
+        register(TIMEZ, TIME) { x, t -> Datum.time(x.localTime, t.precision) }
+        register(TIMEZ, TIMEZ) { x, t -> Datum.timez(x.offsetTime, t.precision) }
+        register(TIMEZ, TIMESTAMP) { x, t -> Datum.timestamp(x.localTime.atDate(LocalDate.now()), t.precision) }
+        register(TIMEZ, TIMESTAMPZ) { x, t -> Datum.timestampz(x.offsetTime.atDate(LocalDate.now()), t.precision) }
+    }
 
+    private fun registerTimestamp() {
+        // WITHOUT TZ
+        register(TIMESTAMP, STRING) { x, _ -> Datum.string(x.localDateTime.toString()) }
+        register(TIMESTAMP, TIMESTAMP) { x, t -> Datum.timestamp(x.localDateTime, t.precision) }
+        register(TIMESTAMP, TIMESTAMPZ) { x, t -> Datum.timestampz(x.localDateTime.atOffset(ZoneOffset.UTC), t.precision) }
+        register(TIMESTAMP, TIME) { x, t -> Datum.time(x.localTime, t.precision) }
+        register(TIMESTAMP, DATE) { x, _ -> Datum.date(x.localDate) }
         // WITH TZ
-        register(TIMEZ, VARCHAR) { x, t -> Datum.varchar(x.time.toString(), t.length) }
-        register(TIMEZ, CHAR) { x, t -> Datum.character(x.time.toString(), t.length) }
-        register(TIMEZ, CLOB) { x, t -> Datum.clob(x.time.toString().toByteArray(), t.length) }
-        register(TIMEZ, STRING) { x, _ -> Datum.string(x.time.toString()) }
-        register(TIMEZ, TIME) { x, _ -> Datum.time(x.time) }
-        register(TIMEZ, TIMESTAMP) { x, _ -> Datum.timestamp(DateTimeValue.timestamp(DateTimeValue.date(1970, 1, 1), x.time)) }
-        register(TIMEZ, TIMESTAMPZ) { x, _ -> Datum.timestamp(DateTimeValue.timestamp(DateTimeValue.date(1970, 1, 1), x.time)) }
+        register(TIMESTAMPZ, STRING) { x, _ -> Datum.string(x.localDateTime.toString()) }
+        register(TIMESTAMPZ, TIMESTAMP) { x, t -> Datum.timestamp(x.localDateTime, t.precision) }
+        register(TIMESTAMPZ, TIMESTAMPZ) { x, t -> Datum.timestampz(x.offsetDateTime, t.precision) }
+        register(TIMESTAMPZ, TIME) { x, t -> Datum.time(x.localTime, t.precision) }
+        register(TIMESTAMPZ, DATE) { x, _ -> Datum.date(x.localDate) }
     }
 
     private fun registerVariant() {
diff --git a/partiql-parser/src/main/kotlin/org/partiql/parser/internal/PartiQLParserDefault.kt b/partiql-parser/src/main/kotlin/org/partiql/parser/internal/PartiQLParserDefault.kt
index 21b9d41afa..7df3e74324 100644
--- a/partiql-parser/src/main/kotlin/org/partiql/parser/internal/PartiQLParserDefault.kt
+++ b/partiql-parser/src/main/kotlin/org/partiql/parser/internal/PartiQLParserDefault.kt
@@ -1949,7 +1949,7 @@ internal class PartiQLParserDefault : PartiQLParser {
             }
             val precision = ctx.LITERAL_INTEGER()?.let {
                 val p = it.text.toBigInteger().toInt()
-                if (p < 0 || 9 < p) throw error(it.symbol, "Precision out of bounds")
+                if (p < 0 || 9 < p) throw error(it.symbol, "Precision out of bounds [0,9]")
                 p
             }
             val type = when (ctx.ZONE()) {
diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt
index 6f04f2a863..9b28fb9ba1 100644
--- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt
+++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/transforms/RexConverter.kt
@@ -89,17 +89,14 @@ import org.partiql.planner.internal.ir.rexOpVarLocal
 import org.partiql.planner.internal.ir.rexOpVarUnresolved
 import org.partiql.planner.internal.typer.CompilerType
 import org.partiql.planner.internal.typer.PlanTyper.Companion.toCType
-import org.partiql.planner.internal.utils.DateTimeUtils
+import org.partiql.planner.internal.util.DateTimeUtils
 import org.partiql.spi.catalog.Identifier
 import org.partiql.spi.value.Datum
 import org.partiql.types.PType
-import org.partiql.value.datetime.DateTimeValue
 import java.math.BigDecimal
 import java.math.BigInteger
 import java.math.MathContext
 import java.math.RoundingMode
-import java.time.LocalDate
-import java.time.format.DateTimeFormatter
 import org.partiql.ast.SetQuantifier as AstSetQuantifier
 
 /**
@@ -192,20 +189,28 @@ internal object RexConverter {
                     val typedString = this.stringValue()
                     when (type.code()) {
                         DataType.DATE -> {
-                            val value = LocalDate.parse(typedString, DateTimeFormatter.ISO_LOCAL_DATE)
-                            val date = DateTimeValue.date(value.year, value.monthValue, value.dayOfMonth)
+                            val date = DateTimeUtils.parseDate(typedString)
                             return Datum.date(date)
                         }
-                        DataType.TIME, DataType.TIME_WITH_TIME_ZONE -> {
-                            val time = DateTimeUtils.parseTimeLiteral(typedString)
+                        DataType.TIME -> {
+                            val time = DateTimeUtils.parseTime(typedString)
                             val precision = type.precision ?: 6
                             return Datum.time(time, precision)
                         }
-                        DataType.TIMESTAMP, DataType.TIMESTAMP_WITH_TIME_ZONE -> {
+                        DataType.TIME_WITH_TIME_ZONE -> {
+                            val time = DateTimeUtils.parseTimez(typedString)
+                            val precision = type.precision ?: 6
+                            return Datum.timez(time, precision)
+                        }
+                        DataType.TIMESTAMP -> {
                             val timestamp = DateTimeUtils.parseTimestamp(typedString)
                             val precision = type.precision ?: 6
-                            val value = timestamp.toPrecision(precision)
-                            return Datum.timestamp(value)
+                            return Datum.timestamp(timestamp, precision)
+                        }
+                        DataType.TIMESTAMP_WITH_TIME_ZONE -> {
+                            val timestamp = DateTimeUtils.parseTimestampz(typedString)
+                            val precision = type.precision ?: 6
+                            return Datum.timestampz(timestamp, precision)
                         }
                         else -> error("Unsupported typed literal string: $this")
                     }
@@ -240,7 +245,11 @@ internal object RexConverter {
          * @param ctx
          * @return
          */
-        internal fun visitExprCoerce(node: Expr, ctx: Env, coercion: Rex.Op.Subquery.Coercion = Rex.Op.Subquery.Coercion.SCALAR): Rex {
+        internal fun visitExprCoerce(
+            node: Expr,
+            ctx: Env,
+            coercion: Rex.Op.Subquery.Coercion = Rex.Op.Subquery.Coercion.SCALAR,
+        ): Rex {
             val rex = node.accept(this, ctx)
             return when (isSqlSelect(node)) {
                 true -> {
@@ -291,7 +300,8 @@ internal object RexConverter {
             val args = when (symbol) {
                 "<", ">",
                 "<=", ">=",
-                "=", "<>", "!=" -> {
+                "=", "<>", "!=",
+                -> {
                     when {
                         // Example: [1, 2] < (SELECT a, b FROM t)
                         isLiteralArray(lhs) && isSqlSelect(rhs) -> {
@@ -553,9 +563,18 @@ internal object RexConverter {
             val selectRef = fromNode.type.schema.size - 1
 
             val constructor = when (val op = curPathNavi.op) {
-                is Rex.Op.Path.Index -> rex(curPathNavi.type, rexOpPathIndex(rex(op.root.type, rexOpVarLocal(0, selectRef)), op.key))
-                is Rex.Op.Path.Key -> rex(curPathNavi.type, rexOpPathKey(rex(op.root.type, rexOpVarLocal(0, selectRef)), op.key))
-                is Rex.Op.Path.Symbol -> rex(curPathNavi.type, rexOpPathSymbol(rex(op.root.type, rexOpVarLocal(0, selectRef)), op.key))
+                is Rex.Op.Path.Index -> rex(
+                    curPathNavi.type,
+                    rexOpPathIndex(rex(op.root.type, rexOpVarLocal(0, selectRef)), op.key)
+                )
+                is Rex.Op.Path.Key -> rex(
+                    curPathNavi.type,
+                    rexOpPathKey(rex(op.root.type, rexOpVarLocal(0, selectRef)), op.key)
+                )
+                is Rex.Op.Path.Symbol -> rex(
+                    curPathNavi.type,
+                    rexOpPathSymbol(rex(op.root.type, rexOpVarLocal(0, selectRef)), op.key)
+                )
                 is Rex.Op.Var.Local -> rex(curPathNavi.type, rexOpVarLocal(0, selectRef))
                 else -> throw IllegalStateException()
             }
@@ -867,7 +886,12 @@ internal object RexConverter {
                 DataType.BIT_VARYING -> call("is_bitVarying", arg0) // TODO define in parser
                 // <numeric types> - <exact numeric types>
                 DataType.NUMERIC -> call("is_numeric", targetType.precision.toRex(), targetType.scale.toRex(), arg0)
-                DataType.DEC, DataType.DECIMAL -> call("is_decimal", targetType.precision.toRex(), targetType.scale.toRex(), arg0)
+                DataType.DEC, DataType.DECIMAL -> call(
+                    "is_decimal",
+                    targetType.precision.toRex(),
+                    targetType.scale.toRex(),
+                    arg0
+                )
                 DataType.BIGINT, DataType.INT8, DataType.INTEGER8 -> call("is_int64", arg0)
                 DataType.INT4, DataType.INTEGER4, DataType.INTEGER -> call("is_int32", arg0)
                 DataType.INT -> call("is_int", arg0)
@@ -1109,9 +1133,24 @@ internal object RexConverter {
                 // <datetime type>
                 DataType.DATE -> PType.date()
                 DataType.TIME -> assertGtEqZeroAndCreate(PType.TIME, "precision", type.precision ?: 0, PType::time)
-                DataType.TIME_WITH_TIME_ZONE -> assertGtEqZeroAndCreate(PType.TIMEZ, "precision", type.precision ?: 0, PType::timez)
-                DataType.TIMESTAMP -> assertGtEqZeroAndCreate(PType.TIMESTAMP, "precision", type.precision ?: 6, PType::timestamp)
-                DataType.TIMESTAMP_WITH_TIME_ZONE -> assertGtEqZeroAndCreate(PType.TIMESTAMPZ, "precision", type.precision ?: 6, PType::timestampz)
+                DataType.TIME_WITH_TIME_ZONE -> assertGtEqZeroAndCreate(
+                    PType.TIMEZ,
+                    "precision",
+                    type.precision ?: 0,
+                    PType::timez
+                )
+                DataType.TIMESTAMP -> assertGtEqZeroAndCreate(
+                    PType.TIMESTAMP,
+                    "precision",
+                    type.precision ?: 6,
+                    PType::timestamp
+                )
+                DataType.TIMESTAMP_WITH_TIME_ZONE -> assertGtEqZeroAndCreate(
+                    PType.TIMESTAMPZ,
+                    "precision",
+                    type.precision ?: 6,
+                    PType::timestampz
+                )
                 // <interval type>
                 DataType.INTERVAL -> error("INTERVAL is not supported yet.")
                 // <container type>
diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/util/DateTimeUtils.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/util/DateTimeUtils.kt
new file mode 100644
index 0000000000..4c893f9e6e
--- /dev/null
+++ b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/util/DateTimeUtils.kt
@@ -0,0 +1,113 @@
+package org.partiql.planner.internal.util
+
+import java.math.BigDecimal
+import java.time.DateTimeException
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+import java.time.OffsetDateTime
+import java.time.OffsetTime
+import java.time.ZoneOffset
+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 parseDate(input: String): LocalDate {
+        val matcher: Matcher = DATE_PATTERN.matcher(input)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expected Date Format to be in YYYY-MM-DD, received $input"
+        )
+        val year = matcher.group("year").toInt()
+        val month = matcher.group("month").toInt()
+        val day = matcher.group("day").toInt()
+        return LocalDate.of(year, month, day)
+    }
+
+    internal fun parseTime(input: String): LocalTime {
+        val matcher: Matcher = TIME_PATTERN.matcher(input)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expect TIME Format to be in HH-mm-ss.ddd+[+|-][hh:mm|z], received $input"
+        )
+        try {
+            val hour = matcher.group("hour").toInt()
+            val minute = matcher.group("minute").toInt()
+            val second = matcher.group("second").toInt()
+            val fraction = matcher.group("fraction")?.let { BigDecimal(".$it") } ?: BigDecimal.ZERO
+            val nanoOfSecond = fraction.movePointRight(9).toInt()
+            val timeZoneString = matcher.group("timezone") ?: null
+            if (timeZoneString != null) {
+                throw DateTimeException("Expect TIME Format to be in HH-mm-ss.ddd, received $input")
+            }
+            return LocalTime.of(hour, minute, second, nanoOfSecond)
+        } catch (e: IllegalStateException) {
+            throw DateTimeException(e.localizedMessage)
+        } catch (e: IllegalArgumentException) {
+            throw DateTimeException(e.localizedMessage)
+        }
+    }
+
+    internal fun parseTimez(input: String): OffsetTime {
+        val matcher: Matcher = TIME_PATTERN.matcher(input)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expect TIME Format to be in HH-mm-ss.ddd+[+|-][hh:mm|z], received $input"
+        )
+        try {
+            val hour = matcher.group("hour").toInt()
+            val minute = matcher.group("minute").toInt()
+            val second = matcher.group("second").toInt()
+            val fraction = matcher.group("fraction")?.let { BigDecimal(".$it") } ?: BigDecimal.ZERO
+            val nanoOfSecond = fraction.movePointRight(9).toInt()
+            matcher.group("utc")?.let {
+                return OffsetTime.of(hour, minute, second, nanoOfSecond, ZoneOffset.UTC)
+            }
+            // zone
+            val timeZoneString = matcher.group("timezone") ?: null
+            if (timeZoneString == null) throw DateTimeException("Expect TIME Format to be in HH-mm-ss.ddd+[+|-][hh:mm|z], received $input")
+            //
+            val timeZone = getTimeZoneComponent(timeZoneString)
+            return OffsetTime.of(hour, minute, second, nanoOfSecond, timeZone)
+        } catch (e: IllegalStateException) {
+            throw DateTimeException(e.localizedMessage)
+        } catch (e: IllegalArgumentException) {
+            throw DateTimeException(e.localizedMessage)
+        }
+    }
+
+    fun parseTimestamp(input: String): LocalDateTime {
+        val matcher: Matcher = TIMESTAMP_PATTERN.matcher(input)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expected TIMESTAMP Format should be in YYYY-MM-DD[\\s|T]hh:mm:ss.ddd+[hh:mm|z], received $input"
+        )
+        val date = parseDate(matcher.group("date"))
+        val time = parseTime(matcher.group("time"))
+        return LocalDateTime.of(date, time)
+    }
+
+    fun parseTimestampz(input: String): OffsetDateTime {
+        val matcher: Matcher = TIMESTAMP_PATTERN.matcher(input)
+        if (!matcher.matches()) throw DateTimeException(
+            "Expected TIMESTAMP Format should be in YYYY-MM-DD[\\s|T]hh:mm:ss.ddd+[hh:mm|z], received $input"
+        )
+        val date = parseDate(matcher.group("date"))
+        val time = parseTimez(matcher.group("time"))
+        return OffsetDateTime.of(date, time.toLocalTime(), time.offset)
+    }
+
+    private fun getTimeZoneComponent(timezone: String): ZoneOffset {
+        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 -> error("unknown zone offset")
+            tzSign == '-' -> ZoneOffset.ofHoursMinutes(-tzHour, -tzMinute)
+            else -> ZoneOffset.ofHoursMinutes(tzHour, tzMinute)
+        }
+    }
+}
diff --git a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/utils/DateTimeUtils.kt b/partiql-planner/src/main/kotlin/org/partiql/planner/internal/utils/DateTimeUtils.kt
deleted file mode 100644
index 1cd4dabc05..0000000000
--- a/partiql-planner/src/main/kotlin/org/partiql/planner/internal/utils/DateTimeUtils.kt
+++ /dev/null
@@ -1,76 +0,0 @@
-package org.partiql.planner.internal.utils
-
-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-spi/api/partiql-spi.api b/partiql-spi/api/partiql-spi.api
index a784ebee64..13636b03f6 100644
--- a/partiql-spi/api/partiql-spi.api
+++ b/partiql-spi/api/partiql-spi.api
@@ -477,7 +477,7 @@ public abstract interface class org/partiql/spi/value/Datum : java/lang/Iterable
 	public static fun clob ([BI)Lorg/partiql/spi/value/Datum;
 	public static fun comparator ()Ljava/util/Comparator;
 	public static fun comparator (Z)Ljava/util/Comparator;
-	public static fun date (Lorg/partiql/value/datetime/Date;)Lorg/partiql/spi/value/Datum;
+	public static fun date (Ljava/time/LocalDate;)Lorg/partiql/spi/value/Datum;
 	public static fun decimal (Ljava/math/BigDecimal;)Lorg/partiql/spi/value/Datum;
 	public static fun decimal (Ljava/math/BigDecimal;II)Lorg/partiql/spi/value/Datum;
 	public static fun doublePrecision (D)Lorg/partiql/spi/value/Datum;
@@ -487,18 +487,19 @@ public abstract interface class org/partiql/spi/value/Datum : java/lang/Iterable
 	public fun getBoolean ()Z
 	public fun getByte ()B
 	public fun getBytes ()[B
-	public fun getDate ()Lorg/partiql/value/datetime/Date;
 	public fun getDouble ()D
 	public fun getFields ()Ljava/util/Iterator;
 	public fun getFloat ()F
 	public fun getInsensitive (Ljava/lang/String;)Lorg/partiql/spi/value/Datum;
 	public fun getInt ()I
-	public fun getInterval ()J
+	public fun getLocalDate ()Ljava/time/LocalDate;
+	public fun getLocalDateTime ()Ljava/time/LocalDateTime;
+	public fun getLocalTime ()Ljava/time/LocalTime;
 	public fun getLong ()J
+	public fun getOffsetDateTime ()Ljava/time/OffsetDateTime;
+	public fun getOffsetTime ()Ljava/time/OffsetTime;
 	public fun getShort ()S
 	public fun getString ()Ljava/lang/String;
-	public fun getTime ()Lorg/partiql/value/datetime/Time;
-	public fun getTimestamp ()Lorg/partiql/value/datetime/Timestamp;
 	public abstract fun getType ()Lorg/partiql/types/PType;
 	public static fun integer (I)Lorg/partiql/spi/value/Datum;
 	public static fun ion (Ljava/lang/String;)Lorg/partiql/spi/value/Datum;
@@ -517,10 +518,10 @@ public abstract interface class org/partiql/spi/value/Datum : java/lang/Iterable
 	public static fun string (Ljava/lang/String;)Lorg/partiql/spi/value/Datum;
 	public static fun struct ()Lorg/partiql/spi/value/Datum;
 	public static fun struct (Ljava/lang/Iterable;)Lorg/partiql/spi/value/Datum;
-	public static fun time (Lorg/partiql/value/datetime/Time;)Lorg/partiql/spi/value/Datum;
-	public static fun time (Lorg/partiql/value/datetime/Time;I)Lorg/partiql/spi/value/Datum;
-	public static fun timestamp (Lorg/partiql/value/datetime/Timestamp;)Lorg/partiql/spi/value/Datum;
-	public static fun timestamp (Lorg/partiql/value/datetime/Timestamp;I)Lorg/partiql/spi/value/Datum;
+	public static fun time (Ljava/time/LocalTime;I)Lorg/partiql/spi/value/Datum;
+	public static fun timestamp (Ljava/time/LocalDateTime;I)Lorg/partiql/spi/value/Datum;
+	public static fun timestampz (Ljava/time/OffsetDateTime;I)Lorg/partiql/spi/value/Datum;
+	public static fun timez (Ljava/time/OffsetTime;I)Lorg/partiql/spi/value/Datum;
 	public static fun tinyint (B)Lorg/partiql/spi/value/Datum;
 	public static fun varchar (Ljava/lang/String;)Lorg/partiql/spi/value/Datum;
 	public static fun varchar (Ljava/lang/String;I)Lorg/partiql/spi/value/Datum;
@@ -556,272 +557,6 @@ public abstract interface class org/partiql/spi/value/Field {
 	public static fun of (Ljava/lang/String;Lorg/partiql/spi/value/Datum;)Lorg/partiql/spi/value/Field;
 }
 
-public abstract interface class org/partiql/value/datetime/Date : java/lang/Comparable, org/partiql/value/datetime/DateTime {
-	public abstract fun atTime (Lorg/partiql/value/datetime/Time;)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun compareTo (Lorg/partiql/value/datetime/Date;)I
-	public abstract fun getDay ()Ljava/lang/Integer;
-	public abstract fun getDecimalSecond ()Ljava/math/BigDecimal;
-	public abstract fun getHour ()Ljava/lang/Integer;
-	public abstract fun getMinute ()Ljava/lang/Integer;
-	public abstract fun getMonth ()Ljava/lang/Integer;
-	public abstract fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public abstract fun getYear ()Ljava/lang/Integer;
-	public abstract fun plusDays (J)Lorg/partiql/value/datetime/Date;
-	public abstract fun plusMonths (J)Lorg/partiql/value/datetime/Date;
-	public abstract fun plusYears (J)Lorg/partiql/value/datetime/Date;
-}
-
-public final class org/partiql/value/datetime/Date$DefaultImpls {
-	public static fun compareTo (Lorg/partiql/value/datetime/Date;Lorg/partiql/value/datetime/Date;)I
-	public static fun getDecimalSecond (Lorg/partiql/value/datetime/Date;)Ljava/math/BigDecimal;
-	public static fun getHour (Lorg/partiql/value/datetime/Date;)Ljava/lang/Integer;
-	public static fun getMinute (Lorg/partiql/value/datetime/Date;)Ljava/lang/Integer;
-	public static fun getTimeZone (Lorg/partiql/value/datetime/Date;)Lorg/partiql/value/datetime/TimeZone;
-}
-
-public abstract class org/partiql/value/datetime/DateImpl : java/lang/Comparable, org/partiql/value/datetime/Date {
-	public fun <init> ()V
-	public synthetic fun compareTo (Ljava/lang/Object;)I
-	public fun compareTo (Lorg/partiql/value/datetime/Date;)I
-	public final fun equals (Ljava/lang/Object;)Z
-	public fun getDecimalSecond ()Ljava/math/BigDecimal;
-	public fun getHour ()Ljava/lang/Integer;
-	public fun getMinute ()Ljava/lang/Integer;
-	public fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public final fun hashCode ()I
-	public final fun toString ()Ljava/lang/String;
-}
-
-public abstract interface class org/partiql/value/datetime/DateTime {
-	public abstract fun equals (Ljava/lang/Object;)Z
-	public abstract fun getDay ()Ljava/lang/Integer;
-	public abstract fun getDecimalSecond ()Ljava/math/BigDecimal;
-	public abstract fun getHour ()Ljava/lang/Integer;
-	public abstract fun getMinute ()Ljava/lang/Integer;
-	public abstract fun getMonth ()Ljava/lang/Integer;
-	public abstract fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public abstract fun getYear ()Ljava/lang/Integer;
-	public abstract fun hashCode ()I
-	public abstract fun toString ()Ljava/lang/String;
-}
-
-public final class org/partiql/value/datetime/DateTimeException : java/lang/RuntimeException {
-	public fun <init> ()V
-	public fun <init> (Ljava/lang/String;Ljava/lang/Throwable;)V
-	public synthetic fun <init> (Ljava/lang/String;Ljava/lang/Throwable;ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public fun getCause ()Ljava/lang/Throwable;
-	public fun getMessage ()Ljava/lang/String;
-}
-
-public final class org/partiql/value/datetime/DateTimeValue {
-	public static final field INSTANCE Lorg/partiql/value/datetime/DateTimeValue;
-	public static final fun date (III)Lorg/partiql/value/datetime/Date;
-	public final fun time (III)Lorg/partiql/value/datetime/Time;
-	public final fun time (IIII)Lorg/partiql/value/datetime/Time;
-	public final fun time (IIIILorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/Time;
-	public final fun time (IIILorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/Time;
-	public final fun time (IILjava/math/BigDecimal;)Lorg/partiql/value/datetime/Time;
-	public final fun time (IILjava/math/BigDecimal;Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/Time;
-	public static synthetic fun time$default (Lorg/partiql/value/datetime/DateTimeValue;IIIILorg/partiql/value/datetime/TimeZone;ILjava/lang/Object;)Lorg/partiql/value/datetime/Time;
-	public static synthetic fun time$default (Lorg/partiql/value/datetime/DateTimeValue;IIILorg/partiql/value/datetime/TimeZone;ILjava/lang/Object;)Lorg/partiql/value/datetime/Time;
-	public static synthetic fun time$default (Lorg/partiql/value/datetime/DateTimeValue;IILjava/math/BigDecimal;Lorg/partiql/value/datetime/TimeZone;ILjava/lang/Object;)Lorg/partiql/value/datetime/Time;
-	public final fun timestamp (I)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (II)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (III)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (IIII)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (IIIII)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (IIIIII)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (IIIIIILorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (IIIIILjava/math/BigDecimal;)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (IIIIILjava/math/BigDecimal;Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/Timestamp;
-	public final fun timestamp (Lcom/amazon/ion/Timestamp;)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public final fun timestamp (Ljava/math/BigDecimal;Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public final fun timestamp (Lorg/partiql/value/datetime/Date;Lorg/partiql/value/datetime/Time;)Lorg/partiql/value/datetime/Timestamp;
-	public static synthetic fun timestamp$default (Lorg/partiql/value/datetime/DateTimeValue;IIIIIILorg/partiql/value/datetime/TimeZone;ILjava/lang/Object;)Lorg/partiql/value/datetime/Timestamp;
-	public static synthetic fun timestamp$default (Lorg/partiql/value/datetime/DateTimeValue;IIIIILjava/math/BigDecimal;Lorg/partiql/value/datetime/TimeZone;ILjava/lang/Object;)Lorg/partiql/value/datetime/Timestamp;
-}
-
-public abstract interface class org/partiql/value/datetime/Time : java/lang/Comparable, org/partiql/value/datetime/DateTime {
-	public abstract fun atDate (Lorg/partiql/value/datetime/Date;)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun compareTo (Lorg/partiql/value/datetime/Time;)I
-	public abstract fun getDay ()Ljava/lang/Integer;
-	public abstract fun getDecimalSecond ()Ljava/math/BigDecimal;
-	public abstract fun getElapsedSecond ()Ljava/math/BigDecimal;
-	public abstract fun getHour ()Ljava/lang/Integer;
-	public abstract fun getMinute ()Ljava/lang/Integer;
-	public abstract fun getMonth ()Ljava/lang/Integer;
-	public abstract fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public abstract fun getYear ()Ljava/lang/Integer;
-	public abstract fun plusHours (J)Lorg/partiql/value/datetime/Time;
-	public abstract fun plusMinutes (J)Lorg/partiql/value/datetime/Time;
-	public abstract fun plusSeconds (J)Lorg/partiql/value/datetime/Time;
-	public abstract fun plusSeconds (Ljava/math/BigDecimal;)Lorg/partiql/value/datetime/Time;
-	public abstract fun toPrecision (I)Lorg/partiql/value/datetime/Time;
-}
-
-public final class org/partiql/value/datetime/Time$DefaultImpls {
-	public static fun compareTo (Lorg/partiql/value/datetime/Time;Lorg/partiql/value/datetime/Time;)I
-	public static fun getDay (Lorg/partiql/value/datetime/Time;)Ljava/lang/Integer;
-	public static fun getMonth (Lorg/partiql/value/datetime/Time;)Ljava/lang/Integer;
-	public static fun getYear (Lorg/partiql/value/datetime/Time;)Ljava/lang/Integer;
-}
-
-public abstract class org/partiql/value/datetime/TimeWithTimeZone : org/partiql/value/datetime/Time {
-	public fun <init> ()V
-	public abstract fun atDate (Lorg/partiql/value/datetime/Date;)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public abstract fun atTimeZone (Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/TimeWithTimeZone;
-	public synthetic fun compareTo (Ljava/lang/Object;)I
-	public fun compareTo (Lorg/partiql/value/datetime/Time;)I
-	public final fun equals (Ljava/lang/Object;)Z
-	public fun getDay ()Ljava/lang/Integer;
-	public fun getMonth ()Ljava/lang/Integer;
-	public abstract fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public fun getYear ()Ljava/lang/Integer;
-	public final fun hashCode ()I
-	public abstract fun plusHours (J)Lorg/partiql/value/datetime/TimeWithTimeZone;
-	public abstract fun plusMinutes (J)Lorg/partiql/value/datetime/TimeWithTimeZone;
-	public final fun plusSeconds (J)Lorg/partiql/value/datetime/Time;
-	public abstract fun plusSeconds (Ljava/math/BigDecimal;)Lorg/partiql/value/datetime/TimeWithTimeZone;
-	public synthetic fun toPrecision (I)Lorg/partiql/value/datetime/Time;
-	public final fun toPrecision (I)Lorg/partiql/value/datetime/TimeWithTimeZone;
-	public final fun toString ()Ljava/lang/String;
-	public abstract fun toTimeWithoutTimeZone (Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/TimeWithoutTimeZone;
-}
-
-public abstract class org/partiql/value/datetime/TimeWithoutTimeZone : org/partiql/value/datetime/Time {
-	public fun <init> ()V
-	public abstract fun atDate (Lorg/partiql/value/datetime/Date;)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public synthetic fun compareTo (Ljava/lang/Object;)I
-	public fun compareTo (Lorg/partiql/value/datetime/Time;)I
-	public final fun equals (Ljava/lang/Object;)Z
-	public fun getDay ()Ljava/lang/Integer;
-	public fun getMonth ()Ljava/lang/Integer;
-	public final fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public fun getYear ()Ljava/lang/Integer;
-	public final fun hashCode ()I
-	public abstract fun plusHours (J)Lorg/partiql/value/datetime/TimeWithoutTimeZone;
-	public abstract fun plusMinutes (J)Lorg/partiql/value/datetime/TimeWithoutTimeZone;
-	public final fun plusSeconds (J)Lorg/partiql/value/datetime/Time;
-	public abstract fun plusSeconds (Ljava/math/BigDecimal;)Lorg/partiql/value/datetime/TimeWithoutTimeZone;
-	public synthetic fun toPrecision (I)Lorg/partiql/value/datetime/Time;
-	public final fun toPrecision (I)Lorg/partiql/value/datetime/TimeWithoutTimeZone;
-	public final fun toString ()Ljava/lang/String;
-	public abstract fun withTimeZone (Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/TimeWithTimeZone;
-}
-
-public abstract class org/partiql/value/datetime/TimeZone {
-}
-
-public final class org/partiql/value/datetime/TimeZone$UnknownTimeZone : org/partiql/value/datetime/TimeZone {
-	public static final field INSTANCE Lorg/partiql/value/datetime/TimeZone$UnknownTimeZone;
-}
-
-public final class org/partiql/value/datetime/TimeZone$UtcOffset : org/partiql/value/datetime/TimeZone {
-	public static final field Companion Lorg/partiql/value/datetime/TimeZone$UtcOffset$Companion;
-	public synthetic fun <init> (ILkotlin/jvm/internal/DefaultConstructorMarker;)V
-	public final fun component1 ()I
-	public final fun copy (I)Lorg/partiql/value/datetime/TimeZone$UtcOffset;
-	public static synthetic fun copy$default (Lorg/partiql/value/datetime/TimeZone$UtcOffset;IILjava/lang/Object;)Lorg/partiql/value/datetime/TimeZone$UtcOffset;
-	public fun equals (Ljava/lang/Object;)Z
-	public final fun getTotalOffsetMinutes ()I
-	public final fun getTzHour ()I
-	public final fun getTzMinute ()I
-	public fun hashCode ()I
-	public static final fun of (I)Lorg/partiql/value/datetime/TimeZone$UtcOffset;
-	public static final fun of (II)Lorg/partiql/value/datetime/TimeZone$UtcOffset;
-	public fun toString ()Ljava/lang/String;
-}
-
-public final class org/partiql/value/datetime/TimeZone$UtcOffset$Companion {
-	public final fun of (I)Lorg/partiql/value/datetime/TimeZone$UtcOffset;
-	public final fun of (II)Lorg/partiql/value/datetime/TimeZone$UtcOffset;
-}
-
-public abstract interface class org/partiql/value/datetime/Timestamp : java/lang/Comparable, org/partiql/value/datetime/DateTime {
-	public abstract fun compareTo (Lorg/partiql/value/datetime/Timestamp;)I
-	public abstract fun getDay ()Ljava/lang/Integer;
-	public abstract fun getDecimalSecond ()Ljava/math/BigDecimal;
-	public abstract fun getHour ()Ljava/lang/Integer;
-	public abstract fun getMinute ()Ljava/lang/Integer;
-	public abstract fun getMonth ()Ljava/lang/Integer;
-	public abstract fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public abstract fun getYear ()Ljava/lang/Integer;
-	public abstract fun plusDays (J)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun plusHours (J)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun plusMinutes (J)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun plusMonths (J)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun plusSeconds (J)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun plusSeconds (Ljava/math/BigDecimal;)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun plusYears (J)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun toDate ()Lorg/partiql/value/datetime/Date;
-	public abstract fun toPrecision (I)Lorg/partiql/value/datetime/Timestamp;
-	public abstract fun toTime ()Lorg/partiql/value/datetime/Time;
-}
-
-public final class org/partiql/value/datetime/Timestamp$DefaultImpls {
-	public static fun compareTo (Lorg/partiql/value/datetime/Timestamp;Lorg/partiql/value/datetime/Timestamp;)I
-	public static fun toDate (Lorg/partiql/value/datetime/Timestamp;)Lorg/partiql/value/datetime/Date;
-}
-
-public abstract class org/partiql/value/datetime/TimestampWithTimeZone : org/partiql/value/datetime/Timestamp {
-	public static final field Companion Lorg/partiql/value/datetime/TimestampWithTimeZone$Companion;
-	public fun <init> ()V
-	public abstract fun atTimeZone (Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public synthetic fun compareTo (Ljava/lang/Object;)I
-	public fun compareTo (Lorg/partiql/value/datetime/Timestamp;)I
-	public final fun equals (Ljava/lang/Object;)Z
-	public final fun getEpochMillis ()Ljava/math/BigDecimal;
-	public abstract fun getEpochSecond ()Ljava/math/BigDecimal;
-	public abstract fun getIonRaw ()Lcom/amazon/ion/Timestamp;
-	public final fun getIonTimestampValue ()Lcom/amazon/ion/Timestamp;
-	public abstract fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public final fun hashCode ()I
-	public static final fun nowZ ()Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public abstract fun plusDays (J)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public abstract fun plusHours (J)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public abstract fun plusMinutes (J)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public abstract fun plusMonths (J)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public synthetic fun plusSeconds (J)Lorg/partiql/value/datetime/Timestamp;
-	public final fun plusSeconds (J)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public abstract fun plusSeconds (Ljava/math/BigDecimal;)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public abstract fun plusYears (J)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public fun toDate ()Lorg/partiql/value/datetime/Date;
-	public synthetic fun toPrecision (I)Lorg/partiql/value/datetime/Timestamp;
-	public final fun toPrecision (I)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-	public final fun toString ()Ljava/lang/String;
-	public synthetic fun toTime ()Lorg/partiql/value/datetime/Time;
-	public final fun toTime ()Lorg/partiql/value/datetime/TimeWithTimeZone;
-	public abstract fun toTimeWithoutTimeZone (Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-}
-
-public final class org/partiql/value/datetime/TimestampWithTimeZone$Companion {
-	public final fun nowZ ()Lorg/partiql/value/datetime/TimestampWithTimeZone;
-}
-
-public abstract class org/partiql/value/datetime/TimestampWithoutTimeZone : org/partiql/value/datetime/Timestamp {
-	public fun <init> ()V
-	public synthetic fun compareTo (Ljava/lang/Object;)I
-	public fun compareTo (Lorg/partiql/value/datetime/Timestamp;)I
-	public final fun equals (Ljava/lang/Object;)Z
-	public fun getTimeZone ()Lorg/partiql/value/datetime/TimeZone;
-	public final fun hashCode ()I
-	public abstract fun plusDays (J)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public abstract fun plusHours (J)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public abstract fun plusMinutes (J)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public abstract fun plusMonths (J)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public synthetic fun plusSeconds (J)Lorg/partiql/value/datetime/Timestamp;
-	public fun plusSeconds (J)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public abstract fun plusSeconds (Ljava/math/BigDecimal;)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public abstract fun plusYears (J)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public fun toDate ()Lorg/partiql/value/datetime/Date;
-	public synthetic fun toPrecision (I)Lorg/partiql/value/datetime/Timestamp;
-	public final fun toPrecision (I)Lorg/partiql/value/datetime/TimestampWithoutTimeZone;
-	public final fun toString ()Ljava/lang/String;
-	public synthetic fun toTime ()Lorg/partiql/value/datetime/Time;
-	public final fun toTime ()Lorg/partiql/value/datetime/TimeWithoutTimeZone;
-	public abstract fun withTimeZone (Lorg/partiql/value/datetime/TimeZone;)Lorg/partiql/value/datetime/TimestampWithTimeZone;
-}
-
 public final class org/partiql/value/util/NumberExtensionsKt {
 	public static final fun coerceNumbers (Ljava/lang/Number;Ljava/lang/Number;)Lkotlin/Pair;
 }
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/Datum.java b/partiql-spi/src/main/java/org/partiql/spi/value/Datum.java
index 9db896e65b..76470b361b 100644
--- a/partiql-spi/src/main/java/org/partiql/spi/value/Datum.java
+++ b/partiql-spi/src/main/java/org/partiql/spi/value/Datum.java
@@ -8,16 +8,12 @@
 import org.partiql.errors.DataException;
 import org.partiql.spi.value.ion.IonVariant;
 import org.partiql.types.PType;
-import org.partiql.value.datetime.Date;
-import org.partiql.value.datetime.Time;
-import org.partiql.value.datetime.Timestamp;
-
-import java.io.InputStream;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.math.MathContext;
 import java.math.RoundingMode;
 import java.nio.charset.Charset;
+import java.time.*;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Iterator;
@@ -123,153 +119,144 @@ default byte getByte() {
 
     /**
      * @return the underlying value applicable to the types:
-     * {@link PType#DATE}.
+     * {@link PType#SMALLINT}
      * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
      *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
      *                                       will throw this exception upon invocation.
      * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
      *                                       {@link #isNull()} returns false before attempting to invoke this method.
      */
-    @NotNull
-    default org.partiql.value.datetime.Date getDate() {
+    default short getShort() {
         throw new UnsupportedOperationException();
     }
 
     /**
      * @return the underlying value applicable to the types:
-     * {@link PType#TIME}
+     * {@link PType#INTEGER}
      * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
      *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
      *                                       will throw this exception upon invocation.
      * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
      *                                       {@link #isNull()} returns false before attempting to invoke this method.
      */
-    @NotNull
-    default Time getTime() {
+    default int getInt() {
         throw new UnsupportedOperationException();
     }
 
     /**
      * @return the underlying value applicable to the types:
-     * {@link PType#TIMESTAMP}.
+     * {@link PType#BIGINT}
      * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
      *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
      *                                       will throw this exception upon invocation.
      * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
      *                                       {@link #isNull()} returns false before attempting to invoke this method.
      */
-    @NotNull
-    default Timestamp getTimestamp() {
+    default long getLong() {
         throw new UnsupportedOperationException();
     }
 
     /**
-     * <b>! ! ! EXPERIMENTAL ! ! !</b> This is an experimental API under development by the PartiQL maintainers.
      * @return the underlying value applicable to the types:
-     * TODO
+     * {@link PType#INTEGER}
      * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
      *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
      *                                       will throw this exception upon invocation.
      * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
      *                                       {@link #isNull()} returns false before attempting to invoke this method.
-     * Please abstain from using this API until given notice otherwise. This may break between iterations without prior notice.
-     * @deprecated This implementation is likely wrong and is not recommended for use.
      */
-    @Deprecated
-    default long getInterval() {
+    @NotNull
+    default BigInteger getBigInteger() {
         throw new UnsupportedOperationException();
     }
 
     /**
      * @return the underlying value applicable to the types:
-     * {@link PType#SMALLINT}
+     * {@link PType#REAL}
      * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
      *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
      *                                       will throw this exception upon invocation.
      * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
      *                                       {@link #isNull()} returns false before attempting to invoke this method.
      */
-    default short getShort() {
+    default float getFloat() {
         throw new UnsupportedOperationException();
     }
 
     /**
      * @return the underlying value applicable to the types:
-     * {@link PType#INTEGER}
+     * {@link PType#DOUBLE}
      * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
      *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
      *                                       will throw this exception upon invocation.
      * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
      *                                       {@link #isNull()} returns false before attempting to invoke this method.
      */
-    default int getInt() {
+    default double getDouble() {
         throw new UnsupportedOperationException();
     }
 
     /**
      * @return the underlying value applicable to the types:
-     * {@link PType#BIGINT}
+     * {@link PType#DECIMAL}
      * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
      *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
      *                                       will throw this exception upon invocation.
      * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
      *                                       {@link #isNull()} returns false before attempting to invoke this method.
      */
-    default long getLong() {
+    @NotNull
+    default BigDecimal getBigDecimal() {
         throw new UnsupportedOperationException();
     }
 
     /**
-     * @return the underlying value applicable to the types:
-     * {@link PType#INTEGER}
-     * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
-     *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
-     *                                       will throw this exception upon invocation.
-     * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
-     *                                       {@link #isNull()} returns false before attempting to invoke this method.
+     * @return a {@link LocalDate} for DATE, TIMESTAMP, and TIMESTAMPZ types.
+     * @throws UnsupportedOperationException if type not in (DATE, TIMESTAMP, TIMESTAMPZ)
+     * @throws NullPointerException          if isNull() is true; callers should check to avoid NPEs.
      */
     @NotNull
-    default BigInteger getBigInteger() {
+    default LocalDate getLocalDate() {
         throw new UnsupportedOperationException();
     }
 
     /**
-     * @return the underlying value applicable to the types:
-     * {@link PType#REAL}
-     * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
-     *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
-     *                                       will throw this exception upon invocation.
-     * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
-     *                                       {@link #isNull()} returns false before attempting to invoke this method.
+     * @return an {@link OffsetTime} for TIME, TIMEZ, TIMESTAMP, TIMESTAMPZ types.
+     * @throws UnsupportedOperationException if type not in (TIME, TIMEZ, TIMESTAMP, TIMESTAMPZ)
+     * @throws NullPointerException          if isNull() is true; callers should check to avoid NPEs.
      */
-    default float getFloat() {
+    @NotNull
+    default LocalTime getLocalTime() {
         throw new UnsupportedOperationException();
     }
 
     /**
-     * @return the underlying value applicable to the types:
-     * {@link PType#DOUBLE}
-     * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
-     *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
-     *                                       will throw this exception upon invocation.
-     * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
-     *                                       {@link #isNull()} returns false before attempting to invoke this method.
+     * @return an {@link OffsetTime} for TIMEZ and TIMESTAMPZ types.
+     * @throws UnsupportedOperationException if type not in (TIMEZ, TIMESTAMPZ)
+     * @throws NullPointerException          if isNull() is true; callers should check to avoid NPEs.
      */
-    default double getDouble() {
+    @NotNull
+    default OffsetTime getOffsetTime() {
+        throw new UnsupportedOperationException("Cannot call getOffsetTime ");
+    }
+
+    /**
+     * @return a {@link LocalDateTime} for TIMESTAMP, TIMESTAMPZ types.
+     * @throws UnsupportedOperationException if type not in (TIMESTAMP, TIMESTAMPZ)
+     * @throws NullPointerException          if isNull() is true; callers should check to avoid NPEs.
+     */
+    @NotNull
+    default LocalDateTime getLocalDateTime() {
         throw new UnsupportedOperationException();
     }
 
     /**
-     * @return the underlying value applicable to the types:
-     * {@link PType#DECIMAL}
-     * @throws UnsupportedOperationException if the operation is not applicable to the type returned from
-     *                                       {@link #getType()}; for example, if {@link #getType()} returns a {@link PType#INTEGER}, then this method
-     *                                       will throw this exception upon invocation.
-     * @throws NullPointerException          if this instance also returns true on {@link #isNull()}; callers should check that
-     *                                       {@link #isNull()} returns false before attempting to invoke this method.
+     * @return a {@link OffsetDateTime} for TIMESTAMPZ types.
+     * @throws UnsupportedOperationException if type not TIMESTAMPZ
+     * @throws NullPointerException          if isNull() is true; callers should check to avoid NPEs.
      */
     @NotNull
-    default BigDecimal getBigDecimal() {
+    default OffsetDateTime getOffsetDateTime() {
         throw new UnsupportedOperationException();
     }
 
@@ -529,28 +516,28 @@ static Datum blob(@NotNull byte[] value, int length) {
     // DATE/TIME
 
     @NotNull
-    static Datum date(@NotNull Date value) {
+    static Datum date(@NotNull LocalDate value) {
         return new DatumDate(value);
     }
 
     @NotNull
-    static Datum time(@NotNull Time value) {
-        return new DatumTime(value);
+    static Datum time(@NotNull LocalTime value, int precision) {
+        return new DatumTime(value, precision);
     }
 
     @NotNull
-    static Datum time(@NotNull Time value, int precision) {
-        return new DatumTime(value, precision);
+    static Datum timez(@NotNull OffsetTime value, int precision) {
+        return new DatumTimez(value, precision);
     }
 
     @NotNull
-    static Datum timestamp(@NotNull Timestamp value) {
-        return new DatumTimestamp(value);
+    static Datum timestamp(@NotNull LocalDateTime value, int precision) {
+        return new DatumTimestamp(value, precision);
     }
 
     @NotNull
-    static Datum timestamp(@NotNull Timestamp value, int precision) {
-        return new DatumTimestamp(value, precision);
+    static Datum timestampz(@NotNull OffsetDateTime value, int precision) {
+        return new DatumTimestampz(value, precision);
     }
 
     // COLLECTIONS
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/DatumComparator.java b/partiql-spi/src/main/java/org/partiql/spi/value/DatumComparator.java
index 69fc85884c..e346ee93f1 100644
--- a/partiql-spi/src/main/java/org/partiql/spi/value/DatumComparator.java
+++ b/partiql-spi/src/main/java/org/partiql/spi/value/DatumComparator.java
@@ -526,7 +526,7 @@ private static DatumComparison[] fillDecimalComparator(DatumComparison[] comps)
 
     @SuppressWarnings({"UnusedReturnValue"})
     private static DatumComparison[] fillDateComparator(DatumComparison[] comps) {
-        comps[DATE] = (self, date, comp) -> self.getDate().compareTo(date.getDate());
+        comps[DATE] = (self, date, comp) -> self.getLocalDate().compareTo(date.getLocalDate());
         return comps;
     }
 
@@ -538,8 +538,8 @@ private static DatumComparison[] fillDateComparator(DatumComparison[] comps) {
      */
     @SuppressWarnings({"UnusedReturnValue"})
     private static DatumComparison[] fillTimeComparator(DatumComparison[] comps) {
-        comps[TIME] = (self, time, comp) -> self.getTime().compareTo(time.getTime());
-        comps[TIMEZ] = (self, time, comp) -> self.getTime().compareTo(time.getTime());
+        comps[TIME] = (self, time, comp) -> self.getLocalTime().compareTo(time.getLocalTime());
+        comps[TIMEZ] = (self, time, comp) -> self.getOffsetTime().compareTo(time.getOffsetTime());
         return comps;
     }
 
@@ -551,8 +551,8 @@ private static DatumComparison[] fillTimeComparator(DatumComparison[] comps) {
      */
     @SuppressWarnings({"UnusedReturnValue"})
     private static DatumComparison[] fillTimestampComparator(DatumComparison[] comps) {
-        comps[TIMESTAMPZ] = (self, timestamp, comp) -> self.getTimestamp().compareTo(timestamp.getTimestamp());
-        comps[TIMESTAMP] = (self, timestamp, comp) -> self.getTimestamp().compareTo(timestamp.getTimestamp());
+        comps[TIMESTAMP] = (self, timestamp, comp) -> self.getLocalDateTime().compareTo(timestamp.getLocalDateTime());
+        comps[TIMESTAMPZ] = (self, timestamp, comp) -> self.getOffsetDateTime().compareTo(timestamp.getOffsetDateTime());
         return comps;
     }
 
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/DatumDate.java b/partiql-spi/src/main/java/org/partiql/spi/value/DatumDate.java
index cac1a359ab..d8c1dce6e3 100644
--- a/partiql-spi/src/main/java/org/partiql/spi/value/DatumDate.java
+++ b/partiql-spi/src/main/java/org/partiql/spi/value/DatumDate.java
@@ -3,34 +3,33 @@
 import org.jetbrains.annotations.NotNull;
 import org.partiql.types.PType;
 
+import java.time.LocalDate;
+
 /**
- * This shall always be package-private (internal).
+ * Today we wrap a {@link LocalDate}, in the future we can do a 7-byte array to avoid double references.
  */
-class DatumDate implements Datum {
+final class DatumDate implements Datum {
 
     @NotNull
-    private final org.partiql.value.datetime.Date _value;
+    private final PType type;
 
-    private static final PType _type = PType.date();
+    @NotNull
+    private final LocalDate value;
 
-    DatumDate(@NotNull org.partiql.value.datetime.Date value) {
-        _value = value;
+    DatumDate(@NotNull LocalDate value) {
+        this.type = PType.date();
+        this.value = value;
     }
 
+    @NotNull
     @Override
-    public boolean isNull() {
-        return false;
+    public PType getType() {
+        return type;
     }
 
     @Override
     @NotNull
-    public org.partiql.value.datetime.Date getDate() {
-        return _value;
-    }
-
-    @NotNull
-    @Override
-    public PType getType() {
-        return _type;
+    public LocalDate getLocalDate() {
+        return value;
     }
 }
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/DatumInterval.java b/partiql-spi/src/main/java/org/partiql/spi/value/DatumInterval.java
deleted file mode 100644
index 4fd9f2b456..0000000000
--- a/partiql-spi/src/main/java/org/partiql/spi/value/DatumInterval.java
+++ /dev/null
@@ -1,27 +0,0 @@
-package org.partiql.spi.value;
-
-import org.jetbrains.annotations.NotNull;
-import org.partiql.types.PType;
-
-/**
- * This shall always be package-private (internal).
- */
-class DatumInterval implements Datum {
-
-    private final long _value;
-
-    DatumInterval(long value) {
-        _value = value;
-    }
-
-    @Override
-    public long getInterval() {
-        return _value;
-    }
-
-    @NotNull
-    @Override
-    public PType getType() {
-        throw new UnsupportedOperationException("NOT YET IMPLEMENTED");
-    }
-}
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/DatumNull.java b/partiql-spi/src/main/java/org/partiql/spi/value/DatumNull.java
index 70da87d9ec..bc4d5fa794 100644
--- a/partiql-spi/src/main/java/org/partiql/spi/value/DatumNull.java
+++ b/partiql-spi/src/main/java/org/partiql/spi/value/DatumNull.java
@@ -2,12 +2,14 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.partiql.types.PType;
-import org.partiql.value.datetime.Date;
-import org.partiql.value.datetime.Time;
-import org.partiql.value.datetime.Timestamp;
 
 import java.math.BigDecimal;
 import java.math.BigInteger;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.OffsetTime;
 import java.util.Iterator;
 
 /**
@@ -112,16 +114,6 @@ public byte[] getBytes() {
         }
     }
 
-    @NotNull
-    @Override
-    public Date getDate() {
-        if (_type.code() == PType.DATE) {
-            throw new NullPointerException();
-        } else {
-            throw new UnsupportedOperationException();
-        }
-    }
-
     @Override
     public double getDouble() {
         if (_type.code() == PType.DOUBLE) {
@@ -172,26 +164,62 @@ public String getString() {
 
     @NotNull
     @Override
-    public Time getTime() {
-        if (_type.code() == PType.TIMEZ || _type.code() == PType.TIME) {
-            throw new NullPointerException();
-        } else {
-            throw new UnsupportedOperationException();
+    public LocalDate getLocalDate() {
+        switch (_type.code()) {
+            case PType.DATE:
+            case PType.TIMESTAMP:
+            case PType.TIMESTAMPZ:
+                throw new NullPointerException();
+            default:
+                throw new UnsupportedOperationException();
         }
     }
 
     @NotNull
     @Override
-    public Timestamp getTimestamp() {
-        if (_type.code() == PType.TIMESTAMPZ || _type.code() == PType.TIMESTAMP) {
-            throw new NullPointerException();
-        } else {
-            throw new UnsupportedOperationException();
+    public LocalTime getLocalTime() {
+        switch (_type.code()) {
+            case PType.TIME:
+            case PType.TIMEZ:
+            case PType.TIMESTAMP:
+            case PType.TIMESTAMPZ:
+                throw new NullPointerException();
+            default:
+                throw new UnsupportedOperationException();
         }
     }
 
+    @NotNull
     @Override
-    public long getInterval() {
-        throw new UnsupportedOperationException();
+    public OffsetTime getOffsetTime() {
+        switch (_type.code()) {
+            case PType.TIMEZ:
+            case PType.TIMESTAMPZ:
+                throw new NullPointerException();
+            default:
+                throw new UnsupportedOperationException();
+        }
+    }
+
+    @NotNull
+    @Override
+    public LocalDateTime getLocalDateTime() {
+        switch (_type.code()) {
+            case PType.TIMESTAMP:
+            case PType.TIMESTAMPZ:
+                throw new NullPointerException();
+            default:
+                throw new UnsupportedOperationException();
+        }
+    }
+
+    @NotNull
+    @Override
+    public OffsetDateTime getOffsetDateTime() {
+        if (_type.code() == PType.TIMESTAMPZ) {
+            throw new NullPointerException();
+        } else {
+            throw new UnsupportedOperationException();
+        }
     }
 }
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/DatumTime.java b/partiql-spi/src/main/java/org/partiql/spi/value/DatumTime.java
index 803440bfc5..0922c0c57e 100644
--- a/partiql-spi/src/main/java/org/partiql/spi/value/DatumTime.java
+++ b/partiql-spi/src/main/java/org/partiql/spi/value/DatumTime.java
@@ -2,38 +2,42 @@
 
 import org.jetbrains.annotations.NotNull;
 import org.partiql.types.PType;
-import org.partiql.value.datetime.Time;
+
+import java.time.LocalTime;
+import java.time.OffsetTime;
+import java.time.ZoneOffset;
 
 /**
- * This shall always be package-private (internal).
+ * Today we wrap a {@link LocalTime}, in the future we do a 4-byte array to avoid double references.
  */
-class DatumTime implements Datum {
+final class DatumTime implements Datum {
 
     @NotNull
-    private final Time _value;
+    private final PType type;
 
-    // TODO: Create a variant specifically for without TZ
-    private final PType _type;
+    @NotNull
+    private final LocalTime value;
 
-    DatumTime(@NotNull Time value) {
-        _value = value.toPrecision(6);
-        _type = PType.timez(6);
+    DatumTime(@NotNull LocalTime value, int precision) {
+        this.type = PType.time(precision);
+        this.value = value;
     }
 
-    DatumTime(@NotNull Time value, int precision) {
-        _value = value.toPrecision(precision);
-        _type = PType.timez(precision);
+    @NotNull
+    @Override
+    public PType getType() {
+        return type;
     }
 
-    @Override
     @NotNull
-    public Time getTime() {
-        return _value;
+    @Override
+    public LocalTime getLocalTime() {
+        return value;
     }
 
     @NotNull
     @Override
-    public PType getType() {
-        return _type;
+    public OffsetTime getOffsetTime() {
+        return value.atOffset(ZoneOffset.UTC);
     }
-}
+}
\ No newline at end of file
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimestamp.java b/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimestamp.java
index 75bda7a27f..dcb1de412a 100644
--- a/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimestamp.java
+++ b/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimestamp.java
@@ -1,39 +1,65 @@
 package org.partiql.spi.value;
 
+
 import org.jetbrains.annotations.NotNull;
 import org.partiql.types.PType;
-import org.partiql.value.datetime.Timestamp;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+import java.time.ZoneOffset;
 
 /**
- * This shall always be package-private (internal).
+ * Today we wrap a {@link LocalDateTime}, in the future we do a 7-byte array to avoid double references.
  */
-class DatumTimestamp implements Datum {
+final class DatumTimestamp implements Datum {
 
     @NotNull
-    private final Timestamp _value;
+    private final PType type;
 
-    // TODO: Create a variant specifically for without TZ
-    private final PType _type;
+    @NotNull
+    private final LocalDateTime value;
 
-    DatumTimestamp(@NotNull Timestamp value) {
-        _value = value.toPrecision(6);
-        _type = PType.timestampz(6);
+    DatumTimestamp(@NotNull LocalDateTime value, int precision) {
+        this.type = PType.timestamp(precision);
+        this.value = value;
     }
 
-    DatumTimestamp(@NotNull Timestamp value, int precision) {
-        _value = value.toPrecision(precision);
-        _type = PType.timestampz(precision);
+    @NotNull
+    @Override
+    public PType getType() {
+        return type;
     }
 
+    @NotNull
     @Override
+    public LocalDate getLocalDate() {
+        return value.toLocalDate();
+    }
+
     @NotNull
-    public Timestamp getTimestamp() {
-        return _value;
+    @Override
+    public LocalTime getLocalTime() {
+        return value.toLocalTime();
     }
 
     @NotNull
     @Override
-    public PType getType() {
-        return _type;
+    public OffsetTime getOffsetTime() {
+        return value.atOffset(ZoneOffset.UTC).toOffsetTime();
+    }
+
+    @NotNull
+    @Override
+    public LocalDateTime getLocalDateTime() {
+        return value;
+    }
+
+    @NotNull
+    @Override
+    public OffsetDateTime getOffsetDateTime() {
+        return value.atOffset(ZoneOffset.UTC);
     }
-}
+}
\ No newline at end of file
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimestampz.java b/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimestampz.java
new file mode 100644
index 0000000000..0169814e9d
--- /dev/null
+++ b/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimestampz.java
@@ -0,0 +1,64 @@
+package org.partiql.spi.value;
+
+
+import org.jetbrains.annotations.NotNull;
+import org.partiql.types.PType;
+
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.OffsetDateTime;
+import java.time.OffsetTime;
+
+/**
+ * Today we wrap an {@link OffsetDateTime}, in the future we do an 8-byte array to avoid double references.
+ */
+final class DatumTimestampz implements Datum {
+
+    @NotNull
+    private final PType type;
+
+    @NotNull
+    private final OffsetDateTime value;
+
+    DatumTimestampz(@NotNull OffsetDateTime value, int precision) {
+        this.type = PType.timestamp(precision);
+        this.value = value;
+    }
+
+    @NotNull
+    @Override
+    public PType getType() {
+        return type;
+    }
+
+    @NotNull
+    @Override
+    public LocalDate getLocalDate() {
+        return value.toLocalDate();
+    }
+
+    @NotNull
+    @Override
+    public LocalTime getLocalTime() {
+        return value.toLocalTime();
+    }
+
+    @NotNull
+    @Override
+    public OffsetTime getOffsetTime() {
+        return value.toOffsetTime();
+    }
+
+    @NotNull
+    @Override
+    public LocalDateTime getLocalDateTime() {
+        return value.toLocalDateTime();
+    }
+
+    @NotNull
+    @Override
+    public OffsetDateTime getOffsetDateTime() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimez.java b/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimez.java
new file mode 100644
index 0000000000..3a5a554555
--- /dev/null
+++ b/partiql-spi/src/main/java/org/partiql/spi/value/DatumTimez.java
@@ -0,0 +1,42 @@
+package org.partiql.spi.value;
+
+import org.jetbrains.annotations.NotNull;
+import org.partiql.types.PType;
+
+import java.time.LocalTime;
+import java.time.OffsetTime;
+
+/**
+ * Today we wrap an {@link OffsetTime}, in the future we do a 5-byte array to avoid double references.
+ */
+final class DatumTimez implements Datum {
+
+    @NotNull
+    private final PType type;
+
+    @NotNull
+    private final OffsetTime value;
+
+    DatumTimez(@NotNull OffsetTime value, int precision) {
+        this.type = PType.timez(precision);
+        this.value = value;
+    }
+
+    @NotNull
+    @Override
+    public PType getType() {
+        return type;
+    }
+
+    @NotNull
+    @Override
+    public LocalTime getLocalTime() {
+        return value.toLocalTime();
+    }
+
+    @NotNull
+    @Override
+    public OffsetTime getOffsetTime() {
+        return value;
+    }
+}
\ No newline at end of file
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnBetween.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnBetween.kt
index 3df72bc163..f629fdb741 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnBetween.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnBetween.kt
@@ -189,9 +189,9 @@ internal val Fn_BETWEEN__DATE_DATE_DATE__BOOL = Function.static(
     ),
 
 ) { args ->
-    val value = args[0].date
-    val lower = args[1].date
-    val upper = args[2].date
+    val value = args[0].localDate
+    val lower = args[1].localDate
+    val upper = args[2].localDate
     Datum.bool(value in lower..upper)
 }
 
@@ -206,9 +206,9 @@ internal val Fn_BETWEEN__TIME_TIME_TIME__BOOL = Function.static(
     ),
 
 ) { args ->
-    val value = args[0].time
-    val lower = args[1].time
-    val upper = args[2].time
+    val value = args[0].localTime
+    val lower = args[1].localTime
+    val upper = args[2].localTime
     Datum.bool(value in lower..upper)
 }
 
@@ -223,8 +223,8 @@ internal val Fn_BETWEEN__TIMESTAMP_TIMESTAMP_TIMESTAMP__BOOL = Function.static(
     ),
 
 ) { args ->
-    val value = args[0].timestamp
-    val lower = args[1].timestamp
-    val upper = args[2].timestamp
+    val value = args[0].localDateTime
+    val lower = args[1].localDateTime
+    val upper = args[2].localDateTime
     Datum.bool(value in lower..upper)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddDay.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddDay.kt
index 98f9e4f5a9..55b82129ac 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddDay.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddDay.kt
@@ -21,7 +21,7 @@ internal val Fn_DATE_ADD_DAY__INT32_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].int
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = interval.toLong()
     Datum.date(datetimeValue.plusDays(intervalValue))
@@ -38,7 +38,7 @@ internal val Fn_DATE_ADD_DAY__INT64_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].long
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = interval
     Datum.date(datetimeValue.plusDays(intervalValue))
@@ -55,7 +55,7 @@ internal val Fn_DATE_ADD_DAY__INT_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].bigInteger
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = try {
         interval.toLong()
@@ -76,10 +76,10 @@ internal val Fn_DATE_ADD_DAY__INT32_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].int
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = interval.toLong()
-    Datum.timestamp(datetimeValue.plusDays(intervalValue))
+    Datum.timestamp(datetimeValue.plusDays(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_DAY__INT64_TIMESTAMP__TIMESTAMP = Function.static(
@@ -93,10 +93,10 @@ internal val Fn_DATE_ADD_DAY__INT64_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].long
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = interval
-    Datum.timestamp(datetimeValue.plusDays(intervalValue))
+    Datum.timestamp(datetimeValue.plusDays(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_DAY__INT_TIMESTAMP__TIMESTAMP = Function.static(
@@ -110,12 +110,12 @@ internal val Fn_DATE_ADD_DAY__INT_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].bigInteger
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = try {
         interval.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.timestamp(datetimeValue.plusDays(intervalValue))
+    Datum.timestamp(datetimeValue.plusDays(intervalValue), 6)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddHour.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddHour.kt
index be21e3c081..ff77ffa8d1 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddHour.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddHour.kt
@@ -22,9 +22,9 @@ internal val Fn_DATE_ADD_HOUR__INT32_TIME__TIME = Function.static(
 ) { args ->
     val interval = args[0].int
     val datetime = args[1]
-    val datetimeValue = datetime.time
+    val datetimeValue = datetime.localTime
     val intervalValue = interval.toLong()
-    Datum.time(datetimeValue.plusHours(intervalValue))
+    Datum.time(datetimeValue.plusHours(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_HOUR__INT64_TIME__TIME = Function.static(
@@ -39,9 +39,9 @@ internal val Fn_DATE_ADD_HOUR__INT64_TIME__TIME = Function.static(
 ) { args ->
     val interval = args[0]
     val datetime = args[1]
-    val datetimeValue = datetime.time
+    val datetimeValue = datetime.localTime
     val intervalValue = interval.long
-    Datum.time(datetimeValue.plusHours(intervalValue))
+    Datum.time(datetimeValue.plusHours(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_HOUR__INT_TIME__TIME = Function.static(
@@ -56,13 +56,13 @@ internal val Fn_DATE_ADD_HOUR__INT_TIME__TIME = Function.static(
 ) { args ->
     val interval = args[0]
     val datetime = args[1]
-    val datetimeValue = datetime.time
+    val datetimeValue = datetime.localTime
     val intervalValue = try {
         interval.bigInteger.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.time(datetimeValue.plusHours(intervalValue))
+    Datum.time(datetimeValue.plusHours(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_HOUR__INT32_TIMESTAMP__TIMESTAMP = Function.static(
@@ -77,9 +77,9 @@ internal val Fn_DATE_ADD_HOUR__INT32_TIMESTAMP__TIMESTAMP = Function.static(
 ) { args ->
     val interval = args[0].int
     val datetime = args[1]
-    val datetimeValue = datetime.timestamp
+    val datetimeValue = datetime.localDateTime
     val intervalValue = interval.toLong()
-    Datum.timestamp(datetimeValue.plusHours(intervalValue))
+    Datum.timestamp(datetimeValue.plusHours(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_HOUR__INT64_TIMESTAMP__TIMESTAMP = Function.static(
@@ -94,9 +94,9 @@ internal val Fn_DATE_ADD_HOUR__INT64_TIMESTAMP__TIMESTAMP = Function.static(
 ) { args ->
     val interval = args[0]
     val datetime = args[1]
-    val datetimeValue = datetime.timestamp
+    val datetimeValue = datetime.localDateTime
     val intervalValue = interval.long
-    Datum.timestamp(datetimeValue.plusHours(intervalValue))
+    Datum.timestamp(datetimeValue.plusHours(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_HOUR__INT_TIMESTAMP__TIMESTAMP = Function.static(
@@ -111,11 +111,11 @@ internal val Fn_DATE_ADD_HOUR__INT_TIMESTAMP__TIMESTAMP = Function.static(
 ) { args ->
     val interval = args[0]
     val datetime = args[1]
-    val datetimeValue = datetime.timestamp
+    val datetimeValue = datetime.localDateTime
     val intervalValue = try {
         interval.bigInteger.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.timestamp(datetimeValue.plusHours(intervalValue))
+    Datum.timestamp(datetimeValue.plusHours(intervalValue), 6)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddMinute.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddMinute.kt
index 9811538a93..04a83e36d7 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddMinute.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddMinute.kt
@@ -22,9 +22,9 @@ internal val Fn_DATE_ADD_MINUTE__INT32_TIME__TIME = Function.static(
 ) { args ->
     val interval = args[0].int
     val datetime = args[1]
-    val datetimeValue = datetime.time
+    val datetimeValue = datetime.localTime
     val intervalValue = interval.toLong()
-    Datum.time(datetimeValue.plusMinutes(intervalValue))
+    Datum.time(datetimeValue.plusMinutes(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_MINUTE__INT64_TIME__TIME = Function.static(
@@ -39,9 +39,9 @@ internal val Fn_DATE_ADD_MINUTE__INT64_TIME__TIME = Function.static(
 ) { args ->
     val interval = args[0]
     val datetime = args[1]
-    val datetimeValue = datetime.time
+    val datetimeValue = datetime.localTime
     val intervalValue = interval.long
-    Datum.time(datetimeValue.plusMinutes(intervalValue))
+    Datum.time(datetimeValue.plusMinutes(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_MINUTE__INT_TIME__TIME = Function.static(
@@ -56,13 +56,13 @@ internal val Fn_DATE_ADD_MINUTE__INT_TIME__TIME = Function.static(
 ) { args ->
     val interval = args[0]
     val datetime = args[1]
-    val datetimeValue = datetime.time
+    val datetimeValue = datetime.localTime
     val intervalValue = try {
         interval.bigInteger.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.time(datetimeValue.plusMinutes(intervalValue))
+    Datum.time(datetimeValue.plusMinutes(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_MINUTE__INT32_TIMESTAMP__TIMESTAMP = Function.static(
@@ -77,9 +77,9 @@ internal val Fn_DATE_ADD_MINUTE__INT32_TIMESTAMP__TIMESTAMP = Function.static(
 ) { args ->
     val interval = args[0].int
     val datetime = args[1]
-    val datetimeValue = datetime.timestamp
+    val datetimeValue = datetime.localDateTime
     val intervalValue = interval.toLong()
-    Datum.timestamp(datetimeValue.plusMinutes(intervalValue))
+    Datum.timestamp(datetimeValue.plusMinutes(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_MINUTE__INT64_TIMESTAMP__TIMESTAMP = Function.static(
@@ -94,9 +94,9 @@ internal val Fn_DATE_ADD_MINUTE__INT64_TIMESTAMP__TIMESTAMP = Function.static(
 ) { args ->
     val interval = args[0]
     val datetime = args[1]
-    val datetimeValue = datetime.timestamp
+    val datetimeValue = datetime.localDateTime
     val intervalValue = interval.long
-    Datum.timestamp(datetimeValue.plusMinutes(intervalValue))
+    Datum.timestamp(datetimeValue.plusMinutes(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_MINUTE__INT_TIMESTAMP__TIMESTAMP = Function.static(
@@ -111,11 +111,11 @@ internal val Fn_DATE_ADD_MINUTE__INT_TIMESTAMP__TIMESTAMP = Function.static(
 ) { args ->
     val interval = args[0]
     val datetime = args[1]
-    val datetimeValue = datetime.timestamp
+    val datetimeValue = datetime.localDateTime
     val intervalValue = try {
         interval.bigInteger.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.timestamp(datetimeValue.plusMinutes(intervalValue))
+    Datum.timestamp(datetimeValue.plusMinutes(intervalValue), 6)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddMonth.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddMonth.kt
index 5a61e31c59..f8dd23fe1e 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddMonth.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddMonth.kt
@@ -21,7 +21,7 @@ internal val Fn_DATE_ADD_MONTH__INT32_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].int
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = interval.toLong()
     Datum.date(datetimeValue.plusMonths(intervalValue))
@@ -38,7 +38,7 @@ internal val Fn_DATE_ADD_MONTH__INT64_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].long
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = interval
     Datum.date(datetimeValue.plusMonths(intervalValue))
@@ -55,7 +55,7 @@ internal val Fn_DATE_ADD_MONTH__INT_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].bigInteger
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = try {
         interval.toLong()
@@ -76,10 +76,10 @@ internal val Fn_DATE_ADD_MONTH__INT32_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].int
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = interval.toLong()
-    Datum.timestamp(datetimeValue.plusMonths(intervalValue))
+    Datum.timestamp(datetimeValue.plusMonths(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_MONTH__INT64_TIMESTAMP__TIMESTAMP = Function.static(
@@ -93,10 +93,10 @@ internal val Fn_DATE_ADD_MONTH__INT64_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].long
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = interval
-    Datum.timestamp(datetimeValue.plusMonths(intervalValue))
+    Datum.timestamp(datetimeValue.plusMonths(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_MONTH__INT_TIMESTAMP__TIMESTAMP = Function.static(
@@ -110,12 +110,12 @@ internal val Fn_DATE_ADD_MONTH__INT_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].bigInteger
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = try {
         interval.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.timestamp(datetimeValue.plusMonths(intervalValue))
+    Datum.timestamp(datetimeValue.plusMonths(intervalValue), 6)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddSecond.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddSecond.kt
index 53c3415e58..a8249e457d 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddSecond.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddSecond.kt
@@ -21,10 +21,10 @@ internal val Fn_DATE_ADD_SECOND__INT32_TIME__TIME = Function.static(
 
 ) { args ->
     val interval = args[0].int
-    val datetime = args[1].time
+    val datetime = args[1].localTime
     val datetimeValue = datetime
     val intervalValue = interval.toLong()
-    Datum.time(datetimeValue.plusSeconds(intervalValue))
+    Datum.time(datetimeValue.plusSeconds(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_SECOND__INT64_TIME__TIME = Function.static(
@@ -38,10 +38,10 @@ internal val Fn_DATE_ADD_SECOND__INT64_TIME__TIME = Function.static(
 
 ) { args ->
     val interval = args[0].long
-    val datetime = args[1].time
+    val datetime = args[1].localTime
     val datetimeValue = datetime
     val intervalValue = interval
-    Datum.time(datetimeValue.plusSeconds(intervalValue))
+    Datum.time(datetimeValue.plusSeconds(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_SECOND__INT_TIME__TIME = Function.static(
@@ -55,14 +55,14 @@ internal val Fn_DATE_ADD_SECOND__INT_TIME__TIME = Function.static(
 
 ) { args ->
     val interval = args[0].bigInteger
-    val datetime = args[1].time
+    val datetime = args[1].localTime
     val datetimeValue = datetime
     val intervalValue = try {
         interval.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.time(datetimeValue.plusSeconds(intervalValue))
+    Datum.time(datetimeValue.plusSeconds(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_SECOND__INT32_TIMESTAMP__TIMESTAMP = Function.static(
@@ -76,10 +76,10 @@ internal val Fn_DATE_ADD_SECOND__INT32_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].int
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = interval.toLong()
-    Datum.timestamp(datetimeValue.plusSeconds(intervalValue))
+    Datum.timestamp(datetimeValue.plusSeconds(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_SECOND__INT64_TIMESTAMP__TIMESTAMP = Function.static(
@@ -93,10 +93,10 @@ internal val Fn_DATE_ADD_SECOND__INT64_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].long
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = interval
-    Datum.timestamp(datetimeValue.plusSeconds(intervalValue))
+    Datum.timestamp(datetimeValue.plusSeconds(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_SECOND__INT_TIMESTAMP__TIMESTAMP = Function.static(
@@ -110,12 +110,12 @@ internal val Fn_DATE_ADD_SECOND__INT_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].bigInteger
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = try {
         interval.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.timestamp(datetimeValue.plusSeconds(intervalValue))
+    Datum.timestamp(datetimeValue.plusSeconds(intervalValue), 6)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddYear.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddYear.kt
index 4beae8cbb3..338ed5ba89 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddYear.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnDateAddYear.kt
@@ -21,7 +21,7 @@ internal val Fn_DATE_ADD_YEAR__INT32_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].int
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = interval.toLong()
     Datum.date(datetimeValue.plusYears(intervalValue))
@@ -38,7 +38,7 @@ internal val Fn_DATE_ADD_YEAR__INT64_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].long
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = interval
     Datum.date(datetimeValue.plusYears(intervalValue))
@@ -55,7 +55,7 @@ internal val Fn_DATE_ADD_YEAR__INT_DATE__DATE = Function.static(
 
 ) { args ->
     val interval = args[0].bigInteger
-    val datetime = args[1].date
+    val datetime = args[1].localDate
     val datetimeValue = datetime
     val intervalValue = try {
         interval.toLong()
@@ -76,10 +76,10 @@ internal val Fn_DATE_ADD_YEAR__INT32_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].int
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = interval.toLong()
-    Datum.timestamp(datetimeValue.plusYears(intervalValue))
+    Datum.timestamp(datetimeValue.plusYears(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_YEAR__INT64_TIMESTAMP__TIMESTAMP = Function.static(
@@ -93,10 +93,10 @@ internal val Fn_DATE_ADD_YEAR__INT64_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].long
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = interval
-    Datum.timestamp(datetimeValue.plusYears(intervalValue))
+    Datum.timestamp(datetimeValue.plusYears(intervalValue), 6)
 }
 
 internal val Fn_DATE_ADD_YEAR__INT_TIMESTAMP__TIMESTAMP = Function.static(
@@ -110,12 +110,12 @@ internal val Fn_DATE_ADD_YEAR__INT_TIMESTAMP__TIMESTAMP = Function.static(
 
 ) { args ->
     val interval = args[0].bigInteger
-    val datetime = args[1].timestamp
+    val datetime = args[1].localDateTime
     val datetimeValue = datetime
     val intervalValue = try {
         interval.toLong()
     } catch (e: DataException) {
         throw TypeCheckException()
     }
-    Datum.timestamp(datetimeValue.plusYears(intervalValue))
+    Datum.timestamp(datetimeValue.plusYears(intervalValue), 6)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnExtract.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnExtract.kt
index dfe6db4cbc..689b67f656 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnExtract.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnExtract.kt
@@ -7,34 +7,30 @@ import org.partiql.spi.function.Function
 import org.partiql.spi.function.Parameter
 import org.partiql.spi.value.Datum
 import org.partiql.types.PType
-import org.partiql.value.datetime.TimeZone
+import java.math.BigDecimal
 
 //
 // Extract Year
 //
 internal val Fn_EXTRACT_YEAR__DATE__INT32 = Function.static(
-
     name = "extract_year",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.date()),
     ),
-
 ) { args ->
-    val v = args[0].date
+    val v = args[0].localDate
     Datum.integer(v.year)
 }
 
 internal val Fn_EXTRACT_YEAR__TIMESTAMP__INT32 = Function.static(
-
     name = "extract_year",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.timestamp(6)),
     ),
-
 ) { args ->
-    val v = args[0].timestamp
+    val v = args[0].localDateTime
     Datum.integer(v.year)
 }
 
@@ -42,29 +38,25 @@ internal val Fn_EXTRACT_YEAR__TIMESTAMP__INT32 = Function.static(
 // Extract Month
 //
 internal val Fn_EXTRACT_MONTH__DATE__INT32 = Function.static(
-
     name = "extract_month",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.date()),
     ),
-
 ) { args ->
-    val v = args[0].date
-    Datum.integer(v.month)
+    val v = args[0].localDate
+    Datum.integer(v.monthValue)
 }
 
 internal val Fn_EXTRACT_MONTH__TIMESTAMP__INT32 = Function.static(
-
     name = "extract_month",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.timestamp(6)),
     ),
-
 ) { args ->
-    val v = args[0].timestamp
-    Datum.integer(v.month)
+    val v = args[0].localDateTime
+    Datum.integer(v.monthValue)
 }
 
 //
@@ -72,57 +64,49 @@ internal val Fn_EXTRACT_MONTH__TIMESTAMP__INT32 = Function.static(
 //
 
 internal val Fn_EXTRACT_DAY__DATE__INT32 = Function.static(
-
     name = "extract_day",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.date()),
     ),
-
 ) { args ->
-    val v = args[0].date
-    Datum.integer(v.day)
+    val v = args[0].localDate
+    Datum.integer(v.dayOfMonth)
 }
 
 internal val Fn_EXTRACT_DAY__TIMESTAMP__INT32 = Function.static(
-
     name = "extract_day",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.timestamp(6)),
     ),
-
 ) { args ->
-    val v = args[0].timestamp
-    Datum.integer(v.day)
+    val v = args[0].localDateTime
+    Datum.integer(v.dayOfMonth)
 }
 
 //
 // Extract Hour
 //
 internal val Fn_EXTRACT_HOUR__TIME__INT32 = Function.static(
-
     name = "extract_hour",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.time(6)),
     ),
-
 ) { args ->
-    val v = args[0].time
+    val v = args[0].localTime
     Datum.integer(v.hour)
 }
 
 internal val Fn_EXTRACT_HOUR__TIMESTAMP__INT32 = Function.static(
-
     name = "extract_hour",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.timestamp(6)),
     ),
-
 ) { args ->
-    val v = args[0].timestamp
+    val v = args[0].localDateTime
     Datum.integer(v.hour)
 }
 
@@ -130,130 +114,112 @@ internal val Fn_EXTRACT_HOUR__TIMESTAMP__INT32 = Function.static(
 // Extract Minute
 //
 internal val Fn_EXTRACT_MINUTE__TIME__INT32 = Function.static(
-
     name = "extract_minute",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.time(6)),
     ),
-
 ) { args ->
-    val v = args[0].time
+    val v = args[0].localTime
     Datum.integer(v.minute)
 }
 
 internal val Fn_EXTRACT_MINUTE__TIMESTAMP__INT32 = Function.static(
-
     name = "extract_minute",
     returns = PType.integer(),
     parameters = arrayOf(
         Parameter("datetime", PType.timestamp(6)),
     ),
-
 ) { args ->
-    val v = args[0].timestamp
+    val v = args[0].localDateTime
     Datum.integer(v.minute)
 }
 
 //
-// Extract Second
+// Extract Second.
+//
+// Rules:
+// - The declared type of the result is exact numeric with implementation-defined precision and scale.
+// - The implementation-defined scale shall not be less than the fractional seconds precision of the source.
+//
+// Seconds is limited to [0-59].000_000_000 so DECIMAL(11,9) for now.
+//
+// We could return the exact precision/scale of the input type, but kiss/scope.
 //
 internal val Fn_EXTRACT_SECOND__TIME__DECIMAL_ARBITRARY = Function.static(
-
     name = "extract_second",
-    returns = PType.decimal(38, 19), // TODO: Rewrite using new function modeling.
+    returns = PType.decimal(11, 9), // TODO: Rewrite using new function modeling.
     parameters = arrayOf(
-        Parameter("datetime", PType.time(6)),
+        Parameter("datetime", PType.time(9)),
     ),
-
 ) { args ->
-    val v = args[0].time
-    Datum.decimal(v.decimalSecond)
+    val v = args[0].localTime
+    val d = BigDecimal(v.second).add(BigDecimal(v.nano).scaleByPowerOfTen(-9))
+    Datum.decimal(d, 11, 9)
 }
 
 internal val Fn_EXTRACT_SECOND__TIMESTAMP__DECIMAL_ARBITRARY = Function.static(
-
     name = "extract_second",
-    returns = PType.decimal(38, 19), // TODO: Rewrite using new function modeling.
+    returns = PType.decimal(11, 9), // TODO: Rewrite using new function modeling.
     parameters = arrayOf(
         Parameter("datetime", PType.timestamp(6)),
     ),
-
 ) { args ->
-    val v = args[0].timestamp
-    Datum.decimal(v.decimalSecond)
+    val v = args[0].localDateTime
+    val d = BigDecimal(v.second).add(BigDecimal(v.nano).scaleByPowerOfTen(-9))
+    Datum.decimal(d, 11, 9)
 }
 
 //
 // Extract Timezone Hour
 //
 internal val Fn_EXTRACT_TIMEZONE_HOUR__TIME__INT32 = Function.static(
-
     name = "extract_timezone_hour",
     returns = PType.integer(),
     parameters = arrayOf(
-        Parameter("datetime", PType.time(6)),
+        Parameter("datetime", PType.timez(6)),
     ),
-
 ) { args ->
-    val v = args[0].time
-    when (val tz = v.timeZone) {
-        TimeZone.UnknownTimeZone -> Datum.integer(0) // TODO: Should this be NULL?
-        is TimeZone.UtcOffset -> Datum.integer(tz.tzHour)
-        null -> Datum.nullValue(PType.integer())
-    }
+    val v = args[0].offsetTime
+    val o = v.offset.totalSeconds / 3600
+    Datum.integer(o)
 }
 
 internal val Fn_EXTRACT_TIMEZONE_HOUR__TIMESTAMP__INT32 = Function.static(
-
     name = "extract_timezone_hour",
     returns = PType.integer(),
     parameters = arrayOf(
-        Parameter("datetime", PType.timestamp(6)),
+        Parameter("datetime", PType.timestampz(6)),
     ),
-
 ) { args ->
-    val v = args[0].timestamp
-    when (val tz = v.timeZone) {
-        TimeZone.UnknownTimeZone -> Datum.integer(0) // TODO: Should this be NULL?
-        is TimeZone.UtcOffset -> Datum.integer(tz.tzHour)
-        null -> Datum.nullValue(PType.integer())
-    }
+    val v = args[0].offsetDateTime
+    val o = v.offset.totalSeconds / 3600
+    Datum.integer(o)
 }
 
 //
 // Extract Timezone Minute
 //
 internal val Fn_EXTRACT_TIMEZONE_MINUTE__TIME__INT32 = Function.static(
-
     name = "extract_timezone_minute",
     returns = PType.integer(),
     parameters = arrayOf(
-        Parameter("datetime", PType.time(6)),
+        Parameter("datetime", PType.timez(6)),
     ),
-
 ) { args ->
-    val v = args[0].time
-    when (val tz = v.timeZone) {
-        TimeZone.UnknownTimeZone -> Datum.integer(0) // TODO: Should this be NULL?
-        is TimeZone.UtcOffset -> Datum.integer(tz.tzMinute)
-        null -> Datum.nullValue(PType.integer())
-    }
+    val v = args[0].offsetTime
+    val o = (v.offset.totalSeconds / 60) % 60
+    Datum.integer(o)
 }
 
 internal val Fn_EXTRACT_TIMEZONE_MINUTE__TIMESTAMP__INT32 = Function.static(
-
     name = "extract_timezone_minute",
     returns = PType.integer(),
     parameters = arrayOf(
-        Parameter("datetime", PType.timestamp(6)),
+        Parameter("datetime", PType.timestampz(6)),
     ),
-
 ) { args ->
-    val v = args[0].timestamp
-    when (val tz = v.timeZone) {
-        TimeZone.UnknownTimeZone -> Datum.integer(0) // TODO: Should this be NULL?
-        is TimeZone.UtcOffset -> Datum.integer(tz.tzMinute)
-        null -> Datum.nullValue(PType.integer())
-    }
+    val v = args[0].offsetDateTime
+    val o = (v.offset.totalSeconds / 60) % 60
+    Datum.integer(o)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnGt.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnGt.kt
index c0077be009..42d8e04c95 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnGt.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnGt.kt
@@ -85,24 +85,24 @@ internal object FnGt : DiadicComparisonOperator("gt") {
 
     override fun getTimestampInstance(timestampLhs: PType, timestampRhs: PType): Function.Instance {
         return basic(PType.bool(), timestampLhs, timestampRhs) { args ->
-            val lhs = args[0].timestamp
-            val rhs = args[1].timestamp
+            val lhs = args[0].localDateTime
+            val rhs = args[1].localDateTime
             Datum.bool(lhs > rhs)
         }
     }
 
     override fun getDateInstance(dateLhs: PType, dateRhs: PType): Function.Instance {
         return basic(PType.bool(), PType.date()) { args ->
-            val lhs = args[0].date
-            val rhs = args[1].date
+            val lhs = args[0].localDate
+            val rhs = args[1].localDate
             Datum.bool(lhs > rhs)
         }
     }
 
     override fun getTimeInstance(timeLhs: PType, timeRhs: PType): Function.Instance {
         return basic(PType.bool(), timeLhs, timeRhs) { args ->
-            val lhs = args[0].time
-            val rhs = args[1].time
+            val lhs = args[0].localTime
+            val rhs = args[1].localTime
             Datum.bool(lhs > rhs)
         }
     }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnGte.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnGte.kt
index 9a581b5c2b..17a93d619b 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnGte.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnGte.kt
@@ -109,24 +109,24 @@ internal object FnGte : DiadicComparisonOperator("gte") {
 
     override fun getTimestampInstance(timestampLhs: PType, timestampRhs: PType): Function.Instance {
         return basic(PType.bool(), timestampLhs, timestampRhs) { args ->
-            val lhs = args[0].timestamp
-            val rhs = args[1].timestamp
+            val lhs = args[0].localDateTime
+            val rhs = args[1].localDateTime
             Datum.bool(lhs >= rhs)
         }
     }
 
     override fun getDateInstance(dateLhs: PType, dateRhs: PType): Function.Instance {
         return basic(PType.bool(), PType.date()) { args ->
-            val lhs = args[0].date
-            val rhs = args[1].date
+            val lhs = args[0].localDate
+            val rhs = args[1].localDate
             Datum.bool(lhs >= rhs)
         }
     }
 
     override fun getTimeInstance(timeLhs: PType, timeRhs: PType): Function.Instance {
         return basic(PType.bool(), timeLhs, timeRhs) { args ->
-            val lhs = args[0].time
-            val rhs = args[1].time
+            val lhs = args[0].localTime
+            val rhs = args[1].localTime
             Datum.bool(lhs >= rhs)
         }
     }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnLt.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnLt.kt
index 8e526a2beb..092752eea4 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnLt.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnLt.kt
@@ -85,24 +85,24 @@ internal object FnLt : DiadicComparisonOperator("lt") {
 
     override fun getTimestampInstance(timestampLhs: PType, timestampRhs: PType): Function.Instance {
         return basic(PType.bool(), timestampLhs, timestampRhs) { args ->
-            val lhs = args[0].timestamp
-            val rhs = args[1].timestamp
+            val lhs = args[0].localDateTime
+            val rhs = args[1].localDateTime
             Datum.bool(lhs < rhs)
         }
     }
 
     override fun getDateInstance(dateLhs: PType, dateRhs: PType): Function.Instance {
         return basic(PType.bool(), PType.date()) { args ->
-            val lhs = args[0].date
-            val rhs = args[1].date
+            val lhs = args[0].localDate
+            val rhs = args[1].localDate
             Datum.bool(lhs < rhs)
         }
     }
 
     override fun getTimeInstance(timeLhs: PType, timeRhs: PType): Function.Instance {
         return basic(PType.bool(), timeLhs, timeRhs) { args ->
-            val lhs = args[0].time
-            val rhs = args[1].time
+            val lhs = args[0].localTime
+            val rhs = args[1].localTime
             Datum.bool(lhs < rhs)
         }
     }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnLte.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnLte.kt
index 35d6cba0e1..c096c5c966 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnLte.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnLte.kt
@@ -85,24 +85,24 @@ internal object FnLte : DiadicComparisonOperator("lte") {
 
     override fun getTimestampInstance(timestampLhs: PType, timestampRhs: PType): Function.Instance {
         return basic(PType.bool(), timestampLhs, timestampRhs) { args ->
-            val lhs = args[0].timestamp
-            val rhs = args[1].timestamp
+            val lhs = args[0].localDateTime
+            val rhs = args[1].localDateTime
             Datum.bool(lhs <= rhs)
         }
     }
 
     override fun getDateInstance(dateLhs: PType, dateRhs: PType): Function.Instance {
         return basic(PType.bool(), PType.date()) { args ->
-            val lhs = args[0].date
-            val rhs = args[1].date
+            val lhs = args[0].localDate
+            val rhs = args[1].localDate
             Datum.bool(lhs <= rhs)
         }
     }
 
     override fun getTimeInstance(timeLhs: PType, timeRhs: PType): Function.Instance {
         return basic(PType.bool(), timeLhs, timeRhs) { args ->
-            val lhs = args[0].time
-            val rhs = args[1].time
+            val lhs = args[0].localTime
+            val rhs = args[1].localTime
             Datum.bool(lhs <= rhs)
         }
     }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnUtcnow.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnUtcnow.kt
index 9887245107..a18a9d5755 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnUtcnow.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/function/builtins/FnUtcnow.kt
@@ -6,13 +6,14 @@ package org.partiql.spi.function.builtins
 import org.partiql.spi.function.Function
 import org.partiql.spi.value.Datum
 import org.partiql.types.PType
-import org.partiql.value.datetime.TimestampWithTimeZone
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
 
 internal val Fn_UTCNOW____TIMESTAMP = Function.static(
     name = "utcnow",
-    returns = PType.timestamp(6),
+    returns = PType.timestampz(6),
     parameters = arrayOf(),
 ) {
-    val now = TimestampWithTimeZone.nowZ()
-    Datum.timestamp(now)
+    val now = OffsetDateTime.now(ZoneOffset.UTC)
+    Datum.timestampz(now, 6)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/value/ion/IonDatumReader.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/value/ion/IonDatumReader.kt
index 085be8d3ec..475e657d83 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/value/ion/IonDatumReader.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/value/ion/IonDatumReader.kt
@@ -10,7 +10,6 @@ import org.partiql.spi.value.Datum
 import org.partiql.spi.value.DatumReader
 import org.partiql.spi.value.Encoding
 import org.partiql.spi.value.Field
-import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
 import java.io.IOException
 import java.io.InputStream
 
@@ -182,14 +181,14 @@ internal class IonDatumReader internal constructor(
     }
 
     private fun decimal0(): Datum {
-        val v = reader.decimalValue().toBigDecimal()
+        val v = reader.decimalValue().bigDecimalValue()
         val p = v.precision()
         val s = v.scale()
         return Datum.decimal(v, p, s)
     }
 
     private fun decimal1(precision: Int): Datum {
-        val v = reader.decimalValue().toBigDecimal()
+        val v = reader.decimalValue().bigDecimalValue()
         val p = v.precision()
         val s = v.scale()
         if (p != precision) {
@@ -199,7 +198,7 @@ internal class IonDatumReader internal constructor(
     }
 
     private fun decimal2(precision: Int, scale: Int): Datum {
-        val v = reader.decimalValue().toBigDecimal()
+        val v = reader.decimalValue().bigDecimalValue()
         val p = v.precision()
         val s = v.scale()
         if (p != precision) {
diff --git a/partiql-spi/src/main/kotlin/org/partiql/spi/value/ion/IonVariant.kt b/partiql-spi/src/main/kotlin/org/partiql/spi/value/ion/IonVariant.kt
index 90d3a586bb..b2a9e4bc0a 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/spi/value/ion/IonVariant.kt
+++ b/partiql-spi/src/main/kotlin/org/partiql/spi/value/ion/IonVariant.kt
@@ -1,5 +1,6 @@
 package org.partiql.spi.value.ion
 
+import com.amazon.ion.Timestamp
 import com.amazon.ion.system.IonBinaryWriterBuilder
 import com.amazon.ion.system.IonTextWriterBuilder
 import com.amazon.ionelement.api.AnyElement
@@ -20,10 +21,17 @@ import com.amazon.ionelement.api.IntElementSize
 import org.partiql.spi.value.Datum
 import org.partiql.spi.value.Field
 import org.partiql.types.PType
-import org.partiql.value.datetime.DateTimeValue
 import java.io.ByteArrayOutputStream
+import java.math.BigDecimal
+import java.math.BigInteger
 import java.nio.charset.Charset
 import java.nio.charset.StandardCharsets
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+import java.time.OffsetDateTime
+import java.time.OffsetTime
+import java.time.ZoneOffset
 
 /**
  * A [Datum] implemented over Ion's [AnyElement].
@@ -62,7 +70,11 @@ internal class IonVariant(private var value: AnyElement) : Datum {
             BOOL -> Datum.bool(value.booleanValue)
             CLOB -> Datum.clob(value.clobValue.copyOfBytes())
             BLOB -> Datum.blob(value.blobValue.copyOfBytes())
-            TIMESTAMP -> Datum.timestamp(DateTimeValue.timestamp(value.timestampValue))
+            TIMESTAMP -> {
+                val ts = value.timestampValue
+                val ot = ts.toOffsetDateTime()
+                Datum.timestampz(ot, 9)
+            }
             INT -> {
                 when (value.integerSize) {
                     IntElementSize.LONG -> {
@@ -115,4 +127,140 @@ internal class IonVariant(private var value: AnyElement) : Datum {
     override fun isNull(): Boolean = false
 
     override fun isMissing(): Boolean = false
+
+    override fun getString(): String = when (value.type) {
+        SYMBOL -> value.stringValue
+        STRING -> value.stringValue
+        else -> super.getString()
+    }
+
+    override fun getBoolean(): Boolean = when (value.type) {
+        BOOL -> value.booleanValue
+        else -> super.getBoolean()
+    }
+
+    @Deprecated("Deprecated in Java")
+    override fun getBytes(): ByteArray = when (value.type) {
+        CLOB -> value.clobValue.copyOfBytes()
+        BLOB -> value.blobValue.copyOfBytes()
+        else -> super.getBytes()
+    }
+
+    /**
+     * Ion timestamp with "whole-day precision" and no time component.
+     */
+    override fun getLocalDate(): LocalDate {
+        if (value.type != TIMESTAMP) {
+            return super.getLocalDate()
+        }
+        val ts = value.timestampValue
+        return LocalDate.of(ts.year, ts.month, ts.day)
+    }
+
+    /**
+     * Ion does not have a TIME type, only TIMESTAMP, so use lower() then coerce.
+     */
+    override fun getLocalTime(): LocalTime {
+        throw IllegalArgumentException("getLocalTime() not supported, use lower() or getLocalDateTime()")
+    }
+
+    /**
+     * Ion does not have TIMEZ type, only TIMESTAMP, so use lower() then coerce.
+     */
+    override fun getOffsetTime(): OffsetTime {
+        throw IllegalArgumentException("getOffsetTime() not supported, use lower() or getOffsetDateTime()")
+    }
+
+    /**
+     * Get the OffsetDateTime and return the local part.
+     *
+     * See: https://github.com/partiql/partiql-lang-kotlin/issues/1689
+     */
+    override fun getLocalDateTime(): LocalDateTime {
+        return offsetDateTime.toLocalDateTime()
+    }
+
+    /**
+     * Get the OffsetDateTime, using UTC if no offset is given.
+     */
+    override fun getOffsetDateTime(): OffsetDateTime {
+        if (value.type != TIMESTAMP) {
+            return super.getOffsetDateTime()
+        }
+        return value.timestampValue.toOffsetDateTime()
+    }
+
+    override fun getBigInteger(): BigInteger = when (value.type) {
+        INT -> value.bigIntegerValue
+        else -> super.getBigInteger()
+    }
+
+    override fun getDouble(): Double = when (value.type) {
+        FLOAT -> value.doubleValue
+        else -> super.getDouble()
+    }
+
+    override fun getBigDecimal(): BigDecimal = when (value.type) {
+        DECIMAL -> value.decimalValue.bigDecimalValue()
+        else -> super.getBigDecimal()
+    }
+
+    override fun iterator(): MutableIterator<Datum> = when (value.type) {
+        LIST -> value.listValues.map { IonVariant(it) }.toMutableList().iterator()
+        SEXP -> value.sexpValues.map { IonVariant(it) }.toMutableList().iterator()
+        else -> super.iterator()
+    }
+
+    override fun getFields(): MutableIterator<Field> {
+        if (value.type != STRUCT) {
+            return super.getFields()
+        }
+        return value.structFields.map { Field.of(it.name, IonVariant(it.value)) }.toMutableList().iterator()
+    }
+
+    override fun get(name: String): Datum {
+        if (value.type != STRUCT) {
+            return super.get(name)
+        }
+        // TODO handle multiple/ambiguous field names?
+        val v = value.asStruct().getOptional(name)
+        return if (v == null) {
+            Datum.missing()
+        } else {
+            IonVariant(v)
+        }
+    }
+
+    override fun getInsensitive(name: String): Datum {
+        if (value.type != STRUCT) {
+            return super.get(name)
+        }
+        // TODO handle multiple/ambiguous field names?
+        val struct = value.asStruct()
+        for (field in struct.fields) {
+            if (field.name.equals(name, ignoreCase = true)) {
+                return IonVariant(field.value)
+            }
+        }
+        return Datum.missing()
+    }
+
+    /**
+     * Get the OffsetDateTime from an Ion Timestamp, using UTC if no offset is given.
+     */
+    private fun Timestamp.toOffsetDateTime(): OffsetDateTime {
+        val ts = this
+        val tz = when (val o = ts.localOffset) {
+            null -> ZoneOffset.UTC
+            else -> ZoneOffset.ofHoursMinutes(o / 60, o % 60)
+        }
+        // [0-59].000_000_000
+        val ds = ts.decimalSecond
+        val second: Int = ds.toInt()
+        val nanoOfSecond: Int = ds.remainder(BigDecimal.ONE).movePointRight(9).toInt()
+        // date/time pair
+        val date = LocalDate.of(ts.year, ts.month, ts.day)
+        val time = LocalTime.of(ts.hour, ts.minute, second, nanoOfSecond)
+        return OffsetDateTime.of(date, time, tz)
+    }
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeUtil.kt b/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeUtil.kt
deleted file mode 100644
index ef1e4b2996..0000000000
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeUtil.kt
+++ /dev/null
@@ -1,52 +0,0 @@
-/*
- * 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-spi/src/test/kotlin/org/partiql/eval/value/DatumComparatorTest.kt b/partiql-spi/src/test/kotlin/org/partiql/eval/value/DatumComparatorTest.kt
index 9b19422c34..021f82fa21 100644
--- a/partiql-spi/src/test/kotlin/org/partiql/eval/value/DatumComparatorTest.kt
+++ b/partiql-spi/src/test/kotlin/org/partiql/eval/value/DatumComparatorTest.kt
@@ -3,11 +3,13 @@ package org.partiql.spi.value
 import org.junit.jupiter.api.Assertions.assertEquals
 import org.junit.jupiter.api.Test
 import org.partiql.types.PType
-import org.partiql.value.datetime.DateTimeValue.date
-import org.partiql.value.datetime.DateTimeValue.time
-import org.partiql.value.datetime.DateTimeValue.timestamp
-import org.partiql.value.datetime.TimeZone
 import java.math.BigDecimal
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+import java.time.OffsetDateTime
+import java.time.OffsetTime
+import java.time.ZoneOffset
 import java.util.Base64
 import java.util.Random
 
@@ -165,39 +167,30 @@ class DatumComparatorTest {
             Datum.doublePrecision(Double.POSITIVE_INFINITY),
         ),
         EquivValues(
-            Datum.date(date(year = 1992, month = 8, day = 22))
+            Datum.date(LocalDate.of(1992, 8, 22))
         ),
         EquivValues(
-            Datum.date(date(year = 2021, month = 8, day = 22))
+            Datum.date(LocalDate.of(2021, 8, 22))
         ),
-        // Set a [timeZone] for every [TimeValue] and [TimestampValue] since comparison between time types without
-        // a timezone results in an error. TODO: add a way to compare between time and timestamp types
         EquivValues(
-            Datum.time(time(hour = 12, minute = 12, second = 12, timeZone = TimeZone.UnknownTimeZone)),
-            Datum.time(time(hour = 12, minute = 12, second = 12, nano = 0, timeZone = TimeZone.UnknownTimeZone)),
-            Datum.time(time(hour = 12, minute = 12, second = 12, timeZone = TimeZone.UnknownTimeZone)),
-            // time second precision handled by time constructor
-            Datum.time(time(hour = 12, minute = 12, second = 12, timeZone = TimeZone.UtcOffset.of(0))),
+            Datum.timez(OffsetTime.of(12, 12, 12, 0, ZoneOffset.UTC), 9),
+            Datum.timez(OffsetTime.of(12, 12, 12, 0, ZoneOffset.ofHours(0)), 9),
         ),
         EquivValues(
-            Datum.time(time(hour = 12, minute = 12, second = 12, nano = 100000000, timeZone = TimeZone.UnknownTimeZone)),
+            Datum.time(LocalTime.of(12, 12, 12, 100000000), 9),
         ),
         EquivValues(
-            Datum.time(time(hour = 12, minute = 12, second = 12, nano = 0, timeZone = TimeZone.UtcOffset.of(-8, 0))),
-            Datum.time(time(hour = 12, minute = 12, second = 12, timeZone = TimeZone.UtcOffset.of(-8, 0))),
+            Datum.timez(OffsetTime.of(12, 12, 12, 100000000, ZoneOffset.ofHours(-9)), 9),
         ),
         EquivValues(
-            Datum.time(time(hour = 12, minute = 12, second = 12, nano = 100000000, timeZone = TimeZone.UtcOffset.of(-9, 0))),
+            Datum.timestamp(LocalDateTime.of(2017, 1, 1, 0, 0, 0), 6),
         ),
         EquivValues(
-            Datum.timestamp(timestamp(year = 2017, timeZone = TimeZone.UtcOffset.of(0, 0))), // `2017T`
-            Datum.timestamp(timestamp(year = 2017, month = 1, timeZone = TimeZone.UtcOffset.of(0, 0))), // `2017-01T`
-            Datum.timestamp(timestamp(year = 2017, month = 1, day = 1, timeZone = TimeZone.UtcOffset.of(0, 0))), // `2017-01-01T`
-            Datum.timestamp(timestamp(year = 2017, month = 1, day = 1, hour = 0, minute = 0, second = 0, timeZone = TimeZone.UtcOffset.of(0, 0))), // `2017-01-01T00:00-00:00`
-            Datum.timestamp(timestamp(year = 2017, month = 1, day = 1, hour = 1, minute = 0, second = 0, timeZone = TimeZone.UtcOffset.of(1, 0))) // `2017-01-01T01:00+01:00`
-        ),
-        EquivValues(
-            Datum.timestamp(timestamp(year = 2017, month = 1, day = 1, hour = 1, minute = 0, second = 0, timeZone = TimeZone.UtcOffset.of(0, 0))) // `2017-01-01T01:00Z`
+            Datum.timestampz(OffsetDateTime.of(2017, 1, 1, 0, 0, 0, 0, ZoneOffset.ofHours(0)), 6), // `2017-01-01T00:00+00`
+            Datum.timestampz(OffsetDateTime.of(2017, 1, 1, 0, 0, 0, 0, ZoneOffset.ofHoursMinutes(0, 0)), 6), // `2017-01-01T00:00+00:00`
+            // equality with different offsets not defined in partiql
+            // Datum.timestampz(OffsetDateTime.of(2017, 1, 1, 1, 0, 0, 0, ZoneOffset.ofHours(1)), 6), // `2017-01-01T01:00+01`
+            // Datum.timestampz(OffsetDateTime.of(2017, 1, 1, 1, 0, 0, 0, ZoneOffset.ofHoursMinutes(-1, 0)), 6), // `2017-01-01T01:00+01:00`
         ),
         EquivValues(
             Datum.string(""),
diff --git a/partiql-spi/src/testFixtures/java/org/partiql/spi/value/ValueUtils.java b/partiql-spi/src/testFixtures/java/org/partiql/spi/value/ValueUtils.java
index 32d40b7b39..a5aea84704 100644
--- a/partiql-spi/src/testFixtures/java/org/partiql/spi/value/ValueUtils.java
+++ b/partiql-spi/src/testFixtures/java/org/partiql/spi/value/ValueUtils.java
@@ -7,6 +7,8 @@
 import org.partiql.value.PartiQL;
 import org.partiql.value.PartiQLValue;
 import org.partiql.value.PartiQLValueType;
+import org.partiql.value.datetime.DateTimeUtil;
+
 import java.math.BigDecimal;
 import java.util.Objects;
 import static org.partiql.types.PType.ARRAY;
@@ -78,13 +80,15 @@ public static PartiQLValue newPartiQLValue(@NotNull Datum datum) {
             case CLOB:
                 return datum.isNull() ? PartiQL.clobValue(null) : PartiQL.clobValue(datum.getBytes());
             case DATE:
-                return datum.isNull() ? PartiQL.dateValue(null) : PartiQL.dateValue(datum.getDate());
+                return datum.isNull() ? PartiQL.dateValue(null) : PartiQL.dateValue(DateTimeUtil.toDate(datum.getLocalDate()));
+            case TIME:
+                return datum.isNull() ? PartiQL.timeValue(null) : PartiQL.timeValue(DateTimeUtil.toTime(datum.getLocalTime()));
             case TIMEZ:
-            case TIME: // TODO
-                return datum.isNull() ? PartiQL.timeValue(null) : PartiQL.timeValue(datum.getTime());
-            case TIMESTAMPZ:
+                return datum.isNull() ? PartiQL.timeValue(null) : PartiQL.timeValue(DateTimeUtil.toTime(datum.getOffsetTime()));
             case TIMESTAMP:
-                return datum.isNull() ? PartiQL.timestampValue(null) : PartiQL.timestampValue(datum.getTimestamp());
+                return datum.isNull() ? PartiQL.timestampValue(null) : PartiQL.timestampValue(DateTimeUtil.toTimestamp(datum.getLocalDateTime()));
+            case TIMESTAMPZ:
+                return datum.isNull() ? PartiQL.timestampValue(null) : PartiQL.timestampValue(DateTimeUtil.toTimestamp(datum.getOffsetDateTime()));
             case BAG:
                 return datum.isNull() ? PartiQL.bagValue((Iterable<? extends PartiQLValue>) null) : PartiQL.bagValue(new PQLToPartiQLIterable(datum));
             case ARRAY:
@@ -158,16 +162,15 @@ public static Datum newDatum(PartiQLValue value) {
                 throw new UnsupportedOperationException();
             case DATE:
                 org.partiql.value.DateValue DATEValue = (org.partiql.value.DateValue) value;
-                return new DatumDate(Objects.requireNonNull(DATEValue.getValue()));
-            case INTERVAL:
-                org.partiql.value.IntervalValue INTERVALValue = (org.partiql.value.IntervalValue) value;
-                return new DatumInterval(Objects.requireNonNull(INTERVALValue.getValue()));
-            case TIMESTAMP:
-                org.partiql.value.TimestampValue TIMESTAMPValue = (org.partiql.value.TimestampValue) value;
-                return new DatumTimestamp(Objects.requireNonNull(TIMESTAMPValue.getValue()));
+                return DateTimeUtil.toDatumDate(Objects.requireNonNull(DATEValue.getValue()));
             case TIME:
                 org.partiql.value.TimeValue TIMEValue = (org.partiql.value.TimeValue) value;
-                return new DatumTime(Objects.requireNonNull(TIMEValue.getValue()));
+                return DateTimeUtil.toDatumTime(Objects.requireNonNull(TIMEValue.getValue()));
+            case TIMESTAMP:
+                org.partiql.value.TimestampValue TIMESTAMPValue = (org.partiql.value.TimestampValue) value;
+                return DateTimeUtil.toDatumTimestamp(Objects.requireNonNull(TIMESTAMPValue.getValue()));
+            case INTERVAL:
+                throw new UnsupportedOperationException("interval not supported");
             case FLOAT32:
                 org.partiql.value.Float32Value FLOAT32Value = (org.partiql.value.Float32Value) value;
                 return new DatumFloat(Objects.requireNonNull(FLOAT32Value.getValue()));
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTime.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTime.kt
similarity index 99%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTime.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTime.kt
index 34a2859597..b6a21eb364 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTime.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTime.kt
@@ -15,10 +15,8 @@
 
 package org.partiql.value.datetime
 
-import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
 import org.partiql.value.datetime.impl.OffsetTimestampLowPrecision
 import java.math.BigDecimal
-import kotlin.jvm.Throws
 
 /**
  * Superclass for all classes representing datetime values.
@@ -375,6 +373,7 @@ public abstract class TimeWithTimeZone : Time {
     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
 
     /**
@@ -398,8 +397,10 @@ public abstract class TimeWithTimeZone : Time {
         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)"
 }
@@ -494,6 +495,7 @@ public abstract class TimestampWithTimeZone : Timestamp {
     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
 
@@ -551,6 +553,7 @@ public abstract class TimestampWithoutTimeZone : Timestamp {
     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
 
@@ -561,6 +564,7 @@ public abstract class TimestampWithoutTimeZone : Timestamp {
     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
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeComparator.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeComparator.kt
similarity index 100%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeComparator.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeComparator.kt
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeException.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeException.kt
similarity index 94%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeException.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeException.kt
index 075bda21c5..9a12abed4d 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeException.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeException.kt
@@ -19,5 +19,5 @@ package org.partiql.value.datetime
  */
 public class DateTimeException(
     public override val message: String? = null,
-    public override val cause: Throwable? = null
+    public override val cause: Throwable? = null,
 ) : RuntimeException()
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt
similarity index 98%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt
index 60717e4cc5..cc8569ac0b 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimePrecisionChanger.kt
@@ -118,7 +118,8 @@ internal object DateTimePrecisionChanger {
         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()
+        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-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeUtil.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeUtil.kt
new file mode 100644
index 0000000000..bd97634ed9
--- /dev/null
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeUtil.kt
@@ -0,0 +1,124 @@
+/*
+ * 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.spi.value.Datum
+import org.partiql.types.PType
+import org.partiql.value.datetime.impl.LocalTimeLowPrecision
+import org.partiql.value.datetime.impl.LocalTimeLowPrecision.Companion.forNano
+import org.partiql.value.datetime.impl.LocalTimestampLowPrecision.Companion.forDateTime
+import org.partiql.value.datetime.impl.OffsetTimeLowPrecision
+import org.partiql.value.datetime.impl.OffsetTimeLowPrecision.Companion.of
+import org.partiql.value.datetime.impl.OffsetTimestampLowPrecision.Companion.forDateTime
+import org.partiql.value.datetime.impl.SqlDate
+import java.math.BigDecimal
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.LocalTime
+import java.time.OffsetDateTime
+import java.time.OffsetTime
+import java.time.ZoneOffset
+
+internal object DateTimeUtil {
+
+    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")
+    }
+
+    @JvmStatic
+    fun toDate(date: LocalDate): Date {
+        return SqlDate.of(date.year, date.monthValue, date.dayOfMonth)
+    }
+
+    @JvmStatic
+    fun toTime(time: LocalTime): Time {
+        return forNano(time.hour, time.minute, time.second, time.nano)
+    }
+
+    @JvmStatic
+    fun toTime(time: OffsetTime): Time {
+        val offset = time.offset.totalSeconds
+        val zone: TimeZone = TimeZone.UtcOffset.of(offset / 60, offset % 60)
+        return of(time.hour, time.minute, time.second, time.nano, zone)
+    }
+
+    @JvmStatic
+    fun toTimestamp(timestamp: LocalDateTime): Timestamp {
+        val date = toDate(timestamp.toLocalDate())
+        val time = toTime(timestamp.toLocalTime())
+        return forDateTime(
+            (date as SqlDate), (time as LocalTimeLowPrecision)
+        )
+    }
+
+    @JvmStatic
+    fun toTimestamp(timestamp: OffsetDateTime): Timestamp {
+        val date = toDate(timestamp.toLocalDate())
+        val time = toTime(timestamp.toOffsetTime())
+        return forDateTime(
+            date, (time as OffsetTimeLowPrecision)
+        )
+    }
+
+    @JvmStatic
+    fun toDatumDate(date: Date): Datum {
+        return Datum.date(LocalDate.of(date.year, date.month, date.day))
+    }
+
+    @JvmStatic
+    fun toDatumTime(time: Time): Datum {
+        // [0-59].000_000_000
+        val ds = time.decimalSecond
+        val second: Int = ds.toInt()
+        val nanoOfSecond: Int = ds.remainder(BigDecimal.ONE).movePointRight(9).toInt()
+        // local
+        val local = LocalTime.of(time.hour, time.minute, second, nanoOfSecond)
+        // check offset
+        if (time.timeZone != null && time.timeZone is TimeZone.UtcOffset) {
+            val zone = time.timeZone as TimeZone.UtcOffset
+            val offset = ZoneOffset.ofHoursMinutes(zone.tzHour, zone.tzMinute)
+            return Datum.timez(local.atOffset(offset), 9)
+        }
+        return Datum.time(local, 9)
+    }
+
+    @JvmStatic
+    fun toDatumTimestamp(timestamp: Timestamp): Datum {
+        val date = toDatumDate(timestamp.toDate()).localDate
+        val time = toDatumTime(timestamp.toTime())
+        return when (time.type.code()) {
+            PType.TIME -> Datum.timestamp(LocalDateTime.of(date, time.localTime), 9)
+            PType.TIMEZ -> Datum.timestampz(OffsetDateTime.of(date, time.localTime, time.offsetTime.offset), 9)
+            else -> throw IllegalArgumentException("unsupported timestamp type")
+        }
+    }
+}
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeValue.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeValue.kt
similarity index 97%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeValue.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeValue.kt
index 291f5f98d8..8db987767a 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/DateTimeValue.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/DateTimeValue.kt
@@ -16,7 +16,6 @@
 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
@@ -53,7 +52,7 @@ public object DateTimeValue {
         hour: Int = 0,
         minute: Int = 0,
         second: BigDecimal = BigDecimal.ZERO,
-        timeZone: TimeZone? = null
+        timeZone: TimeZone? = null,
     ): Timestamp =
         when (timeZone) {
             TimeZone.UnknownTimeZone -> {
@@ -99,7 +98,7 @@ public object DateTimeValue {
         hour: Int,
         minute: Int,
         second: Int,
-        timeZone: TimeZone? = null
+        timeZone: TimeZone? = null,
     ): Timestamp =
         timestamp(year, month, day, hour, minute, second.toBigDecimal(), timeZone)
 
@@ -186,7 +185,7 @@ public object DateTimeValue {
         hour: Int,
         minute: Int,
         second: BigDecimal,
-        timeZone: TimeZone? = null
+        timeZone: TimeZone? = null,
     ): Time =
         when (timeZone) {
             TimeZone.UnknownTimeZone -> {
@@ -226,7 +225,7 @@ public object DateTimeValue {
         hour: Int,
         minute: Int,
         second: Int,
-        timeZone: TimeZone? = null
+        timeZone: TimeZone? = null,
     ): Time =
         time(hour, minute, second.toBigDecimal(), timeZone)
 
@@ -246,7 +245,7 @@ public object DateTimeValue {
         minute: Int,
         second: Int,
         nano: Int,
-        timeZone: TimeZone? = null
+        timeZone: TimeZone? = null,
     ): Time {
         val decimalSecond = second.toBigDecimal().plus(nano.toBigDecimal().movePointLeft(9))
         return time(hour, minute, decimalSecond, timeZone)
@@ -256,7 +255,7 @@ public object DateTimeValue {
     public fun date(
         year: Int,
         month: Int,
-        day: Int
+        day: Int,
     ): Date =
         SqlDate.of(year, month, day)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/TimeZone.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/TimeZone.kt
similarity index 99%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/TimeZone.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/TimeZone.kt
index 04aa978e5c..53b2fc9218 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/TimeZone.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/TimeZone.kt
@@ -37,6 +37,7 @@ public sealed class TimeZone {
         val tzMinute: Int by lazy {
             this.totalOffsetMinutes - this.tzHour * 60
         }
+
         public companion object {
 
             /**
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt
similarity index 93%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt
index 964e370796..d7b238e40d 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimeHighPrecision.kt
@@ -18,7 +18,6 @@ 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.TimeWithoutTimeZone
 import org.partiql.value.datetime.TimeZone
 import java.math.BigDecimal
@@ -34,13 +33,13 @@ internal class LocalTimeHighPrecision private constructor(
     override val hour: Int,
     override val minute: Int,
     override val decimalSecond: BigDecimal,
-    _elapsedSecond: BigDecimal? = null
+    _elapsedSecond: BigDecimal? = null,
 ) : TimeWithoutTimeZone() {
     companion object {
         fun of(
             hour: Int,
             minute: Int,
-            decimalSecond: BigDecimal
+            decimalSecond: BigDecimal,
         ): LocalTimeHighPrecision {
             try {
                 ChronoField.HOUR_OF_DAY.checkValidValue(hour.toLong())
@@ -85,5 +84,6 @@ internal class LocalTimeHighPrecision private constructor(
     override fun withTimeZone(timeZone: TimeZone): OffsetTimeHighPrecision =
         OffsetTimeHighPrecision.of(hour, minute, decimalSecond, timeZone)
 
-    fun copy(_elapsedSecond: BigDecimal? = null) = LocalTimeHighPrecision(this.hour, this.minute, this.decimalSecond, _elapsedSecond)
+    fun copy(_elapsedSecond: BigDecimal? = null) =
+        LocalTimeHighPrecision(this.hour, this.minute, this.decimalSecond, _elapsedSecond)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt
similarity index 93%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt
index cdda78e358..ebd9831711 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimeLowPrecision.kt
@@ -96,8 +96,10 @@ internal class LocalTimeLowPrecision private constructor(
         } else {
             val (wholeSecond, nano) = Utils.getSecondAndNanoFromDecimalSecond(seconds)
             val newTime = localTime.plusSeconds(wholeSecond).plusNanos(nano)
-            val newDecimalSecond = Utils.getDecimalSecondFromSecondAndNano(newTime.second.toLong(), newTime.nano.toLong())
-            val roundedDecimalSecond = newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
+            val newDecimalSecond =
+                Utils.getDecimalSecondFromSecondAndNano(newTime.second.toLong(), newTime.nano.toLong())
+            val roundedDecimalSecond =
+                newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
             of(newTime.hour, newTime.minute, roundedDecimalSecond)
         }
 
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt
similarity index 98%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt
index ad3ff50270..3442c30c84 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimestampHighPrecision.kt
@@ -28,7 +28,7 @@ import java.math.RoundingMode
  */
 internal class LocalTimestampHighPrecision private constructor(
     val date: SqlDate,
-    val time: LocalTimeHighPrecision
+    val time: LocalTimeHighPrecision,
 ) : TimestampWithoutTimeZone() {
     companion object {
         /**
@@ -55,7 +55,7 @@ internal class LocalTimestampHighPrecision private constructor(
             day: Int,
             hour: Int,
             minute: Int,
-            decimalSecond: BigDecimal
+            decimalSecond: BigDecimal,
         ): LocalTimestampHighPrecision {
             val date = SqlDate.of(year, month, day)
             val time = LocalTimeHighPrecision.of(hour, minute, decimalSecond)
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt
similarity index 92%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt
index 19cf1c1ebc..95b038f48a 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/LocalTimestampLowPrecision.kt
@@ -32,7 +32,7 @@ import kotlin.math.max
 internal class LocalTimestampLowPrecision private constructor(
     private val localDateTime: LocalDateTime,
     val date: SqlDate,
-    val time: LocalTimeLowPrecision
+    val time: LocalTimeLowPrecision,
 ) : TimestampWithoutTimeZone() {
     companion object {
         fun forDateTime(date: SqlDate, time: LocalTimeLowPrecision): LocalTimestampLowPrecision {
@@ -42,13 +42,14 @@ internal class LocalTimestampLowPrecision private constructor(
             )
             return LocalTimestampLowPrecision(localDateTime, date, time)
         }
+
         fun of(
             year: Int,
             month: Int,
             day: Int,
             hour: Int,
             minute: Int,
-            decimalSecond: BigDecimal
+            decimalSecond: BigDecimal,
         ): LocalTimestampLowPrecision {
             val date = SqlDate.of(year, month, day)
             val time = LocalTimeLowPrecision.of(hour, minute, decimalSecond)
@@ -99,8 +100,10 @@ internal class LocalTimestampLowPrecision private constructor(
             val (wholeSecond, nano) = Utils.getSecondAndNanoFromDecimalSecond(seconds)
             val newTime = localDateTime.plusSeconds(wholeSecond).plusNanos(nano)
             // the real precision of this operation, should be max(original_value.decimalSecond.precision, seconds.precision)
-            val newDecimalSecond = Utils.getDecimalSecondFromSecondAndNano(newTime.second.toLong(), newTime.nano.toLong())
-            val roundedDecimalSecond = newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
+            val newDecimalSecond =
+                Utils.getDecimalSecondFromSecondAndNano(newTime.second.toLong(), newTime.nano.toLong())
+            val roundedDecimalSecond =
+                newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
             of(newTime.year, newTime.monthValue, newTime.dayOfMonth, newTime.hour, newTime.minute, roundedDecimalSecond)
         }
 
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt
similarity index 98%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt
index 040396a9e1..e9a64334ac 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimeHighPrecision.kt
@@ -19,7 +19,6 @@ import org.partiql.value.datetime.Date
 import org.partiql.value.datetime.DateTimeUtil
 import org.partiql.value.datetime.DateTimeUtil.SECONDS_IN_DAY
 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.TimeZone
 import java.math.BigDecimal
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt
similarity index 91%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt
index 0591de31ed..d44aa9bdd7 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimeLowPrecision.kt
@@ -39,7 +39,7 @@ internal class OffsetTimeLowPrecision private constructor(
     _hour: Int? = null,
     _minute: Int? = null,
     _decimalSecond: BigDecimal? = null,
-    _timeZone: TimeZone? = null
+    _timeZone: TimeZone? = null,
 ) : TimeWithTimeZone() {
     companion object {
         fun of(
@@ -47,7 +47,7 @@ internal class OffsetTimeLowPrecision private constructor(
             minute: Int,
             second: Int,
             nanoOfSecond: Int,
-            timeZone: TimeZone
+            timeZone: TimeZone,
         ): OffsetTimeLowPrecision {
             try {
                 return when (timeZone) {
@@ -105,8 +105,10 @@ internal class OffsetTimeLowPrecision private constructor(
         } else {
             val (wholeSecond, nano) = Utils.getSecondAndNanoFromDecimalSecond(seconds)
             val newTime = offsetTime.plusSeconds(wholeSecond).plusNanos(nano)
-            val newDecimalSecond = Utils.getDecimalSecondFromSecondAndNano(newTime.second.toLong(), newTime.nano.toLong())
-            val roundedDecimalSecond = newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
+            val newDecimalSecond =
+                Utils.getDecimalSecondFromSecondAndNano(newTime.second.toLong(), newTime.nano.toLong())
+            val roundedDecimalSecond =
+                newDecimalSecond.setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
             of(newTime.hour, newTime.minute, roundedDecimalSecond, timeZone)
         }
 
@@ -130,6 +132,11 @@ internal class OffsetTimeLowPrecision private constructor(
         return of(local.hour, local.minute, this.decimalSecond, timeZone)
     }
 
-    fun copy(_hour: Int? = null, _minute: Int? = null, _decimalSecond: BigDecimal? = null, _timeZone: TimeZone? = null) =
+    fun copy(
+        _hour: Int? = null,
+        _minute: Int? = null,
+        _decimalSecond: BigDecimal? = null,
+        _timeZone: TimeZone? = null,
+    ) =
         OffsetTimeLowPrecision(this.offsetTime, this.isUnknownTimeZone, _hour, _minute, _decimalSecond, _timeZone)
 }
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt
similarity index 99%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt
index 138a63c2e9..76faf0eb38 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimestampHighPrecision.kt
@@ -68,7 +68,7 @@ internal class OffsetTimestampHighPrecision private constructor(
             hour: Int,
             minute: Int,
             second: BigDecimal,
-            timeZone: TimeZone
+            timeZone: TimeZone,
         ): OffsetTimestampHighPrecision {
             val date = SqlDate.of(year, month, day)
             val time = OffsetTimeHighPrecision.of(hour, minute, second, timeZone)
@@ -220,9 +220,10 @@ internal class OffsetTimestampHighPrecision private constructor(
 
         return BigDecimal.valueOf(adjustForTimeZoneInSecond).plus(this.time.elapsedSecond)
     }
+
     internal fun copy(
         _inputIonTimestamp: com.amazon.ion.Timestamp? = null,
-        _epochSecond: BigDecimal? = null
+        _epochSecond: BigDecimal? = null,
     ) =
         OffsetTimestampHighPrecision(
             this.date, this.time,
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt
similarity index 89%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt
index f20971de89..de79c706b4 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/OffsetTimestampLowPrecision.kt
@@ -16,9 +16,7 @@
 package org.partiql.value.datetime.impl
 
 import org.partiql.value.datetime.Date
-import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
 import org.partiql.value.datetime.TimeZone
-import org.partiql.value.datetime.Timestamp
 import org.partiql.value.datetime.TimestampWithTimeZone
 import java.math.BigDecimal
 import java.math.RoundingMode
@@ -41,7 +39,7 @@ internal class OffsetTimestampLowPrecision(
     val date: Date,
     val time: OffsetTimeLowPrecision,
     _inputIonTimestamp: com.amazon.ion.Timestamp? = null,
-    _epochSecond: BigDecimal? = null
+    _epochSecond: BigDecimal? = null,
 ) : TimestampWithTimeZone() {
 
     companion object {
@@ -87,7 +85,7 @@ internal class OffsetTimestampLowPrecision(
             hour: Int,
             minute: Int,
             decimalSecond: BigDecimal,
-            timeZone: TimeZone
+            timeZone: TimeZone,
         ): OffsetTimestampLowPrecision {
             val date = SqlDate.of(year, month, day)
             val time = OffsetTimeLowPrecision.of(hour, minute, decimalSecond, timeZone)
@@ -126,9 +124,21 @@ internal class OffsetTimestampLowPrecision(
             val date = SqlDate.of(offsetDateTime.year, offsetDateTime.monthValue, offsetDateTime.dayOfMonth)
             // we need to assign a precision based on the input epochSecond
             val time =
-                OffsetTimeLowPrecision
-                    .of(offsetDateTime.hour, offsetDateTime.minute, offsetDateTime.second, offsetDateTime.nano, timeZone)
-                    .let { it.copy(_decimalSecond = it.decimalSecond.setScale(epochSeconds.scale(), RoundingMode.UNNECESSARY)) }
+                OffsetTimeLowPrecision.of(
+                    offsetDateTime.hour,
+                    offsetDateTime.minute,
+                    offsetDateTime.second,
+                    offsetDateTime.nano,
+                    timeZone
+                )
+                    .let {
+                        it.copy(
+                            _decimalSecond = it.decimalSecond.setScale(
+                                epochSeconds.scale(),
+                                RoundingMode.UNNECESSARY
+                            )
+                        )
+                    }
             return forDateTime(date, time).copy(_epochSecond = epochSeconds)
         }
 
@@ -136,7 +146,13 @@ internal class OffsetTimestampLowPrecision(
         fun nowZ(): OffsetTimestampLowPrecision {
             val javaNowZ = OffsetDateTime.now(ZoneOffset.UTC)
             val date = SqlDate.of(javaNowZ.year, javaNowZ.monthValue, javaNowZ.dayOfMonth)
-            val time = OffsetTimeLowPrecision.of(javaNowZ.hour, javaNowZ.minute, javaNowZ.second, javaNowZ.nano, TimeZone.UtcOffset.of(0))
+            val time = OffsetTimeLowPrecision.of(
+                javaNowZ.hour,
+                javaNowZ.minute,
+                javaNowZ.second,
+                javaNowZ.nano,
+                TimeZone.UtcOffset.of(0)
+            )
             return forDateTime(date, time)
         }
     }
@@ -192,7 +208,8 @@ internal class OffsetTimestampLowPrecision(
             // 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.stripTrailingZeros().setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
+                newDecimalSecond.stripTrailingZeros()
+                    .setScale(max(this.decimalSecond.scale(), seconds.scale()), RoundingMode.UNNECESSARY)
             of(
                 newTime.year,
                 newTime.monthValue,
@@ -238,7 +255,7 @@ internal class OffsetTimestampLowPrecision(
 
     internal fun copy(
         _inputIonTimestamp: com.amazon.ion.Timestamp? = null,
-        _epochSecond: BigDecimal? = null
+        _epochSecond: BigDecimal? = null,
     ) =
         OffsetTimestampLowPrecision(
             this.offsetDateTime, this.isUnknownTimeZone, this.date, this.time,
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/SqlDate.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/SqlDate.kt
similarity index 97%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/SqlDate.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/SqlDate.kt
index 4343839ad8..b2d3eb67b9 100644
--- a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/SqlDate.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/SqlDate.kt
@@ -20,10 +20,9 @@ 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
+    val localDate: LocalDate,
 ) : DateImpl() {
     companion object {
         /**
@@ -56,11 +55,13 @@ internal data class SqlDate private constructor(
             .let { newDate ->
                 of(newDate.year, newDate.monthValue, newDate.dayOfMonth)
             }
+
     override fun plusMonths(months: Long): SqlDate =
         this.localDate.plusMonths(months)
             .let { newDate ->
                 of(newDate.year, newDate.monthValue, newDate.dayOfMonth)
             }
+
     override fun plusYears(years: Long): SqlDate =
         this.localDate.plusYears(years)
             .let { newDate ->
diff --git a/partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/Utils.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/Utils.kt
similarity index 100%
rename from partiql-spi/src/main/kotlin/org/partiql/value/datetime/impl/Utils.kt
rename to partiql-spi/src/testFixtures/kotlin/org/partiql/value/datetime/impl/Utils.kt
diff --git a/partiql-spi/src/testFixtures/kotlin/org/partiql/value/impl/Int32ValueImpl.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/impl/Int32ValueImpl.kt
index f917dfabfa..e49c3396cb 100644
--- a/partiql-spi/src/testFixtures/kotlin/org/partiql/value/impl/Int32ValueImpl.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/impl/Int32ValueImpl.kt
@@ -26,7 +26,6 @@ import org.partiql.value.Int32Value
 import org.partiql.value.Int64Value
 import org.partiql.value.Int8Value
 import org.partiql.value.IntValue
-import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
 import org.partiql.value.decimalValue
 import org.partiql.value.float32Value
 import org.partiql.value.float64Value
diff --git a/partiql-spi/src/testFixtures/kotlin/org/partiql/value/impl/Int64ValueImpl.kt b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/impl/Int64ValueImpl.kt
index a0a33615ae..8868b7e608 100644
--- a/partiql-spi/src/testFixtures/kotlin/org/partiql/value/impl/Int64ValueImpl.kt
+++ b/partiql-spi/src/testFixtures/kotlin/org/partiql/value/impl/Int64ValueImpl.kt
@@ -26,7 +26,6 @@ import org.partiql.value.Int32Value
 import org.partiql.value.Int64Value
 import org.partiql.value.Int8Value
 import org.partiql.value.IntValue
-import org.partiql.value.datetime.DateTimeUtil.toBigDecimal
 import org.partiql.value.decimalValue
 import org.partiql.value.float32Value
 import org.partiql.value.float64Value
diff --git a/test/partiql-randomized-tests/src/test/kotlin/org/partiql/lang/randomized/syntax/PartiQLParserDateTimeRandomizedTests.kt b/test/partiql-randomized-tests/src/test/kotlin/org/partiql/lang/randomized/syntax/PartiQLParserDateTimeRandomizedTests.kt
index 5405942461..4217aa150a 100644
--- a/test/partiql-randomized-tests/src/test/kotlin/org/partiql/lang/randomized/syntax/PartiQLParserDateTimeRandomizedTests.kt
+++ b/test/partiql-randomized-tests/src/test/kotlin/org/partiql/lang/randomized/syntax/PartiQLParserDateTimeRandomizedTests.kt
@@ -15,11 +15,7 @@
 
 package org.partiql.lang.randomized.syntax
 
-import org.junit.jupiter.api.Disabled
 import org.junit.jupiter.api.Test
-import org.partiql.lang.randomized.eval.assertExpression
-import org.partiql.spi.value.Datum
-import org.partiql.value.datetime.DateTimeValue
 import java.util.Random
 
 class PartiQLParserDateTimeRandomizedTests {
@@ -53,15 +49,14 @@ class PartiQLParserDateTimeRandomizedTests {
     }
 
     @Test
-    @Disabled("The planner does not return the v1 plans right now. See assertExpression.") // TODO
     fun testRandomDates() {
-        randomDates.map { date ->
-            val yearStr = date.year.toString().padStart(4, '0')
-            val monthStr = date.month.toString().padStart(2, '0')
-            val dayStr = date.day.toString().padStart(2, '0')
-            assertExpression("DATE '$yearStr-$monthStr-$dayStr'") {
-                Datum.date(DateTimeValue.date(date.year, date.month, date.day))
-            }
-        }
+        // randomDates.map { date -> val y = date.year.toString().padStart(4, '0')
+        //     val m = date.month.toString().padStart(2, '0')
+        //     val d = date.day.toString().padStart(2, '0')
+        //     assertExpression()
+        //     assertExpression("DATE '$yearStr-$monthStr-$dayStr'") {
+        //         Datum.date(DateTimeValue.date(date.year, date.month, date.day))
+        //     }
+        // }
     }
 }
diff --git a/test/partiql-tests-runner/src/test/kotlin/org/partiql/runner/io/DatumIonReader.kt b/test/partiql-tests-runner/src/test/kotlin/org/partiql/runner/io/DatumIonReader.kt
index 67fa93c5b6..fd5f62806f 100644
--- a/test/partiql-tests-runner/src/test/kotlin/org/partiql/runner/io/DatumIonReader.kt
+++ b/test/partiql-tests-runner/src/test/kotlin/org/partiql/runner/io/DatumIonReader.kt
@@ -8,12 +8,16 @@ import com.amazon.ionelement.api.IonElement
 import org.partiql.spi.value.Datum
 import org.partiql.spi.value.Field
 import org.partiql.types.PType
-import org.partiql.value.datetime.DateTimeValue
-import org.partiql.value.datetime.TimeZone
 import java.io.ByteArrayInputStream
 import java.io.ByteArrayOutputStream
 import java.io.IOException
 import java.io.InputStream
+import java.math.BigDecimal
+import java.time.LocalDate
+import java.time.LocalTime
+import java.time.OffsetDateTime
+import java.time.OffsetTime
+import java.time.ZoneOffset
 
 /**
  * Make an arbitrary call on partiql value read
@@ -22,7 +26,6 @@ import java.io.InputStream
  * For example:
  * In `IonForPartiQL` mode: if the input is $time::$day::$time{...}
  * The reader will attempt to create a time value
- *
  */
 class DatumIonReader(
     private val ionReader: IonReader,
@@ -106,8 +109,19 @@ class DatumIonReader(
                 Datum.decimal(d, d.precision(), d.scale())
             }
             IonType.TIMESTAMP -> {
-                val ts = DateTimeValue.timestamp(reader.timestampValue())
-                Datum.timestamp(ts)
+                val ts = reader.timestampValue()
+                val tz = when (ts.localOffset) {
+                    null -> ZoneOffset.UTC
+                    else -> ZoneOffset.ofHoursMinutes(ts.zHour, ts.zMinute)
+                }
+                // [0-59].000_000_000
+                val ds = ts.decimalSecond
+                val second: Int = ds.toInt()
+                val nanoOfSecond: Int = ds.remainder(BigDecimal.ONE).movePointRight(9).toInt()
+                // date/time pair
+                val date = LocalDate.of(ts.year, ts.month, ts.day)
+                val time = LocalTime.of(ts.hour, ts.minute, second, nanoOfSecond)
+                return Datum.timestampz(OffsetDateTime.of(date, time, tz), 9)
             }
             IonType.STRING, IonType.SYMBOL -> Datum.string(reader.stringValue())
             IonType.CLOB -> Datum.clob(reader.newBytes())
@@ -225,11 +239,10 @@ class DatumIonReader(
                             throw IllegalArgumentException("excess field in struct")
                         }
                         reader.stepOut()
-                        Datum.date(DateTimeValue.date(year.int, month.int, day.int))
+                        Datum.date(LocalDate.of(year.int, month.int, day.int))
                     }
                     PARTIQL_ANNOTATION.TIME_ANNOTATION -> {
                         reader.stepIn()
-                        val map = mutableMapOf<String, Any?>()
                         val hour = getRequiredFieldName(reader, "hour")
                         val minute = getRequiredFieldName(reader, "minute")
                         val second = getRequiredFieldName(reader, "second")
@@ -240,11 +253,15 @@ class DatumIonReader(
                         }
                         reader.stepOut()
                         val offsetTz = when {
-                            offset == null -> null
-                            offset.isNull -> TimeZone.UnknownTimeZone
-                            else -> TimeZone.UtcOffset.of(offset.int)
+                            offset == null || offset.isNull -> ZoneOffset.UTC
+                            else -> ZoneOffset.ofHoursMinutes(offset.int / 60, offset.int % 60)
                         }
-                        Datum.time(DateTimeValue.time(hour.int, minute.int, second.bigDecimal, offsetTz))
+                        // calculate second/nanos
+                        val ds = second.bigDecimal
+                        val seconds: Int = ds.toInt()
+                        val nanoOfSecond: Int = ds.remainder(BigDecimal.ONE).movePointRight(9).toInt()
+
+                        Datum.timez(OffsetTime.of(hour.int, minute.int, seconds, nanoOfSecond, offsetTz), 9)
                     }
                     PARTIQL_ANNOTATION.TIMESTAMP_ANNOTATION -> {
                         reader.stepIn()
@@ -255,18 +272,24 @@ class DatumIonReader(
                         val hour = getRequiredFieldName(reader, "hour")
                         val minute = getRequiredFieldName(reader, "minute")
                         val second = getRequiredFieldName(reader, "second")
+                        val offset: Datum? = getOptionalFieldName(reader, "offset")
                         // check remaining
                         if (reader.next() != null) {
                             throw IllegalArgumentException("excess field in struct")
                         }
                         reader.stepOut()
-                        Datum.timestamp(
-                            DateTimeValue.timestamp(
-                                year.int, month.int, day.int,
-                                hour.int, minute.int, second.bigDecimal,
-                                null
-                            )
-                        )
+                        val offsetTz = when {
+                            offset == null || offset.isNull -> ZoneOffset.UTC
+                            else -> ZoneOffset.ofHoursMinutes(offset.int / 60, offset.int % 60)
+                        }
+                        // calculate second/nanos
+                        val ds = second.bigDecimal
+                        val seconds: Int = ds.toInt()
+                        val nanoOfSecond: Int = ds.remainder(BigDecimal.ONE).movePointRight(9).toInt()
+                        // date/time
+                        val date = LocalDate.of(year.int, month.int, day.int)
+                        val time = LocalTime.of(hour.int, minute.int, seconds, nanoOfSecond)
+                        Datum.timestampz(OffsetDateTime.of(date, time, offsetTz), 9)
                     }
                     null -> fromIonGeneric(reader)
                     else -> error("Unsupported annotation.")
diff --git a/test/partiql-tests-runner/src/test/resources/config/eval/skip-eval.txt b/test/partiql-tests-runner/src/test/resources/config/eval/skip-eval.txt
index 52d32e5db0..ffb1c42441 100644
--- a/test/partiql-tests-runner/src/test/resources/config/eval/skip-eval.txt
+++ b/test/partiql-tests-runner/src/test/resources/config/eval/skip-eval.txt
@@ -18,6 +18,22 @@ STRICT:::divDecimalInt
 PERMISSIVE:::subtractionOutOfAllowedPrecision
 STRICT:::subtractionOutOfAllowedPrecision
 
+// TODO: Datetime methods for EXTRACT for TIME WITH TIMEZONE and TIMESTAMP WITH TIMEZONE
+PERMISSIVE:::EXTRACT(SECOND FROM TIME (2) '01:23:45.678')
+STRICT:::EXTRACT(SECOND FROM TIME (2) '01:23:45.678')
+PERMISSIVE:::EXTRACT(HOUR FROM TIME (2) WITH TIME ZONE '01:23:45.678-06:30')
+STRICT:::EXTRACT(HOUR FROM TIME (2) WITH TIME ZONE '01:23:45.678-06:30')
+PERMISSIVE:::EXTRACT(SECOND FROM TIME (2) WITH TIME ZONE '01:23:45.678-06:30')
+STRICT:::EXTRACT(SECOND FROM TIME (2) WITH TIME ZONE '01:23:45.678-06:30')
+PERMISSIVE:::EXTRACT(TIMEZONE_HOUR FROM `2000-01-02T03:04:05.67+08:09`)
+STRICT:::EXTRACT(TIMEZONE_HOUR FROM `2000-01-02T03:04:05.67+08:09`)
+PERMISSIVE:::EXTRACT(TIMEZONE_MINUTE FROM `2000-01-02T03:04:05.67+08:09`)
+STRICT:::EXTRACT(TIMEZONE_MINUTE FROM `2000-01-02T03:04:05.67+08:09`)
+PERMISSIVE:::EXTRACT(TIMEZONE_HOUR FROM `2000-01-02T03:04:05.67-08:09`)
+STRICT:::EXTRACT(TIMEZONE_HOUR FROM `2000-01-02T03:04:05.67-08:09`)
+PERMISSIVE:::EXTRACT(TIMEZONE_MINUTE FROM `2000-01-02T03:04:05.67-08:09`)
+STRICT:::EXTRACT(TIMEZONE_MINUTE FROM `2000-01-02T03:04:05.67-08:09`)
+
 // TODO: Undefined variable tests. Needed for V1 release.
 PERMISSIVE:::GROUP BY binding referenced in FROM clause
 PERMISSIVE:::GROUP BY binding referenced in WHERE clause