Changeset 57

Timestamp:

04/03/07 23:10:58

Author:

fumanchu

Message:

PostgreSQL now works with the new types and adapters.

Files:

• trunk/geniusql/dbtypes.py (modified) (5 diffs)
• trunk/geniusql/providers/msaccess.py (modified) (1 diff)
• trunk/geniusql/providers/postgres.py (modified) (11 diffs)

trunk/geniusql/dbtypes.py

@@ -82 +82 @@
-
-
-Databas
+FrozenByt
-    """DatabaseType for string types whose byte-length is not adjuatable.
-    
@@ -172 +172 @@
-    _initargs = DatabaseType._initargs + ("precision", "max_precision")
-    
-255
+53
-    def _get_precision(self):
-        return self._precision
@@ -192 +192 @@
-    max_precision = 53
-    
-255
+53
-    def _get_precision(self):
-        return self._precision
-    def _set_precision(self, value):
-        if value is not None:
-
-
+
+
+
-            elif value > self.max_precision:
-
-
+: %r
+self, 
-        self._precision = value
-    precision = property(_get_precision, _set_precision,
@@ -279 +280 @@
-
-
-
-
-
+
+
-    _min = None
-    _max = None
-    
-    _initargs = DatabaseType._initargs + ("_min", "_max")
+    
+    def range(self):
+        """Return self.max - self.min."""
+        return self._max - self._min
-    
-    def min(self):
@@ -295 +299 @@
-        return self._max
-
+class DateTimeType(FixedRangeType):
+    default_pytype = datetime.datetime
+    default_adapters = {datetime.datetime: adapters.SQL92TIMESTAMP}
+
+class DateType(FixedRangeType):
+    default_pytype = datetime.date
+    default_adapters = {datetime.date: adapters.SQL92DATE}
+
+class TimeType(DatabaseType):
+    default_pytype = datetime.time
+    default_adapters = {datetime.time: adapters.SQL92TIME}
+
+
+class BooleanType(DatabaseType):
+    """DatabaseType which uses boolean values (True, False, Null)."""
+    default_pytype = bool
+    default_adapters = {bool: adapters.BOOLEAN}
+

trunk/geniusql/providers/msaccess.py

@@ -241 +241 @@
-
-
-Database
+Boolean
-    # "The BOOLEAN data types are logical types that result in either True
-    # or False values. They use 1 byte of memory for storage, and their
-    # synonyms are BIT, LOGICAL, LOGICAL1, and YESNO. A True value is
-    # equal to -1 while a False value is equal to 0."
-default_adapters = {bool: adapters.BOOLEAN}
+pass
-
-

trunk/geniusql/providers/postgres.py

@@ -13 +13 @@
-
-import geniusql
-
-
-
-
+
+
+
+
+
+
+
+
-    def binary_op(self, op1, op, op2):
-
-
+
-            # Postgres assumes a "date" is actually midnight, so we
-            # need to drop any h:m:s from our interval.
-
-
-
-
-
-
-
-
-
-
-
-
+
-        elif op2.pytype is datetime.date:
-            # Cast to timestamp to achieve an INTERVAL result
-
-
-
-
-
-
+
+
+
+
+
-    
-    def push(self, value):
@@ -85 +76 @@
-        
-        return datetime.timedelta(days, s)
-
-
-
+
+
+
+
+
+
+
+
+
+
-    
-    def push(self, value):
@@ -100 +98 @@
-
-
-
+_Adapter
-    
-    def push(self, value):
@@ -121 +119 @@
-
-
-
+_Adapter
-    
-    def push(self, value):
@@ -142 +140 @@
-
-
-
+gP
-    
-    def push(self, value):
@@ -169 +167 @@
-
-
-REAL
+PgFLOAT4_Adapter
-    
-    def push(self, value):
@@ -178 +176 @@
-
-
+
+# ---------------------------- DatabaseTypes ---------------------------- #
+
+# See http://www.postgresql.org/docs/8.1/static/datatype.html
+
+# Not implemented here:
+# 
+# box         rectangular box in the plane
+# cidr        IPv4 or IPv6 network address
+# circle      circle in the plane
+# inet        IPv4 or IPv6 host address
+# line        infinite line in the plane
+# lseg        line segment in the plane
+# macaddr     MAC address
+# path        geometric path in the plane
+# point       geometric point in the plane
+# polygon     closed geometric path in the plane
+# timetz      time of day, including time zone
+# timestamptz date and time, including time zone
+
+
+class BOOLEAN(dbtypes.BooleanType):
+    """A logical Boolean (true/false)."""
+    synonyms = ['BOOL']
+
+
+class BYTEA(dbtypes.FrozenByteType):
+    """A type for binary data ("byte array")."""
+    default_adapters = {str: PgBYTEA_Adapter}
+    default_pytype = str
+
+class BIT(dbtypes.AdjustableStringType):
+    """A fixed-length bit string"""
+    variable = False
+    default_adapters = {str: PgVARCHAR_Adapter,
+                        unicode: PgUNICODE_Adapter,
+                        None: PgPickler,
+                        }
+
+class VARBIT(dbtypes.AdjustableStringType):
+    """A variable-length bit string."""
+    synonyms = ['BIT VARYING']
+    variable = True
+    default_adapters = {str: PgVARCHAR_Adapter,
+                        unicode: PgUNICODE_Adapter,
+                        None: PgPickler,
+                        }
+
+class CHAR(dbtypes.AdjustableStringType):
+    """A fixed-length character string."""
+    synonyms = ['CHARACTER']
+    variable = False
+    default_adapters = {str: PgVARCHAR_Adapter,
+                        unicode: PgUNICODE_Adapter,
+                        None: PgPickler,
+                        }
+
+class VARCHAR(dbtypes.AdjustableStringType):
+    """A variable-length character string."""
+    synonyms = ['CHARACTER VARYING']
+    variable = True
+    default_adapters = {str: PgVARCHAR_Adapter,
+                        unicode: PgUNICODE_Adapter,
+                        None: PgPickler,
+                        }
+
+
+class ComparableInfinity(object):
+    
+    def __cmp__(self, other):
+        if isinstance(other, self.__class__):
+            return False
+        return True
+
+
+class TEXT(dbtypes.FrozenStringType):
+    """A variable-length character string."""
+    # TEXT has no hard byte limit.
+    bytes = max_bytes = ComparableInfinity()
+    default_adapters = {str: PgVARCHAR_Adapter,
+                        unicode: PgUNICODE_Adapter,
+                        None: PgPickler,
+                        }
+
+
+
+# Float types.
+# "In addition to ordinary numeric values, the floating-point types
+# have several special values: Infinity, -Infinity, NaN."
+
+class FLOAT4(dbtypes.InexactNumericType):
+    """A single precision floating-point number."""
+    synonyms = ['REAL']
+    precision = max_precision = 24
+    default_adapters = {float: PgFLOAT4_Adapter}
+    
+    def cast(self, sql, totype):
+        """Cast the given SQL expression from this type to another."""
+        if isinstance(totype, FLOAT4):
+            return sql
+        elif isinstance(totype, FLOAT8):
+            # Upcast to the larger type
+            return "(%s)::FLOAT8" % sql
+        raise TypeError("Could not cast %r from %r to %r."
+                        % (sql, self, totype))
+
+class FLOAT8(dbtypes.InexactNumericType):
+    """A double precision floating-point number."""
+    synonyms = ['DOUBLE PRECISION']
+    precision = max_precision = 53
+    default_adapters = {float: adapters.SQL92DOUBLE}
+    
+    def cast(self, sql, totype):
+        """Cast the given SQL expression from this type to another."""
+        if isinstance(totype, FLOAT8):
+            return sql
+        elif isinstance(totype, FLOAT4):
+            # Downcast to the smaller type
+            return "(%s)::FLOAT4" % sql
+        raise TypeError("Could not cast %r from %r to %r."
+                        % (sql, self, totype))
+
+
+class INT2(dbtypes.IntegerType):
+    """A signed two-byte integer."""
+    synonyms = ['SMALLINT']
+    signed = True
+    bytes = max_bytes = 2
+
+class INT4(dbtypes.IntegerType):
+    """A signed four-byte integer."""
+    
+    # "The data types serial and bigserial are not true types, but merely
+    # a notational convenience for setting up unique identifier columns
+    # (similar to the AUTO_INCREMENT property supported by some other
+    # databases).
+    synonyms = ['INT', 'INTEGER', 'SERIAL', 'SERIAL4']
+    
+    signed = True
+    bytes = max_bytes = 4
+
+class INT8(dbtypes.IntegerType):
+    synonyms = ['BIGINT', 'BIGSERIAL', 'SERIAL8']
+    signed = True
+    bytes = max_bytes = 8
+
+
+class TIMESTAMP(dbtypes.DateTimeType):
+    """A date and time."""
+    pass
+
+class DATE(dbtypes.DateType):
+    """A calendar date (year, month, day)."""
+    default_adapters = {datetime.date: PgDATE_Adapter}
+
+class TIME(dbtypes.TimeType):
+    """A time of day."""
+    pass
+
+class INTERVAL(dbtypes.AdjustablePrecisionType):
+    """A time span."""
+    default_adapters = {datetime.timedelta: PgINTERVAL_Adapter}
+    default_pytype = datetime.timedelta
+
+
+class NUMERIC(dbtypes.ExactNumericType):
+    """An exact numeric of selectable precision."""
+    
+    # "In addition to ordinary numeric values, the numeric type allows the
+    # special value NaN, meaning "not-a-number". Any operation on NaN yields
+    # another NaN. When writing this value as a constant in a SQL command,
+    # you must put quotes around it, for example UPDATE table SET x = 'NaN'.
+    # On input, the string NaN is recognized in a case-insensitive manner."
+    
+    synonyms = ['DECIMAL']
+    precision = max_precision = 1000
+
+
+class MONEY(dbtypes.FrozenPrecisionType):
+    """A currency amount."""
+    default_pytype = dbtypes.ExactNumericType.default_pytype
+
+
+
-class PgAdapterSet(adapters.AdapterSet):
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
@@ -274 +428 @@
-    def builtins_utcnow(self):
-        return self.get_expr("NOW()", datetime.datetime)
+    
+    def builtins_today(self):
+        neg, h, m = adapters.localtime_offset
+        sign = ""
+        if neg:
+            sign = "-"
+        offset = "%s:%s" % (h, m)
+        return self.get_expr("date_trunc('day', NOW() AT TIME ZONE INTERVAL '%s%s')"
+                             % (sign, offset), datetime.date)
-
-
@@ -368 +531 @@
-            dbtype, _ = self.db.fetch("SELECT typname, typlen FROM pg_type "
-                                      "WHERE oid = %s" % row[1], conn=conn)
-
-
-
-
-
-
-
+
+
+
+
+
-            c.adapter = adapterset.default(c.pytype, dbtype)
-            
-'FLOAT4', 'FLOAT8'
-c.hints['precision']
-'MONEY', 'NUMERIC'
-c.hints['precision']
-c.hints['scale']
+FLOAT4, FLOAT8
+dbtype.precision
+MONEY, NUMERIC
+dbtype.precision
+dbtype.scale
-            
-            # Default value
@@ -404 +565 @@
-                c.default = None
-            
-.startswith('BPCHAR') or dbtype.startswith('VARCHAR')
+ is VARCHAR
-                # See http://archives.postgresql.org/pgsql-interfaces/2004-07/msg00021.php
-c.hints['bytes']
+dbtype.bytes
-            else:
-                bytes = row[3]
-                if bytes > 0:
-
-
-
+
-            
-            cols.append(c)
@@ -461 +620 @@
-            default = " DEFAULT %s" % default
-        
-
+.ddl()
-    
-    def create_sequence(self, table, column):