**      comes back for every column in every row. The DBPROCESS structure**      points to a linked-list of DBROW structures. Each DBROW strcture points**      to an array of DBROWDATA structures. Since every DBROWDATA structure**      contains pointers to separately allocated buffers, the members of**      each array are linked together in a singly-linked list, to facilitate**      the operation of simple row-freeing routines.*/struct dbrowdata{        BYTE            *data;          /* actual data for this column in this                                         * row                                         */        DBINT           datlen;         /* length, in bytes, of this data */	DBINT		maxtxtlen;	/* This used to keep track of the 					 * largest SYBTEXT/SYBIMAGE column					 * received so far.					 */        DBBINARY        dattxptr[DBTXPLEN];/* This data's text-ptr, if it's of                                         * type SYBTEXT.                                         */        DBTINYINT       dattxplen;      /* Length, in bytes, of the text-ptr. */        DBBINARY        dattxts[DBTXTSLEN];/* The text-timestamp of this text                                         * value.                                         */        DBTINYINT       dattxtslen;     /* Length, in bytes, of the                                         * text-timestamp.                                         */        struct dbrowdata        *datnext;};typedef struct dbrowdata        DBROWDATA;/*** DBTYPEINFO - This is the structure through which precision and scale** information for Numeric/Decimal datatypes gets passed*/typedef	struct	dbtypeinfo{	DBINT	precision;	DBINT	scale;} DBTYPEINFO;/***  BINDREC - This is the structure used to store information about**      which columns should be bound to which programming variables*/struct  bindrec{        BYTE            *bindvar;       /* ptr to program variable */        DBINT           bindlen;        /* length of program variable */        DB_BINDPROC_FUNC bindproc;  	/* procedure to use for data copy. */        DBINT           *bindnullind;   /* IBM-type indicator variable. */        DBINT           bindtype;       /* variable for indexing convertfunc                                        ** tables.                                        */	DBTYPEINFO	bindtypeinfo;	/* precision/scale info */};typedef struct bindrec  BINDREC;/*** NULLBIND - This structure is attached to the DBPROCESS and is used**      to determine what to bind when bind values are NULL.*/struct  nullbind{        DBBIT           nullbit;        DBTINYINT       nulltiny;        DBSMALLINT      nullsmall;        DBINT           nullint;        DBCHAR          *nullchar;        DBINT           nulllchar;      /* length of char string */        DBBINARY        *nullbinary;        DBINT           nulllbinary;    /* length of binary string */        DBDATETIME      nulldatetime;        DBMONEY         nullmoney;        DBFLT8          nullflt8;        DBCHAR          *nullstring;        DBCHAR          *nullntbstring;        DBVARYCHAR      nullvarychar;        DBVARYBIN       nullvarybin;        DBDATETIME4     nullsmalldatetime;        DBMONEY4        nullsmallmoney;        DBREAL          nullflt4;        DBNUMERIC       nullnumeric;        DBDECIMAL       nulldecimal;        DBCHAR          *nullsensitivity;        DBCHAR          *nullboundary;};typedef struct nullbind NULLBIND;/***  DBCOLINFO - This structure contains the format information about a column.**      There is a linked list of DBCOLINFO structures in the DBPROCESS**      structure.  There is one DBCOLINFO structure for each column in the**      target list of the current command.  Format information for**      alternate rows, like compute, is kept in the DBALTHEAD and**      DBALTINFO structures.*/struct dbcolinfo{        char    colname[DBMAXCOLNAME+1];/* column name */        BYTE    coltype;                /* column type */        DBINT   coludtype;              /* user-defined type */        DBINT   collen;                 /* max length of column */        DBINT   colprlen;               /* max printing length of column */        char    *colcontrol;            /* control format, if any */        struct bindrec  colbind;        /* binding info, if any */        int     coltable;               /* for browse mode: which table                                         * did this column come from?                                         */        BYTE            colstatus;      /* for browse mode: what kind of column                                         * is this?                                         */	BYTE		colrowstatus;	/* for holding status in the 					 * TDS_ROWFMT data stream					 */        char    colorigname[DBMAXCOLNAME+1];/* for browse mode: what is the name                                         * of the table column that provided                                         * this select-list member?                                         */        char    *coltxobjname;          /* the SQL Server always returns the                                         * qualified object-name for TEXT                                         * columns.                                         */	DBTYPEINFO	coltypeinfo;	/* precision/scale info for Numeric or					 * Decimal columns.					 */	DBBOOL		colhasnull;	/* Is column data null? */        struct dbcolinfo        *colnext;       /* next column */};typedef struct dbcolinfo        DBCOLINFO;/***  DBTABNAME - This structure contains information about the tables which**      were used to produce the current set of results. The SQL Server only**      provides this info for queries that are executed in "browse mode".****      There is a linked list of DBTABNAME structures in the DBPROCESS**      structure.  There is one DBTABNAME structure for each table used to**      produce the target list of the current command.****      If this query was executed without "browse mode", then this list will**      have no members.*/struct dbtabname{        char                    tabname[DBMAXNAME+1];   /* column name */        struct dbtabname        *tabnext;               /* next column */};typedef struct dbtabname        DBTABNAME;/***  DBALTHEAD - This structure contains information for ALT rows.  ALT**      rows are COMPUTE results.  There is one DBALTHEAD for each COMPUTE**      statement.  All the COMPUTE operators in a particular COMPUTE statement**      must have the same bylist -- this is enforced by the SQL Server.**      Off of each DBALTHEAD is a linked list of DBALTINFO structures that**      describe the format for each particular COMPUTE operation in the**      COMPUTE.*/struct  dbalthead{        DBUSMALLINT     althid;         /* id for this COMPUTE statement */        BYTE    althalts;       /* number of DBALTINFO structures in althlist */        BYTE    althsizeby;     /* number of elements in the bylist */        BYTE    althbylist[DBMAXBYLIST];        /* colids of bylist elements */        struct dbaltinfo        *althlist;      /* linked list of DBALTINFOs */        struct dbprlist         *althprlist;    /* order print list for aops */        struct dbalthead        *althnext;      /* next dbalthead */};typedef struct dbalthead        DBALTHEAD;typedef struct dbxlate{        void DBFAR *bufstart;    /* For use when freeing translation tables. */        void DBFAR *xlate;       /* Points to an INTL_XLATE structure. */} DBXLATE;/***  DBPRLIST - This structure is used to create an 'ordered' printing list**      for computes.  For example a compute might be:**              compute sum(col1), avg(col2), sum(col2), avg(col3), avg(col1)**      For printing, it would be nice to have a list that pointed to the**      right DBALTINFO structures like this:**              sum(col1)-->sum(col2)**                |**               \|/**              avg(col1)-->avg(col2)-->avg(col3)**      It is used by the praltrow function that dbprrow uses but the**      information could be used by any DBLIB client.*/struct  dbprlist{        DBROWDATA       *prdata;        /* actual data for the compute */        struct dbaltinfo        *prtarget;      /* related ALTINFO struct */        struct dbprlist         *prright;       /* next aop in compute */        struct dbprlist         *prdown;        /* next compute in query */};typedef struct dbprlist DBPRLIST;/***  DBALTINFO - This structure contains the format information about**      alternate rows.  Compute clauses produce alternate rows of data,**      interspersed with the regular data rows returned by the dataserver.**      There is a linked list of DBALTHEAD structures in the DBPROCESS**      structure.  There is one DBALTHEAD structure for each possible**      type of alternate row of the current command.  Format information for**      regular data rows is kept in the DBCOLINFO structure.*/struct dbaltinfo{        char    *altname;       /* null terminated string to alt header */        BYTE    alttoken;       /* type of alternate information */        BYTE    altcolid;       /* which target list member referenced */        BYTE    alttype;        /* column type */        DBINT   altudtype;      /* user-defined type */        DBINT   altlen;         /* max length of column */        DBINT   altprlen;       /* printing length of data */        char    *altcontrol;            /* control format, if any */	DBTYPEINFO	alttypeinfo;	/* precision/scale info for Numeric or					 * Decimal columns.					 */        struct dbprlist *altprlist;     /* ptr to ordered printing list */        struct bindrec  altbind;        /* binding info, if any */        struct dbaltinfo        *altnext;       /* next column */};typedef struct dbaltinfo        DBALTINFO;/***  DBROW - This structure is used to store the actual row and alternate row**      data returned by the dataserver.  The member of the DBPROCESS structure **      called dbfirstdata stores the doubly-linked list of rows.  If buffering**      is off, only one row is stored.  The rows are stored in the order that**      they are received from the server.*/struct dbrow{        DBINT           rowid;          /* this is the returned row number */        DBUSMALLINT     rowaltid;       /* for ALT rows, this is                                         * DBALTINFO.altid                                         */        DBROWDATA       *rowdata;       /* actual data */        DBBOOL          rowhasnull;     /* are there any NULLS in this row of                                         * data?                                         */        struct dbrow    *rowprev;       /* previous row if buffering on */        struct dbrow    *rownext;       /* next row if buffering on */};typedef struct dbrow    DBROW;/***  DBINFO - This structure is used to store information and error messages**      returned by the dataserver.****      NOTE - This structure is used by APT.**              Adding or deleting structure members should be done with**              care.*/struct dbinfo{        DBINT		infonum;        /* error or info number */        DBTINYINT	infostate;      /* error state number */        DBTINYINT	infoclass;      /* info class or error severity */        char DBFAR	*infotext;      /* null terminated message */        char DBFAR	*infoservname;  /* null terminated Server-name */        char DBFAR	*infoprocname;  /* null terminated procedure-name */        DBUSMALLINT     infolinenum;    /* stored-procedure line-number */        struct dbinfo DBFAR	*infonext;};typedef struct dbinfo   DBINFO;struct dbparam{	BYTE		namelen;	DBCHAR		paramname[DBMAXNAME + 1];	BYTE		status;	DBINT		usertype;	BYTE		datatype;	DBINT		maxdatalen;	DBTYPEINFO	paramtypeinfo;	DBINT		datalen;	BYTE		*data;	struct dbparam  *paramnext;};typedef struct dbparam       DBPARAM;struct dbmsg{	DBUSMALLINT	msgid;	DBUSMALLINT	nummsgparams;	DBPARAM		*param;};typedef struct dbmsg        DBMSG;/***  Options - both for the dataserver and DBLIB**      As additional options are added, they should be added here and in**      the Dboptdict array.*//*** dataserver options are defined in pss.h** dataserver options and their index into the Dboptdict array** Dboptdict is defined in options.c*/#define DBPARSEONLY     0#de