home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / object10 / odbase.cpp < prev    next >
C/C++ Source or Header  |  1995-04-04  |  11KB  |  443 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 ODatabase class
  13.                            
  14.     CREATED    ********   11/22/94
  15.  
  16. */
  17.  
  18. #include "windows.h"
  19. #include <ole2.h>
  20. #include <olenls.h>       
  21. #include <dispatch.h>  
  22.  
  23. #ifndef ORACL_ORACLE
  24. #include "oracl.h"
  25. #endif
  26.  
  27. #ifndef _OracleInProcServer_H_
  28. #include <oratlb.h>
  29. #endif
  30.  
  31. #ifndef ORAOBJI_ORACLE
  32. #include "oraobji.h"
  33. #endif
  34.  
  35. static const IID IID_IOraDatabase =
  36. {0x5cdfcf20, 0xffd7, 0x101a, { 0xad, 0xf2, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  37.  
  38. // ----- ODatabase -----------------------------------------------
  39.  
  40. ODatabase::ODatabase(void)
  41. {
  42.     m_dbname = 0;
  43.     m_dbconnect = 0;
  44.     m_errtext = 0;
  45.     m_numrows = -1;
  46. }
  47.  
  48. ODatabase::~ODatabase(void)
  49. {
  50.     Cleanup();
  51. }
  52.  
  53. ODatabase::ODatabase(const ODatabase &other)
  54. {
  55.     m_dbname = 0;
  56.     m_dbconnect = 0;
  57.     m_errtext = 0;
  58.     m_numrows = -1;
  59.     Copy(other);  // call our internal copier
  60. }
  61.  
  62. ODatabase::ODatabase(const OSession &dbsess, const char *dbname, const char *username, const char *pwd, long options)
  63. {
  64.     m_dbname = 0;
  65.     m_dbconnect = 0;
  66.     m_errtext = 0;
  67.     m_numrows = -1;
  68.     Open(dbsess, dbname, username, pwd, options);
  69. }
  70.  
  71. ODatabase::ODatabase(const char *dbname, const char *username, const char *pwd, long options)
  72. {
  73.     m_dbname = 0;
  74.     m_dbconnect = 0;
  75.     m_errtext = 0;
  76.     m_numrows = -1;
  77.     Open(dbname, username, pwd, options);
  78. }
  79.  
  80. oresult ODatabase::Close(void)
  81. {
  82.     return(Cleanup());
  83. }
  84.  
  85. oresult ODatabase::Cleanup(void)
  86. { 
  87.     if (m_dbname)
  88.     {
  89.         OObjectFreeString(m_dbname);
  90.         m_dbname = 0;
  91.     }
  92.     if (m_dbconnect)
  93.     {
  94.         OObjectFreeString(m_dbconnect);
  95.         m_dbconnect = 0;
  96.     }
  97.     if (m_errtext)
  98.     {
  99.         OObjectFreeString(m_errtext);
  100.         m_errtext = 0;
  101.     }
  102.     m_numrows = -1;
  103.     
  104.     return(OOracleObject::Cleanup());
  105. }
  106.  
  107. oresult ODatabase::Open(const char *dbname, const char *username, const char *pwd, long options)
  108. {
  109.     // open a session for this database connection
  110.     OSession tempSess;
  111.     oresult ores;
  112.     
  113.     ores = tempSess.Open();
  114.     if (ores == OSUCCESS)
  115.         ores = Open(tempSess, dbname, username, pwd, options);
  116.     else
  117.     { // couldn't open the temporary session.  Some OLE problem
  118.         SetInternalError(OERROR_SYSTEM);
  119.     }
  120.    
  121.     /*
  122.         Note that although the OSession session variable will go away, the OLE session object
  123.         (in the oip) will not, because the database has a reference to it.  The OLE session object
  124.         will go away when the database does.
  125.     */
  126.     
  127.     return(ores);
  128. }
  129.  
  130. oresult ODatabase::Open(const OSession &sess, const char *dbname, const char *username, const char *pwd, long options)
  131. {
  132.     if (!sess.IsOpen())
  133.     { // no valid session
  134.         SetInternalError(OERROR_INVPARENT); 
  135.         return(OFAILURE);
  136.     }
  137.     if (!dbname || !username)
  138.     {
  139.         SetInternalError(OERROR_BADARG);
  140.         return(OFAILURE);
  141.     }
  142.     
  143.     // get the username and password into the right form 
  144.     // DBCS problem - assumption of single-byte null
  145.     BSTR tp;
  146.     // password and username can't be more than 30 bytes apiece so...
  147.     const char *cp, *cp2;
  148.     cp = username;
  149.     while (*cp)
  150.         cp++; // scan to end of username
  151.     if (pwd)
  152.     {
  153.         cp2 = pwd;
  154.         while (*cp2)
  155.             cp2++;
  156.     }
  157.     //if (strlen(username) > 30 || (pwd && strlen(pwd) > 30))
  158.     if ((cp-username) > 30 || (pwd && (cp2-pwd)) > 30)
  159.     { 
  160.         SetInternalError(OERROR_BADARG);
  161.         return(OFAILURE);
  162.     }
  163.     
  164.     char temps[80];
  165.     if (pwd)
  166.     { // the username and password are separate
  167.         // don't use strcpy, etc so that we don't drag in C runtime
  168.         tp = temps;
  169.         cp = username;
  170.         while (*cp)
  171.             *tp++ = *cp++;
  172.         *tp++ = '/';
  173.         cp = pwd;
  174.         while (*cp)
  175.             *tp++ = *cp++;
  176.         *tp = '\0';  // null terminate;
  177.         tp = OObjectAllocString(temps);
  178.     }
  179.     else
  180.     {
  181.         // the username must contain a '/'
  182.         cp = username;
  183.         while (*cp)
  184.         {
  185.             if (*cp == '/')
  186.                 break;
  187.             cp++;
  188.         }
  189.         if (*cp != '/')
  190.         { // no slash
  191.             SetInternalError(OERROR_BADARG);
  192.             return(OFAILURE);
  193.         }
  194.         tp = OObjectAllocString(username); // contains username/password
  195.     }
  196.     
  197.     // get database name into BSTR
  198.     BSTR tempdbname = OObjectAllocString(dbname);
  199.     
  200.     if (!tp || !tempdbname)
  201.     {
  202.         SetInternalError(OERROR_MEMORY);
  203.         if (tp)
  204.             OObjectFreeString(tp);
  205.         if (tempdbname)
  206.             OObjectFreeString(tempdbname);
  207.         return(OFAILURE);
  208.     }
  209.     
  210.     // now do the real work
  211.     sess.ErrorReset(); // reset error state of session
  212.     
  213.     IDispatch *dbi = ((_IOraSession *)(sess.Internal()))->get_OpenDatabase(tempdbname, tp, options); 
  214.     // free the BSTRs
  215.     OObjectFreeString(tp);
  216.     OObjectFreeString(tempdbname);
  217.     
  218.     return(OpenHelper(dbi, sess.Internal()));
  219. }
  220.  
  221. oresult ODatabase::OpenHelper(void *idisp, void *otheri)
  222. {
  223.     if (!idisp)
  224.     { // couldn't create database
  225.         // the actual error is stored in the session object
  226.         SetOtherError(otheri);
  227.         return(OFAILURE);
  228.     }
  229.     
  230.     Cleanup(); // drop old state
  231.     
  232.     // get database interface
  233.     void *tempi;
  234.     IDispatch *dbi = (IDispatch *) idisp;
  235.     HRESULT hc = dbi->QueryInterface(IID_IOraDatabase, &tempi);
  236.     dbi->Release();
  237.     
  238.     if (FAILED(hc))
  239.     {
  240.         SetInternalError(OERROR_NOINTER);
  241.         return(OFAILURE);
  242.     }
  243.     
  244.     return(SetObjectInterface(tempi));  // this sets error state
  245. }
  246.  
  247. // overloaded assignment operator
  248. ODatabase &ODatabase::operator=(const ODatabase &other)
  249. {
  250.     if (&other == this)
  251.         return(*this); // self assignment - do nothing
  252.     
  253.     // clear out our old state
  254.     if (OSUCCESS == Cleanup())
  255.     {
  256.         Copy(other); // call copy constructor
  257.     }
  258.     // if the cleanup failed (possible but unlikely) we don't do the copy
  259.     //    and as a result, we pass on the unmodified (or partly cleaned!) object
  260.     
  261.     return(*this);
  262. } 
  263.  
  264. oresult ODatabase::ExecuteSQL(const char *sqls) const
  265. {   
  266.     long    numrows;
  267.     
  268.     if (ActionStart() != OSUCCESS)
  269.         return(OFAILURE);
  270.     
  271.     if (!sqls)
  272.     {
  273.         SetInternalError(OERROR_BADARG);
  274.         return(OFAILURE);
  275.     }
  276.     
  277.     BSTR tempsql = OObjectAllocString(sqls);
  278.     numrows = (((_IOraDatabase *) Internal())->ExecuteSQL((BSTR) sqls));
  279.     // un-const this
  280.     ODatabase *dbp = (ODatabase *) this;
  281.     dbp->m_numrows = numrows;
  282.     OObjectFreeString(tempsql);
  283.     
  284.     return((0 == ErrorNumber()) ? OSUCCESS : OFAILURE);
  285. }
  286.  
  287. long ODatabase::GetRowsProcessed(void) const
  288. {
  289.     return m_numrows;
  290. }
  291.  
  292. long ODatabase::GetOptions(void) const
  293. {
  294.     if (ActionStart() != OSUCCESS)
  295.         return(ODATABASE_DEFAULT);
  296.     
  297.     return(((_IOraDatabase *) Internal())->get_Options());
  298. }
  299.  
  300. oresult ODatabase::Copy(const ODatabase &other)
  301. {
  302.     // don't bother to copy strings
  303.     m_dbname = 0;
  304.     m_dbconnect = 0;
  305.     return(OOracleObject::Copy(other));
  306. }
  307.  
  308. const char *ODatabase::GetName(void) const
  309. {
  310.     if (ActionStart() != OSUCCESS)
  311.         return(NULL);
  312.     
  313.     if (!m_dbname)
  314.     {
  315.         char *cp = ((_IOraDatabase *) Internal())->get_DatabaseName();
  316.         /*
  317.             we want to change the state of this const database by changing
  318.             the value of m_dbname.  Note that we're not really changing the
  319.             database, we're only changing what we know about the database
  320.         */
  321.         ODatabase *dbp = (ODatabase *) this;  // un-const this
  322.         dbp->m_dbname = cp;
  323.     }
  324.     
  325.     return(m_dbname);                                                             
  326. }
  327.  
  328. const char *ODatabase::GetConnectString(void) const
  329. {
  330.     if (ActionStart() != OSUCCESS)
  331.         return(NULL);
  332.     
  333.     if (!m_dbconnect)
  334.     {
  335.         char *cp = ((_IOraDatabase *) Internal())->get_Connect();
  336.         /*
  337.             we want to change the state of this const database by changing
  338.             the value of m_dbname.  Note that we're not really changing the
  339.             database, we're only changing what we know about the database
  340.         */
  341.         ODatabase *dbp = (ODatabase *) this;  // un-const this
  342.         dbp->m_dbconnect = cp;
  343.     }
  344.     
  345.     return(m_dbconnect);                                                             
  346. }    
  347.  
  348. OSession ODatabase::GetSession(void) const
  349. {
  350.     OSession dbsess;
  351.  
  352.     if (ActionGetStart(&dbsess) != OSUCCESS)
  353.         return(dbsess); // returning unopened object - indicates error
  354.     
  355.     IDispatch *connect = ((_IOraDatabase *) (Internal()))->get_Session();
  356.     dbsess.OpenHelper((void *) connect, Internal());
  357.     
  358.     return(dbsess);
  359. }
  360.  
  361. OConnection ODatabase::GetConnection(void) const
  362. {
  363.     OConnection dbconn;
  364.     
  365.     if (ActionGetStart(&dbconn) != OSUCCESS)
  366.         return(dbconn); // returning unopened object - indicates error
  367.     
  368.     IDispatch *connect = ((_IOraDatabase *) (Internal()))->get_Connection();
  369.     
  370.     dbconn.OpenHelper((void *) connect, Internal());
  371.     return(dbconn);
  372. }
  373.  
  374. OParameterCollection ODatabase::GetParameters(void) const
  375. {
  376.     OParameterCollection pcoll;
  377.     
  378.     if (ActionGetStart(&pcoll) != OSUCCESS)
  379.         return(pcoll); // returning unopened object - indicates error
  380.     
  381.     IDispatch *connect = ((_IOraDatabase *) (Internal()))->get_Parameters();
  382.     
  383.     pcoll.OpenHelper((void *) connect, Internal());
  384.     return(pcoll);
  385. }
  386.  
  387. long ODatabase::ServerErrorNumber(void) const
  388. {
  389.     if (ActionStart() != OSUCCESS)
  390.         return(0);
  391.     
  392.     long errno = ((_IOraDatabase *) Internal())->get_LastServerErr();
  393.     
  394.     return(errno);
  395. }
  396.  
  397. int ODatabase::ServerErrorSQLPos(void) const
  398. {
  399.     if (ActionStart() != OSUCCESS)
  400.         return(-1);
  401.     
  402.     int errpos = ((_IOraDatabase *) Internal())->get_LastServerErrPos();
  403.     
  404.     return(errpos);
  405. }
  406.  
  407. const char *ODatabase::GetServerErrorText(void) const
  408. {
  409.     if (ActionStart() != OSUCCESS)
  410.         return(NULL);
  411.     
  412.     /*
  413.         we want to change the state of this const database by changing
  414.         the value of m_errtext.  Note that we're not really changing the
  415.         database, we're only changing what we know about the database
  416.     */                                                             
  417.     ODatabase *dbp = (ODatabase *) this;  // un-const the this pointer
  418.  
  419.     if (m_errtext)
  420.     { // discard old error text (to make sure we always get latest error)
  421.         OObjectFreeString(m_errtext);
  422.         dbp->m_errtext = 0;
  423.     }
  424.     
  425.     char *cp = ((_IOraDatabase *) Internal())->get_LastServerErrText();
  426.  
  427.     dbp->m_errtext = cp;
  428.  
  429.     return(m_errtext);
  430. }
  431.  
  432. oresult ODatabase::ServerErrorReset(void)
  433. {
  434.     if (ActionStart() != OSUCCESS)
  435.         return(OFAILURE);
  436.     
  437.     ((_IOraDatabase *) Internal())->LastServerErrReset();
  438.     
  439.     return((0 == ErrorNumber()) ? OSUCCESS : OFAILURE);
  440. }
  441.  
  442.  
  443.