SQLRETURN SQL_API
SQLGetStmtAttr(SQLHSTMT StatementHandle,
SQLINTEGER Attribute,
SQLPOINTER ValuePtr,
SQLINTEGER BufferLength,
SQLINTEGER *StringLengthPtr)
{
#ifdef ODBCDEBUG
ODBCLOG("SQLGetStmtAttr " PTRFMT " %s " PTRFMT " %d " PTRFMT "\n",
PTRFMTCAST StatementHandle, translateStmtAttribute(Attribute),
PTRFMTCAST ValuePtr, (int) BufferLength,
PTRFMTCAST StringLengthPtr);
#endif
if (!isValidStmt((ODBCStmt *) StatementHandle))
return SQL_INVALID_HANDLE;
clearStmtErrors((ODBCStmt *) StatementHandle);
return MNDBGetStmtAttr((ODBCStmt *) StatementHandle,
Attribute,
ValuePtr,
BufferLength,
StringLengthPtr);
}
SQLRETURN SQL_API
SQLColAttributes(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber,
SQLUSMALLINT FieldIdentifier,
SQLPOINTER CharacterAttributePtr,
SQLSMALLINT BufferLength,
SQLSMALLINT *StringLengthPtr,
SQLLEN *NumericAttributePtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLColAttributes " PTRFMT " %u %s\n",
PTRFMTCAST StatementHandle,
(unsigned int) ColumnNumber,
translateFieldIdentifier(FieldIdentifier));
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
return SQLColAttributes_(stmt,
ColumnNumber,
FieldIdentifier,
CharacterAttributePtr,
BufferLength,
StringLengthPtr,
NumericAttributePtr);
}
SQLRETURN SQL_API
SQLRowCount(SQLHSTMT StatementHandle,
SQLLEN *RowCountPtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLRowCount " PTRFMT "\n", PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
/* check statement cursor state, query should be executed */
if (stmt->State < EXECUTED0) {
/* Function sequence error */
addStmtError(stmt, "HY010", NULL, 0);
return SQL_ERROR;
}
/* check output parameter */
if (RowCountPtr == NULL) {
/* Invalid use of null pointer */
addStmtError(stmt, "HY009", NULL, 0);
return SQL_ERROR;
}
/* We can now set the "number of result set rows" value */
*RowCountPtr = (SQLLEN) stmt->rowcount;
return SQL_SUCCESS;
}
SQLRETURN SQL_API
SQLNumResultCols(SQLHSTMT StatementHandle,
SQLSMALLINT *ColumnCountPtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLNumResultCols " PTRFMT "\n", PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
/* check statement cursor state, query should be prepared or executed */
if (stmt->State == INITED) {
/* Function sequence error */
addStmtError(stmt, "HY010", NULL, 0);
return SQL_ERROR;
}
/* check output parameter */
if (ColumnCountPtr == NULL) {
/* Invalid use of null pointer */
addStmtError(stmt, "HY009", NULL, 0);
return SQL_ERROR;
}
/* We can now set the "number of output columns" value */
/* Note: row count can be 0 (for non SELECT queries) */
*ColumnCountPtr = stmt->ImplRowDescr->sql_desc_count;
return SQL_SUCCESS;
}
SQLRETURN SQL_API
SQLColumns(SQLHSTMT StatementHandle,
SQLCHAR *CatalogName,
SQLSMALLINT NameLength1,
SQLCHAR *SchemaName,
SQLSMALLINT NameLength2,
SQLCHAR *TableName,
SQLSMALLINT NameLength3,
SQLCHAR *ColumnName,
SQLSMALLINT NameLength4)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLColumns " PTRFMT, PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
return MNDBColumns(stmt,
CatalogName, NameLength1,
SchemaName, NameLength2,
TableName, NameLength3,
ColumnName, NameLength4);
}
SQLRETURN SQL_API
SQLColAttribute(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber,
SQLUSMALLINT FieldIdentifier,
SQLPOINTER CharacterAttributePtr,
SQLSMALLINT BufferLength,
SQLSMALLINT *StringLengthPtr,
LENP_OR_POINTER_T NumericAttributePtr)
{
#ifdef ODBCDEBUG
ODBCLOG("SQLColAttribute " PTRFMT " %s\n",
PTRFMTCAST StatementHandle,
translateFieldIdentifier(FieldIdentifier));
#endif
if (!isValidStmt((ODBCStmt *) StatementHandle))
return SQL_INVALID_HANDLE;
clearStmtErrors((ODBCStmt *) StatementHandle);
return SQLColAttribute_((ODBCStmt *) StatementHandle,
ColumnNumber,
FieldIdentifier,
CharacterAttributePtr,
BufferLength,
StringLengthPtr,
NumericAttributePtr);
}
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
SQLExtendedFetch(SQLHSTMT StatementHandle,
SQLUSMALLINT FetchOrientation,
SQLLEN FetchOffset,
#ifdef BUILD_REAL_64_BIT_MODE /* note: only defined on Debian Lenny */
SQLUINTEGER *RowCountPtr,
#else
SQLULEN *RowCountPtr,
#endif
SQLUSMALLINT *RowStatusArray)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
SQLRETURN rc;
#ifdef ODBCDEBUG
ODBCLOG("SQLExtendedFetch " PTRFMT " %s " LENFMT " " PTRFMT " " PTRFMT "\n",
PTRFMTCAST StatementHandle,
translateFetchOrientation(FetchOrientation),
LENCAST FetchOffset, PTRFMTCAST RowCountPtr,
PTRFMTCAST RowStatusArray);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
/* check statement cursor state, query should be executed */
if (stmt->State < EXECUTED0 || stmt->State == FETCHED) {
/* Function sequence error */
addStmtError(stmt, "HY010", NULL, 0);
return SQL_ERROR;
}
if (stmt->State == EXECUTED0) {
/* Invalid cursor state */
addStmtError(stmt, "24000", NULL, 0);
return SQL_ERROR;
}
rc = MNDBFetchScroll(stmt, FetchOrientation, FetchOffset,
RowStatusArray);
if (SQL_SUCCEEDED(rc) || rc == SQL_NO_DATA)
stmt->State = EXTENDEDFETCHED;
if (SQL_SUCCEEDED(rc) && RowCountPtr) {
#ifdef BUILD_REAL_64_BIT_MODE /* note: only defined on Debian Lenny */
WriteValue(RowCountPtr, (SQLUINTEGER) stmt->rowSetSize);
#else
WriteValue(RowCountPtr, (SQLULEN) stmt->rowSetSize);
#endif
}
return rc;
}
SQLRETURN SQL_API
SQLGetStmtOption(SQLHSTMT StatementHandle,
SQLUSMALLINT Option,
SQLPOINTER ValuePtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
SQLULEN v;
SQLRETURN r;
#ifdef ODBCDEBUG
ODBCLOG("SQLGetStmtOption " PTRFMT " %s " PTRFMT "\n",
PTRFMTCAST StatementHandle, translateStmtOption(Option),
PTRFMTCAST ValuePtr);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
/* only the ODBC 1.0 and ODBC 2.0 options */
switch (Option) {
case SQL_ASYNC_ENABLE:
case SQL_CONCURRENCY:
case SQL_CURSOR_TYPE:
case SQL_NOSCAN:
case SQL_QUERY_TIMEOUT:
case SQL_RETRIEVE_DATA:
case SQL_SIMULATE_CURSOR:
case SQL_USE_BOOKMARKS:
case SQL_ROW_NUMBER:
/* SQLGetStmtAttr returns 64 bit value, but we need to
* return 32 bit value */
r = MNDBGetStmtAttr(stmt, Option, &v, 0, NULL);
if (SQL_SUCCEEDED(r))
WriteData(ValuePtr, (SQLUINTEGER) v, SQLUINTEGER);
return r;
case SQL_BIND_TYPE:
case SQL_KEYSET_SIZE:
case SQL_MAX_LENGTH:
case SQL_MAX_ROWS:
case SQL_ROWSET_SIZE:
/* case SQL_GET_BOOKMARKS: is deprecated in ODBC 3.0+ */
/* use mapping as described in ODBC 3.0 SDK Help */
return MNDBGetStmtAttr(stmt, Option, ValuePtr, 0, NULL);
default:
/* Invalid attribute/option identifier */
addStmtError(stmt, "HY092", NULL, 0);
break;
}
return SQL_ERROR;
}
SQLRETURN SQL_API
SQLSpecialColumnsW(SQLHSTMT StatementHandle,
SQLUSMALLINT IdentifierType,
SQLWCHAR *CatalogName,
SQLSMALLINT NameLength1,
SQLWCHAR *SchemaName,
SQLSMALLINT NameLength2,
SQLWCHAR *TableName,
SQLSMALLINT NameLength3,
SQLUSMALLINT Scope,
SQLUSMALLINT Nullable)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
SQLRETURN rc = SQL_ERROR;
SQLCHAR *catalog = NULL, *schema = NULL, *table = NULL;
#ifdef ODBCDEBUG
ODBCLOG("SQLSpecialColumnsW %p %s ",
StatementHandle,
translateIdentifierType(IdentifierType));
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
fixWcharIn(CatalogName, NameLength1, SQLCHAR, catalog,
addStmtError, stmt, goto bailout);
fixWcharIn(SchemaName, NameLength2, SQLCHAR, schema,
addStmtError, stmt, goto bailout);
fixWcharIn(TableName, NameLength3, SQLCHAR, table,
addStmtError, stmt, goto bailout);
rc = MNDBSpecialColumns(stmt,
IdentifierType,
catalog, SQL_NTS,
schema, SQL_NTS,
table, SQL_NTS,
Scope,
Nullable);
bailout:
if (catalog)
free(catalog);
if (schema)
free(schema);
if (table)
free(table);
return rc;
}
SQLRETURN SQL_API
SQLColumnsW(SQLHSTMT StatementHandle,
SQLWCHAR *CatalogName,
SQLSMALLINT NameLength1,
SQLWCHAR *SchemaName,
SQLSMALLINT NameLength2,
SQLWCHAR *TableName,
SQLSMALLINT NameLength3,
SQLWCHAR *ColumnName,
SQLSMALLINT NameLength4)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
SQLCHAR *catalog = NULL, *schema = NULL, *table = NULL, *column = NULL;
SQLRETURN rc = SQL_ERROR;
#ifdef ODBCDEBUG
ODBCLOG("SQLColumnsW " PTRFMT, PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
fixWcharIn(CatalogName, NameLength1, SQLCHAR, catalog,
addStmtError, stmt, goto exit);
fixWcharIn(SchemaName, NameLength2, SQLCHAR, schema,
addStmtError, stmt, goto exit);
fixWcharIn(TableName, NameLength3, SQLCHAR, table,
addStmtError, stmt, goto exit);
fixWcharIn(ColumnName, NameLength4, SQLCHAR, column,
addStmtError, stmt, goto exit);
rc = SQLColumns_(stmt,
catalog, SQL_NTS,
schema, SQL_NTS,
table, SQL_NTS,
column, SQL_NTS);
exit:
if (catalog)
free(catalog);
if (schema)
free(schema);
if (table)
free(table);
if (column)
free(column);
return rc;
}
SQLRETURN SQL_API
SQLSetStmtOption(SQLHSTMT StatementHandle,
SQLUSMALLINT Option,
SQLULEN ValuePtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLSetStmtOption " PTRFMT " %s " ULENFMT "\n",
PTRFMTCAST StatementHandle, translateStmtOption(Option),
ULENCAST ValuePtr);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
switch (Option) {
/* only the ODBC 1.0 and ODBC 2.0 options */
case SQL_ROWSET_SIZE:
Option = SQL_ATTR_ROW_ARRAY_SIZE;
/* fall through */
case SQL_QUERY_TIMEOUT:
case SQL_MAX_ROWS:
case SQL_NOSCAN:
case SQL_MAX_LENGTH:
case SQL_ASYNC_ENABLE:
case SQL_BIND_TYPE:
case SQL_CURSOR_TYPE:
case SQL_CONCURRENCY:
case SQL_KEYSET_SIZE:
case SQL_SIMULATE_CURSOR:
case SQL_RETRIEVE_DATA:
case SQL_USE_BOOKMARKS:
/* use mapping as described in ODBC 3.0 SDK Help */
return MNDBSetStmtAttr(stmt,
Option,
(SQLPOINTER) (uintptr_t) ValuePtr,
SQL_NTS);
default:
/* Invalid attribute/option identifier */
addStmtError(stmt, "HY092", NULL, 0);
break;
}
return SQL_ERROR;
}
SQLRETURN SQL_API
SQLFreeStmt(SQLHSTMT StatementHandle,
SQLUSMALLINT Option)
{
#ifdef ODBCDEBUG
ODBCLOG("SQLFreeStmt " PTRFMT " %s\n",
PTRFMTCAST StatementHandle, translateOption(Option));
#endif
if (!isValidStmt((ODBCStmt *) StatementHandle))
return SQL_INVALID_HANDLE;
clearStmtErrors((ODBCStmt *) StatementHandle);
return SQLFreeStmt_((ODBCStmt *) StatementHandle, Option);
}
SQLRETURN SQL_API
SQLBulkOperations(SQLHSTMT StatementHandle,
SQLSMALLINT Operation)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLBulkOperations " PTRFMT " %s\n",
PTRFMTCAST StatementHandle, translateOperation(Operation));
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
if (stmt->State < EXECUTED0 || stmt->State == EXTENDEDFETCHED) {
/* Function sequence error */
addStmtError(stmt, "HY010", NULL, 0);
return SQL_ERROR;
}
if (stmt->State == EXECUTED0) {
/* Invalid cursor state */
addStmtError(stmt, "24000", NULL, 0);
return SQL_ERROR;
}
/* check Operation code */
switch (Operation) {
case SQL_ADD:
case SQL_UPDATE_BY_BOOKMARK:
case SQL_DELETE_BY_BOOKMARK:
case SQL_FETCH_BY_BOOKMARK:
break;
default:
/* Invalid attribute/option identifier */
addStmtError(stmt, "HY092", NULL, 0);
return SQL_ERROR;
}
/* TODO: finish implementation */
/* Driver does not support this function */
addStmtError(stmt, "IM001", NULL, 0);
return SQL_ERROR;
}
SQLRETURN SQL_API
SQLCancel(SQLHSTMT StatementHandle)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLCancel " PTRFMT "\n", PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
if (stmt->Dbc->Env->sql_attr_odbc_version == SQL_OV_ODBC2)
return MNDBFreeStmt(stmt, SQL_CLOSE);
return SQL_SUCCESS;
}
SQLRETURN SQL_API
SQLGetTypeInfoW(SQLHSTMT StatementHandle,
SQLSMALLINT DataType)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLGetTypeInfoW " PTRFMT " %s\n",
PTRFMTCAST StatementHandle, translateDataType(DataType));
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
return MNDBGetTypeInfo(stmt, DataType);
}
SQLRETURN SQL_API
SQLProceduresW(SQLHSTMT StatementHandle,
SQLWCHAR *CatalogName, SQLSMALLINT NameLength1,
SQLWCHAR *SchemaName, SQLSMALLINT NameLength2,
SQLWCHAR *ProcName, SQLSMALLINT NameLength3)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
SQLRETURN rc = SQL_ERROR;
SQLCHAR *catalog = NULL, *schema = NULL, *proc = NULL;
#ifdef ODBCDEBUG
ODBCLOG("SQLProceduresW " PTRFMT " ", PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
fixWcharIn(CatalogName, NameLength1, SQLCHAR, catalog,
addStmtError, stmt, goto exit);
fixWcharIn(SchemaName, NameLength2, SQLCHAR, schema,
addStmtError, stmt, goto exit);
fixWcharIn(ProcName, NameLength3, SQLCHAR, proc,
addStmtError, stmt, goto exit);
rc = MNDBProcedures(stmt,
catalog, SQL_NTS,
schema, SQL_NTS,
proc, SQL_NTS);
exit:
if (catalog)
free(catalog);
if (schema)
free(schema);
if (proc)
free(proc);
return rc;
}
SQLRETURN SQL_API
SQLDescribeCol(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber,
SQLCHAR *ColumnName,
SQLSMALLINT BufferLength,
SQLSMALLINT *NameLengthPtr,
SQLSMALLINT *DataTypePtr,
SQLULEN *ColumnSizePtr,
SQLSMALLINT *DecimalDigitsPtr,
SQLSMALLINT *NullablePtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLDescribeCol " PTRFMT " %u " PTRFMT " %d " PTRFMT " " PTRFMT " " PTRFMT " " PTRFMT " " PTRFMT "\n",
PTRFMTCAST StatementHandle, (unsigned int) ColumnNumber,
PTRFMTCAST ColumnName, (int) BufferLength,
PTRFMTCAST NameLengthPtr, PTRFMTCAST DataTypePtr,
PTRFMTCAST ColumnSizePtr, PTRFMTCAST DecimalDigitsPtr,
PTRFMTCAST NullablePtr);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
return MNDBDescribeCol(stmt,
ColumnNumber,
ColumnName,
BufferLength,
NameLengthPtr,
DataTypePtr,
ColumnSizePtr,
DecimalDigitsPtr,
NullablePtr);
}
SQLRETURN SQL_API
SQLParamData(SQLHSTMT StatementHandle,
SQLPOINTER *ValuePtrPtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLParamData " PTRFMT "\n", PTRFMTCAST StatementHandle);
#endif
(void) ValuePtrPtr; /* Stefan: unused!? */
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
/* TODO: implement this function and corresponding behavior */
/* Function sequence error */
addStmtError(stmt, "HY010", NULL, 0);
return SQL_ERROR;
}
SQLRETURN SQL_API
SQLGetData(SQLHSTMT StatementHandle,
SQLUSMALLINT Col_or_Param_Num,
SQLSMALLINT TargetType,
SQLPOINTER TargetValuePtr,
SQLLEN BufferLength,
SQLLEN *StrLen_or_IndPtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLGetData %p %u %s %p " LENFMT " %p\n",
StatementHandle, (unsigned int) Col_or_Param_Num,
translateCType(TargetType), TargetValuePtr,
LENCAST BufferLength, StrLen_or_IndPtr);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
assert(stmt->Dbc);
assert(stmt->Dbc->mid);
assert(stmt->hdl);
clearStmtErrors(stmt);
/* check statement cursor state, query should be executed */
if (stmt->State < EXECUTED0) {
/* Function sequence error */
addStmtError(stmt, "HY010", NULL, 0);
return SQL_ERROR;
}
if (stmt->State <= EXECUTED1) {
/* Invalid cursor state */
addStmtError(stmt, "24000", NULL, 0);
return SQL_ERROR;
}
if (stmt->rowSetSize == 0) {
/* SQLFetch failed */
/* General error */
addStmtError(stmt, "HY000", NULL, 0);
return SQL_ERROR;
}
if (stmt->rowSetSize > 1 &&
stmt->cursorType == SQL_CURSOR_FORWARD_ONLY) {
/* Invalid cursor position */
addStmtError(stmt, "HY109", NULL, 0);
return SQL_ERROR;
}
if (Col_or_Param_Num <= 0 ||
Col_or_Param_Num > stmt->ImplRowDescr->sql_desc_count) {
/* Invalid descriptor index */
addStmtError(stmt, "07009", NULL, 0);
return SQL_ERROR;
}
if (TargetValuePtr == NULL) {
/* Invalid use of null pointer */
addStmtError(stmt, "HY009", NULL, 0);
return SQL_ERROR;
}
if (Col_or_Param_Num != stmt->currentCol)
stmt->retrieved = 0;
stmt->currentCol = Col_or_Param_Num;
if (TargetType == SQL_ARD_TYPE) {
ODBCDesc *desc = stmt->ApplRowDescr;
if (Col_or_Param_Num > desc->sql_desc_count) {
/* Invalid descriptor index */
addStmtError(stmt, "07009", NULL, 0);
return SQL_ERROR;
}
TargetType = desc->descRec[Col_or_Param_Num].sql_desc_concise_type;
}
return ODBCFetch(stmt, Col_or_Param_Num, TargetType, TargetValuePtr,
BufferLength, StrLen_or_IndPtr, StrLen_or_IndPtr,
UNAFFECTED, UNAFFECTED, UNAFFECTED, 0, 0);
}
SQLRETURN SQL_API
SQLColAttributesW(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber,
SQLUSMALLINT FieldIdentifier,
SQLPOINTER CharacterAttributePtr,
SQLSMALLINT BufferLength,
SQLSMALLINT *StringLengthPtr,
SQLLEN *NumericAttributePtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
SQLPOINTER ptr;
SQLRETURN rc;
SQLSMALLINT n;
#ifdef ODBCDEBUG
ODBCLOG("SQLColAttributesW " PTRFMT " %u %s\n",
PTRFMTCAST StatementHandle,
(unsigned int) ColumnNumber,
translateFieldIdentifier(FieldIdentifier));
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
switch (FieldIdentifier) {
/* all string atributes */
case SQL_DESC_BASE_COLUMN_NAME:
case SQL_DESC_BASE_TABLE_NAME:
case SQL_DESC_CATALOG_NAME: /* SQL_COLUMN_QUALIFIER_NAME */
case SQL_DESC_LABEL: /* SQL_COLUMN_LABEL */
case SQL_DESC_LITERAL_PREFIX:
case SQL_DESC_LITERAL_SUFFIX:
case SQL_DESC_LOCAL_TYPE_NAME:
case SQL_DESC_NAME:
case SQL_DESC_SCHEMA_NAME: /* SQL_COLUMN_OWNER_NAME */
case SQL_DESC_TABLE_NAME: /* SQL_COLUMN_TABLE_NAME */
case SQL_DESC_TYPE_NAME: /* SQL_COLUMN_TYPE_NAME */
rc = SQLColAttributes_(stmt, ColumnNumber, FieldIdentifier,
NULL, 0, &n, NumericAttributePtr);
if (!SQL_SUCCEEDED(rc))
return rc;
clearStmtErrors(stmt);
n++; /* account for NUL byte */
ptr = (SQLPOINTER) malloc(n);
break;
default:
n = BufferLength;
ptr = CharacterAttributePtr;
break;
}
rc = SQLColAttributes_(stmt, ColumnNumber, FieldIdentifier, ptr,
n, &n, NumericAttributePtr);
if (ptr != CharacterAttributePtr) {
if (SQL_SUCCEEDED(rc)) {
fixWcharOut(rc, ptr, n, CharacterAttributePtr,
BufferLength, StringLengthPtr, 2,
addStmtError, stmt);
}
free(ptr);
} else if (StringLengthPtr)
*StringLengthPtr = n;
return rc;
}
SQLRETURN SQL_API
SQLSetPos(SQLHSTMT StatementHandle,
SQLSETPOSIROW RowNumber,
SQLUSMALLINT Operation,
SQLUSMALLINT LockType)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLSetPos " PTRFMT " " ULENFMT " %s %s\n",
PTRFMTCAST StatementHandle, ULENCAST RowNumber,
translateOperation(Operation), translateLockType(LockType));
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
/* check the parameter values */
if (stmt->State < EXECUTED0) {
/* Function sequence error */
addStmtError(stmt, "HY010", NULL, 0);
return SQL_ERROR;
}
if (stmt->State <= EXECUTED1) {
/* Invalid cursor state */
addStmtError(stmt, "24000", NULL, 0);
return SQL_ERROR;
}
if (RowNumber > (SQLSETPOSIROW) stmt->rowSetSize) {
/* Row value out of range */
addStmtError(stmt, "HY107", NULL, 0);
return SQL_ERROR;
}
if (stmt->cursorType == SQL_CURSOR_FORWARD_ONLY) {
/* Invalid cursor position */
addStmtError(stmt, "HY109", NULL, 0);
return SQL_ERROR;
}
switch (LockType) {
case SQL_LOCK_NO_CHANGE:
/* the only value that we support */
break;
case SQL_LOCK_EXCLUSIVE:
case SQL_LOCK_UNLOCK:
/* Optional feature not implemented */
addStmtError(stmt, "HYC00", NULL, 0);
return SQL_ERROR;
default:
/* Invalid attribute/option identifier */
addStmtError(stmt, "HY092", NULL, 0);
return SQL_ERROR;
}
switch (Operation) {
case SQL_POSITION:
if (RowNumber == 0) {
/* Invalid cursor position */
addStmtError(stmt, "HY109", NULL, 0);
return SQL_ERROR;
}
if (mapi_seek_row(stmt->hdl, stmt->startRow + RowNumber - 1,
MAPI_SEEK_SET) != MOK) {
/* Invalid cursor position */
addStmtError(stmt, "HY109", NULL, 0);
return SQL_ERROR;
}
stmt->currentRow = stmt->startRow + RowNumber - 1;
switch (mapi_fetch_row(stmt->hdl)) {
case MOK:
break;
case MTIMEOUT:
/* Connection timeout expired */
addStmtError(stmt, "HYT01", NULL, 0);
return SQL_ERROR;
default:
/* Invalid cursor position */
addStmtError(stmt, "HY109", NULL, 0);
return SQL_ERROR;
}
stmt->currentRow++;
break;
case SQL_REFRESH:
case SQL_UPDATE:
case SQL_DELETE:
/* Optional feature not implemented */
addStmtError(stmt, "HYC00", NULL, 0);
return SQL_ERROR;
default:
/* Invalid attribute/option identifier */
addStmtError(stmt, "HY092", NULL, 0);
return SQL_ERROR;
}
return SQL_SUCCESS;
}
SQLRETURN SQL_API
SQLDescribeParam(SQLHSTMT StatementHandle,
SQLUSMALLINT ParameterNumber,
SQLSMALLINT *DataTypePtr,
SQLULEN *ParameterSizePtr,
SQLSMALLINT *DecimalDigitsPtr,
SQLSMALLINT *NullablePtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
ODBCDescRec *rec;
#ifdef ODBCDEBUG
ODBCLOG("SQLDescribeParam " PTRFMT " %u\n",
PTRFMTCAST StatementHandle, (unsigned int) ParameterNumber);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
/* check statement cursor state, query should be prepared or executed */
if (stmt->State == INITED || stmt->State >= EXECUTED0) {
/* Function sequence error */
addStmtError(stmt, "HY010", NULL, 0);
return SQL_ERROR;
}
if (ParameterNumber < 1 ||
ParameterNumber > stmt->ImplParamDescr->sql_desc_count) {
/* Invalid descriptor index */
addStmtError(stmt, "07009", NULL, 0);
return SQL_ERROR;
}
rec = &stmt->ImplParamDescr->descRec[ParameterNumber];
if (DataTypePtr)
*DataTypePtr = rec->sql_desc_concise_type;
if (NullablePtr)
*NullablePtr = rec->sql_desc_nullable;
/* also see SQLDescribeCol */
if (ParameterSizePtr)
*ParameterSizePtr = ODBCLength(rec, SQL_DESC_LENGTH);
/* also see SQLDescribeCol */
if (DecimalDigitsPtr) {
switch (rec->sql_desc_concise_type) {
case SQL_DECIMAL:
case SQL_NUMERIC:
*DecimalDigitsPtr = rec->sql_desc_scale;
break;
case SQL_BIT:
case SQL_TINYINT:
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_BIGINT:
*DecimalDigitsPtr = 0;
break;
case SQL_TYPE_TIME:
case SQL_TYPE_TIMESTAMP:
case SQL_INTERVAL_SECOND:
case SQL_INTERVAL_DAY_TO_SECOND:
case SQL_INTERVAL_HOUR_TO_SECOND:
case SQL_INTERVAL_MINUTE_TO_SECOND:
*DecimalDigitsPtr = rec->sql_desc_precision;
break;
}
}
return SQL_SUCCESS;
}
SQLRETURN SQL_API
SQLForeignKeysW(SQLHSTMT StatementHandle,
SQLWCHAR *PKCatalogName,
SQLSMALLINT NameLength1,
SQLWCHAR *PKSchemaName,
SQLSMALLINT NameLength2,
SQLWCHAR *PKTableName,
SQLSMALLINT NameLength3,
SQLWCHAR *FKCatalogName,
SQLSMALLINT NameLength4,
SQLWCHAR *FKSchemaName,
SQLSMALLINT NameLength5,
SQLWCHAR *FKTableName,
SQLSMALLINT NameLength6)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
SQLCHAR *PKcatalog = NULL, *PKschema = NULL, *PKtable = NULL;
SQLCHAR *FKcatalog = NULL, *FKschema = NULL, *FKtable = NULL;
SQLRETURN rc = SQL_ERROR;
#ifdef ODBCDEBUG
ODBCLOG("SQLForeignKeysW " PTRFMT " ", PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
fixWcharIn(PKCatalogName, NameLength1, SQLCHAR,
PKcatalog, addStmtError, stmt, goto exit);
fixWcharIn(PKSchemaName, NameLength2, SQLCHAR,
PKschema, addStmtError, stmt, goto exit);
fixWcharIn(PKTableName, NameLength3, SQLCHAR,
PKtable, addStmtError, stmt, goto exit);
fixWcharIn(FKCatalogName, NameLength4, SQLCHAR,
FKcatalog, addStmtError, stmt, goto exit);
fixWcharIn(FKSchemaName, NameLength5, SQLCHAR,
FKschema, addStmtError, stmt, goto exit);
fixWcharIn(FKTableName, NameLength6, SQLCHAR,
FKtable, addStmtError, stmt, goto exit);
rc = SQLForeignKeys_(stmt, PKcatalog, SQL_NTS, PKschema, SQL_NTS,
PKtable, SQL_NTS, FKcatalog, SQL_NTS,
FKschema, SQL_NTS, FKtable, SQL_NTS);
exit:
if (PKcatalog)
free(PKcatalog);
if (PKschema)
free(PKschema);
if (PKtable)
free(PKtable);
if (FKcatalog)
free(FKcatalog);
if (FKschema)
free(FKschema);
if (FKtable)
free(FKtable);
return rc;
}
SQLRETURN SQL_API
SQLBindCol(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber,
SQLSMALLINT TargetType,
SQLPOINTER TargetValuePtr,
SQLLEN BufferLength,
SQLLEN *StrLen_or_Ind)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
ODBCDesc *desc; /* Application Row Descriptor */
#ifdef ODBCDEBUG
ODBCLOG("SQLBindCol " PTRFMT " %u %s " LENFMT "\n",
PTRFMTCAST StatementHandle, (unsigned int) ColumnNumber,
translateCType(TargetType), LENCAST BufferLength);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
assert(stmt->Dbc);
clearStmtErrors(stmt);
/* check input parameters */
/* column number 0 (Bookmark column) is not supported */
if (ColumnNumber == 0) {
if (TargetType == SQL_C_BOOKMARK || TargetType == SQL_C_VARBOOKMARK) {
/* Optional feature not implemented */
addStmtError(stmt, "HYC00", NULL, 0);
} else {
/* Restricted data type attribute violation */
addStmtError(stmt, "07006", NULL, 0);
}
return SQL_ERROR;
}
if (stmt->State >= EXECUTED1 && ColumnNumber > stmt->ImplRowDescr->sql_desc_count) {
/* Invalid descriptor index */
addStmtError(stmt, "07009", NULL, 0);
return SQL_ERROR;
}
/* For safety: limit the maximum number of columns to bind */
if (ColumnNumber > MONETDB_MAX_BIND_COLS) {
/* General error */
addStmtError(stmt, "HY000", "Maximum number of bind columns (8192) exceeded", 0);
return SQL_ERROR;
}
/* can't let SQLSetDescField below do this check since it
returns the wrong error code if the type is incorrect */
switch (TargetType) {
case SQL_C_CHAR:
case SQL_C_WCHAR:
case SQL_C_BINARY:
case SQL_C_BIT:
case SQL_C_STINYINT:
case SQL_C_UTINYINT:
case SQL_C_TINYINT:
case SQL_C_SSHORT:
case SQL_C_USHORT:
case SQL_C_SHORT:
case SQL_C_SLONG:
case SQL_C_ULONG:
case SQL_C_LONG:
case SQL_C_SBIGINT:
case SQL_C_UBIGINT:
case SQL_C_NUMERIC:
case SQL_C_FLOAT:
case SQL_C_DOUBLE:
case SQL_C_TYPE_DATE:
case SQL_C_TYPE_TIME:
case SQL_C_TYPE_TIMESTAMP:
case SQL_C_INTERVAL_YEAR:
case SQL_C_INTERVAL_MONTH:
case SQL_C_INTERVAL_YEAR_TO_MONTH:
case SQL_C_INTERVAL_DAY:
case SQL_C_INTERVAL_HOUR:
case SQL_C_INTERVAL_MINUTE:
case SQL_C_INTERVAL_SECOND:
case SQL_C_INTERVAL_DAY_TO_HOUR:
case SQL_C_INTERVAL_DAY_TO_MINUTE:
case SQL_C_INTERVAL_DAY_TO_SECOND:
case SQL_C_INTERVAL_HOUR_TO_MINUTE:
case SQL_C_INTERVAL_HOUR_TO_SECOND:
case SQL_C_INTERVAL_MINUTE_TO_SECOND:
case SQL_C_GUID:
case SQL_C_DEFAULT:
break;
default:
/* Invalid application buffer type */
addStmtError(stmt, "HY003", NULL, 0);
return SQL_ERROR;
}
if (BufferLength < 0) {
/* Invalid string or buffer length */
addStmtError(stmt, "HY090", NULL, 0);
return SQL_ERROR;
}
desc = stmt->ApplRowDescr;
if (TargetValuePtr == NULL && ColumnNumber == desc->sql_desc_count) {
int i = desc->sql_desc_count - 1;
while (i > 0 && desc->descRec[i].sql_desc_data_ptr == NULL)
i--;
setODBCDescRecCount(desc, i);
} else {
ODBCDescRec *rec;
SQLRETURN rc;
if (ColumnNumber > desc->sql_desc_count)
setODBCDescRecCount(desc, ColumnNumber);
rc = SQLSetDescField_(desc, ColumnNumber, SQL_DESC_CONCISE_TYPE, (SQLPOINTER) (ssize_t) TargetType, 0);
if (!SQL_SUCCEEDED(rc))
return rc;
rec = &desc->descRec[ColumnNumber];
rec->sql_desc_octet_length = BufferLength;
rec->sql_desc_data_ptr = TargetValuePtr;
rec->sql_desc_indicator_ptr = StrLen_or_Ind;
rec->sql_desc_octet_length_ptr = StrLen_or_Ind;
}
return SQL_SUCCESS;
}
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;
}