More refactor

Author: erezsh

preql/api.py

@@ -1,43 +1,32 @@
 from contextlib import contextmanager
 
-
 from . import settings
 from . import pql_ast as ast
 from . import pql_objects as objects
 from .utils import classify
 from .interpreter import Interpreter
-from .evaluate import cast_to_python
-from .interp_common import create_engine, call_pql_func
+from .sql_interface import create_engine
 from .pql_types import T
-from .pql_functions import import_pandas
-from .context import context
-from . import sql
 
 from . import display
 display.install_reprs()
 
 
-def _call_pql_func(state, name, args):
-    with context(state=state):
-        count = call_pql_func(state, name, args)
-        return cast_to_python(state, count)
-
-
 class TablePromise:
     """Returned by Preql whenever the result is a table
 
     Fetching values creates queries to database engine
     """
 
-    def __init__(self, state, inst):
-        self._state = state
+    def __init__(self, interp, inst):
+        self._interp = interp
         self._inst = inst
         self._rows = None
 
     def to_json(self):
         "Returns table as a list of rows, i.e. ``[{col1: value, col2: value, ...}, ...]``"
         if self._rows is None:
-            self._rows = cast_to_python(self._state, self._inst)
+            self._rows = self._interp.cast_to_python(self._inst)
         assert self._rows is not None
         return self._rows
 
@@ -55,30 +44,30 @@ def __eq__(self, other):
 
     def __len__(self):
         "Run a count query on table"
-        return _call_pql_func(self._state, 'count', [self._inst])
+        count = self._interp.call_builtin_func('count', [self._inst])
+        return self._interp.cast_to_python(count)
 
     def __iter__(self):
         return iter(self.to_json())
 
     def __getitem__(self, index):
         "Run a slice query on table"
-        with context(state=self._state):
-            if isinstance(index, slice):
-                offset = index.start or 0
-                limit = index.stop - offset
-                return call_pql_func(self._state, 'limit_offset', [self._inst, ast.make_const(limit), ast.make_const(offset)])
+        if isinstance(index, slice):
+            offset = index.start or 0
+            limit = index.stop - offset
+            return self._interp.call_builtin_func('limit_offset', [self._inst, ast.make_const(limit), ast.make_const(offset)])
 
-            # TODO different debug log level / mode
-            res ,= cast_to_python(self._state, self[index:index+1])
-            return res
+        # TODO different debug log level / mode
+        res ,= self._interp.cast_to_python(self[index:index+1])
+        return res
 
     def __repr__(self):
         return repr(self.to_json())
 
 
 def _prepare_instance_for_user(interp, inst):
     if inst.type <= T.table:
-        return TablePromise(interp.state, inst)
+        return TablePromise(interp, inst)
 
     return interp.localize_obj(inst)
 
@@ -104,6 +93,7 @@ def __init__(self, db_uri: str='sqlite://:memory:', print_sql: bool=settings.pri
         """
         self._db_uri = db_uri
         self._print_sql = print_sql
+        self._auto_create = auto_create
         # self.engine.ping()
 
         engine = create_engine(self._db_uri, print_sql=self._print_sql, auto_create=auto_create)
@@ -182,41 +172,18 @@ def commit(self):
     def rollback(self):
         return self.interp.state.db.rollback()
 
-    def _drop_tables(self, *tables):
-        state = self.interp.state
-        # XXX temporary. Used for testing
-        for t in tables:
-            t = sql._quote(state.db.target, state.db.qualified_name(t))
-            state.db._execute_sql(T.nulltype, f"DROP TABLE {t};", state)
 
     def import_pandas(self, **dfs):
         """Import pandas.DataFrame instances into SQL tables
 
         Example:
             >>> pql.import_pandas(a=df_a, b=df_b)
         """
-        with self.interp.setup_context():
-            return list(import_pandas(self.interp.state, dfs))
+        return self.interp.import_pandas(dfs)
 
 
     def load_all_tables(self):
-        table_types = self.interp.state.db.import_table_types(self.interp.state)
-        table_types_by_schema = classify(table_types, lambda x: x[0], lambda x: x[1:])
-
-        for schema_name, table_types in table_types_by_schema.items():
-            if schema_name:
-                schema = objects.Module(schema_name, {})
-                self.interp.set_var(schema_name, schema)
-
-            for table_name, table_type in table_types:
-                db_name = table_type.options['name']
-                inst = objects.new_table(table_type, db_name)
-
-                if schema_name:
-                    schema.namespace[table_name] = inst
-                else:
-                    if not self.interp.has_var(table_name):
-                        self.interp.set_var(table_name, inst)
+        return self.interp.load_all_tables()
 
 
 

preql/compiler.py

@@ -8,7 +8,7 @@
 from . import pql_objects as objects
 from . import pql_ast as ast
 from . import sql
-from .interp_common import dy, State, assert_type, new_value_instance, evaluate, simplify, call_pql_func, cast_to_python_string, cast_to_python_int
+from .interp_common import dy, State, assert_type, new_value_instance, evaluate, simplify, call_builtin_func, cast_to_python_string, cast_to_python_int
 from .pql_types import T, Type, Id, ITEM_NAME, dp_inst
 from .types_impl import flatten_type, pql_repr, kernel_type
 from .casts import cast
@@ -321,7 +321,7 @@ def _contains(state, op, a: T.string, b: T.string):
         'in': 'str_contains',
         '!in': 'str_notcontains',
     }[op]
-    return call_pql_func(state, f, [a, b])
+    return call_builtin_func(state, f, [a, b])
 
 @dp_inst
 def _contains(state, op, a: T.primitive, b: T.table):
@@ -412,7 +412,7 @@ def _compare(_state, op, a: T.primitive, b: T.primitive):
 @dp_inst
 def _compare(state, op, a: T.type, b: T.type):
     if op == '<=':
-        return call_pql_func(state, "issubclass", [a, b])
+        return call_builtin_func(state, "issubclass", [a, b])
     if op != '=':
         raise exc.Signal.make(T.NotImplementedError, op, f"Cannot compare types using: {op}")
     return new_value_instance(a == b)
@@ -491,7 +491,7 @@ def _compile_arith(state, arith, a: T.table, b: T.table):
 def _compile_arith(state, arith, a: T.string, b: T.int):
     if arith.op != '*':
         raise Signal.make(T.TypeError, arith.op, f"Operator '{arith.op}' not supported between string and integer.")
-    return call_pql_func(state, "repeat", [a, b])
+    return call_builtin_func(state, "repeat", [a, b])
 
 
 @dp_inst

preql/display.py

@@ -9,7 +9,7 @@
 from . import pql_objects as objects
 from . import pql_ast as ast
 from .types_impl import dp_type, pql_repr
-from .interp_common import call_pql_func, cast_to_python_int, cast_to_python
+from .interp_common import call_builtin_func, cast_to_python_int, cast_to_python
 
 from .context import context
 
@@ -67,11 +67,8 @@ def pql_repr(t: T.nulltype, value):
 
 
 def table_limit(table, state, limit, offset=0):
-    return call_pql_func(state, 'limit_offset', [table, ast.make_const(limit), ast.make_const(offset)])
+    return call_builtin_func(state, 'limit_offset', [table, ast.make_const(limit), ast.make_const(offset)])
 
-def _call_pql_func(state, name, args):
-    count = call_pql_func(state, name, args)
-    return cast_to_python_int(state, count)
 
 def _html_table(name, count_str, rows, offset, has_more, colors):
     assert colors
@@ -164,7 +161,7 @@ def _view_table(state, table, size, offset):
 def table_repr(self, offset=0):
     state = context.state
 
-    count = _call_pql_func(state, 'count', [table_limit(self, state, MAX_AUTO_COUNT)])
+    count = cast_to_python_int(state, call_builtin_func(state, 'count', [table_limit(self, state, MAX_AUTO_COUNT)]))
     if count == MAX_AUTO_COUNT:
         count_str = f'>={count}'
     else:

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_pql_func, is_global_scope
+from .interp_common import assert_type, exclude_fields, call_builtin_func, is_global_scope
 from .exceptions import InsufficientAccessLevel, ReturnSignal, Signal
 from . import exceptions as exc
 from . import pql_objects as objects
@@ -85,14 +85,14 @@ def _execute(state: State, struct_def: ast.StructDef):
 
 def db_query(state: State, sql_code, subqueries=None):
     try:
-        return state.db.query(sql_code, subqueries, state=state)
+        return state.db.query(sql_code, subqueries)
     except exc.DatabaseQueryError as e:
         raise Signal.make(T.DbQueryError, None, e.args[0]) from e
 
 def drop_table(state, table_type):
     name ,= table_type.options['name'].parts
     code = sql.compile_drop_table(state, name)
-    return state.db.query(code, {}, state=state)
+    return state.db.query(code, {})
 
 
 @dy
@@ -125,7 +125,7 @@ def _execute(state: State, table_def: ast.TableDef):
     exists = state.db.table_exists(db_name.repr_name)
     if exists:
         assert not t.options['temporary']
-        cur_type = state.db.import_table_type(state, db_name.repr_name, None if ellipsis else set(t.elems) | {'id'})
+        cur_type = state.db.import_table_type(db_name.repr_name, None if ellipsis else set(t.elems) | {'id'})
 
         if ellipsis:
             elems_to_add = {Str(n, ellipsis.text_ref): v for n, v in cur_type.elems.items() if n not in t.elems}
@@ -555,7 +555,7 @@ def _call_expr(state, expr):
 # TODO fix these once we have proper types
 @dy
 def test_nonzero(state: State, table: objects.TableInstance):
-    count = call_pql_func(state, "count", [table])
+    count = call_builtin_func(state, "count", [table])
     return bool(cast_to_python_int(state, count))
 
 @dy

preql/interp_common.py

@@ -199,7 +199,7 @@ def exclude_fields(state, table, fields):
     proj = ast.Projection(table, [ast.NamedField(None, ast.Ellipsis(None, exclude=list(fields) ), user_defined=False)])
     return evaluate(state, proj)
 
-def call_pql_func(state, name, args):
+def call_builtin_func(state, name, args):
     "Call a builtin pql function"
     builtins = state.ns.get_var('__builtins__')
     assert isinstance(builtins, objects.Module)

preql/interpreter.py

@@ -1,13 +1,15 @@
 from pathlib import Path
 from functools import wraps
 
+from .utils import classify
 from .exceptions import Signal, pql_SyntaxError, ReturnSignal
-from .evaluate import State, execute, eval_func_call, import_module, evaluate, localize
+from .evaluate import State, execute, eval_func_call, import_module, evaluate, localize, cast_to_python
 from .parser import parse_stmts
 from . import pql_ast as ast
 from . import pql_objects as objects
-from .interp_common import new_value_instance
+from .interp_common import new_value_instance, call_builtin_func
 from .context import context
+from .pql_functions import import_pandas
 
 from .pql_functions import internal_funcs, joins
 from .pql_types import T, Object
@@ -54,11 +56,11 @@ def _execute_code(self, code, source_file, args=None):
             raise Signal(T.SyntaxError, [e.text_ref], e.message)
 
 
-        last = None
         if stmts:
             if isinstance(stmts[0], ast.Const) and stmts[0].type == T.string:
                 self.set_var('__doc__', stmts[0].value) 
 
+        last = None
         for stmt in stmts:
             try:
                 last = execute(self.state, stmt)
@@ -109,3 +111,40 @@ def localize_obj(self, obj):
     def call_func(self, fname, args):
         res = eval_func_call(self.state, self.state.get_var(fname), args)
         return evaluate(self.state, res)
+
+    @entrypoint
+    def cast_to_python(self, obj):
+        return cast_to_python(self.state, obj)
+
+    @entrypoint
+    def call_builtin_func(self, name, args):
+        return call_builtin_func(self.state, name, args)
+
+    @entrypoint
+    def import_pandas(self, dfs):
+        return list(import_pandas(self.state, dfs))
+
+    @entrypoint
+    def list_tables(self):
+        return self.state.db.list_tables()
+
+
+    @entrypoint
+    def load_all_tables(self):
+        table_types = self.state.db.import_table_types()
+        table_types_by_schema = classify(table_types, lambda x: x[0], lambda x: x[1:])
+
+        for schema_name, table_types in table_types_by_schema.items():
+            if schema_name:
+                schema = objects.Module(schema_name, {})
+                self.set_var(schema_name, schema)
+
+            for table_name, table_type in table_types:
+                db_name = table_type.options['name']
+                inst = objects.new_table(table_type, db_name)
+
+                if schema_name:
+                    schema.namespace[table_name] = inst
+                else:
+                    if not self.has_var(table_name):
+                        self.set_var(table_name, inst)

preql/pql_functions.py

@@ -632,7 +632,7 @@ def pql_import_table(state: State, name: T.string, columns: T.list[T.string].as_
         columns_whitelist = set(columns_whitelist)
 
     # Get table type
-    t = state.db.import_table_type(state, name_str, columns_whitelist)
+    t = state.db.import_table_type(name_str, columns_whitelist)
     assert t <= T.table
 
     # Get table contents
@@ -721,7 +721,7 @@ def pql_tables(state: State):
     The resulting table has two columns: name, and type.
     """
     names = state.db.list_tables()
-    values = [(name, state.db.import_table_type(state, name, None)) for name in names]
+    values = [(name, state.db.import_table_type(name, None)) for name in names]
     tuples = [sql.Tuple(T.list[T.string], [new_str(n).code,new_str(t).code]) for n,t in values]
 
     table_type = T.table(dict(name=T.string, type=T.string))