Better errors

Author: erezsh

preql/api.py

@@ -3,7 +3,6 @@
 from . import settings
 from . import pql_ast as ast
 from . import pql_objects as objects
-from .utils import classify
 from .interpreter import Interpreter
 from .sql_interface import create_engine
 from .pql_types import T

preql/compiler.py

@@ -251,7 +251,7 @@ def compile_to_inst(state: State, proj: ast.Projection):
 @dy
 def compile_to_inst(state: State, order: ast.Order):
     table = cast_to_instance(state, order.table)
-    assert_type(table.type, T.table, state, order, "'order'")
+    assert_type(table.type, T.table, order, "'order'")
 
     with state.use_scope(table.all_attrs()):
         fields = cast_to_instance(state, order.fields)
@@ -447,7 +447,7 @@ def compile_to_inst(state: State, cmp: ast.Compare):
 @dy
 def compile_to_inst(state: State, neg: ast.Neg):
     expr = cast_to_instance(state, neg.expr)
-    assert_type(expr.type, T.number, state, neg, "Negation")
+    assert_type(expr.type, T.number, neg, "Negation")
 
     return make_instance(sql.Neg(expr.code), expr.type, [expr])
 
@@ -732,7 +732,7 @@ def compile_to_inst(state: State, rps: ast.ParameterizedSqlCode):
 def compile_to_inst(state: State, s: ast.Slice):
     obj = cast_to_instance(state, s.obj)
 
-    assert_type(obj.type, T.union[T.string, T.table], state, s, "Slice")
+    assert_type(obj.type, T.union[T.string, T.table], s, "Slice")
 
     instances = [obj]
     if s.range.start:
@@ -773,7 +773,7 @@ def compile_to_inst(state: State, sel: ast.Selection):
                          ).set_text_ref(sel.text_ref)
         return compile_to_inst(state, slice)
 
-    assert_type(table.type, T.table, state, sel, "Selection")
+    assert_type(table.type, T.table, sel, "Selection")
 
     with state.use_scope({n:projected(c) for n, c in table.all_attrs().items()}):
         conds = cast_to_instance(state, sel.conds)

preql/evaluate.py

@@ -3,7 +3,7 @@
 from pathlib import Path
 
 from .utils import safezip, dataclass, SafeDict, listgen
-from .interp_common import assert_type, exclude_fields, call_builtin_func, is_global_scope
+from .interp_common import assert_type, exclude_fields, call_builtin_func, is_global_scope, cast_to_python_string, cast_to_python_int
 from .exceptions import InsufficientAccessLevel, ReturnSignal, Signal
 from . import exceptions as exc
 from . import pql_objects as objects
@@ -56,21 +56,32 @@ def resolve(state: State, col_def: ast.ColumnDef):
     assert not query
 
     if isinstance(coltype, objects.SelectedColumnInstance):
-        x = T.t_relation[coltype.type](rel={'table': coltype.parent.type, 'column': coltype.name, 'key': False})
+        table = coltype.parent.type
+        if 'name' not in table.options:
+            # XXX better test for persistence
+            raise Signal.make(T.TypeError, col_def.type, "Tables provided as relations must be persistent.")
+
+        x = T.t_relation[coltype.type](rel={'table': table, 'column': coltype.name, 'key': False})
         return x.replace(_nullable=coltype.type._nullable)  # inherit is_nullable (TODO: use sumtypes?)
 
     elif coltype <= T.table:
+        if 'name' not in coltype.options:
+            # XXX better test for persistence
+            raise Signal.make(T.TypeError, col_def.type, "Tables provided as relations must be persistent.")
+
         x = T.t_relation[T.t_id.as_nullable()](rel={'table': coltype, 'column': 'id', 'key': True})
         return x.replace(_nullable=coltype._nullable)     # inherit is_nullable (TODO: use sumtypes?)
 
     return coltype(default=col_def.default)
 
 @dy
 def resolve(state: State, type_: ast.Type):
-    t = evaluate(state, type_.name)
+    t = evaluate(state, type_.type_obj)
     if isinstance(t, objects.TableInstance):
         t = t.type
-        assert t <= T.table
+
+    if not isinstance(t, (Type, objects.SelectedColumnInstance)):
+        raise Signal.make(T.TypeError, type_, f"Expected type in column definition. Instead got '{t}'")
 
     if type_.nullable:
         t = t.as_nullable()
@@ -207,7 +218,7 @@ def _execute(state: State, insert_rows: ast.InsertRows):
 
     rval = evaluate(state, insert_rows.value)
 
-    assert_type(rval.type, T.table, state, insert_rows, '+=')
+    assert_type(rval.type, T.table, insert_rows, '+=')
 
     return _copy_rows(state, insert_rows.name, rval)
 
@@ -602,7 +613,7 @@ def apply_database_rw(state: State, o: ast.One):
         return new_value_instance(row)
 
     assert table.type <= T.table
-    assert_type(table.type, T.table, state, o, 'one')
+    assert_type(table.type, T.table, o, 'one')
     d = {k: new_value_instance(v, table.type.elems[k], True) for k, v in row.items()}
     return objects.RowInstance(rowtype, d)
 
@@ -691,7 +702,7 @@ def apply_database_rw(state: State, new: ast.NewRows):
         # XXX Is it always TableInstance? Just sometimes? What's the transition here?
         obj = obj.type
 
-    assert_type(obj, T.table, state, new, "'new' expected an object of type '%s', instead got '%s'")
+    assert_type(obj, T.table, new, "'new' expected an object of type '%s', instead got '%s'")
 
     arg ,= new.args
 
@@ -795,7 +806,7 @@ def create_exception(state, msg):
 
     table = obj
     # TODO assert tabletype is a real table and not a query (not transient), otherwise new is meaningless
-    assert_type(table.type, T.table, state, new, "'new' expected an object of type '%s', instead got '%s'")
+    assert_type(table.type, T.table, new, "'new' expected an object of type '%s', instead got '%s'")
 
     cons = TableConstructor.make(table.type)
     matched = cons.match_params(state, new.args)

preql/interp_common.py

@@ -113,7 +113,7 @@ def get_var(self, name):
             except KeyError:
                 pass
 
-            raise Signal.make(T.NameError, name, f"Name '{name}' not found")
+            raise Signal.make(T.NameError, name, f"Name '{name}' is not defined")
 
 
     def set_var(self, name, value):
@@ -185,7 +185,7 @@ def get_all_vars_with_rank(self):
 
 
 
-def assert_type(t, type_, state, ast_node, op, msg="%s expected an object of type %s, instead got '%s'"):
+def assert_type(t, type_, ast_node, op, msg="%s expected an object of type %s, instead got '%s'"):
     assert isinstance(t, Type), t
     assert isinstance(type_, Type)
     if not t <= type_:

preql/pql_ast.py

@@ -207,7 +207,7 @@ class One(Expr):
 
 @dataclass
 class Type(Ast):
-    name: Object
+    type_obj: Object
     nullable: bool = False
 
 class Definition:

preql/pql_functions.py

@@ -219,8 +219,8 @@ def pql_issubclass(state: State, a: T.type, b: T.type):
         >> issubclass(list, table)
         true
     """
-    assert_type(a.type, T.type, state, a, 'issubclass')
-    assert_type(b.type, T.type, state, b, 'issubclass')
+    assert_type(a.type, T.type, a, 'issubclass')
+    assert_type(b.type, T.type, b, 'issubclass')
     assert isinstance(a, Type)
     assert isinstance(b, Type)
     return new_value_instance(a <= b, T.bool)
@@ -238,7 +238,7 @@ def pql_isa(state: State, obj: T.any, type: T.type):
         >> isa([1], table)
         true
     """
-    assert_type(type.type, T.type, state, obj, 'isa')
+    assert_type(type.type, T.type, obj, 'isa')
     res = obj.isa(type)
     return new_value_instance(res, T.bool)
 
@@ -305,7 +305,7 @@ def pql_temptable(state: State, expr: T.table, const: T.bool.as_nullable() = obj
     # 'temptable' creates its own counting 'id' field. Copying existing 'id' fields will cause a collision
     # 'const table' doesn't
     const = cast_to_python(state, const)
-    assert_type(expr.type, T.table, state, expr, 'temptable')
+    assert_type(expr.type, T.table, expr, 'temptable')
 
     name = state.unique_name("temp")    # TODO get name from table options
 

tests/test_basic.py

@@ -232,6 +232,9 @@ def test_logical(self):
         assert preql('1 and 2 or 3') == 2
         assert preql('1 or 2 and 3') == 1
 
+        self.assertEqual( preql('[1] or [2]'), [1])
+        self.assertEqual( preql('[1] and [2]'), [2])
+
     def test_basic2(self):
         # More basic tests
         preql = self.Preql()