Optimizations to type casting (in preparation to array support.)

Author: fogzot

ChangeLog

@@ -1,13 +1,30 @@
+2005-03-12  Federico Di Gregorio  <fog@debian.org>
+
+	* psycopg/cursor_type.c (_psyco_curs_buildrow_fill): modified to
+	call typecast_cast().
+
+	* psycopg/typecast.c (typecast_call/typecast_cast): modified
+	typecast_call to use the new typecast_cast that avoids one string
+	conversion on every cast.
+
 2005-03-04  Federico Di Gregorio  <fog@initd.org>
 
-	* Release 1.99.13.1.
+	* Release 1.99.12.1.
 
 	* psycopg/adapter_asis.c (asis_str): changed call to PyObject_Repr
 	to PyObject_Str to avoid problems with long integers.
 
+2005-03-03  Federico Di Gregorio  <fog@debian.org>
+
+	* psycopg/typecast.h: added array casting functions.
+
+	* scripts/maketypes.sh: does not generate pgversion.h anymore. 
+
+	* Updated all examples for the release.
+
 2005-03-02  Federico Di Gregorio  <fog@debian.org>
 
-	* Release 1.99.13.
+	* Release 1.99.12.
 
 	* psycopg/adapter_*.c: added __conform__ to all adapters.
 

examples/cursor.py

@@ -26,7 +26,6 @@
     DSN = sys.argv[1]
 
 print "Opening connection using dsn:", DSN
-
 conn = psycopg.connect(DSN)
 print "Encoding for this connection is", conn.encoding
 
@@ -51,7 +50,7 @@ def fetchone(self):
 	    raise NoDataError("no more data")
         return d
 
-curs = conn.cursor(factory=Cursor)
+curs = conn.cursor(cursor_factory=Cursor)
 curs.execute("SELECT 1 AS foo")
 print "Result of fetchone():", curs.fetchone()
 

examples/lastrowid.py

@@ -49,10 +49,10 @@
 moid = curs.lastrowid
 print "Oid for %(name)s %(surname)s" % data[1], "is", moid
 
-curs.execute("SELECT * FROM test_oid WHERE oid = %d", (foid,))
+curs.execute("SELECT * FROM test_oid WHERE oid = %s", (foid,))
 print "Oid", foid, "selected %s %s" % curs.fetchone()
 
-curs.execute("SELECT * FROM test_oid WHERE oid = %d", (moid,))
+curs.execute("SELECT * FROM test_oid WHERE oid = %s", (moid,))
 print "Oid", moid, "selected %s %s" % curs.fetchone()
 
 curs.execute("DROP TABLE test_oid")

examples/mogrify.py

@@ -1,4 +1,4 @@
-# mogrify.py - test all possible type mogrifications
+# mogrify.py - test all possible simple type mogrifications
 # -*- encoding: latin1 -*-
 #
 # Copyright (C) 2004 Federico Di Gregorio  <fog@debian.org>
@@ -33,14 +33,14 @@
 curs.execute("SELECT %(foo)s AS foo", {'foo':'bar'})
 curs.execute("SELECT %(foo)s AS foo", {'foo':None})
 curs.execute("SELECT %(foo)s AS foo", {'foo':True})
-curs.execute("SELECT %(foo)f AS foo", {'foo':42})
+curs.execute("SELECT %(foo)s AS foo", {'foo':42})
 curs.execute("SELECT %(foo)s AS foo", {'foo':u'yattà!'})
 curs.execute("SELECT %(foo)s AS foo", {'foo':u'bar'})
 
 print curs.mogrify("SELECT %(foo)s AS foo", {'foo':'bar'})
 print curs.mogrify("SELECT %(foo)s AS foo", {'foo':None})
 print curs.mogrify("SELECT %(foo)s AS foo", {'foo':True})
-print curs.mogrify("SELECT %(foo)f AS foo", {'foo':42})
+print curs.mogrify("SELECT %(foo)s AS foo", {'foo':42})
 print curs.mogrify("SELECT %(foo)s AS foo", {'foo':u'yattà!'})
 print curs.mogrify("SELECT %(foo)s AS foo", {'foo':u'bar'})
 

examples/threads.py

@@ -81,7 +81,7 @@ def insert_func(conn_or_pool, rows):
                 conn = conn_or_pool.getconn()
         c = conn.cursor()
         try:
-            c.execute("INSERT INTO test_threads VALUES (%s, %d, %f)",
+            c.execute("INSERT INTO test_threads VALUES (%s, %s, %s)",
                       (str(i), i, float(i)))
         except psycopg.ProgrammingError, err:
             print name, ": an error occurred; skipping this insert"

psycopg/cursor_type.c

@@ -30,6 +30,7 @@
 #include "psycopg/cursor.h"
 #include "psycopg/connection.h"
 #include "psycopg/pqpath.h"
+#include "psycopg/typecast.h"
 #include "psycopg/microprotocols.h"
 #include "psycopg/microprotocols_proto.h"
 #include "pgversion.h"
@@ -545,31 +546,26 @@ static PyObject *
 _psyco_curs_buildrow_fill(cursorObject *self, PyObject *res,
                           int row, int n, int istuple)
 {
-    int i;
-    PyObject *str, *val;
+    int i, len;
+    unsigned char *str;
+    PyObject *val;
 
     for (i=0; i < n; i++) {
         if (PQgetisnull(self->pgres, row, i)) {
-            Py_INCREF(Py_None);
-            str = Py_None;
+            str = NULL;
+            len = 0;
         }
         else {
-            char *s = PQgetvalue(self->pgres, row, i);
-            int l = PQgetlength(self->pgres, row, i);
-            str = PyString_FromStringAndSize(s, l);
-
-            Dprintf("_psyco_curs_buildrow: row %ld, element %d, len %i",
-                    self->row, i, l);
+            str = PQgetvalue(self->pgres, row, i);
+            len = PQgetlength(self->pgres, row, i);
         }
 
-        Dprintf("_psyco_curs_buildrow: str->refcnt = %d", str->ob_refcnt);
-        val = PyObject_CallFunction(PyTuple_GET_ITEM(self->casts, i), "OO",
-                                    str, self);
-        /* here we DECREF str because the typecaster should already have
-           INCREFfed it, if necessary and we don't need it anymore */
-        Py_DECREF(str);
-        Dprintf("_psyco_curs_buildrow: str->refcnt = %d", str->ob_refcnt);
-        
+        Dprintf("_psyco_curs_buildrow: row %ld, element %d, len %i",
+                self->row, i, len);
+
+        val = typecast_cast(PyTuple_GET_ITEM(self->casts, i), str, len,
+                            (PyObject*)self);
+
         if (val) {
             Dprintf("_psyco_curs_buildrow: val->refcnt = %d", val->ob_refcnt);
             if (istuple) {
@@ -590,7 +586,6 @@ _psyco_curs_buildrow_fill(cursorObject *self, PyObject *res,
         }
     }
     return res;
-
 }
 
 static PyObject *

psycopg/microprotocols_proto.c

@@ -34,21 +34,6 @@
 
 /** void protocol implementation **/
 
-/* prepare - prepare object for quotation */
-
-#define psyco_isqlquote_prepare_doc \
-"prepare(conn) -> prepare object with connection 'conn'"
-
-static PyObject *
-psyco_isqlquote_prepare(isqlquoteObject *self, PyObject *args)
-{
-    PyObject* conn = NULL;
-   
-    if (!PyArg_ParseTuple(args, "O", &conn)) return NULL;
-    
-    Py_INCREF(Py_None);
-    return Py_None;
-}
 
 /* getquoted - return quoted representation for object */
 

psycopg/typecast.c

@@ -305,31 +305,15 @@ typecast_destroy(typecastObject *self)
 static PyObject *
 typecast_call(PyObject *obj, PyObject *args, PyObject *kwargs)
 {   
-    PyObject *string, *cursor, *res;
-    
-    typecastObject *self = (typecastObject *)obj;
+    PyObject *string, *cursor;
 
     if (!PyArg_ParseTuple(args, "OO", &string, &cursor)) {
         return NULL;
     }
 
-    if (self->ccast) {
-        Dprintf("typecast_call: calling C cast function");
-        res = self->ccast(string, cursor);
-    }
-    else if (self->pcast) {
-        Dprintf("typecast_call: calling python callable");
-        Py_INCREF(string);
-        res = PyObject_CallFunction(self->pcast, "OO", string, cursor);
-    }
-    else {
-        Py_INCREF(Py_None);
-        res = Py_None;
-    }
-
-    Dprintf("typecast_call: string argument has refcnt = %d",
-            string->ob_refcnt);
-    return res;
+    return typecast_cast(obj,
+                         PyString_AsString(string), PyString_Size(string),
+                         cursor);
 }
 
 
@@ -436,4 +420,21 @@ typecast_from_c(typecastObject_initlist *type)
     return (PyObject *)obj;
 }
 
+PyObject *
+typecast_cast(PyObject *obj, unsigned char *str, int len, PyObject *curs)
+{
+    typecastObject *self = (typecastObject *)obj;
 
+    if (self->ccast) {
+        Dprintf("typecast_call: calling C cast function");
+        return self->ccast(str, len, curs);
+    }
+    else if (self->pcast) {
+        Dprintf("typecast_call: calling python callable");
+        return PyObject_CallFunction(self->pcast, "s#O", str, len, curs);
+    }
+    else {
+        PyErr_SetString(Error, "internal error: no casting function found");
+        return NULL;
+    }
+}

psycopg/typecast.h

@@ -29,7 +29,7 @@ extern "C" {
 #endif
 
 /* type of type-casting functions (both C and Python) */
-typedef PyObject *(*typecast_function)(PyObject *, PyObject *);
+typedef PyObject *(*typecast_function)(unsigned char *, int len, PyObject *);
 
 /** typecast type **/
 
@@ -73,5 +73,9 @@ extern PyObject *typecast_from_c(typecastObject_initlist *type);
 /* the python callable typecast creator function */
 extern PyObject *typecast_from_python(
     PyObject *self, PyObject *args, PyObject *keywds);
+
+/* the function used to dispatch typecasting calls */
+extern PyObject *typecast_cast(
+    PyObject *self, unsigned char *str, int len, PyObject *curs);
 
 #endif /* !defined(PSYCOPG_TYPECAST_H) */

psycopg/typecast_basic.c

@@ -20,59 +20,57 @@
  */
 
 #include <libpq-fe.h>
+#include <stdlib.h>
 
 /** INTEGER - cast normal integers (4 bytes) to python int **/
 
 static PyObject *
-typecast_INTEGER_cast(PyObject *s, PyObject *curs)
+typecast_INTEGER_cast(unsigned char *s, int len, PyObject *curs)
 {
-    if (s == Py_None) {Py_INCREF(s); return s;}
-    return PyNumber_Int(s);
+    if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
+    return PyInt_FromString(s, NULL, 0);
 }
 
 /** LONGINTEGER - cast long integers (8 bytes) to python long **/
 
 static PyObject *
-typecast_LONGINTEGER_cast(PyObject *s, PyObject *curs)
+typecast_LONGINTEGER_cast(unsigned char *s, int len, PyObject *curs)
 {
-    if (s == Py_None) {Py_INCREF(s); return s;}
-    return PyNumber_Long(s);
+    if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
+    return PyLong_FromString(s, NULL, 0);
 }
 
 /** FLOAT - cast floating point numbers to python float **/
 
 static PyObject *
-typecast_FLOAT_cast(PyObject *s, PyObject *curs)
+typecast_FLOAT_cast(unsigned char *s, int len, PyObject *curs)
 {
-    if (s == Py_None) {Py_INCREF(s); return s;}
-    return PyNumber_Float(s);
+    if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
+    return PyFloat_FromDouble(atof(s));
 }
 
 /** STRING - cast strings of any type to python string **/
 
 static PyObject *
-typecast_STRING_cast(PyObject *s, PyObject *curs)
+typecast_STRING_cast(unsigned char *s, int len, PyObject *curs)
 {
-    Py_INCREF(s);
-    return s;
+    if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
+    return PyString_FromStringAndSize(s, len);
 }
 
 /** UNICODE - cast strings of any type to a python unicode object **/
 
 static PyObject *
-typecast_UNICODE_cast(PyObject *s, PyObject *curs)
+typecast_UNICODE_cast(unsigned char *s, int len, PyObject *curs)
 {
     PyObject *enc;
-    
-    if (s == Py_None) {Py_INCREF(s); return s;}
+
+    if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
 
     enc = PyDict_GetItemString(psycoEncodings,
                                ((cursorObject*)curs)->conn->encoding);
     if (enc) {
-        return PyUnicode_Decode(PyString_AsString(s),
-                                PyString_Size(s),
-                                PyString_AsString(enc),
-                                NULL);
+        return PyUnicode_Decode(s, strlen(s), PyString_AsString(enc), NULL);
     }
     else {
        PyErr_Format(InterfaceError,
@@ -134,15 +132,15 @@ typecast_BINARY_cast_unescape(unsigned char *str, size_t *to_length)
 #endif
 
 static PyObject *
-typecast_BINARY_cast(PyObject *s, PyObject *curs)
+typecast_BINARY_cast(unsigned char *s, int l, PyObject *curs)
 {
     PyObject *res;
     unsigned char *str;
     size_t len;
 
-    if (s == Py_None) {Py_INCREF(s); return s;}
+    if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
 
-    str = PQunescapeBytea(PyString_AS_STRING(s), &len);
+    str = PQunescapeBytea(s, &len);
     Dprintf("typecast_BINARY_cast: unescaped %d bytes", len);
 
     /* TODO: using a PyBuffer would make this a zero-copy operation but we'll
@@ -159,13 +157,13 @@ typecast_BINARY_cast(PyObject *s, PyObject *curs)
 /** BOOLEAN - cast boolean value into right python object **/
 
 static PyObject *
-typecast_BOOLEAN_cast(PyObject *s, PyObject *curs)
+typecast_BOOLEAN_cast(unsigned char *s, int len, PyObject *curs)
 {
     PyObject *res;
-    
-    if (s == Py_None) {Py_INCREF(s); return s;}
 
-    if (PyString_AS_STRING(s)[0] == 't')
+    if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
+
+    if (s[0] == 't')
         res = Py_True;
     else
         res = Py_False;
@@ -178,10 +176,10 @@ typecast_BOOLEAN_cast(PyObject *s, PyObject *curs)
 
 #ifdef HAVE_DECIMAL
 static PyObject *
-typecast_DECIMAL_cast(PyObject *s, PyObject *curs)
+typecast_DECIMAL_cast(unsigned char *s, int len, PyObject *curs)
 {
-    if (s == Py_None) {Py_INCREF(s); return s;}
-    return PyObject_CallFunction(decimalType, "O", s);
+    if (s == NULL) {Py_INCREF(Py_None); return Py_None;}
+    return PyObject_CallFunction(decimalType, "s", s);
 }
 #else
 #define typecast_DECIMAL_cast  typecast_FLOAT_cast