// Get field as string
_tstring field_impl::as_string() const
{
if (is_null_flag != -1)
return str_buf;
SQLLEN sz_needed = 0;
SQLTCHAR small_buff[256];
RETCODE rc;
// Try with small buffer
is_null_flag = 0;
rc = SQLGetData(stmt_h, col_num, SQL_C_TCHAR, small_buff, sizeof(small_buff), &sz_needed);
if (TIODBC_SUCCESS_CODE(rc))
{
if (sz_needed == SQL_NULL_DATA) {
is_null_flag = 1;
return _tstring();
}
str_buf = sqltchar2ybstring(small_buff, "");
return str_buf;
}
else if (sz_needed > 0)
{
// A bigger buffer is needed
SQLINTEGER sz_buff = sz_needed + 1;
SQLTCHAR_buf buff(sz_buff);
SQLGetData(stmt_h, col_num, SQL_C_TCHAR, buff.data, sz_buff, &sz_needed);
str_buf = sqltchar2ybstring(buff.data, "");
return str_buf;
}
return _tstring(); // Empty
}
void classSpecialColumns::LoadColumns()
{
CursorScoper s(listView()) ;
SQLRETURN nReturn ;
SQLCHAR szColumnName[MAX_COLUMN_WIDTH];
SQLCHAR szColumnType[MAX_COLUMN_WIDTH];
SQLCHAR szColumnSize[MAX_COLUMN_WIDTH];
SQLCHAR szRemarks [MAX_COLUMN_WIDTH];
QString qsDesc ;
classColumn *pColumn = NULL ;
// CREATE A STATEMENT
StatementScoper stmt( hDbc ) ; if ( !stmt() ) return ;
// EXECUTE OUR SQL/CALL
if (!SQL_SUCCEEDED(nReturn=SQLSpecialColumns( stmt(), SQL_BEST_ROWID, 0, 0, (SQLCHAR*)qsLibrary.data(), SQL_NTS, (SQLCHAR*)qsTable.data(), SQL_NTS, SQL_SCOPE_SESSION, SQL_NULLABLE ) ) )
return my_msgBox( "classSpecialColumns", "SQLSpecialColumns", nReturn, NULL, NULL, stmt() ) ;
// GET RESULTS
while (SQL_SUCCEEDED(SQLFetch( stmt() ) ) )
{
if (!SQL_SUCCEEDED(SQLGetData( stmt(), 2, SQL_C_CHAR, &szColumnName[0], sizeof(szColumnName), 0 ) ) )
strcpy( (char *)szColumnName, "Unknown" );
if (!SQL_SUCCEEDED(SQLGetData( stmt(), 4, SQL_C_CHAR, &szColumnType[0], sizeof(szColumnType), 0 ) ) )
strcpy( (char *)szColumnType, "Unknown" );
if (!SQL_SUCCEEDED(SQLGetData( stmt(), 5, SQL_C_CHAR, &szColumnSize[0], sizeof(szColumnSize), 0 ) ) )
strcpy( (char *)szColumnSize, "Unknown" );
qsDesc.sprintf("Len=%s", QString((char*)szColumnSize).stripWhiteSpace().data() ) ;
listColumns.append( pColumn = new classColumn( this, pColumn, pCanvas, hDbc, QString((char*)szColumnName).stripWhiteSpace(), QString((char*)szColumnType).stripWhiteSpace(), qsDesc ) ) ;
}
}
std::string GetAsString() const
{
SQLINTEGER Needed = 0;
const unsigned BufSize = 256;
char SmallBuff[BufSize] = { 0 };
RETCODE Ret = SQLGetData(Stmt.GetHolder().GetHandle(), static_cast<SQLUSMALLINT>(Index), SQL_C_CHAR,
SmallBuff, BufSize,
//reinterpret_cast for x64
reinterpret_cast<SQLLEN *>(&Needed));
if (TIODBC_SUCCESS_CODE(Ret))
return std::string(SmallBuff);
if (Needed > 0)
{
SQLINTEGER Buff = Needed + 1;
std::vector<char> Data(Buff, 0);
Ret = SQLGetData(Stmt.GetHolder().GetHandle(), static_cast<SQLUSMALLINT>(Index), SQL_C_CHAR,
reinterpret_cast<SQLTCHAR *>(&Data.front()), Buff,
//reinterpret_cast for x64
reinterpret_cast<SQLLEN *>(&Needed));
if (TIODBC_SUCCESS_CODE(Ret))
return std::string(&Data[0], Data.size());
throw FieldException("Error get field", feErrorGetField);
}
return std::string();
}
int
main(int argc, char *argv[])
{
char buf[16];
Connect();
/* TODO test with VARCHAR too */
Command(Statement, "SELECT CONVERT(TEXT,'Prova')");
if (SQLFetch(Statement) != SQL_SUCCESS) {
printf("Unable to fetch row\n");
CheckReturn();
exit(1);
}
/* these 2 tests test an old severe BUG in FreeTDS */
if (SQLGetData(Statement, 1, SQL_C_CHAR, buf, 0, NULL) != SQL_SUCCESS_WITH_INFO) {
printf("Unable to get data 1\n");
CheckReturn();
exit(1);
}
if (SQLGetData(Statement, 1, SQL_C_CHAR, buf, 0, NULL) != SQL_SUCCESS_WITH_INFO) {
printf("Unable to get data 2\n");
CheckReturn();
exit(1);
}
if (SQLGetData(Statement, 1, SQL_C_CHAR, buf, 3, NULL) != SQL_SUCCESS_WITH_INFO) {
printf("Unable to get data \n");
CheckReturn();
exit(1);
}
if (strcmp(buf, "Pr") != 0) {
printf("Wrong data result 1\n");
exit(1);
}
if (SQLGetData(Statement, 1, SQL_C_CHAR, buf, 16, NULL) != SQL_SUCCESS) {
printf("Unable to get data \n");
CheckReturn();
exit(1);
}
if (strcmp(buf, "ova") != 0) {
printf("Wrong data result 2 res = '%s'\n", buf);
exit(1);
}
Disconnect();
printf("Done.\n");
return 0;
}
void ring_vm_odbc_getdata ( void *pPointer )
{
ring_odbc *pODBC ;
SQLINTEGER indicator ;
SQLUSMALLINT i ;
SQLRETURN ret ;
char *buf, *buf2 ;
int nSize ;
if ( RING_API_PARACOUNT != 2 ) {
RING_API_ERROR(RING_API_MISS2PARA);
return ;
}
if ( RING_API_ISPOINTER(1) && RING_API_ISNUMBER(2) ) {
pODBC = (ring_odbc *) RING_API_GETCPOINTER(1,RING_VM_POINTER_ODBC) ;
if ( pODBC == NULL ) {
return ;
}
i = (SQLUSMALLINT) RING_API_GETNUMBER(2) ;
nSize = 512 ;
buf = (char *) malloc(nSize) ;
if ( buf == NULL ) {
RING_API_ERROR(RING_OOM);
return ;
}
ret = SQLGetData(pODBC->stmt, i, SQL_C_CHAR,buf, nSize, &indicator);
if ( SQL_SUCCEEDED(ret) ) {
if ( indicator == SQL_NULL_DATA ) {
strcpy(buf,"NULL");
nSize = 4 ;
} else if ( (ret == SQL_SUCCESS_WITH_INFO) && (indicator > 512) ) {
nSize = 512+indicator ;
buf2 = (char *) realloc(buf , nSize);
if ( buf2 == NULL ) {
RING_API_ERROR(RING_OOM);
return ;
}
buf = buf2 ;
SQLGetData(pODBC->stmt, i, SQL_C_CHAR,buf+511, indicator+1, &indicator);
nSize = 511+indicator ;
} else {
nSize = indicator ;
}
RING_API_RETSTRING2(buf,nSize);
} else {
RING_API_RETNUMBER(0);
}
free( buf ) ;
} else {
RING_API_ERROR(RING_API_BADPARATYPE);
}
}
const char *SMSDODBC_GetString(GSM_SMSDConfig * Config, SQL_result *res, unsigned int field)
{
SQLLEN sqllen;
int size;
SQLRETURN ret;
char shortbuffer[1];
if (field > SMSD_ODBC_MAX_RETURN_STRINGS) {
SMSD_Log(DEBUG_ERROR, Config, "Field %d returning NULL, too many fields!", field);
return NULL;
}
/* Figure out string length */
ret = SQLGetData(res->odbc, field + 1, SQL_C_CHAR, shortbuffer, 0, &sqllen);
if (!SQL_SUCCEEDED(ret)) {
SMSDODBC_LogError(Config, ret, SQL_HANDLE_STMT, res->odbc, "SQLGetData(string,0) failed");
return NULL;
}
/*
* This hack seems to be needed to avoid type breakage on Win64, don't ask me why.
*
* Might be actually bug in MinGW compiler, but when using SQLLEN type bellow
* anything fails (it does not match to SQL_NULL_DATA and realloc always fails).
*/
size = sqllen;
/* Did not we get NULL? */
if (size == SQL_NULL_DATA) {
SMSD_Log(DEBUG_SQL, Config, "Field %d returning NULL", field);
return NULL;
}
/* Allocate string */
Config->conn.odbc.retstr[field] = realloc(Config->conn.odbc.retstr[field], size + 1);
if (Config->conn.odbc.retstr[field] == NULL) {
SMSD_Log(DEBUG_ERROR, Config, "Field %d returning NULL, failed to allocate %d bytes of memory", field, size + 1);
return NULL;
}
/* Actually grab result from database */
ret = SQLGetData(res->odbc, field + 1, SQL_C_CHAR, Config->conn.odbc.retstr[field], size + 1, &sqllen);
if (!SQL_SUCCEEDED(ret)) {
SMSDODBC_LogError(Config, ret, SQL_HANDLE_STMT, res->odbc, "SQLGetData(string) failed");
return NULL;
}
SMSD_Log(DEBUG_SQL, Config, "Field %d returning string \"%s\"", field, Config->conn.odbc.retstr[field]);
return Config->conn.odbc.retstr[field];
}
void classTable::LoadColumns()
{
SQLHSTMT hstmt;
SQLRETURN nReturn = -1;
SQLCHAR szTableName[101] = "";
SQLCHAR szColumnName[101] = "";
SQLCHAR szColumnType[101] = "";
SQLCHAR szDescription[301] = "";
QString qsError;
classColumn *pColumn = NULL;
// CREATE A STATEMENT
nReturn = SQLAllocStmt( hDbc, &hstmt );
if ( nReturn != SQL_SUCCESS )
{
QMessageBox::warning( pCanvas, "Data Manager", "Failed to SQLAllocStmt" );
return;
}
// EXECUTE OUR SQL/CALL
strcpy( (char *)szTableName, qsName.data() );
if ( SQL_SUCCESS != (nReturn=SQLColumns( hstmt, 0, 0, 0, 0, szTableName, SQL_NTS, 0, 0 )) )
{
QMessageBox::warning( pCanvas, "Data Manager", "Failed to SQLColumns" );
return;
}
// GET RESULTS
nReturn = SQLFetch( hstmt );
while ( nReturn == SQL_SUCCESS || nReturn == SQL_SUCCESS_WITH_INFO )
{
szDescription[0] = '\0';
nReturn = SQLGetData( hstmt, SQLColumns_COLUMN_NAME, SQL_C_CHAR, &szColumnName[0], sizeof(szColumnName), 0 );
if ( nReturn != SQL_SUCCESS )
strcpy( (char *)szColumnName, "Unknown" );
nReturn = SQLGetData( hstmt, SQLColumns_TYPE_NAME, SQL_C_CHAR, &szColumnType[0], sizeof(szColumnType), 0 );
listColumns.append( pColumn = new classColumn( this, pColumn, pCanvas, hDbc, (char *)szColumnName, (char*)szColumnType, (char*)szDescription ) );
nReturn = SQLFetch( hstmt );
}
// FREE STATEMENT
nReturn = SQLFreeStmt( hstmt, SQL_DROP );
if ( nReturn != SQL_SUCCESS )
QMessageBox::warning( pCanvas, "Data Manager", "Failed to SQLFreeStmt" );
}
int LoadChangeItem()//010708 lsw
{
HSTMT hStmt = NULL;
RETCODE retCode;
SDWORD cbValue;
SQLAllocStmt(hDBC, &hStmt);
retCode = SQLExecDirect(hStmt, (UCHAR *)"Select * from item_change order by original", SQL_NTS);
if(retCode == SQL_SUCCESS || retCode == SQL_SUCCESS_WITH_INFO)
{
int i = 0;
retCode = SQLFetch(hStmt);
while( retCode == SQL_SUCCESS || retCode == SQL_SUCCESS_WITH_INFO)
{
if(i >= MAX_CHANGE_ITEM_COUNT)//020730 lsw
{
SQLFreeStmt(hStmt, SQL_DROP);
return 0;
}
retCode = SQLGetData(hStmt, 1, SQL_C_LONG, &itemchange[i].origin_item_no , 0, &cbValue);
retCode = SQLGetData(hStmt, 2, SQL_C_LONG, &itemchange[i].will_change_item_no , 0, &cbValue);
retCode = SQLGetData(hStmt, 3, SQL_C_LONG, &itemchange[i].add_soksung , 0, &cbValue);
retCode = SQLGetData(hStmt, 4, SQL_C_LONG, &itemchange[i].add_grade , 0, &cbValue);
ichangeItemCount=i;
i++;
retCode = SQLFetch(hStmt);
if(retCode == SQL_SUCCESS || retCode == SQL_SUCCESS_WITH_INFO)
{
}
else if( retCode == SQL_NO_DATA )
{
break;
}
else
{
SQLFreeStmt(hStmt, SQL_DROP);
return 0;
}
}
}
SQLFreeStmt(hStmt, SQL_DROP); // 0308 YGI
return(1);
}
SQLREAL sql_column_float(SQLHSTMT stmt, SQLUSMALLINT col) {
SQLREAL buf;
SQLINTEGER len;
SQLRETURN rc = SQLGetData(stmt, col + 1, SQL_REAL, &buf, 0, &len);
if (SQL_NULL_DATA == len) return 0;
return buf;
}
/*************************************************************************
*
* Function: sql_fetch_row
*
* Purpose: database specific fetch_row. Returns a SQL_ROW struct
* with all the data for the query in 'sqlsocket->row'. Returns
* 0 on success, -1 on failure, SQL_DOWN if 'database is down'
*
*************************************************************************/
static int sql_fetch_row(SQLSOCK * sqlsocket, SQL_CONFIG *config)
{
int c, i;
SQLINTEGER len, slen;
SQL_ROW retval;
rlm_sql_db2_sock *sock;
sock = sqlsocket->conn;
c = sql_num_fields(sqlsocket, config);
retval = (SQL_ROW)rad_malloc(c*sizeof(char*)+1);
/* advance cursor */
if(SQLFetch(sock->stmt) == SQL_NO_DATA_FOUND) {
sqlsocket->row = NULL;
return 0;
}
for(i = 0; i < c; i++) {
/* get column length */
SQLColAttribute(sock->stmt,
i+1, SQL_DESC_DISPLAY_SIZE,
NULL, 0, NULL, &len);
retval[i] = (char*)rad_malloc(len+1);
/* get the actual column */
SQLGetData(sock->stmt,
i+1, SQL_C_CHAR, retval[i], len+1, &slen);
if(slen == SQL_NULL_DATA)
retval[i][0] = '\0';
}
sqlsocket->row = retval;
return 0;
}
static PyObject* GetUUID(Cursor* cur, Py_ssize_t iCol)
{
// REVIEW: Since GUID is a fixed size, do we need to pass the size or cbFetched?
PYSQLGUID guid;
SQLLEN cbFetched = 0;
SQLRETURN ret;
Py_BEGIN_ALLOW_THREADS
ret = SQLGetData(cur->hstmt, (SQLUSMALLINT)(iCol+1), SQL_GUID, &guid, sizeof(guid), &cbFetched);
Py_END_ALLOW_THREADS
if (!SQL_SUCCEEDED(ret))
return RaiseErrorFromHandle("SQLGetData", cur->cnxn->hdbc, cur->hstmt);
if (cbFetched == SQL_NULL_DATA)
Py_RETURN_NONE;
#if PY_MAJOR_VERSION >= 3
const char* szFmt = "(yyy#)";
#else
const char* szFmt = "(sss#)";
#endif
Object args(Py_BuildValue(szFmt, NULL, NULL, &guid, (int)sizeof(guid)));
if (!args)
return 0;
PyObject* uuid_type = GetClassForThread("uuid", "UUID");
if (!uuid_type)
return 0;
PyObject* uuid = PyObject_CallObject(uuid_type, args.Get());
Py_DECREF(uuid_type);
return uuid;
}
void ODBCHandler::printStatement(SQLHSTMT *stmt)
{
SQLRETURN ret;
SQLRETURN ret2;
SQLSMALLINT columns; /* number of columns in result-set */
int row = 0;
/* How many columns are there */
SQLNumResultCols(*stmt, &columns);
/* Loop through the rows in the result-set */
while (SQL_SUCCEEDED(ret = SQLFetch(*stmt))) {
SQLUSMALLINT i;
ColDesc c;
fprintf(stderr,"Row %d\n", row++);
/* Loop through the columns */
for (i = 1; i <= columns; i++) {
SQLLEN indicator;
SQLCHAR buf[512];
//get column info
ret2 = SQLDescribeCol(*stmt,i,c.colName, sizeof(c.colName), &c.nameLen,NULL, NULL, NULL, NULL);
/* retrieve column data as a string */
ret = SQLGetData(*stmt, i, SQL_C_CHAR,buf, sizeof(buf), &indicator);
if (SQL_SUCCEEDED(ret)) {
/* Handle null columns */
if (indicator == SQL_NULL_DATA) strcpy((char*)buf, "NULL");
fprintf(stderr," Column %s %u : %s\n", c.colName,i, buf);
}
}
}
}
bool CODBC_RowResult::CheckSIENoD_Binary(CDB_Stream* val)
{
SQLLEN f = 0;
char buffer[8*1024];
switch(SQLGetData(GetHandle(), m_CurrItem+1, SQL_C_BINARY, buffer, sizeof(buffer), &f)) {
case SQL_SUCCESS_WITH_INFO:
if(f == SQL_NO_TOTAL || f > SQLLEN(sizeof(buffer))) f = sizeof(buffer);
else ReportErrors();
case SQL_SUCCESS:
if(f > 0) {
if(f > SQLLEN(sizeof(buffer))) f = sizeof(buffer);
val->Append(buffer, f);
}
return true;
case SQL_NO_DATA:
break;
case SQL_ERROR:
ReportErrors();
default:
{
DATABASE_DRIVER_ERROR(
string("SQLGetData failed while retrieving BLOB into C") +
CDB_Object::GetTypeName(val->GetType()) + '.',
430022);
}
}
return false;
}
string ODBCHandler::get_tables()
{
SQLHSTMT stmt;
SQLRETURN ret;
SQLSMALLINT nr_columns;
stringstream tbl_list;
string ODBC_error;
bool list_start = false;
SQLAllocHandle(SQL_HANDLE_STMT, dbc, &stmt);
SQLTables(stmt, NULL, 0, NULL, 0, NULL, 0, (unsigned char*)"TABLE",
SQL_NTS);
SQLNumResultCols(stmt, &nr_columns);
while (SQL_SUCCEEDED(ret = SQLFetch(stmt))) {
SQLUSMALLINT i;
tbl_list<<"{";
for (i = 1; i <= nr_columns; i++) {
SQLLEN indicator;
char buf[512];
ret = SQLGetData(stmt, i, SQL_C_CHAR,
buf, sizeof(buf), &indicator);
if (SQL_SUCCEEDED(ret)) {
if (indicator != SQL_NULL_DATA) {//strcpy(buf, "NULL");
if (list_start)
tbl_list<<",";
else
list_start = true;
tbl_list<<buf;
}
}
}
tbl_list<<"}";
}
return tbl_list.str();
}
char *dbt2_sql_getvalue(struct db_context_t *dbc,
struct sql_result_t *sql_result, int field)
{
SQLRETURN rc;
char *tmp;
tmp = NULL;
SQLINTEGER cb_var = 0;
if (sql_result->current_row && field < sql_result->num_fields) {
if ((tmp = calloc(sizeof(char), sql_result->lengths[field] + 1))) {
rc = SQLGetData(dbc->hstmt, field + 1, SQL_C_CHAR, tmp,
sql_result->lengths[field] + 1, &cb_var);
if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) {
LOG_ODBC_ERROR(SQL_HANDLE_STMT, dbc->hstmt);
}
} else {
LOG_ERROR_MESSAGE("dbt2_sql_getvalue: CALLOC FAILED for value from field=%d\n", field);
}
#ifdef DEBUG_QUERY
} else {
LOG_ERROR_MESSAGE("dbt2_sql_getvalue: FIELD %d current_row %d\nQUERY --- %s\n", field, sql_result->current_row, sql_result->query);
#endif
}
return tmp;
}
SQLSMALLINT sql_column_bit(SQLHSTMT stmt, SQLUSMALLINT col) {
SQLCHAR buf;
SQLINTEGER len;
SQLRETURN rc = SQLGetData(stmt, col + 1, SQL_BIT, &buf, 0, &len);
if (SQL_NULL_DATA == len) return 0;
return 0 == buf ? 0 : 1;
}
int CODBC_RowResult::xGetData(SQLSMALLINT target_type, SQLPOINTER buffer,
SQLINTEGER buffer_size)
{
SQLLEN f;
switch(SQLGetData(GetHandle(), m_CurrItem+1, target_type, buffer, buffer_size, &f)) {
case SQL_SUCCESS_WITH_INFO:
switch(f) {
case SQL_NO_TOTAL:
return buffer_size;
case SQL_NULL_DATA:
return 0;
default:
if(f < 0)
ReportErrors();
return (int)f;
}
case SQL_SUCCESS:
if(target_type == SQL_C_CHAR) buffer_size--;
return (f > buffer_size)? buffer_size : (int)f;
case SQL_NO_DATA:
return 0;
case SQL_ERROR:
ReportErrors();
default:
{
string err_message = "SQLGetData failed." + GetDbgInfo();
DATABASE_DRIVER_ERROR( err_message, 430027 );
}
}
}
static PyObject* GetDataTimestamp(Cursor* cur, Py_ssize_t iCol)
{
TIMESTAMP_STRUCT value;
SQLLEN cbFetched = 0;
SQLRETURN ret;
Py_BEGIN_ALLOW_THREADS
ret = SQLGetData(cur->hstmt, (SQLUSMALLINT)(iCol+1), SQL_C_TYPE_TIMESTAMP, &value, sizeof(value), &cbFetched);
Py_END_ALLOW_THREADS
if (!SQL_SUCCEEDED(ret))
return RaiseErrorFromHandle("SQLGetData", cur->cnxn->hdbc, cur->hstmt);
if (cbFetched == SQL_NULL_DATA)
Py_RETURN_NONE;
switch (cur->colinfos[iCol].sql_type)
{
case SQL_TYPE_TIME:
{
int micros = (int)(value.fraction / 1000); // nanos --> micros
return PyTime_FromTime(value.hour, value.minute, value.second, micros);
}
case SQL_TYPE_DATE:
return PyDate_FromDate(value.year, value.month, value.day);
}
int micros = (int)(value.fraction / 1000); // nanos --> micros
return PyDateTime_FromDateAndTime(value.year, value.month, value.day, value.hour, value.minute, value.second, micros);
}
uint CODBC::Fetch(char *buffer, uint buffersize)
{
uint total, totalbytes = 0;
SQLSMALLINT NumCols, i;
buffer[0] = 0x0;
// walk through the resultset
if (SQLFetch(hstmt) != SQL_SUCCESS)
return -1;
// add each column to buffer
SQLNumResultCols(hstmt, &NumCols);
for (i = 1; i <= NumCols; i++)
{
SQLGetData(hstmt, i, SQL_C_CHAR, columnData, MAX_DATA, &cbData);
total = totalbytes + cbData;
if ((total < buffersize) && (cbData != SQL_NULL_DATA)) {
memcpy (&buffer[totalbytes], columnData, cbData);
totalbytes = total;
}
if ((i != NumCols) && (totalbytes + 1 < buffersize)) {
buffer[totalbytes] = '¬'; // ascii 170
totalbytes++;
}
}
buffer[totalbytes] = 0;
return totalbytes;
}
SQLINTEGER sql_column_long(SQLHSTMT stmt, SQLUSMALLINT col) {
SQLINTEGER buf;
SQLINTEGER len;
SQLRETURN rc = SQLGetData(stmt, col + 1, SQL_INTEGER, &buf, 0, &len);
if (SQL_NULL_DATA == len) return 0;
return buf;
}
void print_results(SQLHSTMT stmt)
{
SQLRETURN ret; /* ODBC API return status */
SQLSMALLINT columns; /* number of columns in result-set */
int row = 0;
/* How many columns are there */
SQLNumResultCols(stmt, &columns);
/* Loop through the rows in the result-set */
while (SQL_SUCCEEDED(ret = SQLFetch(stmt))) {
SQLUSMALLINT i;
printf("Row %d\n", row++);
/* Loop through the columns */
for (i = 1; i <= columns; i++) {
SQLLEN indicator;
char buf[512];
/* retrieve column data as a string */
ret = SQLGetData(stmt, i, SQL_C_CHAR,
buf, sizeof(buf), &indicator);
if (SQL_SUCCEEDED(ret)) {
/* Handle null columns */
if (indicator == SQL_NULL_DATA) strcpy(buf, "NULL");
printf(" Column %u : %s\n", i, buf);
}
}
}
printf("\n");
}
bool CRecordSet::sColumnEx(const int iCol, char *sBuf, const int iBufSz, int *iOutLen)
{
int iLen = 0;
if(SQL_SUCCEEDED(SQLGetData(hSTMT, iCol, SQL_C_CHAR, sBuf, iBufSz, (SQLINTEGER *)&iLen)))
{
if(iLen > iBufSz)
{
iLen = iBufSz;
}
if(bReplaceSingleQuotes)
{
ReplaceSingleQuotes(sBuf, iLen);
}
if(bTrimCharData)
{
iLen = RTrim(sBuf, iLen);
}
if(iOutLen)
{
*iOutLen = iLen;
}
return true;
}
else {
ThrowErrorIfSet();
return false;
}
}
CString CSQLDirect::GetCol( int nCol )
{
CString svValue;
// Due to the nature of the SQL API, repeated calls to the same column will result in a NULL value passed
// back into svData. We need to keep track of the columns that have been used already and if so, pass back
// the data stored in our array.
int nIndex=FindColumn( nCol );
if( nIndex==-1 ) {
// Get the column from the SQL cursor.
UCHAR svData[8192];
SDWORD cbDataLen;
SQLGetData( m_hStmt,nCol,GetColumnType( nCol ),&svData,8192,&cbDataLen );
svValue=svData;
svValue.TrimRight();
AddColumn( nCol,svValue );
}
else {
// Get the value from the column array.
svValue=GetColumn( nCol )->m_svValue;
}
return svValue;
}
BOOL CDBProcess::LoadUserCountList()
{
SQLHSTMT hstmt = NULL;
SQLRETURN retcode;
TCHAR szSQL[1024];
CString tempfilename, tempcompname;
memset(szSQL, 0x00, 1024);
wsprintf(szSQL, TEXT("select * from CONCURRENT"));
SQLCHAR serverid;
SQLSMALLINT zone_1 = 0, zone_2 = 0, zone_3 = 0;
SQLINTEGER Indexind = SQL_NTS;
retcode = SQLAllocHandle( (SQLSMALLINT)SQL_HANDLE_STMT, m_VersionDB.m_hdbc, &hstmt );
if (retcode != SQL_SUCCESS) return FALSE;
retcode = SQLExecDirect (hstmt, (unsigned char *)szSQL, 1024);
if( retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO ) {
if( DisplayErrorMsg(hstmt) == -1 ) {
m_VersionDB.Close();
if( !m_VersionDB.IsOpen() ) {
ReConnectODBC( &m_VersionDB, m_pMain->m_ODBCName, m_pMain->m_ODBCLogin, m_pMain->m_ODBCPwd );
return FALSE;
}
}
SQLFreeHandle((SQLSMALLINT)SQL_HANDLE_STMT,hstmt);
return FALSE;
}
while (retcode == SQL_SUCCESS|| retcode == SQL_SUCCESS_WITH_INFO) {
retcode = SQLFetch(hstmt);
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO){
SQLGetData(hstmt,1 ,SQL_C_TINYINT , &serverid, 0, &Indexind);
SQLGetData(hstmt,2 ,SQL_C_SSHORT , &zone_1, 0, &Indexind);
SQLGetData(hstmt,3 ,SQL_C_SSHORT , &zone_2, 0, &Indexind);
SQLGetData(hstmt,4 ,SQL_C_SSHORT , &zone_3, 0, &Indexind);
// 여기에서 데이타를 받아서 알아서 사용....
if( serverid-1 < m_pMain->m_nServerCount )
m_pMain->m_ServerList[serverid-1]->sUserCount = zone_1 + zone_2 + zone_3; // 기범이가 ^^;
}
}
SQLFreeHandle((SQLSMALLINT)SQL_HANDLE_STMT,hstmt);
return TRUE;
}
void dolines(SQLHSTMT *stmt, SQLSMALLINT ncol, char format)
{
int j;
long ans;
string *str, *tstr;
char istr[256];
long sb = 0;
SQLLEN si;
str = new_string();
tstr = new_string();
for(;;)
{
ans = SQLFetch(*stmt);
/*
* I assume error here is EOF...
*/
if((ans != SQL_SUCCESS) && ( ans != SQL_SUCCESS_WITH_INFO))
break;
for(j=0;j<ncol;j++)
{
si = 0;
for(;;)
{
ans = SQLGetData(stmt, j+1, SQL_C_CHAR, istr, 256, &si);
if(ans == SQL_NO_DATA) break;
if(si == SQL_NO_TOTAL)
{
sb += 255;
}
else
{
sb += si;
}
string_cat(tstr, istr);
if(si != SQL_NO_TOTAL) break;
}
dolitem(str, string_s(tstr), (j == ncol - 1), format);
string_clear(tstr);
}
string_cat_c(str, '\n');
if(message_send(mes, str, 0, MES_SERVER_TO_CLIENT) < 0) return;
string_clear(str);
}
string_delete(str);
string_delete(tstr);
return;
}
BOOL CDBProcess::IsCurrentUser(const char *accountid, char* strServerIP, int &serverno)
{
SQLHSTMT hstmt = NULL;
SQLRETURN retcode;
BOOL retval;
TCHAR szSQL[1024];
memset( szSQL, 0x00, 1024 );
SQLINTEGER nServerNo = 0;
TCHAR strIP[16] = {0};
SQLINTEGER Indexind = SQL_NTS;
wsprintf( szSQL, TEXT( "SELECT nServerNo, strServerIP FROM CURRENTUSER WHERE strAccountID = \'%s\'" ), accountid );
retcode = SQLAllocHandle( (SQLSMALLINT)SQL_HANDLE_STMT, m_VersionDB.m_hdbc, &hstmt );
if (retcode != SQL_SUCCESS) return FALSE;
retcode = SQLExecDirect (hstmt, (unsigned char *)szSQL, 1024);
if (retcode == SQL_SUCCESS|| retcode == SQL_SUCCESS_WITH_INFO) {
retcode = SQLFetch(hstmt);
if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) {
SQLGetData(hstmt,1 ,SQL_C_SSHORT, &nServerNo, 0, &Indexind);
SQLGetData(hstmt,2 ,SQL_C_CHAR, strIP, 15, &Indexind);
strcpy_s( strServerIP, 16, strIP );
serverno = nServerNo;
retval = TRUE;
}
else
retval = FALSE;
}
else {
if( DisplayErrorMsg(hstmt) == -1 ) {
m_VersionDB.Close();
if( !m_VersionDB.IsOpen() ) {
ReConnectODBC( &m_VersionDB, m_pMain->m_ODBCName, m_pMain->m_ODBCLogin, m_pMain->m_ODBCPwd );
return FALSE;
}
}
retval = FALSE;
}
SQLFreeHandle((SQLSMALLINT)SQL_HANDLE_STMT,hstmt);
return retval;
}
static isc_result_t
odbc_getManyFields(SQLHSTMT *stmnt, SQLSMALLINT startField,
SQLSMALLINT endField, char **retData) {
isc_result_t result;
SQLLEN size;
int totSize = 0;
SQLSMALLINT i;
int j = 0;
char *data;
REQUIRE(retData != NULL && *retData == NULL);
REQUIRE(startField > 0 && startField <= endField);
/* determine how large the data is */
for (i=startField; i <= endField; i++)
if (sqlOK(SQLColAttribute(stmnt, i, SQL_DESC_DISPLAY_SIZE,
NULL, 0, NULL, &size)) && size > 0) {
/* always allow for a " " (space) character */
totSize += (size + 1);
/* after the data item */
}
if (totSize < 1)
return ISC_R_FAILURE;
/* allow for a "\n" at the end of the string/ */
data = isc_mem_allocate(ns_g_mctx, ++totSize);
if (data == NULL)
return ISC_R_NOMEMORY;
result = ISC_R_FAILURE;
/* get the data and concat all fields into a large string */
for (i=startField; i <= endField; i++) {
if (sqlOK(SQLGetData(stmnt, i, SQL_C_CHAR, &(data[j]),
totSize - j, &size))) {
if (size > 0) {
j += size;
data[j++] = ' ';
data[j] = '\0';
result = ISC_R_SUCCESS;
}
} else {
isc_mem_free(ns_g_mctx, data);
return ISC_R_FAILURE;
}
}
if (result != ISC_R_SUCCESS) {
isc_mem_free(ns_g_mctx, data);
return result;
}
*retData = data;
return ISC_R_SUCCESS;
}
static void
DoTest(int n)
{
int res;
SQLCHAR output[256];
SQLSMALLINT colType;
SQLULEN colSize;
SQLSMALLINT colScale, colNullable;
SQLLEN dataSize;
TIMESTAMP_STRUCT ts;
if (CommandWithResult(Statement, "select convert(datetime, '2002-12-27 18:43:21')") != SQL_SUCCESS)
ODBC_REPORT_ERROR("Unable to execute statement");
res = SQLFetch(Statement);
if (res != SQL_SUCCESS && res != SQL_SUCCESS_WITH_INFO)
ODBC_REPORT_ERROR("Unable to fetch row");
if (SQLDescribeCol(Statement, 1, output, sizeof(output), NULL, &colType, &colSize, &colScale, &colNullable) != SQL_SUCCESS)
ODBC_REPORT_ERROR("Error getting data");
if (n == 0) {
memset(&ts, 0, sizeof(ts));
if (SQLGetData(Statement, 1, SQL_C_TIMESTAMP, &ts, sizeof(ts), &dataSize) != SQL_SUCCESS) {
printf("Unable to get data col %d\n", 1);
CheckReturn();
exit(1);
}
sprintf((char *) output, "%04d-%02d-%02d %02d:%02d:%02d.000", ts.year, ts.month, ts.day, ts.hour, ts.minute, ts.second);
} else {
if (SQLGetData(Statement, 1, SQL_C_CHAR, output, sizeof(output), &dataSize) != SQL_SUCCESS) {
printf("Unable to get data col %d\n", 1);
CheckReturn();
exit(1);
}
}
printf("Date returned: %s\n", output);
if (strcmp((char *) output, "2002-12-27 18:43:21.000") != 0) {
printf("Invalid returned date\n");
exit(1);
}
res = SQLFetch(Statement);
if (res != SQL_NO_DATA)
ODBC_REPORT_ERROR("Unable to fetch row");
res = SQLCloseCursor(Statement);
if (!SQL_SUCCEEDED(res))
ODBC_REPORT_ERROR("Unable to close cursor");
}
/* LAST_INSERT_ID */
unsigned long long SMSDODBC_SeqID(GSM_SMSDConfig * Config, const char *id)
{
SQLRETURN ret;
SQLHSTMT stmt;
SQLINTEGER value;
ret = SQLAllocHandle(SQL_HANDLE_STMT, Config->conn.odbc.dbc, &stmt);
if (!SQL_SUCCEEDED(ret)) {
return 0;
}
ret = SQLExecDirect (stmt, (SQLCHAR*)"SELECT @@IDENTITY", SQL_NTS);
if (!SQL_SUCCEEDED(ret)) {
SQLFreeHandle (SQL_HANDLE_STMT, stmt);
return 0;
}
ret = SQLFetch(stmt);
if (!SQL_SUCCEEDED(ret)) {
SQLFreeHandle (SQL_HANDLE_STMT, stmt);
return 0;
}
ret = SQLGetData(stmt, 1, SQL_C_SLONG, &value, 0, NULL);
if (!SQL_SUCCEEDED(ret)) {
SQLFreeHandle (SQL_HANDLE_STMT, stmt);
return 0;
}
SQLFreeHandle (SQL_HANDLE_STMT, stmt);
return value;
}
static PyObject*
GetDataLongLong(Cursor* cur, int iCol)
{
ColumnInfo* pinfo = &cur->colinfos[iCol];
INT64 value = 0;
SQLLEN cbFetched = 0;
SQLRETURN ret;
SQLSMALLINT nCType = pinfo->is_unsigned ? SQL_C_UBIGINT : SQL_C_SBIGINT;
Py_BEGIN_ALLOW_THREADS
ret = SQLGetData(cur->hstmt, (SQLSMALLINT)(iCol+1), nCType, &value, sizeof(value), &cbFetched);
Py_END_ALLOW_THREADS
if (!SQL_SUCCEEDED(ret))
return RaiseErrorFromHandle("SQLGetData", cur->cnxn->hdbc, cur->hstmt);
if (cbFetched == SQL_NULL_DATA)
Py_RETURN_NONE;
if (pinfo->is_unsigned)
return PyLong_FromLongLong(*(UINT64*)&value);
return PyLong_FromLongLong(*(INT64*)&value);
}
