SQLRETURN SQL_API
SQLForeignKeys(SQLHSTMT StatementHandle,
SQLCHAR *PKCatalogName,
SQLSMALLINT NameLength1,
SQLCHAR *PKSchemaName,
SQLSMALLINT NameLength2,
SQLCHAR *PKTableName,
SQLSMALLINT NameLength3,
SQLCHAR *FKCatalogName,
SQLSMALLINT NameLength4,
SQLCHAR *FKSchemaName,
SQLSMALLINT NameLength5,
SQLCHAR *FKTableName,
SQLSMALLINT NameLength6)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLForeignKeys " PTRFMT " ", PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
return SQLForeignKeys_(stmt, PKCatalogName, NameLength1,
PKSchemaName, NameLength2,
PKTableName, NameLength3,
FKCatalogName, NameLength4,
FKSchemaName, NameLength5,
FKTableName, NameLength6);
}
SQLRETURN SQL_API
SQLRowCount(SQLHSTMT StatementHandle,
SQLLEN *RowCountPtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLRowCount %p\n", 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
SQLSpecialColumns(SQLHSTMT StatementHandle,
SQLUSMALLINT IdentifierType,
SQLCHAR *CatalogName,
SQLSMALLINT NameLength1,
SQLCHAR *SchemaName,
SQLSMALLINT NameLength2,
SQLCHAR *TableName,
SQLSMALLINT NameLength3,
SQLUSMALLINT Scope,
SQLUSMALLINT Nullable)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLSpecialColumns %p %s ",
StatementHandle,
translateIdentifierType(IdentifierType));
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
return MNDBSpecialColumns(stmt,
IdentifierType,
CatalogName, NameLength1,
SchemaName, NameLength2,
TableName, NameLength3,
Scope,
Nullable);
}
SQLRETURN SQL_API
SQLFetchScroll(SQLHSTMT StatementHandle,
SQLSMALLINT FetchOrientation,
SQLLEN FetchOffset)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLFetchScroll %p %s " LENFMT "\n",
StatementHandle,
translateFetchOrientation(FetchOrientation),
LENCAST FetchOffset);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
/* check statement cursor state, query should be executed */
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;
}
return MNDBFetchScroll(stmt, FetchOrientation, FetchOffset,
stmt->ImplRowDescr->sql_desc_array_status_ptr);
}
SQLRETURN SQL_API
SQLFetch(SQLHSTMT StatementHandle)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLFetch " PTRFMT "\n", PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
assert(stmt->hdl);
/* check statement cursor state, query should be executed */
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;
}
stmt->startRow += stmt->rowSetSize;
return MNDBFetch(stmt, stmt->ImplRowDescr->sql_desc_array_status_ptr);
}
SQLRETURN SQL_API
SQLSetScrollOptions(SQLHSTMT StatementHandle,
SQLUSMALLINT fConcurrency,
SQLLEN crowKeyset,
SQLUSMALLINT crowRowset)
{
#ifdef ODBCDEBUG
ODBCLOG("SQLSetScrollOptions " PTRFMT " %u " LENFMT " %u\n",
PTRFMTCAST StatementHandle, (unsigned int) fConcurrency,
LENCAST crowKeyset, (unsigned int) crowRowset);
#endif
(void) fConcurrency; /* Stefan: unused!? */
(void) crowKeyset; /* Stefan: unused!? */
(void) crowRowset; /* Stefan: unused!? */
if (!isValidStmt((ODBCStmt *) StatementHandle))
return SQL_INVALID_HANDLE;
clearStmtErrors((ODBCStmt *) StatementHandle);
/* TODO: implement the mapping to multiple SQLSetStmtAttr() calls */
/* See ODBC 3.5 SDK Help file for details */
/* for now return error */
/* Driver does not support this function */
addStmtError((ODBCStmt *) StatementHandle, "IM001", NULL, 0);
return SQL_ERROR;
}
SQLRETURN SQL_API
SQLProcedures(SQLHSTMT StatementHandle,
SQLCHAR *CatalogName,
SQLSMALLINT NameLength1,
SQLCHAR *SchemaName,
SQLSMALLINT NameLength2,
SQLCHAR *ProcName,
SQLSMALLINT NameLength3)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
#ifdef ODBCDEBUG
ODBCLOG("SQLProcedures " PTRFMT " ", PTRFMTCAST StatementHandle);
#endif
if (!isValidStmt(stmt))
return SQL_INVALID_HANDLE;
clearStmtErrors(stmt);
return MNDBProcedures(stmt,
CatalogName, NameLength1,
SchemaName, NameLength2,
ProcName, NameLength3);
}
SQLRETURN SQL_API
SQLGetStmtAttrW(SQLHSTMT StatementHandle,
SQLINTEGER Attribute,
SQLPOINTER ValuePtr,
SQLINTEGER BufferLength,
SQLINTEGER *StringLengthPtr)
{
#ifdef ODBCDEBUG
ODBCLOG("SQLGetStmtAttrW " 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);
/* there are no string-valued attributes */
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
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 SQLColumns_(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 SQL_API
SQLDescribeColW(SQLHSTMT StatementHandle,
SQLUSMALLINT ColumnNumber,
SQLWCHAR *ColumnName,
SQLSMALLINT BufferLength,
SQLSMALLINT *NameLengthPtr,
SQLSMALLINT *DataTypePtr,
SQLULEN *ColumnSizePtr,
SQLSMALLINT *DecimalDigitsPtr,
SQLSMALLINT *NullablePtr)
{
ODBCStmt *stmt = (ODBCStmt *) StatementHandle;
SQLCHAR *colname;
SQLSMALLINT n;
SQLRETURN rc = SQL_ERROR;
#ifdef ODBCDEBUG
ODBCLOG("SQLDescribeColW " 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);
rc = MNDBDescribeCol(stmt, ColumnNumber, NULL, 0, &n, DataTypePtr,
ColumnSizePtr, DecimalDigitsPtr, NullablePtr);
if (!SQL_SUCCEEDED(rc))
return rc;
clearStmtErrors(stmt);
n++; /* account for NUL byte */
colname = malloc(n);
if (colname == NULL) {
/* Memory allocation error */
addStmtError(stmt, "HY001", NULL, 0);
return SQL_ERROR;
}
rc = MNDBDescribeCol(stmt,
ColumnNumber,
colname,
n,
&n,
DataTypePtr,
ColumnSizePtr,
DecimalDigitsPtr,
NullablePtr);
if (SQL_SUCCEEDED(rc)) {
fixWcharOut(rc, colname, n, ColumnName, BufferLength,
NameLengthPtr, 1, addStmtError, stmt);
}
free(colname);
return rc;
}
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;
}
/*
* Creates and adds an error msg object to the end of the error list of
* this ODBCStmt struct.
* When the errMsg is NULL and the SQLState is an ISO SQLState the
* standard ISO message text for the SQLState is used as message.
*
* Precondition: stmt must be valid. SQLState and errMsg may be NULL.
*/
void
addStmtError(ODBCStmt *stmt, const char *SQLState, const char *errMsg, int nativeErrCode)
{
ODBCError *error = NULL;
#ifdef ODBCDEBUG
ODBCLOG("addStmtError " PTRFMT " %s %s %d\n", PTRFMTCAST stmt, SQLState, errMsg ? errMsg : getStandardSQLStateMsg(SQLState), nativeErrCode);
#endif
assert(isValidStmt(stmt));
error = newODBCError(SQLState, errMsg, nativeErrCode);
appendODBCError(&stmt->Error, error);
}
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
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
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
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;
}
/*
* Destroys the ODBCStmt object including its own managed data.
*
* Precondition: stmt must be valid.
* Postcondition: stmt is completely destroyed, stmt handle is invalid.
*/
void
destroyODBCStmt(ODBCStmt *stmt)
{
ODBCStmt **stmtp;
assert(isValidStmt(stmt));
/* first set this object to invalid */
stmt->Type = 0;
/* remove this stmt from the dbc */
assert(stmt->Dbc);
assert(stmt->Dbc->FirstStmt);
/* search for stmt in linked list */
stmtp = &stmt->Dbc->FirstStmt;
while (*stmtp && *stmtp != stmt)
stmtp = &(*stmtp)->next;
/* stmtp points to location in list where stmt is found */
assert(*stmtp == stmt); /* we must have found it */
/* now remove it from the linked list */
*stmtp = stmt->next;
/* cleanup own managed data */
deleteODBCErrorList(&stmt->Error);
destroyODBCDesc(stmt->ImplParamDescr);
destroyODBCDesc(stmt->ImplRowDescr);
destroyODBCDesc(stmt->AutoApplParamDescr);
destroyODBCDesc(stmt->AutoApplRowDescr);
if (stmt->hdl)
mapi_close_handle(stmt->hdl);
free(stmt);
}
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
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;
}
/*
* Extracts an error object from the error list of this ODBCStmt struct.
* The error object itself is removed from the error list.
* The caller is now responsible for freeing the error object memory.
*
* Precondition: stmt and error must be valid
* Postcondition: returns a ODBCError object or null when no error is available.
*/
ODBCError *
getStmtError(ODBCStmt *stmt)
{
assert(isValidStmt(stmt));
return stmt->Error;
}
