/* --------------------------------------------------------- TestSQLExecute --------------------------------------------------------- */ PassFail TestSQLExecute(TestInfo *pTestInfo, int MX_MP_SPECIFIC) { TEST_DECLARE; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; TCHAR *ExecStr[15]; TCHAR *szInput[] = {_T("Inst char"),_T("Inst vchar"),_T("1234.56789"),_T("1234.56789"),_T("1200"),_T("12000"),_T("123.45"),_T("123.45"),_T("123.45"),_T("1993-07-01"),_T("09:45:30"),_T("1993-08-02 08:44:31.001"),_T("120000"),_T("1234567890.56789"),_T("1234567890.456789"),_T("1234567890.456789"),_T("0.01234567890123456789"),_T("1234.56789"),_T("1234567890.56789"),_T("12345678901234567890.0123456789"),_T("Inst char"),_T("Inst vchar")}; SQLLEN cbInput = SQL_NTS; SQLUSMALLINT i = 0; SQLSMALLINT Type[] = {SQL_WCHAR,SQL_WVARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER,SQL_REAL,SQL_FLOAT,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_BIGINT,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_WCHAR,SQL_WVARCHAR}; SQLUINTEGER ColPrec[] = {254,254,10,10,5,10,7,15,15,10,8,26,19,19,19,128,128,10,18,30,254,254}; SQLSMALLINT ColScale[]= {0,0,5,5,0,0,0,0,0,0,0,0,0,0,6,0,128,5,5,10,0,0}; short CCharOutput1,CCharOutput2; SQLLEN OutputLen1,OutputLen2; int actual_insert=0,num_insert=0; SWORD param = 0; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLExecute"), charset_file); if (var_list == NULL) return FAILED; //print_list(var_list); ExecStr[0] = var_mapping(_T("SQLExecute_ExecStr_0"), var_list); ExecStr[1] = var_mapping(_T("SQLExecute_ExecStr_1"), var_list); ExecStr[2] = var_mapping(_T("SQLExecute_ExecStr_2"), var_list); ExecStr[3] = var_mapping(_T("SQLExecute_ExecStr_3"), var_list); ExecStr[4] = var_mapping(_T("SQLExecute_ExecStr_4"), var_list); ExecStr[5] = var_mapping(_T("SQLExecute_ExecStr_5"), var_list); ExecStr[6] = var_mapping(_T("SQLExecute_ExecStr_6"), var_list); ExecStr[7] = var_mapping(_T("SQLExecute_ExecStr_7"), var_list); ExecStr[8] = var_mapping(_T("SQLExecute_ExecStr_8"), var_list); ExecStr[9] = var_mapping(_T("SQLExecute_ExecStr_9"), var_list); ExecStr[10] = var_mapping(_T("SQLExecute_ExecStr_10"), var_list); ExecStr[11] = var_mapping(_T("SQLExecute_ExecStr_11"), var_list); ExecStr[12] = var_mapping(_T("SQLExecute_ExecStr_12"), var_list); ExecStr[13] = var_mapping(_T("SQLExecute_ExecStr_13"), var_list); ExecStr[14] = var_mapping(_T("SQLExecute_ExecStr_14"), var_list); //================================================================================================= LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => SQLExecute.\n")); TEST_INIT; TESTCASE_BEGIN("Setup for SQLExecute tests\n"); if(!FullConnect(pTestInfo)){ LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode=SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[4],SQL_NTS); returncode=SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[5],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode=SQLExecDirect(hstmt,(SQLTCHAR *)ExecStr[6],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode=SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[7],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode=SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[8],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup TESTCASE_BEGIN("Test #1: Positive Functionality of SQLExecute\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR *)ExecStr[9],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,1,SQL_C_SHORT,&CCharOutput1,0,&OutputLen1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindCol(hstmt,2,SQL_C_SHORT,&CCharOutput2,0,&OutputLen2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } while (returncode != SQL_NO_DATA_FOUND) { returncode = SQLFetch(hstmt); if (returncode != SQL_NO_DATA_FOUND) { if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } } SQLFreeStmt(hstmt,SQL_CLOSE); returncode = SQLPrepare(hstmt,(SQLTCHAR *)ExecStr[10],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[4],SQL_NTS); TESTCASE_END; TESTCASE_BEGIN("Test #2: Positive Functionality of SQLExecute\n"); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[0],_tcslen(ExecStr[0])); /* cleanup */ returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[1],_tcslen(ExecStr[1])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } TESTCASE_END; TESTCASE_BEGIN("Test #3: Positive Functionality of SQLExecute with SQL_NTS\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[2],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } TESTCASE_END; TESTCASE_BEGIN("Test #4: Positive Functionality of SQLPrepare then SQLExecute twice\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[2],_tcslen(ExecStr[2])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } TESTCASE_END; SQLFreeStmt(hstmt,SQL_CLOSE); SQLFreeStmt(hstmt,SQL_UNBIND); SQLFreeStmt(hstmt,SQL_RESET_PARAMS); TESTCASE_BEGIN("Test #5: Positive Functionality of SQLExecute with params\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[3],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ for (i = 0; i <= 3; i++){ if (i==0) Type[0] = 1; returncode = SQLBindParameter(hstmt,(SWORD)(i+1),SQL_PARAM_INPUT,SQL_C_TCHAR,Type[i],EXEC_LEN,0,szInput[i],0,&cbInput); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){ LogMsg(NONE,_T("Type[i]: %d \n"),Type[i]); LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } TESTCASE_END; TESTCASE_BEGIN("Test #6: Negative Functionality of SQLExecute with less params\n"); returncode = SQLFreeStmt(hstmt,SQL_DROP); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[3],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,Type[0],EXEC_LEN,0,szInput[0],0,&cbInput); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_ERROR,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } } } TESTCASE_END; TESTCASE_BEGIN("Test #7: Negative Functionality of SQLExecute with not prepared stmt\n"); returncode = SQLFreeStmt(hstmt,SQL_DROP); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_ERROR,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } TESTCASE_END; TESTCASE_BEGIN("Test #8: Negative Functionality of SQLExecute with invalid handle\n"); returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[2],_tcslen(ExecStr[2])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else{ returncode = SQLExecute((SQLHANDLE)NULL); if(!CHECKRC(SQL_INVALID_HANDLE,returncode,"SQLExecute")){ LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } TESTCASE_END; returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[0],_tcslen(ExecStr[0])); /* cleanup */ TESTCASE_BEGIN("Test #9: Stress Positive Functionality of SQLExecute.\n"); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[11],SQL_NTS); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[12],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[13],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { actual_insert = 0; for (num_insert = 0; num_insert < MAX_INSERTED_ROWS; num_insert++) { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else actual_insert++; } if (actual_insert != MAX_INSERTED_ROWS) { TEST_FAILED; LogMsg(ERRMSG,_T("failed to insert rows actual => %d & excepted => %d.\n"),actual_insert,MAX_INSERTED_ROWS); } } } SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[11],SQL_NTS); TESTCASE_END; TESTCASE_BEGIN("Test #10: Stress Positive Functionality of SQLExecute with Params.\n"); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[11],SQL_NTS); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[12],SQL_NTS); LogMsg(NONE,_T("ExecStr[12]: %s\n"), ExecStr[12]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[14],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { actual_insert = 0; returncode = SQLNumParams(hstmt, ¶m); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumParams")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } for (num_insert = 0; num_insert < MAX_INSERTED_ROWS; num_insert++) { for (i = 0; i < param; i++) { if (i==0) Type[0] = 1; if (MX_MP_SPECIFIC == MX_SPECIFIC) { returncode = SQLBindParameter(hstmt,(SWORD)(i+1),SQL_PARAM_INPUT,SQL_C_TCHAR,Type[i],ColPrec[i],ColScale[i],szInput[i],0,&cbInput); } else { returncode = SQLBindParameter(hstmt,(SWORD)(i+1),SQL_PARAM_INPUT,SQL_C_TCHAR,Type[i],ColPrec[i],ColScale[i],szInput[i],300,&cbInput); } if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else actual_insert++; } if (actual_insert != MAX_INSERTED_ROWS) { TEST_FAILED; LogMsg(ERRMSG,_T("failed to insert rows actual => %d & excepted => %d.\n"),actual_insert,MAX_INSERTED_ROWS); } } } SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[11],SQL_NTS); TESTCASE_END; TESTCASE_BEGIN("Test #11: Negative Functionality of SQLExecute with already existing table\n"); returncode = SQLFreeStmt(hstmt,SQL_DROP); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFreeStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[0],_tcslen(ExecStr[0])); /* cleanup */ returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecStr[1],_tcslen(ExecStr[1])); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_ERROR,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } SQLExecDirect(hstmt,(SQLTCHAR*)ExecStr[0],_tcslen(ExecStr[0])); /* cleanup */ } } TESTCASE_END; //================================================================================================= FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLExecute.\n")); free_list(var_list); TEST_RETURN; }
//************************************************************************* // FUNCTION FOR INSERTING ROWS IN IT. int InsertTest(SQLHANDLE env,SQLHANDLE dbc,SQLHANDLE stmt) { int ret; int f1=90; // f1 field short int f2=20;//f2 field char f3[50]= "jitendra"; float f4 = 2.5; float f5 = 10.50; int f9 = 5; long long f10 = 15000; int result; SQLINTEGER slen = SQL_NTS; //*********************************** // STRUCTURE FIOR DATE DATATYPE SQL_DATE_STRUCT date; char strDate[30]; date.year=2008; date.month=03; date.day=18; // strcpy(strDate,"{d '2008-03-18'}"); //******************************* // STRUCTURE FOR TIME DATATYPE. SQL_TIME_STRUCT time; time.hour = 5; time.minute = 22; time.second = 10; //***************************** // STRUCTURE FOR TIMESTAMP DATATYPE SQL_TIMESTAMP_STRUCT timestamp; timestamp.year = 2008; timestamp.month = 03; timestamp.day = 18; timestamp.hour = 5; timestamp.minute = 22; timestamp.second = 10; timestamp.fraction = 764576; //****************************** // PREPARE THE STATEMENT. ret = SQLPrepare(stmt,(unsigned char*)"INSERT INTO T1 VALUES(?,?,?,?,?,?,?,?,?,?)",SQL_NTS); checkrc(ret,__LINE__); // BIND PARAMETER FOR ALL THE FIELD ret = SQLBindParameter(stmt,1,SQL_PARAM_INPUT,SQL_C_SLONG,SQL_INTEGER,0,0,&f1,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,2,SQL_PARAM_INPUT,SQL_C_SSHORT,SQL_SMALLINT,0,0,&f2,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,3,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,196,0,(void*)f3,0,&slen); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,4,SQL_PARAM_INPUT,SQL_C_FLOAT,SQL_FLOAT,0,0,&f4,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,5,SQL_PARAM_INPUT,SQL_C_FLOAT,SQL_REAL,0,0,&f5,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,6,SQL_PARAM_INPUT,SQL_C_TYPE_DATE,SQL_TYPE_DATE,196,0,&date,sizeof(date),&slen); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,7,SQL_PARAM_INPUT,SQL_C_TYPE_TIME,SQL_TYPE_TIME,196,0,&time,sizeof(time),&slen); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,8,SQL_PARAM_INPUT,SQL_C_TYPE_TIMESTAMP,SQL_TYPE_TIMESTAMP,196,0,×tamp,sizeof(timestamp),&slen); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,9,SQL_PARAM_INPUT,SQL_C_TINYINT,SQL_TINYINT,0,0,&f9,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,10,SQL_PARAM_INPUT,SQL_C_SBIGINT,SQL_BIGINT,0,0,&f10,0,NULL); checkrc(ret,__LINE__); int i,count=0; // EXECUTE THE STATEMENT for(i=0;i<20;i++) { f1++; f2++; f4++; ret = SQLExecute(stmt); checkrc(ret,__LINE__); ret = SQLTransact(env,dbc,SQL_COMMIT); checkrc(ret,__LINE__); count++; } printf("Total row inserted=%d\n",count); return 0; }
void BatchInsert(SQLHANDLE hdbc, SQLHANDLE hstmt, char *TableName, unsigned int SizeOfBatch, unsigned int NumberRecords) { SQLRETURN rc; char Statement[1000]; SQLCHAR FirstName[DESC_LEN]; SQLCHAR LastName[DESC_LEN]; int EmpID = 10000; SQL_DATE_STRUCT HireDate; int Salary; SQLCHAR Dept[DESC_LEN]; int Exempt; SQLLEN FirstNameInd, LastNameInd, EmpIDInd, HireDateInd, SalaryInd, DeptInd, ExemptInd; SQLUINTEGER i, NumRecords, Loop; strcpy(Statement, "insert into "); strcat(Statement, TableName); strcat(Statement, " (FIRST_NAME, LAST_NAME, EMP_ID, HIRE_DATE, SALARY, DEPT, EXEMPT) "); strcat(Statement, "values (?, ?, ?, ?, ?, ?, ?)"); // Set AUTOCOMMIT off rc = SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_OFF, SQL_IS_UINTEGER); // Bind the parameters in column-wise fashion rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 20, 0, FirstName, DESC_LEN, &FirstNameInd); rc = SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 30, 0, LastName, DESC_LEN, &LastNameInd); rc = SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 6, 0, (SQLPOINTER)&EmpID, sizeof(int), &EmpIDInd); rc = SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_TYPE_DATE, SQL_TYPE_TIMESTAMP, 19, 0, &HireDate, 19, &HireDateInd); rc = SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 9, 0, (SQLPOINTER)&Salary, sizeof(int), &SalaryInd); rc = SQLBindParameter(hstmt, 6, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 4, 0, Dept, DESC_LEN, &DeptInd); rc = SQLBindParameter(hstmt, 7, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 3, 0, (SQLPOINTER)&Exempt, sizeof(int), &ExemptInd); rc = SQLPrepare(hstmt, (unsigned char*)Statement, strlen(Statement)); NumRecords = NumberRecords; i = 0; while (NumRecords > 0) { if (NumRecords < SizeOfBatch) { Loop = NumRecords; } else { Loop = SizeOfBatch; } // Set values for insert for (i = 0; i < Loop; i++) { strcpy((char *)FirstName, "Gordon"); FirstNameInd = strlen(FirstName); strcpy((char *)LastName, "Crenshaw"); LastNameInd = strlen(LastName); EmpID++; EmpIDInd = 0; HireDate.year = 1995; HireDate.month = 9; HireDate.day = 06; HireDateInd = 0; Salary = 1000; SalaryInd = 0; strcpy((char *)Dept, "D101"); DeptInd = strlen(Dept); Exempt = 100; ExemptInd = 0; // Execute the statement rc = SQLExecute(hstmt); switch (rc) { case SQL_SUCCESS: break; case SQL_SUCCESS_WITH_INFO: printf("SQL_SUCCESS_WITH_INFO\n"); displayError(SQL_HANDLE_STMT, hstmt); break; case SQL_NEED_DATA: printf("SQL_NEED_DATA\n"); break; case SQL_STILL_EXECUTING: printf("SQL_STILL_EXECUTING\n"); break; case SQL_ERROR: printf("SQL_ERROR\n"); displayError(SQL_HANDLE_STMT, hstmt); break; case SQL_NO_DATA: printf("SQL_NO_DATA\n"); break; case SQL_INVALID_HANDLE: printf("SQL_INVALID_HANDLE\n"); displayError(SQL_HANDLE_STMT, hstmt); break; } NumRecords--; } // Commit Transaction rc = SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT); } // Set AUTOCOMMIT on rc = SQLSetConnectAttr(hdbc, SQL_ATTR_AUTOCOMMIT, (SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_IS_UINTEGER); }
int main(int argc, char **argv) { SQLRETURN rc; HSTMT hstmt = SQL_NULL_HSTMT; char param1[20] = { 1, 2, 3, 4, 5, 6, 7, 8 }; SQLLEN cbParam1; SQLSMALLINT colcount; SQLSMALLINT dataType; SQLULEN paramSize; SQLSMALLINT decDigits; SQLSMALLINT nullable; 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); } /**** Query with a bytea param ****/ /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id, t FROM byteatab WHERE t = ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); /* bind param */ cbParam1 = 8; rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_BINARY, /* value type */ SQL_BINARY, /* 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); /*** Test SQLBindParameter with SQLExecDirect ***/ printf("\nTesting SQLBindParameter with SQLExecDirect...\n"); /* bind param */ strcpy(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); rc = SQLExecDirect(hstmt, (SQLCHAR *) "SELECT 'foo' UNION ALL SELECT ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLExecDirect failed", hstmt); print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /*** Test SQLDescribeParam ***/ printf("\nTesting SQLDescribeParam...\n"); rc = SQLFreeStmt(hstmt, SQL_RESET_PARAMS); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id, t FROM testtab1 WHERE id = ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); rc = SQLDescribeParam(hstmt, 1, &dataType, ¶mSize, &decDigits, &nullable); CHECK_STMT_RESULT(rc, "SQLDescribeParams failed", hstmt); printf("Param 1: type %s; size %u; dec digits %d; %s\n", datatype_str(dataType), (unsigned int) paramSize, decDigits, nullable_str(nullable)); /* bind param */ strcpy(param1, "3"); 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); /* Clean up */ test_disconnect(); return 0; }
//*********************************************************************** // FETCH ROWS FROM THE TABLE "T1"......select * from T1; int DeleteTest(SQLHANDLE env, SQLHANDLE dbc, SQLHANDLE stmt) { int ret; int f1=10; // f1 field short int f2=20;//f2 field char f3[50]= "jitendra"; float f4 = 2.5; float f5 = 10.50; int f9 = 5; long long f10 = 15000; int result; SQLINTEGER slen=SQL_NTS; char strDate[20]; char strTime[20]; char strTimestamp[30]; SQL_DATE_STRUCT date; date.year=2008; date.month=03; date.day=18; //********************************************** SQL_TIME_STRUCT time; time.hour = 5; time.minute = 22; time.second = 10; //********************************************* SQL_TIMESTAMP_STRUCT timestamp; timestamp.year = 2008; timestamp.month = 03; timestamp.day = 18; timestamp.hour = 5; timestamp.minute = 22; timestamp.second = 10; timestamp.fraction = 764576; int f1temp,f2temp; char f3temp[20]; float f4temp, f5temp; SQL_DATE_STRUCT f6Date; SQL_TIME_STRUCT f7Time; SQL_TIMESTAMP_STRUCT f8Timestamp; int f9temp; long long f10temp; ret = SQLPrepare(stmt,(unsigned char*)"DELETE FROM T1 WHERE F1=? AND F2=? AND F3=? AND F4=? AND F5=? AND F6=? AND F7=? AND F8=? AND F9=? AND F10=?",SQL_NTS); checkrc(ret,__LINE__); //ret = SQLBindParameter(stmt,1,SQL_PARAM_INPUT,SQL_C_SMALL,SQL_SMALL,0,0,) ret = SQLBindParameter(stmt,1,SQL_PARAM_INPUT,SQL_C_SLONG,SQL_INTEGER,0,0,&f1temp,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,2,SQL_PARAM_INPUT,SQL_C_SSHORT,SQL_INTEGER,0,0,&f2temp,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,3,SQL_PARAM_INPUT,SQL_C_CHAR,SQL_CHAR,196,0,(void*)f3temp,0,&slen); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,4,SQL_PARAM_INPUT,SQL_C_FLOAT,SQL_FLOAT,0,0,&f4temp,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,5,SQL_PARAM_INPUT,SQL_C_FLOAT,SQL_REAL,0,0,&f5temp,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,6,SQL_PARAM_INPUT,SQL_C_TYPE_DATE,SQL_TYPE_DATE,196,0,&f6Date,sizeof(f6Date),&slen); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,7,SQL_PARAM_INPUT,SQL_C_TYPE_TIME,SQL_TYPE_TIME,196,0,&f7Time,sizeof(f7Time),&slen); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,8,SQL_PARAM_INPUT,SQL_C_TYPE_TIMESTAMP,SQL_TYPE_TIMESTAMP,196,0,&f8Timestamp,sizeof(f8Timestamp),&slen); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,9,SQL_PARAM_INPUT,SQL_C_TINYINT,SQL_TINYINT,0,0,&f9temp,0,NULL); checkrc(ret,__LINE__); ret = SQLBindParameter(stmt,10,SQL_PARAM_INPUT,SQL_C_SBIGINT,SQL_BIGINT,0,0,&f10temp,0,NULL); checkrc(ret,__LINE__); //******************************************************************************************************* int j, count=0; f6Date=date; f7Time=time; f8Timestamp=timestamp; for(j=0;j<20;j++) { f1temp=f1++; f2temp=f2++; strcpy(f3temp,"jitendra"); f4temp=f4++; f5temp=f5; f9temp=f9; f10temp=f10; ret = SQLExecute(stmt); checkrc(ret,__LINE__); count++; } ret = SQLTransact(env,dbc,SQL_COMMIT); checkrc(ret,__LINE__); printf("Total row deleted=%d\n",count); return 0; }
/* * Test program to run on the connected database */ int ODBC_Test () { SQLTCHAR request[4096]; SQLTCHAR fetchBuffer[1024]; char buf[4096]; size_t displayWidths[MAXCOLS]; size_t displayWidth; short numCols; short colNum; SQLTCHAR colName[50]; SQLSMALLINT colType; SQLULEN colPrecision; SQLLEN colIndicator; SQLSMALLINT colScale; SQLSMALLINT colNullable; unsigned long totalRows; unsigned long totalSets; int i; SQLRETURN sts; while (1) { /* * Ask the user for a dynamic SQL statement */ printf ("\nSQL>"); if (fgets (buf, sizeof (buf), stdin) == NULL) break; #ifndef UNICODE strcpy ((char *) request, (char *) buf); #else strcpy_A2W (request, buf); #endif request[TXTLEN (request) - 1] = TEXTC ('\0'); if (request[0] == TEXTC ('\0')) continue; /* * If the user just types tables, give him a list */ if (!TXTCMP (request, TEXT ("tables"))) { if (SQLTables (hstmt, NULL, 0, NULL, 0, NULL, 0, NULL, 0) != SQL_SUCCESS) { ODBC_Errors ("SQLTables(tables)"); continue; } } /* * If the user just types qualifiers, give him a list */ else if (!TXTCMP (request, TEXT ("qualifiers"))) { if (SQLTables (hstmt, TEXT ("%"), SQL_NTS, TEXT (""), 0, TEXT (""), 0, TEXT (""), 0) != SQL_SUCCESS) { ODBC_Errors ("SQLTables(qualifiers)"); continue; } } /* * If the user just types owners, give him a list */ else if (!TXTCMP (request, TEXT ("owners"))) { if (SQLTables (hstmt, TEXT (""), 0, TEXT ("%"), SQL_NTS, TEXT (""), 0, TEXT (""), 0) != SQL_SUCCESS) { ODBC_Errors ("SQLTables(owners)"); continue; } } /* * If the user just types "types", give him a list */ else if (!TXTCMP (request, TEXT ("types"))) { if (SQLTables (hstmt, TEXT (""), 0, TEXT (""), 0, TEXT (""), 0, TEXT ("%"), SQL_NTS) != SQL_SUCCESS) { ODBC_Errors ("SQLTables(types)"); continue; } } /* * If the user just types "datatypes", give him a list */ else if (!TXTCMP (request, TEXT ("datatypes"))) { if (SQLGetTypeInfo (hstmt, 0) != SQL_SUCCESS) { ODBC_Errors ("SQLGetTypeInfo"); continue; } } else if (!TXTCMP (request, TEXT ("reconnect"))) { if (ODBC_Reconnect()) return -1; continue; } #if defined (unix) else if (!TXTCMP (request, TEXT ("environment"))) { extern char **environ; int i; for (i = 0; environ[i]; i++) fprintf (stderr, "%03d: [%s]\n", i, environ[i]); continue; } #endif else if (!TXTCMP (request, TEXT ("quit")) || !TXTCMP (request, TEXT ("exit"))) break; /* If you want to quit, just say so */ else { /* * Prepare & Execute the statement */ if (SQLPrepare (hstmt, (SQLTCHAR *) request, SQL_NTS) != SQL_SUCCESS) { ODBC_Errors ("SQLPrepare"); continue; } if ((sts = SQLExecute (hstmt)) != SQL_SUCCESS) { ODBC_Errors ("SQLExec"); if (sts != SQL_SUCCESS_WITH_INFO) continue; } } /* * Loop through all the result sets */ totalSets = 1; do { /* * Get the number of result columns for this cursor. * If it is 0, then the statement was probably a select */ if (SQLNumResultCols (hstmt, &numCols) != SQL_SUCCESS) { ODBC_Errors ("SQLNumResultCols"); goto endCursor; } if (numCols == 0) { SQLLEN nrows = 0; SQLRowCount (hstmt, &nrows); printf ("Statement executed. %ld rows affected.\n", nrows > 0 ? (long) nrows : 0L); goto endCursor; } if (numCols > MAXCOLS) { numCols = MAXCOLS; fprintf (stderr, "NOTE: Resultset truncated to %d columns.\n", MAXCOLS); } /* * Get the names for the columns */ putchar ('\n'); for (colNum = 1; colNum <= numCols; colNum++) { /* * Get the name and other type information */ if (SQLDescribeCol (hstmt, colNum, (SQLTCHAR *) colName, NUMTCHAR (colName), NULL, &colType, &colPrecision, &colScale, &colNullable) != SQL_SUCCESS) { ODBC_Errors ("SQLDescribeCol"); goto endCursor; } /* * Calculate the display width for the column */ switch (colType) { case SQL_VARCHAR: case SQL_CHAR: case SQL_WVARCHAR: case SQL_WCHAR: case SQL_GUID: displayWidth = colPrecision; break; case SQL_BINARY: displayWidth = colPrecision * 2; break; case SQL_LONGVARCHAR: case SQL_WLONGVARCHAR: case SQL_LONGVARBINARY: displayWidth = 30; /* show only first 30 */ break; case SQL_BIT: displayWidth = 1; break; case SQL_TINYINT: case SQL_SMALLINT: case SQL_INTEGER: case SQL_BIGINT: displayWidth = colPrecision + 1; /* sign */ break; case SQL_DOUBLE: case SQL_DECIMAL: case SQL_NUMERIC: case SQL_FLOAT: case SQL_REAL: displayWidth = colPrecision + 2; /* sign, comma */ break; #ifdef SQL_TYPE_DATE case SQL_TYPE_DATE: #endif case SQL_DATE: displayWidth = 10; break; #ifdef SQL_TYPE_TIME case SQL_TYPE_TIME: #endif case SQL_TIME: displayWidth = 8; break; #ifdef SQL_TYPE_TIMESTAMP case SQL_TYPE_TIMESTAMP: #endif case SQL_TIMESTAMP: displayWidth = 19; if (colScale > 0) displayWidth = displayWidth + colScale + 1; break; default: displayWidths[colNum - 1] = 0; /* skip other data types */ continue; } if (displayWidth < TXTLEN (colName)) displayWidth = TXTLEN (colName); if (displayWidth > NUMTCHAR (fetchBuffer) - 1) displayWidth = NUMTCHAR (fetchBuffer) - 1; displayWidths[colNum - 1] = displayWidth; /* * Print header field */ #ifdef UNICODE printf ("%-*.*S", displayWidth, displayWidth, colName); #else printf ("%-*.*s", displayWidth, displayWidth, colName); #endif if (colNum < numCols) putchar ('|'); } putchar ('\n'); /* * Print second line */ for (colNum = 1; colNum <= numCols; colNum++) { for (i = 0; i < displayWidths[colNum - 1]; i++) putchar ('-'); if (colNum < numCols) putchar ('+'); } putchar ('\n'); /* * Print all the fields */ totalRows = 0; while (1) { #if (ODBCVER < 0x0300) int sts = SQLFetch (hstmt); #else int sts = SQLFetchScroll (hstmt, SQL_FETCH_NEXT, 1); #endif if (sts == SQL_NO_DATA_FOUND) break; if (sts != SQL_SUCCESS) { ODBC_Errors ("Fetch"); break; } for (colNum = 1; colNum <= numCols; colNum++) { /* * Fetch this column as character */ #ifdef UNICODE sts = SQLGetData (hstmt, colNum, SQL_C_WCHAR, fetchBuffer, NUMTCHAR (fetchBuffer), &colIndicator); #else sts = SQLGetData (hstmt, colNum, SQL_C_CHAR, fetchBuffer, NUMTCHAR (fetchBuffer), &colIndicator); #endif if (sts != SQL_SUCCESS_WITH_INFO && sts != SQL_SUCCESS) { ODBC_Errors ("SQLGetData"); goto endCursor; } /* * Show NULL fields as **** */ if (colIndicator == SQL_NULL_DATA) { for (i = 0; i < displayWidths[colNum - 1]; i++) fetchBuffer[i] = TEXTC ('*'); fetchBuffer[i] = TEXTC ('\0'); } #ifdef UNICODE printf ("%-*.*S", displayWidths[colNum - 1], displayWidths[colNum - 1], fetchBuffer); #else printf ("%-*.*s", displayWidths[colNum - 1], displayWidths[colNum - 1], fetchBuffer); #endif if (colNum < numCols) putchar ('|'); } putchar ('\n'); totalRows++; } printf ("\n result set %lu returned %lu rows.\n\n", totalSets, totalRows); totalSets++; } while ((sts = SQLMoreResults (hstmt)) == SQL_SUCCESS); if (sts == SQL_ERROR) ODBC_Errors ("SQLMoreResults"); endCursor: #if (ODBCVER < 0x0300) SQLFreeStmt (hstmt, SQL_CLOSE); #else SQLCloseCursor (hstmt); #endif } return 0; }
int backsql_count_children( Operation *op, SQLHDBC dbh, struct berval *dn, unsigned long *nchildren ) { backsql_info *bi = (backsql_info *)op->o_bd->be_private; SQLHSTMT sth = SQL_NULL_HSTMT; BACKSQL_ROW_NTS row; RETCODE rc; int res = LDAP_SUCCESS; Debug( LDAP_DEBUG_TRACE, "==>backsql_count_children(): dn=\"%s\"\n", dn->bv_val, 0, 0 ); if ( dn->bv_len > BACKSQL_MAX_DN_LEN ) { Debug( LDAP_DEBUG_TRACE, "backsql_count_children(): DN \"%s\" (%ld bytes) " "exceeds max DN length (%d):\n", dn->bv_val, dn->bv_len, BACKSQL_MAX_DN_LEN ); return LDAP_OTHER; } /* begin TimesTen */ Debug(LDAP_DEBUG_TRACE, "children id query \"%s\"\n", bi->sql_has_children_query, 0, 0); assert( bi->sql_has_children_query != NULL ); rc = backsql_Prepare( dbh, &sth, bi->sql_has_children_query, 0 ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "backsql_count_children(): error preparing SQL:\n%s", bi->sql_has_children_query, 0, 0); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); return LDAP_OTHER; } rc = backsql_BindParamBerVal( sth, 1, SQL_PARAM_INPUT, dn ); if ( rc != SQL_SUCCESS) { /* end TimesTen */ Debug( LDAP_DEBUG_TRACE, "backsql_count_children(): " "error binding dn=\"%s\" parameter:\n", dn->bv_val, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); return LDAP_OTHER; } rc = SQLExecute( sth ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "backsql_count_children(): " "error executing query (\"%s\", \"%s\"):\n", bi->sql_has_children_query, dn->bv_val, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); return LDAP_OTHER; } backsql_BindRowAsStrings_x( sth, &row, op->o_tmpmemctx ); rc = SQLFetch( sth ); if ( BACKSQL_SUCCESS( rc ) ) { char *end; *nchildren = strtol( row.cols[ 0 ], &end, 0 ); if ( end == row.cols[ 0 ] ) { res = LDAP_OTHER; } else { switch ( end[ 0 ] ) { case '\0': break; case '.': { unsigned long ul; /* FIXME: braindead RDBMSes return * a fractional number from COUNT! */ if ( lutil_atoul( &ul, end + 1 ) != 0 || ul != 0 ) { res = LDAP_OTHER; } } break; default: res = LDAP_OTHER; } } } else { res = LDAP_OTHER; } backsql_FreeRow_x( &row, op->o_tmpmemctx ); SQLFreeStmt( sth, SQL_DROP ); Debug( LDAP_DEBUG_TRACE, "<==backsql_count_children(): %lu\n", *nchildren, 0, 0 ); return res; }
bool ODBCConnection::Execute() { LLOG("Execute " << (void *)this << " " << (void *)session << " " << statement); if(session->hstmt == SQL_NULL_HANDLE) return false; session->FlushConnections(); last_insert_table.Clear(); number.Clear(); text.Clear(); time.Clear(); CParser p(statement); if((p.Id("insert") || p.Id("INSERT")) && (p.Id("into") || p.Id("INTO")) && p.IsId()) last_insert_table = p.ReadId(); String query; int pi = 0; const char *s = statement; while(s < statement.End()) if(*s == '\'' || *s == '\"') s = ODBCReadString(s, query); else { if(*s == '?') { if(pi >= param.GetCount()) { session->SetError("Invalid number of parameters", statement); return false; } Value v = param[pi++]; if(v.GetType() == 34) query.Cat(SqlCompile(MSSQL, ~SqlBinary(SqlRaw(v)))); else query.Cat(SqlCompile(MSSQL, ~SqlVal(v))); } else query.Cat(*s); s++; } param.Clear(); if(!IsOk(SQLPrepare(session->hstmt, (SQLCHAR *)~query, query.GetCount()))) return false; /* } else { if(!IsOk(SQLPrepare(session->hstmt, (SQLCHAR *)~statement, statement.GetCount()))) return false; parse = false; bparam = pick(param); param.Clear(); for(int i = 0; i < bparam.GetCount(); i++) { Param& p = bparam[i]; if(!IsOk(SQLBindParameter(session->hstmt, i + 1, SQL_PARAM_INPUT, p.ctype, p.sqltype, p.width, 0, (SQLPOINTER)~p.data, p.data.GetLength(), &p.li))) return false; } } */ SQLSMALLINT ncol; if(!IsOk(SQLExecute(session->hstmt)) || !IsOk(SQLNumResultCols(session->hstmt, &ncol))) { SQLFreeStmt(session->hstmt, SQL_CLOSE); return false; } info.Clear(); string_type.Clear(); for(int i = 1; i <= ncol; i++) { SQLCHAR ColumnName[256]; SQLSMALLINT NameLength; SQLSMALLINT DataType; SQLULEN ColumnSize; SQLSMALLINT DecimalDigits; SQLSMALLINT Nullable; if(!IsOk(SQLDescribeCol(session->hstmt, i, ColumnName, 255, &NameLength, &DataType, &ColumnSize, &DecimalDigits, &Nullable))) return false; string_type.Add(SQL_C_CHAR); SqlColumnInfo& f = info.Add(); f.nullable = Nullable != SQL_NO_NULLS; f.binary = false; f.precision = DecimalDigits; f.scale = 0; f.width = ColumnSize; f.name = (char *)ColumnName; switch(DataType) { case SQL_DECIMAL: case SQL_NUMERIC: case SQL_SMALLINT: case SQL_INTEGER: case SQL_REAL: case SQL_FLOAT: case SQL_DOUBLE: case SQL_BIT: case SQL_TINYINT: f.type = DOUBLE_V; break; case SQL_BIGINT: f.type = INT64_V; break; case SQL_TYPE_DATE: f.type = DATE_V; break; case SQL_TYPE_TIMESTAMP: f.type = TIME_V; break; case SQL_BINARY: case SQL_VARBINARY: case SQL_LONGVARBINARY: f.type = STRING_V; f.binary = true; string_type.Top() = SQL_C_BINARY; break; case SQL_WCHAR: case SQL_WVARCHAR: case SQL_WLONGVARCHAR: f.type = STRING_V; f.binary = true; string_type.Top() = SQL_C_WCHAR; break; default: f.type = STRING_V; break; } } SQLLEN rc; SQLRowCount(session->hstmt, &rc); rowsprocessed = rc; FetchAll(); return true; }
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 void query_test(int prepare, SQLRETURN expected, const char *expected_status) { #define DESC_LEN 51 #define ARRAY_SIZE 10 SQLUINTEGER *ids = XMALLOC_N(SQLUINTEGER,ARRAY_SIZE); typedef SQLCHAR desc_t[DESC_LEN]; desc_t *descs = XMALLOC_N(desc_t, ARRAY_SIZE); SQLLEN *id_lens = XMALLOC_N(SQLLEN,ARRAY_SIZE), *desc_lens = XMALLOC_N(SQLLEN,ARRAY_SIZE); SQLUSMALLINT i, *statuses = XMALLOC_N(SQLUSMALLINT,ARRAY_SIZE); unsigned *num_errors = XMALLOC_N(unsigned, ARRAY_SIZE); SQLULEN processed; RETCODE ret; char status[20]; SQLTCHAR *err = ODBC_GET(sizeof(odbc_err)*sizeof(SQLTCHAR)); SQLTCHAR *state = ODBC_GET(sizeof(odbc_sqlstate)*sizeof(SQLTCHAR)); assert(odbc_stmt != SQL_NULL_HSTMT); odbc_reset_statement(); odbc_command_with_result(odbc_stmt, "drop table #tmp1"); odbc_command("create table #tmp1 (id tinyint, value char(20))"); SQLSetStmtAttr(odbc_stmt, SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, 0); SQLSetStmtAttr(odbc_stmt, SQL_ATTR_PARAMSET_SIZE, (void *) ARRAY_SIZE, 0); SQLSetStmtAttr(odbc_stmt, SQL_ATTR_PARAM_STATUS_PTR, statuses, 0); SQLSetStmtAttr(odbc_stmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &processed, 0); SQLBindParameter(odbc_stmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 5, 0, ids, 0, id_lens); SQLBindParameter(odbc_stmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, DESC_LEN - 1, 0, descs, DESC_LEN, desc_lens); processed = ARRAY_SIZE + 1; for (i = 0; i < ARRAY_SIZE; i++) { statuses[i] = SQL_PARAM_DIAG_UNAVAILABLE; ids[i] = (i + 1) * multiply; sprintf((char *) descs[i], "data %d", i * 7); id_lens[i] = 0; desc_lens[i] = SQL_NTS; num_errors[i] = 0; } multiply = 90; if (!prepare) { ret = SQLExecDirect(odbc_stmt, test_query, SQL_NTS); } else { SQLPrepare(odbc_stmt, test_query, SQL_NTS); ret = SQLExecute(odbc_stmt); } if (processed > ARRAY_SIZE) { char buf[256]; sprintf(buf, "Invalid processed number: %d", (int) processed); ODBC_REPORT_ERROR(buf); } for (i = 1; CHKGetDiagRec(SQL_HANDLE_STMT, odbc_stmt, i, state, NULL, err, sizeof(odbc_err), NULL, "SINo") != SQL_NO_DATA; ++i) { SQLINTEGER row; strcpy(odbc_err, C(err)); strcpy(odbc_sqlstate, C(state)); CHKGetDiagField(SQL_HANDLE_STMT, odbc_stmt, i, SQL_DIAG_ROW_NUMBER, &row, sizeof(row), NULL, "S"); if (row == SQL_ROW_NUMBER_UNKNOWN) continue; if (row < 1 || row > ARRAY_SIZE) { fprintf(stderr, "invalid row %d returned reading error number %d\n", (int) row, i); exit(1); } ++num_errors[row-1]; printf("for row %2d returned '%s' %s\n", (int) row, odbc_sqlstate, odbc_err); } for (i = 0; i < processed; ++i) { int has_diag = 0; switch (statuses[i]) { case SQL_PARAM_SUCCESS_WITH_INFO: has_diag = 1; case SQL_PARAM_SUCCESS: status[i] = 'V'; break; case SQL_PARAM_ERROR: has_diag = 1; status[i] = '!'; break; case SQL_PARAM_UNUSED: status[i] = ' '; break; case SQL_PARAM_DIAG_UNAVAILABLE: status[i] = '?'; break; default: fprintf(stderr, "Invalid status returned %d\n", statuses[i]); exit(1); } if (has_diag) { if (!num_errors[i]) { fprintf(stderr, "Diagnostics not returned for status %d\n", i); failure = 1; } } else { if (num_errors[i]) { fprintf(stderr, "Diagnostics returned for status %d\n", i); failure = 1; } } } status[i] = 0; if (ret != expected || strcmp(expected_status, status) != 0) { fprintf(stderr, "Invalid result: got %d \"%s\" expected %d \"%s\" processed %d\n", ret, status, expected, expected_status, (int) processed); if (ret != SQL_SUCCESS) odbc_read_error(); failure = 1; odbc_reset_statement(); return; } odbc_reset_statement(); }
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; }
PassFail TestSQLFetch(TestInfo *pTestInfo) { TEST_DECLARE; TCHAR Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv; SQLHANDLE hdbc; SQLHANDLE hstmt; SQLUSMALLINT i, j, k, fn, h; SWORD col; TCHAR *CCharOutput1[MAX_NUM1], CCharOutput2[NAME_LEN]; SQLLEN OutputLen1[MAX_NUM1], OutputLen2; SQLSMALLINT CType[] = {SQL_C_TCHAR}; //TCHAR *TestCType[] = // { // "SQL_C_TCHAR","SQL_C_BINARY","SQL_C_SSHORT","SQL_C_USHORT","SQL_C_SHORT","SQL_C_SLONG", // "SQL_C_ULONG","SQL_C_FLOAT","SQL_C_DOUBLE","SQL_C_DATE","SQL_C_TIME","SQL_C_TIMESTAMP" // }; //TCHAR *TestSQLType[] = // { // "SQL_CHAR","SQL_VARCHAR","SQL_DECIMAL","SQL_NUMERIC","SQL_SMALLINT","SQL_INTEGER","SQL_REAL", // "SQL_FLOAT","SQL_DOUBLE","SQL_DATE","SQL_TIME","SQL_TIMESTAMP","SQL_BIGINT", // "SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL","SQL_DECIMAL" // "SQL_LONGVARCHAR","SQL_WCHAR","SQL_WVARCHAR","SQL_WLONGVARCHAR" // }; TCHAR *ExecDirStr[5]; TCHAR *CResults[] = { #ifndef _WM _T("--"),_T("--"),_T("1234.56789"),_T("1234.56789"),_T("1200"),_T("12000"), _T("12345.0"),_T("123450.0"),_T("1234500.0"),_T("1993-07-01"),_T("09:45:30"), _T("1993-08-02 08:44:31.001000"),_T("120000"), _T("1234567890123456789"), _T("1234567890123.456789"), _T("1234567890123456789012345678901234567890"), _T("0.12345678901234567890123456789012345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), _T("1234567890.1234567890123456789012345678901234567890000000000000000000000000"), _T("12345.56789"), _T("1234567890123.56789"), _T("12345678901234567890.0123456789"), #ifdef UNICODE _T("--"),_T("--"),_T("--"),_T("--"),_T("--"),_T("--") #else _T("--"),_T("--"),_T("--"),_T("--") #endif #else _T("--"),_T("--"),_T("1234.56789"),_T("1234.56789"),_T("1200"),_T("12000"), _T("12345.0"),_T("123450.0"),_T("1234500.0"),_T("93/07/01"),_T("09:45:30"), _T("1993-08-02 08:44:31.001000"),_T("120000"), _T("1234567890123456789"), _T("1234567890123.456789"), _T("1234567890123456789012345678901234567890"), _T(".12345678901234567890123456789012345678900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000"), _T("1234567890.1234567890123456789012345678901234567890000000000000000000000000"), _T("12345.56789"), _T("1234567890123.56789"), _T("12345678901234567890.0123456789"), _T("--"),_T("--"),_T("--"),_T("--"),_T("--") #endif }; TCHAR *FetchNStr[5]; struct { SQLULEN AccessParam[2]; SQLULEN TransactParam[2]; } ConnOption = { SQL_MODE_READ_WRITE, SQL_MODE_READ_ONLY, SQL_TXN_READ_COMMITTED, SQL_TXN_READ_UNCOMMITTED }; struct _timeb fetchstarttime; struct _timeb fetchendtime; long AccessTime[2]; //Added for transaction isolation problems TCHAR *iso_level_cqd[] = { _T("control query default isolation_level 'READ_COMMITTED'"), _T("control query default isolation_level 'READ_UNCOMMITTED'"), _T("control query default isolation_level 'REPEATABLE_READ'"), _T("control query default isolation_level 'SERIALIZABLE'"), _T("endloop") }; TCHAR *access_mode[] = { _T("default"), _T("set transaction READ ONLY"), _T("set transaction READ WRITE"), _T("endloop") }; SQLTCHAR *sqlstring0 = (SQLTCHAR*)_T("DROP TABLE YRWK_TY_POS_2"); SQLTCHAR *sqlstring1 = (SQLTCHAR*)_T("CREATE TABLE YRWK_TY_POS_2 ( C1 NUMERIC (9, 2) , C2 NUMERIC (9, 2)) NO PARTITION"); SQLTCHAR *sqlstring2 = (SQLTCHAR*)_T("INSERT INTO YRWK_TY_POS_2 VALUES (119.28, 6)"); SQLTCHAR *sqlstring3 = (SQLTCHAR*)_T("SELECT SUM(C1) + SUM(C2) FROM YRWK_TY_POS_2"); //SQLTCHAR sqlstring0[] = _T("DROP TABLE YRWK_TY_POS_2"); //SQLTCHAR sqlstring1[] = _T("CREATE TABLE YRWK_TY_POS_2 ( C1 NUMERIC (9, 2) , C2 NUMERIC (9, 2)) NO PARTITION"); //SQLTCHAR sqlstring2[] = _T("INSERT INTO YRWK_TY_POS_2 VALUES (119.28, 6)"); //SQLTCHAR sqlstring3[] = _T("SELECT SUM(C1) + SUM(C2) FROM YRWK_TY_POS_2"); //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLFetch"), charset_file); if (var_list == NULL) return FAILED; //print_list(var_list); ExecDirStr[0] = var_mapping(_T("SQLFetch_ExecDirStr_1"), var_list); ExecDirStr[1] = var_mapping(_T("SQLFetch_ExecDirStr_2"), var_list); ExecDirStr[2] = var_mapping(_T("SQLFetch_ExecDirStr_3"), var_list); ExecDirStr[3] = var_mapping(_T("SQLFetch_ExecDirStr_4"), var_list); ExecDirStr[4] = var_mapping(_T("SQLFetch_ExecDirStr_5"), var_list); CResults[0] = var_mapping(_T("SQLFetch_CResults_1"), var_list); CResults[1] = var_mapping(_T("SQLFetch_CResults_2"), var_list); #ifdef UNICODE CResults[21] = var_mapping(_T("SQLFetch_datastr1"), var_list); CResults[22] = var_mapping(_T("SQLFetch_datastr2"), var_list); CResults[23] = var_mapping(_T("SQLFetch_datastr3"), var_list); CResults[24] = var_mapping(_T("SQLFetch_CResults_24"), var_list); CResults[25] = var_mapping(_T("SQLFetch_CResults_25"), var_list); CResults[26] = var_mapping(_T("SQLFetch_CResults_26"), var_list); #else CResults[21] = var_mapping(_T("SQLFetch_CResults_21"), var_list); CResults[22] = var_mapping(_T("SQLFetch_CResults_22"), var_list); CResults[23] = var_mapping(_T("SQLFetch_CResults_23"), var_list); CResults[24] = var_mapping(_T("SQLFetch_CResults_24"), var_list); #endif FetchNStr[0] = var_mapping(_T("SQLFetch_FetchNStr_1"), var_list); FetchNStr[1] = var_mapping(_T("SQLFetch_FetchNStr_2"), var_list); FetchNStr[2] = var_mapping(_T("SQLFetch_FetchNStr_3"), var_list); FetchNStr[3] = var_mapping(_T("SQLFetch_FetchNStr_4"), var_list); FetchNStr[4] = var_mapping(_T("SQLFetch_FetchNStr_5"), var_list); //================================================================================================= LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API =>SQLFetch.\n")); TEST_INIT; TESTCASE_BEGIN("Setup for SQLFetch tests\n"); if(!FullConnect(pTestInfo)) { LogMsg(ERRMSG,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[0],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[1],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[2], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup for (i = 0; i < 1; i++) { // begin of 1st for loop _stprintf(Heading,_T("Test 1.%d: Positive functionality of SQLFetch by doing SQLBindcol\n"),i); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[3], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } for (j=0; j<MAX_NUM1; j++) { CCharOutput1[j] = (TCHAR *)malloc(sizeof(TCHAR)*NAME_LEN); *(CCharOutput1[j])=(TCHAR)'\0'; returncode = SQLBindCol(hstmt,(SWORD)(j+1),CType[i],CCharOutput1[j],NAME_LEN,&OutputLen1[j]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { for (j=0; j<MAX_NUM1; j++) { if (_tcscmp(CCharOutput1[j],CResults[j]) == 0) { LogMsg(NONE,_T("expect: '%s' and actual: '%s' of column %d are matched\n"),CResults[j],CCharOutput1[j],j+1); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '%s' and actual: '%s' of column %d are not match, at line %d\n"), CResults[j],CCharOutput1[j],j+1,__LINE__); } free(CCharOutput1[j]); } } SQLFreeStmt(hstmt,SQL_CLOSE); TESTCASE_END; } // end of 1st for loop //============================================================================================ TESTCASE_BEGIN("Setup for more SQLFetch tests\n"); SQLFreeStmt(hstmt,SQL_DROP); SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[4],SQL_NTS); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[2], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; for (i = 0; i < 1; i++) { _stprintf(Heading,_T("Test 2.%d: Positive functionality of SQLFetch by doing SQLGetData\n"),i); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[3], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { for (j=0; j<MAX_NUM1; j++) { returncode = SQLGetData(hstmt,(SWORD)(j+1),CType[i],CCharOutput2,NAME_LEN,&OutputLen2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetData")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (_tcscmp(CCharOutput2,CResults[j]) == 0) { LogMsg(NONE,_T("expect: '%s' and actual: '%s' of column %d are matched\n"), CResults[j],CCharOutput2,j+1); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '%s' and actual: '%s' of column %d are not match, at line %d\n"),CResults[j],CCharOutput2,j+1,__LINE__); } } } SQLFreeStmt(hstmt,SQL_CLOSE); TESTCASE_END; } //============================================================================================ for (fn = 0; fn < NUM_FETCH_LOOP; fn++) { _stprintf(Heading,_T("Setup for Fetch %d tests\n"),(ROWS_INSERTED*(fn+1))); TESTCASE_BEGINW(Heading); SQLFreeStmt(hstmt,SQL_DROP); SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); SQLSetConnectOption((SQLHANDLE)hdbc,SQL_ACCESS_MODE,SQL_MODE_READ_WRITE); SQLSetConnectOption((SQLHANDLE)hdbc,SQL_TXN_ISOLATION,SQL_TXN_READ_COMMITTED); SQLExecDirect(hstmt,(SQLTCHAR*) FetchNStr[0],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)FetchNStr[1],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } for (i = 0; i < (ROWS_INSERTED*(fn+1)); i++) { returncode = SQLExecDirect(hstmt,(SQLTCHAR*)FetchNStr[2], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } } TESTCASE_END; // end of setup _stprintf(Heading,_T("Test Positive functionality of Fetch %d by doing SQLBindcol\n"),(ROWS_INSERTED*(fn+1))); TESTCASE_BEGINW(Heading); for (k = 0; k < 2; k++) { returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_ACCESS_MODE,ConnOption.AccessParam[k]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnection Access")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } returncode = SQLSetConnectOption((SQLHANDLE)hdbc,SQL_TXN_ISOLATION,ConnOption.TransactParam[k]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetConnection Transact")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } returncode = SQLSetStmtOption(hstmt,SQL_ROWSET_SIZE,1); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLSetStmtOption")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)FetchNStr[3], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLNumResultCols(hstmt, &col); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } for (j = 0; j < col; j++) { CCharOutput1[j] = (TCHAR *)malloc(NAME_LEN); *(CCharOutput1[j])=(TCHAR)'\0'; returncode = SQLBindCol(hstmt,(SWORD)(j+1),SQL_C_TCHAR,CCharOutput1[j],NAME_LEN,&OutputLen1[j]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); TEST_RETURN; } } // end of 2nd for loop returncode = SQL_SUCCESS; _ftime(&fetchstarttime); j = 0; while (returncode == SQL_SUCCESS) { returncode = SQLFetch(hstmt); if((returncode != SQL_SUCCESS) && (j < col)) // need to make sure we haven't fallen off the end of the table { if (returncode == SQL_NO_DATA_FOUND) { if (!FindError(_T("00000"),henv,hdbc,hstmt)) // SQLState should be "00000" when return code is SQL_NO_DATA_FOUND. { TEST_FAILED; //assert(0); LogMsg(NONE,_T("Rows #: %d : array %d suppose to be %d at line %d.\n"),j,k, (ROWS_INSERTED*(fn+1)),__LINE__); LogAllErrors(henv,hdbc,hstmt); } } else { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } } if (returncode == SQL_SUCCESS) j++; } _ftime(&fetchendtime); if (j == (ROWS_INSERTED*(fn+1))) { LogMsg(NONE,_T("Rows inserted Expected: %d and Actual: %d.\n"),(ROWS_INSERTED*(fn+1)),j); } else { TEST_FAILED; LogMsg(ERRMSG,_T("Rows inserted Expected: %d and Actual: %d at line%d.\n"),(ROWS_INSERTED*(fn+1)),j,__LINE__); } AccessTime[k] = (long)(((fetchendtime.time - fetchstarttime.time) * 1000) + (fetchendtime.millitm - fetchstarttime.millitm)); for (j = 0; j < col; j++) { free(CCharOutput1[j]); } // end of 3rd for loop SQLFreeStmt(hstmt,SQL_CLOSE); } /* if (AccessTime[0] >= AccessTime[1]) { LogMsg(NONE,_T("FETCH ONE: %d millisecs and FETCH N: %d millisecs.\n"),AccessTime[0],AccessTime[1]); } else { TEST_FAILED; LogMsg(ERRMSG,_T("FETCH ONE: %d millisecs and FETCH N: %d millisecs.\n"),AccessTime[0],AccessTime[1]); } */ LogMsg(NONE,_T("FETCH ONE: %d millisecs and FETCH N: %d millisecs.\n"),AccessTime[0],AccessTime[1]); TESTCASE_END; SQLSetConnectOption((SQLHANDLE)hdbc,SQL_ACCESS_MODE,SQL_MODE_READ_WRITE); SQLSetConnectOption((SQLHANDLE)hdbc,SQL_TXN_ISOLATION,SQL_TXN_READ_COMMITTED); SQLExecDirect(hstmt,(SQLTCHAR*) FetchNStr[0],SQL_NTS); /* cleanup */ } SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[0],SQL_NTS); /* cleanup */ //===================================================================================================== TESTCASE_BEGIN("Setup for SQLFetch isolation level tests\n"); SQLFreeStmt(hstmt,SQL_DROP); SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[0],SQL_NTS);/*clean up*/ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[1], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[2], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; i = 0; k = 0; while (_tcsicmp(iso_level_cqd[k],_T("endloop")) != 0) { h = 0; while (_tcsicmp(access_mode[h],_T("endloop")) != 0) { if ((_tcsstr(iso_level_cqd[k],_T("READ_UNCOMMITTED")) != NULL && _tcsstr(access_mode[h],_T("READ WRITE")) != NULL) || (_tcsstr(iso_level_cqd[k],_T("REPEATABLE_READ")) != NULL && _tcsstr(access_mode[h],_T("default")) != NULL) || (_tcsstr(iso_level_cqd[k],_T("SERIALIZABLE")) != NULL && _tcsstr(access_mode[h],_T("default")) != NULL)) { h++; continue; } FullDisconnect(pTestInfo); _stprintf(Heading, _T("Setup for SQLFetch with: %s\nAnd access-mode: %s\n"), iso_level_cqd[k], access_mode[h]); TESTCASE_BEGINW(Heading); if(!FullConnect(pTestInfo)) { LogMsg(ERRMSG,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt,(SQLTCHAR*)iso_level_cqd[k],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } if (_tcsicmp(access_mode[h],_T("default")) != 0) { returncode = SQLExecDirect(hstmt,(SQLTCHAR*)access_mode[h],SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } } TESTCASE_END; // end of setup _stprintf(Heading,_T("SQLFetch by doing SQLGetData\n")); TESTCASE_BEGINW(Heading); returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[3], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; //TEST_RETURN; } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } else { for (j=0; j<MAX_NUM1; j++) { returncode = SQLGetData(hstmt,(SWORD)(j+1),CType[i],CCharOutput2,NAME_LEN,&OutputLen2); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLGetData")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } if (_tcscmp(CCharOutput2,CResults[j]) == 0) { LogMsg(NONE,_T("expect: '%s' and actual: '%s' of column %d are matched\n"),CResults[j],CCharOutput2,j+1); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '%s' and actual: '%s' of column %d are not match, at line %d\n"),CResults[j],CCharOutput2,j+1,__LINE__); } } } SQLFreeStmt(hstmt,SQL_CLOSE); TESTCASE_END; h++; } k++; }//End while SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[0],SQL_NTS); /* cleanup */ //============================================================================================ TESTCASE_BEGIN("Testcase for Mode_special_1\n"); returncode = SQLExecDirect(hstmt,sqlstring0,SQL_NTS); returncode = SQLExecDirect(hstmt,sqlstring1,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecDirect(hstmt,sqlstring2,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLPrepare(hstmt,sqlstring3,SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLBindCol(hstmt,1,SQL_C_TCHAR,CCharOutput2,300,NULL); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindCol")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } #ifndef _WM if (_tcscmp(CCharOutput2,_T("125.2")) == 0) { LogMsg(NONE,_T("expect: '125.2' and actual: '%s' are matched\n"),CCharOutput2); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '125.2' and actual: '%s' are not match, at line %d\n"),CCharOutput2,__LINE__); } #else if (_tcscmp(CCharOutput2,"125.28") == 0) { LogMsg(NONE,_T("expect: '125.28' and actual: '%s' are matched\n"),CCharOutput2); } else { TEST_FAILED; LogMsg(ERRMSG,_T("expect: '125.28' and actual: '%s' are not match, at line %d\n"),CCharOutput2,__LINE__); } #endif //============================================================================================ FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => SQLFetch.\n")); free_list(var_list); TEST_RETURN; }
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; }
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; }
__declspec(dllexport) BOOL SoaronModuleFunc(void) { SQLHDBC hdbc; HSTMT hstmt; unsigned int NumOfLinks, LinkID; WSADATA wd; SQLRETURN sqlret; HANDLE hHeap; FTNAddr LinkAddr; wchar_t Ip[256]; lpLinksCheckInfo LinksTable; WSAEVENT * EventsTable; WSANETWORKEVENTS evt; unsigned int i, j; int res; ADDRINFOW *result = NULL; ADDRINFOW hints; wchar_t LogStr[255]; memset(&hints, 0, sizeof(hints)); LinkAddr.point = 0; NumOfLinks = 0; SQLAllocHandle(SQL_HANDLE_DBC, cfg.henv, &hdbc); sqlret = SQLDriverConnectW(hdbc, NULL, cfg.ConnectionString, SQL_NTS, NULL, 0, NULL, SQL_DRIVER_NOPROMPT); if (sqlret != SQL_SUCCESS && sqlret != SQL_SUCCESS_WITH_INFO) { SetEvent(cfg.hExitEvent); return FALSE;//fatal error } SQLAllocHandle(SQL_HANDLE_STMT, hdbc, &hstmt); AddLogEntry(L"Checking binkp links alive"); //get links info SQLExecDirectW(hstmt, L"update Links set DialOut=0 where datediff(minute,LastSessionTime,GetDate())>40 and LinkType=1", SQL_NTS); sqlret = SQLExecDirectW(hstmt, L"select count(*) from Links where dialout=0 and passivelink=0 and LinkType=1 and isnull(ip,'')<>''", SQL_NTS); if ((sqlret == SQL_SUCCESS) || (sqlret = SQL_SUCCESS_WITH_INFO)) { sqlret = SQLFetch(hstmt); if ((sqlret == SQL_SUCCESS) || (sqlret = SQL_SUCCESS_WITH_INFO)) { SQLGetData(hstmt, 1, SQL_C_ULONG, &NumOfLinks, 0, NULL); } } SQLCloseCursor(hstmt); if (NumOfLinks == 0) goto exit; hHeap = HeapCreate(HEAP_NO_SERIALIZE, 8192, 0); LinksTable = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, NumOfLinks*sizeof(LinksCheckInfo)); EventsTable = HeapAlloc(hHeap, HEAP_ZERO_MEMORY, sizeof(WSAEVENT)*NumOfLinks); i = 0; hints.ai_family = AF_INET; hints.ai_socktype = SOCK_STREAM; hints.ai_protocol = IPPROTO_TCP; WSAStartup(MAKEWORD(2, 2), &wd); sqlret = SQLExecDirectW(hstmt, L"select LinkID,Zone,Net,Node, Ip from Links where dialout=0 and passivelink=0 and LinkType=1 and isnull(ip,'')<>''", SQL_NTS); if ((sqlret == SQL_SUCCESS) || (sqlret = SQL_SUCCESS_WITH_INFO)) { SQLBindCol(hstmt, 1, SQL_C_ULONG, &LinkID, 0, NULL); SQLBindCol(hstmt, 2, SQL_C_USHORT, &(LinkAddr.zone), 0, NULL); SQLBindCol(hstmt, 3, SQL_C_USHORT, &(LinkAddr.net), 0, NULL); SQLBindCol(hstmt, 4, SQL_C_USHORT, &(LinkAddr.node), 0, NULL); SQLBindCol(hstmt, 5, SQL_C_WCHAR, Ip, 512, NULL); sqlret = SQLFetch(hstmt); while ((sqlret == SQL_SUCCESS) || (sqlret == SQL_SUCCESS_WITH_INFO)) { // res = GetAddrInfoW(Ip, L"24554", &hints, &result); if (res == 0) { memcpy(&(LinksTable[i].sa), result->ai_addr, sizeof(struct sockaddr_in)); // printf("%u %u %S %u.%u.%u.%u\n", i,LinkID, Ip, LinksTable[i].sa.sin_addr.S_un.S_un_b.s_b1, LinksTable[i].sa.sin_addr.S_un.S_un_b.s_b2, LinksTable[i].sa.sin_addr.S_un.S_un_b.s_b3, LinksTable[i].sa.sin_addr.S_un.S_un_b.s_b4); LinksTable[i].LinkID = LinkID; LinksTable[i].LinkAddr.FullAddr = LinkAddr.FullAddr; LinksTable[i].s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); EventsTable[i] = WSACreateEvent(); WSAEventSelect(LinksTable[i].s, EventsTable[i], FD_CONNECT); FreeAddrInfoW(result); ++i; } else { wsprintfW(LogStr,L"%u:%u/%u: Ip address %s cannot be resolved", LinkAddr.zone, LinkAddr.net, LinkAddr.node,Ip); AddLogEntry(LogStr); } sqlret = SQLFetch(hstmt); } } SQLCloseCursor(hstmt); SQLFreeStmt(hstmt, SQL_UNBIND); NumOfLinks = i; for (i = 0; i < NumOfLinks; i++) { connect(LinksTable[i].s, (struct sockaddr *)&(LinksTable[i].sa), sizeof(struct sockaddr_in)); } j = 0; SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &LinkID, 0, NULL); SQLPrepareW(hstmt, L"Update Links set DialOut=1 where LinkID=?", SQL_NTS); while (j < NumOfLinks) { res = WSAWaitForMultipleEvents(NumOfLinks, EventsTable, FALSE, WSA_INFINITE, FALSE); WSAEnumNetworkEvents(LinksTable[res].s, EventsTable[res], &evt); shutdown(LinksTable[res].s, SD_BOTH); closesocket(LinksTable[res].s); if (evt.iErrorCode[FD_CONNECT_BIT] == 0) { wsprintfW(LogStr, L"%u:%u/%u: OK", LinksTable[res].LinkAddr.zone, LinksTable[res].LinkAddr.net, LinksTable[res].LinkAddr.node); LinkID = LinksTable[res].LinkID; SQLExecute(hstmt); } else { switch (evt.iErrorCode[FD_CONNECT_BIT]) { case WSAECONNREFUSED: wsprintfW(LogStr, L"%u:%u/%u: Connection refused", LinksTable[res].LinkAddr.zone, LinksTable[res].LinkAddr.net, LinksTable[res].LinkAddr.node); break; case WSAETIMEDOUT: wsprintfW(LogStr, L"%u:%u/%u: Connection timed out", LinksTable[res].LinkAddr.zone, LinksTable[res].LinkAddr.net, LinksTable[res].LinkAddr.node); break; default:wsprintfW(LogStr, L"%u:%u/%u: Unknown connection error", LinksTable[res].LinkAddr.zone, LinksTable[res].LinkAddr.net, LinksTable[res].LinkAddr.node); } } AddLogEntry(LogStr); ++j; } // for (j = 0; j < NumOfLinks; j++) { WSACloseEvent(EventsTable[j]); } SQLFreeStmt(hstmt, SQL_RESET_PARAMS); // WSACleanup(); HeapDestroy(hHeap); exit: SQLFreeHandle(SQL_HANDLE_STMT, hstmt); SQLDisconnect(hdbc); SQLFreeHandle(SQL_HANDLE_DBC, hdbc); AddLogEntry(L"Links alive check done"); SetEvent(cfg.hLinksUpdateEvent); return TRUE; }
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; }
//************************************************************************* 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=localhost;PORT=5678;", (SQLSMALLINT) strlen ("DSN=mycsql;MODE=csql;SERVER=localhost;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; }
static int backsql_delete_int( Operation *op, SlapReply *rs, SQLHDBC dbh, SQLHSTMT *sthp, backsql_entryID *eid, Entry **ep ) { backsql_info *bi = (backsql_info*)op->o_bd->be_private; SQLHSTMT sth = SQL_NULL_HSTMT; RETCODE rc; int prc = LDAP_SUCCESS; /* first parameter no */ SQLUSMALLINT pno = 0; sth = *sthp; /* avl_apply ... */ rs->sr_err = backsql_delete_all_attrs( op, rs, dbh, eid ); if ( rs->sr_err != LDAP_SUCCESS ) { goto done; } rc = backsql_Prepare( dbh, &sth, eid->eid_oc->bom_delete_proc, 0 ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "error preparing delete query\n", 0, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); rs->sr_err = LDAP_OTHER; rs->sr_text = "SQL-backend error"; *ep = NULL; goto done; } if ( BACKSQL_IS_DEL( eid->eid_oc->bom_expect_return ) ) { pno = 1; rc = backsql_BindParamInt( sth, 1, SQL_PARAM_OUTPUT, &prc ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "error binding output parameter for objectClass %s\n", eid->eid_oc->bom_oc->soc_cname.bv_val, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); rs->sr_text = "SQL-backend error"; rs->sr_err = LDAP_OTHER; *ep = NULL; goto done; } } rc = backsql_BindParamID( sth, pno + 1, SQL_PARAM_INPUT, &eid->eid_keyval ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "error binding keyval parameter for objectClass %s\n", eid->eid_oc->bom_oc->soc_cname.bv_val, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); rs->sr_text = "SQL-backend error"; rs->sr_err = LDAP_OTHER; *ep = NULL; goto done; } rc = SQLExecute( sth ); if ( rc == SQL_SUCCESS && prc == LDAP_SUCCESS ) { rs->sr_err = LDAP_SUCCESS; } else { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "delete_proc execution failed (rc=%d, prc=%d)\n", rc, prc, 0 ); if ( prc != LDAP_SUCCESS ) { /* SQL procedure executed fine * but returned an error */ rs->sr_err = BACKSQL_SANITIZE_ERROR( prc ); } else { backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); rs->sr_err = LDAP_OTHER; } SQLFreeStmt( sth, SQL_DROP ); goto done; } SQLFreeStmt( sth, SQL_DROP ); /* delete "auxiliary" objectClasses, if any... */ rc = backsql_Prepare( dbh, &sth, bi->sql_delobjclasses_stmt, 0 ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "error preparing ldap_entry_objclasses delete query\n", 0, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); rs->sr_err = LDAP_OTHER; rs->sr_text = "SQL-backend error"; *ep = NULL; goto done; } rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &eid->eid_id ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "error binding auxiliary objectClasses " "entry ID parameter for objectClass %s\n", eid->eid_oc->bom_oc->soc_cname.bv_val, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); rs->sr_text = "SQL-backend error"; rs->sr_err = LDAP_OTHER; *ep = NULL; goto done; } rc = SQLExecute( sth ); switch ( rc ) { case SQL_NO_DATA: /* apparently there were no "auxiliary" objectClasses * for this entry... */ case SQL_SUCCESS: break; default: Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "failed to delete record from ldap_entry_objclasses\n", 0, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); rs->sr_err = LDAP_OTHER; rs->sr_text = "SQL-backend error"; *ep = NULL; goto done; } SQLFreeStmt( sth, SQL_DROP ); /* delete entry... */ rc = backsql_Prepare( dbh, &sth, bi->sql_delentry_stmt, 0 ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "error preparing ldap_entries delete query\n", 0, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); rs->sr_err = LDAP_OTHER; rs->sr_text = "SQL-backend error"; *ep = NULL; goto done; } rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &eid->eid_id ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "error binding entry ID parameter " "for objectClass %s\n", eid->eid_oc->bom_oc->soc_cname.bv_val, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); rs->sr_text = "SQL-backend error"; rs->sr_err = LDAP_OTHER; *ep = NULL; goto done; } rc = SQLExecute( sth ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_delete(): " "failed to delete record from ldap_entries\n", 0, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); rs->sr_err = LDAP_OTHER; rs->sr_text = "SQL-backend error"; *ep = NULL; goto done; } SQLFreeStmt( sth, SQL_DROP ); rs->sr_err = LDAP_SUCCESS; *ep = NULL; done:; *sthp = sth; return rs->sr_err; }
/* * NOTE: the dn must be normalized */ int backsql_dn2id( Operation *op, SlapReply *rs, SQLHDBC dbh, struct berval *ndn, backsql_entryID *id, int matched, int muck ) { backsql_info *bi = op->o_bd->be_private; SQLHSTMT sth = SQL_NULL_HSTMT; BACKSQL_ROW_NTS row = { 0 }; RETCODE rc; int res; struct berval realndn = BER_BVNULL; /* TimesTen */ char upperdn[ BACKSQL_MAX_DN_LEN + 1 ]; struct berval tbbDN; int i, j; /* * NOTE: id can be NULL; in this case, the function * simply checks whether the DN can be successfully * turned into an ID, returning LDAP_SUCCESS for * positive cases, or the most appropriate error */ Debug( LDAP_DEBUG_TRACE, "==>backsql_dn2id(\"%s\")%s%s\n", ndn->bv_val, id == NULL ? " (no ID expected)" : "", matched ? " matched expected" : "" ); if ( id ) { /* NOTE: trap inconsistencies */ assert( BER_BVISNULL( &id->eid_ndn ) ); } if ( ndn->bv_len > BACKSQL_MAX_DN_LEN ) { Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): DN length=%ld " "exceeds max DN length %d:\n", ndn->bv_val, ndn->bv_len, BACKSQL_MAX_DN_LEN ); return LDAP_OTHER; } /* return baseObject if available and matches */ /* FIXME: if ndn is already mucked, we cannot check this */ if ( bi->sql_baseObject != NULL && dn_match( ndn, &bi->sql_baseObject->e_nname ) ) { if ( id != NULL ) { #ifdef BACKSQL_ARBITRARY_KEY ber_dupbv_x( &id->eid_id, &backsql_baseObject_bv, op->o_tmpmemctx ); ber_dupbv_x( &id->eid_keyval, &backsql_baseObject_bv, op->o_tmpmemctx ); #else /* ! BACKSQL_ARBITRARY_KEY */ id->eid_id = BACKSQL_BASEOBJECT_ID; id->eid_keyval = BACKSQL_BASEOBJECT_KEYVAL; #endif /* ! BACKSQL_ARBITRARY_KEY */ id->eid_oc_id = BACKSQL_BASEOBJECT_OC; ber_dupbv_x( &id->eid_ndn, &bi->sql_baseObject->e_nname, op->o_tmpmemctx ); ber_dupbv_x( &id->eid_dn, &bi->sql_baseObject->e_name, op->o_tmpmemctx ); id->eid_next = NULL; } return LDAP_SUCCESS; } /* begin TimesTen */ Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): id_query \"%s\"\n", ndn->bv_val, bi->sql_id_query, 0 ); assert( bi->sql_id_query != NULL ); rc = backsql_Prepare( dbh, &sth, bi->sql_id_query, 0 ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): " "error preparing SQL:\n %s", ndn->bv_val, bi->sql_id_query, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); res = LDAP_OTHER; goto done; } realndn = *ndn; if ( muck ) { if ( backsql_api_dn2odbc( op, rs, &realndn ) ) { Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): " "backsql_api_dn2odbc(\"%s\") failed\n", ndn->bv_val, realndn.bv_val, 0 ); res = LDAP_OTHER; goto done; } } if ( BACKSQL_HAS_LDAPINFO_DN_RU( bi ) ) { /* * Prepare an upper cased, byte reversed version * that can be searched using indexes */ for ( i = 0, j = realndn.bv_len - 1; realndn.bv_val[ i ]; i++, j--) { upperdn[ i ] = realndn.bv_val[ j ]; } upperdn[ i ] = '\0'; ldap_pvt_str2upper( upperdn ); Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): " "upperdn=\"%s\"\n", ndn->bv_val, upperdn, 0 ); ber_str2bv( upperdn, 0, 0, &tbbDN ); } else { if ( BACKSQL_USE_REVERSE_DN( bi ) ) { AC_MEMCPY( upperdn, realndn.bv_val, realndn.bv_len + 1 ); ldap_pvt_str2upper( upperdn ); Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): " "upperdn=\"%s\"\n", ndn->bv_val, upperdn, 0 ); ber_str2bv( upperdn, 0, 0, &tbbDN ); } else { tbbDN = realndn; } } rc = backsql_BindParamBerVal( sth, 1, SQL_PARAM_INPUT, &tbbDN ); if ( rc != SQL_SUCCESS) { /* end TimesTen */ Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): " "error binding dn=\"%s\" parameter:\n", ndn->bv_val, tbbDN.bv_val, 0 ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); res = LDAP_OTHER; goto done; } rc = SQLExecute( sth ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): " "error executing query (\"%s\", \"%s\"):\n", ndn->bv_val, bi->sql_id_query, tbbDN.bv_val ); backsql_PrintErrors( bi->sql_db_env, dbh, sth, rc ); res = LDAP_OTHER; goto done; } backsql_BindRowAsStrings_x( sth, &row, op->o_tmpmemctx ); rc = SQLFetch( sth ); if ( BACKSQL_SUCCESS( rc ) ) { char buf[ SLAP_TEXT_BUFLEN ]; #ifdef LDAP_DEBUG snprintf( buf, sizeof(buf), "id=%s keyval=%s oc_id=%s dn=%s", row.cols[ 0 ], row.cols[ 1 ], row.cols[ 2 ], row.cols[ 3 ] ); Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): %s\n", ndn->bv_val, buf, 0 ); #endif /* LDAP_DEBUG */ res = LDAP_SUCCESS; if ( id != NULL ) { struct berval dn; id->eid_next = NULL; #ifdef BACKSQL_ARBITRARY_KEY ber_str2bv_x( row.cols[ 0 ], 0, 1, &id->eid_id, op->o_tmpmemctx ); ber_str2bv_x( row.cols[ 1 ], 0, 1, &id->eid_keyval, op->o_tmpmemctx ); #else /* ! BACKSQL_ARBITRARY_KEY */ if ( lutil_atoulx( &id->eid_id, row.cols[ 0 ], 0 ) != 0 ) { res = LDAP_OTHER; goto done; } if ( lutil_atoulx( &id->eid_keyval, row.cols[ 1 ], 0 ) != 0 ) { res = LDAP_OTHER; goto done; } #endif /* ! BACKSQL_ARBITRARY_KEY */ if ( lutil_atoulx( &id->eid_oc_id, row.cols[ 2 ], 0 ) != 0 ) { res = LDAP_OTHER; goto done; } ber_str2bv( row.cols[ 3 ], 0, 0, &dn ); if ( backsql_api_odbc2dn( op, rs, &dn ) ) { res = LDAP_OTHER; goto done; } res = dnPrettyNormal( NULL, &dn, &id->eid_dn, &id->eid_ndn, op->o_tmpmemctx ); if ( res != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, " backsql_dn2id(\"%s\"): " "dnPrettyNormal failed (%d: %s)\n", realndn.bv_val, res, ldap_err2string( res ) ); /* cleanup... */ (void)backsql_free_entryID( id, 0, op->o_tmpmemctx ); } if ( dn.bv_val != row.cols[ 3 ] ) { free( dn.bv_val ); } } } else { res = LDAP_NO_SUCH_OBJECT; if ( matched ) { struct berval pdn = *ndn; /* * Look for matched */ rs->sr_matched = NULL; while ( !be_issuffix( op->o_bd, &pdn ) ) { char *matchedDN = NULL; dnParent( &pdn, &pdn ); /* * Empty DN ("") defaults to LDAP_SUCCESS */ rs->sr_err = backsql_dn2id( op, rs, dbh, &pdn, id, 0, 1 ); switch ( rs->sr_err ) { case LDAP_NO_SUCH_OBJECT: /* try another one */ break; case LDAP_SUCCESS: matchedDN = pdn.bv_val; /* fail over to next case */ default: rs->sr_err = LDAP_NO_SUCH_OBJECT; rs->sr_matched = matchedDN; goto done; } } } } done:; backsql_FreeRow_x( &row, op->o_tmpmemctx ); Debug( LDAP_DEBUG_TRACE, "<==backsql_dn2id(\"%s\"): err=%d\n", ndn->bv_val, res, 0 ); if ( sth != SQL_NULL_HSTMT ) { SQLFreeStmt( sth, SQL_DROP ); } if ( !BER_BVISNULL( &realndn ) && realndn.bv_val != ndn->bv_val ) { ch_free( realndn.bv_val ); } return res; }
int main(int argc, char *argv[]) { LOGINREC *login; SQLHENV hEnv = 0; SQLHDBC hDbc = 0; SQLRETURN erc; const char *sql; setlocale(LC_ALL, ""); memset(&options, 0, sizeof(options)); options.headers = stderr; login = get_login(argc, argv, &options); /* get command-line parameters and call dblogin() */ assert(login != NULL); /* * Override stdin, stdout, and stderr, as required */ if (options.input_filename) { if (freopen(options.input_filename, "r", stdin) == NULL) { fprintf(stderr, "%s: unable to open %s: %s\n", options.appname, options.input_filename, strerror(errno)); exit(1); } } if (options.output_filename) { if (freopen(options.output_filename, "w", stdout) == NULL) { fprintf(stderr, "%s: unable to open %s: %s\n", options.appname, options.output_filename, strerror(errno)); exit(1); } } if (options.error_filename) { if (freopen(options.error_filename, "w", stderr) == NULL) { fprintf(stderr, "%s: unable to open %s: %s\n", options.appname, options.error_filename, strerror(errno)); exit(1); } } if (options.fverbose) { options.verbose = stderr; } else { static const char null_device[] = "/dev/null"; options.verbose = fopen(null_device, "w"); if (options.verbose == NULL) { fprintf(stderr, "%s:%d unable to open %s for verbose operation: %s\n", options.appname, __LINE__, null_device, strerror(errno)); exit(1); } } fprintf(options.verbose, "%s:%d: Verbose operation enabled\n", options.appname, __LINE__); /* * Connect to the server */ if ((erc = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &hEnv)) != SQL_SUCCESS) { odbc_herror(SQL_HANDLE_ENV, hEnv, erc, "SQLAllocHandle", "failed to allocate an environment"); exit(EXIT_FAILURE); } assert(hEnv); if ((erc = SQLSetEnvAttr(hEnv, SQL_ATTR_ODBC_VERSION, (SQLPOINTER)options.odbc_version, SQL_IS_UINTEGER)) != SQL_SUCCESS) { odbc_herror(SQL_HANDLE_DBC, hDbc, erc, "SQLSetEnvAttr", "failed to set SQL_OV_ODBC3"); exit(EXIT_FAILURE); } if ((erc = SQLAllocHandle(SQL_HANDLE_DBC, hEnv, &hDbc)) != SQL_SUCCESS) { odbc_herror(SQL_HANDLE_DBC, hDbc, erc, "SQLAllocHandle", "failed to allocate a connection"); exit(EXIT_FAILURE); } assert(hDbc); if ((erc = SQLConnect(hDbc, (SQLCHAR *) options.servername, SQL_NTS, (SQLCHAR *) login->username, SQL_NTS, (SQLCHAR *) login->password, SQL_NTS)) != SQL_SUCCESS) { odbc_herror(SQL_HANDLE_DBC, hDbc, erc, "SQLConnect", "failed"); exit(EXIT_FAILURE); } #if 0 /* Switch to the specified database, if any */ if (options.database) dbuse(dbproc, options.database); #endif /* * Read the queries and write the results */ while ((sql = next_query()) != NULL ) { SQLHSTMT hStmt; if ((erc = SQLAllocHandle(SQL_HANDLE_STMT, hDbc, &hStmt)) != SQL_SUCCESS) { odbc_perror(hStmt, erc, "SQLAllocHandle", "failed to allocate a statement handle"); exit(EXIT_FAILURE); } /* "Prepare" the query and send it to the server */ if ((erc = SQLPrepare(hStmt, (SQLCHAR *) sql, SQL_NTS)) != SQL_SUCCESS) { odbc_perror(hStmt, erc, "SQLPrepare", "failed"); exit(EXIT_FAILURE); } if((erc = SQLExecute(hStmt)) != SQL_SUCCESS) { switch(erc) { case SQL_NEED_DATA: goto FreeStatement; case SQL_SUCCESS_WITH_INFO: if (0 != print_error_message(SQL_HANDLE_STMT, hStmt)) { fprintf(stderr, "SQLExecute: continuing...\n"); } break; default: odbc_perror(hStmt, erc, "SQLExecute", "failed"); exit(EXIT_FAILURE); } } /* Write the output */ print_results(hStmt); FreeStatement: if ((erc = SQLFreeHandle(SQL_HANDLE_STMT, hStmt)) != SQL_SUCCESS) { odbc_perror(hStmt, erc, "SQLFreeHandle", "failed"); exit(EXIT_FAILURE); } } SQLDisconnect(hDbc); SQLFreeHandle(SQL_HANDLE_DBC, hDbc); SQLFreeHandle(SQL_HANDLE_ENV, hEnv); return 0; }
static int backsql_get_attr_vals( void *v_at, void *v_bsi ) { backsql_at_map_rec *at = v_at; backsql_srch_info *bsi = v_bsi; backsql_info *bi = (backsql_info *)bsi->bsi_op->o_bd->be_private; RETCODE rc; SQLHSTMT sth = SQL_NULL_HSTMT; BACKSQL_ROW_NTS row; unsigned long i, k = 0, oldcount = 0, res = 0; #ifdef BACKSQL_COUNTQUERY unsigned count, j, append = 0; SQLLEN countsize = sizeof( count ); Attribute *attr = NULL; slap_mr_normalize_func *normfunc = NULL; #endif /* BACKSQL_COUNTQUERY */ #ifdef BACKSQL_PRETTY_VALIDATE slap_syntax_validate_func *validate = NULL; slap_syntax_transform_func *pretty = NULL; #endif /* BACKSQL_PRETTY_VALIDATE */ assert( at != NULL ); assert( bsi != NULL ); #ifdef BACKSQL_ARBITRARY_KEY Debug( LDAP_DEBUG_TRACE, "==>backsql_get_attr_vals(): " "oc=\"%s\" attr=\"%s\" keyval=%s\n", BACKSQL_OC_NAME( bsi->bsi_oc ), at->bam_ad->ad_cname.bv_val, bsi->bsi_c_eid->eid_keyval.bv_val ); #else /* ! BACKSQL_ARBITRARY_KEY */ Debug( LDAP_DEBUG_TRACE, "==>backsql_get_attr_vals(): " "oc=\"%s\" attr=\"%s\" keyval=%ld\n", BACKSQL_OC_NAME( bsi->bsi_oc ), at->bam_ad->ad_cname.bv_val, bsi->bsi_c_eid->eid_keyval ); #endif /* ! BACKSQL_ARBITRARY_KEY */ #ifdef BACKSQL_PRETTY_VALIDATE validate = at->bam_true_ad->ad_type->sat_syntax->ssyn_validate; pretty = at->bam_true_ad->ad_type->sat_syntax->ssyn_pretty; if ( validate == NULL && pretty == NULL ) { return 1; } #endif /* BACKSQL_PRETTY_VALIDATE */ #ifdef BACKSQL_COUNTQUERY if ( at->bam_true_ad->ad_type->sat_equality ) { normfunc = at->bam_true_ad->ad_type->sat_equality->smr_normalize; } /* Count how many rows will be returned. This avoids memory * fragmentation that can result from loading the values in * one by one and using realloc() */ rc = backsql_Prepare( bsi->bsi_dbh, &sth, at->bam_countquery, 0 ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "error preparing count query: %s\n", at->bam_countquery, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc ); return 1; } rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &bsi->bsi_c_eid->eid_keyval ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "error binding key value parameter\n", 0, 0, 0 ); SQLFreeStmt( sth, SQL_DROP ); return 1; } rc = SQLExecute( sth ); if ( ! BACKSQL_SUCCESS( rc ) ) { Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "error executing attribute count query '%s'\n", at->bam_countquery, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); return 1; } SQLBindCol( sth, (SQLUSMALLINT)1, SQL_C_LONG, (SQLPOINTER)&count, (SQLINTEGER)sizeof( count ), &countsize ); rc = SQLFetch( sth ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "error fetch results of count query: %s\n", at->bam_countquery, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); return 1; } Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "number of values in query: %u\n", count, 0, 0 ); SQLFreeStmt( sth, SQL_DROP ); if ( count == 0 ) { return 1; } attr = attr_find( bsi->bsi_e->e_attrs, at->bam_true_ad ); if ( attr != NULL ) { BerVarray tmp; if ( attr->a_vals != NULL ) { oldcount = attr->a_numvals; } tmp = ch_realloc( attr->a_vals, ( oldcount + count + 1 ) * sizeof( struct berval ) ); if ( tmp == NULL ) { return 1; } attr->a_vals = tmp; memset( &attr->a_vals[ oldcount ], 0, ( count + 1 ) * sizeof( struct berval ) ); if ( normfunc ) { tmp = ch_realloc( attr->a_nvals, ( oldcount + count + 1 ) * sizeof( struct berval ) ); if ( tmp == NULL ) { return 1; } attr->a_nvals = tmp; memset( &attr->a_nvals[ oldcount ], 0, ( count + 1 ) * sizeof( struct berval ) ); } else { attr->a_nvals = attr->a_vals; } attr->a_numvals += count; } else { append = 1; /* Make space for the array of values */ attr = attr_alloc( at->bam_true_ad ); attr->a_numvals = count; attr->a_vals = ch_calloc( count + 1, sizeof( struct berval ) ); if ( attr->a_vals == NULL ) { Debug( LDAP_DEBUG_TRACE, "Out of memory!\n", 0,0,0 ); ch_free( attr ); return 1; } if ( normfunc ) { attr->a_nvals = ch_calloc( count + 1, sizeof( struct berval ) ); if ( attr->a_nvals == NULL ) { ch_free( attr->a_vals ); ch_free( attr ); return 1; } } else { attr->a_nvals = attr->a_vals; } } #endif /* BACKSQL_COUNTQUERY */ rc = backsql_Prepare( bsi->bsi_dbh, &sth, at->bam_query, 0 ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "error preparing query: %s\n", at->bam_query, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc ); #ifdef BACKSQL_COUNTQUERY if ( append ) { attr_free( attr ); } #endif /* BACKSQL_COUNTQUERY */ return 1; } rc = backsql_BindParamID( sth, 1, SQL_PARAM_INPUT, &bsi->bsi_c_eid->eid_keyval ); if ( rc != SQL_SUCCESS ) { Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "error binding key value parameter\n", 0, 0, 0 ); #ifdef BACKSQL_COUNTQUERY if ( append ) { attr_free( attr ); } #endif /* BACKSQL_COUNTQUERY */ return 1; } #ifdef BACKSQL_TRACE #ifdef BACKSQL_ARBITRARY_KEY Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "query=\"%s\" keyval=%s\n", at->bam_query, bsi->bsi_c_eid->eid_keyval.bv_val, 0 ); #else /* !BACKSQL_ARBITRARY_KEY */ Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "query=\"%s\" keyval=%d\n", at->bam_query, bsi->bsi_c_eid->eid_keyval, 0 ); #endif /* ! BACKSQL_ARBITRARY_KEY */ #endif /* BACKSQL_TRACE */ rc = SQLExecute( sth ); if ( ! BACKSQL_SUCCESS( rc ) ) { Debug( LDAP_DEBUG_TRACE, "backsql_get_attr_vals(): " "error executing attribute query \"%s\"\n", at->bam_query, 0, 0 ); backsql_PrintErrors( bi->sql_db_env, bsi->bsi_dbh, sth, rc ); SQLFreeStmt( sth, SQL_DROP ); #ifdef BACKSQL_COUNTQUERY if ( append ) { attr_free( attr ); } #endif /* BACKSQL_COUNTQUERY */ return 1; } backsql_BindRowAsStrings_x( sth, &row, bsi->bsi_op->o_tmpmemctx ); #ifdef BACKSQL_COUNTQUERY j = oldcount; #endif /* BACKSQL_COUNTQUERY */ for ( rc = SQLFetch( sth ), k = 0; BACKSQL_SUCCESS( rc ); rc = SQLFetch( sth ), k++ ) { for ( i = 0; i < (unsigned long)row.ncols; i++ ) { if ( row.value_len[ i ] > 0 ) { struct berval bv; int retval; #ifdef BACKSQL_TRACE AttributeDescription *ad = NULL; const char *text; retval = slap_bv2ad( &row.col_names[ i ], &ad, &text ); if ( retval != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_ANY, "==>backsql_get_attr_vals(\"%s\"): " "unable to find AttributeDescription %s " "in schema (%d)\n", bsi->bsi_e->e_name.bv_val, row.col_names[ i ].bv_val, retval ); res = 1; goto done; } if ( ad != at->bam_ad ) { Debug( LDAP_DEBUG_ANY, "==>backsql_get_attr_vals(\"%s\"): " "column name %s differs from " "AttributeDescription %s\n", bsi->bsi_e->e_name.bv_val, ad->ad_cname.bv_val, at->bam_ad->ad_cname.bv_val ); res = 1; goto done; } #endif /* BACKSQL_TRACE */ /* ITS#3386, ITS#3113 - 20070308 * If a binary is fetched? * must use the actual size read * from the database. */ if ( BACKSQL_IS_BINARY( row.col_type[ i ] ) ) { #ifdef BACKSQL_TRACE Debug( LDAP_DEBUG_ANY, "==>backsql_get_attr_vals(\"%s\"): " "column name %s: data is binary; " "using database size %ld\n", bsi->bsi_e->e_name.bv_val, ad->ad_cname.bv_val, row.value_len[ i ] ); #endif /* BACKSQL_TRACE */ bv.bv_val = row.cols[ i ]; bv.bv_len = row.value_len[ i ]; } else { ber_str2bv( row.cols[ i ], 0, 0, &bv ); } #ifdef BACKSQL_PRETTY_VALIDATE if ( pretty ) { struct berval pbv; retval = pretty( at->bam_true_ad->ad_type->sat_syntax, &bv, &pbv, bsi->bsi_op->o_tmpmemctx ); bv = pbv; } else { retval = validate( at->bam_true_ad->ad_type->sat_syntax, &bv ); } if ( retval != LDAP_SUCCESS ) { char buf[ SLAP_TEXT_BUFLEN ]; /* FIXME: we're ignoring invalid values, * but we're accepting the attributes; * should we fail at all? */ snprintf( buf, sizeof( buf ), "unable to %s value #%lu " "of AttributeDescription %s", pretty ? "prettify" : "validate", k - oldcount, at->bam_ad->ad_cname.bv_val ); Debug( LDAP_DEBUG_TRACE, "==>backsql_get_attr_vals(\"%s\"): " "%s (%d)\n", bsi->bsi_e->e_name.bv_val, buf, retval ); continue; } #endif /* BACKSQL_PRETTY_VALIDATE */ #ifndef BACKSQL_COUNTQUERY (void)backsql_entry_addattr( bsi->bsi_e, at->bam_true_ad, &bv, bsi->bsi_op->o_tmpmemctx ); #else /* BACKSQL_COUNTQUERY */ if ( normfunc ) { struct berval nbv; retval = (*normfunc)( SLAP_MR_VALUE_OF_ATTRIBUTE_SYNTAX, at->bam_true_ad->ad_type->sat_syntax, at->bam_true_ad->ad_type->sat_equality, &bv, &nbv, bsi->bsi_op->o_tmpmemctx ); if ( retval != LDAP_SUCCESS ) { char buf[ SLAP_TEXT_BUFLEN ]; /* FIXME: we're ignoring invalid values, * but we're accepting the attributes; * should we fail at all? */ snprintf( buf, sizeof( buf ), "unable to normalize value #%lu " "of AttributeDescription %s", k - oldcount, at->bam_ad->ad_cname.bv_val ); Debug( LDAP_DEBUG_TRACE, "==>backsql_get_attr_vals(\"%s\"): " "%s (%d)\n", bsi->bsi_e->e_name.bv_val, buf, retval ); #ifdef BACKSQL_PRETTY_VALIDATE if ( pretty ) { bsi->bsi_op->o_tmpfree( bv.bv_val, bsi->bsi_op->o_tmpmemctx ); } #endif /* BACKSQL_PRETTY_VALIDATE */ continue; } ber_dupbv( &attr->a_nvals[ j ], &nbv ); bsi->bsi_op->o_tmpfree( nbv.bv_val, bsi->bsi_op->o_tmpmemctx ); } ber_dupbv( &attr->a_vals[ j ], &bv ); assert( j < oldcount + count ); j++; #endif /* BACKSQL_COUNTQUERY */ #ifdef BACKSQL_PRETTY_VALIDATE if ( pretty ) { bsi->bsi_op->o_tmpfree( bv.bv_val, bsi->bsi_op->o_tmpmemctx ); } #endif /* BACKSQL_PRETTY_VALIDATE */ #ifdef BACKSQL_TRACE Debug( LDAP_DEBUG_TRACE, "prec=%d\n", (int)row.col_prec[ i ], 0, 0 ); } else { Debug( LDAP_DEBUG_TRACE, "NULL value " "in this row for attribute \"%s\"\n", row.col_names[ i ].bv_val, 0, 0 ); #endif /* BACKSQL_TRACE */ } } } #ifdef BACKSQL_COUNTQUERY if ( BER_BVISNULL( &attr->a_vals[ 0 ] ) ) { /* don't leave around attributes with no values */ attr_free( attr ); } else if ( append ) { Attribute **ap; for ( ap = &bsi->bsi_e->e_attrs; (*ap) != NULL; ap = &(*ap)->a_next ) /* goto last */ ; *ap = attr; } #endif /* BACKSQL_COUNTQUERY */ SQLFreeStmt( sth, SQL_DROP ); Debug( LDAP_DEBUG_TRACE, "<==backsql_get_attr_vals()\n", 0, 0, 0 ); if ( at->bam_next ) { res = backsql_get_attr_vals( at->bam_next, v_bsi ); } else { res = 1; } #ifdef BACKSQL_TRACE done:; #endif /* BACKSQL_TRACE */ backsql_FreeRow_x( &row, bsi->bsi_op->o_tmpmemctx ); return res; }
/* --------------------------------------------------------- TestSQLDescribeCol for MP Specific --------------------------------------------------------- */ PassFail TestMXSQLDescribeCol(TestInfo *pTestInfo) { TEST_DECLARE; TCHAR Heading[MAX_STRING_SIZE]; RETCODE returncode; SQLHANDLE henv, hdbc, hstmt; UWORD icol; SWORD numcol, st, cs, cnull, cl, colsize = 2; SQLULEN cp; TCHAR cn[COLNAME_LEN]; TCHAR *colname[COL_LEN]; TCHAR *ExecDirStr[12]; TCHAR *colVal[2]; #ifndef _WM #ifdef UNICODE SWORD SQLType[] = {SQL_WCHAR,SQL_WVARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER, SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_WVARCHAR,SQL_BIGINT, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC, SQL_WCHAR,SQL_WVARCHAR,SQL_WVARCHAR,SQL_CHAR,SQL_VARCHAR,SQL_WVARCHAR}; SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,10,8,26,2000,19,19,19,128,128,10,18,30,254,254,2000,1016,1016,2000}; SWORD ColScale[]= {0,0,6,6,0,0,0,0,0,0,0,6,0,0,0,6,0,128,5,5,10,0,0,0,0,0,0}; #else SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER, SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_DATE,SQL_TIME,SQL_TIMESTAMP,SQL_VARCHAR,SQL_BIGINT, SQL_WCHAR,SQL_WVARCHAR,SQL_WVARCHAR, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC }; SQLULEN ColPrec[] = {254,254,18,18,5,10,7,15,15,10,8,26,2000,19,254,127,2000,19,19,128,128,10,18,30}; SWORD ColScale[]= {0, 0, 6, 6, 0,0, 0,0, 0, 0, 0,6, 0, 0, 0, 0, 0, 0, 6, 0, 128,5, 5, 10}; #endif #else SWORD SQLType[] = {SQL_CHAR,SQL_VARCHAR,SQL_DECIMAL,SQL_NUMERIC,SQL_SMALLINT,SQL_INTEGER, SQL_REAL,SQL_DOUBLE,SQL_DOUBLE,SQL_CHAR,SQL_TIME,SQL_TIMESTAMP,SQL_LONGVARCHAR,SQL_BIGINT, SQL_WCHAR,SQL_WVARCHAR,SQL_WLONGVARCHAR, SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC,SQL_NUMERIC}; SQLULEN ColPrec[] = {254,127,18,18,5,10,7,15,15,8,8,26,2000,19,254,127,2000,19,19,128,128,10,18,30}; SWORD ColScale[]= {0,0,6,6,0,0,0,0,0,0,0,6,0,0,0,6,0,128,5,5,10,0,0,0,0,0,0}; #endif TCHAR TempType1[50],TempType2[50]; SWORD ColNullable[] = {SQL_NULLABLE,SQL_NO_NULLS,SQL_NULLABLE}; TCHAR *TestCase[] = { _T("before preparing stmt "), _T("before preparing & executing stmt "), _T("before preparing, executing & fetching stmt "), _T("before execdirect stmt "), _T("before execdirect & fetching stmt "), _T("before preparing param stmt "), _T("before preparing & binding stmt "), _T("before preparing, binding & executing stmt "), _T("before preparing, binding, executing & fetching stmt ") }; int lend = 9, iend = 3; SQLUSMALLINT i = 0, l = 0; SQLLEN cbIn = SQL_NTS; //=========================================================================================================== var_list_t *var_list; var_list = load_api_vars(_T("SQLDescribeColumns"), charset_file); if (var_list == NULL) return FAILED; //print_list(var_list); colname[0] = var_mapping(_T("SQLDescribeColumns_colname_1"), var_list); colname[1] = var_mapping(_T("SQLDescribeColumns_colname_2"), var_list); colname[2] = var_mapping(_T("SQLDescribeColumns_colname_3"), var_list); colname[3] = var_mapping(_T("SQLDescribeColumns_colname_4"), var_list); colname[4] = var_mapping(_T("SQLDescribeColumns_colname_5"), var_list); colname[5] = var_mapping(_T("SQLDescribeColumns_colname_6"), var_list); colname[6] = var_mapping(_T("SQLDescribeColumns_colname_7"), var_list); colname[7] = var_mapping(_T("SQLDescribeColumns_colname_8"), var_list); colname[8] = var_mapping(_T("SQLDescribeColumns_colname_9"), var_list); colname[9] = var_mapping(_T("SQLDescribeColumns_colname_10"), var_list); colname[10] = var_mapping(_T("SQLDescribeColumns_colname_11"), var_list); colname[11] = var_mapping(_T("SQLDescribeColumns_colname_12"), var_list); colname[12] = var_mapping(_T("SQLDescribeColumns_colname_13"), var_list); colname[13] = var_mapping(_T("SQLDescribeColumns_colname_14"), var_list); colname[14] = var_mapping(_T("SQLDescribeColumns_colname_15"), var_list); colname[15] = var_mapping(_T("SQLDescribeColumns_colname_16"), var_list); colname[16] = var_mapping(_T("SQLDescribeColumns_colname_17"), var_list); colname[17] = var_mapping(_T("SQLDescribeColumns_colname_18"), var_list); colname[18] = var_mapping(_T("SQLDescribeColumns_colname_19"), var_list); colname[19] = var_mapping(_T("SQLDescribeColumns_colname_20"), var_list); colname[20] = var_mapping(_T("SQLDescribeColumns_colname_21"), var_list); colname[21] = var_mapping(_T("SQLDescribeColumns_colname_22"), var_list); colname[22] = var_mapping(_T("SQLDescribeColumns_colname_23"), var_list); colname[23] = var_mapping(_T("SQLDescribeColumns_colname_24"), var_list); #ifdef UNICODE colname[24] = var_mapping(_T("SQLDescribeColumns_colname_25"), var_list); colname[25] = var_mapping(_T("SQLDescribeColumns_colname_26"), var_list); colname[26] = var_mapping(_T("SQLDescribeColumns_colname_27"), var_list); #endif ExecDirStr[0] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_1"), var_list); ExecDirStr[1] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_2"), var_list); ExecDirStr[2] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_3"), var_list); ExecDirStr[3] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_4"), var_list); ExecDirStr[4] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_5"), var_list); ExecDirStr[5] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_6"), var_list); ExecDirStr[6] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_7"), var_list); ExecDirStr[7] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_8"), var_list); ExecDirStr[8] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_9"), var_list); ExecDirStr[9] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_10"), var_list); ExecDirStr[10] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_11"), var_list); ExecDirStr[11] = var_mapping(_T("SQLDescribeColumns_ExecDirStr_12"), var_list); colVal[0] = var_mapping(_T("SQLDescribeColumns_colVal_1"), var_list); colVal[1] = var_mapping(_T("SQLDescribeColumns_colVal_2"), var_list); //=========================================================================================================== //if(isUCS2) { // LogMsg(NONE,_T("Setup for UCS2 mode testing: ColPrec has to be doubled\n")); // l = sizeof(SQLType)/sizeof(SQLType[0]); // while(i < l) { // if(SQLType[i] == SQL_WCHAR) { // SQLType[i] = SQL_WCHAR; // //ColPrec[i] *= 2; --> This is in character, so no need to double // } // else if (SQLType[i] == SQL_WVARCHAR) { // SQLType[i] = SQL_WVARCHAR; // //ColPrec[i] *= 2; --> This is in character, so no need to double // } // else if (SQLType[i] == SQL_WLONGVARCHAR) { // SQLType[i] = SQL_WLONGVARCHAR; // //ColPrec[i] *= 2; --> This is in character, so no need to double // } // else { // } // i++; // } // i = 0; // l = 0; //} //=========================================================================================================== LogMsg(LINEBEFORE+SHORTTIMESTAMP,_T("Begin testing API => MX Specific SQLDescribeColumns.\n")); TEST_INIT; TESTCASE_BEGIN("Setup for SQLDescribCol tests\n"); if(!FullConnect(pTestInfo)) { LogMsg(NONE,_T("Unable to connect\n")); TEST_FAILED; TEST_RETURN; } henv = pTestInfo->henv; hdbc = pTestInfo->hdbc; hstmt = (SQLHANDLE)pTestInfo->hstmt; returncode = SQLAllocStmt((SQLHANDLE)hdbc, &hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLAllocStmt")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; TEST_RETURN; } TESTCASE_END; // end of setup for (l = 0; l < lend; l++) { for (i = 0; i < iend; i++) { //================================================================================== _stprintf(Heading,_T("SQLDescribeCol: Test #%d.%d\n"),l,i); TESTCASE_BEGINW(Heading); if ((i != (iend-1)) && (l < 5)) { SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */ LogMsg(NONE,_T("%s\n"), ExecDirStr[i+iend]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { LogMsg(NONE,_T("SQLDescribeCol: %s\n"),TestCase[l]); LogMsg(NONE,_T(" %s\n"),ExecDirStr[i+iend+iend+iend]); switch( l ) { case 0: returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 1 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; case 2 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } break; case 3 : returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 4 : returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; } if (returncode == SQL_SUCCESS) { returncode=SQLNumResultCols(hstmt, &numcol); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } for (icol = 1; icol <= numcol; icol++) { LogMsg(LINEBEFORE,_T("SQLDescribeCol: checking Column #%d\n"),icol); returncode = SQLDescribeCol(hstmt,icol,(SQLTCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } colsize=_tcslen(colname[icol-1]); if(isCharSet == TRUE) colsize -= 2; if ((cwcscmp(cn,colname[icol-1],FALSE) == 0) && (cl == colsize) && (st == SQLType[icol-1]) && (cp == ColPrec[icol-1]) && (cs == ColScale[icol-1]) && (cnull == ColNullable[i])) { LogMsg(NONE,_T("colname expect: %s and actual: %s are matched\n"),colname[icol-1],cn); LogMsg(NONE,_T("ColNameLen expect: %d and actual: %d are matched\n"),colsize,cl); LogMsg(NONE,_T("SQLType expect: %s and actual: %s are matched\n"), SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); LogMsg(NONE,_T("ColPrec expect: %d and actual: %d are matched\n"),ColPrec[icol-1],cp); LogMsg(NONE,_T("ColScale expect: %d and actual: %d are matched\n"),ColScale[icol-1],cs); LogMsg(NONE,_T("ColNullable expect: %s and actual: %s are matched\n\n"), SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } else { TEST_FAILED; if (cwcscmp(cn,colname[icol-1],FALSE) != 0) LogMsg(ERRMSG,_T("colname expect: %s and actual: %s are not matched line %d\n"),colname[icol-1],cn,__LINE__); if (cl != colsize) LogMsg(ERRMSG,_T("ColNameLen expect: %d and actual: %d are not matched line %d\n"),colsize,cl,__LINE__); if (st != SQLType[icol-1]) LogMsg(ERRMSG,_T("SQLType expect: %s and actual: %s are not matched line %d\n"), SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2),__LINE__); if (cp != ColPrec[icol-1]) LogMsg(ERRMSG,_T("ColPrec expect: %d and actual: %d are not matched line %d\n"),ColPrec[icol-1],cp,__LINE__); if (cs != ColScale[icol-1]) LogMsg(ERRMSG,_T("ColScale expect: %d and actual: %d are not matched line %d\n"),ColScale[icol-1],cs,__LINE__); if (cnull != ColNullable[i]) LogMsg(ERRMSG,_T("ColNullable expect: %s and actual: %s are not matched line %d\n\n"), SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2),__LINE__); } } /* end icol loop */ } else { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); /* cleanup */ } } } else if ((i == (iend-1)) && (l >= 5)) { SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i],SQL_NTS); /* cleanup */ returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend],SQL_NTS); /* create table */ LogMsg(NONE,_T("%s\n"), ExecDirStr[i+iend]); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLExecDirect(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend],SQL_NTS); /* insert into table */ if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecDirect")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { LogMsg(NONE,_T("SQLDescribeCol: %s\n"),TestCase[l]); LogMsg(NONE,_T(" %s\n"),ExecDirStr[i+iend+iend+iend]); switch( l ) { case 5 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } break; case 6 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; case 7 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } break; case 8 : returncode = SQLPrepare(hstmt,(SQLTCHAR*)ExecDirStr[i+iend+iend+iend], SQL_NTS); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLPrepare")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLBindParameter(hstmt,1,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[0],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLBindParameter(hstmt,2,SQL_PARAM_INPUT,SQL_C_TCHAR,SQL_WCHAR,2000,0,(SQLPOINTER)colVal[1],300,&cbIn); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLBindParameter")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } returncode = SQLExecute(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLExecute")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } else { returncode = SQLFetch(hstmt); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLFetch")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } } } break; } if (returncode == SQL_SUCCESS) { SQLNumResultCols(hstmt, &numcol); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLNumResultCols")) { LogAllErrors(henv,hdbc,hstmt); TEST_FAILED; } for (icol = 1; icol <= numcol; icol++) { LogMsg(LINEBEFORE,_T("SQLDescribeCol: checking Column #%d\n"),icol); returncode = SQLDescribeCol(hstmt,icol,(SQLTCHAR*)cn,COLNAME_LEN,&cl,&st,&cp,&cs,&cnull); if(!CHECKRC(SQL_SUCCESS,returncode,"SQLDescribeCol")) { TEST_FAILED; LogAllErrors(henv,hdbc,hstmt); } colsize=_tcslen(colname[icol-1]); if(isCharSet == TRUE) colsize -= 2; if ((cwcscmp(cn,colname[icol-1],FALSE) == 0) && (cl == colsize) && (st == SQLType[icol-1]) && (cp == ColPrec[icol-1]) && (cs == ColScale[icol-1]) && (cnull == ColNullable[i])) { LogMsg(NONE,_T("colname expect: %s and actual: %s are matched\n"),colname[icol-1],cn); LogMsg(NONE,_T("ColNameLen expect: %d and actual: %d are matched\n"),colsize,cl); LogMsg(NONE,_T("SQLType expect: %s and actual: %s are matched\n"), SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2)); LogMsg(NONE,_T("ColPrec expect: %d and actual: %d are matched\n"),ColPrec[icol-1],cp); LogMsg(NONE,_T("ColScale expect: %d and actual: %d are matched\n"),ColScale[icol-1],cs); LogMsg(NONE,_T("ColNullable expect: %s and actual: %s are matched\n\n"), SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2)); } else { TEST_FAILED; if (cwcscmp(cn,colname[icol-1],FALSE) != 0) LogMsg(ERRMSG,_T("colname expect: %s and actual: %s are not matched at line %d\n"),colname[icol-1],cn,__LINE__); if (cl != colsize) LogMsg(ERRMSG,_T("ColNameLen expect: %d and actual: %d are not matched at line %d\n"),colsize,cl,__LINE__); if (st != SQLType[icol-1]) LogMsg(ERRMSG,_T("SQLType expect: %s and actual: %s are not matched at line %d\n"), SQLTypeToChar(SQLType[icol-1],TempType1),SQLTypeToChar(st,TempType2),__LINE__); if (cp != ColPrec[icol-1]) LogMsg(ERRMSG,_T("ColPrec expect: %d and actual: %d are not matched at line %d\n"),ColPrec[icol-1],cp,__LINE__); if (cs != ColScale[icol-1]) LogMsg(ERRMSG,_T("ColScale expect: %d and actual: %d are not matched at line %d\n"),ColScale[icol-1],cs,__LINE__); if (cnull != ColNullable[i]) LogMsg(ERRMSG,_T("ColNullable expect: %s and actual: %s are not matched at line %d\n\n"), SQLNullToChar(ColNullable[i],TempType1),SQLNullToChar(cnull,TempType2),__LINE__); } } } } SQLFreeStmt(hstmt,SQL_CLOSE); SQLExecDirect(hstmt,(SQLTCHAR*) ExecDirStr[i],SQL_NTS); } } TESTCASE_END; } /* iend loop */ } /* lend loop */ FullDisconnect(pTestInfo); LogMsg(SHORTTIMESTAMP+LINEAFTER,_T("End testing API => MX Specific SQLDescribeColumns.\n")); free_list(var_list); TEST_RETURN; }
static int odbc_stmt_execute(pdo_stmt_t *stmt) { RETCODE rc; pdo_odbc_stmt *S = (pdo_odbc_stmt*)stmt->driver_data; char *buf = NULL; SQLLEN row_count = -1; if (stmt->executed) { SQLCloseCursor(S->stmt); } rc = SQLExecute(S->stmt); while (rc == SQL_NEED_DATA) { struct pdo_bound_param_data *param; rc = SQLParamData(S->stmt, (SQLPOINTER*)¶m); if (rc == SQL_NEED_DATA) { php_stream *stm; int len; pdo_odbc_param *P; zval *parameter; P = (pdo_odbc_param*)param->driver_data; if (Z_ISREF(param->parameter)) { parameter = Z_REFVAL(param->parameter); } else { parameter = ¶m->parameter; } if (Z_TYPE_P(parameter) != IS_RESOURCE) { /* they passed in a string */ zend_ulong ulen; convert_to_string(parameter); switch (pdo_odbc_utf82ucs2(stmt, P->is_unicode, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), &ulen)) { case PDO_ODBC_CONV_NOT_REQUIRED: SQLPutData(S->stmt, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter)); break; case PDO_ODBC_CONV_OK: SQLPutData(S->stmt, S->convbuf, ulen); break; case PDO_ODBC_CONV_FAIL: pdo_odbc_stmt_error("error converting input string"); SQLCloseCursor(S->stmt); if (buf) { efree(buf); } return 0; } continue; } /* we assume that LOBs are binary and don't need charset * conversion */ php_stream_from_zval_no_verify(stm, parameter); if (!stm) { /* shouldn't happen either */ pdo_odbc_stmt_error("input LOB is no longer a stream"); SQLCloseCursor(S->stmt); if (buf) { efree(buf); } return 0; } /* now suck data from the stream and stick it into the database */ if (buf == NULL) { buf = emalloc(8192); } do { len = php_stream_read(stm, buf, 8192); if (len == 0) { break; } SQLPutData(S->stmt, buf, len); } while (1); } } if (buf) { efree(buf); } switch (rc) { case SQL_SUCCESS: break; case SQL_NO_DATA_FOUND: case SQL_SUCCESS_WITH_INFO: pdo_odbc_stmt_error("SQLExecute"); break; default: pdo_odbc_stmt_error("SQLExecute"); return 0; } SQLRowCount(S->stmt, &row_count); stmt->row_count = row_count; if (!stmt->executed) { /* do first-time-only definition of bind/mapping stuff */ SQLSMALLINT colcount; /* how many columns do we have ? */ SQLNumResultCols(S->stmt, &colcount); stmt->column_count = (int)colcount; S->cols = ecalloc(colcount, sizeof(pdo_odbc_column)); S->going_long = 0; } return 1; }
void classISQL::ExecSQL() { SQLHSTMT hStmt; QString qsHorizSep; SQLLEN nRowsAffected; SWORD nColumns; int iRC = 0; /* TIM - return error messages if provided */ char szState[10]; char szBuf[700]; char szErrString[800]; SQLRETURN retcode; // CREATE A STATEMENT iRC = SQLAllocStmt( hDbc, &hStmt ); if ( SQL_SUCCESS != iRC ) QMessageBox::critical( (QWidget *)this, "Data Manager", "Failed: SQLAllocStmt " ); if ( SQL_SUCCESS != (iRC=SQLPrepare(hStmt, (SQLCHAR*)(txtSQL->text().data()), SQL_NTS)) ) { retcode = SQLError(SQL_NULL_HENV, hDbc, hStmt, (SQLCHAR*)szState, NULL, (SQLCHAR*)szBuf, 700, NULL); if ( retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO ) QMessageBox::critical( (QWidget *)this, "Data Manager", szBuf); else QMessageBox::critical( (QWidget *)this, "Data Manager", "Failed: SQLPrepare " ); } // EXECUTE iRC = SQLExecute( hStmt ); if ( iRC != SQL_SUCCESS ) { retcode = SQLError( 0, 0, hStmt, (SQLCHAR*)szState, NULL, (SQLCHAR*)szBuf, 700, NULL); if ( retcode == SQL_SUCCESS || retcode == SQL_SUCCESS_WITH_INFO ) QMessageBox::critical( (QWidget *)this, "Data Manager", szBuf); else QMessageBox::critical( (QWidget *)this, "Data Manager", "Failed: SQLExecute " ); } if ( iRC != SQL_SUCCESS && iRC != SQL_SUCCESS_WITH_INFO ) return; // UPDATE HISTORY appendHistoryItem(); // GET NUMBER OF ROWS AFFECTED // Wait until we know the exact number. SQLRowCount is not supported by all drivers and should not // be used. // nRowsAffected = -1; // if ( (iRC = SQLRowCount( hStmt, &nRowsAffected )) != SQL_SUCCESS ) // nRowsAffected = -1; // GET NUMBER OF COLUMNS RETURNED if ( (iRC = SQLNumResultCols( hStmt, &nColumns )) != SQL_SUCCESS ) nColumns = -1; txtResults->setAutoUpdate( FALSE ); txtResults->clear(); // GET A RESULTS HEADER (column headers) getResultsHeader( hStmt, nColumns, &qsHorizSep ); // GET A RESULTS BODY (data) nRowsAffected = getResultsBody( hStmt, nColumns ); // FREE STATEMENT iRC = SQLFreeStmt( hStmt, SQL_DROP ); if ( SQL_SUCCESS != iRC ) QMessageBox::critical( (QWidget *)this, "Data Manager", "Failed: SQLFreeStmt " ); pTabBar->setCurrentTab( 1 ); txtResults->show(); txtSQL->hide(); txtResults->append( qsHorizSep ); qsHorizSep.sprintf( "\n\n%d rows affected", nRowsAffected ); txtResults->append( qsHorizSep ); txtResults->setAutoUpdate( TRUE ); txtResults->repaint(); }
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 SMALLINT,F3 CHAR(30),F4 FLOAT,F5 FLOAT,F6 DATE,F7 TIME,F8 TIMESTAMP,F9 TINYINT,F10 BIGINT)"; ret = SQLPrepare(stmt,table,SQL_NTS); checkrc(ret,__LINE__); ret = SQLExecute(stmt); checkrc(ret,__LINE__); printf("\nTABLE CREATED\n"); //***************************** InsertTest(env,dbc,stmt); DeleteTest(env,dbc,stmt); //**************************************************************** SQLCHAR drop[100]="DROP TABLE T1"; ret = SQLPrepare(stmt,drop,SQL_NTS); checkrc(ret,__LINE__); ret = SQLExecute(stmt); if(ret!=SQL_SUCCESS && ret !=SQL_SUCCESS_WITH_INFO) printf("Statement failed\n"); else printf("Table 'T1' dropped successfully\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; }
int main(int argc, char **argv) { SQLRETURN rc; HSTMT hstmt = SQL_NULL_HSTMT; char *param1, *param2; SQLLEN cbParam1, cbParam2; SQLLEN param1bytes, param2bytes; PTR paramid; SQLLEN str_ind_array[2]; SQLUSMALLINT status_array[2]; SQLULEN nprocessed = 0; 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); } /**** * Bind with data-at-execution params. (VARBINARY) */ /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id FROM byteatab WHERE t = ? OR t = ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); /* prepare the parameter values */ param1 = "bar"; param1bytes = strlen(param1); cbParam1 = SQL_DATA_AT_EXEC; param2 = "foobar"; param2bytes = strlen(param2); cbParam2 = SQL_DATA_AT_EXEC; /* bind them. */ rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_BINARY, /* value type */ SQL_VARBINARY, /* param type */ param1bytes, /* column size */ 0, /* dec digits */ (void *) 1, /* param value ptr. For a data-at-exec * param, this is a "parameter id" */ 0, /* buffer len */ &cbParam1 /* StrLen_or_IndPtr */); CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt); rc = SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_BINARY, /* value type */ SQL_VARBINARY, /* param type */ param2bytes, /* column size */ 0, /* dec digits */ (void *) 2, /* param value ptr. For a data-at-exec * param, this is a "parameter id" */ 0, /* buffer len */ &cbParam2 /* StrLen_or_IndPtr */); CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt); /* Execute */ rc = SQLExecute(hstmt); if (rc != SQL_NEED_DATA) CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt); /* set parameters */ paramid = 0; while ((rc = SQLParamData(hstmt, ¶mid)) == SQL_NEED_DATA) { if (paramid == (void *) 1) { rc = SQLPutData(hstmt, param1, param1bytes); CHECK_STMT_RESULT(rc, "SQLPutData failed", hstmt); } else if (paramid == (void *) 2) { rc = SQLPutData(hstmt, param2, param2bytes); CHECK_STMT_RESULT(rc, "SQLPutData failed", hstmt); } else { printf("unexpected parameter id returned by SQLParamData: %p\n", paramid); exit(1); } } CHECK_STMT_RESULT(rc, "SQLParamData failed", hstmt); /* Fetch result */ print_result(hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /**** * Array binding with data-at-execution params. */ /* prepare the parameter values */ str_ind_array[0] = SQL_DATA_AT_EXEC; str_ind_array[1] = SQL_DATA_AT_EXEC; /* Prepare a statement */ rc = SQLPrepare(hstmt, (SQLCHAR *) "SELECT id FROM byteatab WHERE t = ?", SQL_NTS); CHECK_STMT_RESULT(rc, "SQLPrepare failed", hstmt); SQLSetStmtAttr(hstmt, SQL_ATTR_PARAM_BIND_TYPE, SQL_PARAM_BIND_BY_COLUMN, 0); SQLSetStmtAttr(hstmt, SQL_ATTR_PARAM_STATUS_PTR, status_array, 0); SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMS_PROCESSED_PTR, &nprocessed, 0); SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER) 2, 0); /* bind the array. */ rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_BINARY, /* value type */ SQL_VARBINARY, /* param type */ 5, /* column size */ 0, /* dec digits */ (void *) 1, /* param value ptr. For a data-at-exec * param, this is "parameter id" */ 0, /* buffer len */ str_ind_array /* StrLen_or_IndPtr */); CHECK_STMT_RESULT(rc, "SQLBindParameter failed", hstmt); /* Execute */ rc = SQLExecute(hstmt); if (rc != SQL_NEED_DATA) CHECK_STMT_RESULT(rc, "SQLExecute failed", hstmt); /* set parameters */ paramid = 0; while ((rc = SQLParamData(hstmt, ¶mid)) == SQL_NEED_DATA) { if (nprocessed == 1) rc = SQLPutData(hstmt, "foo", strlen("foo")); else if (nprocessed == 2) rc = SQLPutData(hstmt, "barf", strlen("barf")); else { printf("unexpected # of rows processed after SQL_NEED_DATA: %u\n", (unsigned int) nprocessed); exit(1); } CHECK_STMT_RESULT(rc, "SQLPutData failed", hstmt); } CHECK_STMT_RESULT(rc, "SQLParamData failed", hstmt); /* Fetch results */ printf("Parameter Status\n"); for (i = 0; i < nprocessed; i++) { switch (status_array[i]) { case SQL_PARAM_SUCCESS: case SQL_PARAM_SUCCESS_WITH_INFO: break; case SQL_PARAM_ERROR: printf("%d\tError\n", i); break; case SQL_PARAM_UNUSED: printf("%d\tUnused\n", i); break; case SQL_PARAM_DIAG_UNAVAILABLE: printf("%d\tDiag unavailable\n", i); break; } } printf ("Fetching result sets for array bound (%u results expected)\n", (unsigned int) nprocessed); for (i = 1; rc == SQL_SUCCESS || rc == SQL_SUCCESS_WITH_INFO; i++) { printf("%d: ", i); print_result(hstmt); rc = SQLMoreResults(hstmt); } if (rc != SQL_NO_DATA) CHECK_STMT_RESULT(rc, "SQLMoreResults failed", hstmt); rc = SQLFreeStmt(hstmt, SQL_CLOSE); CHECK_STMT_RESULT(rc, "SQLFreeStmt failed", hstmt); /* Clean up */ test_disconnect(); return 0; }
void BatchUpdate (SQLHANDLE hdbc, SQLHANDLE hstmt, char *TableName, unsigned int SizeOfBatch, unsigned int NumberRecords) { SQLRETURN rc; char Statement[1000]; int EmpID = 10000; SQLCHAR FirstName[DESC_LEN]; SQLCHAR LastName[DESC_LEN]; SQL_DATE_STRUCT HireDate; int Salary; SQLLEN FirstNameInd, LastNameInd, EmpIDInd, HireDateInd, SalaryInd; SQLUINTEGER i, NumRecords, Loop, RowCount, NumRowsAffected; struct _timeb timeBuffer; unsigned long beginMSec, endMSec; strcpy(Statement, "update "); strcat(Statement, TableName); strcat(Statement, " set FIRST_NAME = ?, LAST_NAME = ?, HIRE_DATE = ?, SALARY = ? where EMP_ID = ?"); RowCount = 0; NumRowsAffected = 0; // Set AUTOCOMMIT off rc = SQLSetConnectAttr (hdbc, SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)SQL_AUTOCOMMIT_OFF, SQL_IS_UINTEGER); // Bind the parameters in column-wise fashion rc = SQLBindParameter(hstmt, 1, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 20, 0, FirstName, DESC_LEN, &FirstNameInd); rc = SQLBindParameter(hstmt, 2, SQL_PARAM_INPUT, SQL_C_CHAR, SQL_VARCHAR, 30, 0, LastName, DESC_LEN, &LastNameInd); rc = SQLBindParameter(hstmt, 3, SQL_PARAM_INPUT, SQL_C_TYPE_DATE, SQL_TYPE_TIMESTAMP, 19, 0, &HireDate, 19, &HireDateInd); rc = SQLBindParameter(hstmt, 4, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 9, 0, (SQLPOINTER)&Salary, sizeof(int), &SalaryInd); rc = SQLBindParameter(hstmt, 5, SQL_PARAM_INPUT, SQL_C_LONG, SQL_INTEGER, 6, 0, (SQLPOINTER)&EmpID, sizeof(int), &EmpIDInd); rc = SQLPrepare(hstmt, (unsigned char*)Statement, strlen(Statement)); if (rc != SQL_SUCCESS) { printf("SQLPrepare failed\n"); displayError(SQL_HANDLE_STMT, hstmt); exit(255); } // Obtain start time _ftime(&timeBuffer); beginMSec = (unsigned long)(timeBuffer.time * 1000) + timeBuffer.millitm; NumRecords = NumberRecords; i = 0; while (NumRecords > 0) { if (NumRecords < SizeOfBatch) { Loop = NumRecords; //rc = SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER)Loop, 0); } else { Loop = SizeOfBatch; } //rc = SQLSetStmtAttr(hstmt, SQL_ATTR_PARAMSET_SIZE, (SQLPOINTER)Loop, 0); // Set values for update for (i = 0; i < Loop; i++) { strcpy((char *)FirstName, "Barney"); FirstNameInd = strlen(FirstName); strcpy((char *)LastName, "Rubble"); LastNameInd = strlen(LastName); HireDate.year = 2014; HireDate.month = 5; HireDate.day = 01; HireDateInd = 0; Salary = 20000; SalaryInd = 0; EmpID++; EmpIDInd = 0; // Execute the statement rc = SQLExecute(hstmt); switch (rc) { case SQL_SUCCESS: break; case SQL_SUCCESS_WITH_INFO: printf ("SQL_SUCCESS_WITH_INFO\n"); displayError(SQL_HANDLE_STMT, hstmt); break; case SQL_NEED_DATA: printf ("SQL_NEED_DATA\n"); break; case SQL_STILL_EXECUTING: printf ("SQL_STILL_EXECUTING\n"); break; case SQL_ERROR: printf ("SQL_ERROR\n"); displayError(SQL_HANDLE_STMT, hstmt); break; case SQL_NO_DATA: printf ("SQL_NO_DATA\n"); //exit(255); break; case SQL_INVALID_HANDLE: printf ("SQL_INVALID_HANDLE\n"); displayError(SQL_HANDLE_STMT, hstmt); break; } NumRecords--; } // Commit Transaction rc = SQLEndTran(SQL_HANDLE_DBC, hdbc, SQL_COMMIT); rc = SQLRowCount(hstmt, (SQLINTEGER *)&RowCount); NumRowsAffected = NumRowsAffected + RowCount; //printf("NumRowsAffected = %d\n", NumRowsAffected); } // Obtain end time _ftime(&timeBuffer); endMSec = (unsigned long)(timeBuffer.time * 1000) + timeBuffer.millitm; //NumberRecords = (unsigned int)SelectCount(hstmt); printf ("%17d %10d ", NumberRecords, SizeOfBatch); // Display time unsigned long totalMSec = endMSec - beginMSec; printf("%d msecs", totalMSec); // Set AUTOCOMMIT on rc = SQLSetConnectAttr (hdbc, SQL_ATTR_AUTOCOMMIT,(SQLPOINTER)SQL_AUTOCOMMIT_ON, SQL_IS_UINTEGER); }
/* ------------------------------------------------------------- */ LGL jx_sqlUpsert (BOOL update, PUCHAR table , PJXNODE pSqlParms , PUCHAR where) { LONG attrParm; LONG i; UCHAR sqlTempStmt[32766]; PUCHAR stmt = sqlTempStmt; PJXNODE pNode; PUCHAR comma = ""; PUCHAR name, value; SQLSMALLINT length; SQLHDBC hdbctmp; SQLHSTMT hstmttmp; SQLRETURN rc; PJXSQL pSQL = jx_sqlNewStatement (NULL); SQLCHUNK sqlChunk[32]; SHORT sqlChunkIx =0; PUCHAR sqlNullPtr = NULL; // First get the columen types - by now we use a select to mimic that // allocate a statement handle pSQL->rc = SQLAllocHandle(SQL_HANDLE_STMT, pConnection->hdbc , &hstmttmp); if (pSQL->rc != SQL_SUCCESS ) { SQLError( pConnection->henv, pConnection->hdbc , hstmttmp, pConnection->sqlState , &pConnection->sqlCode, pConnection->sqlMsgDta , sizeof(pConnection->sqlMsgDta), &length); substr ( jxMessage , pConnection->sqlMsgDta , length); return ON; // we have an error } stmt = sqlTempStmt; stmt += sprintf (stmt , "select "); comma = ""; pNode = jx_GetNode(pSqlParms, "/"); while (pNode) { name = jx_GetNodeNamePtr (pNode); stmt += sprintf (stmt , "%s%s" , comma , name); comma = ","; pNode = jx_GetNodeNext(pNode); } stmt += sprintf (stmt , " from %s where 1=0" , table); // prepare the statement */ pSQL->rc = SQLPrepare(hstmttmp , sqlTempStmt, SQL_NTS); if (pSQL->rc != SQL_SUCCESS ) { SQLError( pConnection->henv, pConnection->hdbc , hstmttmp, pConnection->sqlState , &pConnection->sqlCode, pConnection->sqlMsgDta , sizeof(pConnection->sqlMsgDta), &length); substr ( jxMessage , pConnection->sqlMsgDta , length); SQLFreeStmt(hstmttmp, SQL_CLOSE); return ON; // we have an error } // Now we have the colume definitions - now build the update statement: // allocate a statement handle pSQL->rc = SQLAllocHandle(SQL_HANDLE_STMT, pConnection->hdbc , &pSQL->hstmt); if (pSQL->rc != SQL_SUCCESS ) { check_error (pSQL); SQLFreeStmt(hstmttmp, SQL_CLOSE); return ON; // we have an error } // This need to allow update attrParm = SQL_INSENSITIVE; pSQL->rc = SQLSetStmtAttr (pSQL->hstmt, SQL_ATTR_CURSOR_SENSITIVITY , &attrParm , 0); if (pSQL->rc != SQL_SUCCESS ) { check_error (pSQL); return ON; // we have an error } if (update) { buildUpdate (hstmttmp, sqlTempStmt , table, pSqlParms , where); } else { buildInsert (hstmttmp, sqlTempStmt , table, pSqlParms , where); } // prepare the statement that provides the coloumn types pSQL->rc = SQLPrepare(pSQL->hstmt , sqlTempStmt, SQL_NTS); if (pSQL->rc != SQL_SUCCESS ) { check_error (pSQL); SQLFreeStmt(hstmttmp, SQL_CLOSE); return ON; // we have an error } // Take the description from the "select" and use it on the "update" pNode = jx_GetNode(pSqlParms, "/"); for (i=1; pNode; i++) { JXCOL Col; memset (&Col , 0 , sizeof(JXCOL)); value = jx_GetNodeValuePtr (pNode , NULL); pSQL->rc = SQLDescribeCol ( hstmttmp, i, Col.colname, sizeof (Col.colname), &Col.colnamelen, &Col.coltype, &Col.collen, &Col.scale, &Col.nullable ); if (pSQL->rc != SQL_SUCCESS ) { check_error (pSQL); return ON; // we have an error } // bind parameter to the statement if ( Col.coltype == SQL_BLOB || Col.coltype == SQL_CLOB ) { SQLINTEGER dataAtExec = SQL_DATA_AT_EXEC; // SQLLEN dataAtExec = SQL_LEN_DATA_AT_EXEC ( 0 ); PSQLCHUNK pSqlChunk = &sqlChunk[sqlChunkIx++]; pSqlChunk->actLen = strlen(value); pSqlChunk->offset = 0; pSqlChunk->chunkLen = min(pSqlChunk->actLen,16384); pSqlChunk->value = value; if (pSqlChunk->actLen == 0) { pSQL->rc = SQLBindParameter(pSQL->hstmt, i, SQL_PARAM_INPUT, SQL_C_BINARY, //SQL_C_CHAR, // SQL_C_BINARY, , // SQL_C_BINARY, //SQL_C_CHAR, SQL_LONGVARBINARY, // SQL_VARBINARY, // // SQL_LONGVARCHAR, 0 , // Col.collen, // pSqlChunk->actLen, pSqlChunk->chunkLen, pSqlChunk->chunkLen,//Col.collen, 0, // presition value, // Parm value 0 , // Buffer len - Not used NULL // no-chunk just direct access to NULL ); } else { pSQL->rc = SQLBindParameter(pSQL->hstmt, i, SQL_PARAM_INPUT, SQL_C_BINARY, //SQL_C_CHAR, // SQL_C_BINARY, , // SQL_C_BINARY, //SQL_C_CHAR, SQL_LONGVARBINARY, // SQL_VARBINARY, // // SQL_LONGVARCHAR, pSqlChunk->actLen,// Col.collen pSqlChunk->chunkLen, pSqlChunk->chunkLen,//Col.collen,//overall length 0, // presition (SQLPOINTER) pSqlChunk, // Parm value 0 , // Buffer len - Not used &dataAtExec // chunk size ); } } else { pSQL->rc = SQLBindParameter(pSQL->hstmt, i, SQL_PARAM_INPUT, SQL_C_CHAR, Col.coltype, Col.collen, // length Col.scale, // presition value, 0, NULL // pointer to length variable ); } if (pSQL->rc != SQL_SUCCESS ) { check_error (pSQL); return ON; // we have an error } pNode = jx_GetNodeNext(pNode); } // Now we are done with the select statement: rc = SQLFreeStmt(hstmttmp, SQL_CLOSE); // run the statement in "sqlstr" pSQL->rc = SQLExecute( pSQL->hstmt); // Has BLOB's ? while (pSQL->rc == SQL_NEED_DATA) { SQLPOINTER parmNo; PSQLCHUNK pSqlChunk; SHORT i; SQLINTEGER putLen; PUCHAR putBuf; pSQL->rc = SQLParamData(pSQL->hstmt, (SQLPOINTER) &pSqlChunk); if (pSQL->rc == SQL_NEED_DATA) { // iterate for each buffer chunk while (pSqlChunk->actLen > 0) { putLen = min(pSqlChunk->actLen , pSqlChunk->chunkLen); putBuf = pSqlChunk->value + pSqlChunk->offset; rc = SQLPutData(pSQL->hstmt, putBuf , putLen); pSqlChunk->offset += putLen; pSqlChunk->actLen -= putLen; } } } if (pSQL->rc != SQL_SUCCESS && pSQL->rc != SQL_NO_DATA_FOUND) { check_error (pSQL); return ON; // we have an error } jx_sqlClose (&pSQL); return OFF; }
int main(int argc, char *argv[]) { HENV env; HDBC dbc; HSTMT stmt; SQLRETURN ret; SQLINTEGER i; Connect(); /* here we can't use temporary table cause we use two connection */ CommandWithResult(Statement, "drop table test_timeout"); Command(Statement, "create table test_timeout(n numeric(18,0) primary key, t varchar(30))"); AutoCommit(SQL_AUTOCOMMIT_OFF); Command(Statement, "insert into test_timeout(n, t) values(1, 'initial')"); EndTransaction(SQL_COMMIT); Command(Statement, "update test_timeout set t = 'second' where n = 1"); /* save this connection and do another */ env = Environment; dbc = Connection; stmt = Statement; Environment = SQL_NULL_HENV; Connection = SQL_NULL_HDBC; Statement = SQL_NULL_HSTMT; Connect(); AutoCommit(SQL_AUTOCOMMIT_OFF); ret = SQLSetStmtAttr(Statement, SQL_ATTR_QUERY_TIMEOUT, (SQLPOINTER) 2, 0); if (ret != SQL_SUCCESS) ODBC_REPORT_ERROR("Error setting timeout"); i = 1; ret = SQLBindParameter(Statement, 1, SQL_PARAM_INPUT, SQL_C_SLONG, SQL_INTEGER, 0, 0, &i, 0, NULL); if (ret != SQL_SUCCESS) ODBC_REPORT_ERROR("SQLBindParameter failure"); if (SQLPrepare(Statement, (SQLCHAR *) "update test_timeout set t = 'bad' where n = ?", SQL_NTS) != SQL_SUCCESS) ODBC_REPORT_ERROR("SQLPrepare failure"); ret = SQLExecute(Statement); if (ret != SQL_ERROR) ODBC_REPORT_ERROR("SQLExecute success ??"); EndTransaction(SQL_ROLLBACK); /* TODO should return error S1T00 Timeout expired, test error message */ ret = CommandWithResult(Statement, "update test_timeout set t = 'bad' where n = 1"); if (ret != SQL_ERROR) ODBC_REPORT_ERROR("SQLExecDirect success ??"); EndTransaction(SQL_ROLLBACK); Disconnect(); Environment = env; Connection = dbc; Statement = stmt; EndTransaction(SQL_COMMIT); /* Sybase do not accept DROP TABLE during a transaction */ AutoCommit(SQL_AUTOCOMMIT_ON); Command(Statement, "drop table test_timeout"); Disconnect(); return 0; }
int execute_product_detail(struct db_context_t *odbcc, struct product_detail_t *data) { SQLRETURN rc; int j; /* Perpare statement for Product Detail interaction. */ rc = SQLPrepare(odbcc->hstmt, STMT_PRODUCT_DETAIL, SQL_NTS); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } /* Bind variables for Product Detail interaction. */ j = 1; rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_INPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &data->i_id, 0, NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_title, sizeof(data->i_title), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->a_fname, sizeof(data->a_fname), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->a_lname, sizeof(data->a_lname), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_pub_date, sizeof(data->i_pub_date), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_publisher, sizeof(data->i_publisher), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_subject, sizeof(data->i_subject), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_desc, sizeof(data->i_desc), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_ULONG, SQL_INTEGER, 0, 0, &data->i_image, 0, NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &data->i_cost, 0, NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_DOUBLE, SQL_DOUBLE, 0, 0, &data->i_srp, 0, NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_avail, sizeof(data->i_avail), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_isbn, sizeof(data->i_isbn), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_SSHORT, SQL_SMALLINT, 0, 0, &data->i_page, 0, NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_backing, sizeof(data->i_backing), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } rc = SQLBindParameter(odbcc->hstmt, j++, SQL_PARAM_OUTPUT, SQL_C_CHAR, SQL_VARCHAR, 0, 0, data->i_dimensions, sizeof(data->i_dimensions), NULL); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } /* Execute stored procedure. */ rc = SQLExecute(odbcc->hstmt); if (rc != SQL_SUCCESS && rc != SQL_SUCCESS_WITH_INFO) { LOG_ODBC_ERROR(SQL_HANDLE_STMT, odbcc->hstmt); return W_ERROR; } return OK; }