{

switch (sqltype)

{

case SQL_DECIMAL:

case SQL_NUMERIC:

case SQL_REAL:

case SQL_FLOAT:

case SQL_DOUBLE:

case SQL_SMALLINT:

case SQL_INTEGER:

case SQL_TINYINT:

case SQL_BIGINT:

return true;

}

return false;

{

// Called after an execute to construct the map shared by rows.

bool success = false;

PyObject *desc = 0, *colmap = 0, *colinfo = 0, *type = 0, *index = 0, *nullable_obj=0;

SQLRETURN ret;

I(cur->hstmt != SQL_NULL_HANDLE && cur->colinfos != 0);

// These are the values we expect after free_results. If this function fails, we do not modify any members, so

// they should be set to something Cursor_close can deal with.

I(cur->description == Py_None);

I(cur->map_name_to_index == 0);

if (cur->cnxn->hdbc == SQL_NULL_HANDLE)

{

RaiseErrorV(0, ProgrammingError, "The cursor's connection was closed.");

return false;

}

desc = PyTuple_New((Py_ssize_t)field_count);

colmap = PyDict_New();

if (!desc || !colmap)

goto done;

for (int i = 0; i < field_count; i++)

{

SQLCHAR name[300];

SQLSMALLINT nDataType;

SQLULEN nColSize; // precision

SQLSMALLINT cDecimalDigits; // scale

SQLSMALLINT nullable;

Py_BEGIN_ALLOW_THREADS

ret = SQLDescribeCol(cur->hstmt, (SQLUSMALLINT)(i + 1), name, _countof(name), 0, &nDataType, &nColSize, &cDecimalDigits, &nullable);

Py_END_ALLOW_THREADS

if (cur->cnxn->hdbc == SQL_NULL_HANDLE)

{

// The connection was closed by another thread in the ALLOW_THREADS block above.

RaiseErrorV(0, ProgrammingError, "The cursor's connection was closed.");

goto done;

}

if (!SQL_SUCCEEDED(ret))

{

RaiseErrorFromHandle("SQLDescribeCol", cur->cnxn->hdbc, cur->hstmt);

goto done;

}

TRACE("Col %d: type=%d colsize=%d\n", (i+1), (int)nDataType, (int)nColSize);

if (lower)

_strlwr((char*)name);

type = PythonTypeFromSqlType(cur, name, nDataType);

if (!type)

goto done;

switch (nullable)

{

case SQL_NO_NULLS:

nullable_obj = Py_False;

break;

case SQL_NULLABLE:

nullable_obj = Py_True;

break;

case SQL_NULLABLE_UNKNOWN:

default:

nullable_obj = Py_None;

break;

}

// The Oracle ODBC driver has a bug (I call it) that it returns a data size of 0 when a numeric value is

// retrieved from a UNION: http://support.microsoft.com/?scid=kb%3Ben-us%3B236786&x=13&y=6

//

// Unfortunately, I don't have a test system for this yet, so I'm *trying* something. (Not a good sign.) If

// the size is zero and it appears to be a numeric type, we'll try to come up with our own length using any

// other data we can get.

if (nColSize == 0 && IsNumericType(nDataType))

{

// I'm not sure how

if (cDecimalDigits != 0)

{

nColSize = (SQLUINTEGER)(cDecimalDigits + 3);

}

else

{

// I'm not sure if this is a good idea, but ...

nColSize = 42;

}

}

colinfo = Py_BuildValue("(sOOiiiO)",

(char*)name,

type, // type_code

Py_None, // display size

(int)nColSize, // internal_size

(int)nColSize, // precision

(int)cDecimalDigits, // scale

nullable_obj); // null_ok

if (!colinfo)

goto done;

nullable_obj = 0;

index = PyInt_FromLong(i);

if (!index)

goto done;

PyDict_SetItemString(colmap, (const char*)name, index);

Py_DECREF(index); // SetItemString increments

index = 0;

PyTuple_SET_ITEM(desc, i, colinfo);

colinfo = 0; // reference stolen by SET_ITEM

}

Py_XDECREF(cur->description);

cur->description = desc;

desc = 0;

cur->map_name_to_index = colmap;

colmap = 0;

success = true;

done:

Py_XDECREF(nullable_obj);

Py_XDECREF(desc);

Py_XDECREF(colmap);

Py_XDECREF(index);

Py_XDECREF(colinfo);

return success;

{

FREE_STATEMENT = 0x01,

KEEP_STATEMENT = 0x02,

FREE_PREPARED = 0x04,

KEEP_PREPARED = 0x08,

STATEMENT_MASK = 0x03,

PREPARED_MASK = 0x0C

{

// Internal function called any time we need to free the memory associated with query results. It is safe to call

// this even when a query has not been executed.

// If we ran out of memory, it is possible that we have a cursor but colinfos is zero. However, we should be

// deleting this object, so the cursor will be freed when the HSTMT is destroyed. */

I((flags & STATEMENT_MASK) != 0);

I((flags & PREPARED_MASK) != 0);

if ((flags & PREPARED_MASK) == FREE_PREPARED)

{

Py_XDECREF(self->pPreparedSQL);

self->pPreparedSQL = 0;

}

if (self->colinfos)

{

pyodbc_free(self->colinfos);

self->colinfos = 0;

}

if (StatementIsValid(self))

{

if ((flags & STATEMENT_MASK) == FREE_STATEMENT)

{

Py_BEGIN_ALLOW_THREADS

SQLFreeStmt(self->hstmt, SQL_CLOSE);

Py_END_ALLOW_THREADS;

}

else

{

Py_BEGIN_ALLOW_THREADS

SQLFreeStmt(self->hstmt, SQL_UNBIND);

SQLFreeStmt(self->hstmt, SQL_RESET_PARAMS);

Py_END_ALLOW_THREADS;

}

if (self->cnxn->hdbc == SQL_NULL_HANDLE)

{

// The connection was closed by another thread in the ALLOW_THREADS block above.

RaiseErrorV(0, ProgrammingError, "The cursor's connection was closed.");

return false;

}

}

if (self->description != Py_None)

{

Py_DECREF(self->description);

self->description = Py_None;

Py_INCREF(Py_None);

}

if (self->map_name_to_index)

{

Py_DECREF(self->map_name_to_index);

self->map_name_to_index = 0;

}

self->rowcount = -1;

return true;

{

// An internal function for the shared 'closing' code used by Cursor_close and Cursor_dealloc.

//

// This method releases the GIL lock while closing, so verify the HDBC still exists if you use it.

free_results(cur, FREE_STATEMENT | FREE_PREPARED);

FreeParameterInfo(cur);

FreeParameterData(cur);

if (StatementIsValid(cur))

{

HSTMT hstmt = cur->hstmt;

cur->hstmt = SQL_NULL_HANDLE;

SQLRETURN ret;

Py_BEGIN_ALLOW_THREADS

ret = SQLFreeHandle(SQL_HANDLE_STMT, hstmt);

Py_END_ALLOW_THREADS

// If there is already an exception, don't overwrite it.

if (!SQL_SUCCEEDED(ret) && !PyErr_Occurred())

RaiseErrorFromHandle("SQLFreeHandle", cur->cnxn->hdbc, SQL_NULL_HANDLE);

}

Py_XDECREF(cur->pPreparedSQL);

Py_XDECREF(cur->description);

Py_XDECREF(cur->map_name_to_index);

Py_XDECREF(cur->cnxn);

cur->pPreparedSQL = 0;

cur->description = 0;

cur->map_name_to_index = 0;

cur->cnxn = 0;

{

if (Cursor_Validate((PyObject*)cursor, CURSOR_REQUIRE_CNXN))

{

closeimpl(cursor);

}

PyObject_Del(cursor);

{

// Initializes ColumnInfo from result set metadata.

SQLRETURN ret;

// REVIEW: This line fails on OS/X with the FileMaker driver : http://www.filemaker.com/support/updaters/xdbc_odbc_mac.html

//

// I suspect the problem is that it doesn't allow NULLs in some of the parameters, so I'm going to supply them all

// to see what happens.

SQLCHAR ColumnName[200];

SQLSMALLINT BufferLength = _countof(ColumnName);

SQLSMALLINT NameLength = 0;

SQLSMALLINT DataType = 0;

SQLULEN ColumnSize = 0;

SQLSMALLINT DecimalDigits = 0;

SQLSMALLINT Nullable = 0;

Py_BEGIN_ALLOW_THREADS

ret = SQLDescribeCol(cursor->hstmt, iCol,

ColumnName,

BufferLength,

&NameLength,

&DataType,

&ColumnSize,

&DecimalDigits,

&Nullable);

Py_END_ALLOW_THREADS

pinfo->sql_type = DataType;

pinfo->column_size = ColumnSize;

if (cursor->cnxn->hdbc == SQL_NULL_HANDLE)

{

// The connection was closed by another thread in the ALLOW_THREADS block above.

RaiseErrorV(0, ProgrammingError, "The cursor's connection was closed.");

return false;

}

if (!SQL_SUCCEEDED(ret))

{

RaiseErrorFromHandle("SQLDescribeCol", cursor->cnxn->hdbc, cursor->hstmt);

return false;

}

// If it is an integer type, determine if it is signed or unsigned. The buffer size is the same but we'll need to

// know when we convert to a Python integer.

switch (pinfo->sql_type)

{

case SQL_TINYINT:

case SQL_SMALLINT:

case SQL_INTEGER:

case SQL_BIGINT:

{

SQLLEN f;

Py_BEGIN_ALLOW_THREADS

ret = SQLColAttribute(cursor->hstmt, iCol, SQL_DESC_UNSIGNED, 0, 0, 0, &f);

Py_END_ALLOW_THREADS

if (cursor->cnxn->hdbc == SQL_NULL_HANDLE)

{

// The connection was closed by another thread in the ALLOW_THREADS block above.

RaiseErrorV(0, ProgrammingError, "The cursor's connection was closed.");

return false;

}

if (!SQL_SUCCEEDED(ret))

{

RaiseErrorFromHandle("SQLColAttribute", cursor->cnxn->hdbc, cursor->hstmt);

return false;

}

pinfo->is_unsigned = (f == SQL_TRUE);

break;

}

default:

pinfo->is_unsigned = false;

}

return true;

{

// Called after a SELECT has been executed to perform pre-fetch work.

//

// Allocates the ColumnInfo structures describing the returned data.

int i;

I(cur->colinfos == 0);

cur->colinfos = (ColumnInfo*)pyodbc_malloc(sizeof(ColumnInfo) * cCols);

if (cur->colinfos == 0)

{

PyErr_NoMemory();

return false;

}

for (i = 0; i < cCols; i++)

{

if (!InitColumnInfo(cur, (SQLUSMALLINT)(i + 1), &cur->colinfos[i]))

{

pyodbc_free(cur->colinfos);

cur->colinfos = 0;

return false;

}

}

return true;

{

const char* p = PyByteArray_AS_STRING(pParam);

SQLLEN offset = 0;

SQLLEN cb = (SQLLEN)PyByteArray_GET_SIZE(pParam);

while (offset < cb)

{

SQLLEN remaining = min(cur->cnxn->varchar_maxlength, cb - offset);

TRACE("SQLPutData [%d] (%d) %s\n", offset, remaining, &p[offset]);

Py_BEGIN_ALLOW_THREADS

ret = SQLPutData(cur->hstmt, (SQLPOINTER)&p[offset], remaining);

Py_END_ALLOW_THREADS

if (!SQL_SUCCEEDED(ret))

return RaiseErrorFromHandle("SQLPutData", cur->cnxn->hdbc, cur->hstmt);

offset += remaining;

}

{

// Buffers can have multiple segments, so we might need multiple writes. Looping through buffers isn't

// difficult, but we've wrapped it up in an iterator object to keep this loop simple.

BufferSegmentIterator it(pParam);

byte* pb;

SQLLEN cb;

while (it.Next(pb, cb))

{

Py_BEGIN_ALLOW_THREADS

ret = SQLPutData(cur->hstmt, pb, cb);

Py_END_ALLOW_THREADS

if (!SQL_SUCCEEDED(ret))

return RaiseErrorFromHandle("SQLPutData", cur->cnxn->hdbc, cur->hstmt);

}

{

// Used to determine if the first parameter of execute is a collection of SQL parameters or is a SQL parameter

// itself. If the first parameter is a list, tuple, or Row object, then we consider it a collection. Anything

// else, including other sequences (e.g. bytearray), are considered SQL parameters.

return PyList_Check(p) || PyTuple_Check(p) || Row_Check(p);