home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Internet Business Development Kit / PRODUCT_CD.iso / sqlsvr / odbcsdk / samples / cppdemo / codbc.h < prev    next >
Encoding:
C/C++ Source or Header  |  1994-12-07  |  15.5 KB  |  571 lines
  1. /*--------------------------------------------------------------------------
  2.   CODBC.H - Low-level ODBC object classes
  3.  
  4.   This code is furnished on an as-is basis as part of the ODBC SDK and is
  5.   intended for example purposes only.
  6.  
  7. --------------------------------------------------------------------------*/
  8.  
  9. #ifndef __CODBC_H
  10. #define __CODBC_H
  11.  
  12. #include    <sql.h>
  13. #include    <sqlext.h>
  14.  
  15. #if defined(_AFX) && !defined(NOODBCEX)
  16. #define CRIT_CHECK_EX(f)    { if( !Success(m_rc)) \
  17.                                 ThrowODBCException(this, SQL_API_##f, m_rc); }
  18. #define CHECK_EX(f)         { if (!Success(m_rc)) \
  19.                                 ThrowODBCException(this, SQL_API_##f, m_rc); }
  20. #elif !defined(_AFX) && !defined(NOODBCEX)
  21.     // Without the MFC exception handling, we'll display a (very) simple
  22.     // message box that at least displays the error code if the action was
  23.     // not successful.  In the absence of the MFC exception handler, we'll
  24.     // only check for exceptions in constructors and destructors, where it
  25.     // is not possible for the executing program to check m_rc or Success if
  26.     // the construction or destruction fails.
  27.     //
  28.     // This simple message box could be replaced by more elaborate application
  29.     // specific error handling; it is only done this way as an example.
  30. #define CRIT_CHECK_EX(f)    if( !Success(m_rc) ) \
  31.                             {   char szMsg[15]; \
  32.                                 wsprintf(szMsg, "RETCODE %d", m_rc); \
  33.                                 MessageBox(GetActiveWindow(), szMsg, \
  34.                                     "Error:", MB_ICONINFORMATION | MB_OK); }
  35. #define CHECK_EX(f)
  36. #else
  37. #define CRIT_CHECK_EX(f)
  38. #define CHECK_EX(f)
  39. #endif
  40.  
  41. #ifdef  _AFX
  42. #define ODBC_OBJECT         : public CObject
  43. #else
  44. #define ODBC_OBJECT
  45. #endif
  46.  
  47.  
  48. typedef PTR FAR *LPPTR;
  49. typedef SWORD FAR *LPSWORD;
  50. typedef UWORD FAR *LPUWORD;
  51. typedef SDWORD FAR *LPSDWORD;
  52. typedef UDWORD FAR *LPUDWORD;
  53.  
  54.  
  55. ////////////////////////////////////////////////////////////////////////////
  56. // Classes declared
  57. //
  58. class CODBCException;                     // ODBC exception object
  59.  
  60. class CODBC;                              // ODBC base object
  61.     class CENV;                            // ODBC environment object
  62.     class CDBC;                            // ODBC connection object
  63.     class CSTMT;                           // ODBC statement object
  64.  
  65.  
  66. ////////////////////////////////////////////////////////////////////////////
  67. // CODBC
  68. class CODBC ODBC_OBJECT {
  69.  
  70. #ifdef _AFX
  71.     DECLARE_DYNAMIC(CODBC);                 // Required by MFC
  72. #endif
  73.  
  74.     // Public members
  75.     public:
  76.  
  77.         RETCODE m_rc;
  78.  
  79.         virtual RETCODE Error(LPSTR  szSqlState,
  80.                             LPSDWORD pfNativeError,
  81.                             LPSTR    szErrorMsg,
  82.                             SWORD    cbErrorMsgMax,
  83.                             LPSWORD  pcbErrorMsg) = 0;
  84.  
  85.         BOOL Success(RETCODE rc);
  86.  
  87.     // Protected members
  88.     protected:
  89.  
  90.         CODBC();
  91.         virtual ~CODBC();
  92.  
  93.         RETCODE Error(HENV   henv,
  94.                     HDBC     hdbc,
  95.                     HSTMT    hstmt,
  96.                     LPSTR    szSqlState,
  97.                     LPSDWORD pfNativeError,
  98.                     LPSTR    szErrorMsg,
  99.                     SWORD    cbErrorMsgMax,
  100.                     LPSWORD  pcbErrorMsg);
  101.  
  102.     // Private members
  103.     private:
  104.  
  105.         CODBC(const CODBC& odbcSrc);          // No implementation
  106.         void operator=(const CODBC& odbcSrc); // No implementation
  107.  
  108. };
  109.  
  110.  
  111. #ifdef _AFX
  112. ////////////////////////////////////////////////////////////////////////////
  113. // CODBCException
  114. class CODBCException : public CException {
  115.  
  116.     DECLARE_DYNAMIC(CODBCException);       // Required by MFC
  117.  
  118.     // Public members
  119.     public:
  120.  
  121.         CODBCException(CODBC* podbc, UWORD fFunction, RETCODE rc);
  122.  
  123.         CODBC*  m_podbc;                   // ODBC object
  124.         UWORD   m_fFunction;               // ODBC function code
  125.         RETCODE m_rc;                      // ODBC return code
  126. };
  127.  
  128. void ThrowODBCException(CODBC* podbc, UWORD fFunction, RETCODE rc=SQL_ERROR);
  129. #endif
  130.  
  131.  
  132. ////////////////////////////////////////////////////////////////////////////
  133. // CENV
  134. class CENV : public CODBC {
  135.  
  136. #ifdef _AFX
  137.     DECLARE_DYNAMIC(CENV);                  // Required by MFC
  138. #endif
  139.  
  140.     // Public members:
  141.     public:
  142.  
  143.         CENV();
  144.         ~CENV();
  145.  
  146.         HENV    m_henv;                    // ODBC environment handle
  147.  
  148.         operator HENV() const;       // CENV to HENV conversion
  149.  
  150.         virtual RETCODE Error(LPSTR  szSqlState,
  151.                             LPSDWORD pfNativeError,
  152.                             LPSTR    szErrorMsg,
  153.                             SWORD    cbErrorMsgMax = SQL_MAX_MESSAGE_LENGTH-1,
  154.                             LPSWORD  pcbErrorMsg = NULL);
  155.  
  156.         // ODBC functions
  157.         CDBC*   AllocConnect();
  158.  
  159.         RETCODE DataSources(UWORD fDirection,
  160.                             LPSTR szDSN,
  161.                             LPSTR szDescription,
  162.                             SWORD cbDescription=255);
  163.        RETCODE DataSources(UWORD   fDirection,
  164.                             LPSTR   szDSN,
  165.                             SWORD   cbDSNMax,
  166.                             LPSWORD pcbDSN,
  167.                             LPSTR   szDescription,
  168.                             SWORD   cbDescriptionMax,
  169.                             LPSWORD pcbDescription);
  170.  
  171.         RETCODE Transact(UWORD fType);
  172.  
  173.     // Protected members:
  174.     protected:
  175.  
  176. };
  177.  
  178.  
  179. ////////////////////////////////////////////////////////////////////////////
  180. // CDBC
  181. class CDBC : public CODBC {
  182.  
  183. #ifdef _AFX
  184.     DECLARE_DYNAMIC(CDBC);                  // Required by MFC
  185. #endif
  186.  
  187.     // Public members
  188.     public:
  189.  
  190.         CDBC(CENV& env);
  191.         CDBC(CENV* penv);
  192.         ~CDBC();
  193.  
  194.         HDBC    m_hdbc;                    // ODBC connection handle
  195.         CENV*   m_penv;                    // Associated environment object
  196.  
  197.         operator HDBC() const;        // CDBC to HDBC  conversion
  198.         operator CENV*() const;       // CDBC to CENV* conversion
  199.         operator CENV&() const;       // CDBC to CENV& conversion
  200.  
  201.         virtual RETCODE Error(LPSTR  szSqlState,
  202.                             LPSDWORD pfNativeError,
  203.                             LPSTR    szErrorMsg,
  204.                             SWORD    cbErrorMsgMax = SQL_MAX_MESSAGE_LENGTH-1,
  205.                             LPSWORD  pcbErrorMsg = NULL);
  206.  
  207.         // ODBC functions
  208.         CSTMT*  AllocStmt();
  209.  
  210.         RETCODE BrowseConnect(LPCSTR szConnStrIn,
  211.                             LPSTR    szConnStrOut,
  212.                             SWORD    cbConnStrOutMax);
  213.         RETCODE BrowseConnect(LPCSTR szConnStrIn,
  214.                             SWORD    cbConnStrIn,
  215.                             LPSTR    szConnStrOut,
  216.                             SWORD    cbConnStrOutMax,
  217.                             LPSWORD  pcbConnStrOut = NULL);
  218.  
  219.         RETCODE Connect(LPCSTR szDSN,
  220.                         LPCSTR szUID,
  221.                         LPCSTR szAuthStr = NULL);
  222.         RETCODE Connect(LPCSTR szDSN,
  223.                         SWORD  cbDSN,
  224.                         LPCSTR szUID,
  225.                         SWORD  cbUID,
  226.                         LPCSTR szAuthStr,
  227.                         SWORD  cbAuthStr);
  228.  
  229.         RETCODE Disconnect();
  230.  
  231.         RETCODE DriverConnect(
  232.                     HWND   hwnd,
  233.                     LPCSTR szConnStrIn,
  234.                     UWORD  fDriverCompletion = SQL_DRIVER_COMPLETE_REQUIRED);
  235.         RETCODE DriverConnect(
  236.                     HWND   hwnd,
  237.                     LPCSTR szConnStrIn,
  238.                     LPSTR  szConnStrOut,
  239.                     SWORD  cbConnStrOutMax,
  240.                     UWORD  fDriverCompletion = SQL_DRIVER_COMPLETE_REQUIRED);
  241.         RETCODE DriverConnect(
  242.                     HWND    hwnd,
  243.                     LPCSTR  szConnStrIn,
  244.                     SWORD   cbConnStrIn,
  245.                     LPSTR   szConnStrOut,
  246.                     SWORD   cbConnStrOutMax,
  247.                     LPSWORD pcbConnStrOut,
  248.                     UWORD   fDriverCompletion = SQL_DRIVER_COMPLETE_REQUIRED);
  249.  
  250.         RETCODE GetConnectOption(UWORD fOption, PTR pvParam);
  251.  
  252.         RETCODE GetFunctions(UWORD fFunction, LPUWORD pfExists);
  253.  
  254.         RETCODE GetInfo(UWORD   fInfoType,
  255.                         PTR     rgbInfoValue,
  256.                         SWORD   cbInfoValueMax = 4,
  257.                         LPSWORD pcbInfoValue = NULL);
  258.  
  259.         RETCODE NativeSql(LPCSTR szSqlStrIn,
  260.                         LPSTR    szSqlStr,
  261.                         SDWORD   cbSqlStrMax,
  262.                         LPSDWORD pcbSqlStr = NULL);
  263.         RETCODE NativeSql(LPCSTR szSqlStrIn,
  264.                         SDWORD   cbSqlStrIn,
  265.                         LPSTR    szSqlStr,
  266.                         SDWORD   cbSqlStrMax,
  267.                         LPSDWORD pcbSqlStr = NULL);
  268.  
  269.         RETCODE SetConnectOption(UWORD fOption, UDWORD vParam);
  270.  
  271.         RETCODE Transact(UWORD fType);
  272.  
  273.     // Protected members:
  274.     protected:
  275.  
  276.         void Initialize(CENV* penv);
  277. };
  278.  
  279.  
  280. ////////////////////////////////////////////////////////////////////////////
  281. // CSTMT
  282. class CSTMT : public CODBC {
  283.  
  284. #ifdef _AFX
  285.     DECLARE_DYNAMIC(CSTMT);                 // Required by MFC
  286. #endif
  287.  
  288.     // Public members
  289.     public:
  290.  
  291.         CSTMT(CDBC& dbc);
  292.         CSTMT(CDBC* pdbc);
  293.         ~CSTMT();
  294.  
  295.         HSTMT   m_hstmt;                   // ODBC statement handle
  296.         CDBC*   m_pdbc;                    // Associated connection  object
  297.         CENV*   m_penv;                    // Associated environment object
  298.  
  299.         operator HSTMT() const;      // CSTMT to HSTMT conversion
  300.         operator CDBC*() const;      // CSTMT to CDBC* conversion
  301.         operator CDBC&() const;      // CSTMT to CDBC& conversion
  302.         operator CENV*() const;      // CSTMT to CENV* conversion
  303.         operator CENV&() const;      // CSTMT to CENV& conversion
  304.  
  305.         virtual RETCODE Error(LPSTR  szSqlState,
  306.                             LPSDWORD pfNativeError,
  307.                             LPSTR    szErrorMsg,
  308.                             SWORD    cbErrorMsgMax = SQL_MAX_MESSAGE_LENGTH-1,
  309.                             LPSWORD  pcbErrorMsg = NULL);
  310.  
  311.         // ODBC functions
  312.         RETCODE BindCol(UWORD    icol,
  313.                         SWORD    fCType,
  314.                         PTR      rgbValue,
  315.                         SDWORD   cbValueMax,
  316.                         LPSDWORD pcbValue);
  317.  
  318.         RETCODE Cancel();
  319.  
  320.         RETCODE ColAttributes(UWORD  icol,
  321.                             UWORD    fDescType,
  322.                             LPSDWORD pfDesc);
  323.         RETCODE ColAttributes(UWORD  icol,
  324.                             UWORD    fDescType,
  325.                             PTR      rgbDesc,
  326.                             SWORD    cbDescMax,
  327.                             LPSWORD  pcbDesc = NULL);
  328.         RETCODE ColAttributes(UWORD  icol,
  329.                             UWORD    fDescType,
  330.                             PTR      rgbDesc,
  331.                             SWORD    cbDescMax,
  332.                             LPSWORD  pcbDesc,
  333.                             LPSDWORD pfDesc);
  334.  
  335.         RETCODE ColumnPrivileges(LPCSTR szTableQualifier,
  336.                                 LPCSTR  szTableOwner,
  337.                                 LPCSTR  szTableName,
  338.                                 LPCSTR  szColumnName);
  339.         RETCODE ColumnPrivileges(LPCSTR szTableQualifier,
  340.                                 SWORD   cbTableQualifier,
  341.                                 LPCSTR  szTableOwner,
  342.                                 SWORD   cbTableOwner,
  343.                                 LPCSTR  szTableName,
  344.                                 SWORD   cbTableName,
  345.                                 LPCSTR  szColumnName,
  346.                                 SWORD   cbColumnName);
  347.  
  348.         RETCODE Columns(LPCSTR  szTableQualifier,
  349.                         LPCSTR  szTableOwner,
  350.                         LPCSTR  szTableName,
  351.                         LPCSTR  szColumnName);
  352.         RETCODE Columns(LPCSTR  szTableQualifier,
  353.                         SWORD   cbTableQualifier,
  354.                         LPCSTR  szTableOwner,
  355.                         SWORD   cbTableOwner,
  356.                         LPCSTR  szTableName,
  357.                         SWORD   cbTableName,
  358.                         LPCSTR  szColumnName,
  359.                         SWORD   cbColumnName);
  360.  
  361.         RETCODE DescribeCol(UWORD    icol,
  362.                             LPSTR    szColName,
  363.                             SWORD    cbColNameMax,
  364.                             LPSWORD  pcbColName,
  365.                             LPSWORD  pfSqlType,
  366.                             LPUDWORD pcbColDef,
  367.                             LPSWORD  pibScale,
  368.                             LPSWORD  pfNullable);
  369.  
  370.         RETCODE DescribeParam(UWORD  ipar,
  371.                             LPSWORD  pfSqlType,
  372.                             LPUDWORD pcbColDef,
  373.                             LPSWORD  pibScale,
  374.                             LPSWORD  pfNullable);
  375.  
  376.         RETCODE ExecDirect(LPCSTR szSqlStr,
  377.                         SDWORD    cbSqlStr = SQL_NTS);
  378.  
  379.         RETCODE Execute();
  380.  
  381.         RETCODE ExtendedFetch(UWORD  fFetchType,
  382.                             SDWORD   irow,
  383.                             LPUWORD  rgfRowStatus);
  384.         RETCODE ExtendedFetch(UWORD  fFetchType,
  385.                             SDWORD   irow,
  386.                             LPUDWORD pcrow,
  387.                             LPUWORD  rgfRowStatus);
  388.  
  389.         RETCODE Fetch();
  390.         RETCODE Fetch(UWORD  fFetchType,
  391.                     SDWORD   irow,
  392.                     LPUWORD  rgfRowStatus);
  393.         RETCODE Fetch(UWORD  fFetchType,
  394.                     SDWORD   irow,
  395.                     LPUDWORD pcrow,
  396.                     LPUWORD  rgfRowStatus);
  397.  
  398.         RETCODE ForeignKeys(LPCSTR szPkTableQualifier,
  399.                             LPCSTR szPkTableOwner,
  400.                             LPCSTR szPkTableName,
  401.                             LPCSTR szFkTableQualifier,
  402.                             LPCSTR szFkTableOwner,
  403.                             LPCSTR szFkTableName);
  404.         RETCODE ForeignKeys(LPCSTR szPkTableQualifier,
  405.                             SWORD  cbPkTableQualifier,
  406.                             LPCSTR szPkTableOwner,
  407.                             SWORD  cbPkTableOwner,
  408.                             LPCSTR szPkTableName,
  409.                             SWORD  cbPkTableName,
  410.                             LPCSTR szFkTableQualifier,
  411.                             SWORD  cbFkTableQualifier,
  412.                             LPCSTR szFkTableOwner,
  413.                             SWORD  cbFkTableOwner,
  414.                             LPCSTR szFkTableName,
  415.                             SWORD  cbFkTableName);
  416.  
  417.         RETCODE Close();
  418.         RETCODE Unbind();
  419.         RETCODE ResetParams();
  420.         RETCODE FreeStmt(UWORD fOption);
  421.  
  422.         RETCODE GetCursorName(LPSTR szCursor,
  423.                             SWORD   cbCursorMax,
  424.                             LPSWORD pcbCursor = NULL);
  425.  
  426.         RETCODE GetData(UWORD    icol,
  427.                         SWORD    fCType,
  428.                         PTR      rgbValue,
  429.                         SDWORD   cbValueMax,
  430.                         LPSDWORD pcbValue);
  431.  
  432.         RETCODE GetStmtOption(UWORD fOption, PTR pvParam);
  433.  
  434.         RETCODE GetTypeInfo(SWORD fSqlType);
  435.  
  436.         RETCODE MoreResults();
  437.  
  438.         RETCODE NumParams(LPSWORD pcpar);
  439.  
  440.         RETCODE NumResultCols(LPSWORD pccol);
  441.  
  442.         RETCODE ParamData(LPPTR prgbValue);
  443.  
  444.         RETCODE ParamOptions(UDWORD crow, LPUDWORD pirow);
  445.  
  446.         RETCODE Prepare(LPCSTR szSqlStr,
  447.                         SDWORD cbSqlStr = SQL_NTS);
  448.  
  449.         RETCODE PrimaryKeys(LPCSTR szTableQualifier,
  450.                             LPCSTR szTableOwner,
  451.                             LPCSTR szTableName);
  452.         RETCODE PrimaryKeys(LPCSTR szTableQualifier,
  453.                             SWORD  cbTableQualifier,
  454.                             LPCSTR szTableOwner,
  455.                             SWORD  cbTableOwner,
  456.                             LPCSTR szTableName,
  457.                             SWORD  cbTableName);
  458.  
  459.         RETCODE ProcedureColumns(LPCSTR szProcQualifier,
  460.                                 LPCSTR  szProcOwner,
  461.                                 LPCSTR  szProcName,
  462.                                 LPCSTR  szColumnName);
  463.         RETCODE ProcedureColumns(LPCSTR szProcQualifier,
  464.                                 SWORD   cbProcQualifier,
  465.                                 LPCSTR  szProcOwner,
  466.                                 SWORD   cbProcOwner,
  467.                                 LPCSTR  szProcName,
  468.                                 SWORD   cbProcName,
  469.                                 LPCSTR  szColumnName,
  470.                                 SWORD   cbColumnName);
  471.  
  472.         RETCODE Procedures(LPCSTR szProcQualifier,
  473.                         LPCSTR    szProcOwner,
  474.                         LPCSTR    szProcName);
  475.         RETCODE Procedures(LPCSTR szProcQualifier,
  476.                         SWORD     cbProcQualifier,
  477.                         LPCSTR    szProcOwner,
  478.                         SWORD     cbProcOwner,
  479.                         LPCSTR    szProcName,
  480.                         SWORD     cbProcName);
  481.  
  482.         RETCODE PutData(PTR rgbValue, SDWORD cbValue);
  483.  
  484.         RETCODE RowCount(LPSDWORD pcrow);
  485.  
  486.         RETCODE SetCursorName(LPCSTR szCursor,
  487.                             SWORD    cbCursor = SQL_NTS);
  488.  
  489.         RETCODE SetParam(UWORD   ipar,
  490.                         SWORD    fCType,
  491.                         SWORD    fSqlType,
  492.                         UDWORD   cbColDef,
  493.                         SWORD    ibScale,
  494.                         PTR      rgbValue,
  495.                         LPSDWORD pcbValue = NULL);
  496.  
  497.         RETCODE SetPos(UWORD irow,
  498.                         BOOL fRefresh = TRUE,
  499.                         BOOL fLock = FALSE);
  500.  
  501.         RETCODE SetScrollOptions(UWORD fConcurrency = SQL_CONCUR_READ_ONLY,
  502.                                 SDWORD crowKeyset = SQL_SCROLL_FORWARD_ONLY,
  503.                                 UWORD  crowRowset = 1);
  504.  
  505.         RETCODE SetStmtOption(UWORD fOption, UDWORD vParam);
  506.  
  507.         RETCODE SpecialColumns(UWORD fColType,
  508.                             LPCSTR   szTableQualifier,
  509.                             LPCSTR   szTableOwner,
  510.                             LPCSTR   szTableName,
  511.                             UWORD    fScope = SQL_SCOPE_TRANSACTION,
  512.                             UWORD    fNullable = SQL_NULLABLE);
  513.         RETCODE SpecialColumns(UWORD fColType,
  514.                             LPCSTR   szTableQualifier,
  515.                             SWORD    cbTableQualifier,
  516.                             LPCSTR   szTableOwner,
  517.                             SWORD    cbTableOwner,
  518.                             LPCSTR   szTableName,
  519.                             SWORD    cbTableName,
  520.                             UWORD    fScope = SQL_SCOPE_TRANSACTION,
  521.                             UWORD    fNullable = SQL_NULLABLE);
  522.  
  523.         RETCODE Statistics(LPCSTR  szTableQualifier,
  524.                             LPCSTR szTableOwner,
  525.                             LPCSTR szTableName,
  526.                             UWORD  fUnique = SQL_INDEX_UNIQUE,
  527.                             UWORD  fAccuracy = SQL_QUICK);
  528.         RETCODE Statistics(LPCSTR  szTableQualifier,
  529.                             SWORD  cbTableQualifier,
  530.                             LPCSTR szTableOwner,
  531.                             SWORD  cbTableOwner,
  532.                             LPCSTR szTableName,
  533.                             SWORD  cbTableName,
  534.                             UWORD  fUnique = SQL_INDEX_UNIQUE,
  535.                             UWORD  fAccuracy = SQL_QUICK);
  536.  
  537.         RETCODE TablePrivileges(LPCSTR szTableQualifier,
  538.                                 LPCSTR szTableOwner,
  539.                                 LPCSTR szTableName);
  540.         RETCODE TablePrivileges(LPCSTR szTableQualifier,
  541.                                 SWORD  cbTableQualifier,
  542.                                 LPCSTR szTableOwner,
  543.                                 SWORD  cbTableOwner,
  544.                                 LPCSTR szTableName,
  545.                                 SWORD  cbTableName);
  546.  
  547.         RETCODE Tables(LPCSTR  szTableQualifier,
  548.                         LPCSTR szTableOwner,
  549.                         LPCSTR szTableName,
  550.                         LPCSTR szTableType);
  551.         RETCODE Tables(LPCSTR  szTableQualifier,
  552.                         SWORD  cbTableQualifier,
  553.                         LPCSTR szTableOwner,
  554.                         SWORD  cbTableOwner,
  555.                         LPCSTR szTableName,
  556.                         SWORD  cbTableName,
  557.                         LPCSTR szTableType,
  558.                         SWORD  cbTableType);
  559.  
  560.     // Protected members
  561.     protected:
  562.     
  563.         void Initialize(CDBC* pdbc);
  564. };
  565.  
  566.  
  567. // Inline functions --------------------------------------------------------
  568. #include    "codbc.inl"
  569.  
  570. #endif // __CODBC_H
  571.