RETCODE SQL_API OPENSEARCHAPI_SetConnectOption()

in sql-odbc/src/sqlodbc/options.c [263:421]

• 125 lines of code
• 42 McCabe index (conditional complexity)

RETCODE SQL_API OPENSEARCHAPI_SetConnectOption(HDBC hdbc, SQLUSMALLINT fOption,
                                       SQLULEN vParam) {
    CSTR func = "OPENSEARCHAPI_SetConnectOption";
    ConnectionClass *conn = (ConnectionClass *)hdbc;
    char changed = FALSE;
    RETCODE retval;
    BOOL autocomm_on;

    MYLOG(OPENSEARCH_TRACE, "entering fOption = %d vParam = " FORMAT_LEN "\n", fOption,
          vParam);
    if (!conn) {
        CC_log_error(func, "", NULL);
        return SQL_INVALID_HANDLE;
    }

    switch (fOption) {
        /*
         * Statement Options (apply to all stmts on the connection and
         * become defaults for new stmts)
         */
        case SQL_ASYNC_ENABLE:
        case SQL_BIND_TYPE:
        case SQL_CONCURRENCY:
        case SQL_CURSOR_TYPE:
        case SQL_KEYSET_SIZE:
        case SQL_MAX_LENGTH:
        case SQL_MAX_ROWS:
        case SQL_NOSCAN:
        case SQL_QUERY_TIMEOUT:
        case SQL_RETRIEVE_DATA:
        case SQL_ROWSET_SIZE:
        case SQL_SIMULATE_CURSOR:
        case SQL_USE_BOOKMARKS:
            /*
             * Become the default for all future statements on this
             * connection
             */
            retval = set_statement_option(conn, NULL, fOption, vParam);

            if (retval == SQL_SUCCESS_WITH_INFO)
                changed = TRUE;
            else if (retval == SQL_ERROR)
                return SQL_ERROR;

            break;

            /*
             * Connection Options
             */

        case SQL_ACCESS_MODE: /* ignored */
            break;

        case SQL_AUTOCOMMIT:
            switch (vParam) {
                case SQL_AUTOCOMMIT_ON:
                    autocomm_on = TRUE;
                    break;
                default:
                    CC_set_error(conn, CONN_INVALID_ARGUMENT_NO,
                                 "Illegal parameter value for SQL_AUTOCOMMIT. "
                                 "Turning SQL_AUTOCOMMIT off requires "
                                 "transactions, which are not supported.",
                                 func);
                    return SQL_ERROR;
            }
            if (autocomm_on && SQL_AUTOCOMMIT_OFF != conn->autocommit_public)
                break;
            else if (!autocomm_on
                     && SQL_AUTOCOMMIT_OFF == conn->autocommit_public)
                break;
            conn->autocommit_public =
                (autocomm_on ? SQL_AUTOCOMMIT_ON : SQL_AUTOCOMMIT_OFF);
            MYLOG(OPENSEARCH_DEBUG,
                  "AUTOCOMMIT: transact_status=%d, vparam=" FORMAT_LEN "\n",
                  conn->transact_status, vParam);

            CC_set_autocommit(conn, autocomm_on);
            break;

        case SQL_CURRENT_QUALIFIER: /* ignored */
            break;

        case SQL_LOGIN_TIMEOUT:
            conn->login_timeout = (SQLUINTEGER)vParam;
            break;

        case SQL_PACKET_SIZE: /* ignored */
            break;

        case SQL_QUIET_MODE: /* ignored */
            break;

        case SQL_TXN_ISOLATION:
            if (conn->isolation == vParam)
                break;
            /*
             * If the connection is not established, just record the setting to
             * reflect it upon connection.
             */
            if (CC_not_connected(conn)) {
                conn->isolation = (UInt4)vParam;
                break;
            }

            conn->isolation = (UInt4)vParam;
            break;

        /* These options should be handled by driver manager */
        case SQL_ODBC_CURSORS:
        case SQL_OPT_TRACE:
        case SQL_OPT_TRACEFILE:
        case SQL_TRANSLATE_DLL:
        case SQL_TRANSLATE_OPTION:
            CC_log_error(
                func,
                "This connect option (Set) is only used by the Driver Manager",
                conn);
            break;

        default: {
            char option[64];

            CC_set_error(conn, CONN_UNSUPPORTED_OPTION,
                         "Unknown connect option (Set)", func);
            SPRINTF_FIXED(option, "fOption=%d, vParam=" FORMAT_LEN, fOption,
                          vParam);
#ifdef WIN32
            if (fOption == 30002 && vParam) {
                int cmp;
#ifdef UNICODE_SUPPORT
                if (CC_is_in_unicode_driver(conn)) {
                    char *asPara =
                        ucs2_to_utf8((SQLWCHAR *)vParam, SQL_NTS, NULL, FALSE);
                    cmp = strcmp(asPara, "Microsoft Jet");
                    free(asPara);
                } else
#endif /* UNICODE_SUPPORT */
                    cmp = strncmp((char *)vParam, "Microsoft Jet", 13);
                if (0 == cmp) {
                    MYLOG(OPENSEARCH_DEBUG, "Microsoft Jet !!!!\n");
                    CC_set_errornumber(conn, 0);
                    conn->ms_jet = 1;
                    return SQL_SUCCESS;
                }
            }
#endif /* WIN32 */
            CC_log_error(func, option, conn);
            return SQL_ERROR;
        }
    }

    if (changed) {
        CC_set_error(conn, CONN_OPTION_VALUE_CHANGED,
                     "Requested value changed.", func);
        return SQL_SUCCESS_WITH_INFO;
    } else
        return SQL_SUCCESS;
}