home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / sqlcla.zip / SQL.CPP < prev    next >
C/C++ Source or Header  |  1993-07-14  |  8KB  |  285 lines
  1. /* (C) Copyright Stephen B. Behman, 1993 -- All rights reserved. */
  2. // $Header: d:/sh/RCS/sql.cpp 2.0 93/07/14 09:45:25 Steve Exp $
  3.  
  4. extern "C" {
  5. short _Far16 _Pascal  sqlestar_api (void);
  6. short _Far16 _Pascal  sqlestrd_api (char *,    /* database */
  7.               char *,      /* spare, password */
  8.               unsigned char,       /* use */
  9.               struct SQLCA *);       /* SQLCA */
  10. short _Far16 _Pascal sqlacall(unsigned short,
  11.                    unsigned short,
  12.                    unsigned short,
  13.                    unsigned short,
  14.                    void *);
  15. short _Far16 _Pascal sqlastop(void *);
  16. short _Far16 _Pascal sqlastrt(void *,
  17.                    void *,
  18.                    struct SQLCA *);
  19. short _Far16 _Pascal sqlausda(unsigned short,
  20.                    struct Sqlda *,
  21.                    void *);
  22. }
  23.  
  24. #define   SQLCODE     sqlca->sqlcode
  25. #define   SQLWARN0     sqlca->sqlwarn[0]
  26. #define   SQLWARN1     sqlca->sqlwarn[1]
  27. #define   SQLWARN2     sqlca->sqlwarn[2]
  28. #define   SQLWARN3     sqlca->sqlwarn[3]
  29. #define   SQLWARN4     sqlca->sqlwarn[4]
  30. #define   SQLWARN5     sqlca->sqlwarn[5]
  31. #define   SQLWARN6     sqlca->sqlwarn[6]
  32. #define   SQLWARN7     sqlca->sqlwarn[7]
  33. #define   SQLWARN8     sqlca->sqlwarn[8]
  34. #define   SQLWARN9     sqlca->sqlwarn[9]
  35. #define   SQLWARNA     sqlca->sqlwarn[10]
  36.  
  37. #pragma pack(1)
  38. struct SQLCA
  39. {
  40.    unsigned char  sqlcaid[8];        /* Eyecatcher = 'SQLCA   ' */
  41.    long       sqlcabc;        /* SQLCA size in bytes = 136 */
  42.    long       sqlcode;        /* SQL return code */
  43.    short      sqlerrml;        /* Length for SQLERRMC */
  44.    unsigned char  sqlerrmc[70];     /* Error message tokens */
  45.    unsigned char  sqlerrp[8];        /* Diagnostic information */
  46.    long       sqlerrd[6];        /* Diagnostic information */
  47.    unsigned char  sqlwarn[11];        /* Warning flags */
  48.    unsigned char  sqlstate[5];        /* State corresponding to SQLCODE */
  49. };
  50. #pragma pack()
  51.  
  52. static SQLCA sqlca;
  53.  
  54. #include <stdarg.h>
  55. #include <stdio.h>
  56. #include <string.h>
  57.  
  58.  
  59. class DATABASE
  60.   {
  61.    static int started;
  62.   public:
  63.    DATABASE( char * dbname, unsigned char dbuse, SQLCA* sqlca );
  64.    int isstarted();
  65.    long COMMIT( SQLCA* sqlca, char* pid  );
  66.    long ROLLBACK( SQLCA* sqlca, char* pid  );
  67.   };
  68.  
  69. int DATABASE::started;
  70.  
  71. DATABASE::DATABASE( char * dbname, unsigned char use, SQLCA* sqlca  )
  72.   {
  73.    if( !started )
  74.      {
  75.       SQLCA inisqlca;
  76.       sqlestar_api();
  77.       use &= 0xdf;
  78.       if( use != 'X' && use != 'S' ) return;
  79.       sqlestrd_api( dbname,"",'S', &inisqlca );
  80.       started=( inisqlca.sqlcode  ) ? 0 : 1;
  81.      }
  82.   }
  83. long DATABASE::COMMIT( SQLCA* sqlca , char* pid )
  84.   {
  85.    sqlastrt( pid,0L,sqlca);
  86.    sqlacall((unsigned short)21,0,0,0,0L);
  87.    sqlastop(0L);
  88.    return SQLCODE;
  89.   }
  90. long DATABASE::ROLLBACK( SQLCA* sqlca, char* pid  )
  91.   {
  92.    sqlastrt( pid,0L,sqlca);
  93.    sqlacall((unsigned short)28,0,0,0,0L);
  94.    sqlastop(0L);
  95.    return SQLCODE;
  96.   }
  97.  
  98. #pragma pack( 1 )
  99. struct SQLVAR
  100.   {
  101.    short      sqltype;         /* Variable data type */
  102.    short      sqllen;         /* Variable data length */
  103.    void  * _Seg16  sqldata;          /* Pointer to variable data value */
  104.    short * _Seg16  sqlind;         /* Pointer to Null indicator */
  105.    struct sqlname             /* Variable Name */
  106.      {
  107.       short         length;         /* Name length [1..30] */
  108.       unsigned char  data[30];         /* Variable or Column name */
  109.      }    sqlname;
  110.   };
  111.  
  112. struct Sqlda
  113.   {
  114.    char  sqldaid[8];            /* Eye catcher = 'SQLDA   ' */
  115.    long       sqldabc;        /* SQLDA size in bytes = 16+44*SQLN */
  116.    short      sqln;         /* Number of SQLVAR elements */
  117.    short      sqld;         /* # of used SQLVAR elements */
  118.    SQLVAR sqlvar[1];
  119.   };
  120.  
  121. #pragma pack( )
  122.  
  123. class SQLDA
  124.   {
  125.    static short nosqldas;          // counter used to name sqlda's
  126.    short sqlid;               // number for this sqlda
  127.    Sqlda *ada;                  // actual sqlda
  128.   public:
  129.    SQLDA( char *t,short noargs )
  130.      {
  131.       if( ! noargs )
  132.     {
  133.      ada=(Sqlda *)0;
  134.      sqlid=0;
  135.     }
  136.       else
  137.     {
  138.      ada=(Sqlda*) new char[ sizeof(Sqlda) + (noargs-1)*sizeof(SQLVAR) ];
  139.      sqlid=(ada==0) ? ( short )0 : nosqldas++;
  140.      SQLCA ca;
  141.      strncpy( ada->sqldaid, "SQLDA   ", 8 );
  142.      ada->sqldabc=sizeof( Sqlda )+(noargs-1)*sizeof( SQLVAR );
  143.      ada->sqln=ada->sqld=noargs;
  144.      sqlastrt( t, 0, &ca );
  145.      sqlausda( sqlid, ada, ( void* )0 );         // register sqlda
  146.      sqlastop( 0 );
  147.     }
  148.       }
  149.    ~SQLDA(){ delete [] ada;}
  150.    void setv( int i, short tp, short ln, void *da, short *ind )
  151.      {
  152.       SQLVAR *v=( SQLVAR* )&ada->sqlvar;
  153.       v[i].sqltype=tp;
  154.       v[i].sqllen=ln;
  155.       v[i].sqldata=da;
  156.       v[i].sqlind=ind;
  157.      }
  158.    inline short id(){ return sqlid; }
  159.    SQLVAR* var(  ){return ( SQLVAR* )&ada->sqlvar;}
  160.   };
  161.  
  162. short SQLDA::nosqldas=1;
  163.  
  164. class CURSOR
  165.   {
  166.    SQLDA outda;
  167.    SQLDA inda;
  168.    SQLCA *ca;
  169.    unsigned char *top;
  170.    short stmntno;
  171.   public:
  172.    CURSOR( SQLCA* c,unsigned char * t,short sno, short nooargs,
  173.        short noinargs, ...);
  174.  
  175.    long close();
  176.    long fetch();
  177.    long open();
  178.    SQLVAR* invars(  );
  179.    SQLVAR* outvars(  );
  180.   };
  181.  
  182.    SQLVAR* CURSOR::invars(  ){ return inda.var(); }
  183.    SQLVAR* CURSOR::outvars( ){ return outda.var();}
  184.  
  185. CURSOR::CURSOR( SQLCA* c,unsigned char * t,short sno, short nooargs,
  186.         short noinargs, ...):
  187.         ca(c), top(t), stmntno( sno ),
  188.         outda( (char *) t, nooargs ), inda( (char *) t, noinargs )
  189.   {
  190.    int i;
  191.    va_list list;
  192.    va_start( list, noinargs );
  193.    SQLVAR* v=( nooargs ) ? outda.var() : 0;
  194.    for( i=0; i<nooargs; i++, v++ )
  195.      {
  196.       v->sqltype=va_arg( list, short );
  197.       v->sqllen=va_arg( list, short );
  198.       v->sqldata=va_arg( list, void * );
  199.       v->sqlind=( short * )va_arg( list, void * );
  200.      }
  201.    v=( noinargs ) ? inda.var() : 0;
  202.    for( i=0; i<noinargs; i++ , v++)
  203.      {
  204.       v->sqltype=va_arg( list, short );
  205.       v->sqllen=va_arg( list, short );
  206.       v->sqldata=va_arg( list, void * );
  207.       v->sqlind=( short * )va_arg( list, void * );
  208.      }
  209.    va_end( list );
  210.   }
  211.  
  212. long CURSOR::close()
  213.      {
  214.       sqlastrt(top,0L,ca);
  215.       sqlacall(20, stmntno, 0, 0, 0 );
  216.       sqlastop(0L);
  217.       return ca->sqlcode;
  218.      }
  219. long CURSOR::fetch()
  220.      {
  221.       sqlastrt(top,0L,ca);
  222.       sqlacall(25, stmntno, 0, inda.id(), 0 );
  223.       sqlastop(0L);
  224.       return ca->sqlcode;
  225.      }
  226. long CURSOR::open()
  227.      {
  228.       sqlastrt(top,0L,ca);
  229.       sqlacall(26, stmntno, outda.id(), 0, 0 );
  230.       sqlastop(0L);
  231.       return ca->sqlcode;
  232.      }
  233.  
  234. class QUERY
  235.   {
  236.    SQLDA outda;
  237.    SQLDA inda;
  238.    SQLCA *ca;
  239.    unsigned char *top;
  240.    short stmntno;
  241.    unsigned short action;
  242.   public:
  243.    QUERY::QUERY( SQLCA* c, unsigned char * t, short sno, unsigned short act,
  244.          short nooargs, short noinargs,... );
  245.    long exec();
  246.    SQLVAR * invars(){return inda.var();}
  247.    SQLVAR * outvars(){return outda.var();}
  248.   };
  249.  
  250. QUERY::QUERY( SQLCA* c, unsigned char * t, short sno, unsigned short act,
  251.           short nooargs, short noinargs,... ):
  252.           ca(c), top(t), stmntno( sno ), action( act ),
  253.           outda( (char *) t, nooargs ), inda( (char *) t, noinargs )
  254.   {
  255.    int i;
  256.    va_list list;
  257.    va_start( list, noinargs );
  258.    SQLVAR* v=( nooargs ) ? outda.var() : 0;
  259.    for( i=0; i<nooargs; i++, v++ )
  260.      {
  261.       v->sqltype=va_arg( list, short );
  262.       v->sqllen=va_arg( list, short );
  263.       v->sqldata=va_arg( list, void * );
  264.       v->sqlind=( short * )va_arg( list, void * );
  265.      }
  266.    v=( noinargs ) ? inda.var() : 0;
  267.    for( i=0; i<noinargs; i++ , v++)
  268.      {
  269.       v->sqltype=va_arg( list, short );
  270.       v->sqllen=va_arg( list, short );
  271.       v->sqldata=va_arg( list, void * );
  272.       v->sqlind=( short * )va_arg( list, void * );
  273.      }
  274.    va_end( list );
  275.   }
  276.  
  277. long QUERY::exec()
  278.   {
  279.    sqlastrt(top, 0L, ca);
  280.    sqlacall(action, stmntno, outda.id(), inda.id(), 0 );
  281.    sqlastop(0L);
  282.    return ca->sqlcode;
  283.   }
  284.  
  285.