SQLRETURN SQL_API RsDesc::RS_SQLGetDescField()

in src/odbc/rsodbc/rsdesc.cpp [150:482]

• 274 lines of code
• 57 McCabe index (conditional complexity)

SQLRETURN  SQL_API RsDesc::RS_SQLGetDescField(SQLHDESC phdesc,
                                       SQLSMALLINT hRecNumber, 
                                       SQLSMALLINT hFieldIdentifier,
                                       SQLPOINTER pValue, 
                                       SQLINTEGER cbLen,
                                       SQLINTEGER *pcbLen,
                                       int iInternal)
{
    SQLRETURN rc = SQL_SUCCESS;
    RS_DESC_INFO *pDesc = (RS_DESC_INFO *)phdesc;
    RS_DESC_HEADER &pDescHeader = pDesc->pDescHeader;
    SQLINTEGER *piVal = (SQLINTEGER *)pValue;
    short *phVal = (short *)pValue;
    void **ppVal = (void **)pValue;
    RS_DESC_REC *pDescRec = NULL;
    int iIsHeaderField;
    int iIsReadableField;
    int iDescType;

    if(!VALID_HDESC(phdesc))
    {
        rc = SQL_INVALID_HANDLE;
        goto error;
    }

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

    if(!pValue)
    {
        rc = SQL_ERROR;
        addError(&pDesc->pErrorList,"HY000", "Output buffer is NULL", 0, NULL);
        goto error;
    }

    iDescType = pDesc->iType;
    iIsReadableField = (iInternal) ? TRUE : isReadableField(pDesc, hFieldIdentifier);
    iIsHeaderField = isHeaderField(hFieldIdentifier);

    if(!iIsHeaderField)
    {
        // Check for record number.

        // Find if rec exist.
        pDescRec = findDescRec(pDesc, hRecNumber);
        if(pDescRec == NULL)
        {
            if(hRecNumber < 0)
            {
                rc = SQL_ERROR;
                addError(&pDesc->pErrorList,"07009", "Invalid descriptor index", 0, NULL);
                goto error;
            }
            else
            {
                rc = SQL_NO_DATA;
                return rc;
            }
        }
    }

    if(!iIsReadableField)
    {
        rc = SQL_ERROR;
        addError(&pDesc->pErrorList,"HY000", "Field is not used or not readable", 0, NULL);
        goto error;
    }

    if(iIsHeaderField)
    {
        if(pDesc->pDescHeader.valid == false)
        {
            rc = SQL_ERROR;
            addError(&pDesc->pErrorList,"HY000", "Null pointer found", 0, NULL);
            goto error;
        }
    }

    switch(hFieldIdentifier)
    {
        // Header fields
        case SQL_DESC_ALLOC_TYPE:
        {
            getShortVal(pDescHeader.hAllocType, phVal, pcbLen);
            break;
        }

        case SQL_DESC_ARRAY_SIZE:
        {
            getSQLINTEGERVal(pDescHeader.lArraySize,piVal, pcbLen);
            break;
        }

        case SQL_DESC_ARRAY_STATUS_PTR:
        {
            getPointerVal(pDescHeader.phArrayStatusPtr,ppVal,pcbLen);
            break;
        }

        case SQL_DESC_BIND_OFFSET_PTR:
        {
            getPointerVal(pDescHeader.plBindOffsetPtr,ppVal,pcbLen);
            break;
        }

        case SQL_DESC_BIND_TYPE:
        {
            getSQLINTEGERVal(pDescHeader.lBindType,piVal, pcbLen);
            break;
        }

        case SQL_DESC_COUNT:
        {
            if(pDescHeader.hHighestCount == 0)
                pDescHeader.hHighestCount = findHighestRecCount(pDesc);

            getShortVal(pDescHeader.hHighestCount, phVal, pcbLen);
            break;
        }

        case SQL_DESC_ROWS_PROCESSED_PTR:
        {
            getPointerVal(pDescHeader.plRowsProcessedPtr,ppVal,pcbLen);
            break;
        }

        // Record fields
        case SQL_DESC_AUTO_UNIQUE_VALUE:
        {
            getSQLINTEGERVal(pDescRec->cAutoInc,piVal, pcbLen);
            break;
        }

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

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

        case SQL_DESC_CASE_SENSITIVE:
        {
            getSQLINTEGERVal(pDescRec->cCaseSensitive,piVal, pcbLen);
            break;
        }

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

        case SQL_DESC_CONCISE_TYPE:
        {
            getShortVal(getConciseType(pDescRec->hConciseType, pDescRec->hType), phVal, pcbLen);
            break;
        }

        case SQL_DESC_TYPE:
        {
            getShortVal(pDescRec->hType, phVal, pcbLen);
            break;
        }

        case SQL_DESC_DATA_PTR:
        {
            getPointerVal(pDescRec->pValue,ppVal,pcbLen);
            break;
        }

        case SQL_DESC_DATETIME_INTERVAL_CODE:
        {
            getShortVal(getDateTimeIntervalCode(pDescRec->hDateTimeIntervalCode,pDescRec->hType),phVal, pcbLen);
            break;
        }

        case SQL_DESC_DATETIME_INTERVAL_PRECISION:
        {
            getSQLINTEGERVal(pDescRec->iDateTimeIntervalPrecision,piVal, pcbLen);
            break;
        }

        case SQL_DESC_DISPLAY_SIZE:
        {
            getSQLINTEGERVal(pDescRec->iDisplaySize,piVal, pcbLen);
            break;
        }

        case SQL_DESC_FIXED_PREC_SCALE:
        {
            getShortVal(pDescRec->cFixedPrecScale, phVal, pcbLen);
            break;
        }

        case SQL_DESC_LENGTH:
        {
            long lLen;

            if(iDescType == RS_IRD || iDescType == RS_IPD || pDescRec->iSize == 0)
                lLen = getSize(pDescRec->hType, pDescRec->iSize);
            else
                lLen = pDescRec->iSize;

            getSQLINTEGERVal(lLen,piVal, pcbLen);

            break;
        }

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

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

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

        case SQL_DESC_NULLABLE:
        {
            getShortVal(pDescRec->hNullable, phVal, pcbLen);
            break;
        }

        case SQL_DESC_NUM_PREC_RADIX:
        {
            getSQLINTEGERVal(pDescRec->iNumPrecRadix,piVal, pcbLen);
            break;
        }

        case SQL_DESC_OCTET_LENGTH:
        {
            getSQLINTEGERVal(pDescRec->iOctetLen,piVal, pcbLen);
            break;
        }

        case SQL_DESC_OCTET_LENGTH_PTR:
        {
            getPointerVal(pDescRec->plOctetLen,ppVal,pcbLen);
            break;
        }

        case SQL_DESC_PARAMETER_TYPE:
        {
            getShortVal(pDescRec->hInOutType, phVal, pcbLen);
            break;
        }

        case SQL_DESC_PRECISION:
        {
            getShortVal(pDescRec->iPrecision, phVal, pcbLen);
            break;
        }

        case SQL_DESC_SCALE:
        {
            short hScale;

            if(iDescType == RS_IRD || iDescType == RS_IPD || pDescRec->hScale == 0)
                hScale = getScale(pDescRec->hType, pDescRec->hScale);
            else
                hScale = pDescRec->hScale;

            getShortVal(hScale, phVal, pcbLen);

            break;
        }

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

        case SQL_DESC_SEARCHABLE:
        {
            getShortVal(pDescRec->iSearchable, phVal, pcbLen);
            break;
        }

        case SQL_DESC_UNNAMED:
        {
            getShortVal(pDescRec->iUnNamed, phVal, pcbLen);
            break;
        }

        case SQL_DESC_UNSIGNED:
        {
            getShortVal(pDescRec->cUnsigned, phVal, pcbLen);
            break;
        }

        case SQL_DESC_UPDATABLE:
        {
            getShortVal(pDescRec->iUpdatable, phVal, pcbLen);
            break;
        }

        case SQL_DESC_INDICATOR_PTR:
        {
            getPointerVal(pDescRec->pcbLenInd,ppVal,pcbLen);
            break;
        }

        default:
        {
            rc = SQL_ERROR;
            addError(&pDesc->pErrorList,"HY091", "Invalid descriptor field identifier", 0, NULL);
            goto error;
        }
    } // Switch

error:

    return rc;
}