__declspec(dllexport) BOOL SoaronModuleFunc(void)
{
SQLHDBC hdbc;
HSTMT hstmt;
unsigned int NumOfLinks, LinkID;
WSADATA wd;
SQLRETURN sqlret;
HANDLE hHeap;
FTNAddr LinkAddr;
wchar_t Ip[256];
lpLinksCheckInfo LinksTable;
WSAEVENT * EventsTable;
WSANETWORKEVENTS evt;
unsigned int i, j;
int res;
ADDRINFOW *result = NULL;
ADDRINFOW hints;
wchar_t LogStr[255];
memset(&hints, 0, sizeof(hints));
LinkAddr.point = 0;
NumOfLinks = 0;
SQLAllocHandle(SQL_HANDLE_DBC, cfg.henv, &hdbc);
sqlret = SQLDriverConnectW(hdbc, NULL, cfg.ConnectionString, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT);
if (sqlret != SQL_SUCCESS && sqlret != SQL_SUCCESS_WITH_INFO)
{
SetEvent(cfg.hExitEvent); return FALSE;//fatal error
}
SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt);
AddLogEntry(L"Checking binkp links alive");
//get links info
SQLExecDirectW(hstmt, L"update Links set DialOut=0 where datediff(minute,LastSessionTime,GetDate())>40 and LinkType=1", SQL_NTS);
sqlret = SQLExecDirectW(hstmt, L"select count(*) from Links where dialout=0 and passivelink=0 and LinkType=1 and isnull(ip,'')<>''", SQL_NTS);
if ((sqlret == SQL_SUCCESS) || (sqlret = SQL_SUCCESS_WITH_INFO))
{
sqlret = SQLFetch(hstmt);
if ((sqlret == SQL_SUCCESS) || (sqlret = SQL_SUCCESS_WITH_INFO))
{
SQLGetData(hstmt, 1, SQL_C_ULONG, &NumOfLinks, 0, NULL);
}
}
SQLCloseCursor(hstmt);
if (NumOfLinks == 0) goto exit;
hHeap = HeapCreate(HEAP_NO_SERIALIZE, 8192, 0);
LinksTable = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, NumOfLinks*sizeof(LinksCheckInfo));
EventsTable = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, sizeof(WSAEVENT)*NumOfLinks);
i = 0;
hints.ai_family = AF_INET;
hints.ai_socktype = SOCK_STREAM;
hints.ai_protocol = IPPROTO_TCP;
WSAStartup(MAKEWORD(2, 2), &wd);
sqlret = SQLExecDirectW(hstmt, L"select LinkID,Zone,Net,Node, Ip from Links where dialout=0 and passivelink=0 and LinkType=1 and isnull(ip,'')<>''", SQL_NTS);
if ((sqlret == SQL_SUCCESS) || (sqlret = SQL_SUCCESS_WITH_INFO))
{
SQLBindCol(hstmt, 1, SQL_C_ULONG, &LinkID, 0, NULL);
SQLBindCol(hstmt, 2, SQL_C_USHORT, &(LinkAddr.zone), 0, NULL);
SQLBindCol(hstmt, 3, SQL_C_USHORT, &(LinkAddr.net), 0, NULL);
SQLBindCol(hstmt, 4, SQL_C_USHORT, &(LinkAddr.node), 0, NULL);
SQLBindCol(hstmt, 5, SQL_C_WCHAR, Ip, 512, NULL);
sqlret = SQLFetch(hstmt);
while ((sqlret == SQL_SUCCESS) || (sqlret == SQL_SUCCESS_WITH_INFO))
{
//
res = GetAddrInfoW(Ip, L"24554", &hints, &result);
if (res == 0)
{
memcpy(&(LinksTable[i].sa), result->ai_addr, sizeof(struct sockaddr_in));
// printf("%u %u %S %u.%u.%u.%u\n", i,LinkID, Ip, LinksTable[i].sa.sin_addr.S_un.S_un_b.s_b1, LinksTable[i].sa.sin_addr.S_un.S_un_b.s_b2, LinksTable[i].sa.sin_addr.S_un.S_un_b.s_b3, LinksTable[i].sa.sin_addr.S_un.S_un_b.s_b4);
LinksTable[i].LinkID = LinkID;
LinksTable[i].LinkAddr.FullAddr = LinkAddr.FullAddr;
LinksTable[i].s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
EventsTable[i] = WSACreateEvent();
WSAEventSelect(LinksTable[i].s, EventsTable[i], FD_CONNECT);
FreeAddrInfoW(result);
++i;
}
else
{
wsprintfW(LogStr,L"%u:%u/%u: Ip address %s cannot be resolved", LinkAddr.zone, LinkAddr.net, LinkAddr.node,Ip);
AddLogEntry(LogStr);
}
sqlret = SQLFetch(hstmt);
}
}
SQLCloseCursor(hstmt);
SQLFreeStmt(hstmt, SQL_UNBIND);
NumOfLinks = i;
for (i = 0; i < NumOfLinks; i++)
{
connect(LinksTable[i].s, (struct sockaddr *)&(LinksTable[i].sa), sizeof(struct sockaddr_in));
}
j = 0;
SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &LinkID, 0, NULL);
SQLPrepareW(hstmt, L"Update Links set DialOut=1 where LinkID=?", SQL_NTS);
while (j < NumOfLinks)
{
res = WSAWaitForMultipleEvents(NumOfLinks, EventsTable, FALSE, WSA_INFINITE, FALSE);
WSAEnumNetworkEvents(LinksTable[res].s, EventsTable[res], &evt);
shutdown(LinksTable[res].s, SD_BOTH);
closesocket(LinksTable[res].s);
if (evt.iErrorCode[FD_CONNECT_BIT] == 0)
{
wsprintfW(LogStr, L"%u:%u/%u: OK", LinksTable[res].LinkAddr.zone, LinksTable[res].LinkAddr.net, LinksTable[res].LinkAddr.node);
LinkID = LinksTable[res].LinkID;
SQLExecute(hstmt);
}
else
{
switch (evt.iErrorCode[FD_CONNECT_BIT])
{
case WSAECONNREFUSED:
wsprintfW(LogStr, L"%u:%u/%u: Connection refused", LinksTable[res].LinkAddr.zone, LinksTable[res].LinkAddr.net, LinksTable[res].LinkAddr.node);
break;
case WSAETIMEDOUT:
wsprintfW(LogStr, L"%u:%u/%u: Connection timed out", LinksTable[res].LinkAddr.zone, LinksTable[res].LinkAddr.net, LinksTable[res].LinkAddr.node);
break;
default:wsprintfW(LogStr, L"%u:%u/%u: Unknown connection error", LinksTable[res].LinkAddr.zone, LinksTable[res].LinkAddr.net, LinksTable[res].LinkAddr.node);
}
}
AddLogEntry(LogStr);
++j;
}
//
for (j = 0; j < NumOfLinks; j++)
{
WSACloseEvent(EventsTable[j]);
}
SQLFreeStmt(hstmt, SQL_RESET_PARAMS);
//
WSACleanup();
HeapDestroy(hHeap);
exit:
SQLFreeHandle(SQL_HANDLE_STMT, hstmt);
SQLDisconnect(hdbc);
SQLFreeHandle(SQL_HANDLE_DBC, hdbc);
AddLogEntry(L"Links alive check done");
SetEvent(cfg.hLinksUpdateEvent);
return TRUE;
}
/*----------------------------------------------------------------------------------------------
Save data in the cache, to the database.
----------------------------------------------------------------------------------------------*/
STDMETHODIMP VwRsOdbcDa::Save(SqlDb & sdb)
{
BEGIN_COM_METHOD
const kcchErrMsgBuf = 1024;
const kcbFmtBufMax = 1024;
const kcchMaxColNameSize = 200;
SQLINTEGER cbColVal;
SDWORD cbClassName;
long cbHvo;
SDWORD cbFieldName;
SDWORD cbFlid;
int cbFmtBufSize = kcbFmtBufMax;
int cbFmtSpaceTaken;
SDWORD cbType;
SQLUSMALLINT cParamsProcessed = 0;
HRESULT hr;
FieldMetaDataMap fmdm; // REVIEW PaulP: Would be nice to have this kept globally.
FieldMetaDataRec fmdr;
int nColVal;
int nFlid;
ITsStringPtr qtssColVal;
RETCODE rc;
byte * rgbFmt = NewObj byte[kcbFmtBufMax]; //[kcbFmtBufMax];
SmartBstr sbstr;
SQLCHAR sqlchSqlState[5];
SQLCHAR sqlchMsgTxt[kcchErrMsgBuf];
SQLINTEGER sqlnNativeErrPtr;
SQLSMALLINT sqlnTextLength;
SQLRETURN sqlr;
SqlStatement sstmt;
StrUni suColumnName;
StrUni suFieldMetaDataSql;
StrUni suSql;
StrUni suTableName;
wchar wchClassName[kcchMaxColNameSize];
wchar wchFieldName[kcchMaxColNameSize];
Assert(sdb.IsOpen());
/*------------------------------------------------------------------------------------------
If a pointer to a HashMap of field$ metadata information was not passed in as a
parameter, create the HashMap. The metaData includes all field names, field types,
class names, and destination class name from the field$ and class$ tables.
This information is needed since only store the "flid" value is stored in the cache
(as the "tag") so when it comes time to do SQL "insert" and "update" statements,
one need's to know what table and column needs to be affected.
REVIEW PaulP: Should really cache this information globally so that it does not have
to be reloaded each time the view cache is saved. The only time this info would have
to be reloaded is when custom fields are added. Perhaps we could have a table with
a single record which indicates the last date/time a change to the database was made.
This could be compared with the currently loaded date each time the cache is saved to
see if there is a need to reload the field$ meta information. Of course, if we
require that only one user is allowed to be connected for a custom field addition,
this would not be necessary.
TOxDO PaulP: Cleanup on any error exit, including db rollback.
CheckSqlRc(SQLEndTran(SQL_HANDLE_DBC, sdb.Hdbc(), SQL_ROLLBACK));
------------------------------------------------------------------------------------------*/
try
{
// Set up SQL statment to obtain meta data.
suFieldMetaDataSql.Format(
L"select f.Id FLID, Type, f.Name FLD_NAME,"
L" c.Name CLS_NAME"
L" from Field$ f"
L" join Class$ c on c.id = f.Class"
L" order by f.id");
sstmt.Init(sdb);
CheckSqlRc(SQLExecDirectW(sstmt.Hstmt(), \
const_cast<wchar *>(suFieldMetaDataSql.Chars()), SQL_NTS));
// Bind Columns.
rc = SQLSetStmtAttr(sstmt.Hstmt(), SQL_ATTR_PARAMS_PROCESSED_PTR, &cParamsProcessed, 0);
CheckSqlRc(SQLBindCol(sstmt.Hstmt(), 1, SQL_C_SLONG, &nFlid, isizeof(int),
&cbFlid));
CheckSqlRc(SQLBindCol(sstmt.Hstmt(), 2, SQL_C_SLONG, &fmdr.m_iType,
isizeof(fmdr.m_iType), &cbType));
CheckSqlRc(SQLBindCol(sstmt.Hstmt(), 3, SQL_C_WCHAR, &wchFieldName,
kcchMaxColNameSize, &cbFieldName));
CheckSqlRc(SQLBindCol(sstmt.Hstmt(), 4, SQL_C_WCHAR, &wchClassName,
kcchMaxColNameSize, &cbClassName));
// Put info from the columns into a FieldMetaDataRec record and insert
// this in the FieldMetaData HashMap.
for (;;)
{
rc = SQLFetch(sstmt.Hstmt());
if (rc != SQL_SUCCESS)
break;
// TOxDO PaulP: Change this so it just gets a null terminated string!!!
fmdr.m_suFieldName.Assign(wchFieldName, kcchMaxColNameSize);
fmdr.m_suClassName.Assign(wchClassName, kcchMaxColNameSize);
fmdm.Insert(nFlid, fmdr);
}
if (rc != SQL_NO_DATA)
{
// REVIEW PaulP (SteveMc): Handle possible error message?
ThrowHr(WarnHr(E_UNEXPECTED));
}
sstmt.Clear();
}
catch (...)
{
sstmt.Clear();
delete rgbFmt;
return E_UNEXPECTED;
}
/*------------------------------------------------------------------------------------------
For every key in the "m_soprMods" ObjPropSet set (ie. all the object properties
that have been updated), look up that key in the appropriate HashMap and form an SQL
"update" statement according to the field$ "Type".
This begins a single database transaction. All the data in the application view cache
must either be inserted/updated to the database successfully or the action should fail.
This necessitates that the database connection is in manual-commit mode.
REVIEW PaulP: It is probably faster to collect all the properties for a given object
type and update the table in the database all with one SQL statement but this will
do for now until the OLE DB stuff is done.
------------------------------------------------------------------------------------------*/
try
{
ObjPropSet::iterator itops;
for (itops = m_soprMods.Begin(); itops != m_soprMods.End(); ++itops)
{
// Get the oprKey from the "update object property" Set.
ObjPropRec & oprKey = itops.GetValue();
// Get the field$ metadata information based on the tag of that oprKey.
fmdm.Retrieve(oprKey.m_tag, &fmdr);
// Initialize and form the SQL statment based on the field "type".
sstmt.Init(sdb);
switch (fmdr.m_iType)
{
case kcptNil:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptBoolean:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptInteger:
// Prepare the SQL statement. (Uses parameters).
suSql.Format(L"update %s set %s=? where id=?", fmdr.m_suClassName.Chars(),
fmdr.m_suFieldName.Chars());
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
// Get the integer value from the appropriate HashMap.
if (m_hmoprn.Retrieve(oprKey, &nColVal))
{
// Bind integer value as the first parameter.
if (nColVal)
{
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, 0, 0, &nColVal, 0, &cbColVal);
}
else
{
// REVIEW JohnT: How do we indicate in the HashMap that the user
// wants to set an integer to NULL?
cbColVal = SQL_NULL_DATA;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, 0, 0, NULL, 0, &cbColVal);
}
// Bind the HVO (Id) as the second parameter.
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT,
SQL_C_SLONG, SQL_INTEGER, 0, 0, &(oprKey.m_hvo), 0, &cbHvo);
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
break;
case kcptNumeric:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptFloat:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptTime:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptGuid:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptImage:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptGenDate:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptBinary:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptString:
case kcptBigString:
// Prepare the SQL statement. (Uses parameters.)
// REVIEW PaulP: Should I be hard-coding "_Fmt" in like this?
suSql.Format(L"update %s set %s=?, %s_Fmt=? where id=?",
fmdr.m_suClassName.Chars(), fmdr.m_suFieldName.Chars(),
fmdr.m_suFieldName.Chars());
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
if (m_hmoprtss.Retrieve(oprKey, qtssColVal))
{
// Obtain a SmartBstr from the COM smart pointer that points
// to the TsString.
CheckHr(qtssColVal->get_Text(&sbstr));
if (sbstr.Length())
{
// Copy format information of the TsString to byte array rgbFmt.
hr = qtssColVal->SerializeFmtRgb(rgbFmt, cbFmtBufSize,
&cbFmtSpaceTaken);
if (hr != S_OK)
{
if (hr == S_FALSE)
{
// If the supplied buffer is too small, try it again with
// the value that cbFmtSpaceTaken was set to. If this
// fails, throw error.
delete rgbFmt;
rgbFmt = NewObj byte[cbFmtSpaceTaken];
cbFmtBufSize = cbFmtSpaceTaken;
CheckHr(qtssColVal->SerializeFmtRgb(rgbFmt, cbFmtBufSize,
&cbFmtSpaceTaken));
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
}
// Bind the text and format parts of the string to the parameters.
SQLINTEGER cbTextPart = sbstr.Length() * 2;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, cbTextPart, 0,
const_cast<wchar *>(sbstr.Chars()), cbTextPart, &cbTextPart);
SQLINTEGER cbFmtPart = cbFmtSpaceTaken;
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT,
SQL_C_BINARY, SQL_VARBINARY, cbFmtPart, 0, rgbFmt, cbFmtPart,
&cbFmtPart);
}
else
{
// Since the string had no length, bind NULL to the parameters.
SQLINTEGER cbTextPart = SQL_NULL_DATA;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, 1, 0, NULL, 0, &cbTextPart);
// REVIEW PaulP: Should we set the Fmt info to NULL for NULL
// strings or should we use the Fmt info returned from the
// TsString?
SQLINTEGER cbFmtPart = SQL_NULL_DATA;
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT,
SQL_C_BINARY, SQL_VARBINARY, 1, 0, NULL, 0, &cbFmtPart);
}
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
// Bind the HVO (ie. Id) value.
rc = SQLBindParameter(sstmt.Hstmt(), 3, SQL_PARAM_INPUT, SQL_C_SLONG,
SQL_INTEGER, 0, 0, &(oprKey.m_hvo), 0, &cbHvo);
break;
case kcptBigUnicode:
case kcptUnicode:
// Prepare the SQL statement. (Uses parameters.)
suSql.Format(L"update %s set %s=? where id=?", fmdr.m_suClassName.Chars(),
fmdr.m_suFieldName.Chars());
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
if (m_hmoprtss.Retrieve(oprKey, qtssColVal))
{
// Obtain a SmartBstr from the COM smart pointer that
// points to a TsString.
CheckHr(qtssColVal->get_Text(&sbstr));
if (sbstr.Length())
{
// Bind the string parameter.
SQLINTEGER cbTextPart = sbstr.Length() * 2;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, cbTextPart, 0,
const_cast<wchar *>(sbstr.Chars()), cbTextPart, &cbTextPart);
}
else
{
// If the string had no length, bind NULL to the parameter.
SQLINTEGER cbTextPart = SQL_NULL_DATA;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, 1, 0, NULL, 0, &cbTextPart);
}
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
// Bind the HVO (ie. Id) value.
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT, SQL_C_SLONG,
SQL_INTEGER, 0, 0, &(oprKey.m_hvo), 0, &cbHvo);
break;
case kcptOwningAtom:
// Update owning field.
// Update Owner$ object of CmObject.
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptReferenceAtom:
// This is basically the same as the Integer case except we obtain the
// value from the m_hmoprobj HashMap rather than the m_hmoprn HashMap.
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptOwningCollection:
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptReferenceCollection:
// Affect the joiner table.
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptOwningSequence:
// Need to update.
ThrowHr(WarnHr(E_NOTIMPL));
break;
case kcptReferenceSequence:
// Affect the joiner table.
ThrowHr(WarnHr(E_NOTIMPL));
break;
default:
ThrowHr(WarnHr(E_UNEXPECTED));
break;
}
// Execute the SQL update command.
//rc = SQLSetStmtAttr(sstmt.Hstmt(), SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, 0);
rc = SQLExecute(sstmt.Hstmt());
if (rc == SQL_ERROR || rc == SQL_SUCCESS_WITH_INFO)
{
// TOxDO PaulP: Error information can be obtained from sqlchMsgTxt.
sqlr = SQLGetDiagRec(SQL_HANDLE_STMT, sstmt.Hstmt(), 1, sqlchSqlState,
&sqlnNativeErrPtr, sqlchMsgTxt, kcchErrMsgBuf, &sqlnTextLength);
ThrowHr(WarnHr(E_UNEXPECTED));
}
sstmt.Clear();
}
/*--------------------------------------------------------------------------------------
Go through the m_soperMods ObjPropSet set and update columns in the MultiX tables.
--------------------------------------------------------------------------------------*/
ObjPropEncSet::iterator itopes;
for (itopes = m_soperMods.Begin(); itopes != m_soperMods.End(); ++itopes)
{
// Get the operKey from the "update MSA" Set.
ObjPropEncRec & operKey = itopes.GetValue();
// Get the field$ metadata information based on the tag of that operKey.
fmdm.Retrieve(operKey.m_tag, &fmdr);
// Initialize and form the SQL statment.
sstmt.Init(sdb);
if (m_hmopertss.Retrieve(operKey, qtssColVal))
{
// Obtain a SmartBstr from the COM smart pointer that points to the TsString.
CheckHr(qtssColVal->get_Text(&sbstr));
if (sbstr.Length())
{
// Get the format of the TsString
hr = qtssColVal->SerializeFmtRgb(rgbFmt, cbFmtBufSize, &cbFmtSpaceTaken);
if (hr != S_OK)
{
if (hr == S_FALSE)
{
// If the supplied buffer is too small, try it again with the value
// that cbFmtSpaceTaken was set to. If this fails, signal error.
delete rgbFmt;
rgbFmt = NewObj byte[cbFmtSpaceTaken];
cbFmtBufSize = cbFmtSpaceTaken;
CheckHr(qtssColVal->SerializeFmtRgb(rgbFmt, cbFmtBufSize,
&cbFmtSpaceTaken));
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
}
// Execute stored procedure to set MSA value.
// REVIEW PaulP: This technique isn't going to work for custom fields
// since there will likely not be any "Set" stored procedure.
suSql.Format(L"exec Set_%s_%s %d, %d, ?, ?", fmdr.m_suClassName.Chars(),
fmdr.m_suFieldName.Chars(), operKey.m_hvo, operKey.m_ws);
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
// Bind the text and format parts of the string to the parameters.
SQLINTEGER cbTextPart = sbstr.Length() * 2;
rc = SQLBindParameter(sstmt.Hstmt(), 1, SQL_PARAM_INPUT,
SQL_C_WCHAR, SQL_WVARCHAR, cbTextPart, 0,
const_cast<wchar *>(sbstr.Chars()), cbTextPart, &cbTextPart);
SQLINTEGER cbFmtPart = cbFmtSpaceTaken;
rc = SQLBindParameter(sstmt.Hstmt(), 2, SQL_PARAM_INPUT, SQL_C_BINARY,
SQL_VARBINARY, cbFmtPart, 0, rgbFmt, cbFmtPart, &cbFmtPart);
}
else
{
// REVIEW PaulP: This technique isn't going to work for custom fields
// since there will likely not be any "Set" stored procedure.
suSql.Format(L"exec Set_%s_%s %d, %d, NULL, NULL",
fmdr.m_suClassName.Chars(), fmdr.m_suFieldName.Chars(), operKey.m_hvo,
operKey.m_ws);
rc = SQLPrepareW(sstmt.Hstmt(), const_cast<wchar *>(suSql.Chars()),
SQL_NTS);
}
// Execute the SQL update command.
//rc = SQLSetStmtAttr(sstmt.Hstmt(), SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, 0);
rc = SQLExecute(sstmt.Hstmt());
if (rc == SQL_ERROR || rc == SQL_SUCCESS_WITH_INFO)
{
// TOxDO PaulP: Error information can be obtained from sqlchMsgTxt.
sqlr = SQLGetDiagRec(SQL_HANDLE_STMT, sstmt.Hstmt(), 1, sqlchSqlState,
&sqlnNativeErrPtr, sqlchMsgTxt, kcchErrMsgBuf, &sqlnTextLength);
ThrowHr(WarnHr(E_UNEXPECTED));
}
sstmt.Clear();
}
else
{
ThrowHr(WarnHr(E_UNEXPECTED));
}
}
/*--------------------------------------------------------------------------------------
Commit the database transaction.
REVIEW PaulP: The DataSource MUST be in manual commit mode.
--------------------------------------------------------------------------------------*/
CheckSqlRc(SQLEndTran(SQL_HANDLE_DBC, sdb.Hdbc(), SQL_COMMIT));
}
catch (...)
{
sstmt.Clear();
delete rgbFmt;
CheckSqlRc(SQLEndTran(SQL_HANDLE_DBC, sdb.Hdbc(), SQL_ROLLBACK));
return E_UNEXPECTED;
}
/*------------------------------------------------------------------------------------------
Clear the two Sets containing records of modified properties and MBA's.
------------------------------------------------------------------------------------------*/
m_soprMods.Clear();
m_soperMods.Clear();
delete rgbFmt; // REVIEW: Shouldn't this be delete[]?
return S_OK;
END_COM_METHOD(g_fact, IID_IVwCacheDa);
}
bool PrepareAndBind(Cursor* cur, PyObject* pSql, PyObject* original_params, bool skip_first)
{
//
// Normalize the parameter variables.
//
// Since we may replace parameters (we replace objects with Py_True/Py_False when writing to a bit/bool column),
// allocate an array and use it instead of the original sequence. Since we don't change ownership we don't bother
// with incref. (That is, PySequence_GetItem will INCREF and ~ObjectArrayHolder will DECREF.)
int params_offset = skip_first ? 1 : 0;
Py_ssize_t cParams = original_params == 0 ? 0 : PySequence_Length(original_params) - params_offset;
PyObject** params = (PyObject**)malloc(sizeof(PyObject*) * cParams);
if (!params)
{
PyErr_NoMemory();
return 0;
}
for (Py_ssize_t i = 0; i < cParams; i++)
params[i] = PySequence_GetItem(original_params, i + params_offset);
ObjectArrayHolder holder(cParams, params);
//
// Prepare the SQL if necessary.
//
if (pSql == cur->pPreparedSQL)
{
// We've already prepared this SQL, so we don't need to do so again. We've also cached the parameter
// information in cur->paramdescs.
if (cParams != cur->paramcount)
{
RaiseErrorV(0, ProgrammingError, "The SQL contains %d parameter markers, but %d parameters were supplied",
cur->paramcount, cParams);
return false;
}
}
else
{
FreeParameterInfo(cur);
SQLRETURN ret;
if (PyString_Check(pSql))
{
Py_BEGIN_ALLOW_THREADS
ret = SQLPrepare(cur->hstmt, (SQLCHAR*)PyString_AS_STRING(pSql), SQL_NTS);
Py_END_ALLOW_THREADS
}
else
{
Py_BEGIN_ALLOW_THREADS
ret = SQLPrepareW(cur->hstmt, (SQLWCHAR*)PyUnicode_AsUnicode(pSql), SQL_NTS);
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.");
return false;
}
if (!SQL_SUCCEEDED(ret))
{
RaiseErrorFromHandle("SQLPrepare", GetConnection(cur)->hdbc, cur->hstmt);
return false;
}
if (!CacheParamDesc(cur))
return false;
cur->pPreparedSQL = pSql;
Py_INCREF(cur->pPreparedSQL);
}
