{

// This should have been checked by the global connect function.

I(PyString_Check(pConnectString) || PyUnicode_Check(pConnectString));

const int cchMax = 600;

if (PySequence_Length(pConnectString) >= cchMax)

{

PyErr_SetString(PyExc_TypeError, "connection string too long");

return false;

}

// The driver manager determines if the app is a Unicode app based on whether we call SQLDriverConnectA or

// SQLDriverConnectW. Some drivers, notably Microsoft Access/Jet, change their behavior based on this, so we try

// the Unicode version first. (The Access driver only supports Unicode text, but SQLDescribeCol returns SQL_CHAR

// instead of SQL_WCHAR if we connect with the ANSI version. Obviously this causes lots of errors since we believe

// what it tells us (SQL_CHAR).)

// Python supports only UCS-2 and UCS-4, so we shouldn't need to worry about receiving surrogate pairs. However,

// Windows does use UCS-16, so it is possible something would be misinterpreted as one. We may need to examine

// this more.

SQLRETURN ret;

if (timeout > 0)

{

Py_BEGIN_ALLOW_THREADS

ret = SQLSetConnectAttr(hdbc, SQL_ATTR_LOGIN_TIMEOUT, (SQLPOINTER)timeout, SQL_IS_UINTEGER);

Py_END_ALLOW_THREADS

if (!SQL_SUCCEEDED(ret))

RaiseErrorFromHandle("SQLSetConnectAttr(SQL_ATTR_LOGIN_TIMEOUT)", hdbc, SQL_NULL_HANDLE);

}

if (!fAnsi)

{

SQLWChar connectString(pConnectString);

Py_BEGIN_ALLOW_THREADS

ret = SQLDriverConnectW(hdbc, 0, connectString.get(), (SQLSMALLINT)connectString.size(), 0, 0, 0, SQL_DRIVER_NOPROMPT);

Py_END_ALLOW_THREADS

if (SQL_SUCCEEDED(ret))

return true;

// The Unicode function failed. If the error is that the driver doesn't have a Unicode version (IM001), continue

// to the ANSI version.

//

// I've commented this out since a number of common drivers are returning different errors. The MySQL 5

// driver, for example, returns IM002 "Data source name not found...".

//

// PyObject* error = GetErrorFromHandle("SQLDriverConnectW", hdbc, SQL_NULL_HANDLE);

// if (!HasSqlState(error, "IM001"))

// {

// RaiseErrorFromException(error);

// return false;

// }

// Py_XDECREF(error);

}

SQLCHAR szConnect[cchMax];

if (PyUnicode_Check(pConnectString))

{

Py_UNICODE* p = PyUnicode_AS_UNICODE(pConnectString);

for (Py_ssize_t i = 0, c = PyUnicode_GET_SIZE(pConnectString); i <= c; i++)

{

if (p[i] > 0xFF)

{

PyErr_SetString(PyExc_TypeError, "A Unicode connection string was supplied but the driver does "

"not have a Unicode connect function");

return false;

}

szConnect[i] = (SQLCHAR)p[i];

}

}

else

{

#if PY_MAJOR_VERSION < 3

const char* p = PyString_AS_STRING(pConnectString);

memcpy(szConnect, p, (size_t)(PyString_GET_SIZE(pConnectString) + 1));

#else

PyErr_SetString(PyExc_TypeError, "Connection strings must be Unicode");

return false;

#endif

}

Py_BEGIN_ALLOW_THREADS

ret = SQLDriverConnect(hdbc, 0, szConnect, SQL_NTS, 0, 0, 0, SQL_DRIVER_NOPROMPT);

Py_END_ALLOW_THREADS

if (SQL_SUCCEEDED(ret))

return true;

RaiseErrorFromHandle("SQLDriverConnect", hdbc, SQL_NULL_HANDLE);

return false;

{

if (cnxn->conv_count != 0)

{

pyodbc_free(cnxn->conv_types);

cnxn->conv_types = 0;

for (int i = 0; i < cnxn->conv_count; i++)

Py_XDECREF(cnxn->conv_funcs[i]);

pyodbc_free(cnxn->conv_funcs);

cnxn->conv_funcs = 0;

cnxn->conv_count = 0;

}

{

// Internal method for closing the connection. (Not called close so it isn't confused with the external close

// method.)

Connection* cnxn = (Connection*)self;

if (cnxn->hdbc != SQL_NULL_HANDLE)

{

// REVIEW: Release threads? (But make sure you zero out hdbc *first*!

TRACE("cnxn.clear cnxn=%p hdbc=%d\n", cnxn, cnxn->hdbc);

Py_BEGIN_ALLOW_THREADS

if (cnxn->nAutoCommit == SQL_AUTOCOMMIT_OFF)

SQLEndTran(SQL_HANDLE_DBC, cnxn->hdbc, SQL_ROLLBACK);

SQLDisconnect(cnxn->hdbc);

SQLFreeHandle(SQL_HANDLE_DBC, cnxn->hdbc);

Py_END_ALLOW_THREADS

cnxn->hdbc = SQL_NULL_HANDLE;

}

Py_XDECREF(cnxn->searchescape);

cnxn->searchescape = 0;

_clear_conv(cnxn);

return 0;

{

Connection_clear(self);

PyObject_Del(self);

{

SQLUSMALLINT infotype;

int datatype; // GI_XXX

{

UNUSED(closure);

Connection* cnxn = Connection_Validate(self);

if (!cnxn)

return -1;

if (value == 0)

{

PyErr_SetString(PyExc_TypeError, "Cannot delete the autocommit attribute.");

return -1;

}

uintptr_t nAutoCommit = PyObject_IsTrue(value) ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF;

SQLRETURN ret;

Py_BEGIN_ALLOW_THREADS

ret = SQLSetConnectAttr(cnxn->hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)nAutoCommit, SQL_IS_UINTEGER);

Py_END_ALLOW_THREADS

if (!SQL_SUCCEEDED(ret))

{

RaiseErrorFromHandle("SQLSetConnectAttr", cnxn->hdbc, SQL_NULL_HANDLE);

return -1;

}

cnxn->nAutoCommit = nAutoCommit;

return 0;

{

UNUSED(closure);

Connection* cnxn = Connection_Validate(self);

if (!cnxn)

return -1;

if (value == 0)

{

PyErr_SetString(PyExc_TypeError, "Cannot delete the timeout attribute.");

return -1;

}

long timeout = PyInt_AsLong(value);

if (timeout == -1 && PyErr_Occurred())

return -1;

if (timeout < 0)

{

PyErr_SetString(PyExc_ValueError, "Cannot set a negative timeout.");

return -1;

}

SQLRETURN ret;

Py_BEGIN_ALLOW_THREADS

ret = SQLSetConnectAttr(cnxn->hdbc, SQL_ATTR_CONNECTION_TIMEOUT, (SQLPOINTER)timeout, SQL_IS_UINTEGER);

Py_END_ALLOW_THREADS

if (!SQL_SUCCEEDED(ret))

{

RaiseErrorFromHandle("SQLSetConnectAttr", cnxn->hdbc, SQL_NULL_HANDLE);

return -1;

}

cnxn->timeout = timeout;

return 0;

{

Connection* cnxn = (Connection*)self;

if (cnxn->conv_count)

{

// If the sqltype is already registered, replace the old conversion function with the new.

for (int i = 0; i < cnxn->conv_count; i++)

{

if (cnxn->conv_types[i] == sqltype)

{

Py_XDECREF(cnxn->conv_funcs[i]);

cnxn->conv_funcs[i] = func;

Py_INCREF(func);

return true;

}

}

}

int oldcount = cnxn->conv_count;

SQLSMALLINT* oldtypes = cnxn->conv_types;

PyObject** oldfuncs = cnxn->conv_funcs;

int newcount = oldcount + 1;

SQLSMALLINT* newtypes = (SQLSMALLINT*)pyodbc_malloc(sizeof(SQLSMALLINT) * newcount);

PyObject** newfuncs = (PyObject**)pyodbc_malloc(sizeof(PyObject*) * newcount);

if (newtypes == 0 || newfuncs == 0)

{

if (newtypes)

pyodbc_free(newtypes);

if (newfuncs)

pyodbc_free(newfuncs);

PyErr_NoMemory();

return false;

}

newtypes[0] = sqltype;

newfuncs[0] = func;

Py_INCREF(func);

cnxn->conv_count = newcount;

cnxn->conv_types = newtypes;

cnxn->conv_funcs = newfuncs;

if (oldcount != 0)

{

// copy old items

memcpy(&newtypes[1], oldtypes, sizeof(int) * oldcount);

memcpy(&newfuncs[1], oldfuncs, sizeof(PyObject*) * oldcount);

pyodbc_free(oldtypes);

pyodbc_free(oldfuncs);

}

return true;