home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / object10 / osession.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-04-03  |  15.7 KB  |  643 lines
  1. /* Copyright (c) Oracle Corporation 1994.  All Rights Reserved */
  2.  
  3. /*
  4.     This source code is provided as a debugging aid for developers
  5.     who have purchased Oracle Objects for OLE    .  Please see the
  6.     online help for documentation of these classes.
  7. */
  8.  
  9. /*
  10.     Oracle Objects for OLE     C++ Classes
  11.     
  12.     This file implements the OSession, OConnection and OClient classes
  13.                            
  14.     CREATED    ********   11/22/94
  15.     RWOOLARD    MODIFIED    03/20/95
  16.                 bug#    263010    GetNamedSession returns default when name NULL
  17. */
  18.  
  19. #include "windows.h"
  20. #include <ole2.h>
  21. #include <olenls.h>       
  22. #include <dispatch.h>  
  23.  
  24. #ifndef ORACL_ORACLE
  25. #include "oracl.h"
  26. #endif
  27.  
  28. #ifndef _OracleInProcServer_H_
  29. #include <oratlb.h>
  30. #endif
  31.  
  32. #ifndef ORAOBJI_ORACLE
  33. #include "oraobji.h"
  34. #endif
  35.  
  36. static const CLSID CLSID_XOSession = 
  37. {0x3893b4a0, 0xffd8, 0x101a, { 0xad, 0xf2, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  38.  
  39. static const IID IID_IOraSession =
  40. {0xa16bec60, 0x134a, 0x101b, { 0x91, 0x9e, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  41. static const IID IID_IOraClient =
  42. {0x8041eee0, 0x134a, 0x101b, { 0x91, 0x9e, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  43. static const IID IID_IOraConnection =
  44. {0xbea85c00, 0x134a, 0x101b, { 0x91, 0x9e, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };   
  45.  
  46. // ----- OSession -----------------------------------------------
  47.  
  48. OSession::OSession(void)
  49. {
  50.     m_name = 0;
  51.     m_errtext = 0;
  52.     m_version = 0;
  53. }
  54.  
  55. OSession::OSession(const OSession &other) // copy constructor
  56. {
  57.     m_name = 0;
  58.     m_errtext = 0;
  59.     m_version = 0;
  60.     Copy(other); // call internal copier
  61. }
  62.  
  63. OSession::OSession(const char *sname)
  64. { // create & open a session
  65.     m_name = 0;
  66.     m_errtext = 0;
  67.     m_version = 0;
  68.     if (sname)
  69.         Open(sname);
  70.     else
  71.         Open();
  72. }
  73.  
  74. // create a brand new session from scratch.  One way or another we always start from here
  75. //    because all the rest of the objects hang off this initial session
  76.  
  77. OSession::~OSession(void)
  78. {
  79.     Cleanup();
  80. }
  81.  
  82. oresult OSession::Open(void)
  83. {
  84.     Cleanup();
  85.     
  86.     if (!CheckOLE())
  87.     { // OLE isn't initialized
  88.         SetInternalError(OERROR_SYSTEM);
  89.         return(OFAILURE);
  90.     }
  91.  
  92.     void *tempi;
  93.     HRESULT hr = CoCreateInstance(CLSID_XOSession, NULL, CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER,
  94.                                   IID_IOraSession, &tempi);
  95.     
  96.     if (FAILED(hr))
  97.     { // can't create session object
  98.         // we could save the HRESULT for later use
  99.         SetInternalError(OERROR_SYSTEM);
  100.         return(OFAILURE);
  101.     }
  102.     
  103.     return(SetObjectInterface(tempi));                              
  104. }
  105.  
  106. // open a new named session
  107. oresult OSession::Open(const char *sname)
  108. {
  109.     // get the client object
  110.     OSession sess;
  111.     sess.Open();  // open the default session
  112.     OClient oCl = sess.GetClient();
  113.     if (!oCl.IsOpen())
  114.     { // no client object not opened yet
  115.         SetInternalError(OERROR_INVPARENT);
  116.         return(OFAILURE);
  117.     }
  118.     if (!sname)
  119.     {
  120.         SetInternalError(OERROR_BADARG);
  121.         return(OFAILURE);
  122.     }
  123.     
  124.     oCl.ErrorReset();
  125.     BSTR cp = OObjectAllocString(sname);
  126.     IDispatch *connect = ((_IOraClient *) (oCl.Internal()))->get_CreateSession(cp);
  127.     OObjectFreeString(cp);
  128.     
  129.     return(OpenHelper((void *) connect, oCl.Internal()));
  130. }
  131.  
  132. OSession OSession::GetNamedSession(const char *sname)
  133. {
  134.     OSession nameds;
  135.  
  136.     // temporary OSession on default session
  137.     OSession defsess(0);
  138.  
  139.     if (!defsess.IsOpen())
  140.     { // can't open default session - probably not initialized
  141.         nameds.SetInternalError(OERROR_INVPARENT);
  142.         return(nameds); // return of closed session indicates error
  143.     }
  144.     
  145.     if (!sname || !strcmp (sname, ""))
  146.         return(defsess);  // user just wanted default session
  147.     
  148.     // otherwise - fetch the named session
  149.     BSTR tempname = OObjectAllocString(sname);
  150.     IDispatch *sess = ((_IOraSession *) (defsess.Internal()))->get_ConnectSession(tempname);
  151.     OObjectFreeString((char *) tempname);
  152.     
  153.     // new session
  154.     nameds.OpenHelper((void *) sess, defsess.Internal());
  155.     
  156.     return(nameds);
  157. }
  158.  
  159. OConnectionCollection OSession::GetConnections(void) const
  160. {
  161.     OConnectionCollection cset;
  162.     
  163.     if (ActionGetStart(&cset) != OSUCCESS)
  164.         return(cset); // returning unopened object - indicates error
  165.     
  166.     IDispatch *connect = ((_IOraSession *) (Internal()))->get_Connections();
  167.     
  168.     cset.OpenHelper((void *) connect, Internal());
  169.     
  170.     return(cset);
  171. }
  172.  
  173. OClient OSession::GetClient(void) const
  174. {
  175.     OClient cl;
  176.     
  177.     if (ActionGetStart(&cl) != OSUCCESS)
  178.         return(cl); // returning unopened object - indicates error
  179.     
  180.     IDispatch *connect = ((_IOraSession *) (Internal()))->get_Client();
  181.     
  182.     cl.OpenHelper((void *) connect, Internal());
  183.     
  184.     return(cl);
  185. }
  186.  
  187. oresult OSession::OpenHelper(void *idisp, void *otheri)
  188. {
  189.     if (!idisp)
  190.     { // couldn't create session - error is on other object
  191.         SetOtherError(otheri);
  192.         return(OFAILURE);
  193.     }
  194.     IDispatch *connect = (IDispatch *) idisp;
  195.     
  196.     Cleanup(); // clear out this object
  197.     
  198.     void *tempi;
  199.     HRESULT hc = connect->QueryInterface(IID_IOraSession, &tempi);
  200.     connect->Release();
  201.     if (FAILED(hc))
  202.     { // couldn't get the interface
  203.         SetInternalError(OERROR_NOINTER);
  204.         return(OFAILURE);
  205.     }
  206.     
  207.     return(SetObjectInterface(tempi));
  208. }
  209.  
  210. oresult OSession::Close(void)
  211. {
  212.     return(Cleanup());
  213. }
  214.  
  215. // overloaded assignment operator
  216. OSession &OSession::operator=(const OSession &other)
  217. {
  218.     if (&other == this)
  219.         return(*this); // self assignment - do nothing
  220.     
  221.     // clear out our old state
  222.     if (OSUCCESS == Cleanup())
  223.     {
  224.         Copy(other); // call copy constructor
  225.     }
  226.     // if the cleanup failed (possible but unlikely) we don't do the copy
  227.     //    and as a result, we pass on the unmodified (or partly cleaned!) object
  228.     
  229.     return(*this);
  230. } 
  231.  
  232. // routine to do all cleanup for OSession
  233. oresult OSession::Cleanup(void)
  234. {
  235.     if (m_name)
  236.     {
  237.         OObjectFreeString(m_name);
  238.         m_name = 0;
  239.     }
  240.     if (m_errtext)
  241.     {
  242.         OObjectFreeString(m_errtext);
  243.         m_errtext = 0;
  244.     }   
  245.     if (m_version)
  246.     {
  247.         OObjectFreeString(m_version);
  248.         m_version = 0;
  249.     }   
  250.     
  251.     return(OOracleObject::Cleanup());
  252. }    
  253.  
  254. oresult OSession::Copy(const OSession &other)
  255. {
  256.     // don't bother copying strings
  257.     m_name = 0;
  258.     m_errtext = 0;
  259.     m_version = 0;
  260.     
  261.     return(OOracleObject::Copy(other));
  262. }
  263.  
  264. const char *OSession::GetName(void) const
  265. {
  266.     if (ActionStart() != OSUCCESS)
  267.         return(NULL);
  268.     
  269.     if (!m_name)
  270.     {
  271.         char *cp = ((_IOraSession *) Internal())->get_Name();
  272.         
  273.         /*
  274.             we want to change the state of this const session by changing
  275.             the value of m_name.  Note that we're not really changing the
  276.             session, we're only changing what we know about the session
  277.         */                                                             
  278.         OSession *sessp = (OSession *) this;  // un-const the this pointer
  279.         sessp->m_name = cp;
  280.     }
  281.     return(m_name);
  282. }
  283.  
  284. const char *OSession::GetVersion(void) const
  285. {
  286.     // the version never changes, so if we have it, it is valid
  287.     if (m_version)
  288.         return(m_version);
  289.     
  290.     if (ActionStart() != OSUCCESS)
  291.         return(NULL);
  292.     
  293.     char *cp = ((_IOraSession *) Internal())->get_OipVersionNumber();
  294.         
  295.     /*
  296.         we want to change the state of this const session by changing
  297.         the value of m_version.  Note that we're not really changing the
  298.         session, we're only changing what we know about the session
  299.     */                                                             
  300.     OSession *sessp = (OSession *) this;  // un-const the this pointer
  301.     sessp->m_version = cp;
  302.     
  303.     return(m_version);
  304. }
  305.  
  306. long OSession::ServerErrorNumber(void) const
  307. {
  308.     if (ActionStart() != OSUCCESS)
  309.         return(0);
  310.     
  311.     long errno = ((_IOraSession *) Internal())->get_LastServerErr();
  312.     
  313.     return(errno);
  314. }
  315.  
  316. const char *OSession::GetServerErrorText(void) const
  317. {
  318.     if (ActionStart() != OSUCCESS)
  319.         return("");
  320.     
  321.     /*
  322.         we want to change the state of this const session by changing
  323.         the value of m_errtext.  Note that we're not really changing the
  324.         session, we're only changing what we know about the session
  325.     */                                                             
  326.     OSession *sessp = (OSession *) this;  // un-const the this pointer
  327.  
  328.     if (m_errtext)
  329.     { // discard old error text (to make sure we always get latest error)
  330.         OObjectFreeString(m_errtext);
  331.         sessp->m_errtext = 0;
  332.     }
  333.     
  334.     char *cp = ((_IOraSession *) Internal())->get_LastServerErrText();
  335.  
  336.     sessp->m_errtext = cp;
  337.  
  338.     return(m_errtext);
  339. }
  340.  
  341. oresult OSession::ServerErrorReset(void)
  342. {
  343.     if (ActionStart() != OSUCCESS)
  344.         return(OFAILURE);
  345.     
  346.     ((_IOraSession *) Internal())->LastServerErrReset();
  347.     
  348.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);
  349. }
  350.  
  351. oresult OSession::BeginTransaction(void)
  352. {
  353.     if (ActionStart() != OSUCCESS)
  354.         return(OFAILURE);
  355.     
  356.     ((_IOraSession *) Internal())->BeginTrans();
  357.  
  358.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);
  359. }
  360.  
  361. oresult OSession::Commit(oboolean startnew)
  362. {
  363.     if (ActionStart() != OSUCCESS)
  364.         return(OFAILURE);
  365.     
  366.     ((_IOraSession *) Internal())->CommitTrans();
  367.     long errno = ErrorNumber();
  368.     
  369.     if (0 == errno && startnew)
  370.     { // the commit worked.  start new transaction if user requested it
  371.         return(BeginTransaction());
  372.     }
  373.     
  374.     return((OERROR_NONE == errno) ? OSUCCESS : OFAILURE);
  375. }
  376.  
  377. oresult OSession::Rollback(oboolean startnew)
  378. {
  379.     if (ActionStart() != OSUCCESS)
  380.         return(OFAILURE);
  381.     
  382.     ((_IOraSession *) Internal())->Rollback();
  383.     long errno = ErrorNumber();
  384.     
  385.     if (OERROR_NONE == errno && startnew)
  386.     { // the rollback worked.  start new transaction if user requested it
  387.         return(BeginTransaction());
  388.     }
  389.     
  390.     return((OERROR_NONE == errno) ? OSUCCESS : OFAILURE);
  391. }
  392.  
  393. oresult OSession::ResetTransaction(void)
  394. {
  395.     if (ActionStart() != OSUCCESS)
  396.         return(OFAILURE);
  397.     
  398.     ((_IOraSession *) Internal())->ResetTrans();
  399.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);
  400. }
  401.  
  402. // ----- OClient -----------------------------------------------
  403.  
  404. OClient::OClient(void)
  405. {
  406.     m_name = 0;
  407. }
  408.  
  409. OClient::OClient(const OClient &other)
  410. {
  411.     m_name = 0;
  412.     Copy(other);
  413. }
  414.  
  415. OClient::~OClient(void)
  416. {
  417.     Cleanup();
  418. }
  419.  
  420. // overloaded assignment operator
  421. OClient &OClient::operator=(const OClient &other)
  422. {
  423.     if (&other == this)
  424.         return(*this); // self assignment - do nothing
  425.     
  426.     // clear out our old state
  427.     if (OSUCCESS == Cleanup())
  428.     {
  429.         Copy(other); // call copy constructor
  430.     }
  431.     // if the cleanup failed (possible but unlikely) we don't do the copy
  432.     //    and as a result, we pass on the unmodified (or partly cleaned!) object
  433.     
  434.     return(*this);
  435. } 
  436.  
  437. oresult OClient::Cleanup(void)
  438. {
  439.     if (m_name)
  440.     {
  441.         OObjectFreeString(m_name);
  442.         m_name = 0;
  443.     }
  444.     
  445.     return(OOracleObject::Cleanup());
  446. }
  447.  
  448. oresult OClient::Copy(const OClient &other)
  449. {
  450.     m_name = 0; // don't bother copying string
  451.     
  452.     return(OOracleObject::Copy(other));
  453. }
  454.  
  455. oresult OClient::OpenHelper(void *obji, void *otheri)
  456. {
  457.     if (!obji)
  458.     { // couldn't create client - error is on other object
  459.         SetOtherError(otheri);
  460.         return(OFAILURE);
  461.     }
  462.     IDispatch *connect = (IDispatch *) obji;
  463.     
  464.     Cleanup(); // clear out this object
  465.     
  466.     void *tempi;
  467.     HRESULT hc = connect->QueryInterface(IID_IOraClient, &tempi);
  468.     connect->Release();
  469.     if (FAILED(hc))
  470.     { // couldn't get the interface
  471.         SetInternalError(OERROR_NOINTER);
  472.         return(OFAILURE);
  473.     }
  474.     
  475.     return(SetObjectInterface(tempi));
  476. }
  477.  
  478. oresult OClient::Close(void)
  479. {
  480.     return(Cleanup());
  481. }
  482.  
  483. const char *OClient::GetName(void) const
  484. {
  485.     if (ActionStart() != OSUCCESS)
  486.         return(NULL);
  487.     
  488.     if (!m_name)
  489.     {
  490.         char *cp = ((_IOraClient *) Internal())->get_Name();
  491.         OClient *clp = (OClient *) this;  // un-const this
  492.         clp->m_name = cp;
  493.     }
  494.     
  495.     return(m_name);
  496. }
  497.  
  498. OSessionCollection OClient::GetSessions(void) const
  499. {
  500.     OSessionCollection cset;
  501.     
  502.     if (ActionGetStart(&cset) != OSUCCESS)
  503.         return(cset); // returning unopened object - indicates error
  504.     
  505.     IDispatch *connect = ((_IOraClient *) (Internal()))->get_Sessions();
  506.     
  507.     cset.OpenHelper((void *) connect, Internal());
  508.     
  509.     return(cset);
  510. }
  511.  
  512. // ----- OConnection -----------------------------------------------
  513.  
  514. OConnection::OConnection(void)
  515. {
  516.     // we don't have strings yet
  517.     m_dbname = 0;
  518.     m_dbconnect = 0;
  519. }
  520.  
  521. OConnection::OConnection(const OConnection &other)
  522. {
  523.     m_dbname = 0;
  524.     m_dbconnect = 0;
  525.     Copy(other);
  526. }
  527.  
  528. OConnection::~OConnection(void)
  529. {
  530.     Cleanup();
  531. }
  532.  
  533. // overloaded assignment operator
  534. OConnection &OConnection::operator=(const OConnection &other)
  535. {
  536.     if (&other == this)
  537.         return(*this); // self assignment - do nothing
  538.     
  539.     // clear out our old state
  540.     if (OSUCCESS == Cleanup())
  541.     {
  542.         Copy(other); // call copy constructor
  543.     }
  544.     // if the cleanup failed (possible but unlikely) we don't do the copy
  545.     //    and as a result, we pass on the unmodified (or partly cleaned!) object
  546.     
  547.     return(*this);
  548. } 
  549.  
  550. oresult OConnection::Close(void)
  551. {
  552.     return(Cleanup());
  553. }
  554.  
  555. oresult OConnection::Cleanup(void)
  556. {
  557.     if (m_dbname)
  558.     {
  559.         OObjectFreeString(m_dbname);
  560.         m_dbname = 0;
  561.     }
  562.     if (m_dbconnect)
  563.     {
  564.         OObjectFreeString(m_dbconnect);
  565.         m_dbconnect = 0;
  566.     }
  567.     
  568.     return(OOracleObject::Cleanup());
  569. }
  570.  
  571. oresult OConnection::Copy(const OConnection &other)
  572. {
  573.     m_dbname = 0;
  574.     m_dbconnect = 0;
  575.     
  576.     return(OOracleObject::Copy(other));
  577. }
  578.  
  579. oresult OConnection::OpenHelper(void *idisp, void *otheri)
  580. { 
  581.     Cleanup();
  582.         
  583.     if (!idisp)
  584.     {  // couldn't create connection.  error is on parent object
  585.         SetOtherError(otheri);
  586.         return(OFAILURE);
  587.     }
  588.     IDispatch *connect = (IDispatch *) idisp;  // cast, for convenience
  589.     
  590.     void *tempi;
  591.     HRESULT hc = connect->QueryInterface(IID_IOraConnection, &tempi);
  592.     connect->Release();
  593.     if (FAILED(hc))
  594.     { // couldn't get the interface
  595.         SetInternalError(OERROR_NOINTER);
  596.         return(OFAILURE);
  597.     }
  598.     
  599.     return(SetObjectInterface(tempi));
  600. }
  601.  
  602. OSession OConnection::GetSession(void) const
  603. {
  604.     OSession sess;
  605.     
  606.     if (ActionGetStart(&sess) != OSUCCESS)
  607.         return(sess); // returning unopened object - indicates error
  608.     
  609.     IDispatch *connect = ((_IOraConnection *) (Internal()))->get_Session();
  610.     sess.OpenHelper((void *) connect, Internal());
  611.     
  612.     return(sess);
  613. }
  614.  
  615. const char *OConnection::GetConnectString(void) const
  616. {
  617.     if (ActionStart() != OSUCCESS)
  618.         return(NULL);
  619.     
  620.     if (!m_dbconnect)
  621.     {
  622.         char *cp = ((_IOraConnection *) Internal())->get_Connect();
  623.         OConnection *connp = (OConnection *) this;  // un-const this
  624.         connp->m_dbconnect = cp;
  625.     }
  626.     return(m_dbconnect);
  627. }
  628.  
  629. const char *OConnection::GetDatabaseName(void) const
  630. {
  631.     if (ActionStart() != OSUCCESS)
  632.         return(NULL);
  633.     
  634.     if (!m_dbname)
  635.     {
  636.         char *cp = ((_IOraConnection *) Internal())->get_DatabaseName();
  637.         OConnection *connp = (OConnection *) this;  // un-const this
  638.         connp->m_dbname = cp;
  639.     }
  640.     return(m_dbname);
  641. }
  642.  
  643.