odbc.py.c

这个是内存数据库的客户端

#define  SWIGTYPE_p_tagSQL_NUMERIC_STRUCT swig_types[21] 
#define  SWIGTYPE_p_tagSQL_YEAR_MONTH swig_types[22] 
#define  SWIGTYPE_ptrdiff_t swig_types[23] 
#define  SWIGTYPE_p_long swig_types[24] 
#define  SWIGTYPE_p_SQL_INTERVAL_STRUCT_intval swig_types[25] 
#define  SWIGTYPE_p_SQLINTERVAL swig_types[26] 
#define  SWIGTYPE_p_tagSQL_DAY_SECOND swig_types[27] 
#define  SWIGTYPE_p_tagODBC_VS_ARGS swig_types[28] 
static swig_type_info *swig_types[30];

/* -------- TYPES TABLE (END) -------- */


/*-----------------------------------------------
              @(target):= _odbc.so
  ------------------------------------------------*/
#define SWIG_init    init_odbc

#define SWIG_name    "_odbc"

#include <sqltypes.h>
#include <sqlucode.h>

#ifdef SQL_MAX_OPTION_STRING_LENGTH
#define BUFLEN ((SQL_MAX_OPTION_STRING_LENGTH) > 1024 ? (SQL_MAX_OPTION_STRING_LENGTH) : 1024)
#else
#define BUFLEN 1024
#endif

#if !defined(PY_LONG_LONG) && defined(LONG_LONG)
/* in python 2.2 it's still called LONG_LONG, but we use the newer
   name PY_LONG_LONG */
#define PY_LONG_LONG LONG_LONG
#endif

static PyObject *ErrorObject;


  /*@/usr/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_int PyInt_FromLong
/*@@*/


#include <limits.h>


SWIGINTERN int
  SWIG_CheckLongInRange(long value, long min_value, long max_value,
			const char *errmsg)
{
  if (value < min_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError, 
		   "value %ld is less than '%s' minimum %ld", 
		   value, errmsg, min_value);
    }
    return 0;    
  } else if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %ld is greater than '%s' maximum %ld", 
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
}


SWIGINTERN int
  SWIG_AsVal_long(PyObject * obj, long* val)
{
  if (PyInt_Check(obj)) {
    if (val) *val = PyInt_AS_LONG(obj);
    return 1;
  }
  if (PyLong_Check(obj)) {
    long v = PyLong_AsLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  }
  if (val) {
    SWIG_type_error("long", obj);
  }
  return 0;
 }


SWIGINTERN int
  SWIG_AsVal_short(PyObject *obj, short *val)
{ 
  const char* errmsg = val ? "short" : (char*)0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, SHRT_MIN, SHRT_MAX, errmsg)) {
      if (val) *val = (short)(v);
      return 1;
    } else {
      return 0;
    }    
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}


SWIGINTERNSHORT short
SWIG_As_short(PyObject* obj)
{
  short v;
  if (!SWIG_AsVal_short(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(short));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_short(PyObject* obj)
{
  return SWIG_AsVal_short(obj, (short*)0);
}


  /*@/usr/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_short PyInt_FromLong
/*@@*/


SWIGINTERNSHORT int
  SWIG_CheckUnsignedLongInRange(unsigned long value,
				unsigned long max_value,
				const char *errmsg) 
{
  if (value > max_value) {
    if (errmsg) {
      PyErr_Format(PyExc_OverflowError,
		   "value %lu is greater than '%s' minimum %lu",
		   value, errmsg, max_value);
    }
    return 0;
  }
  return 1;
 }


SWIGINTERN int
  SWIG_AsVal_unsigned_SS_long(PyObject *obj, unsigned long *val) 
{
  if (PyInt_Check(obj)) {
    long v = PyInt_AS_LONG(obj);
    if (v >= 0) {
      if (val) *val = v;
      return 1;
    }   
  }
  if (PyLong_Check(obj)) {
    unsigned long v = PyLong_AsUnsignedLong(obj);
    if (!PyErr_Occurred()) {
      if (val) *val = v;
      return 1;
    } else {
      if (!val) PyErr_Clear();
      return 0;
    }
  } 
  if (val) {
    SWIG_type_error("unsigned long", obj);
  }
  return 0;
}


SWIGINTERN int
  SWIG_AsVal_unsigned_SS_short(PyObject *obj, unsigned short *val)
{ 
  const char* errmsg = val ? "unsigned short" : (char*)0;
  unsigned long v;
  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    if (SWIG_CheckUnsignedLongInRange(v, USHRT_MAX, errmsg)) {
      if (val) *val = (unsigned short)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;
}


SWIGINTERNSHORT unsigned short
SWIG_As_unsigned_SS_short(PyObject* obj)
{
  unsigned short v;
  if (!SWIG_AsVal_unsigned_SS_short(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(unsigned short));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_unsigned_SS_short(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_short(obj, (unsigned short*)0);
}


  /*@/usr/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_unsigned_SS_short PyInt_FromLong
/*@@*/


SWIGINTERNSHORT unsigned long
SWIG_As_unsigned_SS_long(PyObject* obj)
{
  unsigned long v;
  if (!SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(unsigned long));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_unsigned_SS_long(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_long(obj, (unsigned long*)0);
}


SWIGINTERNSHORT PyObject* 
  SWIG_From_unsigned_SS_long(unsigned long value)
{
  return (value > LONG_MAX) ?
    PyLong_FromUnsignedLong(value) 
    : PyInt_FromLong((long)(value)); 
}


#if INT_MAX != LONG_MAX
SWIGINTERN int
  SWIG_AsVal_int(PyObject *obj, int *val)
{ 
  const char* errmsg = val ? "int" : (char*)0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, INT_MIN,INT_MAX, errmsg)) {
      if (val) *val = (int)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}
#else
SWIGINTERNSHORT int
  SWIG_AsVal_int(PyObject *obj, int *val)
{
  return SWIG_AsVal_long(obj,(long*)val);
}
#endif


SWIGINTERNSHORT int
SWIG_As_int(PyObject* obj)
{
  int v;
  if (!SWIG_AsVal_int(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(int));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_int(PyObject* obj)
{
  return SWIG_AsVal_int(obj, (int*)0);
}


typedef union {
			SQL_YEAR_MONTH_STRUCT year_month;
			SQL_DAY_SECOND_STRUCT day_second;
		} SQL_INTERVAL_STRUCT_intval;



SWIGINTERN int
  SWIG_AsVal_unsigned_SS_char(PyObject *obj, unsigned char *val)
{ 
  const char* errmsg = val ? "unsigned char" : (char*)0;
  unsigned long v;
  if (SWIG_AsVal_unsigned_SS_long(obj, &v)) {
    if (SWIG_CheckUnsignedLongInRange(v, UCHAR_MAX,errmsg)) {
      if (val) *val = (unsigned char)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;
}


SWIGINTERNSHORT unsigned char
SWIG_As_unsigned_SS_char(PyObject* obj)
{
  unsigned char v;
  if (!SWIG_AsVal_unsigned_SS_char(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(unsigned char));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_unsigned_SS_char(PyObject* obj)
{
  return SWIG_AsVal_unsigned_SS_char(obj, (unsigned char*)0);
}


  /*@/usr/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_unsigned_SS_char PyInt_FromLong
/*@@*/


SWIGINTERN int
  SWIG_AsVal_signed_SS_char(PyObject *obj, signed char *val)
{
  const char* errmsg = val ? "signed char" : (char*) 0;
  long v;
  if (SWIG_AsVal_long(obj, &v)) {
    if (SWIG_CheckLongInRange(v, SCHAR_MIN, SCHAR_MAX, errmsg)) {
      if (val) *val = (signed char)(v);
      return 1;
    } else {
      return 0;
    }
  } else {
    PyErr_Clear();
  }  
  if (val) {
    SWIG_type_error(errmsg, obj);
  }
  return 0;    
}


SWIGINTERNSHORT signed char
SWIG_As_signed_SS_char(PyObject* obj)
{
  signed char v;
  if (!SWIG_AsVal_signed_SS_char(obj, &v)) {
    /*
      this is needed to make valgrind/purify happier. 
     */
    memset((void*)&v, 0, sizeof(signed char));
  }
  return v;
}

  
SWIGINTERNSHORT int
SWIG_Check_signed_SS_char(PyObject* obj)
{
  return SWIG_AsVal_signed_SS_char(obj, (signed char*)0);
}


  /*@/usr/share/swig/1.3.24/python/pymacros.swg,66,SWIG_define@*/
#define SWIG_From_signed_SS_char PyInt_FromLong
/*@@*/


/*
  helper code for SQLWCHAR parameters
 */

static PyObject *
PyUnicode_FromSqlWChar(const SQLWCHAR *s, SQLSMALLINT l)
{
	const SQLWCHAR *s1;
	Py_UNICODE *u, *u1;
	PyObject *o;

	if (s == NULL) {
		Py_INCREF(Py_None);
		return Py_None;
	}
	if (l == SQL_NTS)
		for (l = 0, s1 = s; *s1; s1++, l++)
			;
	u = PyMem_Malloc((l + 1) * sizeof(Py_UNICODE));
	for (s1 = s, u1 = u; l > 0; s1++, u1++, l--)
		*u1 = *s1;
	o = PyUnicode_FromUnicode(u, (int) (s1 - s));
	PyMem_Free(u);
	return o;
}

SQLWCHAR *
SqlWChar_FromPyUnicode(PyObject *o, int *lp)
{
	Py_UNICODE *u;
	int ul;