SQLRETURN SQL_API RS_STMT_INFO::RS_SQLColAttribute()

in src/odbc/rsodbc/rsresult.cpp [966:1216]

• 211 lines of code
• 50 McCabe index (conditional complexity)

SQLRETURN  SQL_API RS_STMT_INFO::RS_SQLColAttribute(SQLHSTMT        phstmt,
                                       SQLUSMALLINT hCol, 
                                       SQLUSMALLINT hFieldIdentifier,
                                       SQLPOINTER    pcValue, 
                                       SQLSMALLINT    cbLen,
                                       SQLSMALLINT *pcbLen, 
                                       SQLLEN       *plValue)
{
    SQLRETURN rc = SQL_SUCCESS;
    RS_STMT_INFO *pStmt = (RS_STMT_INFO *)phstmt;
    RS_RESULT_INFO *pResult;
    int isCharIdentifier;
    RS_DESC_REC *pDescRecHead = NULL;

    // Check stmt handle
    if(!VALID_HSTMT(phstmt))
    {
        rc = SQL_INVALID_HANDLE;
        goto error;
    }

    // Clear error list
    pStmt->pErrorList = clearErrorList(pStmt->pErrorList);

    // Check whether field identifier is char or integer type
    isCharIdentifier = isStrFieldIdentifier(hFieldIdentifier);

    // Is buffer valid?
    if((isCharIdentifier 
            && ((pcValue == NULL && pcbLen == NULL) || (cbLen < 0 && cbLen != SQL_NTS)))
        || (!isCharIdentifier && plValue == NULL))
    {
        rc = SQL_ERROR;
        addError(&pStmt->pErrorList,"HY090", "Invalid string or buffer length", 0, NULL);
        goto error; 
    }
    
    pResult = pStmt->pResultHead;

    if(!pResult)
    {
        if(pStmt->pPrepareHead && pStmt->pPrepareHead->pResultForDescribeCol && pStmt->iStatus == RS_PREPARE_STMT)
        {
            pResult = pStmt->pPrepareHead->pResultForDescribeCol;
            if(pResult)
                pDescRecHead = pResult->pIRDRecs;
        }
    }
    else
        pDescRecHead = pStmt->pIRD->pDescRecHead;

    if(pResult)
    {
        if(hFieldIdentifier == SQL_DESC_COUNT)
        {
            *plValue = 0;
            *plValue = pResult->iNumberOfCols;
        }
        else
        {
            if(pResult->iNumberOfCols && pDescRecHead)
            {
                if(hCol > 0 && hCol <= pResult->iNumberOfCols)
                {
                    RS_DESC_REC *pDescRec = &pDescRecHead[hCol - 1];

                    switch(hFieldIdentifier)
                    {
                        case SQL_DESC_AUTO_UNIQUE_VALUE:
                        {
                            *plValue = pDescRec->cAutoInc;
                            break;
                        }

                        case SQL_DESC_BASE_COLUMN_NAME:
                        case SQL_DESC_LABEL:
                        case SQL_DESC_NAME:
                        {
                            rc = copyStrDataSmallLen(pDescRec->szName, SQL_NTS, (char *)pcValue, cbLen, pcbLen);
                            break;
                        }

                        case SQL_DESC_BASE_TABLE_NAME:
                        case SQL_DESC_TABLE_NAME:
                        {
                            rc = copyStrDataSmallLen(pDescRec->szTableName, SQL_NTS, (char *)pcValue, cbLen, pcbLen);
                            break;
                        }

                        case SQL_DESC_CASE_SENSITIVE:
                        {
                            *plValue = pDescRec->cCaseSensitive;
                            break;
                        }

                        case SQL_DESC_CATALOG_NAME:
                        {
                            rc = copyStrDataSmallLen(pDescRec->szCatalogName, SQL_NTS, (char *)pcValue, cbLen, pcbLen);
                            break;
                        }

                        case SQL_DESC_CONCISE_TYPE:
                        {
                            *plValue = getConciseType(pDescRec->hConciseType, pDescRec->hType);
                            break;
                        }

                        case SQL_DESC_TYPE:
                        {
                            *plValue = pDescRec->hType;

                            // Convert to ODBC2 type, if needed
                            CONVERT_TO_ODBC2_SQL_DATE_TYPES(pStmt, plValue);

                            break;
                        }

                        case SQL_DESC_DISPLAY_SIZE:
                        {
                            *plValue = pDescRec->iDisplaySize;
                            break;
                        }

                        case SQL_DESC_FIXED_PREC_SCALE:
                        {
                            *plValue = pDescRec->cFixedPrecScale;
                            break;
                        }

                        case SQL_DESC_LENGTH:
                        case SQL_COLUMN_LENGTH:
                        {
                            *plValue = getSize(pDescRec->hType, pDescRec->iSize);
                            break;
                        }

                        case SQL_DESC_LITERAL_PREFIX:
                        {
                            rc = copyStrDataSmallLen(pDescRec->szLiteralPrefix, SQL_NTS, (char *)pcValue, cbLen, pcbLen);
                            break;
                        }

                        case SQL_DESC_LITERAL_SUFFIX:
                        {
                            rc = copyStrDataSmallLen(pDescRec->szLiteralSuffix, SQL_NTS, (char *)pcValue, cbLen, pcbLen);
                            break;
                        }

                        case SQL_DESC_LOCAL_TYPE_NAME:
                        case SQL_DESC_TYPE_NAME:
                        {
                            rc = copyStrDataSmallLen(pDescRec->szTypeName, SQL_NTS, (char *)pcValue, cbLen, pcbLen);
                            break;
                        }

                        case SQL_DESC_NULLABLE:
                        {
                            *plValue = pDescRec->hNullable; 
                            break;
                        }

                        case SQL_DESC_NUM_PREC_RADIX:
                        {
                            *plValue = pDescRec->iNumPrecRadix;
                            break;
                        }

                        case SQL_DESC_OCTET_LENGTH:
                        {
                            *plValue = pDescRec->iOctetLen;
                            break;
                        }

                        case SQL_DESC_PRECISION:
                        case SQL_COLUMN_PRECISION:
                        {
                            *plValue = pDescRec->iPrecision;
                            break;
                        }

                        case SQL_DESC_SCALE:
                        case SQL_COLUMN_SCALE:
                        {
                            *plValue = getScale(pDescRec->hType, pDescRec->hScale);
                            break;
                        }

                        case SQL_DESC_SCHEMA_NAME:
                        {
                            rc = copyStrDataSmallLen(pDescRec->szSchemaName, SQL_NTS, (char *)pcValue, cbLen, pcbLen);
                            break;
                        }

                        case SQL_DESC_SEARCHABLE:
                        {
                            *plValue = pDescRec->iSearchable;
                            break;
                        }

                        case SQL_DESC_UNNAMED:
                        {
                            *plValue = pDescRec->iUnNamed;
                            break;
                        }

                        case SQL_DESC_UNSIGNED:
                        {
                            *plValue = pDescRec->cUnsigned;
                            break;
                        }

                        case SQL_DESC_UPDATABLE:
                        {
                            *plValue = pDescRec->iUpdatable;
                            break;
                        }

                        default:
                        {
                            rc = SQL_ERROR;
                            addError(&pStmt->pErrorList,"HY091", "Invalid descriptor field identifier", 0, NULL);
                            goto error; 
                        }
                    } // Switch
                }
                else
                {
                    rc = SQL_ERROR;
                    addError(&pStmt->pErrorList,"HY000", "SQLColAttribute: Invalid column number", 0, NULL);
                    goto error; 
                }
            }
            else
            {
                rc = SQL_ERROR;
                addError(&pStmt->pErrorList,"07005", "No columns found", 0, NULL);
                goto error; 
            }
        } // SQL_DESC_COUNT
    }
    else
    {
        rc = SQL_ERROR;
        addError(&pStmt->pErrorList,"HY000", "No result found", 0, NULL);
        goto error; 
    }

error:

    return rc;
}