void remove_catalogs(void) { SQLRETURN retcode; void remove_update_queue_tables(void); sql_db_connection = (TM_CONNECTION *)malloc(sizeof(TM_CONNECTION)); // Allocate an environment handle retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &(sql_db_connection->henv)); if( retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO ) { /* Set the ODBC version environment attribute */ retcode = SQLSetEnvAttr(sql_db_connection->henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) { /* Allocate a connection handle */ retcode = SQLAllocHandle(SQL_HANDLE_DBC, sql_db_connection->henv, &(sql_db_connection->hdbc)); if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) { /* Connect to data source */ retcode = SQLConnect(sql_db_connection->hdbc, (SQLCHAR*) odbc_dsn, SQL_NTS, (SQLCHAR*) username, SQL_NTS, (SQLCHAR*) password, SQL_NTS); if( retcode == SQL_ERROR ) { SQLFreeHandle(SQL_HANDLE_DBC, sql_db_connection->hdbc); SQLFreeHandle(SQL_HANDLE_ENV, sql_db_connection->henv); printf ("Error: unable to connect to SQL Server\n"); puts ("Ensure that the DBMS is running and that your ODBC DSN settings are correct."); exit (EXIT_FAILURE); } } else { SQLFreeHandle(SQL_HANDLE_DBC, sql_db_connection->hdbc); SQLFreeHandle(SQL_HANDLE_ENV, sql_db_connection->henv); printf ("Error: unable to connect to SQL Server\n"); puts ("Ensure that the DBMS is running and that your ODBC DSN settings are correct."); exit (EXIT_FAILURE); } } } else { SQLFreeHandle(SQL_HANDLE_ENV, sql_db_connection->henv); printf ("Error: unable to connect to SQL Server\n"); puts ("Ensure that the DBMS is running and that your ODBC DSN settings are correct."); exit (EXIT_FAILURE); } printf ("\n\nConnected to SQL Server.\n\n"); puts ("Removing Vigilert's catalogs will delete your Vigilert triggers,"); puts ("triggersets, data sources, pending mail, pending OS commands, and pending notices."); printf ("Are you sure you want to do this (Y/N)? "); fgets (yesno, sizeof (yesno), stdin); yesno[strlen (yesno) - 1] = '\0'; // Remove trailing \n. if (stricmp (yesno, "y") != 0) { exit (EXIT_SUCCESS); } puts (""); remove_update_queue_tables(); exec_sql_stmt("drop table vl_DataSrc"); puts ("vl_DataSrc"); exec_sql_stmt("drop table vl_DataSrcAtb"), puts ("vl_datasrcatb"); exec_sql_stmt("drop table vl_IDTable"); puts ("vl_idtable"); exec_sql_stmt("drop table vl_TriggerSet"); puts ("vl_TriggerSet"); exec_sql_stmt("drop table vl_Trigger"); puts ("vl_Trigger"); exec_sql_stmt("drop table vl_TrigDataSrcReln"); puts ("vl_TrigDataSrcReln"); exec_sql_stmt("drop table vl_mail"); puts ("vl_mail"); exec_sql_stmt("drop table vl_osexec"); puts ("vl_osexec"); exec_sql_stmt("drop table vl_notice"); puts ("vl_notice"); exec_sql_stmt("drop table vl_DataSrcMtb"); puts ("vl_DataSrcMtb"); exec_sql_stmt("drop table vl_null_tbl"); puts ("vl_null_tbl"); exec_sql_stmt("drop table vl_mon_watch"); puts ("vl_mon_watch"); exec_sql_stmt("drop table vl_mon_update"); puts ("vl_mon_update"); exec_sql_stmt("drop table vl_ext_fcn_tbl"); puts ("vl_ext_fcn_tbl"); }
ConnectionHolder(Environment &env) { if (SQLAllocHandle(SQL_HANDLE_DBC, env.GetHolder().GetHandle(), &Conn) != SQL_SUCCESS) throw ConnectionException("Error allocate connection", ceErrorAllocConnection); }
CDBBinary CODBCRecordset::SelectBinary(const CString& strQuery) { CDBBinary DBBinary(5, 5); DBBinary.Clear(); DBBinary.SetCurUsedSize(-1); if (0 == strQuery.GetLength()) { return DBBinary; } HSTMT hStmt; unsigned char Data[BINARY_FIELD_MAX_SIZE] = {0}; SQLLEN ind = SQL_DATA_AT_EXEC; if (SQL_SUCCESS != SQLAllocHandle(SQL_HANDLE_STMT, m_pDatabase->GetConn(), &hStmt)) { return DBBinary; } SQLPrepare(hStmt, SQLData(strQuery), SQL_NTS); if (SQL_ERROR == SQLBindParameter(hStmt, 1, SQL_PARAM_OUTPUT, SQL_C_BINARY, SQL_BINARY, BINARY_FIELD_MAX_SIZE, 0, (SQLPOINTER)Data, BINARY_FIELD_MAX_SIZE, &ind)) { return DBBinary; } if (SQL_ERROR == SQLExecute(hStmt)) { return DBBinary; } SQLLEN sqlLen; DBBinary.Begin(); while (SQL_SUCCESS == SQLFetch(hStmt)) { if (!m_pDatabase->IsOpen()) { DBBinary.SetCurUsedSize(-1); return DBBinary; } if (SQL_ERROR == SQLGetData(hStmt, 1, SQL_BINARY, (SQLPOINTER)Data, BINARY_FIELD_MAX_SIZE, &sqlLen)) { DBBinary.SetCurUsedSize(-1); return DBBinary; } if (-1 == sqlLen) { if (0 != DBBinary.InsertData(Data, 0)) { DBBinary.SetCurUsedSize(-1); return DBBinary; } continue; } if (SQL_ERROR == SQLGetData(hStmt, 1, SQL_C_DEFAULT, (SQLPOINTER)Data, sqlLen, &ind)) { DBBinary.SetCurUsedSize(-1); return DBBinary; } if (sqlLen != DBBinary.InsertData(Data, sqlLen)) { DBBinary.SetCurUsedSize(-1); return DBBinary; } } SQLFreeHandle(SQL_HANDLE_STMT, hStmt); return DBBinary; }
static int odbc_dispatch11(void) { unsigned long retval; PWord rval; int rtype; PWord arg1; int type1; PWord arg2; int type2; PWord arg3; int type3; PWord arg4; int type4; PWord arg5; int type5; PI_getan(&arg1,&type1,1); if (type1 != PI_INT) if (!CI_get_integer((unsigned long *)&arg1,type1)) PI_FAIL; PI_getan(&arg2,&type2,2); if (type2 != PI_INT) if (!CI_get_integer((unsigned long *)&arg2,type2)) PI_FAIL; PI_getan(&arg3,&type3,3); if (type3 != PI_INT) if (!CI_get_integer((unsigned long *)&arg3,type3)) PI_FAIL; PI_getan(&arg4,&type4,4); if (type4 != PI_INT) if (!CI_get_integer((unsigned long *)&arg4,type4)) PI_FAIL; PI_getan(&arg5,&type5,5); switch(arg1) { case 0: retval = (unsigned long) SQLAllocHandleStd(((SQLSMALLINT ) arg2),((SQLHANDLE ) arg3),((SQLHANDLE * ) arg4)); break; case 1: retval = (unsigned long) SQLParamOptions(((SQLHSTMT ) arg2),((SQLUINTEGER ) arg3),((SQLUINTEGER * ) arg4)); break; case 2: retval = (unsigned long) SQLTransact(((SQLHENV ) arg2),((SQLHDBC ) arg3),((SQLUSMALLINT ) arg4)); break; case 3: retval = (unsigned long) SQLSetStmtOption(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLUINTEGER ) arg4)); break; case 4: retval = (unsigned long) SQLSetConnectOption(((SQLHDBC ) arg2),((SQLUSMALLINT ) arg3),((SQLUINTEGER ) arg4)); break; case 5: retval = (unsigned long) SQLPutData(((SQLHSTMT ) arg2),((SQLPOINTER ) arg3),((SQLINTEGER ) arg4)); break; case 6: retval = (unsigned long) SQLGetStmtOption(((SQLHSTMT ) arg2),((SQLUSMALLINT ) arg3),((SQLPOINTER ) arg4)); break; case 7: retval = (unsigned long) SQLGetFunctions(((SQLHDBC ) arg2),((SQLUSMALLINT ) arg3),((SQLUSMALLINT * ) arg4)); break; case 8: retval = (unsigned long) SQLGetConnectOption(((SQLHDBC ) arg2),((SQLUSMALLINT ) arg3),((SQLPOINTER ) arg4)); break; case 9: retval = (unsigned long) SQLFetchScroll(((SQLHSTMT ) arg2),((SQLSMALLINT ) arg3),((SQLINTEGER ) arg4)); break; case 10: retval = (unsigned long) SQLEndTran(((SQLSMALLINT ) arg2),((SQLHANDLE ) arg3),((SQLSMALLINT ) arg4)); break; case 11: retval = (unsigned long) SQLAllocHandle(((SQLSMALLINT ) arg2),((SQLHANDLE ) arg3),((SQLHANDLE * ) arg4)); break; default: PI_FAIL; } PI_makedouble(&rval,&rtype,(double) retval); if (PI_unify(arg5,type5,rval,rtype)) PI_SUCCEED; PI_FAIL; }
static isc_result_t odbc_connect(odbc_instance_t *dbi, odbc_db_t **dbc) { odbc_db_t *ndb = *dbc; SQLRETURN sqlRes; isc_result_t result = ISC_R_SUCCESS; if (ndb != NULL) { /* * if db != null, we have to do some cleanup * if statement handle != null free it */ if (ndb->stmnt != NULL) { SQLFreeHandle(SQL_HANDLE_STMT, ndb->stmnt); ndb->stmnt = NULL; } /* if connection handle != null free it */ if (ndb->dbc != NULL) { SQLFreeHandle(SQL_HANDLE_DBC, ndb->dbc); ndb->dbc = NULL; } } else { ndb = isc_mem_allocate(ns_g_mctx, sizeof(odbc_db_t)); if (ndb == NULL) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver unable to allocate memory"); return ISC_R_NOMEMORY; } memset(ndb, 0, sizeof(odbc_db_t)); } sqlRes = SQLAllocHandle(SQL_HANDLE_DBC, dbi->sql_env, &(ndb->dbc)); if (!sqlOK(sqlRes)) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver unable to allocate memory"); result = ISC_R_NOMEMORY; goto cleanup; } sqlRes = SQLConnect(ndb->dbc, dbi->dsn, safeLen(dbi->dsn), dbi->user, safeLen(dbi->user), dbi->pass, safeLen(dbi->pass)); if (!sqlOK(sqlRes)) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver unable to connect"); result = ISC_R_FAILURE; goto cleanup; } sqlRes = SQLAllocHandle(SQL_HANDLE_STMT, ndb->dbc, &(ndb->stmnt)); if (!sqlOK(sqlRes)) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver unable to allocate memory"); result = ISC_R_NOMEMORY; goto cleanup; } *dbc = ndb; return ISC_R_SUCCESS; cleanup: if (ndb != NULL) { /* if statement handle != null free it */ if (ndb->stmnt != NULL) { SQLFreeHandle(SQL_HANDLE_STMT, ndb->stmnt); ndb->stmnt = NULL; } /* if connection handle != null free it */ if (ndb->dbc != NULL) { SQLDisconnect(ndb->dbc); SQLFreeHandle(SQL_HANDLE_DBC, ndb->dbc); ndb->dbc = NULL; } /* free memory holding ndb */ isc_mem_free(ns_g_mctx, ndb); } return result; }
int main() { SQLHENV env; SQLHDBC dbc; SQLHSTMT stmt; SQLRETURN ret; SQLCHAR outstr[1024]; SQLSMALLINT outstrlen; // Aloocate an environment handle ret=SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&env); checkrc(ret,__LINE__); //we need odbc3 support SQLSetEnvAttr(env,SQL_ATTR_ODBC_VERSION,(void*)SQL_OV_ODBC3,0); //ALLOCATE A Connection handle ret = SQLAllocHandle(SQL_HANDLE_DBC,env,&dbc); checkrc(ret,__LINE__); // connect to the DSN mydsn ret = SQLConnect (dbc, (SQLCHAR *) "test", (SQLSMALLINT) strlen ("test"), (SQLCHAR *) "root", (SQLSMALLINT) strlen ("root"), (SQLCHAR *) "manager", (SQLSMALLINT) strlen ("")); if(SQL_SUCCEEDED(ret)) { printf("\nConnected to the Data Source..\n"); } else { printf("error in connection\n"); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); return 1; } //****************************************************************** // TABLE CREATED ret = SQLAllocHandle(SQL_HANDLE_STMT,dbc,&stmt); checkrc(ret,__LINE__); SQLCHAR table[200]= "CREATE TABLE T1(F1 INT,F2 INT)"; ret = SQLPrepare(stmt,table,SQL_NTS); checkrc(ret,__LINE__); ret = SQLExecute(stmt); printf("\nTABLE CREATED\n"); //**************************************************************** InsertTest(env,dbc,stmt); //***************************************************************** int ret1; ret1=FetchTest(env,dbc,stmt); //**************************************************************** ret = SQLPrepare(stmt,(unsigned char*)"drop table T1;",SQL_NTS); checkrc(ret,__LINE__); ret = SQLExecute(stmt); checkrc(ret,__LINE__); printf("Table 'T1' Dropped\n"); ret = SQLFreeHandle(SQL_HANDLE_STMT,stmt); checkrc(ret,__LINE__); ret = SQLDisconnect(dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); if(ret1 == 0)return 1; return 0; }
int main(int argc, char * argv[]) { HDBC hdbc; HENV henv; HSTMT hstmt; RETCODE rc; UCHAR uid[UID_LEN]; UCHAR pwd[PWD_LEN]; UCHAR file[OPT1_LEN]; UCHAR dsn[DSN_LEN]; uid[0] = (UCHAR)NULL; file[0] = (UCHAR)NULL; dsn[0] = (UCHAR)NULL; pwd[0] = (UCHAR)NULL; if (argc > 1) { int argIndex; /* Input argument index */ int argCount; /* Running count of arguments */ for (argCount=argc-1, argIndex=1; argCount > 0; argIndex++, argCount--) { switch (ArgParse(argv[argIndex])) { case HELP_ARG: printf(USAGE_MSG1, argv[0]); return(1); case PWD_ARG: argIndex++; if (argCount <= 1) { printf(PWD_ERR1); printf(USAGE_MSG1, argv[0]); return(1); } if (strlen(argv[argIndex]) > PWD_LEN) { printf(PWD_MSG1, PWD_LEN); return(1); } strcpy((char*)pwd, argv[argIndex]); argCount--; break; case UID_ARG: argIndex++; if (argCount <= 1) { printf(UID_ERR1); printf(USAGE_MSG1, argv[0]); return(1); } if (strlen(argv[argIndex]) > UID_LEN) { printf(UID_MSG1, UID_LEN); return(1); } strcpy((char*)uid, argv[argIndex]); argCount--; break; case DSN_ARG: argIndex++; if (argCount <= 1) { printf(DSN_ERR1); printf(USAGE_MSG1, argv[0]); return(1); } if (strlen(argv[argIndex]) > DSN_LEN) { printf(DSN_MSG1, DSN_LEN); return(1); } strcpy((char*)dsn, argv[argIndex]); argCount--; break; case FILE_ARG: argIndex++; if (argCount <= 1) { printf(FILE_ERR1); printf(USAGE_MSG1, argv[0]); return(1); } if (strlen(argv[argIndex]) > OPT1_LEN) { printf(FILE_MSG1, OPT1_LEN); return(1); } strcpy((char*)file, argv[argIndex]); argCount--; break; } } } else { printf(USAGE_MSG1, argv[0]); return(1); } #if !defined (__cplusplus) && defined (hppa) /* ** C programs must call the HP C++ Object initializer function. */ _main (); #endif rc = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); if ((rc != SQL_SUCCESS) && (rc != SQL_SUCCESS_WITH_INFO)) { printf("Failed to initialize ODBC environmment...\n"); exit(255); /* Exit with failure */ } ODBC_initialize ( &henv ); ODBC_prepareCon ( henv, &hdbc ); rc = ODBC_connect(henv, hdbc, dsn, uid, pwd); if ((rc != SQL_SUCCESS) && (rc != SQL_SUCCESS_WITH_INFO)) exit(255); /* Exit with failure */ /* ** Allocate a HSTMT to communicate with ODBC DB Driver. */ rc = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt); if ((rc != SQL_SUCCESS) && (rc != SQL_SUCCESS_WITH_INFO)) { printf ("Unable to Allocate a statement handle.\n"); ODBC_getErrorInfo (henv, hdbc, hstmt); ODBC_releaseEnv(henv, hdbc); exit (255); } if(file[0] == (UCHAR) NULL) { printf("\nPlease enter SQL script file: "); scanf("%s", (char*)file); } ODBC_fileRead ((char*)file, henv, hdbc, hstmt); SQLFreeHandle (SQL_HANDLE_STMT, hstmt); ODBC_releaseEnv (henv, hdbc); return(0); }
bool OdbcConnection::Connect() { if (m_szDSN.length() == 0) return false; m_lock.Acquire(); tstring szConn = _T("DSN=") + m_szDSN + _T(";"); // Reconnect if we need to. if (isConnected()) Disconnect(); // Allocate enviroment handle if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &m_envHandle))) { ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLAllocHandle"), _T("Unable to allocate environment handle.")); goto error_handler; } // Request ODBC3 support if (!SQL_SUCCEEDED(SQLSetEnvAttr(m_envHandle, SQL_ATTR_ODBC_VERSION, (void *)SQL_OV_ODBC3, 0))) { ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLSetEnvAttr"), _T("Unable to set environment attribute (SQL_ATTR_ODBC_VERSION).")); goto error_handler; } // Allocate the connection handle if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, m_envHandle, &m_connHandle))) { ReportSQLError(SQL_HANDLE_ENV, m_envHandle, _T("SQLAllocHandle"), _T("Unable to allocate connection handle.")); goto error_handler; } if (m_szUser.length()) { szConn += _T("UID=") + m_szUser + _T(";"); if (m_szPass.length()) szConn += _T("PWD=") + m_szPass + _T(";"); } // Enable multiple active result sets if (m_bMarsEnabled) szConn += _T("MARS_Connection=yes;"); if (!SQL_SUCCEEDED(SQLDriverConnect(m_connHandle, NULL, (SQLTCHAR *)szConn.c_str(), SQL_NTS, NULL, NULL, NULL, NULL))) { ReportSQLError(SQL_HANDLE_DBC, m_connHandle, _T("SQLDriverConnect"), _T("Unable to establish connection.")); goto error_handler; } for (auto itr = m_commandSet.begin(); itr != m_commandSet.end(); itr++) (*itr)->SetConnectionHandle(m_connHandle); m_lock.Release(); return true; error_handler: ResetHandles(); m_lock.Release(); return false; }
int main() { SQLHENV env; SQLHDBC dbc; SQLHSTMT stmt; SQLRETURN ret; SQLCHAR outstr[1024]; SQLSMALLINT outstrlen; // Aloocate an environment handle ret=SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&env); checkrc(ret,__LINE__); //we need odbc3 support ret =SQLSetEnvAttr(env,SQL_ATTR_ODBC_VERSION,(void*)SQL_OV_ODBC3,0); checkrc(ret,__LINE__); //ALLOCATE A Connection handle ret = SQLAllocHandle(SQL_HANDLE_DBC,env,&dbc); checkrc(ret,__LINE__); // connect to the DSN mydsn ret = SQLConnect (dbc, (SQLCHAR *) "DSN=mycsql;MODE=csql;SERVER=127.0.0.1;PORT=5678;", (SQLSMALLINT) strlen ("DSN=mycsql;MODE=csql;SERVER=127.0.0.1;PORT=5678;"), (SQLCHAR *) "root", (SQLSMALLINT) strlen ("root"), (SQLCHAR *) "manager", (SQLSMALLINT) strlen ("")); if(SQL_SUCCEEDED(ret)) { printf("\nConnected to the Data Source..\n"); } else { printf("error in connection\n"); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); return 1; } ret = SQLSetConnectAttr(dbc,SQL_ATTR_AUTOCOMMIT,(void*)SQL_AUTOCOMMIT_OFF,SQL_IS_UINTEGER); checkrc(ret,__LINE__); //****************************************************************** // TABLE CREATED ret = SQLAllocHandle(SQL_HANDLE_STMT,dbc,&stmt); checkrc(ret,__LINE__); SQLCHAR table[200]= "CREATE TABLE T1(F1 INT,F2 INT);"; ret = SQLPrepare(stmt,table,SQL_NTS); checkrc(ret,__LINE__); ret = SQLExecute(stmt); checkrc(ret,__LINE__); SQLFreeStmt(stmt, SQL_CLOSE); printf("\nTABLE CREATED\n"); //**************************************************************** ret = SQLPrepare(stmt,(unsigned char*)"INSERT INTO T1 VALUES(1,1);",SQL_NTS); checkrc(ret,__LINE__); ret = SQLExecute(stmt); checkrc(ret,__LINE__); SQLFreeStmt(stmt, SQL_CLOSE); ret = SQLEndTran(SQL_HANDLE_DBC,dbc,SQL_COMMIT); if(ret!=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO) printf("error in commit\n"); //InsertTest(env,dbc,stmt); //***************************************************************** //update ret = SQLPrepare(stmt,(unsigned char*)"UPDATE T1 SET F2=100;",SQL_NTS); checkrc(ret,__LINE__); ret = SQLExecute(stmt); checkrc(ret,__LINE__); SQLFreeStmt(stmt, SQL_CLOSE); ret = SQLEndTran(SQL_HANDLE_DBC,dbc,SQL_COMMIT); if(ret!=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO) printf("error in commit\n"); checkrc(ret,__LINE__); //*********************************************************** //FETCH FetchTest(env,dbc,stmt); //**************************************************************** ret = SQLExecDirect(stmt,(unsigned char*)"DROP TABLE T1",SQL_NTS); checkrc(ret,__LINE__); SQLFreeStmt(stmt, SQL_CLOSE); printf("Table T1 dropped\n"); ret = SQLFreeHandle(SQL_HANDLE_STMT,stmt); checkrc(ret,__LINE__); ret = SQLDisconnect(dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); return 0; }
OdbcHandle odbcConnect(const char* dbname, const char* servername, const char* username, const char* driver, const char* password) { OdbcHandle handle = new OdbcControlStruct; if (handle) { if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &handle->mEnvironmentHandle))) { Os::Logger::instance().log(FAC_ODBC, PRI_ERR, "odbcConnect: Failed to allocate " "environment handle"); delete handle; handle = NULL; } else { SQLSetEnvAttr(handle->mEnvironmentHandle, SQL_ATTR_ODBC_VERSION, (void*) SQL_OV_ODBC3, 0); if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_DBC, handle->mEnvironmentHandle, &handle->mConnectionHandle))) { Os::Logger::instance().log(FAC_ODBC, PRI_ERR, "odbcConnect: Failed to allocate " "connection handle"); extract_error("SQLSetEnvAttr", handle->mEnvironmentHandle, SQL_HANDLE_ENV); SQLFreeHandle(SQL_HANDLE_ENV, handle->mEnvironmentHandle); delete handle; handle = NULL; } else { // Connect - contruct connection string UtlString connectionString; char temp[128]; if (dbname) { sprintf(temp, "DATABASE=%s;", dbname); connectionString.append(temp); } if (servername) { sprintf(temp, "SERVER=%s;", servername); connectionString.append(temp); } if (username) { sprintf(temp, "UID=%s;", username); connectionString.append(temp); } if (password) { sprintf(temp, "PWD=%s;", password); connectionString.append(temp); } else { connectionString.append("PWD=;"); } if (driver) { sprintf(temp, "DRIVER=%s;", driver); connectionString.append(temp); } // Connect in read/write mode connectionString.append("READONLY=0;"); SQLRETURN sqlRet = SQLDriverConnect(handle->mConnectionHandle, NULL, (SQLCHAR*)connectionString.data(), SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT); if (!SQL_SUCCEEDED(sqlRet)) { Os::Logger::instance().log(FAC_ODBC, PRI_ERR, "odbcConnect: Failed to connect %s, error code %d", connectionString.data(), sqlRet); extract_error("SQLDriverConnect", handle->mConnectionHandle, SQL_HANDLE_DBC); SQLFreeHandle(SQL_HANDLE_DBC, handle->mConnectionHandle); SQLFreeHandle(SQL_HANDLE_ENV, handle->mEnvironmentHandle); delete handle; handle = NULL; } else { // Connected to database, now alloc a statement handle if (!SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_STMT, handle->mConnectionHandle, &handle->mStatementHandle))) { Os::Logger::instance().log(FAC_ODBC, PRI_ERR, "odbcConnect: Failed to allocate " "statement handle"); extract_error("SQLAllocHandle", handle->mStatementHandle, SQL_HANDLE_STMT); // Disconnect from database SQLDisconnect(handle->mConnectionHandle); // Free resources SQLFreeHandle(SQL_HANDLE_DBC, handle->mConnectionHandle); SQLFreeHandle(SQL_HANDLE_ENV, handle->mEnvironmentHandle); delete handle; handle = NULL; } else { Os::Logger::instance().log(FAC_ODBC, PRI_DEBUG, "odbcConnect: Connected to database " "%s, OdbcHandle %p", connectionString.data(), handle); } } } } } else { Os::Logger::instance().log(FAC_ODBC, PRI_ERR, "odbcConnect: Couldn't create OdbcHandle"); } return handle; }
/* --------------------------------------------------------- TestSQLGetDescRec --------------------------------------------------------- */ PassFail TestMXSQLGetDescRec(TestInfo *pTestInfo) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt, hstmt1; //Common input params to the apis SQLHDESC hIrd, hImArd, hImIrd, hImApd, hImIpd, hExArd, hExApd; SWORD RecNumber = 0; //SQLGetDescRec: params SQLHDESC getDescRecHandle; //input SWORD getDescRecNumber; //input TCHAR getDescName[MAXLEN]; SWORD getNameMaxLength; //input; MAXLEN = 100 : defined in Common.h SWORD getDescNameActualLength; SQLSMALLINT getDescType; SWORD getDescIntervalCode; SQLLEN getDescOctectLength; SWORD getDescPrecision; SWORD getDescScale; SWORD getDescNullable; //SQLSetDescRec: params SQLHDESC setDescRecHandle; SQLSMALLINT setDescRecNumber; SQLSMALLINT setDescType; SQLSMALLINT setDescIntervalCode; SQLINTEGER setDescOctetLength; SQLSMALLINT setDescPrecision; SQLSMALLINT setDescScale; SQLPOINTER setDescDataPtr; SQLLEN setDescOctectLengthPtr; SQLLEN setDescIndicatorPtr; TCHAR setDescName[1]; SQLINTEGER setDescNullable = SQL_NULL_DATA; short int i; // Template for a Descriptor record typedef struct { // TCHAR DescName[MAXLEN]; TCHAR *DescName; short int DescType; short int DescDatetimeIntervalCode; short int DescOctetLength; short int DescPrecision; short int DescScale; void* DescDataPtr; short int DescOctectLengthPtr; short int DescIndicatorPtr; short int DescNullable; }DescRec; DescRec TestDataAPD[DATA_ARR_LEN] = { //APD // DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable {_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN } }; DescRec TestDataARD[DATA_ARR_LEN] = { //ARD // DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable {_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN } }; DescRec TestDataIPD[DATA_ARR_LEN] = { //IPD // DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable {_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, 0, 0, 0, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_TYPE_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, 0, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN } }; DescRec TestDataIRD[DATA_ARR_LEN] = { //IRD can only be read // DescName Type DatetimeIntervalCode DescOctetLength Precision DescScale DescDataPtr OctectLengthPtr IndicatorPtr DescNullable {_T(""), SQL_C_DEFAULT, 0, 0, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 80, 0, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TCHAR, 0, 300, 0, 0, NULL, SQL_NTS, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_NUMERIC, 0, 0, 0, 0, NULL, SQL_DATA_AT_EXEC, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_TIMESTAMP, SQL_CODE_TIMESTAMP, 0, 6, 1, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN }, {_T(""), SQL_C_INTERVAL_SECOND, SQL_CODE_SECOND, 0, 2, 0, NULL, 0, SQL_NULL_DATA, SQL_NULLABLE_UNKNOWN } }; _tcscpy(setDescName, _T("")); // ================================================================================================================ // begin common test setup //================================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLSetDescRec and SQLGetDescRec.\n")); TEST_INIT; if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } //Explicit APD //allocate an Explicit APD desc returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExApd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle to get explicit APD")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } //Explicit ARD returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExArd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle to get explicit ARD")) { LogAllErrorsVer3(henv,hdbc,hstmt); FullDisconnect(pTestInfo); TEST_FAILED; TEST_RETURN; } //=============================================================================================================== // Begin Testing:Positive Test for Implicit APD //=============================================================================================================== //Get Implicit APD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hImApd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get APD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting Implicit APD tests.\n")); TEST_FAILED; goto ExAPDtests; // transfers control to the next set of tests } for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataAPD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit APD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hImApd ; setDescRecNumber = RecNumber; setDescType = TestDataAPD[i].DescType; setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataAPD[i].DescOctetLength; setDescPrecision = TestDataAPD[i].DescPrecision; setDescScale = TestDataAPD[i].DescScale; setDescDataPtr = TestDataAPD[i].DescDataPtr; setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr; /*LogMsg(NONE,_T("SQLSetDescRec(handle,%d,%d,%d,%d,%d,%d,%s,%d,%d)\n"), setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr, setDescOctectLengthPtr, setDescIndicatorPtr); */ returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec ")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit APD: TestDataAPD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //Get the Implicit APD Descriptor //LogMsg(SHORTTIMESTAMP,"SQLGetDescRec: test for Implicit APD.\n"); LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Implicit APD.\n")); getDescRecHandle = hImApd; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataAPD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit APD: TestDataAPD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //begin checking APD values ---------- //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for APD //=============================================================================================================== // Begin Testing:Positive Test for Explicit APD //=============================================================================================================== ExAPDtests: ; // beginning next set of tests //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit APD.\n"); //Get Explicit APD handle returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExApd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle: get Explicit APD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting Explicit APD tests.\n")); TEST_FAILED; //TEST_RETURN; goto ARDtests; // transfers control to the next set of tests } //associate with a statement returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, (SQLPOINTER)hExApd, SQL_IS_POINTER); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr: explicit APD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot set Explicit APD for statement.\n")); TEST_FAILED; } setDescRecHandle = hExApd ; for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataAPD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit APD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecNumber = RecNumber; setDescType = TestDataAPD[i].DescType; setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataAPD[i].DescOctetLength; setDescPrecision = TestDataAPD[i].DescPrecision; setDescScale = TestDataAPD[i].DescScale; setDescDataPtr = TestDataAPD[i].DescDataPtr; setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr; /*LogMsg(NONE,_T("SQLSetDescRect(handle,%d,%d,%d,%d,%d,%d,%s,%d,%d)\n"), setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr, setDescOctectLengthPtr, setDescIndicatorPtr);*/ returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Explicit APD: TestDataAPD['%d'].\n"),i); TEST_FAILED; //TEST_RETURN; continue; } //Get the Explicit APD Descriptor //LogMsg(SHORTTIMESTAMP,"SQLGetDescRec: test for Implicit APD.\n"); LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Explicit APD.\n")); getDescRecHandle = setDescRecHandle; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataAPD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Explicit APD: TestDataAPD['%d'].\n"),i); TEST_FAILED; continue; } //begin checking APD values //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for Explicit APD //=============================================================================================================== // Begin Testing: Statement reverts to Implicit APD after freeing Explicit Descriptor //=============================================================================================================== //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "SQLGetDescRec for Explicit-Implicit APD: statement reverts to implicit descriptor after explicit descriptor has been freed.\n"); //free Explicit APD returncode = SQLFreeHandle(SQL_HANDLE_DESC, hExApd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle (for APD)")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("Cannot free explicit descriptor: Aborting Explicit-Implicit Descriptor tests.\n")); TEST_FAILED; goto ARDtests; // transfers control to the next set of tests } //Use the previously allocated Implicit APD handle getDescRecHandle = hImApd; TESTCASE_BEGIN("Test that the implicit descriptor get associated with statement after explicit descriptor has been freed.\n"); //set multiple Fields i = 0; RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecNumber = RecNumber; setDescType = TestDataAPD[i].DescType; setDescIntervalCode = TestDataAPD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataAPD[i].DescOctetLength; setDescPrecision = TestDataAPD[i].DescPrecision; setDescScale = TestDataAPD[i].DescScale; setDescDataPtr = TestDataAPD[i].DescDataPtr; setDescOctectLengthPtr = TestDataAPD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataAPD[i].DescIndicatorPtr; //Get the Implicit APD Descriptor LogMsg(NONE,_T("SQLGetDescRec: tests for Explicit-Implicit Descriptor.\n")); getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataAPD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: tests for Explicit-Implicit APD: TestDataAPD['%d'].\n"),i); TEST_FAILED; //continue; } //begin checking APD values ---------- //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; //================================================================================================================== // Begin Testing: Positive Test for Implicit ARD //=================================================================================================================== ARDtests: ; //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit ARD.\n"); //Get Implicit ARD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hImArd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get ARD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot get ARD: Aborting Implicit ARD tests.\n")); TEST_FAILED; goto ExARDtests; //go to next set of tests } for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataARD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit ARD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hImArd ; setDescRecNumber = RecNumber; setDescType = TestDataARD[i].DescType; setDescIntervalCode = TestDataARD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataARD[i].DescOctetLength; setDescPrecision = TestDataARD[i].DescPrecision; setDescScale = TestDataARD[i].DescScale; setDescDataPtr = TestDataARD[i].DescDataPtr; setDescOctectLengthPtr = TestDataARD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataARD[i].DescIndicatorPtr; returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit ARD: TestDataARD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //Get the Implicit ARD Descriptor LogMsg(NONE,_T("SQLSetDescRec / SQLGetDescRec: positive tests for Implicit ARD.\n")); getDescRecHandle = hImApd; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataARD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec and SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit ARD: TestDataARD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; break; } //begin checking ARD values //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for ARD //================================================================================================================== // Begin Testing: Positive Test for Explicit ARD //=================================================================================================================== ExARDtests: ; //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit ARD.\n"); //Get Explicit ARD handle returncode = SQLAllocHandle(SQL_HANDLE_DESC, (SQLHANDLE)hdbc, &hExArd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle: get explicit ARD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot get ARD: Aborting Implicit ARD tests.\n")); TEST_FAILED; goto IPDtests; //go to next set of tests } //associate with a statement returncode = SQLSetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, (SQLPOINTER)hExArd, SQL_IS_POINTER); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtAttr: explicit ARD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot set Explicit ARD for statement.\n")); TEST_FAILED; } for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataARD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Explicit ARD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hExArd ; setDescRecNumber = RecNumber; setDescType = TestDataARD[i].DescType; setDescIntervalCode = TestDataARD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataARD[i].DescOctetLength; setDescPrecision = TestDataARD[i].DescPrecision; setDescScale = TestDataARD[i].DescScale; setDescDataPtr = TestDataARD[i].DescDataPtr; setDescOctectLengthPtr = TestDataARD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataARD[i].DescIndicatorPtr; returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Explicit ARD: TestDataARD['%d'].\n"),i); TEST_FAILED; continue; } //Get the Explicit ARD Descriptor LogMsg(NONE,_T("SQLSetDescRec and SQLGetDescRec: positive tests for Explicit ARD.\n")); getDescRecHandle = hExArd; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataARD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Explicit ARD: TestDataARD['%d'].\n"),i); TEST_FAILED; break; } //begin checking ARD values //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"),getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"), getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for Explicit ARD //free explicit ARD returncode = SQLFreeHandle(SQL_HANDLE_DESC, hExArd); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle (for ARD)")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } //====================================================================================================================== // Begin Testing: Positive Test for Implicit IPD //===================================================================================================================== IPDtests: ; //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IPD.\n"); //Get Implicit IPD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hImIpd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get IPD")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot get IPD: Aborting Implicit IPD tests.\n")); TEST_FAILED; goto IRDtests; //go to next set of tests } for (i = 0;i < DATA_ARR_LEN; i++) // i = index to TestDataIPD { TESTCASE_BEGIN("Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IPD.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hImIpd ; setDescRecNumber = RecNumber; setDescType = TestDataIPD[i].DescType; setDescIntervalCode = TestDataIPD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataIPD[i].DescOctetLength; setDescPrecision = TestDataIPD[i].DescPrecision; setDescScale = TestDataIPD[i].DescScale; setDescDataPtr = TestDataIPD[i].DescDataPtr; setDescOctectLengthPtr = TestDataIPD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataIPD[i].DescIndicatorPtr; returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_SUCCESS,returncode, "SQLSetDescRec and SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLSetDescRec: positive tests for Implicit IPD: TestDataIPD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //Get the Implicit IPD Descriptor LogMsg(NONE,_T("SQLSetDescRec and SQLGetDescRec: positive tests for Implicit IPD.\n")); getDescRecHandle = hImApd; getDescRecNumber = RecNumber; getNameMaxLength = MAXLEN; _tcscpy(getDescName ,_T("")); //initialize setDescNullable = TestDataIPD[i].DescNullable; returncode = SQLGetDescRec(getDescRecHandle, getDescRecNumber, (SQLTCHAR*)getDescName, getNameMaxLength, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG,_T("SQLGetDescRec: positive tests for Implicit IPD: TestDataIPD['%d'].\n"),i); //FullDisconnect(pTestInfo); TEST_FAILED; //TEST_RETURN; continue; } //begin checking IPD values //check SQL_DESC_NAME if (!(_tcscmp(getDescName, setDescName))) { LogMsg(NONE,_T("SQL_DESC_NAME value returned is '%s'\n"),getDescName); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NAME: '%s' and actual: '%s' are not matched\n"), setDescName,getDescName); } //check SQL_DESC_TYPE if (getDescType == setDescType) { LogMsg(NONE,_T("SQL_DESC_TYPE value returned is '%d'\n"), getDescType); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_TYPE: '%d' and actual: '%d' are not matched\n"), setDescType, getDescType); } //check SQL_DESC_DATETIME_INTERVAL_CODE if (getDescIntervalCode == setDescIntervalCode) { LogMsg(NONE,_T("SQL_DESC_DATETIME_INTERVAL_CODE value returned is '%d'\n"),getDescIntervalCode); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_DATETIME_INTERVAL_CODE: '%d' and actual: '%d' are not matched\n"), setDescIntervalCode, getDescIntervalCode); } //check SQL_DESC_OCTECT_LENGTH if (getDescOctectLength == setDescOctetLength) { LogMsg(NONE,_T("SQL_DESC_OCTECT_LENGTH value returned is '%d'\n"),getDescOctectLength); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_OCTECT_LENGTH: '%d' and actual: '%d' are not matched\n"), setDescOctetLength,getDescOctectLength); } //check SQL_DESC_PRECISION if (getDescPrecision == setDescPrecision) { LogMsg(NONE,_T("SQL_DESC_PRECISION value returned is '%d'\n"),getDescPrecision); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_PRECISION: '%d' and actual: '%d' are not matched\n"), setDescPrecision,getDescPrecision); } //check SQL_DESC_SCALE if (getDescScale == setDescScale) { LogMsg(NONE,_T("SQL_DESC_SCALE value returned is '%d'\n"),getDescScale); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_SCALE: '%d' and actual: '%d' are not matched\n"), setDescScale,getDescScale); } //check SQL_DESCNULLABLE if (getDescNullable == setDescNullable) { LogMsg(NONE,_T("SQL_DESC_NULLABLE value returned is '%d'\n"),getDescNullable); } else { TEST_FAILED; LogMsg(ERRMSG, _T("expect SQL_DESC_NULLABLE: '%d' and actual: '%d' are not matched\n"), setDescNullable, getDescNullable); } // end of checks TESTCASE_END; } //end for loop; end of positive tests for IPD //================================================================================================================== // Begin Testing: Posituve Tests for IRD (IRD Desc Fields are read only) //================================================================================================================== IRDtests: ; //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of SQLSetDescRec and SQLGetDescRec for Implicit IRD.\n"); //Get Implicit IRD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_ROW_DESC, &hImIrd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr")) { LogAllErrorsVer3(henv,hdbc,hstmt); LogMsg(ERRMSG, _T("Cannot get IRD: Aborting Implicit IRD tests.\n")); TEST_FAILED; // TEST_RETURN; //this will abort tests and perform a full disconnect. } //--------------------------------------------------------------------------------------------------------- TESTCASE_BEGIN("Test SQLSetDescRec for Implicit IRD: IRD Descriptor Fields cannot be set by the application.\n"); //set multiple Fields RecNumber = i + 1; //increment the recnumber and thus set the next rec (change SQL_DESC_COUNT) setDescRecHandle = hImIrd ; setDescRecNumber = RecNumber; setDescType = TestDataIRD[i].DescType; setDescIntervalCode = TestDataIRD[i].DescDatetimeIntervalCode; setDescOctetLength = TestDataIRD[i].DescOctetLength; setDescPrecision = TestDataIRD[i].DescPrecision; setDescScale = TestDataIRD[i].DescScale; setDescDataPtr = TestDataIRD[i].DescDataPtr; setDescOctectLengthPtr = TestDataIRD[i].DescOctectLengthPtr; setDescIndicatorPtr = TestDataIRD[i].DescIndicatorPtr; returncode = SQLSetDescRec(setDescRecHandle, setDescRecNumber, setDescType, setDescIntervalCode, setDescOctetLength , setDescPrecision, setDescScale, setDescDataPtr,&setDescOctectLengthPtr, &setDescIndicatorPtr); if(!CHECKRC(SQL_ERROR,returncode,"SQLSetDescRec")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } TESTCASE_END; //------------------------------------------------------------------------------------------------------------- TESTCASE_BEGIN("Test SQLGetDescRec for Implicit IRD: IRD Descriptor Fields not populated before call to DB.\n"); //This testcases use the Implicit IRD handle obtained in previous testcase returncode = SQLGetDescRec(hImIrd, 1, (SQLTCHAR*)getDescName, MAXLEN, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_NO_DATA_FOUND,returncode,"SQLGetDescField")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; //TEST_RETURN; //last test: valid to use TEST_RETURN when the test suite must be exited. } TESTCASE_END; //=============================================================================================================== // Begin Testing:Positive Test for populated Implicit IRD //=============================================================================================================== TESTCASE_BEGIN("Test SQLGetDescRec for populated Implicit IRD.\n"); //mark the beginning of tests in log file //LogMsg(SHORTTIMESTAMP, "Test the positive functionality of (SQLSetDescRec) and SQLGetDescRec for Implicit IRD.\n"); //alloc new handle returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt1); LogMsg(ERRMSG,_T("Cannot allocate statement: Aborting populated Implicit IRD tests.\n")); FullDisconnect(pTestInfo); TEST_FAILED; goto Cleanup; // transfers control to the next set } //Get Implicit IRD handle returncode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hIrd, 0, NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetStmtAttr: get IRD")) { LogAllErrorsVer3(henv,hdbc,hstmt1); LogMsg(ERRMSG,_T("Cannot allocate descriptor: Aborting populated Implicit IRD tests.\n")); TEST_FAILED; goto Cleanup; // transfers control to the next set } //populate the IRD by executing an catalog api returncode = SQLGetTypeInfo(hstmt1, SQL_ALL_TYPES); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetTypeInfo: population of IRD")) { LogAllErrorsVer3(henv,hdbc,hstmt1); LogMsg(ERRMSG,_T("Cannot execute statement: Aborting populated Implicit IRD tests.\n")); TEST_FAILED; goto Cleanup; // transfers control to the next set } //check IRD returncode = SQLGetDescRec(hIrd, 1, (SQLTCHAR*)getDescName, MAXLEN, &getDescNameActualLength, &getDescType, &getDescIntervalCode, &getDescOctectLength, &getDescPrecision, &getDescScale, &getDescNullable); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetDescField")) { LogAllErrorsVer3(henv,hdbc,hstmt1); TEST_FAILED; //TEST_RETURN; //last test: valid to use TEST_RETURN when the test suite must be exited. } TESTCASE_END; // free implicitly allocated descriptors by freeing statement returncode = SQLFreeHandle(SQL_HANDLE_STMT,hstmt1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt1); TEST_FAILED; } //=========================================================================================================== // begin cleanup //============================================================================================================== Cleanup: ; // free implicitly allocated descriptors by freeing statement returncode = SQLFreeHandle(SQL_HANDLE_STMT,hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeHandle")) { LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; } FullDisconnect3(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLSetDescRec and SQLGetDescRec.\n")); TEST_RETURN; } //end of test ****************
//************************************************************************* int main() { SQLHENV env; SQLHDBC dbc; SQLHSTMT stmt; SQLRETURN ret; SQLCHAR outstr[1024]; SQLSMALLINT outstrlen; // Aloocate an environment handle ret=SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&env); checkrc(ret,__LINE__); //we need odbc3 support SQLSetEnvAttr(env,SQL_ATTR_ODBC_VERSION,(void*)SQL_OV_ODBC3,0); //ALLOCATE A Connection handle ret = SQLAllocHandle(SQL_HANDLE_DBC,env,&dbc); checkrc(ret,__LINE__); // connect to the Data source ret = SQLConnect (dbc, (SQLCHAR *) "DSN=mycsql;MODE=ADAPTER;SERVER=127.0.0.1;PORT=5678;", (SQLSMALLINT) strlen ("DSN=mycsql;MODE=ADAPTER;SERVER=127.0.0.1;PORT=5678;"), (SQLCHAR *) "root", (SQLSMALLINT) strlen ("root"), (SQLCHAR *) "manager", (SQLSMALLINT) strlen ("")); if(SQL_SUCCEEDED(ret)) { printf("\nConnected to the Data Source..\n"); } else { printf("error in connection\n"); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_DBC,env); checkrc(ret,__LINE__); return 1; } //********************************************************************* //again call to driver connect ret = SQLConnect (dbc, (SQLCHAR *) "DSN=mycsql;MODE=ADAPTER;SERVER=127.0.0.1;PORT=5678;", (SQLSMALLINT) strlen ("DSN=mycsql;MODE=ADAPTER;SERVER=127.0.0.1;PORT=5678;"), (SQLCHAR *) "root", (SQLSMALLINT) strlen ("root"), (SQLCHAR *) "manager", (SQLSMALLINT) strlen ("")); int rettype = ret; if(SQL_SUCCEEDED(ret)) { printf("\nConnected to the Data Source..\n"); } else { printf("Connection name in use\n"); } //********************************************************************** ret = SQLDisconnect(dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); if(rettype ==0)return 1; return 0; }
/* ------------------------------------------------------------------ TestSQLGetTypeInfo: Tests SQLGetTypeInfo ------------------------------------------------------------------ */ PassFail TestSQLGetTypeInfoR18(TestInfo *pTestInfo) { TEST_DECLARE; char Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; char TempBuf[MAX_STRING_SIZE]; int j = 0,END_LOOP; struct { char *TYPE_NAME; SWORD DATA_TYPE; SDWORD PRECISION; char *LITERAL_PREFIX; char *LITERAL_SUFFIX; char *CREATE_PARAMS; SWORD NULLABLE; SWORD CASE_SENSITIVE; SWORD SEARCHABLE; SWORD UNSIGNED_ATTRIBUTE; SWORD MONEY; SWORD AUTO_INCREMENT; char *LOCAL_TYPE_NAME; SWORD MINIMUM_SCALE; SWORD MAXIMUM_SCALE; } TypeInfo[] = {//TYPENAME,DATATYPE,PREC,LITPRE,LITSUF,PARAM,NULL,CASE,SRCH,ATTR,MON,INC,LOC,MIN,MAX {"",SQL_ALL_TYPES,0,"","","",0,0,0,0,0,0,"",0,0}, // this is for get all types {"CHAR", SQL_CHAR, 254, "'", "'", "max length", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "CHARACTER", 0, 0}, {"VARCHAR", SQL_VARCHAR, 254, "'", "'", "max length", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "VARCHAR", 0, 0}, {"DECIMAL", SQL_DECIMAL, 18, "", "", "precision,scale", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DECIMAL", 0, 18}, {"NUMERIC", SQL_NUMERIC, 128, "", "", "precision,scale", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "NUMERIC", 0, 128}, {"SMALLINT", SQL_SMALLINT, 5, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "SMALLINT", 0, 0}, {"INTEGER", SQL_INTEGER, 10, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTEGER", 0, 0}, {"REAL", SQL_REAL, 7, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "REAL", 0, 0}, {"FLOAT", SQL_FLOAT, 15, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "FLOAT", 0, 0}, {"DOUBLE PRECISION", SQL_DOUBLE, 15, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DOUBLE", 0, 0}, // {"DATE", SQL_DATE, 10, "{d '", "'}","", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DATE", 0, 0}, // {"TIME", SQL_TIME, 8, "{t '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIME", 0, 0}, // {"TIMESTAMP", SQL_TIMESTAMP, 23, "{ts '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIMESTAMP", 0, 6}, {"DATE", SQL_TYPE_DATE, 10, "{d '", "'}","", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "DATE", 0, 0}, {"TIME", SQL_TYPE_TIME, 8, "{t '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIME", 0, 0}, {"TIMESTAMP", SQL_TYPE_TIMESTAMP, 26, "{ts '", "'}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "TIMESTAMP", 0, 6}, {"BIGINT", SQL_BIGINT, 19, "", "", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "LARGEINT", 0, 0}, {"LONG VARCHAR", SQL_LONGVARCHAR, 4018, "'", "'", "", SQL_NULLABLE, 1, SQL_SEARCHABLE, 0, 0, 0, "LONG VARCHAR", 0, 0}, // {"BINARY", SQL_BINARY, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0}, // {"VARBINARY", -3, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0}, // {"LONG VARBINARY", -4, 4059, "'", "'", "max length", 1, 0, 0, 0, 0, 0, "", 0, 0}, // {"TINYINT", -6, 3, "", "", "", 1, 0, SQL_ALL_EXCEPT_LIKE, 1, 0, 0, "", 0, 0}, // {"BIT", -7, 1, "", "", "", 1, 0, SQL_UNSEARCHABLE, 0, 0, 0, "", 0, 0}, {"INTERVAL", SQL_INTERVAL_YEAR, 0, "{INTERVAL '", "' YEAR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_MONTH, 0, "{INTERVAL '", "' MONTH}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_DAY, 0, "{INTERVAL '", "' DAY}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_HOUR, 0, "{INTERVAL '", "' HOUR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_MINUTE, 0, "{INTERVAL '", "' MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_SECOND, 0, "{INTERVAL '", "' SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_YEAR_TO_MONTH, 0, "{INTERVAL '", "' YEAR TO MONTH}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_DAY_TO_HOUR, 0, "{INTERVAL '", "' DAY TO HOUR}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_DAY_TO_MINUTE, 0, "{INTERVAL '", "' DAY TO MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_DAY_TO_SECOND, 0, "{INTERVAL '", "' DAY TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_HOUR_TO_MINUTE, 0, "{INTERVAL '", "' HOUR TO MINUTE}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_HOUR_TO_SECOND, 0, "{INTERVAL '", "' HOUR TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"INTERVAL", SQL_INTERVAL_MINUTE_TO_SECOND, 0, "{INTERVAL '", "' MINUTE TO SECOND}", "", SQL_NULLABLE, 0, SQL_ALL_EXCEPT_LIKE, 0, 0, 0, "INTERVAL", 0, 0}, {"",999,} }; char oTYPE_NAME[TYPE_LEN]; SWORD oDATA_TYPE, fSqlType1; SDWORD oPRECISION; char oLITERAL_PREFIX[TYPE_LEN]; char oLITERAL_SUFFIX[TYPE_LEN]; char oCREATE_PARAMS[TYPE_LEN]; SWORD oNULLABLE; SWORD oCASE_SENSITIVE; SWORD oSEARCHABLE; SWORD oUNSIGNED_ATTRIBUTE; SWORD oMONEY; SWORD oAUTO_INCREMENT; char oLOCAL_TYPE_NAME[TYPE_LEN]; SWORD oMINIMUM_SCALE; SWORD oMAXIMUM_SCALE; SQLLEN oTYPE_NAMElen; SQLLEN oDATA_TYPElen; SQLLEN oPRECISIONlen; SQLLEN oLITERAL_PREFIXlen; SQLLEN oLITERAL_SUFFIXlen; SQLLEN oCREATE_PARAMSlen; SQLLEN oNULLABLElen; SQLLEN oCASE_SENSITIVElen; SQLLEN oSEARCHABLElen; SQLLEN oUNSIGNED_ATTRIBUTElen; SQLLEN oMONEYlen; SQLLEN oAUTO_INCREMENTlen; SQLLEN oLOCAL_TYPE_NAMElen; SQLLEN oMINIMUM_SCALElen; SQLLEN oMAXIMUM_SCALElen; /* Set up some local variables to save on typing in longer ones */ /* This previously was R1.8 */ //================Modified for Longvarchar Changes=========================================================== if(!pTestInfo->bLongOn) { char *TYPE_NAME = "VARCHAR"; SWORD DATA_TYPE = SQL_VARCHAR; SDWORD PRECISION = 32000; char *CREATE_PARAMS = "max length"; char *LOCAL_TYPE_NAME = "VARCHAR"; TypeInfo[1].PRECISION = PRECISION; TypeInfo[2].PRECISION = PRECISION; TypeInfo[14].TYPE_NAME = TYPE_NAME; TypeInfo[14].DATA_TYPE = DATA_TYPE; TypeInfo[14].PRECISION = PRECISION; TypeInfo[14].CREATE_PARAMS = CREATE_PARAMS; TypeInfo[14].LOCAL_TYPE_NAME = LOCAL_TYPE_NAME; } //================Modified for Longvarhcar Changes=========================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,"Begin testing API =>SQLGetTypeInfo30 | SQLGetTypeInfo3 | gettypeiR18.c\n"); TEST_INIT; TESTCASE_BEGIN("Setup for SQLGetTypeInfo tests for ODBC 3.0\n"); if(!FullConnectWithOptions(pTestInfo, CONNECT_ODBC_VERSION_3)) { LogMsg(NONE,"Unable to connect\n"); TEST_FAILED; TEST_RETURN; } /* Set up some local variables to save on typing in longer ones */ henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocHandle(SQL_HANDLE_STMT, (SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocHandle")){ LogAllErrorsVer3(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup //========================================================================================= /* if (MX_MP_SPECIFIC == MX_SPECIFIC) END_LOOP = SQL_BINARY; else if (MX_MP_SPECIFIC == MP_SPECIFIC) END_LOOP = 999; else { LogMsg(ERRMSG,"gettypeinfo test failed.\n"); TEST_RETURN; } */ END_LOOP = 999; j = 0; while (TypeInfo[j].DATA_TYPE != END_LOOP) { sprintf(Heading,"Test Positive functionality of SQLGetTypeInfo for data type: %s\n", SQLTypeToChar(TypeInfo[j].DATA_TYPE,TempBuf)); TESTCASE_BEGIN(Heading); returncode = SQLGetTypeInfo(hstmt,TypeInfo[j].DATA_TYPE); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetTypeInfo")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { if (TypeInfo[j].DATA_TYPE != 0) { strcpy(oTYPE_NAME,""); oDATA_TYPE = 0; oPRECISION = 0; strcpy(oLITERAL_PREFIX,""); strcpy(oLITERAL_SUFFIX,""); strcpy(oCREATE_PARAMS,""); oNULLABLE = 0; oCASE_SENSITIVE = 0; oSEARCHABLE = 0; oUNSIGNED_ATTRIBUTE = 0; oMONEY = 0; oAUTO_INCREMENT = 0; strcpy(oLOCAL_TYPE_NAME,""); oMINIMUM_SCALE = 0; oMAXIMUM_SCALE = 0; returncode = SQLBindCol(hstmt,1,SQL_C_CHAR,oTYPE_NAME,TYPE_LEN,&oTYPE_NAMElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,2,SQL_C_SHORT,&oDATA_TYPE,0,&oDATA_TYPElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,3,SQL_C_LONG,&oPRECISION,0,&oPRECISIONlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,4,SQL_C_CHAR,oLITERAL_PREFIX,TYPE_LEN,&oLITERAL_PREFIXlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,5,SQL_C_CHAR,oLITERAL_SUFFIX,TYPE_LEN,&oLITERAL_SUFFIXlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,6,SQL_C_CHAR,oCREATE_PARAMS,TYPE_LEN,&oCREATE_PARAMSlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,7,SQL_C_SHORT,&oNULLABLE,0,&oNULLABLElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,8,SQL_C_SHORT,&oCASE_SENSITIVE,0,&oCASE_SENSITIVElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,9,SQL_C_SHORT,&oSEARCHABLE,0,&oSEARCHABLElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,10,SQL_C_SHORT,&oUNSIGNED_ATTRIBUTE,0,&oUNSIGNED_ATTRIBUTElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,11,SQL_C_SHORT,&oMONEY,0,&oMONEYlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,12,SQL_C_SHORT,&oAUTO_INCREMENT,0,&oAUTO_INCREMENTlen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,13,SQL_C_CHAR,oLOCAL_TYPE_NAME,TYPE_LEN,&oLOCAL_TYPE_NAMElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,14,SQL_C_SHORT,&oMINIMUM_SCALE,0,&oMINIMUM_SCALElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,15,SQL_C_SHORT,&oMAXIMUM_SCALE,0,&oMAXIMUM_SCALElen); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { LogMsg(NONE,"Comparing results\n"); if ((_stricmp(TypeInfo[j].TYPE_NAME,oTYPE_NAME) == 0) && (TypeInfo[j].DATA_TYPE == oDATA_TYPE) && (TypeInfo[j].PRECISION == oPRECISION) && (_stricmp(TypeInfo[j].LITERAL_PREFIX,oLITERAL_PREFIX) == 0) && (_stricmp(TypeInfo[j].LITERAL_SUFFIX,oLITERAL_SUFFIX) == 0) && (_stricmp(TypeInfo[j].CREATE_PARAMS,oCREATE_PARAMS) == 0) && (TypeInfo[j].NULLABLE == oNULLABLE) && (TypeInfo[j].CASE_SENSITIVE == oCASE_SENSITIVE) && (TypeInfo[j].SEARCHABLE == oSEARCHABLE) && (TypeInfo[j].UNSIGNED_ATTRIBUTE == oUNSIGNED_ATTRIBUTE) && (TypeInfo[j].MONEY == oMONEY) && (TypeInfo[j].AUTO_INCREMENT == oAUTO_INCREMENT) && (_stricmp(TypeInfo[j].LOCAL_TYPE_NAME,oLOCAL_TYPE_NAME) == 0) && (TypeInfo[j].MINIMUM_SCALE == oMINIMUM_SCALE) && (TypeInfo[j].MAXIMUM_SCALE == oMAXIMUM_SCALE)) { //LogMsg(NONE,"Data Type Name actual: %s and expected: %s are matched\n",oTYPE_NAME,TypeInfo[j].TYPE_NAME); //LogMsg(NONE,"Data Type actual: %d and expected: %d are matched\n",oDATA_TYPE,TypeInfo[j].DATA_TYPE); //LogMsg(NONE,"Precision actual: %d and expected: %d are matched\n",oPRECISION,TypeInfo[j].PRECISION); //LogMsg(NONE,"Literal Prefix actual: %s and expected: %s are matched\n",oLITERAL_PREFIX,TypeInfo[j].LITERAL_PREFIX); //LogMsg(NONE,"Literal Suffix actual: %s and expected: %s are matched\n",oLITERAL_SUFFIX,TypeInfo[j].LITERAL_SUFFIX); //LogMsg(NONE,"Create Params actual: %s and expected: %s are matched\n",oCREATE_PARAMS,TypeInfo[j].CREATE_PARAMS); //LogMsg(NONE,"Nullable actual: %d and expected: %d are matched\n",oNULLABLE,TypeInfo[j].NULLABLE); //LogMsg(NONE,"Case sensitive actual: %d and expected: %d are matched\n",oCASE_SENSITIVE,TypeInfo[j].CASE_SENSITIVE); //LogMsg(NONE,"Searchable actual: %d and expected: %d are matched\n",oSEARCHABLE,TypeInfo[j].SEARCHABLE); //LogMsg(NONE,"Unsigned attribute actual: %d and expected: %d are matched\n",oUNSIGNED_ATTRIBUTE,TypeInfo[j].UNSIGNED_ATTRIBUTE); //LogMsg(NONE,"Money actual: %d and expected: %d are matched\n",oMONEY,TypeInfo[j].MONEY); //LogMsg(NONE,"Auto Increment actual: %d and expected: %d are matched\n",oAUTO_INCREMENT,TypeInfo[j].AUTO_INCREMENT); //LogMsg(NONE,"Local Type name actual: %s and expected: %s are matched\n",oLOCAL_TYPE_NAME,TypeInfo[j].LOCAL_TYPE_NAME); //LogMsg(NONE,"Minimum Scale actual: %d and expected: %d are matched\n",oMINIMUM_SCALE,TypeInfo[j].MINIMUM_SCALE); //LogMsg(NONE,"Maximum Scale actual: %d and expected: %d are matched\n",oMAXIMUM_SCALE,TypeInfo[j].MAXIMUM_SCALE); } else { TEST_FAILED; if (_stricmp(TypeInfo[j].TYPE_NAME,oTYPE_NAME) != 0) LogMsg(ERRMSG,"Data Type Name actual: %s and expected: %s are not matched\n",oTYPE_NAME,TypeInfo[j].TYPE_NAME); if (TypeInfo[j].DATA_TYPE != oDATA_TYPE) LogMsg(ERRMSG,"Data Type actual: %d and expected: %d are not matched\n",oDATA_TYPE,TypeInfo[j].DATA_TYPE); if (TypeInfo[j].PRECISION != oPRECISION) LogMsg(ERRMSG,"Precision actual: %d and expected: %d are not matched\n",oPRECISION,TypeInfo[j].PRECISION); if (_stricmp(TypeInfo[j].LITERAL_PREFIX,oLITERAL_PREFIX) != 0) LogMsg(ERRMSG,"Literal Prefix actual: %s and expected: %s are not matched\n",oLITERAL_PREFIX,TypeInfo[j].LITERAL_PREFIX); if (_stricmp(TypeInfo[j].LITERAL_SUFFIX,oLITERAL_SUFFIX) != 0) LogMsg(ERRMSG,"Literal Suffix actual: %s and expected: %s are not matched\n",oLITERAL_SUFFIX,TypeInfo[j].LITERAL_SUFFIX); if (_stricmp(TypeInfo[j].CREATE_PARAMS,oCREATE_PARAMS) != 0) LogMsg(ERRMSG,"Create Params actual: %s and expected: %s are not matched\n",oCREATE_PARAMS,TypeInfo[j].CREATE_PARAMS); if (TypeInfo[j].NULLABLE != oNULLABLE) LogMsg(ERRMSG,"Nullable actual: %d and expected: %d are not matched\n",oNULLABLE,TypeInfo[j].NULLABLE); if (TypeInfo[j].CASE_SENSITIVE != oCASE_SENSITIVE) LogMsg(ERRMSG,"Case sensitive actual: %d and expected: %d are not matched\n",oCASE_SENSITIVE,TypeInfo[j].CASE_SENSITIVE); if (TypeInfo[j].SEARCHABLE != oSEARCHABLE) LogMsg(ERRMSG,"Searchable actual: %d and expected: %d are not matched\n",oSEARCHABLE,TypeInfo[j].SEARCHABLE); if (TypeInfo[j].UNSIGNED_ATTRIBUTE != oUNSIGNED_ATTRIBUTE) LogMsg(ERRMSG,"Unsigned attribute actual: %d and expected: %d are not matched\n",oUNSIGNED_ATTRIBUTE,TypeInfo[j].UNSIGNED_ATTRIBUTE); if (TypeInfo[j].MONEY != oMONEY) LogMsg(ERRMSG,"Money actual: %d and expected: %d are not matched\n",oMONEY,TypeInfo[j].MONEY); if (TypeInfo[j].AUTO_INCREMENT != oAUTO_INCREMENT) LogMsg(ERRMSG,"Auto Increment actual: %d and expected: %d are not matched\n",oAUTO_INCREMENT,TypeInfo[j].AUTO_INCREMENT); if (_stricmp(TypeInfo[j].LOCAL_TYPE_NAME,oLOCAL_TYPE_NAME) != 0) LogMsg(ERRMSG,"Local Type name actual: %s and expected: %s are not matched\n",oLOCAL_TYPE_NAME,TypeInfo[j].LOCAL_TYPE_NAME); if (TypeInfo[j].MINIMUM_SCALE != oMINIMUM_SCALE) LogMsg(ERRMSG,"Minimum Scale actual: %d and expected: %d are not matched\n",oMINIMUM_SCALE,TypeInfo[j].MINIMUM_SCALE); if (TypeInfo[j].MAXIMUM_SCALE != oMAXIMUM_SCALE) LogMsg(ERRMSG,"Maximum Scale actual: %d and expected: %d are not matched\n",oMAXIMUM_SCALE,TypeInfo[j].MAXIMUM_SCALE); } } } } TESTCASE_END; SQLFreeStmt(hstmt,SQL_CLOSE); // This is a bug this should be after the inner for loop. j++; } //========================================================================================== TESTCASE_BEGIN("SQLGetTypeInfo: Negative test for invalid data type\n"); fSqlType1 = 50; returncode = SQLGetTypeInfo(hstmt,fSqlType1); if(!CHECKRC(SQL_ERROR,returncode,"SQLGetTypeInfo")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //========================================================================================= sprintf(Heading,"SQLGetTypeInfo: Negative test with invalid handle\n"); TESTCASE_BEGIN(Heading); hstmt = (SQLHANDLE)NULL; fSqlType1 = 1; returncode = SQLGetTypeInfo(hstmt,fSqlType1); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLGetTypeInfo")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } TESTCASE_END; //========================================================================================= FullDisconnect3(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,"End testing API => SQLGetTypeInfo.\n"); TEST_RETURN; }
int main(int argc, char **argv) { SQLRETURN rc; HSTMT hstmt = SQL_NULL_HSTMT; char *param1; SQLLEN cbParam1; SQLINTEGER longparam; SQL_INTERVAL_STRUCT intervalparam; SQLSMALLINT colcount; char byteaParam[5000]; int i; test_connect(); rc = SQLAllocHandle(SQL_HANDLE_STMT, conn, &hstmt); if (!SQL_SUCCEEDED(rc)) { print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn); exit(1); } /**** A simple query with one text param ****/ rc = SQLExecDirect(hstmt, (SQLCHAR *) "SET intervalstyle=postgres_verbose", SQL_NTS); /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id, t FROM testtab1 WHERE t = ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); /* bind param */ param1 = "bar"; cbParam1 = SQL_NTS; rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, /* value type */ SQL_CHAR, /* param type */ 20, /* column size */ 0, /* dec digits */ param1, /* param value ptr */ 0, /* buffer len */ &cbParam1 /* StrLen_or_IndPtr */); CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt); /* Test SQLNumResultCols, called before SQLExecute() */ rc = SQLNumResultCols(hstmt, &colcount); CHECK_STMT_RESULT(rc, "SQLNumResultCols failed", hstmt); printf("# of result cols: %d\n", colcount); /* Execute */ rc = SQLExecute(hstmt); CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt); /* Fetch result */ print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /**** A query with an integer param ****/ /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id, t FROM testtab1 WHERE id = ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); /* bind param */ longparam = 3; cbParam1 = sizeof(longparam); rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SLONG, /* value type */ SQL_INTEGER, /* param type */ 0, /* column size (ignored for SQL_INTEGER) */ 0, /* dec digits */ &longparam, /* param value ptr */ sizeof(longparam), /* buffer len (ignored for SQL_INTEGER) */ &cbParam1 /* StrLen_or_IndPtr (ignored for SQL_INTEGER) */); CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt); /* Execute */ rc = SQLExecute(hstmt); CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt); /* Fetch result */ print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /**** Test a query with a bytea param of various sizes. ****/ /* * The driver has some special handling for byteas, as it sends them in * binary mode. This particular test case exercises an old bug where * the bind packet size was calculated incorrectly, and there was an * out-of-bounds write of two bytes when the total packet size was exactly * 4097 bytes. So, exercise packet sizes near that boundary. */ rc = SQLExecDirect(hstmt, (SQLCHAR *) "CREATE TEMPORARY TABLE btest (len int4, b bytea)", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "INSERT INTO btest VALUES(?, ?)", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); /* fill in test data */ for (i = 0; i < sizeof(byteaParam); i++) byteaParam[i] = (char) i; printf ("inserting bytea values..."); for (i = 4000; i < 4100; i++) { printf(" %d", i); fflush(stdout); /* bind int param */ longparam = i; cbParam1 = sizeof(longparam); rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_SLONG, /* value type */ SQL_INTEGER, /* param type */ 0, /* column size (ignored for SQL_INTEGER) */ 0, /* dec digits */ &longparam, /* param value ptr */ sizeof(longparam), /* buffer len (ignored for SQL_INTEGER) */ &cbParam1 /* StrLen_or_IndPtr (ignored for SQL_INTEGER) */); CHECK_STMT_RESULT(rc, "\nSQLBindParameter failed", hstmt); cbParam1 = i; rc = SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_BINARY, /* value type */ SQL_VARBINARY, /* param type */ sizeof(byteaParam), /* column size */ 0, /* dec digits */ byteaParam, /* param value ptr */ sizeof(byteaParam), /* buffer len */ &cbParam1 /* StrLen_or_IndPtr */); CHECK_STMT_RESULT(rc, "\nSQLBindParameter failed", hstmt); /* Execute */ rc = SQLExecute(hstmt); CHECK_STMT_RESULT(rc, "\nSQLExecute failed", hstmt); } printf(" done!\n"); printf("Now reading them back...\n"); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /* Check the inserted data */ rc = SQLExecDirect(hstmt, (SQLCHAR *) "SELECT len, length(b) FROM btest", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /**** A query with an interval param (SQL_C_INTERVAL_SECOND) ****/ /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id, iv, d FROM intervaltable WHERE iv < ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); /* bind param */ intervalparam.interval_type = SQL_IS_SECOND; intervalparam.interval_sign = 0; intervalparam.intval.day_second.day = 1; intervalparam.intval.day_second.hour = 2; intervalparam.intval.day_second.minute = 3; intervalparam.intval.day_second.second = 4; intervalparam.intval.day_second.fraction = 5; cbParam1 = sizeof(intervalparam); rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_INTERVAL_SECOND, /* value type */ SQL_INTERVAL_SECOND, /* param type */ 0, /* column size (ignored for SQL_INTERVAL_SECOND) */ 0, /* dec digits */ &intervalparam, /* param value ptr */ sizeof(intervalparam), /* buffer len (ignored for SQL_C_INTERVAL_SECOND) */ &cbParam1 /* StrLen_or_IndPtr (ignored for SQL_C_INTERVAL_SECOND) */); CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt); /* Execute */ rc = SQLExecute(hstmt); CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt); /* Fetch result */ print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /**** * With BoolsAsChar=1, a varchar param with column_size=5 forces a * server-side Prepare. So test that. */ /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id, t FROM testtab1 WHERE id = ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); /* bind param */ param1 = "2"; cbParam1 = SQL_NTS; rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, /* value type */ SQL_VARCHAR, /* param type */ 5, /* column size. 5 Triggers special * behavior with BoolsAsChar=1 */ 0, /* dec digits */ param1, /* param value ptr */ 0, /* buffer len */ &cbParam1 /* StrLen_or_IndPtr */); CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt); /* Test SQLNumResultCols, called before SQLExecute() */ rc = SQLNumResultCols(hstmt, &colcount); CHECK_STMT_RESULT(rc, "SQLNumResultCols failed", hstmt); printf("# of result cols: %d\n", colcount); /* Execute */ rc = SQLExecute(hstmt); CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt); /* Fetch result */ print_result(hstmt); rc = SQLFreeHandle(SQL_HANDLE_STMT, hstmt); if (!SQL_SUCCEEDED(rc)) { print_diag("SQLFreeStmt failed", SQL_HANDLE_STMT, hstmt); exit(1); } /* Clean up */ test_disconnect(); return 0; }
int main(int argc, char **argv) { int rc; HSTMT hstmt = SQL_NULL_HSTMT; /* * NOTE: in the psqlodbc, we assume that SQL_C_LONG actually means a * variable of type SQLINTEGER. They are not the same on platforms where * "long" is a 64-bit integer. That seems a bit bogus, but it's too late * to change that without breaking applications that depend on it. * (on little-endian systems, you won't notice the difference if you reset * the high bits to zero before calling SQLBindCol.) */ SQLINTEGER longvalue; SQLLEN indLongvalue; char charvalue[100]; SQLLEN indCharvalue; int rowno; test_connect(); rc = SQLAllocHandle(SQL_HANDLE_STMT, conn, &hstmt); if (!SQL_SUCCEEDED(rc)) { print_diag("failed to allocate stmt handle", SQL_HANDLE_DBC, conn); exit(1); } rc = SQLBindCol(hstmt, 1, SQL_C_LONG, &longvalue, 0, &indLongvalue); CHECK_STMT_RESULT(rc, "SQLBindCol failed", hstmt); rc = SQLBindCol(hstmt, 2, SQL_C_CHAR, &charvalue, sizeof(charvalue), &indCharvalue); CHECK_STMT_RESULT(rc, "SQLBindCol failed", hstmt); rc = SQLExecDirect(hstmt, (SQLCHAR *) "SELECT id, 'foo' || id FROM generate_series(1, 10) id", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); printf("Result set:\n"); rowno = 0; while(1) { rc = SQLFetch(hstmt); if (rc == SQL_NO_DATA) break; if (rc == SQL_SUCCESS) { printf("%ld %s\n", (long) longvalue, charvalue); } else { print_diag("SQLFetch failed", SQL_HANDLE_STMT, hstmt); exit(1); } /* * At row 3, unbind the text field. At row 5, bind it again. * At row 7, unbind both columns with SQLFreeStmt(SQL_UNBIND). * At row 9, bind text field again. */ rowno++; if (rowno == 3) { rc = SQLBindCol(hstmt, 2, SQL_C_CHAR, NULL, 0, NULL); CHECK_STMT_RESULT(rc, "SQLBindCol failed", hstmt); } if (rowno == 7) { rc = SQLFreeStmt(hstmt, SQL_UNBIND); CHECK_STMT_RESULT(rc, "SQLFreeStmt(SQL_UNBIND) failed", hstmt); } if (rowno == 5 || rowno == 9) { rc = SQLBindCol(hstmt, 2, SQL_C_CHAR, &charvalue, sizeof(charvalue), &indCharvalue); CHECK_STMT_RESULT(rc, "SQLBindCol failed", hstmt); } } rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /* Clean up */ test_disconnect(); return 0; }
// Main Program int main (int argc, char **argv) { SQLCHAR *dsnName; SQLCHAR *user; SQLCHAR *password; SQLRETURN returnCode; bool testPassed = true; SQLCHAR InConnStr[MAX_CONNECT_STRING]; SQLCHAR OutConnStr[MAX_CONNECT_STRING]; SQLSMALLINT ConnStrLength; int c, errflag = 0; optarg = NULL; if (argc != 7) errflag++; while (!errflag && (c = getopt(argc, argv, ARGS)) != -1) switch (c) { case 'd': dsnName = (SQLCHAR*)optarg; break; case 'u': user = (SQLCHAR*)optarg; break; case 'p': password = (SQLCHAR*)optarg; break; default : errflag++; } if (errflag) { printf("Command line error.\n"); printf("Usage: %s [-d <datasource>] [-u <userid>] [-p <password>]\n", argv[0] ); return FALSE; } // Initialize handles to NULL henv = SQL_NULL_HANDLE; hstmt = SQL_NULL_HANDLE; hdbc = SQL_NULL_HANDLE; // Allocate Environment Handle returnCode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv)",returnCode); // Set ODBC version to 3.0 returnCode = SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLSetEnvAttr(henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0)",returnCode,false); // Allocate Connection handle returnCode = SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLAllocHandle(SQL_HANDLE_DBC, henv, &hdbc)", returnCode); //Connect to the database sprintf((char*)InConnStr,"DSN=%s;UID=%s;PWD=%s;%c",(char*)dsnName, (char*)user, (char*)password,'\0'); printf("Using Connect String: %s\n", InConnStr); returnCode = SQLDriverConnect(hdbc,hWnd,InConnStr,SQL_NTS,OutConnStr,sizeof(OutConnStr),&ConnStrLength,SQL_DRIVER_NOPROMPT); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLDriverConnect",returnCode); //Allocate Statement handle returnCode = SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt)", returnCode); //Free Statement handle returnCode = SQLFreeHandle(SQL_HANDLE_STMT, hstmt); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLFreeHandle(SQL_HANDLE_STMT, hstmt)", returnCode); hstmt = SQL_NULL_HANDLE; //Disconnect returnCode = SQLDisconnect(hdbc); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLDisconnect(hdbc)", returnCode); //Free Connection handle returnCode = SQLFreeHandle(SQL_HANDLE_DBC, hdbc); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLFreeHandle(SQL_HANDLE_DBC, hdbc)", returnCode); hdbc = SQL_NULL_HANDLE; //Free Environment handle returnCode = SQLFreeHandle(SQL_HANDLE_ENV, henv); if(returnCode != SQL_SUCCESS) LogDiagnostics("SQLFreeHandle(SQL_HANDLE_ENV, henv)", returnCode); henv = SQL_NULL_HANDLE; printf("\nConnect Test Passed...\n"); exit(EXIT_SUCCESS); }
int main(int argc, char **argv) { SQLHENV hEnv = NULL; SQLHDBC hDbc = NULL; SQLHSTMT hStmt = NULL; char* pConnStr; char pQuery[1000]; bool silent = true; if (argc != 5) { fprintf(stderr, "Usage: %s <ConnString> <pkey range> <ccol range> <rand seed>\n", argv[0]); return 1; } pConnStr = argv[1]; char *endptr; long long numkeys = strtoll(argv[2], &endptr, 10); long long rowsperkey = strtoll(argv[3], &endptr, 10); int seed = atoi(argv[4]); struct drand48_data lcg; srand48_r(seed, &lcg); // Allocate an environment if (!silent) fprintf(stderr, "Allocating Handle Enviroment\n"); if (SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv) == SQL_ERROR) { fprintf(stderr, "Unable to allocate an environment handle\n"); exit(-1); } // Register this as an application that expects 3.x behavior, // you must register something if you use AllocHandle if (!silent) fprintf(stderr, "Setting to ODBC3\n"); TRYODBC(hEnv, SQL_HANDLE_ENV, SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)SQL_OV_ODBC3, 0)); // Allocate a connection if (!silent) fprintf(stderr, "Allocating Handle\n"); TRYODBC(hEnv, SQL_HANDLE_ENV, SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc)); // Connect to the driver. Use the connection string if supplied // on the input, otherwise let the driver manager prompt for input. if (!silent) fprintf(stderr, "Connecting to driver\n"); TRYODBC(hDbc, SQL_HANDLE_DBC, SQLDriverConnect(hDbc, NULL, pConnStr, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_COMPLETE)); fprintf(stderr, "Connected!\n"); if (!silent) fprintf(stderr, "Allocating statement\n"); TRYODBC(hDbc, SQL_HANDLE_DBC, SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt)); RETCODE RetCode; SQLSMALLINT sNumResults; // Execute the query if (!silent) fprintf(stderr, "Executing query\n"); long long i; double rval; for (i = 0; i < 100000; i++) { drand48_r(&lcg, &rval); sprintf(pQuery, "SELECT MAX(col1) FROM otest.test10 WHERE ccol = %lld", (long long)(rval * numkeys)); RetCode = SQLExecDirect(hStmt, pQuery, SQL_NTS); switch(RetCode) { case SQL_SUCCESS_WITH_INFO: { HandleDiagnosticRecord(hStmt, SQL_HANDLE_STMT, RetCode); // fall through } case SQL_SUCCESS: { // If this is a row-returning query, display // results TRYODBC(hStmt, SQL_HANDLE_STMT, SQLNumResultCols(hStmt,&sNumResults)); if (sNumResults > 0) { DisplayResults(hStmt,sNumResults, silent); } else { SQLLEN cRowCount; TRYODBC(hStmt, SQL_HANDLE_STMT, SQLRowCount(hStmt,&cRowCount)); if (cRowCount >= 0) { printf("%d %s returned\n", (int)cRowCount, (cRowCount == 1) ? "row" : "rows"); } } break; } case SQL_ERROR: { HandleDiagnosticRecord(hStmt, SQL_HANDLE_STMT, RetCode); break; } default: fprintf(stderr, "Unexpected return code %hd!\n", RetCode); } } TRYODBC(hStmt, SQL_HANDLE_STMT, SQLFreeStmt(hStmt, SQL_CLOSE)); Exit: // Free ODBC handles and exit if (hStmt) { SQLFreeHandle(SQL_HANDLE_STMT, hStmt); } if (hDbc) { SQLDisconnect(hDbc); SQLFreeHandle(SQL_HANDLE_DBC, hDbc); } if (hEnv) { SQLFreeHandle(SQL_HANDLE_ENV, hEnv); } return 0; }
int odbc_DBconnect(ZBX_ODBC_DBH *pdbh, const char *db_dsn, const char *user, const char *pass) { SQLCHAR err_stat[10], err_msg[100]; SQLINTEGER err_int; SQLSMALLINT err_msg_len; SQLRETURN retcode; clean_odbc_strerror(); memset(pdbh, 0 , sizeof(ZBX_ODBC_DBH)); zabbix_log(LOG_LEVEL_DEBUG, "ODBC connect [%s] [%s]", db_dsn, user); /*Allocate environment handle */ retcode = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &(pdbh->henv)); if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) { set_last_odbc_strerror("%s","failed environment handle allocation."); } else { /* Set the ODBC version environment attribute */ retcode = SQLSetEnvAttr(pdbh->henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) { set_last_odbc_strerror("%s","failed ODBC version setting."); } else { /* Allocate connection handle */ retcode = SQLAllocHandle(SQL_HANDLE_DBC, pdbh->henv, &(pdbh->hdbc)); if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) { set_last_odbc_strerror("%s","failed connection handle allocation."); } else { /* Set login timeout to 5 seconds. */ SQLSetConnectAttr(pdbh->hdbc, (SQLINTEGER)SQL_LOGIN_TIMEOUT, (SQLPOINTER)5, (SQLINTEGER)0); /* Connect to data source */ retcode = SQLConnect(pdbh->hdbc, (SQLCHAR*) db_dsn, SQL_NTS, (SQLCHAR*) user, SQL_NTS, (SQLCHAR*) pass, SQL_NTS ); if (retcode != SQL_SUCCESS && retcode != SQL_SUCCESS_WITH_INFO) { SQLGetDiagRec(SQL_HANDLE_DBC, pdbh->hdbc, 1, err_stat, &err_int, err_msg, sizeof(err_msg), &err_msg_len ); set_last_odbc_strerror("failed connection [%s] (%d)", err_msg, err_int); } else { pdbh->connected = 1; /* Allocate statement handle */ retcode = SQLAllocHandle(SQL_HANDLE_STMT, pdbh->hdbc, &(pdbh->hstmt)); if (retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO) { return SUCCEED; } else { SQLFreeHandle(SQL_HANDLE_STMT, pdbh->hstmt); pdbh->hstmt = NULL; } SQLDisconnect(pdbh->hdbc); } SQLFreeHandle(SQL_HANDLE_DBC, pdbh->hdbc); pdbh->hdbc = NULL; } } SQLFreeHandle(SQL_HANDLE_ENV, pdbh->henv); pdbh->henv = NULL; } zabbix_log(LOG_LEVEL_ERR, "Failed to connect to DSN '%s' : Error: %s", db_dsn, get_last_odbc_strerror()); return FAIL; /* error */ }
static int odbc_log(struct ast_cdr *cdr) { int ODBC_res; char sqlcmd[2048] = "", timestr[128]; int res = 0; struct tm tm; if (usegmtime) gmtime_r(&cdr->start.tv_sec,&tm); else ast_localtime(&cdr->start.tv_sec, &tm, NULL); ast_mutex_lock(&odbc_lock); strftime(timestr, sizeof(timestr), DATE_FORMAT, &tm); memset(sqlcmd,0,2048); if (loguniqueid) { snprintf(sqlcmd,sizeof(sqlcmd),"INSERT INTO %s " "(calldate,clid,src,dst,dcontext,channel,dstchannel,lastapp," "lastdata,duration,billsec,disposition,amaflags,accountcode,uniqueid,userfield) " "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", table); } else { snprintf(sqlcmd,sizeof(sqlcmd),"INSERT INTO %s " "(calldate,clid,src,dst,dcontext,channel,dstchannel,lastapp,lastdata," "duration,billsec,disposition,amaflags,accountcode) " "VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)", table); } if (!connected) { res = odbc_init(); if (res < 0) { odbc_disconnect(); ast_mutex_unlock(&odbc_lock); return 0; } } ODBC_res = SQLAllocHandle(SQL_HANDLE_STMT, ODBC_con, &ODBC_stmt); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Failure in AllocStatement %d\n", ODBC_res); SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt); odbc_disconnect(); ast_mutex_unlock(&odbc_lock); return 0; } /* We really should only have to do this once. But for some strange reason if I don't it blows holes in memory like like a shotgun. So we just do this so its safe. */ ODBC_res = SQLPrepare(ODBC_stmt, (unsigned char *)sqlcmd, SQL_NTS); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Error in PREPARE %d\n", ODBC_res); SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt); odbc_disconnect(); ast_mutex_unlock(&odbc_lock); return 0; } SQLBindParameter(ODBC_stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(timestr), 0, ×tr, 0, NULL); SQLBindParameter(ODBC_stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->clid), 0, cdr->clid, 0, NULL); SQLBindParameter(ODBC_stmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->src), 0, cdr->src, 0, NULL); SQLBindParameter(ODBC_stmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dst), 0, cdr->dst, 0, NULL); SQLBindParameter(ODBC_stmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dcontext), 0, cdr->dcontext, 0, NULL); SQLBindParameter(ODBC_stmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->channel), 0, cdr->channel, 0, NULL); SQLBindParameter(ODBC_stmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dstchannel), 0, cdr->dstchannel, 0, NULL); SQLBindParameter(ODBC_stmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->lastapp), 0, cdr->lastapp, 0, NULL); SQLBindParameter(ODBC_stmt, 9, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->lastdata), 0, cdr->lastdata, 0, NULL); SQLBindParameter(ODBC_stmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->duration, 0, NULL); SQLBindParameter(ODBC_stmt, 11, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->billsec, 0, NULL); if (dispositionstring) SQLBindParameter(ODBC_stmt, 12, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(ast_cdr_disp2str(cdr->disposition)) + 1, 0, ast_cdr_disp2str(cdr->disposition), 0, NULL); else SQLBindParameter(ODBC_stmt, 12, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->disposition, 0, NULL); SQLBindParameter(ODBC_stmt, 13, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->amaflags, 0, NULL); SQLBindParameter(ODBC_stmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->accountcode), 0, cdr->accountcode, 0, NULL); if (loguniqueid) { SQLBindParameter(ODBC_stmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->uniqueid), 0, cdr->uniqueid, 0, NULL); SQLBindParameter(ODBC_stmt, 16, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->userfield), 0, cdr->userfield, 0, NULL); } if (connected) { res = odbc_do_query(); if (res < 0) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query FAILED Call not logged!\n"); if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Reconnecting to dsn %s\n", dsn); SQLDisconnect(ODBC_con); res = odbc_init(); if (res < 0) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: %s has gone away!\n", dsn); odbc_disconnect(); } else { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Trying Query again!\n"); res = odbc_do_query(); if (res < 0) { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query FAILED Call not logged!\n"); } } } } else { if (option_verbose > 10) ast_verbose( VERBOSE_PREFIX_4 "cdr_odbc: Query FAILED Call not logged!\n"); } SQLFreeHandle(SQL_HANDLE_STMT, ODBC_stmt); ast_mutex_unlock(&odbc_lock); return 0; }
static int db_is_up(switch_odbc_handle_t *handle) { int ret = 0; SQLHSTMT stmt = NULL; SQLLEN m = 0; int result; switch_event_t *event; switch_odbc_status_t recon = 0; char *err_str = NULL; SQLCHAR sql[255] = ""; int max_tries = 120; int code = 0; SQLRETURN rc; SQLSMALLINT nresultcols; top: if (!handle) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "No DB Handle\n"); goto done; } if (handle->is_firebird) { strcpy((char *) sql, "select first 1 * from RDB$RELATIONS"); } else { strcpy((char *) sql, "select 1"); } if (SQLAllocHandle(SQL_HANDLE_STMT, handle->con, &stmt) != SQL_SUCCESS) { code = __LINE__; goto error; } if (SQLPrepare(stmt, sql, SQL_NTS) != SQL_SUCCESS) { code = __LINE__; goto error; } result = SQLExecute(stmt); if (result != SQL_SUCCESS && result != SQL_SUCCESS_WITH_INFO) { code = __LINE__; goto error; } SQLRowCount(stmt, &m); rc = SQLNumResultCols(stmt, &nresultcols); if (rc != SQL_SUCCESS) { code = __LINE__; goto error; } ret = (int) nresultcols; /* determine statement type */ if (nresultcols <= 0) { /* statement is not a select statement */ code = __LINE__; goto error; } goto done; error: err_str = switch_odbc_handle_get_error(handle, stmt); recon = switch_odbc_handle_connect(handle); max_tries--; if (switch_event_create(&event, SWITCH_EVENT_TRAP) == SWITCH_STATUS_SUCCESS) { switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Failure-Message", "The sql server is not responding for DSN %s [%s][%d]", switch_str_nil(handle->dsn), switch_str_nil(err_str), code); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The sql server is not responding for DSN %s [%s][%d]\n", switch_str_nil(handle->dsn), switch_str_nil(err_str), code); if (recon == SWITCH_ODBC_SUCCESS) { switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Additional-Info", "The connection has been re-established"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "The connection has been re-established\n"); } else { switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Additional-Info", "The connection could not be re-established"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "The connection could not be re-established\n"); } if (!max_tries) { switch_event_add_header(event, SWITCH_STACK_BOTTOM, "Additional-Info", "Giving up!"); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Giving up!\n"); } switch_event_fire(&event); } if (!max_tries) { goto done; } switch_safe_free(err_str); switch_yield(1000000); goto top; done: switch_safe_free(err_str); if (stmt) { SQLFreeHandle(SQL_HANDLE_STMT, stmt); } return ret; }
int odbc_DBconnect(ZBX_ODBC_DBH *pdbh, char *db_dsn, char *user, char *pass, int login_timeout) { const char *__function_name = "odbc_DBconnect"; int ret = FAIL; SQLRETURN rc; zabbix_log(LOG_LEVEL_DEBUG, "In %s() db_dsn:'%s' user:'******'", __function_name, db_dsn, user); clean_odbc_strerror(); memset(pdbh, 0, sizeof(ZBX_ODBC_DBH)); /* allocate environment handle */ if (0 == SQL_SUCCEEDED(SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &(pdbh->henv)))) { set_last_odbc_strerror("%s", "Cannot create ODBC environment handle."); goto end; } /* set the ODBC version environment attribute */ if (0 != CALLODBC(SQLSetEnvAttr(pdbh->henv, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0), rc, SQL_HANDLE_ENV, pdbh->henv, "Cannot set ODBC version")) { goto end; } /* allocate connection handle */ if (0 != CALLODBC(SQLAllocHandle(SQL_HANDLE_DBC, pdbh->henv, &(pdbh->hdbc)), rc, SQL_HANDLE_ENV, pdbh->henv, "Cannot create ODBC connection handle")) { goto end; } /* set login timeout */ if (0 != CALLODBC(SQLSetConnectAttr(pdbh->hdbc, (SQLINTEGER)SQL_LOGIN_TIMEOUT, (SQLPOINTER)(intptr_t)login_timeout, (SQLINTEGER)0), rc, SQL_HANDLE_DBC, pdbh->hdbc, "Cannot set ODBC login timeout")) { goto end; } /* connect to data source */ if (0 != CALLODBC(SQLConnect(pdbh->hdbc, (SQLCHAR *)db_dsn, SQL_NTS, (SQLCHAR *)user, SQL_NTS, (SQLCHAR *)pass, SQL_NTS), rc, SQL_HANDLE_DBC, pdbh->hdbc, "Cannot connect to ODBC DSN")) { goto end; } /* allocate statement handle */ if (0 != CALLODBC(SQLAllocHandle(SQL_HANDLE_STMT, pdbh->hdbc, &(pdbh->hstmt)), rc, SQL_HANDLE_DBC, pdbh->hdbc, "Cannot create ODBC statement handle.")) { goto end; } pdbh->connected = 1; ret = SUCCEED; end: if (SUCCEED != ret) odbc_DBclose(pdbh); zabbix_log(LOG_LEVEL_DEBUG, "End of %s():%s", __function_name, zbx_result_string(ret)); return ret; }
SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_connect(switch_odbc_handle_t *handle) { #ifdef SWITCH_HAVE_ODBC int result; SQLINTEGER err; int16_t mlen; unsigned char msg[200], stat[10]; SQLSMALLINT valueLength = 0; int i = 0; if (handle->env == SQL_NULL_HANDLE) { result = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &handle->env); if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error AllocHandle\n"); return SWITCH_ODBC_FAIL; } result = SQLSetEnvAttr(handle->env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0); if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error SetEnv\n"); SQLFreeHandle(SQL_HANDLE_ENV, handle->env); return SWITCH_ODBC_FAIL; } result = SQLAllocHandle(SQL_HANDLE_DBC, handle->env, &handle->con); if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error AllocHDB %d\n", result); SQLFreeHandle(SQL_HANDLE_ENV, handle->env); return SWITCH_ODBC_FAIL; } SQLSetConnectAttr(handle->con, SQL_LOGIN_TIMEOUT, (SQLPOINTER *) 10, 0); } if (handle->state == SWITCH_ODBC_STATE_CONNECTED) { switch_odbc_handle_disconnect(handle); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Re-connecting %s\n", handle->dsn); } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Connecting %s\n", handle->dsn); if (!strstr(handle->dsn, "DRIVER")) { result = SQLConnect(handle->con, (SQLCHAR *) handle->dsn, SQL_NTS, (SQLCHAR *) handle->username, SQL_NTS, (SQLCHAR *) handle->password, SQL_NTS); } else { SQLCHAR outstr[1024] = { 0 }; SQLSMALLINT outstrlen = 0; result = SQLDriverConnect(handle->con, NULL, (SQLCHAR *) handle->dsn, (SQLSMALLINT) strlen(handle->dsn), outstr, sizeof(outstr), &outstrlen, SQL_DRIVER_NOPROMPT); } if ((result != SQL_SUCCESS) && (result != SQL_SUCCESS_WITH_INFO)) { char *err_str; if ((err_str = switch_odbc_handle_get_error(handle, NULL))) { switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "%s\n", err_str); free(err_str); } else { SQLGetDiagRec(SQL_HANDLE_DBC, handle->con, 1, stat, &err, msg, 100, &mlen); switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_ERROR, "Error SQLConnect=%d errno=%d %s\n", result, (int) err, msg); } SQLFreeHandle(SQL_HANDLE_ENV, handle->env); return SWITCH_ODBC_FAIL; } result = SQLGetInfo(handle->con, SQL_DRIVER_NAME, (SQLCHAR *) handle->odbc_driver, 255, &valueLength); if (result == SQL_SUCCESS || result == SQL_SUCCESS_WITH_INFO) { for (i = 0; i < valueLength; ++i) handle->odbc_driver[i] = (char) toupper(handle->odbc_driver[i]); } if (strstr(handle->odbc_driver, "FIREBIRD") != 0 || strstr(handle->odbc_driver, "FB32") != 0 || strstr(handle->odbc_driver, "FB64") != 0) { handle->is_firebird = TRUE; } else { handle->is_firebird = FALSE; } switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG1, "Connected to [%s]\n", handle->dsn); handle->state = SWITCH_ODBC_STATE_CONNECTED; return SWITCH_ODBC_SUCCESS; #else return SWITCH_ODBC_FAIL; #endif }
/*% * create an instance of the driver. Remember, only 1 copy of the driver's * code is ever loaded, the driver has to remember which context it's * operating in. This is done via use of the dbdata argument which is * passed into all query functions. */ static isc_result_t odbc_create(const char *dlzname, unsigned int argc, char *argv[], void *driverarg, void **dbdata) { isc_result_t result; odbc_instance_t *odbc_inst = NULL; dbinstance_t *db = NULL; SQLRETURN sqlRes; #ifdef ISC_PLATFORM_USETHREADS /* if multi-threaded, we need a few extra variables. */ int dbcount; int i; char *endp; #endif /* ISC_PLATFORM_USETHREADS */ UNUSED(dlzname); UNUSED(driverarg); #ifdef ISC_PLATFORM_USETHREADS /* if debugging, let user know we are multithreaded. */ isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(1), "Odbc driver running multithreaded"); #else /* ISC_PLATFORM_USETHREADS */ /* if debugging, let user know we are single threaded. */ isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_DEBUG(1), "Odbc driver running single threaded"); #endif /* ISC_PLATFORM_USETHREADS */ /* verify we have at least 5 arg's passed to the driver */ if (argc < 5) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver requires at least " "4 command line args."); return (ISC_R_FAILURE); } /* no more than 8 arg's should be passed to the driver */ if (argc > 8) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver cannot accept more than " "7 command line args."); return (ISC_R_FAILURE); } /* multithreaded build can have multiple DB connections */ #ifdef ISC_PLATFORM_USETHREADS /* check how many db connections we should create */ dbcount = strtol(argv[1], &endp, 10); if (*endp != '\0' || dbcount < 0) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver database connection count " "must be positive."); return (ISC_R_FAILURE); } #endif /* ISC_PLATFORM_USETHREADS */ /* allocate memory for odbc instance */ odbc_inst = isc_mem_get(ns_g_mctx, sizeof(odbc_instance_t)); if (odbc_inst == NULL) return (ISC_R_NOMEMORY); memset(odbc_inst, 0, sizeof(odbc_instance_t)); /* parse connection string and get paramters. */ /* get odbc database dsn - required */ odbc_inst->dsn = (SQLCHAR *) getParameterValue(argv[2], "dsn="); if (odbc_inst->dsn == NULL) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "odbc driver requires a dns parameter."); result = ISC_R_FAILURE; goto cleanup; } /* get odbc database username */ /* if no username was passed, set odbc_inst.user = NULL; */ odbc_inst->user = (SQLCHAR *) getParameterValue(argv[2], "user="******"pass="******"Odbc driver unable to allocate memory"); result = ISC_R_NOMEMORY; goto cleanup; } /*set ODBC version = 3 */ sqlRes = SQLSetEnvAttr(odbc_inst->sql_env, SQL_ATTR_ODBC_VERSION, (void *) SQL_OV_ODBC3, 0); if (!sqlOK(sqlRes)) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_INFO, "Unable to configure ODBC environment"); result = ISC_R_NOMEMORY; goto cleanup; } } #ifdef ISC_PLATFORM_USETHREADS /* allocate memory for database connection list */ odbc_inst->db = isc_mem_get(ns_g_mctx, sizeof(db_list_t)); if (odbc_inst->db == NULL) { result = ISC_R_NOMEMORY; goto cleanup; } /* initialize DB connection list */ ISC_LIST_INIT(*odbc_inst->db); /* create the appropriate number of database instances (DBI) */ /* append each new DBI to the end of the list */ for (i=0; i < dbcount; i++) { #endif /* ISC_PLATFORM_USETHREADS */ /* how many queries were passed in from config file? */ switch(argc) { case 5: result = build_sqldbinstance(ns_g_mctx, NULL, NULL, NULL, argv[3], argv[4], NULL, &db); break; case 6: result = build_sqldbinstance(ns_g_mctx, NULL, NULL, argv[5], argv[3], argv[4], NULL, &db); break; case 7: result = build_sqldbinstance(ns_g_mctx, argv[6], NULL, argv[5], argv[3], argv[4], NULL, &db); break; case 8: result = build_sqldbinstance(ns_g_mctx, argv[6], argv[7], argv[5], argv[3], argv[4], NULL, &db); break; default: /* not really needed, should shut up compiler. */ result = ISC_R_FAILURE; } /* unsuccessful?, log err msg and cleanup. */ if (result != ISC_R_SUCCESS) { isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver could not create " "database instance object."); goto cleanup; } #ifdef ISC_PLATFORM_USETHREADS /* when multithreaded, build a list of DBI's */ ISC_LINK_INIT(db, link); ISC_LIST_APPEND(*odbc_inst->db, db, link); #endif result = odbc_connect(odbc_inst, (odbc_db_t **) &(db->dbconn)); if (result != ISC_R_SUCCESS) { #ifdef ISC_PLATFORM_USETHREADS /* * if multi threaded, let user know which * connection failed. user could be * attempting to create 10 db connections and * for some reason the db backend only allows * 9. */ isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver failed to create database " "connection number %u after 3 attempts", i+1); #else isc_log_write(dns_lctx, DNS_LOGCATEGORY_DATABASE, DNS_LOGMODULE_DLZ, ISC_LOG_ERROR, "Odbc driver failed to create database " "connection after 3 attempts"); #endif goto cleanup; } #ifdef ISC_PLATFORM_USETHREADS /* set DB = null for next loop through. */ db = NULL; } /* end for loop */ #else /* tell odbc_inst about the db connection we just created. */ odbc_inst->db = db; #endif /* set dbdata to the odbc_instance we created. */ *dbdata = odbc_inst; /* hey, we got through all of that ok, return success. */ return(ISC_R_SUCCESS); cleanup: destroy_odbc_instance(odbc_inst); return result; }
SWITCH_DECLARE(switch_odbc_status_t) switch_odbc_handle_callback_exec_detailed(const char *file, const char *func, int line, switch_odbc_handle_t *handle, const char *sql, switch_core_db_callback_func_t callback, void *pdata, char **err) { #ifdef SWITCH_HAVE_ODBC SQLHSTMT stmt = NULL; SQLSMALLINT c = 0, x = 0; SQLLEN m = 0; char *err_str = NULL; int result; int err_cnt = 0; int done = 0; switch_assert(callback != NULL); if (!db_is_up(handle)) { goto error; } if (SQLAllocHandle(SQL_HANDLE_STMT, handle->con, &stmt) != SQL_SUCCESS) { err_str = strdup("Unable to SQL allocate handle."); goto error; } if (SQLPrepare(stmt, (unsigned char *) sql, SQL_NTS) != SQL_SUCCESS) { err_str = strdup("Unable to prepare SQL statement."); goto error; } result = SQLExecute(stmt); if (result != SQL_SUCCESS && result != SQL_SUCCESS_WITH_INFO && result != SQL_NO_DATA) { goto error; } SQLNumResultCols(stmt, &c); SQLRowCount(stmt, &m); while (!done) { int name_len = 256; char **names; char **vals; int y = 0; result = SQLFetch(stmt); if (result != SQL_SUCCESS) { if (result != SQL_NO_DATA) { err_cnt++; } break; } names = calloc(c, sizeof(*names)); vals = calloc(c, sizeof(*vals)); switch_assert(names && vals); for (x = 1; x <= c; x++) { SQLSMALLINT NameLength = 0, DataType = 0, DecimalDigits = 0, Nullable = 0; SQLULEN ColumnSize = 0; names[y] = malloc(name_len); memset(names[y], 0, name_len); SQLDescribeCol(stmt, x, (SQLCHAR *) names[y], (SQLSMALLINT) name_len, &NameLength, &DataType, &ColumnSize, &DecimalDigits, &Nullable); if (!ColumnSize) { ColumnSize = 255; } ColumnSize++; vals[y] = malloc(ColumnSize); memset(vals[y], 0, ColumnSize); SQLGetData(stmt, x, SQL_C_CHAR, (SQLCHAR *) vals[y], ColumnSize, NULL); y++; } if (callback(pdata, y, vals, names)) { done = 1; } for (x = 0; x < y; x++) { free(names[x]); free(vals[x]); } free(names); free(vals); } SQLFreeHandle(SQL_HANDLE_STMT, stmt); if (!err_cnt) { return SWITCH_ODBC_SUCCESS; } error: if (stmt) { err_str = switch_odbc_handle_get_error(handle, stmt); SQLFreeHandle(SQL_HANDLE_STMT, stmt); } if (err_str) { switch_log_printf(SWITCH_CHANNEL_ID_LOG, file, func, line, NULL, SWITCH_LOG_ERROR, "ERR: [%s]\n[%s]\n", sql, switch_str_nil(err_str)); if (err) { *err = err_str; } else { free(err_str); } } #endif return SWITCH_ODBC_FAIL; }
/* Changed ... Have to implement the same for translators */ void adddrivers_to_list (ControlRef widget, WindowRef dlg, BOOL addNotify) { wchar_t drvdesc[1024], drvattrs[1024], driver[1024]; DataBrowserItemID item = DBITEM_ID + 1; DataBrowserCallbacks dbCallbacks; ThemeDrawingState outState = NULL; UInt16 colSize[5] = { 150, 150, 100, 50 , 50}; void *handle; SInt16 outBaseline; Point ioBound; struct stat _stat; SQLSMALLINT len, len1; SQLRETURN ret; HENV henv, drv_henv; HDBC drv_hdbc; pSQLGetInfoFunc funcHdl; pSQLAllocHandle allocHdl; pSQLAllocEnv allocEnvHdl = NULL; pSQLAllocConnect allocConnectHdl = NULL; pSQLFreeHandle freeHdl; pSQLFreeEnv freeEnvHdl; pSQLFreeConnect freeConnectHdl; char *_drv_u8 = NULL; int i; if (!widget) return; GetThemeDrawingState (&outState); /* Install an event handler on the component databrowser */ dbCallbacks.version = kDataBrowserLatestCallbacks; InitDataBrowserCallbacks (&dbCallbacks); if (addNotify) dbCallbacks.u.v1.itemNotificationCallback = NewDataBrowserItemNotificationUPP (drivers_notification_item); /* On Mac OS X 10.0.x : clientDataCallback */ dbCallbacks.u.v1.itemDataCallback = NewDataBrowserItemDataUPP (drivers_getset_item); SetDataBrowserCallbacks (widget, &dbCallbacks); /* Begin the draw of the data browser */ SetDataBrowserTarget (widget, DBITEM_ID); /* Make the clean up */ for (i = 0; i < Drivers_nrows; i++, item++) { CFRelease (Drivers_array[0][i]); Drivers_array[0][i] = NULL; CFRelease (Drivers_array[1][i]); Drivers_array[1][i] = NULL; CFRelease (Drivers_array[2][i]); Drivers_array[2][i] = NULL; CFRelease (Drivers_array[3][i]); Drivers_array[3][i] = NULL; CFRelease (Drivers_array[4][i]); Drivers_array[4][i] = NULL; RemoveDataBrowserItems (widget, DBITEM_ID, 1, &item, DBNAME_ID); } /* Global Initialization */ Drivers_nrows = 0; item = DBITEM_ID + 1; /* Create a HENV to get the list of drivers then */ ret = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { _iodbcdm_nativeerrorbox (dlg, henv, SQL_NULL_HANDLE, SQL_NULL_HANDLE); goto end; } /* Set the version ODBC API to use */ SQLSetEnvAttr (henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_UINTEGER); /* Get the list of drivers */ ret = SQLDriversW (henv, SQL_FETCH_FIRST, drvdesc, sizeof (drvdesc)/sizeof(wchar_t), &len, drvattrs, sizeof (drvattrs)/sizeof(wchar_t), &len1); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO && ret != SQL_NO_DATA) { _iodbcdm_nativeerrorbox (dlg, henv, SQL_NULL_HANDLE, SQL_NULL_HANDLE); goto error; } while (ret != SQL_NO_DATA) { Drivers_array[0][Drivers_nrows] = convert_wchar_to_CFString(drvdesc); /* Get the driver library name */ SQLSetConfigMode (ODBC_BOTH_DSN); SQLGetPrivateProfileStringW (drvdesc, L"Driver", L"", driver, sizeof (driver)/sizeof(wchar_t), L"odbcinst.ini"); if (driver[0] == L'\0') SQLGetPrivateProfileStringW (L"Default", L"Driver", L"", driver, sizeof (driver)/sizeof(wchar_t), L"odbcinst.ini"); if (driver[0] == L'\0') { if (Drivers_array[0][Drivers_nrows]) { CFRelease (Drivers_array[0][Drivers_nrows]); Drivers_array[0][Drivers_nrows] = NULL; } goto skip; } Drivers_array[1][Drivers_nrows] = convert_wchar_to_CFString(driver); /* Alloc a connection handle */ drv_hdbc = NULL; drv_henv = NULL; _drv_u8 = (char *) dm_SQL_WtoU8((SQLWCHAR*)driver, SQL_NTS); if (_drv_u8 == NULL) goto skip; if ((handle = DLL_OPEN(_drv_u8)) != NULL) { if ((allocHdl = (pSQLAllocHandle)DLL_PROC(handle, "SQLAllocHandle")) != NULL) { ret = allocHdl(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &drv_henv); if (ret == SQL_ERROR) goto nodriverver; ret = allocHdl(SQL_HANDLE_DBC, drv_henv, &drv_hdbc); if (ret == SQL_ERROR) goto nodriverver; } else { if ((allocEnvHdl = (pSQLAllocEnv)DLL_PROC(handle, "SQLAllocEnv")) != NULL) { ret = allocEnvHdl(&drv_henv); if (ret == SQL_ERROR) goto nodriverver; } else goto nodriverver; if ((allocConnectHdl = (pSQLAllocConnect)DLL_PROC(handle, "SQLAllocConnect")) != NULL) { ret = allocConnectHdl(drv_henv, &drv_hdbc); if (ret == SQL_ERROR) goto nodriverver; } else goto nodriverver; } /* * Use SQLGetInfoA for Unicode drivers * and SQLGetInfo for ANSI drivers */ funcHdl = (pSQLGetInfoFunc)DLL_PROC(handle, "SQLGetInfoA"); if (!funcHdl) funcHdl = (pSQLGetInfoFunc)DLL_PROC(handle, "SQLGetInfo"); if (funcHdl) { /* Retrieve some informations */ ret = funcHdl (drv_hdbc, SQL_DRIVER_VER, drvattrs, sizeof(drvattrs), &len); if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) { char *p = drvattrs; /* Find the description if one provided */ for (; *p ; p++) { if (*p == ' ') { *p++ = '\0'; break; } } /* * Store Version */ Drivers_array[2][Drivers_nrows] = CFStringCreateWithCString(NULL, (char *)drvattrs, kCFStringEncodingUTF8); } else goto nodriverver; } else if ((funcHdl = (pSQLGetInfoFunc)DLL_PROC(handle, "SQLGetInfoW")) != NULL) { /* Retrieve some informations */ ret = funcHdl (drv_hdbc, SQL_DRIVER_VER, drvattrs, sizeof(drvattrs), &len); if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) { wchar_t *p = drvattrs; /* Find the description if one provided */ for (; *p ; p++) { if (*p == L' ') { *p++ = L'\0'; break; } } /* * Store Version */ Drivers_array[2][Drivers_nrows] = convert_wchar_to_CFString(drvattrs); } else goto nodriverver; } else goto nodriverver; } else { nodriverver: Drivers_array[2][Drivers_nrows] = CFStringCreateWithCString(NULL, "##.##", kCFStringEncodingUTF8); } if(drv_hdbc || drv_henv) { if(allocConnectHdl && (freeConnectHdl = (pSQLFreeConnect)DLL_PROC(handle, "SQLFreeConnect")) != NULL) { freeConnectHdl(drv_hdbc); drv_hdbc = NULL; } if(allocEnvHdl && (freeEnvHdl = (pSQLFreeEnv)DLL_PROC(handle, "SQLFreeEnv")) != NULL) { freeEnvHdl(drv_henv); drv_henv = NULL; } } if ((drv_hdbc || drv_henv) && (freeHdl = (pSQLFreeHandle)DLL_PROC(handle, "SQLFreeHandle")) != NULL) { if(drv_hdbc) freeHdl(SQL_HANDLE_DBC, drv_hdbc); if(drv_henv) freeHdl(SQL_HANDLE_ENV, drv_henv); } DLL_CLOSE(handle); /* Get the size and date of the driver */ if (!stat (_drv_u8, &_stat)) { CFStringRef strRef; struct tm drivertime; char buf[100]; Drivers_array[3][Drivers_nrows] = CFStringCreateWithFormat(NULL, NULL, strRef = CFStringCreateWithCString(NULL, "%d Kb", kCFStringEncodingUTF8), (int) (_stat.st_size / 1024)); CFRelease(strRef); localtime_r (&_stat.st_mtime, &drivertime); strftime (buf, sizeof (buf), "%c", &drivertime); Drivers_array[4][Drivers_nrows] = CFStringCreateWithCString(NULL, buf, kCFStringEncodingUTF8); } else { Drivers_array[3][Drivers_nrows] = CFStringCreateWithCString(NULL, "-", kCFStringEncodingUTF8); Drivers_array[4][Drivers_nrows] = CFStringCreateWithCString(NULL, "-", kCFStringEncodingUTF8); } for(i = 0 ; i < 5 ; i++) { GetThemeTextDimensions (Drivers_array[i][Drivers_nrows], kThemeSystemFont, kThemeStateActive, false, &ioBound, &outBaseline); if(colSize[i] < ioBound.h) colSize[i] = ioBound.h; } AddDataBrowserItems (widget, DBITEM_ID, 1, &item, DBNAME_ID); item++; Drivers_nrows++; /* Process next one */ skip: MEM_FREE (_drv_u8); _drv_u8 = NULL; ret = SQLDriversW (henv, SQL_FETCH_NEXT, drvdesc, sizeof (drvdesc)/sizeof(wchar_t), &len, drvattrs, sizeof (drvattrs)/sizeof(wchar_t), &len1); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO && ret != SQL_NO_DATA) { _iodbcdm_nativeerrorbox (dlg, henv, SQL_NULL_HANDLE, SQL_NULL_HANDLE); goto error; } } error: /* Clean all that */ SQLFreeHandle (SQL_HANDLE_ENV, henv); end: ActivateControl (widget); /* Resize the columns to have a good look */ SetDataBrowserTableViewNamedColumnWidth (widget, DBNAME_ID, colSize[0] + 20); SetDataBrowserTableViewNamedColumnWidth (widget, DBFILE_ID, colSize[1] + 20); SetDataBrowserTableViewNamedColumnWidth (widget, DBVERSION_ID, colSize[2] + 20); SetDataBrowserTableViewNamedColumnWidth (widget, DBSIZE_ID, colSize[3] + 20); SetDataBrowserTableViewNamedColumnWidth (widget, DBDATE_ID, colSize[4] + 20); DrawOneControl (widget); /* Remove the DataBrowser callback */ SetDataBrowserCallbacks (NULL, &dbCallbacks); if(outState) DisposeThemeDrawingState (outState); }
//************************************************************************* int main() { SQLHENV env; SQLHDBC dbc; SQLHSTMT stmt; SQLRETURN ret; SQLCHAR outstr[1024]; SQLSMALLINT outstrlen; // Aloocate an environment handle ret=SQLAllocHandle(SQL_HANDLE_ENV,SQL_NULL_HANDLE,&env); checkrc(ret,__LINE__); //we need odbc3 support SQLSetEnvAttr(env,SQL_ATTR_ODBC_VERSION,(void*)SQL_OV_ODBC3,0); //ALLOCATE A Connection handle ret = SQLAllocHandle(SQL_HANDLE_DBC,env,&dbc); checkrc(ret,__LINE__); // connect to the DSN mydsn ret = SQLConnect (dbc, (SQLCHAR *) "DSN=mycsql;MODE=csql;SERVER=127.0.0.1;PORT=5678;", (SQLSMALLINT) strlen ("DSN=mycsql;MODE=csql;SERVER=127.0.0.1;PORT=5678;"), (SQLCHAR *) "root", (SQLSMALLINT) strlen ("root"), (SQLCHAR *) "manager", (SQLSMALLINT) strlen ("")); if(SQL_SUCCEEDED(ret)) { printf("\nConnected to the Data Source..\n"); } else { printf("connection failed\n"); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); return 1; } ret = SQLAllocHandle(SQL_HANDLE_STMT,dbc,&stmt); checkrc(ret,__LINE__); SQLCHAR table[100]="CREATE TABLE EMP(EID INT,SALARY INT)"; ret = SQLPrepare(stmt,table,SQL_NTS); checkrc(ret,__LINE__); ret = SQLDisconnect(dbc); checkrc(ret,__LINE__); //AFTER CLOSE THE CONNECTION ,CALL execute ret = SQLExecute(stmt); int rettype = ret; if(ret ) printf("After closing the connection, Execution failed\n"); ret = SQLFreeHandle(SQL_HANDLE_DBC,dbc); checkrc(ret,__LINE__); ret = SQLFreeHandle(SQL_HANDLE_ENV,env); checkrc(ret,__LINE__); if(rettype ==0)return 1; return 0; }
StatementHolder(Connection &conn) { if (SQLAllocHandle(SQL_HANDLE_STMT, conn.GetHolder().GetHandle(), &Stmt) != SQL_SUCCESS) throw StatementException("Error alloc statement", srErrorAllocStatement); }
static SQLHSTMT execute_cb(struct odbc_obj *obj, void *data) { struct ast_cdr *cdr = data; SQLRETURN ODBC_res; char sqlcmd[2048] = "", timestr[128]; struct ast_tm tm; SQLHSTMT stmt; ast_localtime(&cdr->start, &tm, ast_test_flag(&config, CONFIG_USEGMTIME) ? "GMT" : NULL); ast_strftime(timestr, sizeof(timestr), DATE_FORMAT, &tm); if (ast_test_flag(&config, CONFIG_LOGUNIQUEID)) { snprintf(sqlcmd,sizeof(sqlcmd),"INSERT INTO %s " "(calldate,clid,src,dst,dcontext,channel,dstchannel,lastapp," "lastdata,duration,billsec,disposition,amaflags,accountcode,uniqueid,userfield) " "VALUES ({ts '%s'},?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)", table, timestr); } else { snprintf(sqlcmd,sizeof(sqlcmd),"INSERT INTO %s " "(calldate,clid,src,dst,dcontext,channel,dstchannel,lastapp,lastdata," "duration,billsec,disposition,amaflags,accountcode) " "VALUES ({ts '%s'},?,?,?,?,?,?,?,?,?,?,?,?,?)", table, timestr); } ODBC_res = SQLAllocHandle(SQL_HANDLE_STMT, obj->con, &stmt); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { ast_verb(11, "cdr_odbc: Failure in AllocStatement %d\n", ODBC_res); SQLFreeHandle(SQL_HANDLE_STMT, stmt); return NULL; } SQLBindParameter(stmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->clid), 0, cdr->clid, 0, NULL); SQLBindParameter(stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->src), 0, cdr->src, 0, NULL); SQLBindParameter(stmt, 3, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dst), 0, cdr->dst, 0, NULL); SQLBindParameter(stmt, 4, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dcontext), 0, cdr->dcontext, 0, NULL); SQLBindParameter(stmt, 5, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->channel), 0, cdr->channel, 0, NULL); SQLBindParameter(stmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->dstchannel), 0, cdr->dstchannel, 0, NULL); SQLBindParameter(stmt, 7, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->lastapp), 0, cdr->lastapp, 0, NULL); SQLBindParameter(stmt, 8, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->lastdata), 0, cdr->lastdata, 0, NULL); if (ast_test_flag(&config, CONFIG_HRTIME)) { double hrbillsec = 0.0; double hrduration; if (!ast_tvzero(cdr->answer)) { hrbillsec = (double) ast_tvdiff_us(cdr->end, cdr->answer) / 1000000.0; } hrduration = (double) ast_tvdiff_us(cdr->end, cdr->start) / 1000000.0; SQLBindParameter(stmt, 9, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_FLOAT, 0, 0, &hrduration, 0, NULL); SQLBindParameter(stmt, 10, SQL_PARAM_INPUT, SQL_C_DOUBLE, SQL_FLOAT, 0, 0, &hrbillsec, 0, NULL); } else { SQLBindParameter(stmt, 9, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->duration, 0, NULL); SQLBindParameter(stmt, 10, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->billsec, 0, NULL); } if (ast_test_flag(&config, CONFIG_DISPOSITIONSTRING)) SQLBindParameter(stmt, 11, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, strlen(ast_cdr_disp2str(cdr->disposition)) + 1, 0, ast_cdr_disp2str(cdr->disposition), 0, NULL); else SQLBindParameter(stmt, 11, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->disposition, 0, NULL); SQLBindParameter(stmt, 12, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &cdr->amaflags, 0, NULL); SQLBindParameter(stmt, 13, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->accountcode), 0, cdr->accountcode, 0, NULL); if (ast_test_flag(&config, CONFIG_LOGUNIQUEID)) { SQLBindParameter(stmt, 14, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->uniqueid), 0, cdr->uniqueid, 0, NULL); SQLBindParameter(stmt, 15, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_CHAR, sizeof(cdr->userfield), 0, cdr->userfield, 0, NULL); } ODBC_res = SQLExecDirect(stmt, (unsigned char *)sqlcmd, SQL_NTS); if ((ODBC_res != SQL_SUCCESS) && (ODBC_res != SQL_SUCCESS_WITH_INFO)) { ast_verb(11, "cdr_odbc: Error in ExecDirect: %d\n", ODBC_res); SQLFreeHandle(SQL_HANDLE_STMT, stmt); return NULL; } return stmt; }
bool CODBCRecordset::InsertBinary(const CString& strQuery, const u8* pData, int nSize) { if (!m_pDatabase->IsOpen()) { assert(0); return false; } if ((0 == strQuery.GetLength()) || 0 == pData) return false; if (8000 < nSize) return false; HSTMT hStmt; SQLTCHAR* pWriteBuff; SQLLEN ind = SQL_DATA_AT_EXEC; if (SQL_ERROR == SQLAllocHandle(SQL_HANDLE_STMT, m_pDatabase->GetConn(), &hStmt)) { return false; } if (SQL_ERROR == SQLPrepare(hStmt, SQLData(strQuery), SQL_NTS)) { return false; } if (SQL_ERROR == SQLBindParameter(hStmt, 1, SQL_PARAM_INPUT, SQL_C_BINARY, SQL_BINARY, nSize, 0, (SQLPOINTER)pData, nSize, &ind)) { return false; } if (SQL_ERROR == SQLExecute(hStmt)) { return false; } if (SQL_ERROR == SQLParamData(hStmt, (SQLPOINTER*)&pWriteBuff)) { return false; } int nWrSize; int len; SQLRETURN sqlRet; for (nWrSize = 0; nWrSize < nSize; nWrSize += BINARY_CHUNK_SIZE, pWriteBuff += BINARY_CHUNK_SIZE) { if (nWrSize + BINARY_CHUNK_SIZE < nSize) len = BINARY_CHUNK_SIZE; else len = nSize - nWrSize; sqlRet = SQLPutData(hStmt, (SQLPOINTER)pWriteBuff, len); } if (SQL_ERROR == sqlRet) { return false; } if (SQL_ERROR == SQLParamData(hStmt, (SQLPOINTER*)&pWriteBuff)) { return false; } SQLFreeHandle(SQL_HANDLE_STMT, hStmt); return true; }
void adddrivers_to_list (GtkWidget *widget, GtkWidget *dlg) { SQLCHAR drvdesc[1024], drvattrs[1024], driver[1024], size[64]; SQLCHAR *data[4]; void *handle; struct stat _stat; SQLSMALLINT len, len1; SQLRETURN ret; HENV henv, drv_henv; HDBC drv_hdbc; pSQLGetInfoFunc funcHdl; pSQLAllocHandle allocHdl; pSQLAllocEnv allocEnvHdl = NULL; pSQLAllocConnect allocConnectHdl = NULL; pSQLFreeHandle freeHdl; pSQLFreeEnv freeEnvHdl; pSQLFreeConnect freeConnectHdl; if (!GTK_IS_CLIST (widget)) return; gtk_clist_clear (GTK_CLIST (widget)); /* Create a HENV to get the list of drivers then */ ret = SQLAllocHandle (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &henv); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO) { _iodbcdm_nativeerrorbox (dlg, henv, SQL_NULL_HANDLE, SQL_NULL_HANDLE); goto end; } /* Set the version ODBC API to use */ SQLSetEnvAttr (henv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER) SQL_OV_ODBC3, SQL_IS_INTEGER); /* Get the list of drivers */ ret = SQLDrivers (henv, SQL_FETCH_FIRST, drvdesc, sizeof (drvdesc) / sizeof (SQLTCHAR), &len, drvattrs, sizeof (drvattrs) / sizeof (SQLTCHAR), &len1); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO && ret != SQL_NO_DATA) { _iodbcdm_nativeerrorbox (dlg, henv, SQL_NULL_HANDLE, SQL_NULL_HANDLE); goto error; } while (ret != SQL_NO_DATA) { data[0] = drvdesc; /* Get the driver library name */ SQLSetConfigMode (ODBC_BOTH_DSN); SQLGetPrivateProfileString (drvdesc, "Driver", "", driver, sizeof (driver) / sizeof (SQLTCHAR), "odbcinst.ini"); if (driver[0] == '\0') SQLGetPrivateProfileString ("Default", "Driver", "", driver, sizeof (driver) / sizeof (SQLTCHAR), "odbcinst.ini"); if (driver[0] == '\0') { data[0] = NULL; goto skip; } data[1] = driver; drv_hdbc = NULL; drv_henv = NULL; if ((handle = (void *) DLL_OPEN (driver)) != NULL) { if ((allocHdl = (pSQLAllocHandle) DLL_PROC (handle, "SQLAllocHandle")) != NULL) { ret = allocHdl (SQL_HANDLE_ENV, SQL_NULL_HANDLE, &drv_henv); if (ret == SQL_ERROR) goto nodriverver; ret = allocHdl (SQL_HANDLE_DBC, drv_henv, &drv_hdbc); if (ret == SQL_ERROR) goto nodriverver; } else { if ((allocEnvHdl = (pSQLAllocEnv) DLL_PROC (handle, "SQLAllocEnv")) != NULL) { ret = allocEnvHdl (&drv_henv); if (ret == SQL_ERROR) goto nodriverver; } else goto nodriverver; if ((allocConnectHdl = (pSQLAllocConnect) DLL_PROC (handle, "SQLAllocConnect")) != NULL) { ret = allocConnectHdl (drv_henv, &drv_hdbc); if (ret == SQL_ERROR) goto nodriverver; } else goto nodriverver; } if ((funcHdl = (pSQLGetInfoFunc) DLL_PROC (handle, "SQLGetInfo")) != NULL) { /* Retrieve some information */ ret = funcHdl (drv_hdbc, SQL_DRIVER_VER, drvattrs, sizeof (drvattrs), &len); if (ret == SQL_SUCCESS || ret == SQL_SUCCESS_WITH_INFO) { unsigned int z; /* Drop the description if one provided */ for (z = 0; ((char *) drvattrs)[z]; z++) if (((char *) drvattrs)[z] == ' ') ((char *) drvattrs)[z] = '\0'; data[2] = drvattrs; } else goto nodriverver; } else goto nodriverver; } else { nodriverver: data[2] = "##.##"; } if (drv_hdbc || drv_henv) { if (allocConnectHdl && (freeConnectHdl = (pSQLFreeConnect) DLL_PROC (handle, "SQLFreeConnect")) != NULL) { freeConnectHdl (drv_hdbc); drv_hdbc = NULL; } if (allocEnvHdl && (freeEnvHdl = (pSQLFreeEnv) DLL_PROC (handle, "SQLFreeEnv")) != NULL) { freeEnvHdl (drv_henv); drv_henv = NULL; } } if ((drv_hdbc || drv_henv) && (freeHdl = (pSQLFreeHandle) DLL_PROC (handle, "SQLFreeHandle")) != NULL) { if (drv_hdbc) freeHdl (SQL_HANDLE_DBC, drv_hdbc); if (drv_henv) freeHdl (SQL_HANDLE_ENV, drv_henv); } if (handle) DLL_CLOSE (handle); /* Get the size of the driver */ if (!stat (driver, &_stat)) { sprintf (size, "%d Kb", (int) (_stat.st_size / 1024)); data[3] = size; } else data[3] = "-"; gtk_clist_append (GTK_CLIST (widget), data); skip: ret = SQLDrivers (henv, SQL_FETCH_NEXT, drvdesc, sizeof (drvdesc) / sizeof (SQLTCHAR), &len, drvattrs, sizeof (drvattrs) / sizeof (SQLTCHAR), &len1); if (ret != SQL_SUCCESS && ret != SQL_SUCCESS_WITH_INFO && ret != SQL_NO_DATA) { _iodbcdm_nativeerrorbox (dlg, henv, SQL_NULL_HANDLE, SQL_NULL_HANDLE); goto error; } } error: /* Clean all that */ SQLFreeHandle (SQL_HANDLE_ENV, henv); end: if (GTK_CLIST (widget)->rows > 0) { gtk_clist_columns_autosize (GTK_CLIST (widget)); gtk_clist_sort (GTK_CLIST (widget)); } }