Changeset 297

Timestamp:

09/01/06 20:35:19

Author:

dowski

Message:

Implemented dejavu.month() and dejavu.day() for all SMs that can support it. Except firebird. Didn't touch firebird.

Tried implementing "Perfect Date" functionality for SQLite and hit a wall. See comments in storage/storesqlite.py.

Files:

• trunk/__init__.py (modified) (1 diff)
• trunk/storage/geniusql.py (modified) (1 diff)
• trunk/storage/storeado.py (modified) (2 diffs)
• trunk/storage/storepypgsql.py (modified) (1 diff)
• trunk/storage/storesqlite.py (modified) (8 diffs)
• trunk/test/test_storesqlite.py (modified) (1 diff)
• trunk/test/zoo_fixture.py (modified) (2 diffs)

trunk/__init__.py

@@ -109 +109 @@
-        return None
-
+def day(value):
+    """The day attribute of a date."""
+    if isinstance(value, (_datetime.date, _datetime.datetime)):
+        return value.day
+    else:
+        return None
+
-def now():
-    """Late-bound datetime.datetime.now(). Taint this when early binding."""

trunk/storage/geniusql.py

@@ -797 +797 @@
-        return "MONTH(" + x + ")"
-    
+    def dejavu_day(self, x):
+        return "DAY(" + x + ")"
+    
-    def func__builtin___len(self, x):
-        return "LENGTH(" + x + ")"

trunk/storage/storeado.py

@@ -294 +294 @@
-    def dejavu_today(self):
-        return "DATEADD(dd, DATEDIFF(dd,0,getdate()), 0)"
+    
+    def dejavu_year(self, x):
+        return "DATEPART(year, " + x + ")"
+    
+    def dejavu_month(self, x):
+        return "DATEPART(month, " + x + ")"
+    
+    def dejavu_day(self, x):
+        return "DATEPART(day, " + x + ")"
-    
-    def func__builtin___len(self, x):
@@ -813 +822 @@
-    def dejavu_year(self, x):
-        return "Year(" + x + ")"
-
+
+
+
+
+
+
-
-class TypeAdapter_MSAccess(db.TypeAdapter):

trunk/storage/storepypgsql.py

@@ -107 +107 @@
-    def dejavu_month(self, x):
-        return "date_part('month', " + x + ")"
-
+
+
+
-
-

trunk/storage/storesqlite.py

@@ +1 @@
+import datetime
-import os
-import time
@@ -9 +10 @@
-# This will import the "old API for SQLite 3.x", using e.g. pysqlite 1.1.7
-import _sqlite
+
-_version = storage.Version(_sqlite.sqlite_version())
-
@@ -22 +24 @@
-_rename_table_support = (_version >= storage.Version([3, 1, 0]))
-_autoincrement_support = (_version >= storage.Version([3, 1, 0]))
-
+
-
-class AdapterToSQLite(db.AdapterToSQL):
@@ -33 +35 @@
-    bool_true = "1"
-    bool_false = "0"
+    
+    # If you are using type adapters that support a "standard"
+    # date/datetime format for SQLite, set the following flag to True
+    using_perfect_dates = False
-    
-    def coerce_bool_to_any(self, value):
@@ -52 +58 @@
-class SQLiteDecompiler(db.SQLDecompiler):
-    
+    def visit_COMPARE_OP(self, lo, hi):
+        if self.adapter.using_perfect_dates:
+            op2, op1 = self.stack.pop(), self.stack.pop()
+            #@@NOTE: date/datetime comparision
+            # This code seems to work fine, but see the NOTE in visit_LOAD_ATTR
+            # for the problem...
+            
+            # SQLite can do meaningful date/datetime comparisions with
+            # Julian dates.  It has a function to convert a string date
+            # to a Julian date.  We make use of it here.
+            if (isinstance(op1, db.ConstWrapper) and
+                isinstance(op1.basevalue, (datetime.date, datetime.datetime))):
+                op1 = "julianday(" + op1 + ")"
+            
+            elif (isinstance(op2, db.ConstWrapper) and
+                  isinstance(op2.basevalue, (datetime.date, datetime.datetime))):
+                op2 = "julianday(" + op2 + ")"
+                
+            # Put the operands back on the stack so that the standard
+            # visit_COMPARE_OP can have its way with them.
+            self.stack.append(op1)
+            self.stack.append(op2)
+            
+        db.SQLDecompiler.visit_COMPARE_OP(self, lo, hi)
+    
+    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.
+            tablename, table = tos
+            col = table.columns[name]
+            if col.imperfect_type:
+                atom = db.cannot_represent
+                self.imperfect = True
+            # @@NOTE: date/datetime comparision
+            # I hit a wall here.  With the lack of a definitive date/datetime
+            # coltype in SQLite, and with the Python type of a column being
+            # determined by a different adapter, I have no way of determining
+            # if I should wrap a [table].[column] reference in the julianday()
+            # function :-(  I would like to do something like ...
+            # elif col.pytype in (datetime.date, datetime.datetime):
+            #     atom = "julianday(%s.%s)" % (tablename, col.qname)
+            else:
+                atom = '%s.%s' % (tablename, col.qname)
+        else:
+            # 'tos.name' will reference an attribute of the tos object.
+            # Stick the tos and name in a tuple for later processing.
+            atom = (tos, name)
+        self.stack.append(atom)
+    
-    def attr_startswith(self, tos, arg):
-        if _escape_support:
@@ -127 +184 @@
-    
-    def dejavu_now(self):
-
-
+
+
+
+
+
-    
-    dejavu_today = dejavu_now
-    
-    def dejavu_year(self, x):
-
-
-
+
+
+
+
+
+
-    def dejavu_month(self, x):
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
-
-class TypeAdapterSQLite(db.TypeAdapter):
@@ -358 +430 @@
-    
-    columnsetclass = SQLiteColumnSet
+    
+    def isrelatedtype(self, pytype1, pytype2):
+        if (self.using_perfect_dates and
+            issubclass(pytype1, (datetime.date, datetime.time, datetime.datetime)) and
+            issubclass(pytype2, self.python_type(self.typeadapter.coerce(None, pytype1)))):
+            return True
+        return db.Database.isrelatedtype(self, pytype1, pytype2)
-    
-    def _get_tables(self, conn=None):
@@ -557 +636 @@
-        allOptions['mode'] = int(allOptions.pop('Mode', '0755'), 8)
-        db.StorageManagerDB.__init__(self, arena, allOptions)
+        pd = str(allOptions.get('Perfect Dates', 'False')).lower() == "true"
+        self.databaseclass.using_perfect_dates = pd
+        self.databaseclass.adaptertosql.using_perfect_dates = pd
-    
-    def version(self):

trunk/test/test_storesqlite.py

@@ -19 +19 @@
-        
-        print
-':memory:' database...
-Database'] = ':memory:'
+with 'Perfect Dates'
+Perfect Dates'] = True
-        reload(zoo_fixture)
-        zoo_fixture.init()
-        zoo_fixture.run(SM_class, opts)
+        opts['Perfect Dates'] = False
+        
+##        print
+##        print "Testing SQLite ':memory:' database..."
+##        opts['Database'] = ':memory:'
+##        reload(zoo_fixture)
+##        zoo_fixture.init()
+##        zoo_fixture.run(SM_class, opts)
-        
-        print

trunk/test/zoo_fixture.py

@@ -421 +421 @@
-        self.assertEqual(matches(lambda x: 'i' in x.Species), 7)
-        
-
+, day()
-        self.assertEqual(matches(lambda x: x.Founded != None
-                                 and x.Founded < dejavu.today(), Zoo), 3)
@@ -427 +427 @@
-        self.assertEqual(matches(lambda x: dejavu.year(x.LastEscape) == 2004), 1)
-        self.assertEqual(matches(lambda x: dejavu.month(x.LastEscape) == 12), 1)
+        self.assertEqual(matches(lambda x: dejavu.day(x.LastEscape) == 21), 1)
-
-