sql-sqlda.c File Reference

#include <ecpglib.h>
#include <ecpgerrno.h>
#include <sqlca.h>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include "ecpg_config.h"
#include "sqlda-native.h"
#include <pgtypes.h>

Include dependency graph for sql-sqlda.c:

Go to the source code of this file.

Data Structures
struct	numeric
struct	decimal

Macros
#define	ECPGdebug(X, Y)   ECPGdebug((X)+100,(Y))
#define	ECPG_SQLDA_H
#define	PGTYPES_NUMERIC
#define	NUMERIC_POS   0x0000
#define	NUMERIC_NEG   0x4000
#define	NUMERIC_NAN   0xC000
#define	NUMERIC_NULL   0xF000
#define	NUMERIC_MAX_PRECISION   1000
#define	NUMERIC_MAX_DISPLAY_SCALE   NUMERIC_MAX_PRECISION
#define	NUMERIC_MIN_DISPLAY_SCALE   0
#define	NUMERIC_MIN_SIG_DIGITS   16
#define	DECSIZE   30

Typedefs
typedef struct sqlvar_struct	sqlvar_t
typedef struct sqlda_struct	sqlda_t
typedef unsigned char	NumericDigit

Functions
numeric *	PGTYPESnumeric_new (void)
decimal *	PGTYPESdecimal_new (void)
void	PGTYPESnumeric_free (numeric *var)
void	PGTYPESdecimal_free (decimal *var)
numeric *	PGTYPESnumeric_from_asc (char *str, char **endptr)
char *	PGTYPESnumeric_to_asc (numeric *num, int dscale)
int	PGTYPESnumeric_add (numeric *var1, numeric *var2, numeric *result)
int	PGTYPESnumeric_sub (numeric *var1, numeric *var2, numeric *result)
int	PGTYPESnumeric_mul (numeric *var1, numeric *var2, numeric *result)
int	PGTYPESnumeric_div (numeric *var1, numeric *var2, numeric *result)
int	PGTYPESnumeric_cmp (numeric *var1, numeric *var2)
int	PGTYPESnumeric_from_int (signed int int_val, numeric *var)
int	PGTYPESnumeric_from_long (signed long int long_val, numeric *var)
int	PGTYPESnumeric_copy (numeric *src, numeric *dst)
int	PGTYPESnumeric_from_double (double d, numeric *dst)
int	PGTYPESnumeric_to_double (numeric *nv, double *dp)
int	PGTYPESnumeric_to_int (numeric *nv, int *ip)
int	PGTYPESnumeric_to_long (numeric *nv, long *lp)
int	PGTYPESnumeric_to_decimal (numeric *src, decimal *dst)
int	PGTYPESnumeric_from_decimal (decimal *src, numeric *dst)
static void	dump_sqlda (sqlda_t *sqlda)
int	main (void)

Variables
sqlda_t *	inp_sqlda
sqlda_t *	outp_sqlda
sqlda_t *	outp_sqlda1

Macro Definition Documentation

DECSIZE

#define DECSIZE   30

Definition at line 64 of file sql-sqlda.c.

ECPG_SQLDA_H

#define ECPG_SQLDA_H

Definition at line 28 of file sql-sqlda.c.

ECPGdebug

#define ECPGdebug	(		X,
			Y
	)		ECPGdebug((X)+100,(Y))

Definition at line 7 of file sql-sqlda.c.

NUMERIC_MAX_DISPLAY_SCALE

#define NUMERIC_MAX_DISPLAY_SCALE   NUMERIC_MAX_PRECISION

Definition at line 60 of file sql-sqlda.c.

NUMERIC_MAX_PRECISION

#define NUMERIC_MAX_PRECISION   1000

Definition at line 59 of file sql-sqlda.c.

NUMERIC_MIN_DISPLAY_SCALE

#define NUMERIC_MIN_DISPLAY_SCALE   0

Definition at line 61 of file sql-sqlda.c.

NUMERIC_MIN_SIG_DIGITS

#define NUMERIC_MIN_SIG_DIGITS   16

Definition at line 62 of file sql-sqlda.c.

NUMERIC_NAN

#define NUMERIC_NAN   0xC000

Definition at line 57 of file sql-sqlda.c.

NUMERIC_NEG

#define NUMERIC_NEG   0x4000

Definition at line 56 of file sql-sqlda.c.

NUMERIC_NULL

#define NUMERIC_NULL   0xF000

Definition at line 58 of file sql-sqlda.c.

NUMERIC_POS

#define NUMERIC_POS   0x0000

Definition at line 55 of file sql-sqlda.c.

PGTYPES_NUMERIC

#define PGTYPES_NUMERIC

Definition at line 51 of file sql-sqlda.c.

Typedef Documentation

NumericDigit

typedef unsigned char NumericDigit

Definition at line 66 of file sql-sqlda.c.

sqlda_t

typedef struct sqlda_struct sqlda_t

Definition at line 40 of file sql-sqlda.c.

sqlvar_t

typedef struct sqlvar_struct sqlvar_t

Definition at line 39 of file sql-sqlda.c.

Function Documentation

dump_sqlda()

static void dump_sqlda ( sqlda_t *  sqlda )

static

Definition at line 131 of file sql-sqlda.c.

{
    int i;
 
    if (sqlda == NULL)
    {
        printf("dump_sqlda called with NULL sqlda\n");
        return;
    }
 
    for (i = 0; i < sqlda->sqld; i++)
    {
        if (sqlda->sqlvar[i].sqlind && *(sqlda->sqlvar[i].sqlind) == -1)
            printf("name sqlda descriptor: '%s' value NULL'\n", sqlda->sqlvar[i].sqlname.data);
        else
        switch (sqlda->sqlvar[i].sqltype)
        {
        case ECPGt_char:
            printf("name sqlda descriptor: '%s' value '%s'\n", sqlda->sqlvar[i].sqlname.data, sqlda->sqlvar[i].sqldata);
            break;
        case ECPGt_int:
            printf("name sqlda descriptor: '%s' value %d\n", sqlda->sqlvar[i].sqlname.data, *(int *)sqlda->sqlvar[i].sqldata);
            break;
        case ECPGt_long:
            printf("name sqlda descriptor: '%s' value %ld\n", sqlda->sqlvar[i].sqlname.data, *(long int *)sqlda->sqlvar[i].sqldata);
            break;
        case ECPGt_long_long:
            printf("name sqlda descriptor: '%s' value %lld\n",
                   sqlda->sqlvar[i].sqlname.data, *(long long int *)sqlda->sqlvar[i].sqldata);
            break;
        case ECPGt_double:
            printf("name sqlda descriptor: '%s' value %f\n", sqlda->sqlvar[i].sqlname.data, *(double *)sqlda->sqlvar[i].sqldata);
            break;
        case ECPGt_numeric:
            {
                char    *val;
 
                val = PGTYPESnumeric_to_asc((numeric*)sqlda->sqlvar[i].sqldata, -1);
                printf("name sqlda descriptor: '%s' value NUMERIC '%s'\n", sqlda->sqlvar[i].sqlname.data, val);
                PGTYPESchar_free(val);
                break;
            }
        }
    }
}

References sqlname::data, ECPGt_char, ECPGt_double, ECPGt_int, ECPGt_long, ECPGt_long_long, ECPGt_numeric, i, PGTYPESchar_free(), PGTYPESnumeric_to_asc(), printf, sqlda_struct::sqld, sqlvar_struct::sqldata, sqlvar_struct::sqlind, sqlvar_struct::sqlname, sqlvar_struct::sqltype, sqlda_struct::sqlvar, and val.

Referenced by main().

main()

int main

(

void

)

Definition at line 178 of file sql-sqlda.c.

{
/* exec sql begin declare section */
          
          
        
        
 
#line 66 "sqlda.pgc"
 char * stmt1 = "SELECT * FROM t1" ;
 
#line 67 "sqlda.pgc"
 char * stmt2 = "SELECT * FROM t1 WHERE id = ?" ;
 
#line 68 "sqlda.pgc"
 int rec ;
 
#line 69 "sqlda.pgc"
 int id ;
/* exec sql end declare section */
#line 70 "sqlda.pgc"
 
 
    char msg[128];
 
    ECPGdebug(1, stderr);
 
    strcpy(msg, "connect");
    { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , "regress1", 0); 
#line 77 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 77 "sqlda.pgc"
 
 
    strcpy(msg, "set");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "set datestyle to iso", ECPGt_EOIT, ECPGt_EORT);
#line 80 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 80 "sqlda.pgc"
 
 
    strcpy(msg, "create");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "create table t1 ( id integer , t text , d1 numeric , d2 float8 , c char ( 10 ) , big bigint )", ECPGt_EOIT, ECPGt_EORT);
#line 90 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 90 "sqlda.pgc"
 
 
    strcpy(msg, "insert");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "insert into t1 values ( 1 , 'a' , 1.0 , 1 , 'a' , 1111111111111111111 ) , ( 2 , null , null , null , null , null ) , ( 3 , 'c' , 0.0 , 3 , 'c' , 3333333333333333333 ) , ( 4 , 'd' , 'NaN' , 4 , 'd' , 4444444444444444444 ) , ( 5 , 'e' , 0.001234 , 5 , 'e' , 5555555555555555555 )", ECPGt_EOIT, ECPGt_EORT);
#line 98 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 98 "sqlda.pgc"
 
 
    strcpy(msg, "commit");
    { ECPGtrans(__LINE__, NULL, "commit");
#line 101 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 101 "sqlda.pgc"
 
 
    /* SQLDA test for getting all records from a table */
 
    outp_sqlda = NULL;
 
    strcpy(msg, "prepare");
    { ECPGprepare(__LINE__, NULL, 0, "st_id1", stmt1);
#line 108 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 108 "sqlda.pgc"
 
 
    strcpy(msg, "declare");
    /* declare mycur1 cursor for $1 */
#line 111 "sqlda.pgc"
 
 
    strcpy(msg, "open");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "declare mycur1 cursor for $1", 
    ECPGt_char_variable,(ECPGprepared_statement(NULL, "st_id1", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
#line 114 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 114 "sqlda.pgc"
 
 
    /* exec sql whenever not found  break ; */
#line 116 "sqlda.pgc"
 
 
    rec = 0;
    while (1)
    {
        strcpy(msg, "fetch");
        { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "fetch 1 from mycur1", ECPGt_EOIT, 
    ECPGt_sqlda, &outp_sqlda, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
#line 122 "sqlda.pgc"
 
if (sqlca.sqlcode == ECPG_NOT_FOUND) break;
#line 122 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 122 "sqlda.pgc"
 
 
        printf("FETCH RECORD %d\n", ++rec);
        dump_sqlda(outp_sqlda);
    }
 
    /* exec sql whenever not found  continue ; */
#line 128 "sqlda.pgc"
 
 
    strcpy(msg, "close");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "close mycur1", ECPGt_EOIT, ECPGt_EORT);
#line 131 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 131 "sqlda.pgc"
 
 
    strcpy(msg, "deallocate");
    { ECPGdeallocate(__LINE__, 0, NULL, "st_id1");
#line 134 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 134 "sqlda.pgc"
 
 
    free(outp_sqlda);
 
    /* SQLDA test for getting ALL records into the sqlda list */
 
    outp_sqlda = NULL;
 
    strcpy(msg, "prepare");
    { ECPGprepare(__LINE__, NULL, 0, "st_id2", stmt1);
#line 143 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 143 "sqlda.pgc"
 
 
    strcpy(msg, "declare");
    /* declare mycur2 cursor for $1 */
#line 146 "sqlda.pgc"
 
 
    strcpy(msg, "open");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "declare mycur2 cursor for $1", 
    ECPGt_char_variable,(ECPGprepared_statement(NULL, "st_id2", __LINE__)),(long)1,(long)1,(1)*sizeof(char), 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, ECPGt_EORT);
#line 149 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 149 "sqlda.pgc"
 
 
    strcpy(msg, "fetch");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "fetch all from mycur2", ECPGt_EOIT, 
    ECPGt_sqlda, &outp_sqlda, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
#line 152 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 152 "sqlda.pgc"
 
 
    outp_sqlda1 = outp_sqlda;
    rec = 0;
    while (outp_sqlda1)
    {
        sqlda_t *ptr;
        printf("FETCH RECORD %d\n", ++rec);
        dump_sqlda(outp_sqlda1);
 
        ptr = outp_sqlda1;
        outp_sqlda1 = outp_sqlda1->desc_next;
        free(ptr);
    }
 
    strcpy(msg, "close");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "close mycur2", ECPGt_EOIT, ECPGt_EORT);
#line 168 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 168 "sqlda.pgc"
 
 
    strcpy(msg, "deallocate");
    { ECPGdeallocate(__LINE__, 0, NULL, "st_id2");
#line 171 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 171 "sqlda.pgc"
 
 
    /* SQLDA test for getting one record using an input descriptor */
 
    /*
     * Input sqlda has to be built manually
     * sqlda_t contains 1 sqlvar_t structure already.
     */
    inp_sqlda = (sqlda_t *)malloc(sizeof(sqlda_t));
    memset(inp_sqlda, 0, sizeof(sqlda_t));
    inp_sqlda->sqln = 1;
 
    inp_sqlda->sqlvar[0].sqltype = ECPGt_int;
    inp_sqlda->sqlvar[0].sqldata = (char *)&id;
 
    printf("EXECUTE RECORD 4\n");
 
    id = 4;
 
    outp_sqlda = NULL;
 
    strcpy(msg, "prepare");
    { ECPGprepare(__LINE__, NULL, 0, "st_id3", stmt2);
#line 193 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 193 "sqlda.pgc"
 
 
    strcpy(msg, "execute");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_execute, "st_id3", 
    ECPGt_sqlda, &inp_sqlda, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
    ECPGt_sqlda, &outp_sqlda, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
#line 196 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 196 "sqlda.pgc"
 
 
    dump_sqlda(outp_sqlda);
 
    strcpy(msg, "deallocate");
    { ECPGdeallocate(__LINE__, 0, NULL, "st_id3");
#line 201 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 201 "sqlda.pgc"
 
 
    free(inp_sqlda);
    free(outp_sqlda);
 
    /* SQLDA test for getting one record using an input descriptor
     * on a named connection
     */
 
    { ECPGconnect(__LINE__, 0, "ecpg1_regression" , NULL, NULL , "con2", 0); 
#line 210 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 210 "sqlda.pgc"
 
 
    /*
     * Input sqlda has to be built manually
     * sqlda_t contains 1 sqlvar_t structure already.
     */
    inp_sqlda = (sqlda_t *)malloc(sizeof(sqlda_t));
    memset(inp_sqlda, 0, sizeof(sqlda_t));
    inp_sqlda->sqln = 1;
 
    inp_sqlda->sqlvar[0].sqltype = ECPGt_int;
    inp_sqlda->sqlvar[0].sqldata = (char *)&id;
 
    printf("EXECUTE RECORD 4\n");
 
    id = 4;
 
    outp_sqlda = NULL;
 
    strcpy(msg, "prepare");
    { ECPGprepare(__LINE__, "con2", 0, "st_id4", stmt2);
#line 230 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 230 "sqlda.pgc"
 
 
    strcpy(msg, "execute");
    { ECPGdo(__LINE__, 0, 1, "con2", 0, ECPGst_execute, "st_id4", 
    ECPGt_sqlda, &inp_sqlda, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EOIT, 
    ECPGt_sqlda, &outp_sqlda, 0L, 0L, 0L, 
    ECPGt_NO_INDICATOR, NULL , 0L, 0L, 0L, ECPGt_EORT);
#line 233 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 233 "sqlda.pgc"
 
 
    dump_sqlda(outp_sqlda);
 
    strcpy(msg, "commit");
    { ECPGtrans(__LINE__, "con2", "commit");
#line 238 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 238 "sqlda.pgc"
 
 
    strcpy(msg, "deallocate");
    { ECPGdeallocate(__LINE__, 0, NULL, "st_id4");
#line 241 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 241 "sqlda.pgc"
 
 
    free(inp_sqlda);
    free(outp_sqlda);
 
    strcpy(msg, "disconnect");
    { ECPGdisconnect(__LINE__, "con2");
#line 247 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 247 "sqlda.pgc"
 
 
    /* End test */
 
    strcpy(msg, "drop");
    { ECPGdo(__LINE__, 0, 1, NULL, 0, ECPGst_normal, "drop table t1", ECPGt_EOIT, ECPGt_EORT);
#line 252 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 252 "sqlda.pgc"
 
 
    strcpy(msg, "commit");
    { ECPGtrans(__LINE__, NULL, "commit");
#line 255 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 255 "sqlda.pgc"
 
 
    strcpy(msg, "disconnect");
    { ECPGdisconnect(__LINE__, "CURRENT");
#line 258 "sqlda.pgc"
 
if (sqlca.sqlcode < 0) exit (1);}
#line 258 "sqlda.pgc"
 
 
    return 0;
}

References sqlda_struct::desc_next, dump_sqlda(), ECPG_NOT_FOUND, ECPGconnect(), ECPGdeallocate(), ECPGdebug, ECPGdisconnect(), ECPGdo(), ECPGprepare(), ECPGprepared_statement(), ECPGst_execute, ECPGst_normal, ECPGt_char_variable, ECPGt_EOIT, ECPGt_EORT, ECPGt_int, ECPGt_NO_INDICATOR, ECPGt_sqlda, ECPGtrans(), free, inp_sqlda, malloc, outp_sqlda, outp_sqlda1, printf, sqlca, sqlvar_struct::sqldata, sqlda_struct::sqln, sqlvar_struct::sqltype, and sqlda_struct::sqlvar.

PGTYPESdecimal_free()

void PGTYPESdecimal_free

(

decimal *

var

)

Definition at line 392 of file numeric.c.

{
    free(var);
}

PGTYPESdecimal_new()

decimal * PGTYPESdecimal_new

(

void

)

Definition at line 59 of file numeric.c.

{
    decimal    *var;
 
    if ((var = (decimal *) pgtypes_alloc(sizeof(decimal))) == NULL)
        return NULL;
 
    memset(var, 0, sizeof(decimal));
 
    return var;
}

PGTYPESnumeric_add()

int PGTYPESnumeric_add	(	numeric *	var1,
		numeric *	var2,
		numeric *	result
	)

Definition at line 637 of file numeric.c.

{
    /*
     * Decide on the signs of the two variables what to do
     */
    if (var1->sign == NUMERIC_POS)
    {
        if (var2->sign == NUMERIC_POS)
        {
            /*
             * Both are positive result = +(ABS(var1) + ABS(var2))
             */
            if (add_abs(var1, var2, result) != 0)
                return -1;
            result->sign = NUMERIC_POS;
        }
        else
        {
            /*
             * var1 is positive, var2 is negative Must compare absolute values
             */
            switch (cmp_abs(var1, var2))
            {
                case 0:
                    /* ----------
                     * ABS(var1) == ABS(var2)
                     * result = ZERO
                     * ----------
                     */
                    zero_var(result);
                    result->rscale = Max(var1->rscale, var2->rscale);
                    result->dscale = Max(var1->dscale, var2->dscale);
                    break;
 
                case 1:
                    /* ----------
                     * ABS(var1) > ABS(var2)
                     * result = +(ABS(var1) - ABS(var2))
                     * ----------
                     */
                    if (sub_abs(var1, var2, result) != 0)
                        return -1;
                    result->sign = NUMERIC_POS;
                    break;
 
                case -1:
                    /* ----------
                     * ABS(var1) < ABS(var2)
                     * result = -(ABS(var2) - ABS(var1))
                     * ----------
                     */
                    if (sub_abs(var2, var1, result) != 0)
                        return -1;
                    result->sign = NUMERIC_NEG;
                    break;
            }
        }
    }
    else
    {
        if (var2->sign == NUMERIC_POS)
        {
            /* ----------
             * var1 is negative, var2 is positive
             * Must compare absolute values
             * ----------
             */
            switch (cmp_abs(var1, var2))
            {
                case 0:
                    /* ----------
                     * ABS(var1) == ABS(var2)
                     * result = ZERO
                     * ----------
                     */
                    zero_var(result);
                    result->rscale = Max(var1->rscale, var2->rscale);
                    result->dscale = Max(var1->dscale, var2->dscale);
                    break;
 
                case 1:
                    /* ----------
                     * ABS(var1) > ABS(var2)
                     * result = -(ABS(var1) - ABS(var2))
                     * ----------
                     */
                    if (sub_abs(var1, var2, result) != 0)
                        return -1;
                    result->sign = NUMERIC_NEG;
                    break;
 
                case -1:
                    /* ----------
                     * ABS(var1) < ABS(var2)
                     * result = +(ABS(var2) - ABS(var1))
                     * ----------
                     */
                    if (sub_abs(var2, var1, result) != 0)
                        return -1;
                    result->sign = NUMERIC_POS;
                    break;
            }
        }
        else
        {
            /* ----------
             * Both are negative
             * result = -(ABS(var1) + ABS(var2))
             * ----------
             */
            if (add_abs(var1, var2, result) != 0)
                return -1;
            result->sign = NUMERIC_NEG;
        }
    }
 
    return 0;
}

PGTYPESnumeric_cmp()

int PGTYPESnumeric_cmp	(	numeric *	var1,
		numeric *	var2
	)

Definition at line 1281 of file numeric.c.

{
    /* use cmp_abs function to calculate the result */
 
    /* both are positive: normal comparison with cmp_abs */
    if (var1->sign == NUMERIC_POS && var2->sign == NUMERIC_POS)
        return cmp_abs(var1, var2);
 
    /* both are negative: return the inverse of the normal comparison */
    if (var1->sign == NUMERIC_NEG && var2->sign == NUMERIC_NEG)
    {
        /*
         * instead of inverting the result, we invert the parameter ordering
         */
        return cmp_abs(var2, var1);
    }
 
    /* one is positive, one is negative: trivial */
    if (var1->sign == NUMERIC_POS && var2->sign == NUMERIC_NEG)
        return 1;
    if (var1->sign == NUMERIC_NEG && var2->sign == NUMERIC_POS)
        return -1;
 
    errno = PGTYPES_NUM_BAD_NUMERIC;
    return INT_MAX;
}

PGTYPESnumeric_copy()

int PGTYPESnumeric_copy	(	numeric *	src,
		numeric *	dst
	)

Definition at line 1388 of file numeric.c.

{
    int         i;
 
    if (dst == NULL)
        return -1;
    zero_var(dst);
 
    dst->weight = src->weight;
    dst->rscale = src->rscale;
    dst->dscale = src->dscale;
    dst->sign = src->sign;
 
    if (alloc_var(dst, src->ndigits) != 0)
        return -1;
 
    for (i = 0; i < src->ndigits; i++)
        dst->digits[i] = src->digits[i];
 
    return 0;
}

Referenced by numericvar_to_double(), PGTYPESnumeric_from_double(), and PGTYPESnumeric_to_asc().

PGTYPESnumeric_div()

int PGTYPESnumeric_div	(	numeric *	var1,
		numeric *	var2,
		numeric *	result
	)

Definition at line 1053 of file numeric.c.

{
    NumericDigit *res_digits;
    int         res_ndigits;
    int         res_sign;
    int         res_weight;
    numeric     dividend;
    numeric     divisor[10];
    int         ndigits_tmp;
    int         weight_tmp;
    int         rscale_tmp;
    int         ri;
    long        guess;
    long        first_have;
    long        first_div;
    int         first_nextdigit;
    int         stat = 0;
    int         rscale;
    int         res_dscale = select_div_scale(var1, var2, &rscale);
    int         err = -1;
    NumericDigit *tmp_buf;
 
    /*
     * First of all division by zero check
     */
    ndigits_tmp = var2->ndigits + 1;
    if (ndigits_tmp == 1)
    {
        errno = PGTYPES_NUM_DIVIDE_ZERO;
        return -1;
    }
 
    /*
     * Determine the result sign, weight and number of digits to calculate
     */
    if (var1->sign == var2->sign)
        res_sign = NUMERIC_POS;
    else
        res_sign = NUMERIC_NEG;
    res_weight = var1->weight - var2->weight + 1;
    res_ndigits = rscale + res_weight;
    if (res_ndigits <= 0)
        res_ndigits = 1;
 
    /*
     * Now result zero check
     */
    if (var1->ndigits == 0)
    {
        zero_var(result);
        result->rscale = rscale;
        return 0;
    }
 
    /*
     * Initialize local variables
     */
    init_var(&dividend);
    for (int i = 1; i < 10; i++)
        init_var(&divisor[i]);
 
    /*
     * Make a copy of the divisor which has one leading zero digit
     */
    divisor[1].ndigits = ndigits_tmp;
    divisor[1].rscale = var2->ndigits;
    divisor[1].sign = NUMERIC_POS;
    divisor[1].buf = digitbuf_alloc(ndigits_tmp);
    if (divisor[1].buf == NULL)
        goto done;
    divisor[1].digits = divisor[1].buf;
    divisor[1].digits[0] = 0;
    memcpy(&(divisor[1].digits[1]), var2->digits, ndigits_tmp - 1);
 
    /*
     * Make a copy of the dividend
     */
    dividend.ndigits = var1->ndigits;
    dividend.weight = 0;
    dividend.rscale = var1->ndigits;
    dividend.sign = NUMERIC_POS;
    dividend.buf = digitbuf_alloc(var1->ndigits);
    if (dividend.buf == NULL)
        goto done;
    dividend.digits = dividend.buf;
    memcpy(dividend.digits, var1->digits, var1->ndigits);
 
    /*
     * Setup the result. Do the allocation in a temporary buffer first, so we
     * don't free result->buf unless we have successfully allocated a buffer
     * to replace it with.
     */
    tmp_buf = digitbuf_alloc(res_ndigits + 2);
    if (tmp_buf == NULL)
        goto done;
    digitbuf_free(result->buf);
    result->buf = tmp_buf;
    res_digits = result->buf;
    result->digits = res_digits;
    result->ndigits = res_ndigits;
    result->weight = res_weight;
    result->rscale = rscale;
    result->sign = res_sign;
    res_digits[0] = 0;
 
    first_div = divisor[1].digits[1] * 10;
    if (ndigits_tmp > 2)
        first_div += divisor[1].digits[2];
 
    first_have = 0;
    first_nextdigit = 0;
 
    weight_tmp = 1;
    rscale_tmp = divisor[1].rscale;
 
    for (ri = 0; ri <= res_ndigits; ri++)
    {
        first_have = first_have * 10;
        if (first_nextdigit >= 0 && first_nextdigit < dividend.ndigits)
            first_have += dividend.digits[first_nextdigit];
        first_nextdigit++;
 
        guess = (first_have * 10) / first_div + 1;
        if (guess > 9)
            guess = 9;
 
        while (guess > 0)
        {
            if (divisor[guess].buf == NULL)
            {
                int         i;
                long        sum = 0;
 
                memcpy(&divisor[guess], &divisor[1], sizeof(numeric));
                divisor[guess].buf = digitbuf_alloc(divisor[guess].ndigits);
                if (divisor[guess].buf == NULL)
                    goto done;
                divisor[guess].digits = divisor[guess].buf;
                for (i = divisor[1].ndigits - 1; i >= 0; i--)
                {
                    sum += divisor[1].digits[i] * guess;
                    divisor[guess].digits[i] = sum % 10;
                    sum /= 10;
                }
            }
 
            divisor[guess].weight = weight_tmp;
            divisor[guess].rscale = rscale_tmp;
 
            stat = cmp_abs(&dividend, &divisor[guess]);
            if (stat >= 0)
                break;
 
            guess--;
        }
 
        res_digits[ri + 1] = guess;
        if (stat == 0)
        {
            ri++;
            break;
        }
 
        weight_tmp--;
        rscale_tmp++;
 
        if (guess == 0)
            continue;
 
        if (sub_abs(&dividend, &divisor[guess], &dividend) != 0)
            goto done;
 
        first_nextdigit = dividend.weight - weight_tmp;
        first_have = 0;
        if (first_nextdigit >= 0 && first_nextdigit < dividend.ndigits)
            first_have = dividend.digits[first_nextdigit];
        first_nextdigit++;
    }
 
    result->ndigits = ri + 1;
    if (ri == res_ndigits + 1)
    {
        int         carry = (res_digits[ri] > 4) ? 1 : 0;
 
        result->ndigits = ri;
        res_digits[ri] = 0;
 
        while (carry && ri > 0)
        {
            carry += res_digits[--ri];
            res_digits[ri] = carry % 10;
            carry /= 10;
        }
    }
 
    while (result->ndigits > 0 && *(result->digits) == 0)
    {
        (result->digits)++;
        (result->weight)--;
        (result->ndigits)--;
    }
    while (result->ndigits > 0 && result->digits[result->ndigits - 1] == 0)
        (result->ndigits)--;
    if (result->ndigits == 0)
        result->sign = NUMERIC_POS;
 
    result->dscale = res_dscale;
    err = 0;                    /* if we've made it this far, return success */
 
done:
 
    /*
     * Tidy up
     */
    if (dividend.buf != NULL)
        digitbuf_free(dividend.buf);
 
    for (int i = 1; i < 10; i++)
    {
        if (divisor[i].buf != NULL)
            digitbuf_free(divisor[i].buf);
    }
 
    return err;
}

PGTYPESnumeric_free()

void PGTYPESnumeric_free

(

numeric *

var

)

Definition at line 385 of file numeric.c.

{
    digitbuf_free(var->buf);
    free(var);
}

Referenced by numericvar_to_double(), PGTYPESnumeric_from_asc(), PGTYPESnumeric_from_double(), and PGTYPESnumeric_to_asc().

PGTYPESnumeric_from_asc()

numeric * PGTYPESnumeric_from_asc	(	char *	str,
		char **	endptr
	)

Definition at line 321 of file numeric.c.

{
    numeric    *value = (numeric *) pgtypes_alloc(sizeof(numeric));
    int         ret;
 
    char       *realptr;
    char      **ptr = (endptr != NULL) ? endptr : &realptr;
 
    if (!value)
        return NULL;
 
    ret = set_var_from_str(str, ptr, value);
    if (ret)
    {
        PGTYPESnumeric_free(value);
        return NULL;
    }
 
    return value;
}

Referenced by PGTYPESnumeric_from_double().

PGTYPESnumeric_from_decimal()

int PGTYPESnumeric_from_decimal	(	decimal *	src,
		numeric *	dst
	)

Definition at line 1570 of file numeric.c.

{
    int         i;
 
    zero_var(dst);
 
    dst->weight = src->weight;
    dst->rscale = src->rscale;
    dst->dscale = src->dscale;
    dst->sign = src->sign;
 
    if (alloc_var(dst, src->ndigits) != 0)
        return -1;
 
    for (i = 0; i < src->ndigits; i++)
        dst->digits[i] = src->digits[i];
 
    return 0;
}

PGTYPESnumeric_from_double()

int PGTYPESnumeric_from_double	(	double	d,
		numeric *	dst
	)

Definition at line 1411 of file numeric.c.

{
    char        buffer[DBL_DIG + 100];
    numeric    *tmp;
    int         i;
 
    if (sprintf(buffer, "%.*g", DBL_DIG, d) <= 0)
        return -1;
 
    if ((tmp = PGTYPESnumeric_from_asc(buffer, NULL)) == NULL)
        return -1;
    i = PGTYPESnumeric_copy(tmp, dst);
    PGTYPESnumeric_free(tmp);
    if (i != 0)
        return -1;
 
    errno = 0;
    return 0;
}

PGTYPESnumeric_from_int()

int PGTYPESnumeric_from_int	(	signed int	int_val,
		numeric *	var
	)

Definition at line 1309 of file numeric.c.

{
    /* implicit conversion */
    signed long int long_int = int_val;
 
    return PGTYPESnumeric_from_long(long_int, var);
}

PGTYPESnumeric_from_long()

int PGTYPESnumeric_from_long	(	signed long int	long_val,
		numeric *	var
	)

Definition at line 1318 of file numeric.c.

{
    /* calculate the size of the long int number */
    /* a number n needs log_10 n digits */
 
    /*
     * however we multiply by 10 each time and compare instead of calculating
     * the logarithm
     */
 
    int         size = 0;
    int         i;
    signed long int abs_long_val = long_val;
    signed long int extract;
    signed long int reach_limit;
 
    if (abs_long_val < 0)
    {
        abs_long_val *= -1;
        var->sign = NUMERIC_NEG;
    }
    else
        var->sign = NUMERIC_POS;
 
    reach_limit = 1;
    do
    {
        size++;
        reach_limit *= 10;
    } while (reach_limit - 1 < abs_long_val && reach_limit <= LONG_MAX / 10);
 
    if (reach_limit > LONG_MAX / 10)
    {
        /* add the first digit and a .0 */
        size += 2;
    }
    else
    {
        /* always add a .0 */
        size++;
        reach_limit /= 10;
    }
 
    if (alloc_var(var, size) < 0)
        return -1;
 
    var->rscale = 1;
    var->dscale = 1;
    var->weight = size - 2;
 
    i = 0;
    do
    {
        extract = abs_long_val - (abs_long_val % reach_limit);
        var->digits[i] = extract / reach_limit;
        abs_long_val -= extract;
        i++;
        reach_limit /= 10;
 
        /*
         * we can abandon if abs_long_val reaches 0, because the memory is
         * initialized properly and filled with '0', so converting 10000 in
         * only one step is no problem
         */
    } while (abs_long_val > 0);
 
    return 0;
}

Referenced by PGTYPESnumeric_from_int().

PGTYPESnumeric_mul()

int PGTYPESnumeric_mul	(	numeric *	var1,
		numeric *	var2,
		numeric *	result
	)

Definition at line 896 of file numeric.c.

{
    NumericDigit *res_buf;
    NumericDigit *res_digits;
    int         res_ndigits;
    int         res_weight;
    int         res_sign;
    int         i,
                ri,
                i1,
                i2;
    long        sum = 0;
    int         global_rscale = var1->rscale + var2->rscale;
 
    res_weight = var1->weight + var2->weight + 2;
    res_ndigits = var1->ndigits + var2->ndigits + 1;
    if (var1->sign == var2->sign)
        res_sign = NUMERIC_POS;
    else
        res_sign = NUMERIC_NEG;
 
    if ((res_buf = digitbuf_alloc(res_ndigits)) == NULL)
        return -1;
    res_digits = res_buf;
    memset(res_digits, 0, res_ndigits);
 
    ri = res_ndigits;
    for (i1 = var1->ndigits - 1; i1 >= 0; i1--)
    {
        sum = 0;
        i = --ri;
 
        for (i2 = var2->ndigits - 1; i2 >= 0; i2--)
        {
            sum += res_digits[i] + var1->digits[i1] * var2->digits[i2];
            res_digits[i--] = sum % 10;
            sum /= 10;
        }
        res_digits[i] = sum;
    }
 
    i = res_weight + global_rscale + 2;
    if (i >= 0 && i < res_ndigits)
    {
        sum = (res_digits[i] > 4) ? 1 : 0;
        res_ndigits = i;
        i--;
        while (sum)
        {
            sum += res_digits[i];
            res_digits[i--] = sum % 10;
            sum /= 10;
        }
    }
 
    while (res_ndigits > 0 && *res_digits == 0)
    {
        res_digits++;
        res_weight--;
        res_ndigits--;
    }
    while (res_ndigits > 0 && res_digits[res_ndigits - 1] == 0)
        res_ndigits--;
 
    if (res_ndigits == 0)
    {
        res_sign = NUMERIC_POS;
        res_weight = 0;
    }
 
    digitbuf_free(result->buf);
    result->buf = res_buf;
    result->digits = res_digits;
    result->ndigits = res_ndigits;
    result->weight = res_weight;
    result->rscale = global_rscale;
    result->sign = res_sign;
    result->dscale = var1->dscale + var2->dscale;
 
    return 0;
}

PGTYPESnumeric_new()

numeric * PGTYPESnumeric_new

(

void

)

Definition at line 42 of file numeric.c.

{
    numeric    *var;
 
    if ((var = (numeric *) pgtypes_alloc(sizeof(numeric))) == NULL)
        return NULL;
 
    if (alloc_var(var, 0) < 0)
    {
        free(var);
        return NULL;
    }
 
    return var;
}

Referenced by numericvar_to_double(), and PGTYPESnumeric_to_asc().

PGTYPESnumeric_sub()

int PGTYPESnumeric_sub	(	numeric *	var1,
		numeric *	var2,
		numeric *	result
	)

Definition at line 765 of file numeric.c.

{
    /*
     * Decide on the signs of the two variables what to do
     */
    if (var1->sign == NUMERIC_POS)
    {
        if (var2->sign == NUMERIC_NEG)
        {
            /* ----------
             * var1 is positive, var2 is negative
             * result = +(ABS(var1) + ABS(var2))
             * ----------
             */
            if (add_abs(var1, var2, result) != 0)
                return -1;
            result->sign = NUMERIC_POS;
        }
        else
        {
            /* ----------
             * Both are positive
             * Must compare absolute values
             * ----------
             */
            switch (cmp_abs(var1, var2))
            {
                case 0:
                    /* ----------
                     * ABS(var1) == ABS(var2)
                     * result = ZERO
                     * ----------
                     */
                    zero_var(result);
                    result->rscale = Max(var1->rscale, var2->rscale);
                    result->dscale = Max(var1->dscale, var2->dscale);
                    break;
 
                case 1:
                    /* ----------
                     * ABS(var1) > ABS(var2)
                     * result = +(ABS(var1) - ABS(var2))
                     * ----------
                     */
                    if (sub_abs(var1, var2, result) != 0)
                        return -1;
                    result->sign = NUMERIC_POS;
                    break;
 
                case -1:
                    /* ----------
                     * ABS(var1) < ABS(var2)
                     * result = -(ABS(var2) - ABS(var1))
                     * ----------
                     */
                    if (sub_abs(var2, var1, result) != 0)
                        return -1;
                    result->sign = NUMERIC_NEG;
                    break;
            }
        }
    }
    else
    {
        if (var2->sign == NUMERIC_NEG)
        {
            /* ----------
             * Both are negative
             * Must compare absolute values
             * ----------
             */
            switch (cmp_abs(var1, var2))
            {
                case 0:
                    /* ----------
                     * ABS(var1) == ABS(var2)
                     * result = ZERO
                     * ----------
                     */
                    zero_var(result);
                    result->rscale = Max(var1->rscale, var2->rscale);
                    result->dscale = Max(var1->dscale, var2->dscale);
                    break;
 
                case 1:
                    /* ----------
                     * ABS(var1) > ABS(var2)
                     * result = -(ABS(var1) - ABS(var2))
                     * ----------
                     */
                    if (sub_abs(var1, var2, result) != 0)
                        return -1;
                    result->sign = NUMERIC_NEG;
                    break;
 
                case -1:
                    /* ----------
                     * ABS(var1) < ABS(var2)
                     * result = +(ABS(var2) - ABS(var1))
                     * ----------
                     */
                    if (sub_abs(var2, var1, result) != 0)
                        return -1;
                    result->sign = NUMERIC_POS;
                    break;
            }
        }
        else
        {
            /* ----------
             * var1 is negative, var2 is positive
             * result = -(ABS(var1) + ABS(var2))
             * ----------
             */
            if (add_abs(var1, var2, result) != 0)
                return -1;
            result->sign = NUMERIC_NEG;
        }
    }
 
    return 0;
}

PGTYPESnumeric_to_asc()

char * PGTYPESnumeric_to_asc	(	numeric *	num,
		int	dscale
	)

Definition at line 343 of file numeric.c.

{
    numeric    *numcopy = PGTYPESnumeric_new();
    char       *s;
 
    if (numcopy == NULL)
        return NULL;
 
    if (PGTYPESnumeric_copy(num, numcopy) < 0)
    {
        PGTYPESnumeric_free(numcopy);
        return NULL;
    }
 
    if (dscale < 0)
        dscale = num->dscale;
 
    /* get_str_from_var may change its argument */
    s = get_str_from_var(numcopy, dscale);
    PGTYPESnumeric_free(numcopy);
    return s;
}

Referenced by dump_sqlda(), and PGTYPESnumeric_to_long().

PGTYPESnumeric_to_decimal()

int PGTYPESnumeric_to_decimal	(	numeric *	src,
		decimal *	dst
	)

Definition at line 1547 of file numeric.c.

{
    int         i;
 
    if (src->ndigits > DECSIZE)
    {
        errno = PGTYPES_NUM_OVERFLOW;
        return -1;
    }
 
    dst->weight = src->weight;
    dst->rscale = src->rscale;
    dst->dscale = src->dscale;
    dst->sign = src->sign;
    dst->ndigits = src->ndigits;
 
    for (i = 0; i < src->ndigits; i++)
        dst->digits[i] = src->digits[i];
 
    return 0;
}

PGTYPESnumeric_to_double()

int PGTYPESnumeric_to_double	(	numeric *	nv,
		double *	dp
	)

Definition at line 1483 of file numeric.c.

{
    double      tmp;
 
    if (numericvar_to_double(nv, &tmp) != 0)
        return -1;
    *dp = tmp;
    return 0;
}

PGTYPESnumeric_to_int()

int PGTYPESnumeric_to_int	(	numeric *	nv,
		int *	ip
	)

Definition at line 1494 of file numeric.c.

{
    long        l;
    int         i;
 
    if ((i = PGTYPESnumeric_to_long(nv, &l)) != 0)
        return i;
 
/* silence compilers that might complain about useless tests */
#if SIZEOF_LONG > SIZEOF_INT
 
    if (l < INT_MIN || l > INT_MAX)
    {
        errno = PGTYPES_NUM_OVERFLOW;
        return -1;
    }
 
#endif
 
    *ip = (int) l;
    return 0;
}

PGTYPESnumeric_to_long()

int PGTYPESnumeric_to_long	(	numeric *	nv,
		long *	lp
	)

Definition at line 1518 of file numeric.c.

{
    char       *s = PGTYPESnumeric_to_asc(nv, 0);
    char       *endptr;
 
    if (s == NULL)
        return -1;
 
    errno = 0;
    *lp = strtol(s, &endptr, 10);
    if (endptr == s)
    {
        /* this should not happen actually */
        free(s);
        return -1;
    }
    free(s);
    if (errno == ERANGE)
    {
        if (*lp == LONG_MIN)
            errno = PGTYPES_NUM_UNDERFLOW;
        else
            errno = PGTYPES_NUM_OVERFLOW;
        return -1;
    }
    return 0;
}

Referenced by PGTYPESnumeric_to_int().

Variable Documentation

inp_sqlda

sqlda_t* inp_sqlda

Definition at line 128 of file sql-sqlda.c.

Referenced by main().

outp_sqlda

sqlda_t * outp_sqlda

Definition at line 128 of file sql-sqlda.c.

Referenced by main().

outp_sqlda1

sqlda_t * outp_sqlda1

Definition at line 128 of file sql-sqlda.c.

Referenced by main().