SQLRETURN MNDBFreeHandle(SQLSMALLINT HandleType, SQLHANDLE Handle) { /* Check parameter handle */ if (Handle == NULL) { /* can not set an error message because the handle is NULL */ return SQL_INVALID_HANDLE; } switch (HandleType) { case SQL_HANDLE_ENV: { ODBCEnv *env = (ODBCEnv *) Handle; /* check it's validity */ if (!isValidEnv(env)) return SQL_INVALID_HANDLE; clearEnvErrors(env); return ODBCFreeEnv_(env); } case SQL_HANDLE_DBC: { ODBCDbc *dbc = (ODBCDbc *) Handle; /* check it's validity */ if (!isValidDbc(dbc)) return SQL_INVALID_HANDLE; clearDbcErrors(dbc); return ODBCFreeDbc_(dbc); } case SQL_HANDLE_STMT: { ODBCStmt *stmt = (ODBCStmt *) Handle; /* check it's validity */ if (!isValidStmt(stmt)) return SQL_INVALID_HANDLE; clearStmtErrors(stmt); return ODBCFreeStmt_(stmt); } case SQL_HANDLE_DESC: { ODBCDesc *desc = (ODBCDesc *) Handle; /* check it's validity */ if (!isValidDesc(desc)) return SQL_INVALID_HANDLE; clearDescErrors(desc); return ODBCFreeDesc_(desc); } default: return SQL_INVALID_HANDLE; } /* not reached */ }
SQLRETURN SQL_API SQLSetDescRec(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT Type, SQLSMALLINT SubType, SQLLEN Length, SQLSMALLINT Precision, SQLSMALLINT Scale, SQLPOINTER DataPtr, SQLLEN *StringLengthPtr, SQLLEN *IndicatorPtr) { ODBCDesc *desc = (ODBCDesc *) DescriptorHandle; #ifdef ODBCDEBUG ODBCLOG("SQLSetDescRec " PTRFMT " %d %s %s " LENFMT " %d %d\n", PTRFMTCAST DescriptorHandle, (int) RecNumber, isAD(desc) ? translateCType(Type) : translateSQLType(Type), translateSubType(Type, SubType), LENCAST Length, (int) Precision, (int) Scale); #endif if (!isValidDesc(desc)) return SQL_INVALID_HANDLE; if (SQLSetDescField_(desc, RecNumber, SQL_DESC_TYPE, (SQLPOINTER) (ssize_t) Type, 0) == SQL_ERROR) return SQL_ERROR; if ((Type == SQL_DATETIME || Type == SQL_INTERVAL) && SQLSetDescField_(desc, RecNumber, SQL_DESC_DATETIME_INTERVAL_CODE, (SQLPOINTER) (ssize_t) SubType, 0) == SQL_ERROR) return SQL_ERROR; if (SQLSetDescField_(desc, RecNumber, SQL_DESC_OCTET_LENGTH, (SQLPOINTER) (ssize_t) Length, 0) == SQL_ERROR) return SQL_ERROR; if (SQLSetDescField_(desc, RecNumber, SQL_DESC_PRECISION, (SQLPOINTER) (ssize_t) Precision, 0) == SQL_ERROR) return SQL_ERROR; if (SQLSetDescField_(desc, RecNumber, SQL_DESC_SCALE, (SQLPOINTER) (ssize_t) Scale, 0) == SQL_ERROR) return SQL_ERROR; if (SQLSetDescField_(desc, RecNumber, SQL_DESC_OCTET_LENGTH_PTR, (SQLPOINTER) StringLengthPtr, 0) == SQL_ERROR) return SQL_ERROR; if (SQLSetDescField_(desc, RecNumber, SQL_DESC_INDICATOR_PTR, (SQLPOINTER) IndicatorPtr, 0) == SQL_ERROR) return SQL_ERROR; if (SQLSetDescField_(desc, RecNumber, SQL_DESC_DATA_PTR, (SQLPOINTER) DataPtr, 0) == SQL_ERROR) return SQL_ERROR; return desc->Error ? SQL_SUCCESS_WITH_INFO : SQL_SUCCESS; }
SQLRETURN SQL_API SQLSetDescFieldW(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier, SQLPOINTER ValuePtr, SQLINTEGER BufferLength) { ODBCDesc *desc = (ODBCDesc *) DescriptorHandle; SQLRETURN rc; SQLPOINTER ptr; SQLINTEGER n; #ifdef ODBCDEBUG ODBCLOG("SQLSetDescFieldW %p %d %s %p %d\n", DescriptorHandle, (int) RecNumber, translateFieldIdentifier(FieldIdentifier), ValuePtr, (int) BufferLength); #endif if (!isValidDesc(desc)) return SQL_INVALID_HANDLE; clearDescErrors(desc); switch (FieldIdentifier) { case SQL_DESC_NAME: if (BufferLength > 0) /* convert from bytes to characters */ BufferLength /= 2; fixWcharIn(ValuePtr, BufferLength, SQLCHAR, ptr, addDescError, desc, return SQL_ERROR); n = SQL_NTS; break; default: ptr = ValuePtr; n = BufferLength; break; } rc = MNDBSetDescField(desc, RecNumber, FieldIdentifier, ptr, n); if (ptr && ptr != ValuePtr) free(ptr); return rc; }
SQLRETURN SQL_API SQLSetDescField(SQLHDESC DescriptorHandle, SQLSMALLINT RecNumber, SQLSMALLINT FieldIdentifier, SQLPOINTER ValuePtr, SQLINTEGER BufferLength) { #ifdef ODBCDEBUG ODBCLOG("SQLSetDescField %p %d %s %p %d\n", DescriptorHandle, (int) RecNumber, translateFieldIdentifier(FieldIdentifier), ValuePtr, (int) BufferLength); #endif if (!isValidDesc((ODBCDesc *) DescriptorHandle)) return SQL_INVALID_HANDLE; clearDescErrors((ODBCDesc *) DescriptorHandle); return MNDBSetDescField((ODBCDesc *) DescriptorHandle, RecNumber, FieldIdentifier, ValuePtr, BufferLength); }
SQLRETURN MNDBEndTran(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT CompletionType) { ODBCEnv *env = NULL; ODBCDbc *dbc = NULL; SQLHANDLE StatementHandle; RETCODE rc; /* check parameters HandleType and Handle for validity */ switch (HandleType) { case SQL_HANDLE_DBC: dbc = (ODBCDbc *) Handle; if (!isValidDbc(dbc)) return SQL_INVALID_HANDLE; clearDbcErrors(dbc); if (!dbc->Connected) { /* Connection does not exist */ addDbcError(dbc, "08003", NULL, 0); return SQL_ERROR; } break; case SQL_HANDLE_ENV: env = (ODBCEnv *) Handle; if (!isValidEnv(env)) return SQL_INVALID_HANDLE; clearEnvErrors(env); if (env->sql_attr_odbc_version == 0) { /* Function sequence error */ addEnvError(env, "HY010", NULL, 0); return SQL_ERROR; } break; case SQL_HANDLE_STMT: if (isValidStmt((ODBCStmt *) Handle)) { clearStmtErrors((ODBCStmt *) Handle); /* Invalid attribute/option identifier */ addStmtError((ODBCStmt *) Handle, "HY092", NULL, 0); return SQL_ERROR; } return SQL_INVALID_HANDLE; case SQL_HANDLE_DESC: if (isValidDesc((ODBCDesc *) Handle)) { clearDescErrors((ODBCDesc *) Handle); /* Invalid attribute/option identifier */ addDescError((ODBCDesc *) Handle, "HY092", NULL, 0); return SQL_ERROR; } return SQL_INVALID_HANDLE; default: return SQL_INVALID_HANDLE; } /* check parameter CompletionType */ if (CompletionType != SQL_COMMIT && CompletionType != SQL_ROLLBACK) { /* Invalid transaction operation code */ if (HandleType == SQL_HANDLE_DBC) addDbcError(dbc, "HY012", NULL, 0); else addEnvError(env, "HY012", NULL, 0); return SQL_ERROR; } if (HandleType == SQL_HANDLE_ENV) { RETCODE rc1 = SQL_SUCCESS; for (dbc = env->FirstDbc; dbc; dbc = dbc->next) { assert(isValidDbc(dbc)); if (!dbc->Connected) continue; rc = MNDBEndTran(SQL_HANDLE_DBC, dbc, CompletionType); if (rc == SQL_ERROR) rc1 = SQL_ERROR; else if (rc == SQL_SUCCESS_WITH_INFO && rc1 != SQL_ERROR) rc1 = rc; } return rc1; } assert(HandleType == SQL_HANDLE_DBC); if (dbc->sql_attr_autocommit == SQL_AUTOCOMMIT_ON) { /* nothing to do if in autocommit mode */ return SQL_SUCCESS; } /* construct a statement object and excute a SQL COMMIT or ROLLBACK */ rc = MNDBAllocStmt(dbc, &StatementHandle); if (SQL_SUCCEEDED(rc)) { ODBCStmt *stmt = (ODBCStmt *) StatementHandle; rc = MNDBExecDirect(stmt, CompletionType == SQL_COMMIT ? (SQLCHAR *) "commit" : (SQLCHAR *) "rollback", SQL_NTS); if (rc == SQL_ERROR || rc == SQL_SUCCESS_WITH_INFO) { /* get the error/warning and post in on the * dbc handle */ SQLCHAR sqlState[SQL_SQLSTATE_SIZE + 1]; SQLINTEGER nativeErrCode; SQLCHAR msgText[SQL_MAX_MESSAGE_LENGTH + 1]; (void) MNDBGetDiagRec(SQL_HANDLE_STMT, stmt, 1, sqlState, &nativeErrCode, msgText, sizeof(msgText), NULL); addDbcError(dbc, (char *) sqlState, (char *) msgText + ODBCErrorMsgPrefixLength, nativeErrCode); } /* clean up the statement handle */ ODBCResetStmt(stmt); ODBCFreeStmt_(stmt); for (stmt = dbc->FirstStmt; stmt; stmt = stmt->next) ODBCResetStmt(stmt); } else { /* could not allocate a statement object */ /* Memory management error */ addDbcError(dbc, "HY013", NULL, 0); return SQL_ERROR; } return rc; }
static SQLRETURN MNDBGetDiagField(SQLSMALLINT HandleType, SQLHANDLE Handle, SQLSMALLINT RecNumber, SQLSMALLINT DiagIdentifier, SQLPOINTER DiagInfoPtr, SQLSMALLINT BufferLength, SQLSMALLINT *StringLengthPtr) { ODBCError *err; ODBCDbc *dbc = NULL; /* input & output parameters validity checks */ switch (HandleType) { case SQL_HANDLE_ENV: /* Check if this struct is still valid/alive */ if (!isValidEnv((ODBCEnv *) Handle)) return SQL_INVALID_HANDLE; err = ((ODBCEnv *) Handle)->Error; break; case SQL_HANDLE_DBC: /* Check if this struct is still valid/alive */ dbc = (ODBCDbc *) Handle; if (!isValidDbc(dbc)) return SQL_INVALID_HANDLE; err = dbc->Error; break; case SQL_HANDLE_STMT: /* Check if this struct is still valid/alive */ if (!isValidStmt((ODBCStmt *) Handle)) return SQL_INVALID_HANDLE; err = ((ODBCStmt *) Handle)->Error; dbc = ((ODBCStmt *) Handle)->Dbc; break; case SQL_HANDLE_DESC: /* Check if this struct is still valid/alive */ if (!isValidDesc((ODBCDesc *) Handle)) return SQL_INVALID_HANDLE; err = ((ODBCDesc *) Handle)->Error; dbc = ((ODBCDesc *) Handle)->Dbc; break; default: return SQL_INVALID_HANDLE; } /* header fields */ switch (DiagIdentifier) { case SQL_DIAG_CURSOR_ROW_COUNT: /* SQLLEN */ if (HandleType != SQL_HANDLE_STMT) return SQL_ERROR; *(SQLLEN *) DiagInfoPtr = (SQLLEN) ((ODBCStmt *) Handle)->rowSetSize; return SQL_SUCCESS; case SQL_DIAG_DYNAMIC_FUNCTION: /* SQLCHAR* */ if (HandleType != SQL_HANDLE_STMT) return SQL_ERROR; copyDiagString("", DiagInfoPtr, BufferLength, StringLengthPtr); return SQL_SUCCESS; case SQL_DIAG_DYNAMIC_FUNCTION_CODE: /* SQLINTEGER */ if (HandleType != SQL_HANDLE_STMT) return SQL_ERROR; *(SQLINTEGER *) DiagInfoPtr = SQL_DIAG_UNKNOWN_STATEMENT; return SQL_SUCCESS; case SQL_DIAG_NUMBER: /* SQLINTEGER */ *(SQLINTEGER *) DiagInfoPtr = getErrorRecCount(err); return SQL_SUCCESS; case SQL_DIAG_RETURNCODE: /* SQLRETURN */ *(SQLRETURN *) DiagInfoPtr = SQL_SUCCESS; return SQL_SUCCESS; case SQL_DIAG_ROW_COUNT: /* SQLLEN */ if (HandleType != SQL_HANDLE_STMT || ((ODBCStmt *) Handle)->State < EXECUTED0) return SQL_ERROR; *(SQLLEN *) DiagInfoPtr = (SQLLEN) ((ODBCStmt *) Handle)->rowcount; return SQL_SUCCESS; } /* record fields */ if (RecNumber <= 0) return SQL_ERROR; err = getErrorRec(err, RecNumber); if (err == NULL) return SQL_NO_DATA; switch (DiagIdentifier) { case SQL_DIAG_CLASS_ORIGIN:{ /* SQLCHAR* */ char *msg = strncmp(getSqlState(err), "IM", 2) == 0 ? "ODBC 3.0" : "ISO 9075"; copyDiagString(msg, DiagInfoPtr, BufferLength, StringLengthPtr); return SQL_SUCCESS; } case SQL_DIAG_COLUMN_NUMBER: /* SQLINTEGER */ if (HandleType != SQL_HANDLE_STMT) return SQL_ERROR; *(SQLINTEGER *) DiagInfoPtr = SQL_COLUMN_NUMBER_UNKNOWN; return SQL_SUCCESS; case SQL_DIAG_CONNECTION_NAME:{ /* SQLCHAR* */ char *msg = "MonetDB ODBC/Mapi"; copyDiagString(msg, DiagInfoPtr, BufferLength, StringLengthPtr); return SQL_SUCCESS; } #if 0 /* not clear yet what to return here */ case SQL_DIAG_MESSAGE_TEXT: { /* SQLCHAR* */ char msg[1024]; snprintf(msg, sizeof(msg), ""); copyDiagString(msg, DiagInfoPtr, BufferLength, StringLengthPtr); return SQL_SUCCESS; } #endif case SQL_DIAG_NATIVE: /* SQLINTEGER */ *(SQLINTEGER *) DiagInfoPtr = getNativeErrorCode(err); return SQL_SUCCESS; case SQL_DIAG_ROW_NUMBER: /* SQLLEN */ if (HandleType != SQL_HANDLE_STMT) return SQL_ERROR; *(SQLLEN *) DiagInfoPtr = SQL_ROW_NUMBER_UNKNOWN; return SQL_SUCCESS; case SQL_DIAG_SERVER_NAME:{ /* SQLCHAR* */ char *msg = dbc && dbc->Connected && dbc->dsn ? dbc->dsn : ""; copyDiagString(msg, DiagInfoPtr, BufferLength, StringLengthPtr); return SQL_SUCCESS; } case SQL_DIAG_SQLSTATE:{ /* SQLCHAR* */ char *msg = getSqlState(err); copyDiagString(msg, DiagInfoPtr, BufferLength, StringLengthPtr); return SQL_SUCCESS; } case SQL_DIAG_SUBCLASS_ORIGIN:{ /* SQLCHAR* */ char *state = getSqlState(err); char *msg; if (('0' <= state[0] && state[0] <= '4') || ('A' <= state[0] && state[0] <= 'H')) msg = "ISO 9075"; /* defined by standard */ else msg = "ODBC 3.0"; /* effectively just "IM" */ copyDiagString(msg, DiagInfoPtr, BufferLength, StringLengthPtr); return SQL_SUCCESS; } } /* Currently no Diagnostic Fields are supported. Hence we always return NO_DATA */ return SQL_NO_DATA; }