// Copyright © 2014 CCP ehf.

#include "SqlCommand.h"

#include "PythonBuff.h"

#include "Utils.h"

using Utilities::DbExc_RuntimeError;

#include "NSession.h"

//--------------------------------------------------------------------

// SQLCommand::Prepare: Make the command ready

//--------------------------------------------------------------------

bool SQLCommand::Prepare(size_t &paramLen, CSession *session, PyObject *schema, PyObject* args)

{

AUTOTASKLETC("DB::SQLCommand::Prepare", mNSession->mTimerDetail >= 2);

HRESULT hr;

char* procname;

PyObject* parameters;

PyObject* procParamSchema;

SetBlobHandling(DBBLOBHANDLING_NOSTREAMS);

if (!PyArg_ParseTuple(args, "sO:Execute", &procname, &parameters))

return false;

if (!PyList_Check(parameters) && !PyDict_Check(parameters)) {

PyErr_SetString(PyExc_TypeError, "Second argument must be a list or dictionary");

return false;

}

PyObject* procSchema = PyTuple_GET_ITEM(schema, 0);

procParamSchema = PyDict_GetItemString(procSchema, procname);

if (procParamSchema == NULL || strcmp(procname, "__schemas") == 0)

return PyErr_Format(DbExc_RuntimeError, "Stored procedure '%s' not found", procname), false;

CString csSQL;

if (!SelectProcedure(csSQL, procname, procParamSchema))

return false;

hr = Create(*session, csSQL, DBGUID_SQL);

if (FAILED(hr))

return Utilities::SetErr32(hr, "Couldn't create command for %s", procname), false;

//Bind parameters, using the custom bind thing. Note, this is like this in

//the atl samples.

void* pDummy;

hr = BindParameters( &(m_hParameterAccessor), m_spCommand, procParamSchema, &pDummy, true, true, parameters);

if (FAILED(hr))

return Utilities::SetErr32(hr, "Couldn't bind parameters for %s", csSQL), false;

// Now let's put in the parameters

if (!SetDefaultParams())

return false;

if (PyList_Check(parameters))

{

if (!SetParamsFromList(paramLen, parameters))

return false;

} else {

if (!SetParamsFromDict(paramLen, parameters))

return false;

}

return true;

}

bool SQLCommand::SelectProcedure(CString &csSQL, const char *procname, PyObject *procParamSchema)

{

// It's a stored proc call

Py_ssize_t numargs = PyList_GET_SIZE(procParamSchema);

if (numargs == 1) {

csSQL.Format("{ ? = CALL %s;1 }", procname);

} else {

CString csParams = "?";

for (Py_ssize_t i = 2; i<numargs; i++)

csParams += ",?";

csSQL.Format("{ ? = CALL %s;1(%s) }", procname, csParams);

}

return true;

}

//This dude returns parameter info from the already cached schema.

//Similar to the ICommandWithParameters::GetParameterInfo

//but without a server roundtrip.

HRESULT SQLCommand::GetParameterInfo (

DB_UPARAMS *pcParams,

DBPARAMINFO **prgParamInfo,

OLECHAR **ppNamesBuffer,

PyObject *procParamSchema)

{

// Create some binding sjite

Py_ssize_t size = PyList_GET_SIZE(procParamSchema);

DB_UPARAMS cols = Py_SAFE_DOWNCAST(size, Py_ssize_t, DB_UPARAMS);

DBPARAMINFO* pinfo = (DBPARAMINFO*)CoTaskMemAlloc(cols * sizeof(DBPARAMINFO));

if (!pinfo)

return E_OUTOFMEMORY;

size_t namesize = 0;

DB_UPARAMS i;

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

{

PyObject* colinfo = PyList_GET_ITEM(procParamSchema, i);

CMiniProcParamsInfo* info =

(CMiniProcParamsInfo*)PyCapsule_GetPointer(

PyList_GET_ITEM(colinfo,6),

"CMiniProcParamsInfo");

// Calculate total size of name buffer

namesize += strlen(info->m_szParameterName)+1;

// Set the parameter characteristic flags

switch(info->m_nType){

case DBPARAMTYPE_INPUT:

pinfo[i].dwFlags = DBPARAMFLAGS_ISINPUT; break;

case DBPARAMTYPE_INPUTOUTPUT:

pinfo[i].dwFlags = DBPARAMFLAGS_ISINPUT | DBPARAMFLAGS_ISOUTPUT; break;

case DBPARAMTYPE_OUTPUT:

case DBPARAMTYPE_RETURNVALUE:

pinfo[i].dwFlags = DBPARAMFLAGS_ISOUTPUT; break;

default:

CCP_ASSERT(0);

}

if (info->m_bIsNullable)

pinfo[i].dwFlags |= DBPARAMFLAGS_ISNULLABLE;

if (info->m_nMaxLength > 8192)

pinfo[i].dwFlags |= DBPARAMFLAGS_ISLONG;

// Set the ordinal, starting with 1

pinfo[i].iOrdinal = i+1;

//temporarily store the pointer here. translate and modify later

pinfo[i].pwszName = (LPOLESTR)info->m_szParameterName;

// There's no type info

pinfo[i].pTypeInfo = NULL;

pinfo[i].ulParamSize =

info->m_nMaxLength ? info->m_nMaxLength : Utilities::GetSizeofDBType(info->m_nDataType);

pinfo[i].wType = info->m_nDataType;

pinfo[i].bPrecision = (BYTE)info->m_nPrecision;

pinfo[i].bScale = (BYTE)info->m_nScale;

}

// Build the names

LPOLESTR pnames = (LPOLESTR)CoTaskMemAlloc(namesize * sizeof(wchar_t));

if (!pnames) {

CoTaskMemFree(pinfo);

return E_OUTOFMEMORY;

}

LPOLESTR ix = pnames;

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

{

const char *pName = (const char*)pinfo[i].pwszName;

CA2W pNameOLE(pName);

wcscpy_s(ix, namesize, pNameOLE);

pinfo[i].pwszName = ix;

size_t l = wcslen(ix)+1;

ix += l;

namesize -= l;

}

*pcParams = cols;

*prgParamInfo = pinfo;

*ppNamesBuffer = pnames;

return S_OK;

}

// This is cut and pasted from atldbcli.h, line 4974. Exactly the same as there, but

// uses the function above to get the paraminfo.

HRESULT SQLCommand::BindParameters(HACCESSOR* pHAccessor, ICommand* pCommand, PyObject *procParamScema,

void** ppParameterBuffer, bool fBindLength, bool fBindStatus, PyObject *params) throw()

{

// If we have already bound the parameters then just return

// the pointer to the parameter buffer

if (*pHAccessor != NULL)

{

*ppParameterBuffer = m_pParameterBuffer;

return S_OK;

}

CComPtr<IAccessor> spAccessor;

ATLASSERT(pCommand != NULL);

HRESULT hr = pCommand->QueryInterface(&spAccessor);

if (FAILED(hr))

return hr;

// This is our new hack. CCPmodification.

DB_UPARAMS ulParams = 0;

CComHeapPtr<DBPARAMINFO> spParamInfo;

LPOLESTR pNamesBuffer;

// Get Parameter Information

hr = GetParameterInfo(&ulParams, &spParamInfo, &pNamesBuffer, procParamScema);

if (FAILED(hr))

return hr;

//CCPMOdification ends here.

// Create the parameter information for binding

hr = AllocateParameterInfo(ulParams);

if (FAILED(hr))

{

CoTaskMemFree(pNamesBuffer);

return hr;

}

DBBYTEOFFSET nOffset = 0;

DBBYTEOFFSET nDataOffset = 0;

DBBYTEOFFSET nLengthOffset = 0;

DBBYTEOFFSET nStatusOffset = 0;

DBBINDING* pCurrent = m_pParameterEntry;

for (ULONG l=0; l<ulParams; l++)

{

m_pParameterEntry[l].eParamIO = 0;

if (spParamInfo[l].dwFlags & DBPARAMFLAGS_ISINPUT)

m_pParameterEntry[l].eParamIO |= DBPARAMIO_INPUT;

if (spParamInfo[l].dwFlags & DBPARAMFLAGS_ISOUTPUT)

m_pParameterEntry[l].eParamIO |= DBPARAMIO_OUTPUT;

//CCP modification: Handle long data in input

DBOBJECT* dbo = NULL;

if (spParamInfo[l].dwFlags & DBPARAMFLAGS_ISLONG) {

SSIZE_T size = GetStringSize(&spParamInfo[l], params);

if (size < 0) {

spParamInfo[l].ulParamSize = 0; //no data

} else if (size>=0 && (size_t)size <= m_nBlobSize) {

//we just pack it in there.

spParamInfo[l].ulParamSize = Py_SAFE_DOWNCAST(size, SSIZE_T, DBLENGTH);

} else {

//we must pass this large parameter as a blob (CCP addition, blobs weren't supported)

spParamInfo[l].wType = DBTYPE_IUNKNOWN;

spParamInfo[l].ulParamSize = sizeof(void*);

dbo = new DBOBJECT;

if (!dbo) {

if (l == 0)

//otherwise, the pointer has been placed in there correctly

CoTaskMemFree(pNamesBuffer);

return E_OUTOFMEMORY;

}

m_pParameterEntry[l].pObject = dbo;

dbo->dwFlags = STGM_READ;

dbo->iid = IID_ISequentialStream;

}

}

// if this is a BLOB, truncate column length to m_nBlobSize (like 8000 bytes)

if( spParamInfo[l].ulParamSize > m_nBlobSize )

spParamInfo[l].ulParamSize = m_nBlobSize;

// if this is a string, recalculate column size in bytes

DBLENGTH colLength = spParamInfo[l].ulParamSize;

if (spParamInfo[l].wType == DBTYPE_STR)

colLength += 1;

if (spParamInfo[l].wType == DBTYPE_WSTR)

colLength = colLength*2 + 2;

// Calculate the column data offset

nDataOffset = AlignAndIncrementOffset( nOffset, colLength, GetAlignment( spParamInfo[l].wType ) );

if( fBindLength )

{

// Calculate the column length offset

nLengthOffset = AlignAndIncrementOffset( nOffset, sizeof(DBLENGTH), __alignof(DBLENGTH) );

}

if( fBindStatus )

{

// Calculate the column status offset

nStatusOffset = AlignAndIncrementOffset( nOffset, sizeof(DBSTATUS), __alignof(DBSTATUS) );

}

//CCP modification too

CDynamicParameterAccessor::Bind(pCurrent, spParamInfo[l].iOrdinal, spParamInfo[l].wType,

colLength, spParamInfo[l].bPrecision, spParamInfo[l].bScale,

m_pParameterEntry[l].eParamIO, nDataOffset, nLengthOffset, nStatusOffset,

dbo);

pCurrent++;

m_ppParamName[l] = pNamesBuffer;

if (pNamesBuffer && *pNamesBuffer)

{

// Search for the NULL termination character

while (*pNamesBuffer++)

;

}

}

// Allocate memory for the new buffer

m_pParameterBuffer = NULL;

ATLTRY(m_pParameterBuffer = new BYTE[nOffset]);

if (m_pParameterBuffer == NULL)

{

// Note that pNamesBuffer will be freed in the destructor

// by freeing *m_ppParamName

return E_OUTOFMEMORY;

}

*ppParameterBuffer = m_pParameterBuffer;

m_nParameterBufferSize = nOffset;

m_nParams = ulParams;

hr = BindEntries(m_pParameterEntry, ulParams, pHAccessor, nOffset, spAccessor);

return hr;

}

//This function gets the size of a parameter blob

SSIZE_T SQLCommand::GetStringSize(DBPARAMINFO *info, PyObject *params)

{

BluePy object;

if (!params)

return -1;

if (PyList_Check(params))

object = BluePy(PyList_GetItem(params, (info->iOrdinal-2)), true); //weird, ordinals start at 2

else

object = BluePy(PyDict_GetItemString(params, CW2A(info->pwszName)), true);

if (!object) {

PyErr_Clear();

return -1;

}

if( PyUnicode_Check( object.o ) )

return PyUnicode_GET_LENGTH( object.o ); //return number of wide chars

if( object.o->ob_type->tp_as_buffer )

{

if( !PyObject_CheckBuffer( object.o ) )

{

PyErr_SetString( PyExc_TypeError, "Object must have a buffer interface." );

return -1;

}

Py_buffer view;

if( PyObject_GetBuffer( object.o, &view, 0 ) != 0 )

{

PyErr_SetString( PyExc_TypeError, "Object must have a buffer interface." );

return -1;

}

if( !PyBuffer_IsContiguous( &view, 'A' ) )

{

PyBuffer_Release( &view );

PyErr_SetString( PyExc_TypeError, "Object buffer must be contiguous." );

return -1;

}

SSIZE_T bufferLength = view.len;

PyBuffer_Release( &view );

return bufferLength;

}

return -1;

}

// Set return value to OK

bool SQLCommand::SetDefaultParams()

{

if (!SetParamStatus(1, DBSTATUS_S_OK))

return PyErr_SetString(DbExc_RuntimeError, "Couldn't set param status for return column"), false;

// Set all other parameters to default

DB_UPARAMS n = GetParamCount();

for (DBORDINAL i = 1; i < n; i++)

if (!SetParamStatus(i+1, DBSTATUS_S_DEFAULT)) {

PyErr_Format(DbExc_RuntimeError, "Couldn't set param status for column %d:%s to DBSTATUS_S_DEFAULT",

i, (const char*)CW2A(GetParamName(i+1)));

return false;

}

return true;

}

bool SQLCommand::SetParamsFromList(size_t &paramLen, PyObject *plist)

{

if (PyList_GET_SIZE(plist) > (Py_ssize_t)(GetParamCount()-1)) {

PyErr_Format(DbExc_RuntimeError,

"The stored procedure accepts at most %d argument(s), not %d",

GetParamCount()-1, PyList_GET_SIZE(plist));

return false;

}

paramLen = 0;

for (int i = 0; i < PyList_GET_SIZE(plist); i++)

{

size_t len;

if (!SetPyParam(len, i+2, PyList_GET_ITEM(plist, i)))

return false;

paramLen += len;

}

return true;

}

bool SQLCommand::SetParamsFromDict(size_t &paramLen, PyObject *pdict)

{

// Key/value arguments

Py_ssize_t j = 0;

PyObject* key;

PyObject* value;

paramLen = 0;

while (PyDict_Next(pdict, &j, &key, &value))

{

BluePyStr pyname(BluePy(PyObject_Str(key)));

// Look for the field

DBORDINAL col;

if (!_GetParameterNo(CA2T(pyname.Str()), col))

{

return PyErr_Format( DbExc_RuntimeError,"%s has no argument '%s'.", "", pyname.Str()), false;

}

size_t len;

if (!SetPyParam(len, col+1, value))

return false;

paramLen += len;

}

return true;

}

//Set an integer parameter

template<class T>

bool SQLCommand::SetPyParamInt(size_t &len, DBORDINAL col, PyObject *value)

{

if( !PyLong_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a long", col - 1, (const char*)CW2A( GetParamName( col ) ) ), false;

}

long long l = PyLong_AsLongLong( value );

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

return false;

T v = (T)l;

if (v != l) {

PyErr_Format(DbExc_RuntimeError, "Argument %d(%s) out of range:%lld", col, (const char*)CW2A(GetParamName(col)), l);

return false;

}

SetParam(col, &v);

len = sizeof(T);

return true;

}

bool SQLCommand::SetPyParam(size_t &paramLen, DBORDINAL nparam, PyObject *value)

{

//first, if we have a pynone, set the paramstatus

if (value == Py_None) {

SetParamStatus(nparam, DBSTATUS_S_ISNULL);

paramLen = 0;

return true;

}

DBTYPE type;

GetParamType(nparam, &type);

switch (type) {

case DBTYPE_BOOL: {

int res = PyObject_IsTrue( value );

if(res == -1)

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must evaluate to a boolean", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

VARIANT_BOOL p = res ? VARIANT_TRUE : VARIANT_FALSE;

SetParam(nparam, &p);

paramLen = 1;

return true; }

case DBTYPE_I1:

return SetPyParamInt<signed char>(paramLen, nparam, value);

case DBTYPE_UI1:

return SetPyParamInt<unsigned char>(paramLen, nparam, value);

case DBTYPE_I2:

return SetPyParamInt<signed short>(paramLen, nparam, value);

case DBTYPE_UI2:

return SetPyParamInt<unsigned short>(paramLen, nparam, value);

case DBTYPE_I4:

return SetPyParamInt<signed long>(paramLen, nparam, value);

case DBTYPE_UI4: {

//NOTE: This type is slightly broken. The value here should be an unsigned long

//Issue has always been present and is also reflected in Blue PyRowSet

if( !PyLong_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a long", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

long l = PyLong_AsLong( value );

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

return PyErr_Format( DbExc_RuntimeError, "Failed to convert argument %d(%s) to long.", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

SetParam( nparam, &l );

paramLen = sizeof( long );

return true;

}

case DBTYPE_I8:

case DBTYPE_FILETIME:{

if( !PyLong_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a long", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

signed __int64 ll = PyLong_AsLongLong(value);

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

return PyErr_Format( DbExc_RuntimeError, "Failed to convert argument %d(%s) to long long.", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

SetParam(nparam, &ll);

paramLen = sizeof(ll);

return true;}

case DBTYPE_UI8: {

if( !PyLong_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a long", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

unsigned __int64 ll = PyLong_AsUnsignedLongLong(value);

if (ll == (unsigned __int64)-1 && PyErr_Occurred())

return PyErr_Format( DbExc_RuntimeError, "Failed to convert argument %d(%s) to unsigned long long.", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

SetParam(nparam, &ll);

paramLen = sizeof(ll);

return true;}

case DBTYPE_R4: {

if( !PyFloat_Check( value ) && !PyLong_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a number", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

float rr = (float)PyFloat_AsDouble(value);

if (rr == -1.0f && PyErr_Occurred())

return false;

SetParam(nparam, &rr);

paramLen = sizeof(rr);

return true;}

case DBTYPE_R8: {

if( !PyFloat_Check( value ) && !PyLong_Check( value ))

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a number", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

double rr = PyFloat_AsDouble(value);

if (rr == -1.0 && PyErr_Occurred())

return false;

SetParam(nparam, &rr);

paramLen = sizeof(rr);

return true;}

case DBTYPE_CY: {

if( !PyFloat_Check( value ) && !PyLong_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a number", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

double dd = PyFloat_AsDouble(value);

if (dd == -1.0 && PyErr_Occurred())

return false;

__int64 rr = (__int64)(floor(dd * 100.0 + 0.5) * 100.0);

SetParam(nparam, &rr);

paramLen = sizeof(rr);

return true;}

case DBTYPE_STR: {

if( !PyUnicode_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be an ASCII string", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

//Convert using ASCII

PyObject* valueAsAscii = PyUnicode_AsASCIIString( value );

if( !valueAsAscii )

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be an ASCII string", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

const char* str = PyBytes_AsString( valueAsAscii );

if (!SetParamString(nparam, str)) {

Py_DecRef( valueAsAscii );

DBLENGTH max;

GetParamSize(nparam, &max);

return PyErr_Format(DbExc_RuntimeError, "Argument %d(%s) too long, can be at most %d chars", nparam-1, (const char*)CW2A(GetParamName(nparam)), max), false;

}

/* only the actual string data is sent, not the max column size. Verified using network packet sniffing */

paramLen = strlen(str); //this string is preallocated

Py_DecRef( valueAsAscii );

break;}

case DBTYPE_BSTR:

case DBTYPE_WSTR: {

if( !PyUnicode_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be UnicodeType", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

wchar_t* str = PyUnicode_AsWideCharString( value, nullptr );

if( !str )

{

return PyErr_Format( DbExc_RuntimeError, "Failed to get wchar from unicode argument %d(%s)", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

if (!SetParamString(nparam, str)) {

DBLENGTH max;

GetParamSize(nparam, &max);

PyMem_Free( str );

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) too long, can be at most %d chars", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ), max / 2 ), false;

}

paramLen = wcslen(str) * sizeof(wchar_t);

PyMem_Free( str );

break;}

case DBTYPE_BYTES: {

if( !PyObject_CheckBuffer( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must have buffer interface", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

Py_buffer view;

if( PyObject_GetBuffer( value, &view, 0 ) != 0 )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must have buffer interface", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

if( !PyBuffer_IsContiguous( &view, 'A' ) )

{

PyBuffer_Release( &view );

return PyErr_Format( PyExc_TypeError, "Buffer argument %d(%s) must be contiguous", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

DBLENGTH dblen;

GetParamSize( nparam, &dblen );

if( view.len > (Py_ssize_t)dblen )

{

PyBuffer_Release( &view );

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) BLOB too large. is %d, can be at most %d", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ), view.len, dblen ), false;

}

char* dest = (char*)GetParam( nparam );

memcpy( dest, view.buf, view.len );

SetParamLength( nparam, Py_SAFE_DOWNCAST( view.len, Py_ssize_t, DBLENGTH ) );

SetParamStatus( nparam, view.len ? DBSTATUS_S_OK : DBSTATUS_S_ISNULL );

paramLen = view.len;

PyBuffer_Release( &view );

break;

}

case DBTYPE_IUNKNOWN: {

PythonBuff *pbuff = new PythonBuff(value);

if (!pbuff)

return PyErr_NoMemory(), false;

if (pbuff->GetLength() == -1) {

delete pbuff;

return false;

}

if (!pbuff->Valid()) {

delete pbuff;

return PyErr_Format(DbExc_RuntimeError, "Argument %d(%s) must have buffer interface", nparam-1, (const char*)CW2A(GetParamName(nparam))), false;

}

IUnknown *iu = pbuff;

SetParam(nparam, &iu);

size_t bufflen = pbuff->GetLength();

SetParamLength(nparam, Py_SAFE_DOWNCAST(bufflen, size_t, DBLENGTH));

paramLen = bufflen;

break;}

case DBTYPE_DBTIMESTAMP:

case DBTYPE_DBDATE: {

if( !PyLong_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a long", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

__int64 filetime = PyLong_AsLongLong(value);

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

return false;

DBLENGTH dstlen;

HRESULT hr = mNSession->mConv->DataConvert(

DBTYPE_FILETIME, type,

sizeof(filetime), &dstlen,

&filetime, GetParam(nparam),

sizeof (DBTIMESTAMP),

DBSTATUS_S_OK, GetParamStatus(nparam),

0, 0,

DBDATACONVERT_DEFAULT);

if (FAILED(hr))

{

return Utilities::SetErr32( hr, "DataConvert failed" ), false;

}

paramLen = dstlen;

return true; }

case DBTYPE_DBTIME2: {

if( !PyLong_Check( value ) )

{

return PyErr_Format( DbExc_RuntimeError, "Argument %d(%s) must be a long", nparam - 1, (const char*)CW2A( GetParamName( nparam ) ) ), false;

}

__int64 filetime = PyLong_AsLongLong(value);

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

return false;

DBTIME2 time;

time.fraction = (ULONG)(filetime % 10000000) * 100;

filetime /= 10000000;

time.second = (USHORT)(filetime % 60);

filetime /= 60;

time.minute = (USHORT)(filetime % 60);

filetime /= 60;

time.hour = (USHORT)(filetime % 24);

SetParam(nparam, &time);

paramLen = sizeof(time);

break; }

default:

return PyErr_Format(DbExc_RuntimeError, "Argument %d(%s) unexpected DB type: %d", nparam-1, (const char*)CW2A(GetParamName(nparam)), type), false;

}

return true;

}

//--------------------------------------------------------------------

// SetErr32

//--------------------------------------------------------------------

PyObject* SQLCommand::Raise(const char *msg, HRESULT hr, const CDBErrorInfo *errorInfo, ULONG nErrors )

{

BluePy none(Py_None, true);

//get column errors

BluePy paramErrors, columnErrors;

if (!Utilities::ParamErrorsToPy(hr, *this, &paramErrors, &columnErrors))

return 0;

//Get Error Records

BluePy errorRecords(Utilities::ErrorRecToPy(errorInfo, nErrors));

if (!errorRecords)

return 0;

//Get the command

GUID sqlguid = DBGUID_SQL;

CComQIPtr<ICommandText> cmdtext(m_spCommand);

CComHeapPtr<OLECHAR> sql;

if (cmdtext)

cmdtext->GetCommandText(&sqlguid, &sql);

// Put everything together

BluePy errorArgs = BluePy(Py_BuildValue("isOuOO",

hr, msg, errorRecords,

sql?sql:(wchar_t*)L"", paramErrors, columnErrors));

if (!errorArgs)

return 0;

return PyErr_SetObject(Utilities::ErrorClass(hr), errorArgs), nullptr;

}