home *** CD-ROM | disk | FTP | other *** search
/ Microsoft Internet Business Development Kit / PRODUCT_CD.iso / sqlsvr / odbcsdk / samples / cppdemo / codbc.inl < prev    next >
Encoding:
Text File  |  1994-12-07  |  26.6 KB  |  1,072 lines
  1. /*--------------------------------------------------------------------------
  2.   CODBC.INL - Low-level ODBC object classes inline functions
  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_INL
  10. #define __CODBC_INL
  11.  
  12. #if defined(_AFX) && defined(_DEBUG) && !defined(new)
  13. #define new DEBUG_NEW                  // Debugging version of new (MFC)
  14. #endif
  15.  
  16. #if !defined(_AFX) || !defined(_DEBUG)
  17. #define ASSERT(x)   (x)
  18. #endif
  19.  
  20. ////////////////////////////////////////////////////////////////////////////
  21. // CODBC
  22. inline CODBC::CODBC()
  23. {
  24.     m_rc = SQL_SUCCESS;
  25.     return;
  26. }
  27.  
  28. inline CODBC::~CODBC()
  29. {
  30.     return;
  31. }
  32.  
  33. inline RETCODE CODBC::Error(HENV    henv,
  34.                             HDBC     hdbc,
  35.                             HSTMT    hstmt,
  36.                             LPSTR    szSqlState,
  37.                             LPSDWORD pfNativeError,
  38.                             LPSTR    szErrorMsg,
  39.                             SWORD    cbErrorMsgMax,
  40.                             LPSWORD  cbErrorMsg)
  41. {
  42.     m_rc = ::SQLError(henv, hdbc, hstmt,
  43.                     (UCHAR FAR *)szSqlState,
  44.                     pfNativeError,
  45.                     (UCHAR FAR *)szErrorMsg,
  46.                     cbErrorMsgMax, cbErrorMsg);
  47.     return m_rc;
  48. }
  49.  
  50. inline BOOL CODBC::Success(RETCODE rc)
  51. {
  52.     return (rc >= 0);
  53. }
  54.  
  55.  
  56. #ifdef _AFX
  57. ////////////////////////////////////////////////////////////////////////////
  58. // CODBCException
  59. inline CODBCException::CODBCException(CODBC*   podbc,
  60.                                         UWORD   fFunction,
  61.                                         RETCODE rc)
  62. {
  63.     m_podbc     = podbc;
  64.     m_fFunction = fFunction;
  65.     m_rc        = rc;
  66.     return;
  67. }
  68.  
  69. inline void ThrowODBCException(CODBC*  podbc,
  70.                                 UWORD   fFunction,
  71.                                 RETCODE rc)
  72. {
  73.     THROW(new CODBCException(podbc, fFunction, rc));
  74.     return;
  75. }
  76. #endif
  77.  
  78.  
  79. ////////////////////////////////////////////////////////////////////////////
  80. // CENV
  81. inline CENV::CENV()
  82. {
  83.     m_henv = SQL_NULL_HENV;
  84.     m_rc   = ::SQLAllocEnv(&m_henv);
  85.     CRIT_CHECK_EX(SQLALLOCENV);
  86.     return;
  87. }
  88.  
  89. inline CENV::~CENV()
  90. {
  91.     if (m_henv != SQL_NULL_HENV) {
  92.         m_rc = ::SQLFreeEnv(m_henv);
  93.         CRIT_CHECK_EX(SQLFREEENV);
  94.     }
  95.     return;
  96. }
  97.  
  98. inline CENV::operator HENV() const
  99. {
  100.     return m_henv;
  101. }
  102.  
  103. inline RETCODE CENV::Error(LPSTR    szSqlState,
  104.                             LPSDWORD pfNativeError,
  105.                             LPSTR    szErrorMsg,
  106.                             SWORD    cbErrorMsgMax,
  107.                             LPSWORD  pcbErrorMsg)
  108. {
  109.     ASSERT(m_henv != SQL_NULL_HENV);
  110.     return CODBC::Error(m_henv, SQL_NULL_HDBC, SQL_NULL_HSTMT,
  111.                         szSqlState, pfNativeError, szErrorMsg,
  112.                         cbErrorMsgMax, pcbErrorMsg);
  113. }
  114.  
  115. inline CDBC* CENV::AllocConnect()
  116. {
  117.     ASSERT(m_henv != SQL_NULL_HENV);
  118.     return new CDBC(this);
  119. }
  120.  
  121. inline RETCODE CENV::DataSources(UWORD fDirection,
  122.                                 LPSTR   szDSN,
  123.                                 LPSTR   szDescription,
  124.                                 SWORD   cbDescription)
  125. {
  126.     return DataSources(fDirection, szDSN, SQL_MAX_DSN_LENGTH-1, NULL,
  127.                             szDescription, cbDescription, NULL);
  128. }
  129.  
  130. inline RETCODE CENV::DataSources(UWORD fDirection,
  131.                                 LPSTR   szDSN,
  132.                                 SWORD   cbDSNMax,
  133.                                 LPSWORD pcbDSN,
  134.                                 LPSTR   szDescription,
  135.                                 SWORD   cbDescriptionMax,
  136.                                 LPSWORD pcbDescription)
  137. {
  138.     ASSERT(m_henv != SQL_NULL_HENV);
  139.     m_rc = ::SQLDataSources(m_henv, fDirection,
  140.                             (UCHAR FAR *)szDSN, cbDSNMax, pcbDSN,
  141.                             (UCHAR FAR *)szDescription, cbDescriptionMax,
  142.                             pcbDescription);
  143.     CHECK_EX(SQLDATASOURCES);
  144.     return m_rc;
  145. }
  146.  
  147. inline RETCODE CENV::Transact(UWORD fType)
  148. {
  149.     m_rc = ::SQLTransact(m_henv, SQL_NULL_HDBC, fType);
  150.     CHECK_EX(SQLTRANSACT);
  151.     return m_rc;
  152. }
  153.  
  154.  
  155. ////////////////////////////////////////////////////////////////////////////
  156. // CDBC
  157. inline CDBC::CDBC(CENV& env)
  158. {
  159.     Initialize(&env);
  160.     return;
  161. }
  162.  
  163. inline CDBC::CDBC(CENV* penv)
  164. {
  165.     Initialize(penv);
  166.     return;
  167. }
  168.  
  169. inline void CDBC::Initialize(CENV* penv)
  170. {
  171.     ASSERT(penv != NULL);
  172.  
  173.     m_hdbc = SQL_NULL_HDBC;
  174.     m_penv = penv;
  175.     m_rc   = ::SQLAllocConnect(*penv, &m_hdbc);
  176.     CRIT_CHECK_EX(SQLALLOCCONNECT);
  177.     return;
  178. }
  179.  
  180. inline CDBC::~CDBC()
  181. {
  182.     if (m_hdbc != SQL_NULL_HDBC) {
  183.         m_rc = ::SQLFreeConnect(m_hdbc);
  184.         CRIT_CHECK_EX(SQLFREECONNECT);
  185.     }
  186.     return;
  187. }
  188.  
  189. inline CDBC::operator HDBC() const
  190. {
  191.     return m_hdbc;
  192. }
  193.  
  194. inline CDBC::operator CENV*() const
  195. {
  196.     ASSERT(m_penv != NULL);
  197.     return m_penv;
  198. }
  199.  
  200. inline CDBC::operator CENV&() const
  201. {
  202.     ASSERT(m_penv != NULL);
  203.     return *m_penv;
  204. }
  205.  
  206. inline RETCODE CDBC::Error(LPSTR    szSqlState,
  207.                             LPSDWORD pfNativeError,
  208.                             LPSTR    szErrorMsg,
  209.                             SWORD    cbErrorMsgMax,
  210.                             LPSWORD  pcbErrorMsg)
  211. {
  212.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  213.     return CODBC::Error(SQL_NULL_HENV, m_hdbc, SQL_NULL_HSTMT,
  214.                         szSqlState, pfNativeError, szErrorMsg,
  215.                         cbErrorMsgMax, pcbErrorMsg);
  216. }
  217.  
  218. inline CSTMT* CDBC::AllocStmt()
  219. {
  220.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  221.     return new CSTMT(this);
  222. }
  223.  
  224. inline RETCODE CDBC::BrowseConnect(LPCSTR szConnStrIn,
  225.                                     LPSTR  szConnStrOut,
  226.                                     SWORD  cbConnStrOutMax)
  227. {
  228.     return BrowseConnect(szConnStrIn, SQL_NTS, szConnStrOut, cbConnStrOutMax);
  229. }
  230.  
  231. inline RETCODE CDBC::BrowseConnect(LPCSTR  szConnStrIn,
  232.                                     SWORD   cbConnStrIn,
  233.                                     LPSTR   szConnStrOut,
  234.                                     SWORD   cbConnStrOutMax,
  235.                                     LPSWORD pcbConnStrOut)
  236. {
  237.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  238.     m_rc = ::SQLBrowseConnect(m_hdbc, (UCHAR FAR *)szConnStrIn, cbConnStrIn,
  239.                                 (UCHAR FAR *)szConnStrOut, cbConnStrOutMax,
  240.                                 pcbConnStrOut);
  241.     CHECK_EX(SQLBROWSECONNECT);
  242.     return m_rc;
  243. }
  244.  
  245. inline RETCODE CDBC::Connect(LPCSTR szDSN, LPCSTR szUID, LPCSTR szAuthStr)
  246. {
  247.     return Connect(szDSN, SQL_NTS, szUID, SQL_NTS, szAuthStr, SQL_NTS);
  248. }
  249.  
  250. inline RETCODE CDBC::Connect(LPCSTR szDSN,
  251.                             SWORD    cbDSN,
  252.                             LPCSTR   szUID,
  253.                             SWORD    cbUID,
  254.                             LPCSTR   szAuthStr,
  255.                             SWORD    cbAuthStr)
  256. {
  257.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  258.     m_rc = ::SQLConnect(m_hdbc, (UCHAR FAR *)szDSN, cbDSN,
  259.                         (UCHAR FAR *)szUID, cbUID, 
  260.                         (UCHAR FAR *)szAuthStr, cbAuthStr);
  261.     CHECK_EX(SQLCONNECT);
  262.     return m_rc;
  263. }
  264.  
  265. inline RETCODE CDBC::Disconnect()
  266. {
  267.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  268.     m_rc = ::SQLDisconnect(m_hdbc);
  269.     CHECK_EX(SQLDISCONNECT);
  270.     return m_rc;
  271. }
  272.  
  273. inline RETCODE CDBC::DriverConnect(HWND   hwnd,
  274.                                     LPCSTR szConnStrIn,
  275.                                     UWORD  fDriverCompletion)
  276. {
  277.     return DriverConnect(hwnd, szConnStrIn, SQL_NTS,
  278.                             NULL, 0, NULL, fDriverCompletion);
  279. }
  280.  
  281. inline RETCODE CDBC::DriverConnect(HWND   hwnd,
  282.                                     LPCSTR szConnStrIn,
  283.                                     LPSTR  szConnStrOut,
  284.                                     SWORD  cbConnStrOutMax,
  285.                                     UWORD  fDriverCompletion)
  286. {
  287.     return DriverConnect(hwnd, szConnStrIn, SQL_NTS,
  288.                     szConnStrOut, cbConnStrOutMax, NULL, fDriverCompletion);
  289. }
  290.  
  291. inline RETCODE CDBC::DriverConnect(HWND    hwnd,
  292.                                     LPCSTR  szConnStrIn,
  293.                                     SWORD   cbConnStrIn,
  294.                                     LPSTR   szConnStrOut,
  295.                                     SWORD   cbConnStrOutMax,
  296.                                     LPSWORD pcbConnStrOut,
  297.                                     UWORD   fDriverCompletion)
  298. {
  299.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  300.     m_rc = ::SQLDriverConnect(m_hdbc, hwnd,
  301.                         (UCHAR FAR *)szConnStrIn, cbConnStrIn,
  302.                         (UCHAR FAR *)szConnStrOut, cbConnStrOutMax,
  303.                         pcbConnStrOut, fDriverCompletion);
  304.     CHECK_EX(SQLDRIVERCONNECT);
  305.     return m_rc;
  306. }
  307.  
  308. inline RETCODE CDBC::GetConnectOption(UWORD fOption, PTR pvParam)
  309. {
  310.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  311.     m_rc = ::SQLGetConnectOption(m_hdbc, fOption, pvParam);
  312.     CHECK_EX(SQLGETCONNECTOPTION);
  313.     return m_rc;
  314. }
  315.  
  316. inline RETCODE CDBC::GetFunctions(UWORD fFunction, LPUWORD pfExists)
  317. {
  318.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  319.     m_rc = ::SQLGetFunctions(m_hdbc, fFunction, pfExists);
  320.     CHECK_EX(SQLGETFUNCTIONS);
  321.     return m_rc;
  322. }
  323.  
  324. inline RETCODE CDBC::GetInfo(UWORD fInfoType,
  325.                             PTR     rgbInfoValue,
  326.                             SWORD   cbInfoValueMax,
  327.                             LPSWORD pcbInfoValue)
  328. {
  329.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  330.     m_rc = ::SQLGetInfo(m_hdbc, fInfoType, 
  331.                         rgbInfoValue, cbInfoValueMax, pcbInfoValue);
  332.     CHECK_EX(SQLGETFUNCTIONS);
  333.     return m_rc;
  334. }
  335.  
  336. inline RETCODE CDBC::NativeSql(LPCSTR   szSqlStrIn,
  337.                                 LPSTR    szSqlStr,
  338.                                 SDWORD   cbSqlStrMax,
  339.                                 LPSDWORD pcbSqlStr)
  340. {
  341.     return NativeSql(szSqlStrIn, SQL_NTS, szSqlStr, cbSqlStrMax, pcbSqlStr);
  342. }
  343.  
  344. inline RETCODE CDBC::NativeSql(LPCSTR   szSqlStrIn,
  345.                                 SDWORD   cbSqlStrIn,
  346.                                 LPSTR    szSqlStr,
  347.                                 SDWORD   cbSqlStrMax,
  348.                                 LPSDWORD pcbSqlStr)
  349. {
  350.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  351.     m_rc = ::SQLNativeSql(m_hdbc, (UCHAR FAR *)szSqlStrIn, cbSqlStrIn,
  352.                             (UCHAR FAR *)szSqlStr, cbSqlStrMax, pcbSqlStr);
  353.     CHECK_EX(SQLNATIVESQL);
  354.     return m_rc;
  355. }
  356.  
  357. inline RETCODE CDBC::SetConnectOption(UWORD fOption, UDWORD vParam)
  358. {
  359.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  360.     m_rc = ::SQLSetConnectOption(m_hdbc, fOption, vParam);
  361.     CHECK_EX(SQLSETCONNECTOPTION);
  362.     return m_rc;
  363. }
  364.  
  365. inline RETCODE CDBC::Transact(UWORD fType)
  366. {
  367.     ASSERT(m_hdbc != SQL_NULL_HDBC);
  368.     m_rc = ::SQLTransact(SQL_NULL_HENV, m_hdbc, fType);
  369.     CHECK_EX(SQLTRANSACT);
  370.     return m_rc;
  371. }
  372.  
  373.  
  374. ////////////////////////////////////////////////////////////////////////////
  375. // CSTMT
  376. inline CSTMT::CSTMT(CDBC& dbc)
  377. {
  378.     Initialize(&dbc);
  379.     return;
  380. }
  381.  
  382. inline CSTMT::CSTMT(CDBC* pdbc)
  383. {
  384.     Initialize(pdbc);
  385.     return;
  386. }
  387.  
  388. inline void CSTMT::Initialize(CDBC* pdbc)
  389. {
  390.     ASSERT(pdbc != NULL);
  391.  
  392.     m_hstmt = SQL_NULL_HSTMT;
  393.     m_pdbc  = pdbc;
  394.     m_penv  = (CENV*)pdbc;
  395.  
  396.     m_rc    = ::SQLAllocStmt(HDBC(*pdbc), &m_hstmt);
  397.     CRIT_CHECK_EX(SQLALLOCSTMT);
  398.     return;
  399. }
  400.  
  401. inline CSTMT::~CSTMT()
  402. {
  403.     if (m_hstmt != SQL_NULL_HSTMT) {
  404.         m_rc = ::SQLFreeStmt(m_hstmt, SQL_DROP);
  405.         CRIT_CHECK_EX(SQLFREESTMT);
  406.     }
  407.     return;
  408. }
  409.  
  410. inline CSTMT::operator HSTMT() const
  411. {
  412.     return m_hstmt;
  413. }
  414.  
  415. inline CSTMT::operator CDBC*() const
  416. {
  417.     ASSERT(m_pdbc != NULL);
  418.     return m_pdbc;
  419. }
  420.  
  421. inline CSTMT::operator CDBC&() const
  422. {
  423.     ASSERT(m_pdbc != NULL);
  424.     return *m_pdbc;
  425. }
  426.  
  427. inline CSTMT::operator CENV*() const
  428. {
  429.     ASSERT(m_penv != NULL);
  430.     return m_penv;
  431. }
  432.  
  433. inline CSTMT::operator CENV&() const
  434. {
  435.     ASSERT(m_penv != NULL);
  436.     return *m_penv;
  437. }
  438.  
  439. inline RETCODE CSTMT::Error(LPSTR   szSqlState,
  440.                             LPSDWORD pfNativeError,
  441.                             LPSTR    szErrorMsg,
  442.                             SWORD    cbErrorMsgMax,
  443.                             LPSWORD  pcbErrorMsg)
  444. {
  445.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  446.     return CODBC::Error(SQL_NULL_HENV, SQL_NULL_HDBC, m_hstmt,
  447.                         szSqlState, pfNativeError, szErrorMsg,
  448.                         cbErrorMsgMax, pcbErrorMsg);
  449. }
  450.  
  451. inline RETCODE CSTMT::BindCol(UWORD icol,
  452.                             SWORD    fCType,
  453.                             PTR      rgbValue,
  454.                             SDWORD   cbValueMax,
  455.                             LPSDWORD pcbValue)
  456. {
  457.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  458.     m_rc = ::SQLBindCol(m_hstmt, icol, fCType, rgbValue, cbValueMax, pcbValue);
  459.     CHECK_EX(SQLBINDCOL);
  460.     return m_rc;
  461. }
  462.  
  463. inline RETCODE CSTMT::Cancel()
  464. {
  465.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  466.     m_rc = ::SQLCancel(m_hstmt);
  467.     CHECK_EX(SQLCANCEL);
  468.     return m_rc;
  469. }
  470.  
  471. inline RETCODE CSTMT::ColAttributes(UWORD   icol,
  472.                                     UWORD    fDescType,
  473.                                     LPSDWORD pfDesc)
  474. {
  475.     return ColAttributes(icol, fDescType, NULL, 0, NULL, pfDesc);
  476. }
  477.  
  478. inline RETCODE CSTMT::ColAttributes(UWORD   icol,
  479.                                     UWORD    fDescType,
  480.                                     PTR      rgbDesc,
  481.                                     SWORD    cbDescMax,
  482.                                     LPSWORD  pcbDesc)
  483. {
  484.     return ColAttributes(icol, fDescType, rgbDesc, cbDescMax, pcbDesc, NULL);
  485. }
  486.  
  487. inline RETCODE CSTMT::ColAttributes(UWORD   icol,
  488.                                     UWORD    fDescType,
  489.                                     PTR      rgbDesc,
  490.                                     SWORD    cbDescMax,
  491.                                     LPSWORD  pcbDesc,
  492.                                     LPSDWORD pfDesc)
  493. {
  494.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  495.     m_rc = ::SQLColAttributes(m_hstmt, icol, fDescType, rgbDesc,
  496.                                 cbDescMax, pcbDesc, pfDesc);
  497.     CHECK_EX(SQLCOLATTRIBUTES);
  498.     return m_rc;
  499. }
  500.  
  501. inline RETCODE CSTMT::ColumnPrivileges(LPCSTR szTableQualifier,
  502.                                     LPCSTR  szTableOwner,
  503.                                     LPCSTR  szTableName,
  504.                                     LPCSTR  szColumnName)
  505. {
  506.     return ColumnPrivileges(szTableQualifier, SQL_NTS,
  507.                             szTableOwner, SQL_NTS,
  508.                             szTableName, SQL_NTS,
  509.                             szColumnName, SQL_NTS);
  510. }
  511.  
  512. inline RETCODE CSTMT::ColumnPrivileges(LPCSTR  szTableQualifier,
  513.                                         SWORD   cbTableQualifier,
  514.                                         LPCSTR  szTableOwner,
  515.                                         SWORD   cbTableOwner,
  516.                                         LPCSTR  szTableName,
  517.                                         SWORD   cbTableName,
  518.                                         LPCSTR  szColumnName,
  519.                                         SWORD   cbColumnName)
  520. {
  521.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  522.     m_rc = ::SQLColumnPrivileges(m_hstmt,
  523.                         (UCHAR FAR *)szTableQualifier, cbTableQualifier,
  524.                         (UCHAR FAR *)szTableOwner, cbTableOwner,
  525.                         (UCHAR FAR *)szTableName, cbTableName,
  526.                         (UCHAR FAR *)szColumnName, cbColumnName);
  527.     CHECK_EX(SQLCOLUMNPRIVILEGES);
  528.     return m_rc;
  529. }
  530.  
  531. inline RETCODE CSTMT::Columns(LPCSTR   szTableQualifier,
  532.                                 LPCSTR  szTableOwner,
  533.                                 LPCSTR  szTableName,
  534.                                 LPCSTR  szColumnName)
  535. {
  536.     return Columns(szTableQualifier, SQL_NTS,
  537.                     szTableOwner, SQL_NTS,
  538.                     szTableName, SQL_NTS,
  539.                     szColumnName, SQL_NTS);
  540. }
  541.  
  542. inline RETCODE CSTMT::Columns(LPCSTR   szTableQualifier,
  543.                                 SWORD   cbTableQualifier,
  544.                                 LPCSTR  szTableOwner,
  545.                                 SWORD   cbTableOwner,
  546.                                 LPCSTR  szTableName,
  547.                                 SWORD   cbTableName,
  548.                                 LPCSTR  szColumnName,
  549.                                 SWORD   cbColumnName)
  550. {
  551.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  552.     m_rc = ::SQLColumns(m_hstmt,
  553.                         (UCHAR FAR *)szTableQualifier, cbTableQualifier,
  554.                         (UCHAR FAR *)szTableOwner, cbTableOwner,
  555.                         (UCHAR FAR *)szTableName, cbTableName,
  556.                         (UCHAR FAR *)szColumnName, cbColumnName);
  557.     CHECK_EX(SQLCOLUMNS);
  558.     return m_rc;
  559. }
  560.  
  561. inline RETCODE CSTMT::DescribeCol(UWORD     icol,
  562.                                     LPSTR    szColName,
  563.                                     SWORD    cbColNameMax,
  564.                                     LPSWORD  pcbColName,
  565.                                     LPSWORD  pfSqlType,
  566.                                     LPUDWORD pcbColDef,
  567.                                     LPSWORD  pibScale,
  568.                                     LPSWORD  pfNullable)
  569. {
  570.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  571.     m_rc = ::SQLDescribeCol(m_hstmt, icol,
  572.                             (UCHAR FAR *)szColName, cbColNameMax,
  573.                             pcbColName, pfSqlType, pcbColDef,
  574.                             pibScale, pfNullable);
  575.     CHECK_EX(SQLDESCRIBECOL);
  576.     return m_rc;
  577. }
  578.  
  579. inline RETCODE CSTMT::DescribeParam(UWORD   ipar,
  580.                                     LPSWORD  pfSqlType,
  581.                                     LPUDWORD pcbColDef,
  582.                                     LPSWORD  pibScale,
  583.                                     LPSWORD  pfNullable)
  584. {
  585.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  586.     m_rc = ::SQLDescribeParam(m_hstmt, ipar, pfSqlType, pcbColDef,
  587.                                     pibScale, pfNullable);
  588.     CHECK_EX(SQLDESCRIBEPARAM);
  589.     return m_rc;
  590. }
  591.  
  592. inline RETCODE CSTMT::ExecDirect(LPCSTR szSqlStr,
  593.                                 SDWORD   cbSqlStr)
  594. {
  595.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  596.     m_rc = ::SQLExecDirect(m_hstmt, (UCHAR FAR *)szSqlStr, cbSqlStr);
  597.     CHECK_EX(SQLEXECDIRECT);
  598.     return m_rc;
  599. }
  600.  
  601. inline RETCODE CSTMT::Execute()
  602. {
  603.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  604.     m_rc = ::SQLExecute(m_hstmt);
  605.     CHECK_EX(SQLEXECUTE);
  606.     return m_rc;
  607. }
  608.  
  609. inline RETCODE CSTMT::ExtendedFetch(UWORD  fFetchType,
  610.                                     SDWORD   irow,
  611.                                     LPUWORD  rgfRowStatus)
  612. {
  613.     return ExtendedFetch(fFetchType, irow, NULL, rgfRowStatus);
  614. }
  615.  
  616. inline RETCODE CSTMT::ExtendedFetch(UWORD  fFetchType,
  617.                                     SDWORD   irow,
  618.                                     LPUDWORD pcrow,
  619.                                     LPUWORD  rgfRowStatus)
  620. {
  621.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  622.     m_rc = ::SQLExtendedFetch(m_hstmt, fFetchType, irow, pcrow, rgfRowStatus);
  623.     CHECK_EX(SQLEXTENDEDFETCH);
  624.     return m_rc;
  625. }
  626.  
  627. inline RETCODE CSTMT::Fetch()
  628. {
  629.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  630.     m_rc = ::SQLFetch(m_hstmt);
  631.     CHECK_EX(SQLFETCH);
  632.     return m_rc;
  633. }
  634.  
  635. inline RETCODE CSTMT::Fetch(UWORD  fFetchType,
  636.                             SDWORD   irow,
  637.                             LPUWORD  rgfRowStatus)
  638. {
  639.     return ExtendedFetch(fFetchType, irow, NULL, rgfRowStatus);
  640. }
  641.  
  642. inline RETCODE CSTMT::Fetch(UWORD  fFetchType,
  643.                             SDWORD   irow,
  644.                             LPUDWORD pcrow,
  645.                             LPUWORD  rgfRowStatus)
  646. {
  647.     return ExtendedFetch(fFetchType, irow, pcrow, rgfRowStatus);
  648. }
  649.  
  650. inline RETCODE CSTMT::ForeignKeys(LPCSTR szPkTableQualifier,
  651.                                     LPCSTR szPkTableOwner,
  652.                                     LPCSTR szPkTableName,
  653.                                     LPCSTR szFkTableQualifier,
  654.                                     LPCSTR szFkTableOwner,
  655.                                     LPCSTR szFkTableName)
  656. {
  657.     return ForeignKeys(szPkTableQualifier, SQL_NTS,
  658.                     szPkTableOwner, SQL_NTS,
  659.                     szPkTableName, SQL_NTS,
  660.                     szFkTableQualifier, SQL_NTS,
  661.                     szFkTableOwner, SQL_NTS,
  662.                     szFkTableName, SQL_NTS);
  663.                         
  664. }
  665.  
  666. inline RETCODE CSTMT::ForeignKeys(LPCSTR szPkTableQualifier,
  667.                                     SWORD  cbPkTableQualifier,
  668.                                     LPCSTR szPkTableOwner,
  669.                                     SWORD  cbPkTableOwner,
  670.                                     LPCSTR szPkTableName,
  671.                                     SWORD  cbPkTableName,
  672.                                     LPCSTR szFkTableQualifier,
  673.                                     SWORD  cbFkTableQualifier,
  674.                                     LPCSTR szFkTableOwner,
  675.                                     SWORD  cbFkTableOwner,
  676.                                     LPCSTR szFkTableName,
  677.                                     SWORD  cbFkTableName)
  678. {
  679.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  680.     m_rc = ::SQLForeignKeys(m_hstmt,
  681.                         (UCHAR FAR *)szPkTableQualifier, cbPkTableQualifier,
  682.                         (UCHAR FAR *)szPkTableOwner, cbPkTableOwner,
  683.                         (UCHAR FAR *)szPkTableName, cbPkTableName,
  684.                         (UCHAR FAR *)szFkTableQualifier, cbFkTableQualifier,
  685.                         (UCHAR FAR *)szFkTableOwner, cbFkTableOwner,
  686.                         (UCHAR FAR *)szFkTableName, cbFkTableName);
  687.     CHECK_EX(SQLFOREIGNKEYS);
  688.     return m_rc;
  689. }
  690.  
  691. inline RETCODE CSTMT::Close()
  692. {
  693.     return FreeStmt(SQL_CLOSE);
  694. }
  695.  
  696. inline RETCODE CSTMT::Unbind()
  697. {
  698.     return FreeStmt(SQL_UNBIND);
  699. }
  700.  
  701. inline RETCODE CSTMT::ResetParams()
  702. {
  703.     return FreeStmt(SQL_RESET_PARAMS);
  704. }
  705.  
  706. inline RETCODE CSTMT::FreeStmt(UWORD fOption)
  707. {
  708.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  709.     ASSERT(fOption != SQL_DROP);
  710.     m_rc = ::SQLFreeStmt(m_hstmt, fOption);
  711.     CHECK_EX(SQLFREESTMT);
  712.     return m_rc;
  713. }
  714.  
  715. inline RETCODE CSTMT::GetCursorName(LPSTR szCursor,
  716.                                     SWORD   cbCursorMax,
  717.                                     LPSWORD pcbCursor)
  718. {
  719.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  720.     m_rc = ::SQLGetCursorName(m_hstmt, (UCHAR FAR *)szCursor,
  721.                                 cbCursorMax, pcbCursor);
  722.     CHECK_EX(SQLGETCURSORNAME);
  723.     return m_rc;
  724. }
  725.  
  726. inline RETCODE CSTMT::GetData(UWORD    icol,
  727.                                 SWORD    fCType,
  728.                                 PTR      rgbValue,
  729.                                 SDWORD   cbValueMax,
  730.                                 LPSDWORD pcbValue)
  731. {
  732.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  733.     m_rc = ::SQLGetData(m_hstmt, icol, fCType, rgbValue, cbValueMax, pcbValue);
  734.     CHECK_EX(SQLGETDATA);
  735.     return m_rc;
  736. }
  737.  
  738. inline RETCODE CSTMT::GetStmtOption(UWORD fOption, PTR pvParam)
  739. {
  740.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  741.     m_rc = ::SQLGetStmtOption(m_hstmt, fOption, pvParam);
  742.     CHECK_EX(SQLGETSTMTOPTION);
  743.     return m_rc;
  744. }
  745.  
  746. inline RETCODE CSTMT::GetTypeInfo(SWORD fSqlType)
  747. {
  748.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  749.     m_rc = ::SQLGetTypeInfo(m_hstmt, fSqlType);
  750.     CHECK_EX(SQLGETINFO);
  751.     return m_rc;
  752. }
  753.  
  754. inline RETCODE CSTMT::MoreResults()
  755. {
  756.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  757.     m_rc = ::SQLMoreResults(m_hstmt);
  758.     CHECK_EX(SQLMORERESULTS);
  759.     return m_rc;
  760. }
  761.  
  762. inline RETCODE CSTMT::NumParams(LPSWORD pcpar)
  763. {
  764.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  765.     m_rc = ::SQLNumParams(m_hstmt, pcpar);
  766.     CHECK_EX(SQLNUMPARAMS);
  767.     return m_rc;
  768. }
  769.  
  770. inline RETCODE CSTMT::NumResultCols(LPSWORD pccol)
  771. {
  772.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  773.     m_rc = ::SQLNumResultCols(m_hstmt, pccol);
  774.     CHECK_EX(SQLNUMRESULTCOLS);
  775.     return m_rc;
  776. }
  777.  
  778. inline RETCODE CSTMT::ParamData(LPPTR prgbValue)
  779. {
  780.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  781.     m_rc = ::SQLParamData(m_hstmt, prgbValue);
  782.     CHECK_EX(SQLPARAMDATA);
  783.     return m_rc;
  784. }
  785.  
  786. inline RETCODE CSTMT::ParamOptions(UDWORD crow, LPUDWORD pirow)
  787. {
  788.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  789.     m_rc = ::SQLParamOptions(m_hstmt, crow, pirow);
  790.     CHECK_EX(SQLPARAMOPTIONS);
  791.     return m_rc;
  792. }
  793.  
  794. inline RETCODE CSTMT::Prepare(LPCSTR szSqlStr,
  795.                                 SDWORD cbSqlStr)
  796. {
  797.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  798.     m_rc = ::SQLPrepare(m_hstmt, (UCHAR FAR *)szSqlStr, cbSqlStr);
  799.     CHECK_EX(SQLPREPARE);
  800.     return m_rc;
  801. }
  802.  
  803. inline RETCODE CSTMT::PrimaryKeys(LPCSTR szTableQualifier,
  804.                                     LPCSTR szTableOwner,
  805.                                     LPCSTR szTableName)
  806. {
  807.     return PrimaryKeys(szTableQualifier, SQL_NTS,
  808.                         szTableOwner, SQL_NTS,
  809.                         szTableName, SQL_NTS);
  810. }
  811.  
  812. inline RETCODE CSTMT::PrimaryKeys(LPCSTR szTableQualifier,
  813.                                     SWORD  cbTableQualifier,
  814.                                     LPCSTR szTableOwner,
  815.                                     SWORD  cbTableOwner,
  816.                                     LPCSTR szTableName,
  817.                                     SWORD  cbTableName)
  818. {
  819.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  820.     m_rc = ::SQLPrimaryKeys(m_hstmt,
  821.                             (UCHAR FAR *)szTableQualifier, cbTableQualifier,
  822.                             (UCHAR FAR *)szTableOwner, cbTableOwner,
  823.                             (UCHAR FAR *)szTableName, cbTableName);
  824.     CHECK_EX(SQLPRIMARYKEYS);
  825.     return m_rc;
  826. }
  827.  
  828. inline RETCODE CSTMT::ProcedureColumns(LPCSTR szProcQualifier,
  829.                                         LPCSTR  szProcOwner,
  830.                                         LPCSTR  szProcName,
  831.                                         LPCSTR  szColumnName)
  832. {
  833.     return ProcedureColumns(szProcQualifier, szProcOwner,
  834.                             szProcName, szColumnName);
  835. }
  836.  
  837. inline RETCODE CSTMT::ProcedureColumns(LPCSTR szProcQualifier,
  838.                                         SWORD   cbProcQualifier,
  839.                                         LPCSTR  szProcOwner,
  840.                                         SWORD   cbProcOwner,
  841.                                         LPCSTR  szProcName,
  842.                                         SWORD   cbProcName,
  843.                                         LPCSTR  szColumnName,
  844.                                         SWORD   cbColumnName)
  845. {
  846.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  847.     m_rc = ::SQLProcedureColumns(m_hstmt,
  848.                             (UCHAR FAR *)szProcQualifier, cbProcQualifier,
  849.                             (UCHAR FAR *)szProcOwner, cbProcOwner,
  850.                             (UCHAR FAR *)szProcName, cbProcName,
  851.                             (UCHAR FAR *)szColumnName, cbColumnName);
  852.     CHECK_EX(SQLPROCEDURECOLUMNS);
  853.     return m_rc;
  854. }
  855.  
  856. inline RETCODE CSTMT::Procedures(LPCSTR szProcQualifier,
  857.                                 LPCSTR    szProcOwner,
  858.                                 LPCSTR    szProcName)
  859. {
  860.     return Procedures(szProcQualifier, SQL_NTS,
  861.                     szProcOwner, SQL_NTS,
  862.                     szProcName, SQL_NTS);
  863. }
  864.  
  865. inline RETCODE CSTMT::Procedures(LPCSTR szProcQualifier,
  866.                                 SWORD     cbProcQualifier,
  867.                                 LPCSTR    szProcOwner,
  868.                                 SWORD     cbProcOwner,
  869.                                 LPCSTR    szProcName,
  870.                                 SWORD     cbProcName)
  871. {
  872.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  873.     m_rc = ::SQLProcedures(m_hstmt,
  874.                         (UCHAR FAR *)szProcQualifier, cbProcQualifier,
  875.                         (UCHAR FAR *)szProcOwner, cbProcOwner,
  876.                         (UCHAR FAR *)szProcName, cbProcName);
  877.     CHECK_EX(SQLPROCEDURES);
  878.     return m_rc;
  879. }
  880.  
  881. inline RETCODE CSTMT::PutData(PTR rgbValue, SDWORD cbValue)
  882. {
  883.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  884.     m_rc = ::SQLPutData(m_hstmt, rgbValue, cbValue);
  885.     CHECK_EX(SQLPUTDATA);
  886.     return m_rc;
  887. }
  888.  
  889. inline RETCODE CSTMT::RowCount(LPSDWORD pcrow)
  890. {
  891.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  892.     m_rc = ::SQLRowCount(m_hstmt, pcrow);
  893.     CHECK_EX(SQLROWCOUNT);
  894.     return m_rc;
  895. }
  896.  
  897. inline RETCODE CSTMT::SetCursorName(LPCSTR szCursor,
  898.                                     SWORD    cbCursor)
  899. {
  900.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  901.     m_rc = ::SQLSetCursorName(m_hstmt, (UCHAR FAR *)szCursor, cbCursor);
  902.     CHECK_EX(SQLSETCURSORNAME);
  903.     return m_rc;
  904. }
  905.  
  906. inline RETCODE CSTMT::SetParam(UWORD   ipar,
  907.                                 SWORD    fCType,
  908.                                 SWORD    fSqlType,
  909.                                 UDWORD   cbColDef,
  910.                                 SWORD    ibScale,
  911.                                 PTR      rgbValue,
  912.                                 LPSDWORD pcbValue)
  913. {
  914.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  915.     m_rc = ::SQLSetParam(m_hstmt, ipar, fCType, fSqlType,
  916.                         cbColDef, ibScale, rgbValue, pcbValue);
  917.     CHECK_EX(SQLSETPARAM);
  918.     return m_rc;
  919. }
  920.  
  921. inline RETCODE CSTMT::SetPos(UWORD irow,
  922.                                 BOOL fRefresh,
  923.                                 BOOL fLock)
  924. {
  925.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  926.     m_rc = ::SQLSetPos(m_hstmt, irow, fRefresh, fLock);
  927.     CHECK_EX(SQLSETPOS);
  928.     return m_rc;
  929. }
  930.  
  931. inline RETCODE CSTMT::SetScrollOptions(UWORD fConcurrency,
  932.                                         SDWORD crowKeyset,
  933.                                         UWORD  crowRowset)
  934. {
  935.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  936.     m_rc = ::SQLSetScrollOptions(m_hstmt, fConcurrency,
  937.                                 crowKeyset, crowRowset);
  938.     CHECK_EX(SQLSETSCROLLOPTIONS);
  939.     return m_rc;
  940. }
  941.  
  942.  
  943. inline RETCODE CSTMT::SetStmtOption(UWORD fOption, UDWORD vParam)
  944. {
  945.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  946.     m_rc = ::SQLSetStmtOption(m_hstmt, fOption, vParam);
  947.     CHECK_EX(SQLSETSTMTOPTION);
  948.     return m_rc;
  949. }
  950.  
  951. inline RETCODE CSTMT::SpecialColumns(UWORD fColType,
  952.                                     LPCSTR   szTableQualifier,
  953.                                     LPCSTR   szTableOwner,
  954.                                     LPCSTR   szTableName,
  955.                                     UWORD    fScope,
  956.                                     UWORD    fNullable)
  957. {
  958.     return SpecialColumns(fColType, szTableQualifier, SQL_NTS,
  959.                         szTableOwner, SQL_NTS,
  960.                         szTableName, SQL_NTS,
  961.                         fScope, fNullable);
  962. }
  963.  
  964. inline RETCODE CSTMT::SpecialColumns(UWORD fColType,
  965.                                     LPCSTR   szTableQualifier,
  966.                                     SWORD    cbTableQualifier,
  967.                                     LPCSTR   szTableOwner,
  968.                                     SWORD    cbTableOwner,
  969.                                     LPCSTR   szTableName,
  970.                                     SWORD    cbTableName,
  971.                                     UWORD    fScope,
  972.                                     UWORD    fNullable)
  973. {
  974.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  975.     m_rc = ::SQLSpecialColumns(m_hstmt, fColType,
  976.                             (UCHAR FAR *)szTableQualifier, cbTableQualifier,
  977.                             (UCHAR FAR *)szTableOwner, cbTableOwner,
  978.                             (UCHAR FAR *)szTableName, cbTableName,
  979.                             fScope, fNullable);
  980.     CHECK_EX(SQLSPECIALCOLUMNS);
  981.     return m_rc;
  982. }
  983.  
  984. inline RETCODE CSTMT::Statistics(LPCSTR  szTableQualifier,
  985.                                     LPCSTR szTableOwner,
  986.                                     LPCSTR szTableName,
  987.                                     UWORD  fUnique,
  988.                                     UWORD  fAccuracy)
  989. {
  990.     return Statistics(szTableQualifier, SQL_NTS,
  991.                     szTableOwner, SQL_NTS,
  992.                     szTableName, SQL_NTS,
  993.                     fUnique, fAccuracy);
  994. }
  995.  
  996. inline RETCODE CSTMT::Statistics(LPCSTR  szTableQualifier,
  997.                                     SWORD  cbTableQualifier,
  998.                                     LPCSTR szTableOwner,
  999.                                     SWORD  cbTableOwner,
  1000.                                     LPCSTR szTableName,
  1001.                                     SWORD  cbTableName,
  1002.                                     UWORD  fUnique,
  1003.                                     UWORD  fAccuracy)
  1004. {
  1005.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  1006.     m_rc = ::SQLStatistics(m_hstmt,
  1007.                         (UCHAR FAR *)szTableQualifier, cbTableQualifier,
  1008.                         (UCHAR FAR *)szTableOwner, cbTableOwner,
  1009.                         (UCHAR FAR *)szTableName, cbTableName,
  1010.                         fUnique, fAccuracy);
  1011.     CHECK_EX(SQLSTATISTICS);
  1012.     return m_rc;
  1013. }
  1014.  
  1015. inline RETCODE CSTMT::TablePrivileges(LPCSTR szTableQualifier,
  1016.                                         LPCSTR szTableOwner,
  1017.                                         LPCSTR szTableName)
  1018. {
  1019.     return TablePrivileges(szTableQualifier, SQL_NTS,
  1020.                             szTableOwner, SQL_NTS,
  1021.                             szTableName, SQL_NTS);
  1022. }
  1023.  
  1024. inline RETCODE CSTMT::TablePrivileges(LPCSTR szTableQualifier,
  1025.                                         SWORD  cbTableQualifier,
  1026.                                         LPCSTR szTableOwner,
  1027.                                         SWORD  cbTableOwner,
  1028.                                         LPCSTR szTableName,
  1029.                                         SWORD  cbTableName)
  1030. {
  1031.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  1032.     m_rc = ::SQLTablePrivileges(m_hstmt,
  1033.                         (UCHAR FAR *)szTableQualifier, cbTableQualifier,
  1034.                         (UCHAR FAR *)szTableOwner, cbTableOwner,
  1035.                         (UCHAR FAR *)szTableName, cbTableName);
  1036.     CHECK_EX(SQLTABLEPRIVILEGES);
  1037.     return m_rc;
  1038. }
  1039.  
  1040. inline RETCODE CSTMT::Tables(LPCSTR  szTableQualifier,
  1041.                                 LPCSTR szTableOwner,
  1042.                                 LPCSTR szTableName,
  1043.                                 LPCSTR szTableType)
  1044. {
  1045.     return Tables(szTableQualifier, SQL_NTS,
  1046.                 szTableOwner, SQL_NTS,
  1047.                 szTableName, SQL_NTS,
  1048.                 szTableType, SQL_NTS);
  1049. }
  1050.  
  1051. inline RETCODE CSTMT::Tables(LPCSTR  szTableQualifier,
  1052.                                 SWORD  cbTableQualifier,
  1053.                                 LPCSTR szTableOwner,
  1054.                                 SWORD  cbTableOwner,
  1055.                                 LPCSTR szTableName,
  1056.                                 SWORD  cbTableName,
  1057.                                 LPCSTR szTableType,
  1058.                                 SWORD  cbTableType)
  1059. {
  1060.     ASSERT(m_hstmt != SQL_NULL_HSTMT);
  1061.     m_rc = ::SQLTables(m_hstmt,
  1062.                         (UCHAR FAR *)szTableQualifier, cbTableQualifier,
  1063.                         (UCHAR FAR *)szTableOwner, cbTableOwner,
  1064.                         (UCHAR FAR *)szTableName, cbTableName,
  1065.                         (UCHAR FAR *)szTableType, cbTableType);
  1066.     CHECK_EX(SQLTABLES);
  1067.     return m_rc;
  1068. }
  1069.  
  1070.  
  1071. #endif // __CODBC_INL
  1072.