WIP

Author: erezsh

preql/core/pql_functions.py

@@ -1053,7 +1053,7 @@ def f(datetime):
 
 _datetime_methods = 'hour', 'minute', 'day', 'month', 'year', 'day_of_week', 'week_of_year'
 
-T.datetime.proto_attrs.update(create_internal_properties({
+T.timestamp.proto_attrs.update(create_internal_properties({
     n: _make_datetime_method(n) for n in _datetime_methods
 }))
 

preql/core/pql_types.py

@@ -256,8 +256,10 @@ def __setattr__(self, name, args):
 T.decimal = [T.number]
 
 # TODO datetime vs timestamp ! 
+T.timestamp = [T.primitive]    # struct?
 T.datetime = [T.primitive]    # struct?
 T.date = [T.primitive]    # struct?
+T.time = [T.primitive]    # struct?
 
 T.container = [T.object]
 
@@ -331,18 +333,18 @@ def _get_subtypes():
 #-------------
 
 
-_t = {
+_python_type_to_sql_type = {
     bool: T.bool,
     int: T.int,
     float: T.float,
     str: T.string,
-    datetime: T.datetime,
+    datetime: T.timestamp,
     Decimal: T.decimal,
-    arrow.Arrow: T.datetime,
+    arrow.Arrow: T.timestamp,   # datetime?
 }
 def from_python(t):
     # TODO throw proper exception if this fails
-    return _t[t]
+    return _python_type_to_sql_type[t]
 
 
 def common_type(t1, t2):

preql/core/sql.py

@@ -904,6 +904,10 @@ def _repr(_t: T.datetime, x):
     # TODO Better to pass the object instead of a string?
     return repr(str(x))
 
+def _repr(_t: T.timestamp, x):
+    # TODO Better to pass the object instead of a string?
+    return repr(str(x))
+
 @dp_type
 def _repr(_t: T.union[T.string, T.text], x):
     quoted_quote = r"\'" if get_db_target() == bigquery else "''"
@@ -930,37 +934,47 @@ def _compile_type(target, type_: T.t_relation):
     #return 'INTEGER'    # Foreign-key is integer
     return _compile_type(target, type_.elems['item'])
 
+
+class Types_PqlToSql:
+    bool = "BOOLEAN"
+    time = "TIME"
+    date = "DATE"
+    datetime = "DATETIME"
+    timestamp = "TIMESTAMP"
+
+    int = "INTEGER"
+    string = "VARCHAR(4000)"
+    float = "FLOAT"
+    text = "TEXT"
+
+class P2S_BigQuery(Types_PqlToSql):
+    int = "INT64"
+    string = "STRING"
+    float = "FLOAT64"
+    text = "STRING"
+
+
+class P2S_MySql(Types_PqlToSql):
+    int = "SIGNED"
+
+class P2S_Sqlite(Types_PqlToSql):
+    datetime = "TEXT"
+    timestamp = "TEXT"
+
+class P2S_Postgres(Types_PqlToSql):
+    datetime = "timestamp with time zone"
+
+_pql_to_sql_by_target = {
+    bigquery: P2S_BigQuery,
+    mysql: P2S_MySql,
+    sqlite: P2S_Sqlite,
+    postgres: P2S_Postgres,
+}
+
+
 @dp_type
 def _compile_type(target, type_: T.primitive):
-    if target == bigquery:
-        d = {
-            'int': "INT64",
-            'string': "STRING",
-            'float': "FLOAT64",
-            'bool': "BOOLEAN",
-            'text': "STRING",
-            'datetime': "DATETIME",
-            'date': "DATE",
-        }
-    elif target == mysql:
-        d = {
-            'int': "SIGNED",
-            'string': "VARCHAR(4000)",
-            'float': "FLOAT",
-            'bool': "BOOLEAN",
-            'text': "TEXT",
-            'datetime': "TIMESTAMP",
-        }
-    else:
-        d = {
-            'int': "INTEGER",
-            'string': "VARCHAR(4000)",
-            'float': "FLOAT",
-            'bool': "BOOLEAN",
-            'text': "TEXT",
-            'datetime': "TIMESTAMP",
-        }
-    s = d[type_.typename]
+    s = getattr(_pql_to_sql_by_target[target], type_.typename)
     if not type_.maybe_null():
         s += " NOT NULL"
     return s

preql/core/sql_import_result.py

@@ -89,6 +89,11 @@ def _restructure_result(_t: T.datetime, i):
     s = next(i)
     return _from_datetime(s)
 
+@dp_type
+def _restructure_result(_t: T.timestamp, i):
+    s = next(i)
+    return _from_datetime(s)
+
 
 
 @dp_inst
@@ -115,6 +120,14 @@ def sql_result_to_python(res: T.datetime):
     s = item
     return _from_datetime(s)
 
+@dp_inst
+def sql_result_to_python(res: T.timestamp):
+    # XXX doesn't belong here?
+    row ,= res.value
+    item ,= row
+    s = item
+    return _from_datetime(s)
+
 def _from_sql_primitive(p):
     if isinstance(p, decimal.Decimal):
         # TODO Needs different handling when we expect a decimal
@@ -170,9 +183,11 @@ def type_from_sql(type, nullable):
         'float': T.float,
         'double precision': T.float,    # double on 32-bit?
         'boolean': T.bool,
-        'timestamp': T.datetime,
+        'timestamp': T.timestamp,
         'timestamp without time zone': T.datetime,
+        'datetime': T.datetime,
         'date': T.date,
+        'time': T.time,
         'text': T.text,
     }
     try:

preql/docstring/type_docs.py

@@ -59,7 +59,8 @@
 T.bool: "A boolean, which can be either `true` or `false`",
 # T.decimal: "A decimal number",
 
-T.datetime: "A datetime type",
+T.datetime: "A datetime type (date+time combined)",
+T.timestamp: "A timestamp type (unix epoch)",
 
 T.container: """The base type of containers.
 

tests/test_basic.py

@@ -1380,7 +1380,7 @@ def test_import_table(self):
                 c: string
                 d: float
                 e: bool
-                f: datetime
+                f: timestamp
                 g: text
             }
         """)