/**********************************************************************
* FILENAME :        util.c
*
* DESCRIPTION :     Various useful functions
*
*                   rtrim  - right trim string
*                   getStr - get string from user
*                   getInt - get integer value from user
*                   extract_error - get error for handle from driver
*                   padOut - pad out string to given length
*                   itoa   - create string of integer
*                   getDataSources - get list of Data Sources
*                   selectDSN      - select data source
*                   getDescRecCount - get number of records in descriptor
*                   dumpDescriptorRec - uses SQLGetDescRec and output info
*                                       for descriptor record
*                   dumpDescriptorHeaderFields - outouts descriptor
*                                                header fields
*                   dumpDescriptorRecordFields - outputs descriptor
*                                                record fields
*                   dumpDescriptors - dumps out descriptors in use on handle
*                   hasBookmarkRecord - returns true/false to indicate
*                                       whether handle has bookmark rec (0)
*
* ODBC USAGE :
*                   See code.
*/

#define CHECK_ERROR(e, s, h, t) ({\
            if (e!=SQL_SUCCESS && e != SQL_SUCCESS_WITH_INFO) {extract_error(s, h, t); goto exit;} \
})

#define MAXDSNS 10
#define MAXDSNLEN 100

char* rtrim(char* string, char junk)
{
    char* original = string + strlen(string);
    while(*--original == junk);
        *(original + 1) = '\0';
    return string;
}

// get string from user.
char getStr (char *label, char *retStr, int len, char confirm) {

    char reply[3];
    char *nl=0;

    strcpy (reply, "Y");

    if (strlen(label) > 0) {
        printf ("%s : ", label);
    }

    fgets(retStr, len, stdin);
    if ( (nl = strchr (retStr, '\n')) != NULL) {*nl='\0';}

    if (confirm == 'Y') {
        printf ("Confirm Y/N? : ");
        fgets(reply, 3, stdin);
    }

    return reply[0];
}

// gets integer value from user. confirm ignored if number equals quitVal
char getInt (char *label, int *retInt, char confirm, int quitVal) {

    char reply[3];
    char buff[256];

    if (strlen(label)>0) {
        printf ("%s : ", label);
    }

    fgets(buff, sizeof(buff), stdin);
    *retInt=atoi(buff);
    if (confirm=='Y' && *retInt!=quitVal) {
        printf ("Confirm Y/N? : ");
        fgets(reply, 3, stdin);
    }

    return reply[0];
}

void extract_error(char *fn, SQLHANDLE handle, SQLSMALLINT type)
{
    SQLINTEGER i = 0;
    SQLINTEGER NativeError;
    SQLCHAR SQLState[ 7 ];
    SQLCHAR MessageText[256];
    SQLSMALLINT TextLength;
    SQLRETURN ret;

    fprintf(stderr, "\nThe driver reported the following error %s\n", fn);
    do
    {
        ret = SQLGetDiagRec(type, handle, ++i, SQLState, &NativeError,
                            MessageText, sizeof(MessageText), &TextLength);
        if (SQL_SUCCEEDED(ret)) {
            printf("%s:%ld:%ld:%s\n",
                        SQLState, (long) i, (long) NativeError, MessageText);
        }
    }
    while( ret == SQL_SUCCESS );
}

void padOut (char* data, char* padding, int max) {

    memset (padding, ' ', max);
    padding[max]='\0';

    //printf ("Data    '%s', Len %i\n", data, (int)strlen(data));
    //printf ("Padding '%s', Len %i\n", padding, (int)strlen(padding));
    //printf ("Max     %i\n", max);

    if (strlen(data)<strlen(padding)){
        padding[strlen(padding)-strlen(data)]='\0';
    } else {
        padding[0]='\0';
    }
    return;
}

//implemenation of itoa

char* itoa(int n) {
    char* ret = NULL;
    int numChars = 0;

    // Determine if integer is negative
    int isNegative = 0;

    if (n < 0) {
        n = -n;
        isNegative = 1;
        numChars++;
    }

    // Count how much space we will need for the string
    int temp = n;
    do {
        numChars++;
        temp /= 10;
    } while ( temp );

    // Allocate space for the string (1 for negative sign, 1 for each digit,
    // and 1 for null terminator)
    ret = malloc (numChars + 1);
    ret[numChars] = 0;

    // Add the negative sign if needed
    if (isNegative) ret[0] = '-';

    // Copy digits to string in reverse order
    int i = numChars - 1;
    do {
        ret[i--] = n%10 + '0';
        n /= 10;
    } while (n);

    return ret;
}

// Example of passing 2D array ...

int getDataSources (SQLHANDLE env, int maxNo, int maxLen,
                    char dsns[maxNo][maxLen]) {

	SQLRETURN retcode;
	SQLCHAR dsnName[256];
	SQLSMALLINT dsnNameLenReturned;
	SQLCHAR driverDesc[256];
	SQLSMALLINT driverDescLenReturned;
	SQLUSMALLINT direction;
    int count=0;

	direction = SQL_FETCH_FIRST;
	while (SQL_SUCCEEDED(retcode=SQLDataSources(env, direction, dsnName,
                                                sizeof(dsnName),
                                                &dsnNameLenReturned,
                                                driverDesc,
                                                sizeof(driverDesc),
                                                &driverDescLenReturned))) {
	    direction = SQL_FETCH_NEXT;
        strcpy (&dsns[count][0], dsnName);
        count++;
	}

    return count;
}

int selectDSN (SQLHANDLE henv, char *dsn, char *prompt) {

    char dsns[MAXDSNS][MAXDSNLEN];
    int count, i;
    count = getDataSources(henv, MAXDSNS, MAXDSNLEN, dsns);

    printf ("%s\n", prompt);
    printf ("0 - Quit\n");
    for (i=0;i<count;i++) {
        printf ("%i - %s\n", i+1, dsns[i]);
    }

    getInt ("DSN ? ", &i, 'N', 0);
    if (i==0)
        return SQL_ERROR;
    else {
        strcpy (dsn, &dsns[i-1][0]);
        return SQL_SUCCESS;
    }
}

//
// get number of column/param records in descriptor
// count does not include bookmark record ever
//
SQLSMALLINT getDescRecCount (SQLHDESC descriptor) {

    SQLRETURN retcode;
    SQLSMALLINT descCount=0;

    // get number of fields in the descriptor
    retcode = SQLGetDescField(descriptor, 0, SQL_DESC_COUNT, &descCount, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetDescField (COUNT)",
                                        descriptor, SQL_HANDLE_DESC);
        descCount=0;
    }
    return descCount;
}

//
// Dump various settings or values of multiple fields of a descriptor record
// using ODBC function SQLGetDescRec ()
//
void dumpDescriptorRec (char *comment,
                        SQLHDESC descriptor,
                        int incBookmarkRec) {

    int i;
    SQLRETURN       retcode;

    SQLCHAR         Name[255];
    SQLSMALLINT     BufferLength=255;
    SQLSMALLINT     StringLength;
    SQLSMALLINT     Type;
    SQLSMALLINT     SubType;
    SQLLEN          Length;
    SQLSMALLINT     Precision;
    SQLSMALLINT     Scale;
    SQLSMALLINT     Nullable;

    SQLSMALLINT     RecNumber;
    SQLSMALLINT     FieldIdentifier;

    SQLSMALLINT     descCount=0;
    SQLINTEGER      Len;

    printf ("\n---\n%s\n---\n", comment);
    descCount = getDescRecCount(descriptor);
    printf ("%i Records\n", (int) descCount);

    // Descriptor records are numbered from 0,
    // with record number 0 being the bookmark record.
    if (incBookmarkRec) {
        i=-1;
    } else {
        i=0;
    }

    for (;i<descCount;i++) {
        retcode = SQLGetDescRec(descriptor, i+1,
                                Name, BufferLength,
                                &StringLength, &Type,
                                &SubType, &Length,
                                &Precision, &Scale,
                                &Nullable);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            if (retcode==SQL_NO_DATA) {
                printf ("\nNo %s records !\n", comment);
            } else {
                 extract_error("SQLGetDescRec (hdbc)",
                                        descriptor, SQL_HANDLE_DESC);
                 break;
            }
        } else {
            printf ("\nName %s, ",      Name);
            printf ("Type %i, ",        (int)Type);
            printf ("SubType %i, ",     (int)SubType);
            printf ("Length %i, ",      (int)Length);
            printf ("Precision %i, ",   (int)Precision);
            printf (" Scale %i, ",      (int)Scale);
            printf ("Nullable %i\n",    (int)Nullable);
        }
    }

    return;
}

//
// Dumps out descriptor header record fields using ODBC
// function SQLGetDescField ()
//
void dumpDescriptorHeaderFields (SQLHDESC descriptor) {

    SQLRETURN       retcode;

    //
    // Header fields
    //
    SQLSMALLINT     descAllocType=0;
    SQLULEN         descArraySize=0;
    SQLUSMALLINT   *descArrayStatusPtr;
    SQLLEN         *descBindOffsetPtr;
    SQLINTEGER      descBindType=0;
    SQLSMALLINT     descCount=0;
    SQLULEN        *descRowsProcessesPtr;

    printf ("\n  Descriptor Header Fields");
    printf ("\n  ------------------------\n");
    retcode = SQLGetDescField(descriptor, 0, SQL_DESC_ALLOC_TYPE,
                                             &descAllocType, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetDescField (ALLOC_TYPE)",
                                descriptor, SQL_HANDLE_DESC);
        return;
    } else {
        printf (" SQL_DESC_ALLOC_TYPE : %i\n", (int) descAllocType);
    }

    retcode = SQLGetDescField(descriptor, 0, SQL_DESC_ARRAY_SIZE,
                                             &descArraySize, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetDescField (ARRAY_SIZE)",
                                descriptor, SQL_HANDLE_DESC);
        return;
    } else {
        printf (" SQL_DESC_ARRAY_SIZE : %i\n", (int) descArraySize);
    }

    retcode = SQLGetDescField(descriptor, 0, SQL_DESC_ARRAY_STATUS_PTR ,
                                             &descArrayStatusPtr, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetDescField (ARRAY_STATUS_PTR )",
                                            descriptor, SQL_HANDLE_DESC);
        return;
    } else {
        printf (" SQL_DESC_ARRAY_STATUS_PTR  : %p\n", descArrayStatusPtr);
    }

    retcode = SQLGetDescField(descriptor, 0, SQL_DESC_BIND_OFFSET_PTR ,
                                             &descBindOffsetPtr, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetDescField (BIND_OFFSET_PTR )",
                                            descriptor, SQL_HANDLE_DESC);
        return;
    } else {
        printf (" SQL_DESC_BIND_OFFSET_PTR  : %p\n", descBindOffsetPtr);
    }

    retcode = SQLGetDescField(descriptor, 0, SQL_DESC_BIND_TYPE ,
                                             &descBindType, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetDescField (BIND_TYPE )",
                                            descriptor, SQL_HANDLE_DESC);
        return;
    } else {
        printf (" SQL_DESC_BIND_TYPE  : %i\n", descBindType);
    }

    retcode = SQLGetDescField(descriptor, 0, SQL_DESC_COUNT ,
                                             &descCount, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetDescField (COUNT )",
                                            descriptor, SQL_HANDLE_DESC);
        return;
    } else {
        printf (" SQL_DESC_COUNT  : %i\n", descCount);
    }

    retcode = SQLGetDescField(descriptor, 0, SQL_DESC_ROWS_PROCESSED_PTR ,
                                             &descRowsProcessesPtr, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetDescField (ROWS_PROCESSED_PTR )",
                                            descriptor, SQL_HANDLE_DESC);
        return;
    } else {
        printf (" SQL_DESC_ROWS_PROCESSED_PTR  : %p\n", descRowsProcessesPtr);
    }

    return;
}

//
// Dump out descriptor records fields using ODBC function SQLGetDescField ()
//
void dumpDescriptorRecordFields (SQLHDESC descriptor, int incBookmarkRec) {

    SQLINTEGER      descAutoUniqueValue;
    SQLCHAR         descBaseColumnName[255];
    SQLCHAR         descBaseTableName[255];
    SQLINTEGER      descCaseSensitive;
    SQLCHAR         descCatalogName[255];
    SQLSMALLINT     descConsiseType;
    SQLPOINTER      descDataPtr;
    SQLSMALLINT     descDatetimeIntervalCode;
    SQLINTEGER      descDatetimeIntervalPrecision;
    SQLLEN          descDisplaySize;
    SQLSMALLINT     descFixedPreCScale;
    SQLLEN         *descIndicatorPtr;
    SQLCHAR         descLabel[255];
    SQLULEN         descLength;
    SQLCHAR         descLiteralPrefix[255];
    SQLCHAR         descLiteralSuffix[255];
    SQLCHAR         descLocalTypeName[255];
    SQLCHAR         descName[255];
    SQLSMALLINT     descNullable;
    SQLINTEGER      descNumPrecRadix;
    SQLLEN          descOctetLength;
    SQLLEN         *descOctetLengthPtr;
    SQLSMALLINT     descParameterType;
    SQLSMALLINT     descPrecision;
    SQLSMALLINT     descRowver;
    SQLSMALLINT     descScale;
    SQLCHAR         descSchemaName[255];
    SQLSMALLINT     descSearchable;
    SQLCHAR         descTableName[255];
    SQLSMALLINT     descType=0;
    SQLCHAR         descTypeName[255];
    SQLSMALLINT     descUnnamed;
    SQLSMALLINT     descUnsigned;
    SQLSMALLINT     descUpdatable;
    SQLINTEGER      Len;

    SQLRETURN retcode;
    SQLSMALLINT descCount;

    descCount=getDescRecCount (descriptor);

    printf ("\n  Descriptor Record Fields");
    printf ("\n  ------------------------\n");

    int i;
    if (incBookmarkRec) {
        i=-1;
    } else {
        i=0;
    }
    for (;i<descCount;i++) {
        printf ("\n  Record %i ", i+1);
        if (i==-1) printf ("(BOOKMARK RECORD)");
        printf ("\n");
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_AUTO_UNIQUE_VALUE ,
                                  &descAutoUniqueValue, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (AUTO_UNIQUE_VALUE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_AUTO_UNIQUE_VALUE  : %i\n", descAutoUniqueValue);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_BASE_COLUMN_NAME ,
                                  descBaseColumnName, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (BASE_COLUMN_NAME)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_BASE_COLUMN_NAME  : '%s'\n",
                                                descBaseColumnName);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_BASE_TABLE_NAME ,
                                  descBaseTableName, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (BASE_TABLE_NAME)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_BASE_TABLE_NAME  : '%s'\n", descBaseTableName);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_CASE_SENSITIVE ,
                                  &descCaseSensitive, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (CASE_SENSITIVE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_CASE_SENSITIVE  : %i\n", descCaseSensitive);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_CATALOG_NAME ,
                                  &descCatalogName, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (CATALOG_NAME)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_CATALOG_NAME  : '%s'\n", descCatalogName);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_CONCISE_TYPE ,
                                  &descConsiseType, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (CONCISE_TYPE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_CONCISE_TYPE  : %i\n", descConsiseType);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_DATA_PTR ,
                                  &descDataPtr, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (DATA_PTR)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_DATA_PTR  : %p\n", descDataPtr);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_DATETIME_INTERVAL_CODE ,
                                  &descDatetimeIntervalCode, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (DATETIME_INTERVAL_CODE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_DATETIME_INTERVAL_CODE  : %i\n",
                                                (int)descDatetimeIntervalCode);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_DATETIME_INTERVAL_PRECISION ,
                                  &descDatetimeIntervalPrecision, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (DATETIME_INTERVAL_PRECISION)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_DATETIME_INTERVAL_PRECISION  : %i\n",
                                                descDatetimeIntervalPrecision);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_DISPLAY_SIZE ,
                                  &descDisplaySize, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (DISPLAY_SIZE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_DISPLAY_SIZE  : %i\n", (int)descDisplaySize);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_FIXED_PREC_SCALE ,
                                  &descFixedPreCScale, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (FIXED_PREC_SCALE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_FIXED_PREC_SCALE  : %i\n",
                                                (int)descFixedPreCScale);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_INDICATOR_PTR ,
                                  &descIndicatorPtr, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (INDICATOR_PTR)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_INDICATOR_PTR  : %p\n", descIndicatorPtr);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_LABEL ,
                                  descLabel, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (LABEL )",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_LABEL  : '%s'\n", descLabel);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_LENGTH ,
                                  &descLength, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (LENGTH)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_LENGTH  : %i\n", (unsigned int)descLength);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_LITERAL_PREFIX ,
                                  descLiteralPrefix, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (LITERAL_PREFIX)",
                                                descriptor, SQL_HANDLE_DESC);

        } else {
            printf (" SQL_DESC_LITERAL_PREFIX  : '%s'\n", descLiteralPrefix);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_LITERAL_SUFFIX ,
                                  descLiteralSuffix, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (LITERAL_SUFFIX)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_LITERAL_SUFFIX  : '%s'\n", descLiteralSuffix);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_LOCAL_TYPE_NAME ,
                                  descLocalTypeName, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (LOCAL_TYPE_NAME)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_LOCAL_TYPE_NAME  : '%s'\n", descLocalTypeName);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_NAME ,
                                  descName, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (NAME )",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_NAME  : '%s'\n", descName);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_NULLABLE ,
                                  &descNullable, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (NULLABLE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_NULLABLE  : %i\n", (int)descNullable);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_NUM_PREC_RADIX ,
                                  &descNumPrecRadix, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (NUM_PREC_RADIX)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_NUM_PREC_RADIX  : %i\n", (int)descNumPrecRadix);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_OCTET_LENGTH ,
                                  &descOctetLength, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (OCTET_LENGTH)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_OCTET_LENGTH  : %i\n", (int)descOctetLength);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_OCTET_LENGTH_PTR ,
                                  &descOctetLengthPtr, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (OCTET_LENGTH_PTR)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_OCTET_LENGTH_PTR  : %p\n", descOctetLengthPtr);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_PARAMETER_TYPE ,
                                  &descParameterType, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (PARAMETER_TYPE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_PARAMETER_TYPE  : %i\n", (int)descParameterType);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_PRECISION ,
                                  &descPrecision, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (PRECISION)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_PRECISION  : %i\n", (int)descPrecision);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_ROWVER ,
                                  &descRowver, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (ROWVER)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_ROWVER  : %i\n", (int)descRowver);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_SCALE ,
                                  &descScale, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (SCALE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_SCALE  : %i\n", (int)descScale);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_SCHEMA_NAME ,
                                  &descSchemaName, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (SCHEMA_NAME)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_SCHEMA_NAME  : '%s'\n", descSchemaName);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_SEARCHABLE ,
                                  &descSearchable, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (SEARCHABLE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_SEARCHABLE  : %i\n", (int)descSearchable);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_TYPE ,
                                  &descType, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (TYPE )",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_TYPE  : %i\n", (int)descType);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_TYPE_NAME ,
                                  descTypeName, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (TYPE_NAME )",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_TYPE_NAME  : '%s'\n", descTypeName);
        }

        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_UNNAMED ,
                                  &descUnnamed, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (UNNAMED)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_UNNAMED  : %i\n", descUnnamed);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_UNSIGNED ,
                                  &descUnsigned, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (UNSIGNED)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_UNSIGNED  : %i\n", descUnsigned);
        }
         retcode = SQLGetDescField(descriptor, i+1,
                                   SQL_DESC_UPDATABLE ,
                                   &descUpdatable, 0, 0);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (UPDATABLE)",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_UPDATABLE  : %i\n", descUpdatable);
        }
        retcode = SQLGetDescField(descriptor, i+1,
                                  SQL_DESC_TABLE_NAME ,
                                  descTableName, 255, &Len);
        if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
            extract_error("SQLGetDescField (TABLE_NAME )",
                                                descriptor, SQL_HANDLE_DESC);
        } else {
            printf (" SQL_DESC_TABLE_NAME  : '%s'\n", descTableName);
        }

    }

    return;
}

//
// dump descriptors
//
void dumpDescriptors (SQLCHAR *comment,         // display heading/comment
                      SQLHSTMT hstmt,           // statement handle
                      USHORT header,            // display header record
                      USHORT records,           // display col/parm records
                      int incBookmarkRec) {     // include bookmark record

    SQLRETURN retcode;
    SQLHDESC  hArd, hIrd, hApd, hIpd;           // descriptors

    // Get ARD
    retcode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_ROW_DESC, &hArd, 0, NULL);
    CHECK_ERROR(retcode, "SQLGetStmtAttr(SQL_HANDLE_STMT)",
                hstmt, SQL_HANDLE_STMT);

    // Get IRD
    retcode = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_ROW_DESC, &hIrd, 0, NULL);
    CHECK_ERROR(retcode, "SQLExecDirect(SQL_HANDLE_STMT)",
                hstmt, SQL_HANDLE_STMT);

    // Get APD
    retcode = SQLGetStmtAttr(hstmt, SQL_ATTR_APP_PARAM_DESC, &hApd, 0, NULL);
    CHECK_ERROR(retcode, "SQLExecDirect(SQL_HANDLE_STMT)",
                hstmt, SQL_HANDLE_STMT);

    // Get IPD
    retcode = SQLGetStmtAttr(hstmt, SQL_ATTR_IMP_PARAM_DESC, &hIpd, 0, NULL);
    CHECK_ERROR(retcode, "SQLExecDirect(SQL_HANDLE_STMT)",
                hstmt, SQL_HANDLE_STMT);

    printf ("\n---\n%s\n---\n", comment);
    dumpDescriptorRec ("ARD", hArd, incBookmarkRec);
    if (header=='Y') {
        dumpDescriptorHeaderFields (hArd);
    }
    if (records=='Y') {
        dumpDescriptorRecordFields (hArd, incBookmarkRec);
    }

    dumpDescriptorRec ("IRD", hIrd, incBookmarkRec);
    if (header=='Y') {
        dumpDescriptorHeaderFields (hIrd);
    }
    if (records='Y') {
        dumpDescriptorRecordFields (hIrd, incBookmarkRec);
    }

    dumpDescriptorRec ("APD", hApd, incBookmarkRec);
    if (header=='Y') {
        dumpDescriptorHeaderFields (hApd);
    }
    if (records='Y') {
        dumpDescriptorRecordFields (hApd, incBookmarkRec);
    }

    dumpDescriptorRec ("IPD", hIpd, incBookmarkRec);
    if (header=='Y') {
        dumpDescriptorHeaderFields (hIpd);
    }
    if (records='Y') {
        dumpDescriptorRecordFields (hIpd, incBookmarkRec);
    }

exit:

    return;
}

//
// returns true/false if descriptor has/hasn't bookmark record
//
int hasBookmarkRecord (SQLHANDLE handle) {

    SQLRETURN retcode;
    SQLULEN   bookmark;

    retcode = SQLGetStmtAttr(handle, SQL_ATTR_USE_BOOKMARKS,
                             &bookmark, 0, 0);
    if ( (retcode != SQL_SUCCESS) && (retcode != SQL_SUCCESS_WITH_INFO) ) {
        extract_error("SQLGetStmtAttr (SQL_ATTR_USE_BOOKMARKS)",
                      handle, SQL_HANDLE_ENV);
        return 0;
    }
    if (bookmark==SQL_UB_OFF)
        return 0;
    else
        return 1;
}

See Also


Oracle is a registered trademark of Oracle Corporation and/or its affiliates.