Changeset 35

Timestamp:

03/15/07 22:49:03

Author:

fumanchu

Message:

Preliminary support for using lambdas as select attributes.

Files:

• trunk/geniusql/__init__.py (modified) (1 diff)
• trunk/geniusql/decompile.py (modified) (2 diffs)
• trunk/geniusql/objects.py (modified) (2 diffs)
• trunk/geniusql/providers/ado.py (modified) (1 diff)
• trunk/geniusql/select.py (modified) (5 diffs)
• trunk/geniusql/test/zoo_fixture.py (modified) (4 diffs)

trunk/geniusql/__init__.py

@@ -1 @@
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-
-__version__ = "1.0alpha"

trunk/geniusql/decompile.py

@@ -6 +6 @@
-    'ConstWrapper', 'ColumnWrapper', 'Sentinel',
-    'cannot_represent', 'kw_arg', 'SQLDecompiler',
+    'AttributeDecompiler',
-    ]
-
-
-# -------------------------- SQL DECOMPILATION -------------------------- #
-
-
@@ -382 +380 @@
-        return "LENGTH(" + x + ")"
-
+
+# ----------------------- Attribute Decompilation ----------------------- #
+
+
+class ColumnExpr(object):
+    """Wraps a column for use in AttributeDecompiler's stack.
+    
+    When we hit LOAD_ATTR while decompiling, we need to keep the column
+    metadata around.
+    
+    expr: the expression to be used for this column in the SELECT clause.
+        This should not contain an alias ("AS" clause); that will be
+        provided by the consumer, usually via the 'key' attribute.
+    """
+    
+    def __init__(self, table, col, key, expr):
+        self.table = table
+        self.col = col
+        self.key = key
+        self.alias = key
+        self.expr = expr
+        self.aggregate = False
+
+
+class AttributeDecompiler(codewalk.Visitor):
+    """Produce an SQL source list from a supplied Expression object.
+    
+    Attributes of each argument in the signature will be mapped to table
+    columns. Keyword arguments should be bound using Expression.bind_args
+    before calling this decompiler.
+    
+    After walk(), self.stack should be reduced to a list of ColumnExpr's.
+    """
+    
+    # Some constants are function or class objects,
+    # which should not be coerced.
+    no_coerce = (FunctionType,
+                 type,
+                 type(len),       # <type 'builtin_function_or_method'>
+                 )
+    
+    sql_cmp_op = ('<', '<=', '=', '!=', '>', '>=', 'in', 'not in')
+    
+    def __init__(self, tables, expr, adapter):
+        self.tables = tables
+        self.expr = expr
+        self.adapter = adapter
+        self.groups = []
+        codewalk.Visitor.__init__(self, expr.func)
+    
+    def walk(self):
+        self.stack = []
+        codewalk.Visitor.walk(self)
+    
+    def visit_LOAD_DEREF(self, lo, hi):
+        raise ValueError("Illegal reference found in %s." % self.expr)
+    
+    def visit_LOAD_GLOBAL(self, lo, hi):
+        raise ValueError("Illegal global found in %s." % self.expr)
+    
+    def visit_LOAD_FAST(self, lo, hi):
+        arg_index = lo + (hi << 8)
+        if arg_index < self.co_argcount:
+            # We've hit a reference to a positional arg, which in our case
+            # implies a reference to a DB table. Append the (qname, table)
+            # tuple for later unpacking inside visit_LOAD_ATTR.
+            self.stack.append(self.tables[arg_index])
+        else:
+            # Since lambdas don't support local bindings,
+            # any remaining local name must be a keyword arg.
+            raise ValueError("Illegal keyword arg found in %s." % self.expr)
+    
+    def visit_LOAD_ATTR(self, lo, hi):
+        name = self.co_names[lo + (hi << 8)]
+        tos = self.stack.pop()
+        if isinstance(tos, tuple):
+            # The name in question refers to a DB column (see visit_LOAD_FAST).
+            alias, table = tos
+            col = table[name]
+            atom = ColumnExpr(table, col, name, '%s.%s' % (alias, col.qname))
+        else:
+            # 'tos.name' will reference an attribute of the tos object.
+            # Stick the tos and name in a tuple for later processing
+            # (for example, in visit_CALL_FUNCTION).
+            atom = (tos, name)
+        self.stack.append(atom)
+    
+    def visit_LOAD_CONST(self, lo, hi):
+        val = self.co_consts[lo + (hi << 8)]
+        if not isinstance(val, self.no_coerce):
+            val = ConstWrapper(val, self.adapter.coerce(val))
+        self.stack.append(val)
+    
+    def visit_CALL_FUNCTION(self, lo, hi):
+        kwargs = {}
+        for i in xrange(hi):
+            val = self.stack.pop()
+            key = self.stack.pop()
+            kwargs[key] = val
+        kwargs = [k + "=" + v for k, v in kwargs.iteritems()]
+        
+        args = []
+        for i in xrange(lo):
+            arg = self.stack.pop()
+            args.append(arg)
+        args.reverse()
+        
+        if kwargs:
+            args += kwargs
+        
+        func = self.stack.pop()
+        
+        # Handle function objects.
+        funcname = func.__module__ + "_" + func.__name__
+        funcname = funcname.replace(".", "_")
+        if funcname.startswith("_"):
+            funcname = "func" + funcname
+        dispatch = getattr(self, funcname)
+        self.stack.append(dispatch(*args))
+    
+    def visit_UNARY_NOT(self):
+        op = self.stack.pop()
+        self.stack.append("NOT (" + op + ")")
+    
+    # --------------------------- Dispatchees --------------------------- #
+    
+    def dejavu_day(self, x):
+        x.alias = "day_%s" % x.alias
+        x.expr = "DAY(" + x.expr + ")"
+        return x
+    
+    def func__builtin___min(self, x):
+        x.aggregate = True
+        x.alias = "min_%s" % x.alias
+        x.expr = "MIN(" + x.expr + ")"
+        return x
+    
+    def func__builtin___max(self, x):
+        x.aggregate = True
+        x.alias = "max_%s" % x.alias
+        x.expr = "MAX(" + x.expr + ")"
+        return x
+    
+    def geniusql_decompile_count(self, x):
+        x.aggregate = True
+        x.alias = "count_%s" % x.alias
+        x.expr = "COUNT(" + x.expr + ")"
+        return x
+

trunk/geniusql/objects.py

@@ +1 @@
+"""Geniusql architectural classes.
+
+The Column and Index classes model corresponding database objects, and are
+intentionally simple. They should rarely contain any SQL or "smarts" of
+any kind, besides the "qname", the quoted name, of the column or index.
+At most, subclasses and consumers might put implementation-specific data
+into them.
+
+The IndexSet, Table, and Database objects are all dict-like containers,
+and therefore have a key for each value. Those keys should equate to things
+at the consumer layer; for example, a Database may possess a pair of the
+form: {'YoYo': Table('yoyo')} -- the key is the "friendly" name, but the
+Table.name is a lowercase version of that, because that's what the database
+uses in SQL to refer to that table.
+"""
+
-import threading
-from dejavu import logic
@@ -756 +772 @@
-    typeadapter = adapters.TypeAdapter()
-    decompiler = decompile.SQLDecompiler
+    attributedecompiler = decompile.AttributeDecompiler
-    joinwrapper = select.TableWrapper
-    selectwriter = select.SelectWriter

trunk/geniusql/providers/ado.py

@@ -677 +677 @@
-            query = query.encode(self.adaptertosql.encoding)
-        
-repr((id(conn), id(getattr(conn, "conn", None)), query))
+query
-        try:
-            bareconn = conn

trunk/geniusql/select.py

@@ +1 @@
+from types import FunctionType
+
-from geniusql import errors
-from dejavu import logic
@@ -111 +113 @@
-        must be in the same order as the tables in the relation.
-    
-
-
-
+
+
+
+
-    """
-    
@@ -149 +152 @@
-        self.output_list = []
-        self.output_keys = []
+        self._groupby = []
-        if self.attributes is None:
-            # Return all columns
-            for t in self.tables:
-                self._get_columns(t, None)
+        elif isinstance(self.attributes, FunctionType):
+            self.attributes = logic.Expression(self.attributes)
+            self.decompile_attributes()
+        elif isinstance(self.attributes, logic.Expression):
+            self.decompile_attributes()
-        else:
-            if isinstance(relation, Join):
@@ -227 +236 @@
-            w = ""
-        
-
+
+
+
+
+
+
+
-    
-    def where(self):
@@ -323 +338 @@
-        raise errors.ReferenceError("No reference found between %s and %s."
-                                    % (name1, name2))
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

trunk/geniusql/test/zoo_fixture.py

@@ -401 +401 @@
-    def test_5_Aggregates(self):
-        try:
+            Animal = schema['Animal']
+            Visit = schema['Visit']
+            Vet = schema['Vet']
+            
-            # views
-schema['Animal']
+Animal
-            legs = [x[0] for x in view]
-            legs.sort()
@@ -419 +423 @@
-                        'Ape': None,
-                        }
-schema['Animal']
+Animal
-                if expected[species] is None:
-                    self.assertEqual(lifespan, None)
@@ -436 +440 @@
-            # distinct
-            legs = [x[0] for x in
-schema['Animal']
+Animal
-            legs.sort()
-            self.assertEqual(legs, [1, 2, 4, 100, 1000000])
@@ -442 +446 @@
-            # This may raise a warning on some DB's.
-            f = (lambda x: x.Species == 'Lion')
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        finally:
-            db.connections.commit()