home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / perl502b.zip / ext / DB2CLI / DB2CLI.xs < prev    next >
Text File  |  1995-08-12  |  24KB  |  1,061 lines
  1. #include "EXTERN.h"
  2. #include "perl.h"
  3. #include "XSUB.h"
  4.  
  5. #include <limits.h>
  6. #include <string.h>
  7. #include <sqlcli.h>
  8. #include <sqlcli1.h>
  9. #include <sqlext.h>
  10.  
  11. #include "const.h"
  12.  
  13. #define    SmallSize    32767
  14. #define    HugeSize    (1024 * 1024)
  15.  
  16. static struct {
  17.     SQLINTEGER    length;
  18.     SQLCHAR        buffer[HugeSize];
  19. } buffer;
  20. static SQLSMALLINT    len1, len2;
  21. #define buf1        (buffer.buffer + 0)
  22. #define buf2        (buffer.buffer + SmallSize)
  23.  
  24. static int        db2cli_debug;
  25.  
  26. typedef struct {
  27.     STRLEN    len;
  28.     char *    ptr;
  29. } SQLString, SQLLargeString;
  30.  
  31. typedef struct {
  32.     int    code;
  33.     char *    text;
  34. } TypeMap;
  35.  
  36. static SQLString null = { 0, "" };
  37.  
  38. static void
  39. initialize(void)
  40. {
  41.     char *cp = getenv("DB2CLI_DEBUG");
  42.     if (cp)
  43.         db2cli_debug = atoi(cp);
  44. }
  45.  
  46. static TypeMap cTypes[] = {
  47.     { SQL_C_CHAR, "SQL_C_CHAR" },
  48.     { SQL_C_LONG, "SQL_C_LONG" },
  49.     { SQL_C_SHORT, "SQL_C_SHORT" },
  50.     { SQL_C_FLOAT, "SQL_C_FLOAT" },
  51.     { SQL_C_DOUBLE, "SQL_C_DOUBLE" },
  52.     { SQL_C_DATE, "SQL_C_DATE" },
  53.     { SQL_C_TIME, "SQL_C_TIME" },
  54.     { SQL_C_TIMESTAMP, "SQL_C_TIMESTAMP" },
  55.     { SQL_C_BINARY, "SQL_C_BINARY" },
  56.     { SQL_C_BIT, "SQL_C_BIT" },
  57.     { SQL_C_TINYINT, "SQL_C_TINYINT" },
  58.     { SQL_C_DBCHAR, "SQL_C_DBCHAR" },
  59.     { SQL_C_SLONG, "SQL_C_SLONG" },
  60.     { SQL_C_SSHORT, "SQL_C_SSHORT" },
  61.     { SQL_C_STINYINT, "SQL_C_STINYINT" },
  62.     { SQL_C_ULONG, "SQL_C_ULONG" },
  63.     { SQL_C_USHORT, "SQL_C_USHORT" },
  64.     { SQL_C_UTINYINT, "SQL_C_UTINYINT" },
  65.     { SQL_C_BLOB_LOCATOR, "SQL_C_BLOB_LOCATOR" },
  66.     { SQL_C_CLOB_LOCATOR, "SQL_C_CLOB_LOCATOR" },
  67.     { SQL_C_DBCLOB_LOCATOR, "SQL_C_DBCLOB_LOCATOR" },
  68.     { 0, 0 }
  69. };
  70.  
  71. static TypeMap sqlTypes[] = {
  72.     { SQL_CHAR, "SQL_CHAR" },
  73.     { SQL_NUMERIC, "SQL_NUMERIC" },
  74.     { SQL_DECIMAL, "SQL_DECIMAL" },
  75.     { SQL_INTEGER, "SQL_INTEGER" },
  76.     { SQL_SMALLINT, "SQL_SMALLINT" },
  77.     { SQL_FLOAT, "SQL_FLOAT" },
  78.     { SQL_REAL, "SQL_REAL" },
  79.     { SQL_DOUBLE, "SQL_DOUBLE" },
  80.     { SQL_DATE, "SQL_DATE" },
  81.     { SQL_TIME, "SQL_TIME" },
  82.     { SQL_TIMESTAMP, "SQL_TIMESTAMP" },
  83.     { SQL_VARCHAR, "SQL_VARCHAR" },
  84.     { SQL_LONGVARCHAR, "SQL_LONGVARCHAR" },
  85.     { SQL_BINARY, "SQL_BINARY" },
  86.     { SQL_VARBINARY, "SQL_VARBINARY" },
  87.     { SQL_LONGVARBINARY, "SQL_LONGVARBINARY" },
  88.     { SQL_BIGINT, "SQL_BIGINT" },
  89.     { SQL_TINYINT, "SQL_TINYINT" },
  90.     { SQL_BIT, "SQL_BIT" },
  91.     { SQL_GRAPHIC, "SQL_GRAPHIC" },
  92.     { SQL_VARGRAPHIC, "SQL_VARGRAPHIC" },
  93.     { SQL_LONGVARGRAPHIC, "SQL_LONGVARGRAPHIC" },
  94.     { SQL_BLOB, "SQL_BLOB" },
  95.     { SQL_CLOB, "SQL_CLOB" },
  96.     { SQL_DBCLOB, "SQL_DBCLOB" },
  97.     { 0, 0 }
  98. };
  99.  
  100. static char *
  101. mapCode(int code, TypeMap *p)
  102. {
  103.     static char s[10];
  104.     for (; p->text; ++p)
  105.         if (p->code == code)
  106.             return p->text;
  107.     sprintf(s, "%d", code);
  108.     return s;
  109. }
  110.  
  111. static __inline__ SQLString
  112. getstr(SV *sv, int max)
  113. {
  114.     SQLString r;
  115.     r.ptr = SvPV(sv, r.len);
  116.     if (r.len > max)
  117.         r.len = max;
  118.     return r;
  119. }
  120.  
  121.  
  122. static void
  123. dump_var(int sqlType, int prec, void *value)
  124. {
  125.     fprintf(stderr, "\tvalue=%p:", value);
  126.     switch (sqlType) {
  127.     case SQL_INTEGER:
  128.         fprintf(stderr, "%ld\n", *(long *)value);
  129.         break;
  130.     case SQL_DOUBLE:
  131.         fprintf(stderr, "%g\n", *(double *)value);
  132.         break;
  133.     default:
  134.       { int x;
  135.         char *cp = (char *)value;
  136.         fputc('\'', stderr);
  137.         for (x = 0; x < prec; ++x)
  138.         if (cp[x] == '\'')
  139.             fputs("\\'", stderr);
  140.         else if (isprint(cp[x]))
  141.             fputc(cp[x], stderr);
  142.         else
  143.             fprintf(stderr, "\\x%02X", (unsigned char)cp[x]);
  144.         fputs("'\n", stderr);
  145.       }
  146.     }
  147. }
  148.  
  149. static void *
  150. bindParams(SQLHSTMT hstmt, SV **args, int nargs, SQLRETURN *retval, int direct)
  151. {
  152.     int i;
  153.     SQLSMALLINT nparams;
  154.     struct Parm {
  155.         union {
  156.             long    ival;
  157.             double    nval;
  158.         }        val;
  159.         SQLINTEGER    len;
  160.     } *a;
  161.  
  162.     if (direct) {
  163.         nparams = nargs;
  164.         *retval = SQLFreeStmt(hstmt, SQL_RESET_PARAMS);
  165.     } else
  166.         *retval = SQLNumParams(hstmt, &nparams);
  167.     if (*retval != SQL_SUCCESS)
  168.         return 0;
  169.     if (nparams)
  170.         a = malloc(nparams * sizeof(struct Parm));
  171.     else
  172.         a = 0;
  173.     for (i = 0; i < nparams; ++i) {
  174.         struct Parm *ap = &a[i];
  175.         SQLSMALLINT cType = SQL_C_CHAR;
  176.         SQLSMALLINT sqlType = SQL_CHAR;
  177.         SQLUINTEGER prec = 1;
  178.         SQLPOINTER  value = "";
  179.         ap->len = SQL_NULL_DATA;
  180.         if (i < nargs) {
  181.         SV *sv = args[i];
  182.         if (SvOK(sv)) {
  183.             if (SvIOKp(sv)) {
  184.             ap->val.ival = SvIV(sv);
  185.             ap->len = sizeof(long);
  186.             cType = SQL_C_LONG;
  187.             sqlType = SQL_INTEGER;
  188.             value = &ap->val.ival;
  189.             } else if (SvNOKp(sv)) {
  190.             ap->val.nval = SvNV(sv);
  191.             ap->len = sizeof(double);
  192.             cType = SQL_C_DOUBLE;
  193.             sqlType = SQL_DOUBLE;
  194.             value = &ap->val.nval;
  195.             } else if (SvPOKp(sv)) {
  196.             value = SvPV(sv,prec);
  197.             ap->len = prec;
  198.             }
  199.         }
  200.         }
  201.         *retval = SQLBindParameter(hstmt, 1+i, SQL_PARAM_INPUT, cType, sqlType,
  202.                 prec, 0, value, prec, &ap->len);
  203.         if (db2cli_debug)
  204.         fprintf(stderr, "bind #%d cType=%s sqlType=%s prec=%d len=%d retval=%d\n",
  205.             1+i, mapCode(cType,cTypes), mapCode(sqlType,sqlTypes), prec, ap->len, *retval);
  206.         if (db2cli_debug >= 2)
  207.         dump_var(sqlType, prec, value);
  208.         if (*retval < 0) {
  209.         free(a);
  210.         return 0;
  211.         }
  212.     }
  213.     return a;
  214. }
  215.  
  216. static void *
  217. bindParams2(SQLHSTMT hstmt, SV **args, int nargs, SQLRETURN *retval, int direct)
  218. {
  219.     dXSARGS;
  220.     int i, k;
  221.     SQLSMALLINT nparams;
  222.     struct Parm {
  223.         union {
  224.             long    ival;
  225.             double    nval;
  226.         }        val;
  227.         SQLINTEGER    len;
  228.     } *a;
  229.         
  230.     if (direct) {
  231.         nparams = nargs / 3;
  232.         *retval = SQLFreeStmt(hstmt, SQL_RESET_PARAMS);
  233.     } else
  234.         *retval = SQLNumParams(hstmt, &nparams);
  235.     if (*retval != SQL_SUCCESS)
  236.         return 0;
  237.     if (nparams)
  238.         a = malloc(nparams * sizeof(struct Parm));
  239.     else
  240.         a = 0;
  241.     for (i = k = 0; i < nparams; ++i, k += 3) {
  242.         struct Parm *ap = &a[i];
  243.         SQLSMALLINT cType = (k+0 < nargs) ? SvIV(args[k+0]) : SQL_C_CHAR;
  244.         SQLSMALLINT sqlType = (k+1 < nargs) ? SvIV(args[k+1]) : SQL_CHAR;
  245.         SQLUINTEGER prec = 1;
  246.         SQLPOINTER  value = "";
  247.         SV *sv = (k+2 < nargs) ? args[k+2] : &sv_undef;
  248.         ap->len = SQL_NULL_DATA;
  249.         if (SvOK(sv)) {
  250.         if (SvIOKp(sv)) {
  251.             ap->val.ival = SvIV(sv);
  252.             ap->len = sizeof(long);
  253.             cType = SQL_C_LONG;
  254.             value = &ap->val.ival;
  255.         } else if (SvNOKp(sv)) {
  256.             ap->val.nval = SvNV(sv);
  257.             ap->len = sizeof(double);
  258.             cType = SQL_C_DOUBLE;
  259.             value = &ap->val.nval;
  260.         } else if (SvPOKp(sv)) {
  261.             value = SvPV(sv,prec);
  262.             ap->len = prec;
  263.         }
  264.         }
  265.         *retval = SQLBindParameter(hstmt, 1+i, SQL_PARAM_INPUT, cType, sqlType,
  266.                 prec, 0, value, prec, &ap->len);
  267.         if (db2cli_debug)
  268.         fprintf(stderr, "bind #%d cType=%s sqlType=%s prec=%d len=%d retval=%d\n",
  269.             1+i, mapCode(cType,cTypes), mapCode(sqlType,sqlTypes), prec, ap->len, *retval);
  270.         if (db2cli_debug >= 2)
  271.         dump_var(sqlType, prec, value);
  272.         if (*retval < 0) {
  273.         free(a);
  274.         return 0;
  275.         }
  276.     }
  277.     return a;
  278. }
  279.  
  280. static int
  281. not_here(s)
  282. char *s;
  283. {
  284.     croak("%s not implemented on this architecture", s);
  285.     return -1;
  286. }
  287.  
  288. static long
  289. constant(name, arg)
  290. char *name;
  291. int arg;
  292. {
  293.     const struct CliConst *p = in_word_set(name, strlen(name));
  294.     if (p) {
  295.         errno = 0;
  296.         return p->val;
  297.     }
  298.     errno = strncmp(name, "SQL_", 4) ? EINVAL : ENOENT;
  299.     return 0;
  300. }
  301.  
  302.  
  303. MODULE = DB2CLI        PACKAGE = DB2CLI
  304.  
  305. BOOT:    initialize();
  306.  
  307. double
  308. constant(name,arg)
  309.     char *        name
  310.     int        arg
  311.  
  312. char *
  313. cTypeName(cType)
  314.     int        cType
  315.     CODE:
  316.     RETVAL = mapCode(cType, cTypes);
  317.     OUTPUT:
  318.     RETVAL
  319.  
  320. char *
  321. sqlTypeName(sqlType)
  322.     int        sqlType
  323.     CODE:
  324.     RETVAL = mapCode(sqlType, sqlTypes);
  325.     OUTPUT:
  326.     RETVAL
  327.  
  328. SQLRETURN
  329. SQLAllocConnect(henv,hdbcOut)
  330.     SQLHENV        henv
  331.     SQLHDBC        &hdbcOut = NO_INIT
  332.     OUTPUT:
  333.     hdbcOut
  334.  
  335. SQLRETURN
  336. SQLAllocEnv(henvOut)
  337.     SQLHENV        &henvOut = NO_INIT
  338.     CODE:
  339.     if ((RETVAL = SQLAllocEnv(&henvOut)) == SQL_SUCCESS)
  340.         SQLSetEnvAttr(henvOut, SQL_ATTR_OUTPUT_NTS, SQL_FALSE, 0);
  341.     OUTPUT:
  342.     RETVAL
  343.     henvOut
  344.  
  345. SQLRETURN
  346. SQLAllocStmt(hdbc,hstmtOut)
  347.     SQLHDBC        hdbc
  348.     SQLHSTMT    &hstmtOut = NO_INIT
  349.     OUTPUT:
  350.     hstmtOut
  351.  
  352. SQLRETURN
  353. SQLCancel(hstmt)
  354.     SQLHSTMT    hstmt
  355.  
  356. SQLRETURN
  357. SQLColAttributes(hstmt,col,descType,textDescOut,numDescOut)
  358.     SQLHSTMT    hstmt
  359.     SQLUSMALLINT    col
  360.     SQLUSMALLINT    descType
  361.     char *        &textDescOut = NO_INIT
  362.     SQLINTEGER    &numDescOut = NO_INIT
  363.     CODE:
  364.     RETVAL = SQLColAttributes(hstmt,col,descType,
  365.         buf1,SmallSize,&len1,
  366.         &numDescOut);
  367.     if (RETVAL >= 0)
  368.         sv_setpvn(ST(3), buf1, len1);
  369.     OUTPUT:
  370.     RETVAL
  371.  
  372. SQLRETURN
  373. SQLColumnPrivileges(hstmt,catalog,schema,table,column)
  374.     SQLHSTMT    hstmt
  375.     SQLString    catalog
  376.     SQLString    schema
  377.     SQLString    table
  378.     SQLString    column
  379.     CODE:
  380.     RETVAL = SQLColumnPrivileges(hstmt,
  381.             catalog.ptr,    catalog.len,
  382.             schema.ptr,    schema.len,
  383.             table.ptr,    table.len,
  384.             column.ptr,    column.len);
  385.     OUTPUT:
  386.     RETVAL
  387.  
  388. SQLRETURN
  389. SQLColumns(hstmt,catalog,schema,table,column)
  390.     SQLHSTMT    hstmt
  391.     SQLString    catalog
  392.     SQLString    schema
  393.     SQLString    table
  394.     SQLString    column
  395.     CODE:
  396.     RETVAL = SQLColumns(hstmt,
  397.             catalog.ptr,    catalog.len,
  398.             schema.ptr,    schema.len,
  399.             table.ptr,    table.len,
  400.             column.ptr,    column.len);
  401.     OUTPUT:
  402.     RETVAL
  403.  
  404. SQLRETURN
  405. SQLConnect(hdbc,dataset,userId=null,authentication=null)
  406.     SQLHDBC        hdbc
  407.     SQLString    dataset
  408.     SQLString    userId
  409.     SQLString    authentication
  410.     CODE:
  411.     RETVAL = SQLConnect(hdbc,
  412.             dataset.ptr,        dataset.len,
  413.             userId.ptr,        userId.len,
  414.             authentication.ptr,    authentication.len);
  415.     OUTPUT:
  416.     RETVAL
  417.  
  418. SQLRETURN
  419. SQLDataSources(henv,direction,datasetOut,descriptionOut)
  420.     SQLHENV        henv
  421.     SQLUSMALLINT    direction
  422.     char *        &datasetOut = NO_INIT
  423.     char *        &descriptionOut = NO_INIT
  424.     CODE:
  425.     RETVAL = SQLDataSources(henv,direction,buf1,SmallSize,&len1,
  426.                            buf2,SmallSize,&len2);
  427.     if (RETVAL >= 0) {
  428.         sv_setpvn(ST(2), buf1, len1);
  429.         sv_setpvn(ST(3), buf2, len2);
  430.     }
  431.     OUTPUT:
  432.     RETVAL
  433.  
  434. SQLRETURN
  435. SQLDescribeCol(hstmt,col,colNameOut,sqlTypeOut,precOut,scaleOut,nullableOut)
  436.     SQLHSTMT    hstmt
  437.     SQLUSMALLINT    col
  438.     char *        &colNameOut = NO_INIT
  439.     SQLSMALLINT    &sqlTypeOut = NO_INIT
  440.     SQLUINTEGER    &precOut = NO_INIT
  441.     SQLSMALLINT    &scaleOut = NO_INIT
  442.     SQLSMALLINT    &nullableOut = NO_INIT
  443.     CODE:
  444.     RETVAL = SQLDescribeCol(hstmt,col,buf1,SmallSize,&len1,
  445.                 &sqlTypeOut,&precOut,&scaleOut,&nullableOut);
  446.     if (RETVAL >= 0)
  447.         sv_setpvn(ST(2), buf1, len1);
  448.     OUTPUT:
  449.     RETVAL
  450.     sqlTypeOut
  451.     precOut
  452.     scaleOut
  453.     nullableOut
  454.  
  455. SQLRETURN
  456. SQLDisconnect(hdbc)
  457.     SQLHDBC        hdbc
  458.  
  459. SQLRETURN
  460. SQLDriverConnect(hdbc,hwindow,connStrIn,connStrOut,completion)
  461.     SQLHDBC        hdbc
  462.     long        hwindow
  463.     SQLString    connStrIn
  464.     char *        &connStrOut = NO_INIT
  465.     SQLUSMALLINT    completion
  466.     CODE:
  467.     RETVAL = SQLDriverConnect(hdbc,hwindow,
  468.             connStrIn.ptr,connStrIn.len,
  469.             buf1,SmallSize,&len1,
  470.             completion);
  471.     if (RETVAL >= 0)
  472.         sv_setpvn(ST(3), buf1, len1);
  473.     OUTPUT:
  474.     RETVAL
  475.  
  476. SQLRETURN
  477. SQLError(henv,hdbc,hstmt,sqlStateOut,nativeErrorOut,errorMsgOut)
  478.     SQLHENV        henv
  479.     SQLHDBC        hdbc
  480.     SQLHSTMT    hstmt
  481.     char *        &sqlStateOut = NO_INIT
  482.     SQLINTEGER    &nativeErrorOut = NO_INIT
  483.     char *        &errorMsgOut = NO_INIT
  484.     CODE:
  485.     RETVAL = SQLError(henv,hdbc,hstmt, buf1, &nativeErrorOut,
  486.             buf2,SmallSize,&len2);
  487.     if (RETVAL >= 0) {
  488.         sv_setpvn(ST(3), buf1, 5);
  489.         sv_setpvn(ST(5), buf2, len2);
  490.     }
  491.     OUTPUT:
  492.     RETVAL
  493.     nativeErrorOut
  494.  
  495. SQLRETURN
  496. SQLExecDirect(hstmt,sqlStr,...)
  497.     SQLHSTMT    hstmt
  498.     SQLLargeString    sqlStr
  499.     CODE:
  500.     {    void *a = bindParams(hstmt, &ST(2), items-2, &RETVAL, 1);
  501.     if (RETVAL >= 0)
  502.         RETVAL = SQLExecDirect(hstmt, sqlStr.ptr,sqlStr.len);
  503.     if (a)
  504.         free(a);
  505.     }
  506.     OUTPUT:
  507.     RETVAL
  508.  
  509. SQLRETURN
  510. SQLExecDirect2(hstmt,sqlStr,...)
  511.     SQLHSTMT    hstmt
  512.     SQLLargeString    sqlStr
  513.     CODE:
  514.     {    void *a = bindParams2(hstmt, &ST(2), items-2, &RETVAL, 1);
  515.     if (RETVAL >= 0)
  516.         RETVAL = SQLExecDirect(hstmt, sqlStr.ptr,sqlStr.len);
  517.     if (a)
  518.         free(a);
  519.     }
  520.     OUTPUT:
  521.     RETVAL
  522.  
  523. SQLRETURN
  524. SQLExecute(hstmt,...)
  525.     SQLHSTMT    hstmt
  526.     CODE:
  527.     {    void *a = bindParams(hstmt, &ST(1), items-1, &RETVAL, 0);
  528.     if (RETVAL >= 0)
  529.         RETVAL = SQLExecute(hstmt);
  530.     if (a)
  531.         free(a);
  532.     }
  533.     OUTPUT:
  534.     RETVAL
  535.  
  536. SQLRETURN
  537. SQLExecute2(hstmt,...)
  538.     SQLHSTMT    hstmt
  539.     CODE:
  540.     {    void *a = bindParams2(hstmt, &ST(1), items-1, &RETVAL, 0);
  541.     if (RETVAL >= 0)
  542.         RETVAL = SQLExecute(hstmt);
  543.     if (a)
  544.         free(a);
  545.     }
  546.     OUTPUT:
  547.     RETVAL
  548.  
  549. SQLRETURN
  550. SQLFetch(hstmt,...)
  551.     SQLHSTMT    hstmt
  552.     CODE:
  553.     RETVAL = SQLFetch(hstmt);
  554.     if (RETVAL == SQL_SUCCESS || RETVAL == SQL_SUCCESS_WITH_INFO) {
  555.         int i;
  556.         for (i = 1; i < items; ++i) {
  557.             SQLRETURN rc = SQLGetData(hstmt, i, SQL_C_CHAR,
  558.                 buffer.buffer, HugeSize, &buffer.length);
  559.             if (rc < 0) {
  560.                 RETVAL = rc;
  561.                 break;
  562.             }
  563.             if (RETVAL == SQL_SUCCESS)
  564.                 RETVAL = rc;
  565.             if (buffer.length == SQL_NULL_DATA)
  566.                 sv_setsv(ST(i), &sv_undef);
  567.             else
  568.                 sv_setpvn(ST(i), buffer.buffer, buffer.length);
  569.         }
  570.     }
  571.     OUTPUT:
  572.     RETVAL
  573.  
  574. SQLRETURN
  575. SQLForeignKeys(hstmt,primCatalog,primSchema,primTable,forgCatalog,forgSchema,forgTable)
  576.     SQLHSTMT    hstmt
  577.     SQLString    primCatalog
  578.     SQLString    primSchema
  579.     SQLString    primTable
  580.     SQLString    forgCatalog
  581.     SQLString    forgSchema
  582.     SQLString    forgTable
  583.     CODE:
  584.     RETVAL = SQLForeignKeys(hstmt,
  585.             primCatalog.ptr,    primCatalog.len,
  586.             primSchema.ptr,        primSchema.len,
  587.             primTable.ptr,        primTable.len,
  588.             forgCatalog.ptr,    forgCatalog.len,
  589.             forgSchema.ptr,        forgSchema.len,
  590.             forgTable.ptr,        forgTable.len);
  591.     OUTPUT:
  592.     RETVAL
  593.  
  594. SQLRETURN
  595. SQLFreeConnect(hdbc)
  596.     SQLHDBC        hdbc
  597.  
  598. SQLRETURN
  599. SQLFreeEnv(henv)
  600.     SQLHENV        henv
  601.  
  602. SQLRETURN
  603. SQLFreeStmt(hstmt,option=SQL_DROP)
  604.     SQLHSTMT    hstmt
  605.     SQLUSMALLINT    option
  606.  
  607. SQLRETURN
  608. SQLGetConnectOptionLong(hdbc,option,param)
  609.     SQLHDBC        hdbc
  610.     SQLUSMALLINT    option
  611.     SQLUINTEGER    ¶m = NO_INIT
  612.     CODE:
  613.     RETVAL = SQLGetConnectOption(hdbc,option, buffer.buffer);
  614.     if (RETVAL >= 0)
  615.         sv_setiv(ST(2), *(SQLUINTEGER *)&buffer.buffer);
  616.     OUTPUT:
  617.     RETVAL
  618.  
  619. SQLRETURN
  620. SQLGetConnectOptionStr(hdbc,option,param)
  621.     SQLHDBC        hdbc
  622.     SQLUSMALLINT    option
  623.     char *        ¶m = NO_INIT
  624.     CODE:
  625.     RETVAL = SQLGetConnectOption(hdbc,option, buffer.buffer);
  626.     if (RETVAL >= 0)
  627.         sv_setpv(ST(2), buffer.buffer);
  628.     OUTPUT:
  629.     RETVAL
  630.  
  631. SQLRETURN
  632. SQLGetCursorName(hstmt,cursorOut)
  633.     SQLHSTMT    hstmt
  634.     char *        &cursorOut = NO_INIT
  635.     CODE:
  636.     RETVAL = SQLGetCursorName(hstmt, buf1,SmallSize,&len1);
  637.     if (RETVAL >= 0)
  638.         sv_setpvn(ST(1), buf1, len1);
  639.     OUTPUT:
  640.     RETVAL
  641.  
  642. SQLRETURN
  643. SQLGetData(hstmt,col,cType,valueOut)
  644.     SQLHSTMT    hstmt
  645.     SQLUSMALLINT    col
  646.     SQLSMALLINT    cType
  647.     char *        &valueOut = NO_INIT
  648.     CODE:
  649.     buffer.length = SQL_NULL_DATA;
  650.     RETVAL = SQLGetData(hstmt, col, cType, buffer.buffer,HugeSize,&buffer.length);
  651.     if (RETVAL >= 0) {
  652.         if (buffer.length == SQL_NULL_DATA)
  653.             sv_setsv(ST(3), &sv_undef);
  654.         else switch (cType) {
  655.         case SQL_C_SHORT:
  656.             sv_setiv(ST(3), *(SQLSMALLINT *)buffer.buffer);
  657.             break;
  658.         case SQL_C_LONG:
  659.             sv_setiv(ST(3), *(SQLINTEGER *)buffer.buffer);
  660.             break;
  661.         case SQL_C_FLOAT:
  662.             sv_setnv(ST(3), *(SQLREAL *)buffer.buffer);
  663.             break;
  664.         case SQL_C_DOUBLE:
  665.             sv_setnv(ST(3), *(SQLDOUBLE *)buffer.buffer);
  666.             break;
  667.         default:
  668.             sv_setpvn(ST(3), buffer.buffer, buffer.length);
  669.             break;
  670.         }
  671.     }
  672.     OUTPUT:
  673.     RETVAL
  674.  
  675. SQLRETURN
  676. SQLGetEnvAttrLong(henv,attribute,value)
  677.     SQLHENV        henv
  678.     SQLINTEGER    attribute
  679.     SQLUINTEGER    &value = NO_INIT
  680.     CODE:
  681.     RETVAL = SQLGetEnvAttr(henv,attribute, &value,0,0);
  682.     OUTPUT:
  683.     RETVAL
  684.     value
  685.  
  686. SQLRETURN
  687. SQLGetEnvAttrStr(henv,attribute,value)
  688.     SQLHENV        henv
  689.     SQLINTEGER    attribute
  690.     char *        &value = NO_INIT
  691.     CODE:
  692.     buffer.length = 0;
  693.     RETVAL = SQLGetEnvAttr(henv,attribute, buffer.buffer,HugeSize,&buffer.length);
  694.     if (RETVAL >= 0)
  695.         sv_setpvn(ST(2), buffer.buffer, buffer.length);
  696.     OUTPUT:
  697.     RETVAL
  698.  
  699. SQLRETURN
  700. SQLGetFunctions(hdbc,function,existsOut)
  701.     SQLHDBC        hdbc
  702.     SQLUSMALLINT    function
  703.     SQLUSMALLINT    &existsOut = NO_INIT
  704.     OUTPUT:
  705.     existsOut
  706.  
  707. SQLRETURN
  708. SQLGetInfoShort(hdbc,infoType,infoOut)
  709.     SQLHDBC        hdbc
  710.     SQLUSMALLINT    infoType
  711.     SQLUSMALLINT    &infoOut = 0;
  712.     CODE:
  713.     RETVAL = SQLGetInfo(hdbc, infoType, &infoOut,sizeof infoOut,&len1);
  714.     OUTPUT:
  715.     RETVAL
  716.     infoOut
  717.  
  718. SQLRETURN
  719. SQLGetInfoLong(hdbc,infoType,infoOut)
  720.     SQLHDBC        hdbc
  721.     SQLUSMALLINT    infoType
  722.     SQLUINTEGER    &infoOut = 0;
  723.     CODE:
  724.     RETVAL = SQLGetInfo(hdbc, infoType, &infoOut,sizeof infoOut,&len1);
  725.     OUTPUT:
  726.     RETVAL
  727.     infoOut
  728.  
  729. SQLRETURN
  730. SQLGetInfoStr(hdbc,infoType,infoOut)
  731.     SQLHDBC        hdbc
  732.     SQLUSMALLINT    infoType
  733.     char *        &infoOut = NO_INIT
  734.     CODE:
  735.     RETVAL = SQLGetInfo(hdbc, infoType, buf1,SmallSize,&len1);
  736.     if (RETVAL >= 0)
  737.         sv_setpvn(ST(2), buf1, len1);
  738.     OUTPUT:
  739.     RETVAL
  740.  
  741. SQLRETURN
  742. SQLGetLength(hstmt,locType,locator,lengthOut,indicatorOut)
  743.     SQLHSTMT    hstmt
  744.     SQLSMALLINT    locType
  745.     SQLINTEGER    locator
  746.     SQLINTEGER    &lengthOut = NO_INIT
  747.     SQLINTEGER    &indicatorOut = NO_INIT
  748.     OUTPUT:
  749.     lengthOut
  750.     indicatorOut
  751.  
  752. SQLRETURN
  753. SQLGetPosition(hstmt,locType,locator,searchLoc,searchLit,position,locatedAtOut,indicatorOut)
  754.     SQLHSTMT    hstmt
  755.     SQLSMALLINT    locType
  756.     SQLINTEGER    locator
  757.     SQLINTEGER    searchLoc
  758.     SQLLargeString    searchLit
  759.     SQLINTEGER    position
  760.     SQLINTEGER    &locatedAtOut = NO_INIT
  761.     SQLINTEGER    &indicatorOut = NO_INIT
  762.     CODE:
  763.     RETVAL = SQLGetPosition(hstmt,locType,locator,searchLoc,
  764.             searchLit.ptr,searchLit.len,
  765.             position,&locatedAtOut,&indicatorOut);
  766.     OUTPUT:
  767.     RETVAL
  768.     locatedAtOut
  769.     indicatorOut
  770.  
  771. SQLRETURN
  772. SQLGetSQLCA(henv,hdbc,hstmt,sqlcaOut)
  773.     SQLHENV        henv
  774.     SQLHDBC        hdbc
  775.     SQLHSTMT    hstmt
  776.     char *        &sqlcaOut = NO_INIT
  777.     CODE:
  778.     {    struct sqlca ca;
  779.     RETVAL = SQLGetSQLCA(henv,hdbc,hstmt, &ca);
  780.     if (RETVAL >= 0)
  781.         sv_setpvn(ST(3), (char *)&ca, sizeof ca);
  782.     }
  783.     OUTPUT:
  784.     RETVAL
  785.  
  786. SQLRETURN
  787. SQLGetStmtOptionLong(hstmt,option,param)
  788.     SQLHSTMT    hstmt
  789.     SQLUSMALLINT    option
  790.     SQLUINTEGER    ¶m = NO_INIT
  791.     CODE:
  792.     RETVAL = SQLGetStmtOption(hstmt, option, buffer.buffer);
  793.     if (RETVAL >= 0)
  794.         sv_setiv(ST(2), *(SQLUINTEGER *)buffer.buffer);
  795.     OUTPUT:
  796.     RETVAL
  797.  
  798. SQLRETURN
  799. SQLGetStmtOptionStr(hstmt,option,param)
  800.     SQLHSTMT    hstmt
  801.     SQLUSMALLINT    option
  802.     char *        param = NO_INIT
  803.     CODE:
  804.     RETVAL = SQLGetStmtOption(hstmt, option, buffer.buffer);
  805.     if (RETVAL >= 0)
  806.         sv_setpv(ST(2), buffer.buffer);
  807.     OUTPUT:
  808.     RETVAL
  809.  
  810. SQLRETURN
  811. SQLGetSubString(hstmt,locType,locator,position,length,targetCType,valueOut,indicatorOut)
  812.     SQLHSTMT    hstmt
  813.     SQLSMALLINT    locType
  814.     SQLINTEGER    locator
  815.     SQLUINTEGER    position
  816.     SQLUINTEGER    length
  817.     SQLSMALLINT    targetCType
  818.     char *        &valueOut = NO_INIT
  819.     SQLINTEGER    &indicatorOut = NO_INIT
  820.     CODE:
  821.     RETVAL = SQLGetSubString(hstmt,locType,locator,position,length,targetCType,
  822.                 buffer.buffer,HugeSize,&buffer.length,&indicatorOut);
  823.     if (RETVAL >= 0)
  824.         sv_setpvn(ST(6), buffer.buffer, buffer.length);
  825.     OUTPUT:
  826.     RETVAL
  827.  
  828. SQLRETURN
  829. SQLGetTypeInfo(hstmt,sqlType)
  830.     SQLHSTMT    hstmt
  831.     SQLSMALLINT    sqlType
  832.  
  833. SQLRETURN
  834. SQLMoreResults(hstmt)
  835.     SQLHSTMT    hstmt
  836.  
  837. SQLRETURN
  838. SQLNativeSql(hdbc,stringIn,stringOut)
  839.     SQLHDBC        hdbc
  840.     SQLLargeString    stringIn
  841.     char *        &stringOut = NO_INIT
  842.     CODE:
  843.     RETVAL = SQLNativeSql(hdbc, stringIn.ptr,stringIn.len,
  844.                 buffer.buffer,HugeSize,&buffer.length);
  845.     if (RETVAL >= 0)
  846.         sv_setpvn(ST(2), buffer.buffer, buffer.length);
  847.     OUTPUT:
  848.     RETVAL
  849.  
  850. SQLRETURN
  851. SQLNumParams(hstmt,paramOut)
  852.     SQLHSTMT    hstmt
  853.     SQLSMALLINT    ¶mOut = NO_INIT
  854.     OUTPUT:
  855.     paramOut
  856.  
  857. SQLRETURN
  858. SQLNumResultCols(hstmt,paramOut)
  859.     SQLHSTMT    hstmt
  860.     SQLSMALLINT    ¶mOut = NO_INIT
  861.     OUTPUT:
  862.     paramOut
  863.  
  864. SQLRETURN
  865. SQLPrepare(hstmt,sqlString)
  866.     SQLHSTMT    hstmt
  867.     SQLLargeString    sqlString
  868.     CODE:
  869.     RETVAL = SQLPrepare(hstmt, sqlString.ptr,sqlString.len);
  870.     OUTPUT:
  871.     RETVAL
  872.  
  873. SQLRETURN
  874. SQLPrimaryKeys(hstmt,catalog,schema,table)
  875.     SQLHSTMT    hstmt
  876.     SQLString    catalog
  877.     SQLString    schema
  878.     SQLString    table
  879.     CODE:
  880.     RETVAL = SQLPrimaryKeys(hstmt,
  881.             catalog.ptr,    catalog.len,
  882.             schema.ptr,    schema.len,
  883.             table.ptr,    table.len);
  884.     OUTPUT:
  885.     RETVAL
  886.  
  887. SQLRETURN
  888. SQLProcedureColumns(hstmt,catalog,schema,procedure,column)
  889.     SQLHSTMT    hstmt
  890.     SQLString    catalog
  891.     SQLString    schema
  892.     SQLString    procedure
  893.     SQLString    column
  894.     CODE:
  895.     RETVAL = SQLProcedureColumns(hstmt,
  896.             catalog.ptr,      catalog.len,
  897.             schema.ptr,    schema.len,
  898.             procedure.ptr,    procedure.len,
  899.             column.ptr,    column.len);
  900.     OUTPUT:
  901.     RETVAL
  902.  
  903. SQLRETURN
  904. SQLProcedures(hstmt,catalog,schema,procedure)
  905.     SQLHSTMT    hstmt
  906.     SQLString    catalog
  907.     SQLString    schema
  908.     SQLString    procedure
  909.     CODE:
  910.     RETVAL = SQLProcedures(hstmt,
  911.             catalog.ptr,      catalog.len,
  912.             schema.ptr,    schema.len,
  913.             procedure.ptr,    procedure.len);
  914.     OUTPUT:
  915.     RETVAL
  916.  
  917. SQLRETURN
  918. SQLRowCount(hstmt,rowsOut)
  919.     SQLHSTMT    hstmt
  920.     SQLINTEGER    &rowsOut = NO_INIT
  921.  
  922. SQLRETURN
  923. SQLSetColAttributes(hstmt,col,name,sqlType,prec,scale,nullable)
  924.     SQLHSTMT    hstmt
  925.     SQLUSMALLINT    col
  926.     SQLString    name
  927.     SQLSMALLINT    sqlType
  928.     SQLUINTEGER    prec
  929.     SQLSMALLINT    scale
  930.     SQLSMALLINT    nullable
  931.     CODE:
  932.     RETVAL = SQLSetColAttributes(hstmt,col, name.ptr,name.len,
  933.                 sqlType,prec,scale,nullable);
  934.     OUTPUT:
  935.     RETVAL
  936.  
  937. SQLRETURN
  938. SQLSetConnection(hdbc)
  939.     SQLHDBC        hdbc
  940.  
  941. SQLRETURN
  942. SQLSetConnectOption(hdbc,option,param)
  943.     SQLHDBC        hdbc
  944.     SQLUSMALLINT    option
  945.     SV *        param
  946.     CODE:
  947.     if (SvPOKp(param))
  948.         RETVAL = SQLSetConnectOption(hdbc, option, (SQLUINTEGER)SvPV(param,na));
  949.     else
  950.         RETVAL = SQLSetConnectOption(hdbc, option, SvIV(param));
  951.     OUTPUT:
  952.     RETVAL
  953.  
  954. SQLRETURN
  955. SQLSetCursorName(hstmt,cursor)
  956.     SQLHSTMT    hstmt
  957.     SQLString    cursor
  958.     CODE:
  959.     RETVAL = SQLSetCursorName(hstmt, cursor.ptr,cursor.len);
  960.     OUTPUT:
  961.     RETVAL
  962.  
  963. SQLRETURN
  964. SQLSetEnvAttr(henv,attribute,value)
  965.     SQLHENV        henv
  966.     SQLINTEGER    attribute
  967.     SV *        value
  968.     CODE:
  969.     if (SvPOKp(value)) {
  970.         STRLEN len;
  971.         char *ptr = SvPV(value,len);
  972.         RETVAL = SQLSetEnvAttr(henv, attribute, ptr,len);
  973.     } else
  974.         RETVAL = SQLSetEnvAttr(henv, attribute, (SQLPOINTER)SvIV(value),0);
  975.     OUTPUT:
  976.     RETVAL
  977.  
  978. SQLRETURN
  979. SQLSetStmtOption(hstmt,option,param)
  980.     SQLHSTMT    hstmt
  981.     SQLUSMALLINT    option
  982.     SV *        param
  983.     CODE:
  984.     if (SvPOKp(param))
  985.         RETVAL = SQLSetStmtOption(hstmt, option, (SQLUINTEGER)SvPV(param,na));
  986.     else
  987.         RETVAL = SQLSetStmtOption(hstmt, option, SvIV(param));
  988.     OUTPUT:
  989.     RETVAL
  990.  
  991. SQLRETURN
  992. SQLSpecialColumns(hstmt,colType,catalog,schema,table,scope,nullable)
  993.     SQLHSTMT    hstmt
  994.     SQLUSMALLINT    colType
  995.     SQLString    catalog
  996.     SQLString    schema
  997.     SQLString    table
  998.     SQLUSMALLINT    scope
  999.     SQLUSMALLINT    nullable
  1000.     CODE:
  1001.     RETVAL = SQLSpecialColumns(hstmt,colType,
  1002.                 catalog.ptr,    catalog.len,
  1003.                 schema.ptr,    schema.len,
  1004.                 table.ptr,    table.len,
  1005.                 scope, nullable);
  1006.     OUTPUT:
  1007.     RETVAL
  1008.  
  1009. SQLRETURN
  1010. SQLStatistics(hstmt,catalog,schema,table,unique,accuracy)
  1011.     SQLHSTMT    hstmt
  1012.     SQLString    catalog
  1013.     SQLString    schema
  1014.     SQLString    table
  1015.     SQLUSMALLINT    unique
  1016.     SQLUSMALLINT    accuracy
  1017.     CODE:
  1018.     RETVAL = SQLStatistics(hstmt,
  1019.                 catalog.ptr,    catalog.len,
  1020.                 schema.ptr,    schema.len,
  1021.                 table.ptr,    table.len,
  1022.                 unique,accuracy);
  1023.     OUTPUT:
  1024.     RETVAL
  1025.  
  1026. SQLRETURN
  1027. SQLTablePrivileges(hstmt,catalog,schema,table)
  1028.     SQLHSTMT    hstmt
  1029.     SQLString    catalog
  1030.     SQLString    schema
  1031.     SQLString    table
  1032.     CODE:
  1033.     RETVAL = SQLTablePrivileges(hstmt,
  1034.                 catalog.ptr,    catalog.len,
  1035.                 schema.ptr,    schema.len,
  1036.                 table.ptr,    table.len);
  1037.     OUTPUT:
  1038.     RETVAL
  1039.  
  1040. SQLRETURN
  1041. SQLTables(hstmt,catalog,schema,table,type)
  1042.     SQLHSTMT    hstmt
  1043.     SQLString    catalog
  1044.     SQLString    schema
  1045.     SQLString    table
  1046.     SQLString    type
  1047.     CODE:
  1048.     RETVAL = SQLTables(hstmt,catalog.ptr,    catalog.len,
  1049.                  schema.ptr,    schema.len,
  1050.                  table.ptr,    table.len,
  1051.                  type.ptr,    type.len);
  1052.     OUTPUT:
  1053.     RETVAL
  1054.  
  1055. SQLRETURN
  1056. SQLTransact(henv,hdbc,type=SQL_COMMIT)
  1057.     SQLHENV        henv
  1058.     SQLHDBC        hdbc
  1059.     SQLUSMALLINT    type
  1060.  
  1061.