#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "tdsql.h"
 /* Global variables shared by subroutines */
int g_msglevel;
double g_activcount;
int g_errorcode;
char g_errormsg[260];
 /* Data descriptors for Results */
struct datadescr ddesc[3];
 /* Common variables within this file only */
static SV * c_msgl_sv;
static SV * c_actv_sv;
static SV * c_errc_sv;
static SV * c_emsg_sv;
 /* Many applications will use only one request at a time,
    so we pre-allocate this one to avoid having to allocate
    and free all the time.  */
Request  request0;
int  r0_in_use = 0;  /* Is it in use? */
static int
not_here(char *s)
{
    croak("%s not implemented on this architecture", s);
    return -1;
}
MODULE = Teradata::SQL          PACKAGE = Teradata::SQL
 # CONNECT to Teradata
SV *
Xconnect(log, ccs, tmode, logmech)
    PROTOTYPE:$$$$
    INPUT:
        char *          log
        char *          ccs
        char *          tmode
        char *          logmech
    PREINIT:
        pSession        sess_ptr;
        int             ok;
    CODE:
        c_msgl_sv = get_sv("Teradata::SQL::msglevel", FALSE);
        c_actv_sv = get_sv("Teradata::SQL::activcount", FALSE);
        c_errc_sv = get_sv("Teradata::SQL::errorcode", FALSE);
        c_emsg_sv = get_sv("Teradata::SQL::errormsg", FALSE);
        g_msglevel = SvIV(c_msgl_sv);
        New(0, sess_ptr, 1, Session);
        ok = Zconnect(sess_ptr, log, ccs, tmode, logmech);
        if (ok) {
           RETVAL = newSVpvn((char *) sess_ptr, sizeof(Session));
        } else {
           RETVAL = newSVpvn("NO SESS", 7);
        }
        Safefree(sess_ptr);
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # DISCONNECT
int
Xdisconnect(sess)
    PROTOTYPE:$
    INPUT:
        SV *    sess
    CODE:
        pSession  sess_ptr;
        g_msglevel = SvIV(c_msgl_sv);
        sess_ptr = (pSession) SvPV_nolen(sess);
        RETVAL = Zdisconnect(sess_ptr);
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # EXECUTE without arguments
int
Xexecute(sess, sql)
    PROTOTYPE:$$
    INPUT:
        SV *            sess
        char *          sql
    CODE:
        pSession  sess_ptr;
        g_msglevel = SvIV(c_msgl_sv);
        sess_ptr = (pSession) SvPV_nolen(sess);
        RETVAL = Zexecute(sess_ptr, sql);
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # OPEN without arguments
SV *
Xopen(sess, sql)
    PROTOTYPE:$$
    INPUT:
        SV *            sess
        char *          sql
    PREINIT:
        pSession        sess_ptr;
        Request         req;
        int             ok;
    CODE:
        g_msglevel = SvIV(c_msgl_sv);
        sess_ptr = (pSession) SvPV_nolen(sess);
        req.dbcp = &(sess_ptr->dbc);
        ok = Zopen(&req, sql);
        if (ok) {
           RETVAL = newSVpvn((char *) &req, sizeof(Request));
        } else {
           RETVAL = newSV(0);  /* undef */
        }
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # EXECUTE a prepared request with optional arguments
int
Xexecutep(sess, sql, ...)
    PROTOTYPE:$$
    INPUT:
        SV *            sess
        char *          sql
    PREINIT:
        pSession        sess_ptr;
        int             i, nindic, idlen, nargs;
        Int32           wint;
        char *          sptr;
        STRLEN          slen;
        double          wdouble;
        Byte            hv_data[MAX_RDA_LEN];
        Byte *          hvdata_ptr;
        Byte *          hvindic_ptr;
        Byte            indic_mask;
        struct ModCliDataInfoType  hv_datainfo;
        struct ModCliDInfoType * hv_datainfo_ptr;
    CODE:
        g_msglevel = SvIV(c_msgl_sv);
        sess_ptr = (pSession) SvPV_nolen(sess);
        if (items == 2) {
           RETVAL = Zexecutep(sess_ptr, sql);
        } else {
            /* Store the Perl variables in an IndicData array. */
            /* First, reserve the indicator bytes. */
           nargs = items - 2;
           nindic = (nargs + 7) / 8;
           idlen = nindic;  /* IndicData length in bytes */
           hvindic_ptr = hv_data;
           *hvindic_ptr = 0x00;
           indic_mask = 0x80;
           hvdata_ptr = hv_data + nindic;
            /* DataInfo */
           hv_datainfo.FieldCount = (PclWord) nargs;
           hv_datainfo_ptr = &(hv_datainfo.InfoVar[0]);
           for (i = 2; i < items; i++) {
              if ( SvIOK(ST(i)) ) {
                 hv_datainfo_ptr->SQLType = INTEGER_N;
                 hv_datainfo_ptr->SQLLen = 4;
                 wint = SvIV(ST(i));
                 memcpy(hvdata_ptr, &wint, 4);
                 hvdata_ptr += 4;
                 idlen += 4;
              } else if ( SvNOK(ST(i)) ) {
                 hv_datainfo_ptr->SQLType = FLOAT_N;
                 hv_datainfo_ptr->SQLLen = 8;
                 wdouble = SvNV(ST(i));
                 memcpy(hvdata_ptr, &wdouble, 8);
                 hvdata_ptr += 8;
                 idlen += 8;
              } else if ( SvPOK(ST(i)) ) {
                 sptr = SvPV(ST(i), slen);
                 hv_datainfo_ptr->SQLType = CHAR_N;
                 hv_datainfo_ptr->SQLLen = slen;
                 memcpy(hvdata_ptr, sptr, slen);
                 hvdata_ptr += slen;
                 idlen += slen;
              } else {  /* Null */
                 hv_datainfo_ptr->SQLType = INTEGER_N;
                 hv_datainfo_ptr->SQLLen = 4;
                 wint = 0;
                 memcpy(hvdata_ptr, &wint, 4);
                 *hvindic_ptr |= indic_mask;
                 hvdata_ptr += 4;
                 idlen += 4;
              }
               /* Point to the next DataInfo field. */
              hv_datainfo_ptr++;
               /* Point to the next indicator bit. */
              if (indic_mask != 0x01) {
                 indic_mask >>= 1;
              } else {
                 indic_mask = 0x80;
                 hvindic_ptr++;
              }
           }
           RETVAL = Zexecutep_args(sess_ptr, sql, &hv_datainfo,
             hv_data, idlen);
        }
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # OPEN without arguments, segmented
SV *
Xopenseg(sess, sql, save_spl)
    PROTOTYPE:$$
    INPUT:
        SV *            sess
        char *          sql
        char *          save_spl
    PREINIT:
        pSession        sess_ptr;
        Request         req;
        int             ok;
    CODE:
        g_msglevel = SvIV(c_msgl_sv);
        sess_ptr = (pSession) SvPV_nolen(sess);
        req.dbcp = &(sess_ptr->dbc);
        ok = Zopenseg(&req, sql, save_spl);
        if (ok) {
           RETVAL = newSVpvn((char *) &req, sizeof(Request));
        } else {
           RETVAL = newSV(0);  /* undef */
        }
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # OPEN a prepared request with optional arguments
SV *
Xopenp(sess, sql, ...)
    PROTOTYPE:$$
    INPUT:
        SV *            sess
        char *          sql
    PREINIT:
        int             i, wint, nindic, idlen, nargs;
        int             ok;
        pSession        sess_ptr;
        Request         req;
        char *          sptr;
        STRLEN          slen;
        double          wdouble;
        Byte            hv_data[MAX_RDA_LEN]; /* "host variables" */
        Byte *          hvdata_ptr;
        Byte *          hvindic_ptr;
        Byte            indic_mask;
        struct ModCliDataInfoType  hv_datainfo;
        struct ModCliDInfoType * hv_datainfo_ptr;
    CODE:
        g_msglevel = SvIV(c_msgl_sv);
        sess_ptr = (pSession) SvPV_nolen(sess);
        req.dbcp = &(sess_ptr->dbc);
        if (items == 2) {
           ok = Zopenp(&req, sql);
        } else {
            /* Store the Perl variables in an IndicData array. */
            /* First, reserve the indicator bytes. */
           nargs = items - 2;
           nindic = (nargs + 7) / 8;
           idlen = nindic;  /* IndicData length in bytes */
           hvindic_ptr = hv_data;
           *hvindic_ptr = 0x00;
           indic_mask = 0x80;
           hvdata_ptr = hv_data + nindic;
            /* DataInfo */
           hv_datainfo.FieldCount = (PclWord) nargs;
           hv_datainfo_ptr = &(hv_datainfo.InfoVar[0]);
           for (i = 2; i < items; i++) {
              if ( SvIOK(ST(i)) ) {
                 hv_datainfo_ptr->SQLType = INTEGER_N;
                 hv_datainfo_ptr->SQLLen = 4;
                 wint = SvIV(ST(i));
                 memcpy(hvdata_ptr, &wint, 4);
                 hvdata_ptr += 4;
                 idlen += 4;
              } else if ( SvNOK(ST(i)) ) {
                 hv_datainfo_ptr->SQLType = FLOAT_N;
                 hv_datainfo_ptr->SQLLen = 8;
                 wdouble = SvNV(ST(i));
                 memcpy(hvdata_ptr, &wdouble, 8);
                 hvdata_ptr += 8;
                 idlen += 8;
              } else if ( SvPOK(ST(i)) ) {
                 sptr = SvPV(ST(i), slen);
                 hv_datainfo_ptr->SQLType = CHAR_N;
                 hv_datainfo_ptr->SQLLen = slen;
                 memcpy(hvdata_ptr, sptr, slen);
                 hvdata_ptr += slen;
                 idlen += slen;
              } else {  /* Null */
                 hv_datainfo_ptr->SQLType = INTEGER_N;
                 hv_datainfo_ptr->SQLLen = 4;
                 wint = 0;
                 memcpy(hvdata_ptr, &wint, 4);
                 *hvindic_ptr |= indic_mask;
                 hvdata_ptr += 4;
                 idlen += 4;
              }
               /* Point to the next DataInfo field. */
              hv_datainfo_ptr++;
               /* Point to the next indicator bit. */
              if (indic_mask != 0x01) {
                 indic_mask >>= 1;
              } else {
                 indic_mask = 0x80;
                 hvindic_ptr++;
              }
           }
           ok = Zopenp_args(&req, sql,
             &hv_datainfo, hv_data, idlen);
        }
        if (ok) {
           RETVAL = newSVpvn((char *) &req, sizeof(Request));
        } else {
           RETVAL = newSV(0);  /* undef */
        }
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # FETCH. Last argument says whether this is fetching into a
 # hash or not.
void
Xfetch(req, hash)
    PROTOTYPE:$$
    INPUT:
        SV *            req
        int             hash
    PREINIT:
        int             i, decp, decs;
        pRequest        req_ptr;
        STRLEN          slen;
        Int16           dlen; /* data length */
        char *          sptr;
        char *          ret_data;
        Byte *          indic_ptr;
        Byte *          data_ptr;
        struct datadescr * ddesc_ptr;
        Int32           wint;
        double          wdouble;
        char            wstring[24];
        Byte            indic_mask;
    PPCODE:
        g_msglevel = SvIV(c_msgl_sv);
        req_ptr = (pRequest) SvPV_nolen(req);
        ret_data = Zfetch(req_ptr);
        if (ret_data) {
           ddesc_ptr = &(req_ptr->ddesc);
            /* Point to the indicators and the data. */
           indic_ptr = (Byte *) ret_data;
           indic_mask = 0x80;
           data_ptr = ((Byte *) ret_data) + ( (ddesc_ptr->nfields + 7) / 8);
           for (i = 0; i < ddesc_ptr->nfields; i++) {
               /* If this is a hash request, push the name first. */
              if (hash) {
                 slen = strlen(ddesc_ptr->sqlvar[i].colident);
                 sptr = (char *)ddesc_ptr->sqlvar[i].colident;
                 XPUSHs(sv_2mortal(newSVpvn(sptr, slen)));
              }
               /* Now push the value, testing for null first. */
              switch (ddesc_ptr->sqlvar[i].sqltype) {
               case INTEGER_N:
                  if ( (*indic_ptr & indic_mask) > 0) { /* Null */
                     XPUSHs(&PL_sv_undef);
                  } else {
                     wint = *((Int32 *)data_ptr) + 0;
                     XPUSHs(sv_2mortal(newSViv(wint)));
                  }
                  data_ptr += 4;
                  break;
               case SMALLINT_N:
                  if ( (*indic_ptr & indic_mask) > 0) {
                     XPUSHs(&PL_sv_undef);
                  } else {
                     wint = *((Int16 *)data_ptr) + 0;
                     XPUSHs(sv_2mortal(newSViv(wint)));
                  }
                  data_ptr += 2;
                  break;
               case BYTEINT_N:
                  if ( (*indic_ptr & indic_mask) > 0) {
                     XPUSHs(&PL_sv_undef);
                  } else {
                     wint = *((ByteInt *)data_ptr) + 0;
                     XPUSHs(sv_2mortal(newSViv(wint)));
                  }
                  data_ptr++;
                  break;
               case CHAR_N:
                  slen = ddesc_ptr->sqlvar[i].datalen;
                  if ( (*indic_ptr & indic_mask) > 0) {
                     XPUSHs(&PL_sv_undef);
                  } else {
                     sptr = (char *) data_ptr;
                     XPUSHs(sv_2mortal(newSVpvn(sptr, slen)));
                  }
                  data_ptr += slen;
                  break;
               case VARCHAR_N:
                  slen = *((UInt16 *) data_ptr);
                  if ( (*indic_ptr & indic_mask) > 0) {
                     XPUSHs(&PL_sv_undef);
                  } else {
                     sptr = (char *) (data_ptr + 2);
                     XPUSHs(sv_2mortal(newSVpvn(sptr, slen)));
                  }
                  data_ptr += slen + 2;
                  break;
               case DECIMAL_N:
                   /* Decimal precision and scale */
                  decp = ddesc_ptr->sqlvar[i].datalen;
                  decs = ddesc_ptr->sqlvar[i].decscale;
                  if ( (*indic_ptr & indic_mask) > 0) {
                     XPUSHs(&PL_sv_undef);
                     data_ptr += ddesc_ptr->sqlvar[i].dlb;
                  } else if (decp <= 9) {
                     wdouble = _dec_to_double(data_ptr, decp, decs);
                     XPUSHs(sv_2mortal(newSVnv(wdouble)));
                     data_ptr += ddesc_ptr->sqlvar[i].dlb;
                  } else if (decp <= 18) {
                     _dec_to_string(wstring, data_ptr, decs);
                     slen = strlen(wstring);
                     XPUSHs(sv_2mortal(newSVpvn(wstring, slen)));
                     data_ptr += 8;
                  } else {
                     if (g_msglevel > 0)
                        warn("Decimal field too large");
                     XPUSHs(sv_2mortal(newSVnv(0.0)));
                     data_ptr += 16;
                  }
                  break;
               case BIGINT_N:
                  if ( (*indic_ptr & indic_mask) > 0) {
                     XPUSHs(&PL_sv_undef);
                  } else {
                     _dec_to_string(wstring, data_ptr, 0);
                     slen = strlen(wstring);
                     XPUSHs(sv_2mortal(newSVpvn(wstring, slen)));
                  }
                  data_ptr += 8;
                  break;
               case NUMBER_N:
                   /* Precision and scale */
                  dlen = 0 + *((char *) data_ptr);
                  decp = ddesc_ptr->sqlvar[i].datalen;
                  decs = ddesc_ptr->sqlvar[i].decscale;
                  if ( (*indic_ptr & indic_mask) > 0) {
                     XPUSHs(&PL_sv_undef);
                     data_ptr += dlen + 1;
                  } else if (dlen <= 9) {
                     wdouble = _num_to_double(data_ptr);
                     XPUSHs(sv_2mortal(newSVnv(wdouble)));
                     data_ptr += dlen + 1;
                  } else if (dlen == 10) {
                     _num_to_string(wstring, data_ptr);
                     slen = strlen(wstring);
                     XPUSHs(sv_2mortal(newSVpvn(wstring, slen)));
                     data_ptr += dlen + 1;
                  } else {
                     if (g_msglevel > 0)
                        warn("Number field too large");
                     XPUSHs(sv_2mortal(newSVnv(0.0)));
                     data_ptr += dlen + 1;
                  }
                  break;
               case FLOAT_N:
                  if ( (*indic_ptr & indic_mask) > 0) {
                     XPUSHs(&PL_sv_undef);
                  } else {
                     wdouble = *((double *) data_ptr);
                     XPUSHs(sv_2mortal(newSVnv(wdouble)));
                  }
                  data_ptr += 8;
                  break;
               default:
                  croak("Data type %d not supported\n",
                   ddesc_ptr->sqlvar[i].sqltype);
              }
                /* Point to the next indicator bit. */
              if (indic_mask != 0x01) {
                 indic_mask >>= 1;
              } else {
                 indic_mask = 0x80;
                 indic_ptr++;
              }
           }
        }
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
 # CLOSE
int
Xclose(req)
    PROTOTYPE:$
    INPUT:
        SV *            req
    CODE:
        pRequest        req_ptr;
        g_msglevel = SvIV(c_msgl_sv);
        req_ptr = (pRequest) SvPV_nolen(req);
        RETVAL = Zclose(req_ptr);
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # ABORT (DBFABT)
int
Xabort(sess)
    PROTOTYPE:$
    INPUT:
        SV *            sess
    CODE:
        pSession        sess_ptr;
        g_msglevel = SvIV(c_msgl_sv);
        sess_ptr = (pSession) SvPV_nolen(sess);
        RETVAL = Zabort(sess_ptr);
        sv_setnv(c_actv_sv, g_activcount);
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);
    OUTPUT:
        RETVAL
 # SERVER_INFO (DBCHQE)
void
Xserver_info(server, qepitem)
    PROTOTYPE:$$
    INPUT:
        char *          server
        int             qepitem
    PREINIT:
        int             wint, string_len;
        int             ok;
         /* DBCHQE request area */
        DBCHQEP         our_qep;
         /* Data returned from DBCHQE */
        Byte            hqe_ret_data[200];
        char *          RArea_char_ptr;
        char *          ret_ptr;
         /* Error message from DBCHQE */
        char            hqe_message[258];
        struct QEPDBLIMIT_  our_dblimit;
    PPCODE:
        c_msgl_sv = get_sv("Teradata::SQL::msglevel", FALSE);
        c_errc_sv = get_sv("Teradata::SQL::errorcode", FALSE);
        c_emsg_sv = get_sv("Teradata::SQL::errormsg", FALSE);
        g_msglevel = SvIV(c_msgl_sv);
          /* Store the fields needed for the request. */
        our_qep.qepLevel = QEPL10NLVL1;
        our_qep.qepItem = qepitem;
        our_qep.qepTLen = strlen(server);
#ifdef CLI_64BIT
        our_qep.qepTIdP = server;
#else
         /* 32-bit CLI insanely defines this as an Int32!! */
        our_qep.qepTDP = (Int32) server;
#endif
        our_qep.qepRALen = 200;
        our_qep.qepRArea = hqe_ret_data;
        memcpy(our_qep.qepMLid, "EN", 2);
        our_qep.qepMsgP = hqe_message;
        our_qep.qepMsgM = 256;
        ok = Zserver_info(&our_qep);
        if (ok) {
           RArea_char_ptr = (char *) our_qep.qepRArea;
           switch (our_qep.qepItem) {
            case QEPIDBR:       /* DBS release info */
              /* Returned to perl as a two-element list */
              ret_ptr = RArea_char_ptr;
              for (string_len=0; string_len < 30; string_len++) {
                 if (*ret_ptr == ' ') break;
                 else ret_ptr++;
              }
              XPUSHs(sv_2mortal(newSVpvn(RArea_char_ptr, string_len)));
              RArea_char_ptr += 30;
              ret_ptr = RArea_char_ptr;
              for (string_len=0; string_len < 32; string_len++) {
                 if (*ret_ptr == ' ') break;
                 else ret_ptr++;
              }
              XPUSHs(sv_2mortal(newSVpvn(RArea_char_ptr, string_len)));
              break;
            case QEPISC:        /* char set */
            case QEPICL2R:      /* CLIv2 Release Info */
            case QEPIASL:       /* server default char set */
            case QEPIDCS:       /* server default char set */
              XPUSHs(sv_2mortal(newSVpvn(RArea_char_ptr,
                 our_qep.qepRDLen)));
              break;
            case QEPIFTSM:      /* transaction semantics */
            case QEPIFLCS:      /* lang-conformance support */
            case QEPIFUCR:      /* updatable cursor support */
            case QEPIFRFI:      /* referential integ. support */
            case QEPIDTSM:      /* tx_semantics default */
            case QEP64K:        /* 64KB parcel support */
            case QEPIFSSO:      /* SSO support */
            case QEPIFUPS:      /* Atomic UPSERT support */
            case QEPIAOP:       /* array-ops support */
            case QEPIFMRG:      /* Merge-Into support */
            case QEPIFLOB:      /* LOB support */
            case QEPIXRS:       /* extended response support */
            case QEPIUD:        /* Identity Column Support */
            case QEPIRPO:       /* cursor positioning sup. */
            case QEPIESS:       /* Enhanced Statement Status */
            case QEPIUDT:       /* User-defined types */
            case QEPIRCA:       /* relaxed call arguments */
              XPUSHs(sv_2mortal(newSVpvn(our_qep.qepRArea, 1)));
              break;
            case QEPIDPF:       /* internal (V)AMP count */
            case QEPIDMSS:      /* MaxSegmentSize */
              wint = *((int *)our_qep.qepRArea);
              XPUSHs(sv_2mortal(newSViv(wint)));
              break;
            case QEPIEPU:       /* enlarged parcel (APH) support */
            case QEPIAPH:       /* APH responses */
              wint = *((Int16 *)our_qep.qepRArea);
              XPUSHs(sv_2mortal(newSViv(wint)));
              break;
            case QEPITPR:       /* precision on timestamp */
              wint = *((Int16 *)RArea_char_ptr);
              XPUSHs(sv_2mortal(newSViv(wint)));
              wint = *((Int16 *)(RArea_char_ptr + 2));
              XPUSHs(sv_2mortal(newSViv(wint)));
              break;
            case QEPISQL:       /* SQL limits */
              memcpy(&our_dblimit, our_qep.qepRArea,
                sizeof(struct QEPDBLIMIT_));
              wint = (int) our_dblimit.MaxRowBytes;
              XPUSHs(sv_2mortal(newSViv(wint)));
              wint = (int) our_dblimit.MaxLobBytes;
              XPUSHs(sv_2mortal(newSViv(wint)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxObjectNameChars)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxColinTbl)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxTblinSel)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxColinSel)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxColGrpBy)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxColOrdrBy)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxCharLiteralChars)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxBinLiteralChars)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxColBytes)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxCharChars)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxVarcharChars)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxGraphicChars)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxVargraphicChars)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxByteBytes)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxVarbyteBytes)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxDecimal)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxTimeScale)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxTimeStampScale)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxIntervalToSecondScale)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxFldsUsingRow)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxParamsInRequest)));
              XPUSHs(sv_2mortal(newSViv(our_dblimit.MaxSPParams)));
              break;
            /*case QEPIACS:   not implemented */
            /* remainder are undocumented or not implemented here */
            default:
              XPUSHs(&PL_sv_undef);
           }
        } else {
           XPUSHs(&PL_sv_undef);
        }
        sv_setiv(c_errc_sv, g_errorcode);
        sv_setpv(c_emsg_sv, g_errormsg);