From 126fe94e2303dd62d8e9622b1a6b1f83899e1524 Mon Sep 17 00:00:00 2001
From: Elliot Chance <elliotchance@gmail.com>
Date: Sun, 3 Jul 2022 17:53:18 -0400
Subject: [PATCH] F051: Basic date and time (#109)

In a nutshell, this adds storage support for date/time types and values.
Although, we do not yet support other features such as constants,
functions, comparisons and casting. They can come as a separate features
in the near future.

More specifically, this adds support for:

1. F051-01: `DATE` data type (including support of `DATE` literal).
2. F051-02: `TIME` data type (including support of `TIME` literal) with
fractional seconds precision of at least 0.
3. F051-03: `TIMESTAMP` data type (including support of `TIMESTAMP`
literal) with fractional seconds precision of at least 0 and 6.

The five new distinct data types and their storage requirements are:

1. `DATE` (8 bytes)
2. `TIME(n) WITH TIME ZONE` (10 bytes)
3. `TIME(n) WITHOUT TIME ZONE` or `TIME(n)` (8 bytes)
4. `TIMESTAMP(n) WITH TIME ZONE` (10 bytes)
5. `TIMESTAMP(n) WITHOUT TIME ZONE` or `TIMESTAMP(n)` (8 bytes)
---
 docs/data-types.rst     | 106 ++++++-
 docs/sql-compliance.rst |  34 ++-
 generate-grammar.py     |   4 +-
 grammar.bnf             |  81 +++++-
 tests/create-table.sql  |  39 +++
 tests/date.sql          |  63 +++++
 tests/time.sql          | 124 +++++++++
 tests/timestamp.sql     | 111 ++++++++
 vsql/ast.v              |   4 +-
 vsql/bytes.v            |  16 ++
 vsql/cast.v             |  88 +++---
 vsql/grammar.v          | 594 +++++++++++++++++++++++++++++++++++++++-
 vsql/parse.v            |  82 +++++-
 vsql/query_cache.v      |   8 +
 vsql/row.v              |  43 +--
 vsql/table.v            |   6 +-
 vsql/time.v             | 317 +++++++++++++++++++++
 vsql/type.v             | 131 +++++++--
 vsql/value.v            |  48 +++-
 19 files changed, 1779 insertions(+), 120 deletions(-)
 create mode 100644 tests/date.sql
 create mode 100644 tests/time.sql
 create mode 100644 tests/timestamp.sql
 create mode 100644 vsql/time.v

diff --git a/docs/data-types.rst b/docs/data-types.rst
index 57bb3f4..f399833 100644
--- a/docs/data-types.rst
+++ b/docs/data-types.rst
@@ -82,6 +82,105 @@ is an alias for ``CHARACTER(1)``.
 1. The *n* limit is not yet enforced.
 2. Values are not actually space padded.
 
+Date and Time Types
+-------------------
+
+``DATE``
+^^^^^^^^
+
+A ``DATE`` holds a year-month-day value, such as ``2010-10-25``.
+
+A ``DATE`` value can be created with the ``DATE '2010-10-25'`` literal
+expression.
+
+Valid date ranges are between ``0000-01-01`` and ``9999-12-31``.
+
+A ``DATE`` is stored as 8 bytes.
+
+``TIME(n) WITH TIME ZONE``
+^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Holds a time as hour-minute-second-timezone (without respect to a date),
+for example: ``15:12:47+05:30``.
+
+The ``(n)`` describes the sub-second resolution to be stored. It must be
+inclusively between 0 (whole seconds) and 6 (microseconds). If omitted, 0 is
+used.
+
+A ``TIME(n) WITH TIME ZONE`` value is created with the ``TIME 'VALUE'`` literal
+expression. The ``VALUE`` itself will determine whether the time has a time zone
+and its precision. For example:
+
+.. list-table::
+  :header-rows: 1
+
+  * - Expr
+    - Type
+
+  * - ``TIME '15:12:47'``
+    - ``TIME(0) WITHOUT TIME ZONE``
+
+  * - ``TIME '15:12:47.123'``
+    - ``TIME(3) WITHOUT TIME ZONE``
+
+  * - ``TIME '15:12:47+05:30'``
+    - ``TIME(0) WITH TIME ZONE``
+
+  * - ``TIME '15:12:47.000000+05:30'``
+    - ``TIME(6) WITH TIME ZONE``
+
+A ``TIME WITH TIME ZONE`` (with any precision) is stored as 10 bytes.
+
+``TIME(n) WITHOUT TIME ZONE``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This works the same way as ``TIME(n) WITH TIME ZONE`` except there is no
+time zone component.
+
+A ``TIME WITHOUT TIME ZONE`` (with any precision) is stored as 8 bytes.
+
+``TIMESTAMP(n) WITH TIME ZONE``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Holds a timestamp as year-month-day-hour-minute-second-timezone, for example:
+``2010-10-25 15:12:47+05:30``.
+
+The ``(n)`` describes the sub-second resolution to be stored. It must be
+inclusively between 0 (whole seconds) and 6 (microseconds). If omitted, 6 is
+used. This is different from the behavior of ``TIME`` that uses 0 by default.
+
+A ``TIMESTAMP(n) WITH TIME ZONE`` value is created with the
+``TIMESTAMP 'VALUE'`` literal expression. The ``VALUE`` itself will determine
+whether the timestamp has a time zone and its precision. For example:
+
+.. list-table::
+  :header-rows: 1
+
+  * - Expr
+    - Type
+
+  * - ``TIMESTAMP '2010-10-25 15:12:47'``
+    - ``TIMESTAMP(0) WITHOUT TIME ZONE``
+
+  * - ``TIMESTAMP '2010-10-25 15:12:47.123'``
+    - ``TIMESTAMP(3) WITHOUT TIME ZONE``
+
+  * - ``TIMESTAMP '2010-10-25 15:12:47+05:30'``
+    - ``TIMESTAMP(0) WITH TIME ZONE``
+
+  * - ``TIMESTAMP '2010-10-25 15:12:47.000000+05:30'``
+    - ``TIMESTAMP(6) WITH TIME ZONE``
+
+A ``TIMESTAMP WITH TIME ZONE`` (with any precision) is stored as 10 bytes.
+
+``TIMESTAMP(n) WITHOUT TIME ZONE``
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+This works the same way as ``TIMESTAMP(n) WITH TIME ZONE`` except there is no
+time zone component.
+
+A ``TIMESTAMP WITHOUT TIME ZONE`` (with any precision) is stored as 8 bytes.
+
 Unsupported Data Types
 ----------------------
 
@@ -136,13 +235,6 @@ Some are supported, but the remaining ones that are not supported:
 
 1. ``DECFLOAT``
 
-<datetime type>
-^^^^^^^^^^^^^^^
-
-1. ``DATE``
-2. ``TIME``
-3. ``TIMESTAMP``
-
 <interval type>
 ^^^^^^^^^^^^^^^
 
diff --git a/docs/sql-compliance.rst b/docs/sql-compliance.rst
index 0326f8e..7c8e283 100644
--- a/docs/sql-compliance.rst
+++ b/docs/sql-compliance.rst
@@ -210,9 +210,41 @@ The following table is **not complete** and will be filled in as time goes on.
      - All comparison operators are supported (rather than just =)
 
    * - **F051**
-     - **Unknown**
+     - **Partial**
      - **Basic date and time**
 
+   * - F051-01
+     - Yes
+     - ``DATE`` data type (including support of ``DATE`` literal)
+
+   * - F051-02
+     - Yes
+     - ``TIME`` data type (including support of ``TIME`` literal) with fractional seconds precision of at least 0.
+
+   * - F051-03
+     - Yes
+     - ``TIMESTAMP`` data type (including support of ``TIMESTAMP`` literal) with fractional seconds precision of at least 0 and 6.
+
+   * - F051-04
+     - No
+     - Comparison predicate on ``DATE``, ``TIME``, and ``TIMESTAMP`` data types
+
+   * - F051-05
+     - No
+     - Explicit ``CAST`` between date-time types and character string types
+
+   * - F051-06
+     - No
+     - ``CURRENT_DATE``
+
+   * - F051-07
+     - No
+     - ``LOCALTIME``
+
+   * - F051-08
+     - No
+     - ``LOCALTIMESTAMP``
+
    * - **F081**
      - **Unknown**
      - **UNION and EXCEPT in views**
diff --git a/generate-grammar.py b/generate-grammar.py
index 73e9f90..cb5e46c 100644
--- a/generate-grammar.py
+++ b/generate-grammar.py
@@ -418,7 +418,7 @@ def var_name(name):
     if node.children.len == 0 {
         match node.value.name {
             '^integer' {
-                return [EarleyValue(new_integer_value(node.value.end_column.value.int()))]
+                return [EarleyValue(node.value.end_column.value.int())]
             }
             '^identifier' {
                 return [EarleyValue(new_identifier(node.value.end_column.value))]
@@ -513,6 +513,8 @@ def parse_tree(text):
 # parse_tree("SELECT * FROM ( VALUES ROW ( 123 ) , ROW ( 456 ) )")
 # parse_tree("SELECT x FROM ( SELECT y FROM t2 )")
 # parse_tree("SELECT x , y FROM ( SELECT x , y FROM t1 )")
+# parse_tree("VALUES TIMESTAMP '2022-06-30'")
+# parse_tree("INSERT INTO foo ( f1 ) VALUES ( TIMESTAMP '2022-06-30' )")
 
 for arg in sys.argv[1:]:
     print(arg)
diff --git a/grammar.bnf b/grammar.bnf
index 5c5b80e..5ca13f5 100644
--- a/grammar.bnf
+++ b/grammar.bnf
@@ -81,6 +81,7 @@
     <character string type>
   | <numeric type>
   | <boolean type>
+  | <datetime type>
 
 <character string type> /* Type */ ::=
     CHARACTER                                                         -> character
@@ -95,13 +96,13 @@
 
 <right paren> ::= ")"
 
-<character length> /* Value */ ::=
+<character length> /* int */ ::=
     <length>
 
-<length> /* Value */ ::=
+<length> /* int */ ::=
     <unsigned integer>
 
-<unsigned integer> /* Value */ ::=
+<unsigned integer> /* int */ ::=
     ^integer
 
 <comma> ::= ","
@@ -122,7 +123,7 @@
   | REAL                                           -> real
   | DOUBLE PRECISION                               -> double_precision
 
-<precision> /* Value */ ::=
+<precision> /* int */ ::=
     <unsigned integer>
 
 <boolean type> /* Type */ ::=
@@ -182,8 +183,8 @@
     <SQL schema statement>
 
 <exact numeric literal> /* Value */ ::=
-    <unsigned integer>
-  | <unsigned integer> <period>                      -> value
+    <unsigned integer>                               -> int_value
+  | <unsigned integer> <period>                      -> int_value
   | <unsigned integer> <period> <unsigned integer>   -> exact_numeric_literal1
   | <period> <unsigned integer>                      -> exact_numeric_literal2
 
@@ -245,6 +246,19 @@
 <common value expression> /* Expr */ ::=
     <numeric value expression>
   | <string value expression>
+  | <datetime value expression>
+
+<datetime value expression> /* Expr */ ::=
+    <datetime term>
+
+<datetime term> /* Expr */ ::=
+    <datetime factor>
+
+<datetime factor> /* Expr */ ::=
+    <datetime primary>
+
+<datetime primary> /* Expr */ ::=
+    <value expression primary>
 
 <value expression> /* Expr */ ::=
     <common value expression>
@@ -365,8 +379,32 @@
 
 <general literal> /* Value */ ::=
     <character string literal>
+  | <datetime literal>
   | <boolean literal>
 
+<datetime literal> /* Value */ ::=
+    <date literal>
+  | <time literal>
+  | <timestamp literal>
+
+<date literal> /* Value */ ::=
+    DATE <date string>   -> date_literal
+
+<date string> /* Value */ ::=
+    ^string
+
+<time literal> /* Value */ ::=
+    TIME <time string>   -> time_literal
+
+<time string> /* Value */ ::=
+    ^string
+
+<timestamp literal> /* Value */ ::=
+    TIMESTAMP <timestamp string>   -> timestamp_literal
+
+<timestamp string> /* Value */ ::=
+    ^string
+
 <boolean literal> /* Value */ ::=
     TRUE      -> true
   | FALSE     -> false
@@ -914,3 +952,34 @@
     INNER
   | <outer join type>
   | <outer join type> OUTER   -> string
+
+<datetime type> /* Type */ ::=
+    DATE                                               -> date_type
+  | TIME                                               -> time_type
+  | TIME <left paren> <time precision> <right paren>   -> time_prec_type
+  | TIME <with or without time zone>                   -> time_tz_type
+  | TIME <left paren> <time precision> <right paren>
+    <with or without time zone>                        -> time_prec_tz_type
+  | TIMESTAMP                                          -> timestamp_type
+  | TIMESTAMP
+    <left paren> <timestamp precision> <right paren>   -> timestamp_prec_type
+  | TIMESTAMP <with or without time zone>              -> timestamp_tz_type
+  | TIMESTAMP
+    <left paren> <timestamp precision> <right paren>
+    <with or without time zone>                        -> timestamp_prec_tz_type
+
+<time precision> /* int */ ::=
+    <time fractional seconds precision>
+
+<time fractional seconds precision> /* int */ ::=
+    <unsigned integer>
+
+<with or without time zone> /* bool */ ::=
+    WITH TIME ZONE      -> yes
+  | WITHOUT TIME ZONE   -> no
+
+<timestamp precision> /* int */ ::=
+    <time fractional seconds precision>
+
+<time fractional seconds precision> /* int */ ::=
+    <unsigned integer>
diff --git a/tests/create-table.sql b/tests/create-table.sql
index 7013cc3..f779f26 100644
--- a/tests/create-table.sql
+++ b/tests/create-table.sql
@@ -66,3 +66,42 @@ CREATE TABLE "Foo" (baz CHARACTER VARYING(10));
 
 CREATE TABLE t1 (f1 CHARACTER VARYING(10), f2 FLOAT NOT NULL);
 -- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar DATE);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIME);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIME(3));
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIME WITHOUT TIME ZONE);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIME(3) WITHOUT TIME ZONE);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIME WITH TIME ZONE);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIME(3) WITH TIME ZONE);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIMESTAMP);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIMESTAMP(3));
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIMESTAMP WITHOUT TIME ZONE);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIMESTAMP(3) WITHOUT TIME ZONE);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIMESTAMP WITH TIME ZONE);
+-- msg: CREATE TABLE 1
+
+CREATE TABLE foo (bar TIMESTAMP(3) WITH TIME ZONE);
+-- msg: CREATE TABLE 1
diff --git a/tests/date.sql b/tests/date.sql
new file mode 100644
index 0000000..541157c
--- /dev/null
+++ b/tests/date.sql
@@ -0,0 +1,63 @@
+VALUES DATE '2022-06-30 21:47:32';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:32' is not valid
+
+VALUES DATE '2022-06-30 21:47:32+05:12';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:32+05:12' is not valid
+
+VALUES DATE '21:47:32';
+-- error 42601: syntax error: DATE '21:47:32' is not valid
+
+VALUES DATE '21:47:32+05:12';
+-- error 42601: syntax error: DATE '21:47:32+05:12' is not valid
+
+VALUES DATE '2022-06-30 21:47:32-11:30';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:32-11:30' is not valid
+
+VALUES DATE '2022-06-30 00:00:00';
+-- error 42601: syntax error: DATE '2022-06-30 00:00:00' is not valid
+
+VALUES DATE '2022-06-30 21:47:32.123';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:32.123' is not valid
+
+VALUES DATE '2022-06-30 21:47:32.456000+05:12';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:32.456000+05:12' is not valid
+
+VALUES DATE '2022-06-30T21:47:32';
+-- error 42601: syntax error: DATE '2022-06-30T21:47:32' is not valid
+
+VALUES DATE 'a2022-06-30 21:47:32';
+-- error 42601: syntax error: DATE 'a2022-06-30 21:47:32' is not valid
+
+VALUES DATE '2022-06-30 21:47:32a';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:32a' is not valid
+
+VALUES DATE '2022-06-30';
+-- COL1: 2022-06-30
+
+VALUES DATE '21:47:32';
+-- error 42601: syntax error: DATE '21:47:32' is not valid
+
+VALUES DATE 'FOO BAR';
+-- error 42601: syntax error: DATE 'FOO BAR' is not valid
+
+VALUES DATE '2022-06-30 21:47:75';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:75' is not valid
+
+VALUES DATE '10000-06-30T21:47:32';
+-- error 42601: syntax error: DATE '10000-06-30T21:47:32' is not valid
+
+VALUES DATE '-1-06-30T21:47:32';
+-- error 42601: syntax error: DATE '-1-06-30T21:47:32' is not valid
+
+VALUES DATE '2022-06-30 21:47:32+12:00';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:32+12:00' is not valid
+
+VALUES DATE '2022-06-30 21:47:32-12:00';
+-- error 42601: syntax error: DATE '2022-06-30 21:47:32-12:00' is not valid
+
+CREATE TABLE foo (f1 DATE);
+INSERT INTO foo (f1) VALUES (DATE '2022-06-30');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- msg: INSERT 1
+-- F1: 2022-06-30
diff --git a/tests/time.sql b/tests/time.sql
new file mode 100644
index 0000000..c7cf5b2
--- /dev/null
+++ b/tests/time.sql
@@ -0,0 +1,124 @@
+VALUES TIME '2022-06-30 21:47:32';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:32' is not valid
+
+VALUES TIME '2022-06-30 21:47:32+05:12';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:32+05:12' is not valid
+
+VALUES TIME '21:47:32';
+-- COL1: 21:47:32
+
+VALUES TIME 'a21:47:32';
+-- error 42601: syntax error: TIME 'a21:47:32' is not valid
+
+VALUES TIME '21:47:32T';
+-- error 42601: syntax error: TIME '21:47:32T' is not valid
+
+VALUES TIME '21:47:32+05:12';
+-- COL1: 21:47:32+0512
+
+VALUES TIME '21:47:32-11:30';
+-- COL1: 21:47:32-1130
+
+VALUES TIME '21:47:32.123+05:12';
+-- COL1: 21:47:32.123+0512
+
+VALUES TIME '2022-06-30 21:47:32-11:30';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:32-11:30' is not valid
+
+VALUES TIME '2022-06-30 00:00:00';
+-- error 42601: syntax error: TIME '2022-06-30 00:00:00' is not valid
+
+VALUES TIME '2022-06-30 21:47:32.123';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:32.123' is not valid
+
+VALUES TIME '2022-06-30 21:47:32.456000+05:12';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:32.456000+05:12' is not valid
+
+VALUES TIME '2022-06-30T21:47:32';
+-- error 42601: syntax error: TIME '2022-06-30T21:47:32' is not valid
+
+VALUES TIME 'a2022-06-30 21:47:32';
+-- error 42601: syntax error: TIME 'a2022-06-30 21:47:32' is not valid
+
+VALUES TIME '2022-06-30 21:47:32a';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:32a' is not valid
+
+VALUES TIME '2022-06-30';
+-- error 42601: syntax error: TIME '2022-06-30' is not valid
+
+VALUES TIME '21:47:32';
+-- COL1: 21:47:32
+
+VALUES TIME 'FOO BAR';
+-- error 42601: syntax error: TIME 'FOO BAR' is not valid
+
+VALUES TIME '2022-06-30 21:47:75';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:75' is not valid
+
+VALUES TIME '10000-06-30T21:47:32';
+-- error 42601: syntax error: TIME '10000-06-30T21:47:32' is not valid
+
+VALUES TIME '-1-06-30T21:47:32';
+-- error 42601: syntax error: TIME '-1-06-30T21:47:32' is not valid
+
+VALUES TIME '2022-06-30 21:47:32+12:00';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:32+12:00' is not valid
+
+VALUES TIME '2022-06-30 21:47:32-12:00';
+-- error 42601: syntax error: TIME '2022-06-30 21:47:32-12:00' is not valid
+
+CREATE TABLE foo (f1 TIME WITHOUT TIME ZONE);
+INSERT INTO foo (f1) VALUES (TIME '21:47:32');
+INSERT INTO foo (f1) VALUES (TIME '01:47:32+05:12');
+INSERT INTO foo (f1) VALUES (TIME '21:47:32.123');
+INSERT INTO foo (f1) VALUES (TIME '01:47:32.123456+05:12');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIME(0) WITHOUT TIME ZONE but got TIME(0) WITH TIME ZONE
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIME(0) WITHOUT TIME ZONE but got TIME(6) WITH TIME ZONE
+-- F1: 21:47:32
+-- F1: 21:47:32
+
+CREATE TABLE foo (f1 TIME WITH TIME ZONE);
+INSERT INTO foo (f1) VALUES (TIME '21:47:32');
+INSERT INTO foo (f1) VALUES (TIME '01:47:32+05:12');
+INSERT INTO foo (f1) VALUES (TIME '21:47:32.123');
+INSERT INTO foo (f1) VALUES (TIME '01:47:32.123456+05:12');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- error 42804: data type mismatch for column F1: expected TIME(0) WITH TIME ZONE but got TIME(0) WITHOUT TIME ZONE
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIME(0) WITH TIME ZONE but got TIME(3) WITHOUT TIME ZONE
+-- msg: INSERT 1
+-- F1: 01:47:32+0512
+-- F1: 01:47:32+0512
+
+CREATE TABLE foo (f1 TIME (3) WITHOUT TIME ZONE);
+INSERT INTO foo (f1) VALUES (TIME '21:47:32');
+INSERT INTO foo (f1) VALUES (TIME '01:47:32+05:12');
+INSERT INTO foo (f1) VALUES (TIME '21:47:32.123');
+INSERT INTO foo (f1) VALUES (TIME '01:47:32.123456+05:12');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIME(3) WITHOUT TIME ZONE but got TIME(0) WITH TIME ZONE
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIME(3) WITHOUT TIME ZONE but got TIME(6) WITH TIME ZONE
+-- F1: 21:47:32.000
+-- F1: 21:47:32.123
+
+CREATE TABLE foo (f1 TIME (3) WITH TIME ZONE);
+INSERT INTO foo (f1) VALUES (TIME '21:47:32');
+INSERT INTO foo (f1) VALUES (TIME '01:47:32+05:12');
+INSERT INTO foo (f1) VALUES (TIME '21:47:32.123');
+INSERT INTO foo (f1) VALUES (TIME '01:47:32.123456+05:12');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- error 42804: data type mismatch for column F1: expected TIME(3) WITH TIME ZONE but got TIME(0) WITHOUT TIME ZONE
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIME(3) WITH TIME ZONE but got TIME(3) WITHOUT TIME ZONE
+-- msg: INSERT 1
+-- F1: 01:47:32.000+0512
+-- F1: 01:47:32.123456+0512
diff --git a/tests/timestamp.sql b/tests/timestamp.sql
new file mode 100644
index 0000000..467e864
--- /dev/null
+++ b/tests/timestamp.sql
@@ -0,0 +1,111 @@
+VALUES TIMESTAMP '2022-06-30 21:47:32';
+-- COL1: 2022-06-30T21:47:32
+
+VALUES TIMESTAMP '2022-06-30 21:47:32+05:12';
+-- COL1: 2022-06-30T21:47:32+0512
+
+VALUES TIMESTAMP '21:47:32';
+-- error 42601: syntax error: TIMESTAMP '21:47:32' is not valid
+
+VALUES TIMESTAMP '21:47:32+05:12';
+-- error 42601: syntax error: TIMESTAMP '21:47:32+05:12' is not valid
+
+VALUES TIMESTAMP '2022-06-30 21:47:32-11:30';
+-- COL1: 2022-06-30T21:47:32-1130
+
+VALUES TIMESTAMP '2022-06-30 00:00:00';
+-- COL1: 2022-06-30T00:00:00
+
+VALUES TIMESTAMP '2022-06-30 21:47:32.123';
+-- COL1: 2022-06-30T21:47:32.123
+
+VALUES TIMESTAMP '2022-06-30 21:47:32.456000+05:12';
+-- COL1: 2022-06-30T21:47:32.456000+0512
+
+VALUES TIMESTAMP '2022-06-30T21:47:32';
+-- error 42601: syntax error: TIMESTAMP '2022-06-30T21:47:32' is not valid
+
+VALUES TIMESTAMP 'a2022-06-30 21:47:32';
+-- error 42601: syntax error: TIMESTAMP 'a2022-06-30 21:47:32' is not valid
+
+VALUES TIMESTAMP '2022-06-30 21:47:32a';
+-- error 42601: syntax error: TIMESTAMP '2022-06-30 21:47:32a' is not valid
+
+VALUES TIMESTAMP '2022-06-30';
+-- error 42601: syntax error: TIMESTAMP '2022-06-30' is not valid
+
+VALUES TIMESTAMP '21:47:32';
+-- error 42601: syntax error: TIMESTAMP '21:47:32' is not valid
+
+VALUES TIMESTAMP 'FOO BAR';
+-- error 42601: syntax error: TIMESTAMP 'FOO BAR' is not valid
+
+VALUES TIMESTAMP '2022-06-30 21:47:75';
+-- COL1: 2022-06-30T21:48:15
+
+VALUES TIMESTAMP '10000-06-30T21:47:32';
+-- error 42601: syntax error: TIMESTAMP '10000-06-30T21:47:32' is not valid
+
+VALUES TIMESTAMP '-1-06-30T21:47:32';
+-- error 42601: syntax error: TIMESTAMP '-1-06-30T21:47:32' is not valid
+
+VALUES TIMESTAMP '2022-06-30 21:47:32+12:00';
+-- error 42601: syntax error: TIMESTAMP '2022-06-30 21:47:32+12:00' is not valid
+
+VALUES TIMESTAMP '2022-06-30 21:47:32-12:00';
+-- error 42601: syntax error: TIMESTAMP '2022-06-30 21:47:32-12:00' is not valid
+
+CREATE TABLE foo (f1 TIMESTAMP WITHOUT TIME ZONE);
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 21:47:32');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 01:47:32+05:12');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 21:47:32.123');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 01:47:32.123456+05:12');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(6) WITHOUT TIME ZONE but got TIMESTAMP(0) WITH TIME ZONE
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(6) WITHOUT TIME ZONE but got TIMESTAMP(6) WITH TIME ZONE
+-- F1: 2022-06-30T21:47:32.000000
+-- F1: 2022-06-30T21:47:32.123000
+
+CREATE TABLE foo (f1 TIMESTAMP WITH TIME ZONE);
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 21:47:32');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 01:47:32+05:12');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 21:47:32.123');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 01:47:32.123456+05:12');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(6) WITH TIME ZONE but got TIMESTAMP(0) WITHOUT TIME ZONE
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(6) WITH TIME ZONE but got TIMESTAMP(3) WITHOUT TIME ZONE
+-- msg: INSERT 1
+-- F1: 2022-06-30T01:47:32.000000+0512
+-- F1: 2022-06-30T01:47:32.123456+0512
+
+CREATE TABLE foo (f1 TIMESTAMP (3) WITHOUT TIME ZONE);
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 21:47:32');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 01:47:32+05:12');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 21:47:32.123');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 01:47:32.123456+05:12');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(3) WITHOUT TIME ZONE but got TIMESTAMP(0) WITH TIME ZONE
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(3) WITHOUT TIME ZONE but got TIMESTAMP(6) WITH TIME ZONE
+-- F1: 2022-06-30T21:47:32.000
+-- F1: 2022-06-30T21:47:32.123
+
+CREATE TABLE foo (f1 TIMESTAMP (3) WITH TIME ZONE);
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 21:47:32');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 01:47:32+05:12');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 21:47:32.123');
+INSERT INTO foo (f1) VALUES (TIMESTAMP '2022-06-30 01:47:32.123456+05:12');
+SELECT * FROM foo;
+-- msg: CREATE TABLE 1
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(3) WITH TIME ZONE but got TIMESTAMP(0) WITHOUT TIME ZONE
+-- msg: INSERT 1
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(3) WITH TIME ZONE but got TIMESTAMP(3) WITHOUT TIME ZONE
+-- error 42804: data type mismatch for column F1: expected TIMESTAMP(3) WITH TIME ZONE but got TIMESTAMP(6) WITH TIME ZONE
+-- F1: 2022-06-30T01:47:32.000+0512
diff --git a/vsql/ast.v b/vsql/ast.v
index 78ccb0c..aa8df03 100644
--- a/vsql/ast.v
+++ b/vsql/ast.v
@@ -81,7 +81,7 @@ fn (e Expr) pstr(params map[string]Value) string {
 			e.pstr(params)
 		}
 		Value {
-			if e.typ.uses_string() {
+			if e.typ.uses_string() || e.typ.uses_time() {
 				'\'$e.str()\''
 			} else {
 				e.str()
@@ -336,7 +336,7 @@ fn (e Parameter) str() string {
 fn (e Parameter) pstr(params map[string]Value) string {
 	p := params[e.name]
 
-	if p.typ.uses_string() {
+	if p.typ.uses_string() || p.typ.uses_time() {
 		return '\'$p.str()\''
 	}
 
diff --git a/vsql/bytes.v b/vsql/bytes.v
index b153466..9d2e263 100644
--- a/vsql/bytes.v
+++ b/vsql/bytes.v
@@ -195,12 +195,28 @@ fn bytes_to_int(bytes []u8) int {
 	}
 }
 
+fn bytes_to_i16(bytes []u8) i16 {
+	return unsafe {
+		Bytes2{
+			bytes: [bytes[0], bytes[1]]!
+		}.i16_value
+	}
+}
+
 fn i64_to_bytes(n i64) []u8 {
 	return Bytes8{
 		i64_value: n
 	}.bytes().reverse()
 }
 
+fn bytes_to_i64(bytes []u8) i64 {
+	return unsafe {
+		Bytes8{
+			bytes: [bytes[7], bytes[6], bytes[5], bytes[4], bytes[3], bytes[2], bytes[1], bytes[0]]!
+		}.i64_value
+	}
+}
+
 fn (mut b Bytes) write_string1_list(ss []string) {
 	b.write_byte(u8(ss.len))
 	for s in ss {
diff --git a/vsql/cast.v b/vsql/cast.v
index 2f5e4a4..f4b7f94 100644
--- a/vsql/cast.v
+++ b/vsql/cast.v
@@ -14,10 +14,7 @@ fn cast(msg string, v Value, to Type) ?Value {
 		.is_boolean {
 			match to.typ {
 				.is_boolean {
-					return Value{
-						typ: to
-						f64_value: v.f64_value
-					}
+					return v
 				}
 				else {}
 			}
@@ -25,10 +22,7 @@ fn cast(msg string, v Value, to Type) ?Value {
 		.is_bigint {
 			match to.typ {
 				.is_bigint, .is_double_precision, .is_integer, .is_real, .is_smallint {
-					return Value{
-						typ: to
-						f64_value: v.f64_value
-					}
+					return v
 				}
 				else {}
 			}
@@ -36,10 +30,7 @@ fn cast(msg string, v Value, to Type) ?Value {
 		.is_character {
 			match to.typ {
 				.is_character, .is_varchar {
-					return Value{
-						typ: to
-						string_value: v.string_value
-					}
+					return v
 				}
 				else {}
 			}
@@ -47,10 +38,7 @@ fn cast(msg string, v Value, to Type) ?Value {
 		.is_double_precision {
 			match to.typ {
 				.is_bigint, .is_double_precision, .is_integer, .is_real, .is_smallint {
-					return Value{
-						typ: to
-						f64_value: v.f64_value
-					}
+					return v
 				}
 				else {}
 			}
@@ -58,10 +46,7 @@ fn cast(msg string, v Value, to Type) ?Value {
 		.is_integer {
 			match to.typ {
 				.is_bigint, .is_double_precision, .is_integer, .is_real, .is_smallint {
-					return Value{
-						typ: to
-						f64_value: v.f64_value
-					}
+					return v
 				}
 				else {}
 			}
@@ -69,10 +54,7 @@ fn cast(msg string, v Value, to Type) ?Value {
 		.is_real {
 			match to.typ {
 				.is_bigint, .is_double_precision, .is_integer, .is_real, .is_smallint {
-					return Value{
-						typ: to
-						f64_value: v.f64_value
-					}
+					return v
 				}
 				else {}
 			}
@@ -80,10 +62,7 @@ fn cast(msg string, v Value, to Type) ?Value {
 		.is_smallint {
 			match to.typ {
 				.is_bigint, .is_double_precision, .is_integer, .is_real, .is_smallint {
-					return Value{
-						typ: to
-						f64_value: v.f64_value
-					}
+					return v
 				}
 				else {}
 			}
@@ -91,15 +70,60 @@ fn cast(msg string, v Value, to Type) ?Value {
 		.is_varchar {
 			match to.typ {
 				.is_varchar, .is_character {
-					return Value{
-						typ: to
-						string_value: v.string_value
+					return v
+				}
+				else {}
+			}
+		}
+		.is_date {
+			match to.typ {
+				.is_date {
+					return v
+				}
+				else {}
+			}
+		}
+		.is_timestamp_with_time_zone {
+			match to.typ {
+				.is_timestamp_with_time_zone {
+					// We cannot lower the precision of the timestamp without an
+					// explicit CAST.
+					if to.size >= v.typ.size {
+						return v
 					}
 				}
 				else {}
 			}
 		}
+		.is_timestamp_without_time_zone {
+			match to.typ {
+				.is_timestamp_without_time_zone {
+					// We cannot lower the precision of the timestamp without an
+					// explicit CAST.
+					if to.size >= v.typ.size {
+						return v
+					}
+				}
+				else {}
+			}
+		}
+		.is_time_with_time_zone {
+			match to.typ {
+				.is_time_with_time_zone {
+					return v
+				}
+				else {}
+			}
+		}
+		.is_time_without_time_zone {
+			match to.typ {
+				.is_time_without_time_zone {
+					return v
+				}
+				else {}
+			}
+		}
 	}
 
-	return sqlstate_42804(msg, to.typ.str(), v.typ.str())
+	return sqlstate_42804(msg, to.str(), v.typ.str())
 }
diff --git a/vsql/grammar.v b/vsql/grammar.v
index f1d2b60..7246a4d 100644
--- a/vsql/grammar.v
+++ b/vsql/grammar.v
@@ -33,6 +33,7 @@ type EarleyValue = BetweenExpr
 	| []SortSpecification
 	| []TableElement
 	| bool
+	| int
 	| map[string]Expr
 	| string
 
@@ -408,6 +409,60 @@ fn get_grammar() map[string]EarleyRule {
 	mut rule_data_type_ := &EarleyRule{
 		name: '<data type>'
 	}
+	mut rule_date_literal_1_ := &EarleyRule{
+		name: '<date literal: 1>'
+	}
+	mut rule_date_literal_ := &EarleyRule{
+		name: '<date literal>'
+	}
+	mut rule_date_string_ := &EarleyRule{
+		name: '<date string>'
+	}
+	mut rule_datetime_factor_ := &EarleyRule{
+		name: '<datetime factor>'
+	}
+	mut rule_datetime_literal_ := &EarleyRule{
+		name: '<datetime literal>'
+	}
+	mut rule_datetime_primary_ := &EarleyRule{
+		name: '<datetime primary>'
+	}
+	mut rule_datetime_term_ := &EarleyRule{
+		name: '<datetime term>'
+	}
+	mut rule_datetime_type_1_ := &EarleyRule{
+		name: '<datetime type: 1>'
+	}
+	mut rule_datetime_type_2_ := &EarleyRule{
+		name: '<datetime type: 2>'
+	}
+	mut rule_datetime_type_3_ := &EarleyRule{
+		name: '<datetime type: 3>'
+	}
+	mut rule_datetime_type_4_ := &EarleyRule{
+		name: '<datetime type: 4>'
+	}
+	mut rule_datetime_type_5_ := &EarleyRule{
+		name: '<datetime type: 5>'
+	}
+	mut rule_datetime_type_6_ := &EarleyRule{
+		name: '<datetime type: 6>'
+	}
+	mut rule_datetime_type_7_ := &EarleyRule{
+		name: '<datetime type: 7>'
+	}
+	mut rule_datetime_type_8_ := &EarleyRule{
+		name: '<datetime type: 8>'
+	}
+	mut rule_datetime_type_9_ := &EarleyRule{
+		name: '<datetime type: 9>'
+	}
+	mut rule_datetime_type_ := &EarleyRule{
+		name: '<datetime type>'
+	}
+	mut rule_datetime_value_expression_ := &EarleyRule{
+		name: '<datetime value expression>'
+	}
 	mut rule_delete_statement_searched_1_ := &EarleyRule{
 		name: '<delete statement: searched: 1>'
 	}
@@ -444,6 +499,9 @@ fn get_grammar() map[string]EarleyRule {
 	mut rule_equals_operator_ := &EarleyRule{
 		name: '<equals operator>'
 	}
+	mut rule_exact_numeric_literal_1_ := &EarleyRule{
+		name: '<exact numeric literal: 1>'
+	}
 	mut rule_exact_numeric_literal_2_ := &EarleyRule{
 		name: '<exact numeric literal: 2>'
 	}
@@ -1215,6 +1273,33 @@ fn get_grammar() map[string]EarleyRule {
 	mut rule_term_ := &EarleyRule{
 		name: '<term>'
 	}
+	mut rule_time_fractional_seconds_precision_ := &EarleyRule{
+		name: '<time fractional seconds precision>'
+	}
+	mut rule_time_literal_1_ := &EarleyRule{
+		name: '<time literal: 1>'
+	}
+	mut rule_time_literal_ := &EarleyRule{
+		name: '<time literal>'
+	}
+	mut rule_time_precision_ := &EarleyRule{
+		name: '<time precision>'
+	}
+	mut rule_time_string_ := &EarleyRule{
+		name: '<time string>'
+	}
+	mut rule_timestamp_literal_1_ := &EarleyRule{
+		name: '<timestamp literal: 1>'
+	}
+	mut rule_timestamp_literal_ := &EarleyRule{
+		name: '<timestamp literal>'
+	}
+	mut rule_timestamp_precision_ := &EarleyRule{
+		name: '<timestamp precision>'
+	}
+	mut rule_timestamp_string_ := &EarleyRule{
+		name: '<timestamp string>'
+	}
 	mut rule_trigonometric_function_name_ := &EarleyRule{
 		name: '<trigonometric function name>'
 	}
@@ -1281,6 +1366,15 @@ fn get_grammar() map[string]EarleyRule {
 	mut rule_where_clause_ := &EarleyRule{
 		name: '<where clause>'
 	}
+	mut rule_with_or_without_time_zone_1_ := &EarleyRule{
+		name: '<with or without time zone: 1>'
+	}
+	mut rule_with_or_without_time_zone_2_ := &EarleyRule{
+		name: '<with or without time zone: 2>'
+	}
+	mut rule_with_or_without_time_zone_ := &EarleyRule{
+		name: '<with or without time zone>'
+	}
 	mut rule__identifier := &EarleyRule{
 		name: '^identifier'
 	}
@@ -1362,6 +1456,9 @@ fn get_grammar() map[string]EarleyRule {
 	mut rule_create := &EarleyRule{
 		name: 'CREATE'
 	}
+	mut rule_date := &EarleyRule{
+		name: 'DATE'
+	}
 	mut rule_delete := &EarleyRule{
 		name: 'DELETE'
 	}
@@ -1542,6 +1639,12 @@ fn get_grammar() map[string]EarleyRule {
 	mut rule_tanh := &EarleyRule{
 		name: 'TANH'
 	}
+	mut rule_time := &EarleyRule{
+		name: 'TIME'
+	}
+	mut rule_timestamp := &EarleyRule{
+		name: 'TIMESTAMP'
+	}
 	mut rule_to := &EarleyRule{
 		name: 'TO'
 	}
@@ -1572,9 +1675,18 @@ fn get_grammar() map[string]EarleyRule {
 	mut rule_where := &EarleyRule{
 		name: 'WHERE'
 	}
+	mut rule_with := &EarleyRule{
+		name: 'WITH'
+	}
+	mut rule_without := &EarleyRule{
+		name: 'WITHOUT'
+	}
 	mut rule_work := &EarleyRule{
 		name: 'WORK'
 	}
+	mut rule_zone := &EarleyRule{
+		name: 'ZONE'
+	}
 
 	rule_absolute_value_expression_1_.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
@@ -2470,6 +2582,11 @@ fn get_grammar() map[string]EarleyRule {
 			rule: rule_string_value_expression_
 		},
 	]}
+	rule_common_value_expression_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_value_expression_
+		},
+	]}
 
 	rule_comp_op_.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
@@ -2834,6 +2951,215 @@ fn get_grammar() map[string]EarleyRule {
 		},
 	]}
 
+	rule_date_literal_1_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_date
+		},
+		&EarleyRuleOrString{
+			rule: rule_date_string_
+		},
+	]}
+
+	rule_date_literal_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_date_literal_1_
+		},
+	]}
+
+	rule_date_string_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule__string
+		},
+	]}
+
+	rule_datetime_factor_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_primary_
+		},
+	]}
+
+	rule_datetime_literal_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_date_literal_
+		},
+	]}
+	rule_datetime_literal_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time_literal_
+		},
+	]}
+	rule_datetime_literal_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_timestamp_literal_
+		},
+	]}
+
+	rule_datetime_primary_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_value_expression_primary_
+		},
+	]}
+
+	rule_datetime_term_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_factor_
+		},
+	]}
+
+	rule_datetime_type_1_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_date
+		},
+	]}
+
+	rule_datetime_type_2_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time
+		},
+	]}
+
+	rule_datetime_type_3_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time
+		},
+		&EarleyRuleOrString{
+			rule: rule_left_paren_
+		},
+		&EarleyRuleOrString{
+			rule: rule_time_precision_
+		},
+		&EarleyRuleOrString{
+			rule: rule_right_paren_
+		},
+	]}
+
+	rule_datetime_type_4_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time
+		},
+		&EarleyRuleOrString{
+			rule: rule_with_or_without_time_zone_
+		},
+	]}
+
+	rule_datetime_type_5_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time
+		},
+		&EarleyRuleOrString{
+			rule: rule_left_paren_
+		},
+		&EarleyRuleOrString{
+			rule: rule_time_precision_
+		},
+		&EarleyRuleOrString{
+			rule: rule_right_paren_
+		},
+		&EarleyRuleOrString{
+			rule: rule_with_or_without_time_zone_
+		},
+	]}
+
+	rule_datetime_type_6_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_timestamp
+		},
+	]}
+
+	rule_datetime_type_7_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_timestamp
+		},
+		&EarleyRuleOrString{
+			rule: rule_left_paren_
+		},
+		&EarleyRuleOrString{
+			rule: rule_timestamp_precision_
+		},
+		&EarleyRuleOrString{
+			rule: rule_right_paren_
+		},
+	]}
+
+	rule_datetime_type_8_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_timestamp
+		},
+		&EarleyRuleOrString{
+			rule: rule_with_or_without_time_zone_
+		},
+	]}
+
+	rule_datetime_type_9_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_timestamp
+		},
+		&EarleyRuleOrString{
+			rule: rule_left_paren_
+		},
+		&EarleyRuleOrString{
+			rule: rule_timestamp_precision_
+		},
+		&EarleyRuleOrString{
+			rule: rule_right_paren_
+		},
+		&EarleyRuleOrString{
+			rule: rule_with_or_without_time_zone_
+		},
+	]}
+
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_1_
+		},
+	]}
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_2_
+		},
+	]}
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_3_
+		},
+	]}
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_4_
+		},
+	]}
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_5_
+		},
+	]}
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_6_
+		},
+	]}
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_7_
+		},
+	]}
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_8_
+		},
+	]}
+	rule_datetime_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_9_
+		},
+	]}
+
+	rule_datetime_value_expression_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_term_
+		},
+	]}
+
 	rule_delete_statement_searched_1_.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
 			rule: rule_delete
@@ -2944,6 +3270,12 @@ fn get_grammar() map[string]EarleyRule {
 		},
 	]}
 
+	rule_exact_numeric_literal_1_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_unsigned_integer_
+		},
+	]}
+
 	rule_exact_numeric_literal_2_.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
 			rule: rule_unsigned_integer_
@@ -2976,7 +3308,7 @@ fn get_grammar() map[string]EarleyRule {
 
 	rule_exact_numeric_literal_.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
-			rule: rule_unsigned_integer_
+			rule: rule_exact_numeric_literal_1_
 		},
 	]}
 	rule_exact_numeric_literal_.productions << &EarleyProduction{[
@@ -3252,6 +3584,11 @@ fn get_grammar() map[string]EarleyRule {
 			rule: rule_character_string_literal_
 		},
 	]}
+	rule_general_literal_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_literal_
+		},
+	]}
 	rule_general_literal_.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
 			rule: rule_boolean_literal_
@@ -4121,6 +4458,11 @@ fn get_grammar() map[string]EarleyRule {
 			rule: rule_boolean_type_
 		},
 	]}
+	rule_predefined_type_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_datetime_type_
+		},
+	]}
 
 	rule_predicate_.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
@@ -5403,6 +5745,71 @@ fn get_grammar() map[string]EarleyRule {
 		},
 	]}
 
+	rule_time_fractional_seconds_precision_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_unsigned_integer_
+		},
+	]}
+	rule_time_fractional_seconds_precision_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_unsigned_integer_
+		},
+	]}
+
+	rule_time_literal_1_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time
+		},
+		&EarleyRuleOrString{
+			rule: rule_time_string_
+		},
+	]}
+
+	rule_time_literal_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time_literal_1_
+		},
+	]}
+
+	rule_time_precision_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time_fractional_seconds_precision_
+		},
+	]}
+
+	rule_time_string_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule__string
+		},
+	]}
+
+	rule_timestamp_literal_1_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_timestamp
+		},
+		&EarleyRuleOrString{
+			rule: rule_timestamp_string_
+		},
+	]}
+
+	rule_timestamp_literal_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_timestamp_literal_1_
+		},
+	]}
+
+	rule_timestamp_precision_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_time_fractional_seconds_precision_
+		},
+	]}
+
+	rule_timestamp_string_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule__string
+		},
+	]}
+
 	rule_trigonometric_function_name_.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
 			rule: rule_sin
@@ -5653,6 +6060,41 @@ fn get_grammar() map[string]EarleyRule {
 		},
 	]}
 
+	rule_with_or_without_time_zone_1_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_with
+		},
+		&EarleyRuleOrString{
+			rule: rule_time
+		},
+		&EarleyRuleOrString{
+			rule: rule_zone
+		},
+	]}
+
+	rule_with_or_without_time_zone_2_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_without
+		},
+		&EarleyRuleOrString{
+			rule: rule_time
+		},
+		&EarleyRuleOrString{
+			rule: rule_zone
+		},
+	]}
+
+	rule_with_or_without_time_zone_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_with_or_without_time_zone_1_
+		},
+	]}
+	rule_with_or_without_time_zone_.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			rule: rule_with_or_without_time_zone_2_
+		},
+	]}
+
 	rule__identifier.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
 			str: '^identifier'
@@ -5842,6 +6284,13 @@ fn get_grammar() map[string]EarleyRule {
 		},
 	]}
 
+	rule_date.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			str: 'DATE'
+			rule: 0
+		},
+	]}
+
 	rule_delete.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
 			str: 'DELETE'
@@ -6262,6 +6711,20 @@ fn get_grammar() map[string]EarleyRule {
 		},
 	]}
 
+	rule_time.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			str: 'TIME'
+			rule: 0
+		},
+	]}
+
+	rule_timestamp.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			str: 'TIMESTAMP'
+			rule: 0
+		},
+	]}
+
 	rule_to.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
 			str: 'TO'
@@ -6332,6 +6795,20 @@ fn get_grammar() map[string]EarleyRule {
 		},
 	]}
 
+	rule_with.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			str: 'WITH'
+			rule: 0
+		},
+	]}
+
+	rule_without.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			str: 'WITHOUT'
+			rule: 0
+		},
+	]}
+
 	rule_work.productions << &EarleyProduction{[
 		&EarleyRuleOrString{
 			str: 'WORK'
@@ -6339,6 +6816,13 @@ fn get_grammar() map[string]EarleyRule {
 		},
 	]}
 
+	rule_zone.productions << &EarleyProduction{[
+		&EarleyRuleOrString{
+			str: 'ZONE'
+			rule: 0
+		},
+	]}
+
 	rules['<absolute value expression: 1>'] = rule_absolute_value_expression_1_
 	rules['<absolute value expression>'] = rule_absolute_value_expression_
 	rules['<actual identifier>'] = rule_actual_identifier_
@@ -6462,6 +6946,24 @@ fn get_grammar() map[string]EarleyRule {
 	rules['<cursor specification>'] = rule_cursor_specification_
 	rules['<data type or domain name>'] = rule_data_type_or_domain_name_
 	rules['<data type>'] = rule_data_type_
+	rules['<date literal: 1>'] = rule_date_literal_1_
+	rules['<date literal>'] = rule_date_literal_
+	rules['<date string>'] = rule_date_string_
+	rules['<datetime factor>'] = rule_datetime_factor_
+	rules['<datetime literal>'] = rule_datetime_literal_
+	rules['<datetime primary>'] = rule_datetime_primary_
+	rules['<datetime term>'] = rule_datetime_term_
+	rules['<datetime type: 1>'] = rule_datetime_type_1_
+	rules['<datetime type: 2>'] = rule_datetime_type_2_
+	rules['<datetime type: 3>'] = rule_datetime_type_3_
+	rules['<datetime type: 4>'] = rule_datetime_type_4_
+	rules['<datetime type: 5>'] = rule_datetime_type_5_
+	rules['<datetime type: 6>'] = rule_datetime_type_6_
+	rules['<datetime type: 7>'] = rule_datetime_type_7_
+	rules['<datetime type: 8>'] = rule_datetime_type_8_
+	rules['<datetime type: 9>'] = rule_datetime_type_9_
+	rules['<datetime type>'] = rule_datetime_type_
+	rules['<datetime value expression>'] = rule_datetime_value_expression_
 	rules['<delete statement: searched: 1>'] = rule_delete_statement_searched_1_
 	rules['<delete statement: searched: 2>'] = rule_delete_statement_searched_2_
 	rules['<delete statement: searched>'] = rule_delete_statement_searched_
@@ -6474,6 +6976,7 @@ fn get_grammar() map[string]EarleyRule {
 	rules['<drop table statement>'] = rule_drop_table_statement_
 	rules['<dynamic select statement>'] = rule_dynamic_select_statement_
 	rules['<equals operator>'] = rule_equals_operator_
+	rules['<exact numeric literal: 1>'] = rule_exact_numeric_literal_1_
 	rules['<exact numeric literal: 2>'] = rule_exact_numeric_literal_2_
 	rules['<exact numeric literal: 3>'] = rule_exact_numeric_literal_3_
 	rules['<exact numeric literal: 4>'] = rule_exact_numeric_literal_4_
@@ -6731,6 +7234,15 @@ fn get_grammar() map[string]EarleyRule {
 	rules['<term: 2>'] = rule_term_2_
 	rules['<term: 3>'] = rule_term_3_
 	rules['<term>'] = rule_term_
+	rules['<time fractional seconds precision>'] = rule_time_fractional_seconds_precision_
+	rules['<time literal: 1>'] = rule_time_literal_1_
+	rules['<time literal>'] = rule_time_literal_
+	rules['<time precision>'] = rule_time_precision_
+	rules['<time string>'] = rule_time_string_
+	rules['<timestamp literal: 1>'] = rule_timestamp_literal_1_
+	rules['<timestamp literal>'] = rule_timestamp_literal_
+	rules['<timestamp precision>'] = rule_timestamp_precision_
+	rules['<timestamp string>'] = rule_timestamp_string_
 	rules['<trigonometric function name>'] = rule_trigonometric_function_name_
 	rules['<trigonometric function: 1>'] = rule_trigonometric_function_1_
 	rules['<trigonometric function>'] = rule_trigonometric_function_
@@ -6753,6 +7265,9 @@ fn get_grammar() map[string]EarleyRule {
 	rules['<value expression>'] = rule_value_expression_
 	rules['<where clause: 1>'] = rule_where_clause_1_
 	rules['<where clause>'] = rule_where_clause_
+	rules['<with or without time zone: 1>'] = rule_with_or_without_time_zone_1_
+	rules['<with or without time zone: 2>'] = rule_with_or_without_time_zone_2_
+	rules['<with or without time zone>'] = rule_with_or_without_time_zone_
 	rules['^identifier'] = rule__identifier
 	rules['^integer'] = rule__integer
 	rules['^string'] = rule__string
@@ -6780,6 +7295,7 @@ fn get_grammar() map[string]EarleyRule {
 	rules['COSH'] = rule_cosh
 	rules['COUNT'] = rule_count
 	rules['CREATE'] = rule_create
+	rules['DATE'] = rule_date
 	rules['DELETE'] = rule_delete
 	rules['DESC'] = rule_desc
 	rules['DOUBLE'] = rule_double
@@ -6840,6 +7356,8 @@ fn get_grammar() map[string]EarleyRule {
 	rules['TABLE'] = rule_table
 	rules['TAN'] = rule_tan
 	rules['TANH'] = rule_tanh
+	rules['TIME'] = rule_time
+	rules['TIMESTAMP'] = rule_timestamp
 	rules['TO'] = rule_to
 	rules['TRANSACTION'] = rule_transaction
 	rules['TRUE'] = rule_true
@@ -6850,7 +7368,10 @@ fn get_grammar() map[string]EarleyRule {
 	rules['VARCHAR'] = rule_varchar
 	rules['VARYING'] = rule_varying
 	rules['WHERE'] = rule_where
+	rules['WITH'] = rule_with
+	rules['WITHOUT'] = rule_without
 	rules['WORK'] = rule_work
+	rules['ZONE'] = rule_zone
 
 	return rules
 }
@@ -6859,9 +7380,7 @@ fn parse_ast(node &EarleyNode) ?[]EarleyValue {
 	if node.children.len == 0 {
 		match node.value.name {
 			'^integer' {
-				return [
-					EarleyValue(new_integer_value(node.value.end_column.value.int())),
-				]
+				return [EarleyValue(node.value.end_column.value.int())]
 			}
 			'^identifier' {
 				return [EarleyValue(new_identifier(node.value.end_column.value))]
@@ -6908,7 +7427,7 @@ fn parse_ast_name(children []EarleyValue, name string) ?[]EarleyValue {
 			return [EarleyValue(parse_float()?)]
 		}
 		'<approximate numeric type: 2>' {
-			return [EarleyValue(parse_float_n(children[2] as Value)?)]
+			return [EarleyValue(parse_float_n(children[2] as int)?)]
 		}
 		'<approximate numeric type: 3>' {
 			return [EarleyValue(parse_real()?)]
@@ -6996,22 +7515,22 @@ fn parse_ast_name(children []EarleyValue, name string) ?[]EarleyValue {
 			return [EarleyValue(parse_character()?)]
 		}
 		'<character string type: 2>' {
-			return [EarleyValue(parse_character_n(children[2] as Value)?)]
+			return [EarleyValue(parse_character_n(children[2] as int)?)]
 		}
 		'<character string type: 3>' {
 			return [EarleyValue(parse_character()?)]
 		}
 		'<character string type: 4>' {
-			return [EarleyValue(parse_character_n(children[2] as Value)?)]
+			return [EarleyValue(parse_character_n(children[2] as int)?)]
 		}
 		'<character string type: 5>' {
-			return [EarleyValue(parse_varchar(children[3] as Value)?)]
+			return [EarleyValue(parse_varchar(children[3] as int)?)]
 		}
 		'<character string type: 6>' {
-			return [EarleyValue(parse_varchar(children[3] as Value)?)]
+			return [EarleyValue(parse_varchar(children[3] as int)?)]
 		}
 		'<character string type: 7>' {
-			return [EarleyValue(parse_varchar(children[2] as Value)?)]
+			return [EarleyValue(parse_varchar(children[2] as int)?)]
 		}
 		'<column constraint: 1>' {
 			return [EarleyValue(parse_yes()?)]
@@ -7113,6 +7632,40 @@ fn parse_ast_name(children []EarleyValue, name string) ?[]EarleyValue {
 				EarleyValue(parse_cursor_specification(children[0] as QueryExpression)?),
 			]
 		}
+		'<date literal: 1>' {
+			return [EarleyValue(parse_date_literal(children[1] as Value)?)]
+		}
+		'<datetime type: 1>' {
+			return [EarleyValue(parse_date_type()?)]
+		}
+		'<datetime type: 2>' {
+			return [EarleyValue(parse_time_type()?)]
+		}
+		'<datetime type: 3>' {
+			return [EarleyValue(parse_time_prec_type(children[2] as int)?)]
+		}
+		'<datetime type: 4>' {
+			return [EarleyValue(parse_time_tz_type(children[1] as bool)?)]
+		}
+		'<datetime type: 5>' {
+			return [
+				EarleyValue(parse_time_prec_tz_type(children[2] as int, children[4] as bool)?),
+			]
+		}
+		'<datetime type: 6>' {
+			return [EarleyValue(parse_timestamp_type()?)]
+		}
+		'<datetime type: 7>' {
+			return [EarleyValue(parse_timestamp_prec_type(children[2] as int)?)]
+		}
+		'<datetime type: 8>' {
+			return [EarleyValue(parse_timestamp_tz_type(children[1] as bool)?)]
+		}
+		'<datetime type: 9>' {
+			return [
+				EarleyValue(parse_timestamp_prec_tz_type(children[2] as int, children[4] as bool)?),
+			]
+		}
 		'<delete statement: searched: 1>' {
 			return [EarleyValue(parse_delete_statement(children[2] as Identifier)?)]
 		}
@@ -7134,16 +7687,19 @@ fn parse_ast_name(children []EarleyValue, name string) ?[]EarleyValue {
 				EarleyValue(parse_drop_table_statement(children[2] as Identifier)?),
 			]
 		}
+		'<exact numeric literal: 1>' {
+			return [EarleyValue(parse_int_value(children[0] as int)?)]
+		}
 		'<exact numeric literal: 2>' {
-			return [EarleyValue(parse_value(children[0] as Value)?)]
+			return [EarleyValue(parse_int_value(children[0] as int)?)]
 		}
 		'<exact numeric literal: 3>' {
 			return [
-				EarleyValue(parse_exact_numeric_literal1(children[0] as Value, children[2] as Value)?),
+				EarleyValue(parse_exact_numeric_literal1(children[0] as int, children[2] as int)?),
 			]
 		}
 		'<exact numeric literal: 4>' {
-			return [EarleyValue(parse_exact_numeric_literal2(children[1] as Value)?)]
+			return [EarleyValue(parse_exact_numeric_literal2(children[1] as int)?)]
 		}
 		'<exact numeric type: 1>' {
 			return [EarleyValue(parse_smallint()?)]
@@ -7569,6 +8125,12 @@ fn parse_ast_name(children []EarleyValue, name string) ?[]EarleyValue {
 					children[2] as Expr)?),
 			]
 		}
+		'<time literal: 1>' {
+			return [EarleyValue(parse_time_literal(children[1] as Value)?)]
+		}
+		'<timestamp literal: 1>' {
+			return [EarleyValue(parse_timestamp_literal(children[1] as Value)?)]
+		}
 		'<trigonometric function: 1>' {
 			return [
 				EarleyValue(parse_trig_func(children[0] as string, children[2] as Expr)?),
@@ -7599,6 +8161,12 @@ fn parse_ast_name(children []EarleyValue, name string) ?[]EarleyValue {
 		'<where clause: 1>' {
 			return [EarleyValue(parse_expr(children[1] as Expr)?)]
 		}
+		'<with or without time zone: 1>' {
+			return [EarleyValue(parse_yes()?)]
+		}
+		'<with or without time zone: 2>' {
+			return [EarleyValue(parse_no()?)]
+		}
 		else {
 			return children
 		}
diff --git a/vsql/parse.v b/vsql/parse.v
index 02a7ac7..f405984 100644
--- a/vsql/parse.v
+++ b/vsql/parse.v
@@ -103,12 +103,12 @@ fn parse_smallint() ?Type {
 	return new_type('SMALLINT', 0)
 }
 
-fn parse_varchar(length Value) ?Type {
-	return new_type('CHARACTER VARYING', int(length.f64_value))
+fn parse_varchar(length int) ?Type {
+	return new_type('CHARACTER VARYING', length)
 }
 
-fn parse_character_n(length Value) ?Type {
-	return new_type('CHARACTER', int(length.f64_value))
+fn parse_character_n(length int) ?Type {
+	return new_type('CHARACTER', length)
 }
 
 fn parse_character() ?Type {
@@ -119,8 +119,8 @@ fn parse_double_precision() ?Type {
 	return new_type('DOUBLE PRECISION', 0)
 }
 
-fn parse_float_n(length Value) ?Type {
-	return new_type('FLOAT', int(length.f64_value))
+fn parse_float_n(length int) ?Type {
+	return new_type('FLOAT', length)
 }
 
 fn parse_float() ?Type {
@@ -243,12 +243,12 @@ fn parse_value(v Value) ?Value {
 	return v
 }
 
-fn parse_exact_numeric_literal1(a Value, b Value) ?Value {
-	return new_double_precision_value('${a.f64_value}.$b.f64_value'.f64())
+fn parse_exact_numeric_literal1(a int, b int) ?Value {
+	return new_double_precision_value('${a}.$b'.f64())
 }
 
-fn parse_exact_numeric_literal2(a Value) ?Value {
-	return new_double_precision_value('0.$a.f64_value'.f64())
+fn parse_exact_numeric_literal2(a int) ?Value {
+	return new_double_precision_value('0.$a'.f64())
 }
 
 // <select list> <comma> <select sublist>
@@ -653,3 +653,65 @@ fn parse_joined_table(join QualifiedJoin) ?TableReference {
 fn parse_string(s string) ?string {
 	return s
 }
+
+fn parse_int_value(x int) ?Value {
+	return new_integer_value(x)
+}
+
+fn parse_timestamp_prec_tz_type(prec int, tz bool) ?Type {
+	if tz {
+		return new_type('TIMESTAMP WITH TIME ZONE', prec)
+	}
+
+	return new_type('TIMESTAMP WITHOUT TIME ZONE', prec)
+}
+
+fn parse_timestamp_prec_type(prec int) ?Type {
+	return parse_timestamp_prec_tz_type(prec, false)
+}
+
+fn parse_timestamp_tz_type(tz bool) ?Type {
+	// ISO/IEC 9075-2:2016(E), 6.1, 36) If <timestamp precision> is not
+	// specified, then 6 is implicit.
+	return parse_timestamp_prec_tz_type(6, tz)
+}
+
+fn parse_timestamp_type() ?Type {
+	return parse_timestamp_prec_tz_type(0, false)
+}
+
+fn parse_time_prec_tz_type(prec int, tz bool) ?Type {
+	if tz {
+		return new_type('TIME WITH TIME ZONE', prec)
+	}
+
+	return new_type('TIME WITHOUT TIME ZONE', prec)
+}
+
+fn parse_time_type() ?Type {
+	return parse_time_prec_tz_type(0, false)
+}
+
+fn parse_time_prec_type(prec int) ?Type {
+	return parse_time_prec_tz_type(prec, false)
+}
+
+fn parse_time_tz_type(tz bool) ?Type {
+	return parse_time_prec_tz_type(0, tz)
+}
+
+fn parse_date_type() ?Type {
+	return new_type('DATE', 0)
+}
+
+fn parse_timestamp_literal(v Value) ?Value {
+	return new_timestamp_value(v.string_value)
+}
+
+fn parse_time_literal(v Value) ?Value {
+	return new_time_value(v.string_value)
+}
+
+fn parse_date_literal(v Value) ?Value {
+	return new_date_value(v.string_value)
+}
diff --git a/vsql/query_cache.v b/vsql/query_cache.v
index f0f56d6..7d119c5 100644
--- a/vsql/query_cache.v
+++ b/vsql/query_cache.v
@@ -50,6 +50,14 @@ fn (q QueryCache) prepare_stmt(tokens []Token) (string, map[string]Value, []Toke
 			ignore = true
 		}
 
+		// Do not replace with placeholders for string literals that are part of
+		// date time literals, these have to stay as strings because they are
+		// parsed internally.
+		if j > 0 && tokens[j - 1].kind == .keyword && (tokens[j - 1].value == 'TIMESTAMP'
+			|| tokens[j - 1].value == 'TIME' || tokens[j - 1].value == 'DATE') {
+			ignore = true
+		}
+
 		if !ignore {
 			match token.kind {
 				.literal_number {
diff --git a/vsql/row.v b/vsql/row.v
index 7b3f0ce..3f9a251 100644
--- a/vsql/row.v
+++ b/vsql/row.v
@@ -109,7 +109,8 @@ fn new_empty_row(columns Columns, table_name string) Row {
 
 fn new_empty_value(col Column) Value {
 	match col.typ.typ {
-		.is_null {
+		.is_null, .is_date, .is_time_with_time_zone, .is_time_without_time_zone,
+		.is_timestamp_with_time_zone, .is_timestamp_without_time_zone {
 			return new_null_value()
 		}
 		.is_bigint {
@@ -193,6 +194,10 @@ fn (r Row) bytes(t Table) []u8 {
 					buf.write_string4(v.string_value)
 				}
 			}
+			.is_date, .is_time_with_time_zone, .is_time_without_time_zone,
+			.is_timestamp_with_time_zone, .is_timestamp_without_time_zone {
+				buf.write_bytes(v.time_value.bytes())
+			}
 		}
 	}
 
@@ -246,6 +251,23 @@ fn new_row_from_bytes(t Table, data []u8, tid int, table_name string) Row {
 					v.string_value = buf.read_bytes(len).bytestr()
 				}
 			}
+			.is_date {
+				v.time_value = new_time_from_bytes(.date, false, buf.read_bytes(8), 0)
+			}
+			.is_time_with_time_zone {
+				v.time_value = new_time_from_bytes(.time, true, buf.read_bytes(10), u8(col.typ.size))
+			}
+			.is_time_without_time_zone {
+				v.time_value = new_time_from_bytes(.time, false, buf.read_bytes(8), u8(col.typ.size))
+			}
+			.is_timestamp_with_time_zone {
+				v.time_value = new_time_from_bytes(.timestamp, true, buf.read_bytes(10),
+					u8(col.typ.size))
+			}
+			.is_timestamp_without_time_zone {
+				v.time_value = new_time_from_bytes(.timestamp, false, buf.read_bytes(8),
+					u8(col.typ.size))
+			}
 		}
 
 		if table_name == '' {
@@ -266,32 +288,17 @@ fn (mut r Row) object_key(t Table) ?[]u8 {
 		for col_name in t.primary_key {
 			col := t.column(col_name)?
 			match col.typ.typ {
-				.is_null {
-					return error('cannot use NULL in PRIMARY KEY')
-				}
 				.is_bigint {
 					pk.write_i64(i64(r.data[col_name].f64_value))
 				}
-				.is_boolean {
-					return error('cannot use BOOLEAN in PRIMARY KEY')
-				}
-				.is_character {
-					return error('cannot use character types in PRIMARY KEY')
-				}
-				.is_double_precision {
-					return error('cannot use non-integer types in PRIMARY KEY')
-				}
 				.is_integer {
 					pk.write_int(int(r.data[col_name].f64_value))
 				}
-				.is_real {
-					return error('cannot use non-integer types in PRIMARY KEY')
-				}
 				.is_smallint {
 					pk.write_i16(i16(r.data[col_name].f64_value))
 				}
-				.is_varchar {
-					return error('cannot use character types in PRIMARY KEY')
+				else {
+					return error('cannot use $col.typ.str() in PRIMARY KEY')
 				}
 			}
 		}
diff --git a/vsql/table.v b/vsql/table.v
index 4718a5b..d5b79b3 100644
--- a/vsql/table.v
+++ b/vsql/table.v
@@ -70,7 +70,7 @@ fn (t Table) bytes() []u8 {
 		b.write_string1(col.name)
 		b.write_byte(col.typ.number())
 		b.write_bool(col.not_null)
-		b.write_i16(0) // size
+		b.write_int(col.typ.size)
 		b.write_i16(0) // precision
 	}
 
@@ -88,10 +88,10 @@ fn new_table_from_bytes(data []u8, tid int) Table {
 		column_name := b.read_string1()
 		column_type := b.read_byte()
 		is_not_null := b.read_bool()
-		b.read_i16() // size
+		size := b.read_int()
 		b.read_i16() // precision
 
-		columns << Column{column_name, type_from_number(column_type), is_not_null}
+		columns << Column{column_name, type_from_number(column_type, size), is_not_null}
 	}
 
 	return Table{table_name, columns, primary_key, tid, false}
diff --git a/vsql/time.v b/vsql/time.v
new file mode 100644
index 0000000..9598279
--- /dev/null
+++ b/vsql/time.v
@@ -0,0 +1,317 @@
+// time.v contains functions for dealing with dates and times.
+
+module vsql
+
+import strings
+import regex
+import time
+
+const (
+	second_period = i64(1000000)
+	minute_period = 60 * second_period
+	hour_period   = 60 * minute_period
+	day_period    = 24 * hour_period
+	month_period  = 31 * day_period
+	year_period   = 12 * month_period
+)
+
+// The SQL standard is pretty strict about the format for date and time
+// literals. They express this through the grammar itself, but for simplicity
+// and performance the lexer treats all strings the same.
+//
+// We need to emulate the grammar with a regex which is expressed as:
+//
+//   <unquoted timestamp string> ::=
+//     <unquoted date string> <space> <unquoted time string>
+//
+//   <unquoted date string> ::= <date value>
+//
+//   <unquoted time string> ::= <time value> [ <time zone interval> ]
+//
+//   <date value> ::=
+//     <years value> <minus sign> <months value> <minus sign> <days value>
+//
+//   <time value> ::=
+//     <hours value> <colon> <minutes value> <colon> <seconds value>
+//
+//   <time zone interval> ::=
+//     <sign> <hours value> <colon> <minutes value>
+//
+const (
+	unquoted_date_string                        = r'\d+\-\d+\-\d+'
+	unquoted_time_string_with_time_zone         = r'\d+:\d+:\d+(\.\d{1,6})?[-+]\d+:\d+'
+	unquoted_time_string_without_time_zone      = r'\d+:\d+:\d+(\.\d{1,6})?'
+	unquoted_timestamp_with_time_zone_string    = '^' + unquoted_date_string + r'\s' +
+		unquoted_time_string_with_time_zone + '$'
+	unquoted_timestamp_without_time_zone_string = '^' + unquoted_date_string + r'\s' +
+		unquoted_time_string_without_time_zone + '$'
+)
+
+// TimeType changes the behavior of calculations of Time objects. The time zone
+// is not included here as that is kept separate.
+enum TimeType {
+	date
+	time
+	timestamp
+}
+
+// Time is the internal way that time is represented and provides other
+// conversions such as to/from storage and to/from V's native time.Time.
+struct Time {
+	typ            TimeType
+	with_time_zone bool
+	time_zone      i16 // number of minutes from 00:00 (positive or negative)
+	t              time.Time
+	prec           u8 // 0 to 6
+}
+
+// This is an internal constructor, you will want to use new_timestamp_value
+// (or similar others) to return the Value instead.
+fn new_timestamp_from_string(s string) ?Time {
+	expects_time_zone := s.len > 6 && (s[s.len - 6] == `+` || s[s.len - 6] == `-`)
+
+	mut re := regex.regex_opt(match expects_time_zone {
+		true { vsql.unquoted_timestamp_with_time_zone_string }
+		false { vsql.unquoted_timestamp_without_time_zone_string }
+	})?
+	if !re.matches_string(s) {
+		return sqlstate_42601('TIMESTAMP \'$s\' is not valid')
+	}
+
+	mut time_zone := i16(0)
+	mut to_parse := s
+	if expects_time_zone {
+		hours := i16(s[s.len - 6..s.len - 3].int())
+		minutes := i16(s[s.len - 2..s.len].int())
+		if hours < 0 {
+			time_zone = hours * 60 - minutes
+		} else {
+			time_zone = hours * 60 + minutes
+		}
+
+		if time_zone <= -720 || time_zone >= 720 {
+			return sqlstate_42601('TIMESTAMP \'$s\' is not valid')
+		}
+
+		// If we don't trim off the time zone, V will try and interpret it but
+		// we don't want that because we handle the time zone separately.
+		to_parse = s.substr(0, s.len - 6)
+	}
+
+	mut prec := u8(0)
+	if to_parse.contains('.') {
+		prec = u8(to_parse.len - to_parse.index_u8(`.`)) - 1
+	}
+
+	return Time{.timestamp, expects_time_zone, time_zone, time.parse_iso8601(to_parse) or {
+		return sqlstate_42601('TIMESTAMP \'$s\' is not valid')
+	}, prec}
+}
+
+// This is an internal constructor, you will want to use new_time_value
+// (or similar others) to return the Value instead.
+fn new_time_from_string(s string) ?Time {
+	// The easiest way to parse it is as a normal timestamp with a dummy date
+	// part. We use 1970-01-01 because internally we still need to rely on the
+	// unix timestamp in V's Time object. This data part will be ignored in
+	// actual calculations.
+	t := new_timestamp_from_string('1970-01-01 $s') or {
+		return sqlstate_42601('TIME \'$s\' is not valid')
+	}
+
+	return Time{.time, t.with_time_zone, t.time_zone, t.t, t.prec}
+}
+
+// This is an internal constructor, you will want to use new_date_value
+// (or similar others) to return the Value instead.
+fn new_date_from_string(s string) ?Time {
+	// The easiest way to parse it is as a normal timestamp with a dummy time
+	// part.
+	t := new_timestamp_from_string('$s 00:00:00') or {
+		return sqlstate_42601('DATE \'$s\' is not valid')
+	}
+
+	return Time{.date, t.with_time_zone, t.time_zone, t.t, t.prec}
+}
+
+fn new_time_from_components(typ TimeType, with_time_zone bool, year int, month int, day int, hour int, minute int, second int, microsecond int, time_zone i16, prec u8) Time {
+	return Time{typ, with_time_zone, time_zone, time.new_time(time.Time{
+		year: year
+		month: month
+		day: day
+		hour: hour
+		minute: minute
+		second: second
+		microsecond: microsecond
+	}), prec}
+}
+
+fn new_time_from_bytes(typ TimeType, with_time_zone bool, bytes []u8, prec u8) Time {
+	mut ts_i64 := bytes_to_i64(bytes)
+
+	year := int(ts_i64 / vsql.year_period)
+	ts_i64 -= year * vsql.year_period
+
+	month := int(ts_i64 / vsql.month_period)
+	ts_i64 -= month * vsql.month_period
+
+	day := int(ts_i64 / vsql.day_period)
+	ts_i64 -= day * vsql.day_period
+
+	hour := int(ts_i64 / vsql.hour_period)
+	ts_i64 -= hour * vsql.hour_period
+
+	minute := int(ts_i64 / vsql.minute_period)
+	ts_i64 -= minute * vsql.minute_period
+
+	second := int(ts_i64 / vsql.second_period)
+	ts_i64 -= second * vsql.second_period
+
+	mut time_zone := i16(0)
+	if with_time_zone {
+		time_zone = bytes_to_i16(bytes[bytes.len - 2..])
+	}
+
+	return new_time_from_components(typ, with_time_zone, year, month, day, hour, minute,
+		second, int(ts_i64), time_zone, prec)
+}
+
+// bytes returns the storage representation of the Time. The number of bytes
+// used depends on the type, where combinations produce the sum of:
+//
+//   date = 4 bytes
+//   time = 4 bytes
+//   time zone = 2 bytes
+//
+// A Time is stored as a modulo of the respective parts (rather than in
+// continuous form such as epoch seconds). This makes it faster to store an
+// retrieve but cannot be used in calculations directly.
+//
+// It's also worth nothing that the SQL standard does not permit for fractional
+// minute time zones. These are not used anymore, but for historical reason
+// (even as recent as 1972) some time zones had a seconds component. Trying to
+// use seconds in the time zone will result in a syntax error since the standard
+// treats a timestamp as grammar. It will be up to you how to decide to round
+// the time zone to whole minutes in these cases.
+fn (t Time) bytes() []u8 {
+	if t.with_time_zone {
+		mut buf := new_bytes(i64_to_bytes(t.i64()))
+		buf.write_i16(t.time_zone)
+
+		return buf.bytes()
+	}
+
+	return i64_to_bytes(t.i64())
+}
+
+// i64 returns the canonical integer representation of a specific millisecond
+// in time.
+//
+// Considering that the highest precision for seconds the SQL standard permits
+// is 6 (that's microseconds) we can store any timestamp in an i64 with plenty
+// of room to spare:
+//
+//   2^63 / (1e6 * 60 * 60 * 24 * 31 * 12) ~= 286967 years
+//
+// Unfortunatly, even with this ridiculous range of years we do not have enough
+// spare digits to also encode the time zone (without reducing the years to
+// around 400, even ultilizing the full 64 bits). So we store the timezone
+// separate.
+fn (t Time) i64() i64 {
+	return t.date_i64() + t.time_i64()
+}
+
+// See i64() for details.
+fn (t Time) time_i64() i64 {
+	return t.t.hour * vsql.hour_period + t.t.minute * vsql.minute_period +
+		t.t.second * vsql.second_period + t.t.microsecond
+}
+
+// See i64() for details.
+fn (t Time) date_i64() i64 {
+	return t.t.year * vsql.year_period + t.t.month * vsql.month_period + t.t.day * vsql.day_period
+}
+
+fn (t Time) str() string {
+	return match t.typ {
+		.timestamp {
+			t.str_timestamp()
+		}
+		.time {
+			t.str_time()
+		}
+		.date {
+			t.str_date()
+		}
+	}
+}
+
+fn (t Time) str_timestamp() string {
+	return t.str_date() + 'T' + t.str_time()
+}
+
+fn (t Time) str_date() string {
+	return t.t.strftime('%Y-%m-%d')
+}
+
+fn (t Time) str_time() string {
+	mut s := t.t.strftime('%H:%M:%S')
+
+	if t.prec > 0 {
+		s += '.' + t.t.microsecond.str()
+		s += strings.repeat(`0`, t.prec - t.t.microsecond.str().len)
+	}
+
+	if t.with_time_zone {
+		negative := t.time_zone < 0
+		mut time_zone := t.time_zone
+		if negative {
+			time_zone *= -1
+		}
+
+		if t.time_zone >= 0 {
+			s += '+'
+		} else {
+			s += '-'
+		}
+
+		hours := time_zone / 60
+		minutes := time_zone % 60
+
+		if hours < 10 {
+			s += '0$hours'
+		} else {
+			s += '$hours'
+		}
+
+		if minutes < 10 {
+			s += '0$minutes'
+		} else {
+			s += '$minutes'
+		}
+	}
+
+	return s
+}
+
+fn (t Time) sql_type() Type {
+	match t.typ {
+		.date {
+			return Type{.is_date, t.prec}
+		}
+		.time {
+			if t.with_time_zone {
+				return Type{.is_time_with_time_zone, t.prec}
+			}
+
+			return Type{.is_time_without_time_zone, t.prec}
+		}
+		.timestamp {
+			if t.with_time_zone {
+				return Type{.is_timestamp_with_time_zone, t.prec}
+			}
+
+			return Type{.is_timestamp_without_time_zone, t.prec}
+		}
+	}
+}
diff --git a/vsql/type.v b/vsql/type.v
index ce21582..659f368 100644
--- a/vsql/type.v
+++ b/vsql/type.v
@@ -19,20 +19,11 @@ enum SQLType {
 	is_real // REAL
 	is_smallint // SMALLINT
 	is_varchar // CHARACTER VARYING, CHAR VARYING and VARCHAR
-}
-
-fn (t SQLType) str() string {
-	return match t {
-		.is_null { 'NULL' }
-		.is_bigint { 'BIGINT' }
-		.is_boolean { 'BOOLEAN' }
-		.is_character { 'CHARACTER' }
-		.is_double_precision { 'DOUBLE PRECISION' }
-		.is_integer { 'INTEGER' }
-		.is_real { 'REAL' }
-		.is_smallint { 'SMALLINT' }
-		.is_varchar { 'CHARACTER VARYING' }
-	}
+	is_date // DATE
+	is_time_without_time_zone // TIME, TIME WITHOUT TIME ZONE
+	is_time_with_time_zone // TIME WITH TIME ZONE
+	is_timestamp_without_time_zone // TIMESTAMP, TIMESTAMP WITHOUT TIME ZONE
+	is_timestamp_with_time_zone // TIMESTAMP WITH TIME ZONE
 }
 
 fn new_type(name string, size int) Type {
@@ -63,6 +54,21 @@ fn new_type(name string, size int) Type {
 		'SMALLINT' {
 			Type{.is_smallint, size}
 		}
+		'DATE' {
+			Type{.is_date, 0}
+		}
+		'TIME', 'TIME WITHOUT TIME ZONE' {
+			Type{.is_time_without_time_zone, size}
+		}
+		'TIME WITH TIME ZONE' {
+			Type{.is_time_with_time_zone, size}
+		}
+		'TIMESTAMP', 'TIMESTAMP WITHOUT TIME ZONE' {
+			Type{.is_timestamp_without_time_zone, size}
+		}
+		'TIMESTAMP WITH TIME ZONE' {
+			Type{.is_timestamp_with_time_zone, size}
+		}
 		else {
 			panic(name_without_size)
 			Type{}
@@ -71,24 +77,80 @@ fn new_type(name string, size int) Type {
 }
 
 fn (t Type) str() string {
-	if t.size > 0 {
-		return '${t.typ}($t.size)'
-	}
+	match t.typ {
+		.is_null {
+			return 'NULL'
+		}
+		.is_bigint {
+			return 'BIGINT'
+		}
+		.is_boolean {
+			return 'BOOLEAN'
+		}
+		.is_character {
+			if t.size > 0 {
+				return 'CHARACTER($t.size)'
+			}
+
+			return 'CHARACTER'
+		}
+		.is_double_precision {
+			return 'DOUBLE PRECISION'
+		}
+		.is_integer {
+			return 'INTEGER'
+		}
+		.is_real {
+			return 'REAL'
+		}
+		.is_smallint {
+			return 'SMALLINT'
+		}
+		.is_varchar {
+			// TODO(elliotchance): Is this a bug to allow no size for CHARACTER
+			//  VARYING? Need to check standard.
+			if t.size > 0 {
+				return 'CHARACTER VARYING($t.size)'
+			}
 
-	return t.typ.str()
+			return 'CHARACTER VARYING'
+		}
+		.is_date {
+			return 'DATE'
+		}
+		.is_time_without_time_zone {
+			return 'TIME($t.size) WITHOUT TIME ZONE'
+		}
+		.is_time_with_time_zone {
+			return 'TIME($t.size) WITH TIME ZONE'
+		}
+		.is_timestamp_without_time_zone {
+			return 'TIMESTAMP($t.size) WITHOUT TIME ZONE'
+		}
+		.is_timestamp_with_time_zone {
+			return 'TIMESTAMP($t.size) WITH TIME ZONE'
+		}
+	}
 }
 
 fn (t Type) uses_f64() bool {
 	return match t.typ {
-		.is_boolean, .is_double_precision, .is_bigint, .is_real, .is_smallint, .is_integer { true }
-		.is_null, .is_varchar, .is_character { false }
+		.is_boolean, .is_double_precision, .is_bigint, .is_real, .is_smallint, .is_integer,
+		.is_date, .is_time_with_time_zone, .is_time_without_time_zone,
+		.is_timestamp_with_time_zone, .is_timestamp_without_time_zone {
+			true
+		}
+		.is_null, .is_varchar, .is_character {
+			false
+		}
 	}
 }
 
 fn (t Type) uses_string() bool {
 	return match t.typ {
 		.is_null, .is_boolean, .is_double_precision, .is_bigint, .is_real, .is_smallint,
-		.is_integer {
+		.is_integer, .is_date, .is_time_with_time_zone, .is_time_without_time_zone,
+		.is_timestamp_with_time_zone, .is_timestamp_without_time_zone {
 			false
 		}
 		.is_varchar, .is_character {
@@ -97,6 +159,19 @@ fn (t Type) uses_string() bool {
 	}
 }
 
+fn (t Type) uses_time() bool {
+	return match t.typ {
+		.is_null, .is_boolean, .is_double_precision, .is_bigint, .is_real, .is_smallint,
+		.is_integer, .is_varchar, .is_character {
+			false
+		}
+		.is_date, .is_time_with_time_zone, .is_time_without_time_zone,
+		.is_timestamp_with_time_zone, .is_timestamp_without_time_zone {
+			true
+		}
+	}
+}
+
 fn (t Type) number() u8 {
 	return match t.typ {
 		.is_null { 0 }
@@ -108,10 +183,15 @@ fn (t Type) number() u8 {
 		.is_smallint { 6 }
 		.is_varchar { 7 }
 		.is_character { 8 }
+		.is_date { 9 }
+		.is_time_with_time_zone { 10 }
+		.is_time_without_time_zone { 11 }
+		.is_timestamp_with_time_zone { 12 }
+		.is_timestamp_without_time_zone { 13 }
 	}
 }
 
-fn type_from_number(number u8) Type {
+fn type_from_number(number u8, size int) Type {
 	return new_type(match number {
 		0 { 'NULL' }
 		1 { 'BOOLEAN' }
@@ -120,8 +200,13 @@ fn type_from_number(number u8) Type {
 		4 { 'INTEGER' }
 		5 { 'REAL' }
 		6 { 'SMALLINT' }
-		7 { 'CHARACTER VARYING' }
+		7 { 'CHARACTER VARYING($size)' }
 		8 { 'CHARACTER' }
+		9 { 'DATE' }
+		10 { 'TIME($size) WITH TIME ZONE' }
+		11 { 'TIME($size) WITHOUT TIME ZONE' }
+		12 { 'TIMESTAMP($size) WITH TIME ZONE' }
+		13 { 'TIMESTAMP($size) WITHOUT TIME ZONE' }
 		else { panic(number) }
 	}, 0)
 }
diff --git a/vsql/value.v b/vsql/value.v
index f8835c2..724ea6a 100644
--- a/vsql/value.v
+++ b/vsql/value.v
@@ -10,6 +10,7 @@ pub mut:
 	typ          Type
 	f64_value    f64    // boolean and numeric
 	string_value string // char and varchar
+	time_value   Time   // date, time and timestamp
 }
 
 fn new_null_value() Value {
@@ -81,6 +82,33 @@ pub fn new_character_value(x string, size int) Value {
 	}
 }
 
+pub fn new_timestamp_value(ts string) ?Value {
+	t := new_timestamp_from_string(ts)?
+
+	return Value{
+		typ: t.sql_type()
+		time_value: t
+	}
+}
+
+pub fn new_time_value(ts string) ?Value {
+	t := new_time_from_string(ts)?
+
+	return Value{
+		typ: t.sql_type()
+		time_value: t
+	}
+}
+
+pub fn new_date_value(ts string) ?Value {
+	t := new_date_from_string(ts)?
+
+	return Value{
+		typ: t.sql_type()
+		time_value: t
+	}
+}
+
 fn bool_str(x f64) string {
 	return match x {
 		0 { 'FALSE' }
@@ -101,10 +129,22 @@ fn f64_string(x f64) string {
 
 fn (v Value) str() string {
 	return match v.typ.typ {
-		.is_null { 'NULL' }
-		.is_boolean { bool_str(v.f64_value) }
-		.is_double_precision, .is_real, .is_bigint, .is_integer, .is_smallint { f64_string(v.f64_value) }
-		.is_varchar, .is_character { v.string_value }
+		.is_null {
+			'NULL'
+		}
+		.is_boolean {
+			bool_str(v.f64_value)
+		}
+		.is_double_precision, .is_real, .is_bigint, .is_integer, .is_smallint {
+			f64_string(v.f64_value)
+		}
+		.is_varchar, .is_character {
+			v.string_value
+		}
+		.is_date, .is_time_with_time_zone, .is_time_without_time_zone,
+		.is_timestamp_with_time_zone, .is_timestamp_without_time_zone {
+			v.time_value.str()
+		}
 	}
 }