home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / object10 / ofield.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-23  |  14.5 KB  |  626 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 OField class
  13.                            
  14.     CREATED    ********   11/22/94
  15.     RWOOLARD    MODIFIED    03/20/95
  16.                 bug#    262209  SetValue(NULL) causes GPF (in OValue)
  17.                         263418    GetFieldValue does not work with dates (in ODynaset)
  18.                         271184    SetValue succeeds when not in edit mode
  19. */
  20.  
  21. #include "windows.h"
  22. #include <ole2.h>
  23. #include <olenls.h>       
  24. #include <dispatch.h>  
  25.  
  26. #ifndef ORACL_ORACLE
  27. #include "oracl.h"
  28. #endif
  29.  
  30. #ifndef ORAOBJI_ORACLE
  31. #include "oraobji.h"
  32. #endif
  33.  
  34. #ifndef _OracleInProcServer_H_
  35. #include <oratlb.h>
  36. #endif
  37.  
  38. /*
  39.     Note that the C++ implementation of the field object does not use the _IOraField interface.
  40.     It simply uses the _IOraDynaset
  41. */
  42.  
  43. static const IID IID_IOraDynaset =
  44. {0xf0051a80, 0x00b3, 0x101b, { 0xad, 0xf2, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  45.  
  46. // ----- OField -----------------------------------------------
  47.  
  48. OField::OField(void)
  49. {
  50.     m_name = 0; // don't know name yet
  51.     m_data = 0; 
  52.     m_index = 0;
  53. } 
  54.  
  55. OField::OField(const OField &other)
  56. {
  57.     m_name = 0;
  58.     m_data = 0;
  59.     m_index = 0;
  60.     Copy(other);
  61. }
  62.  
  63. OField::~OField(void)
  64. {
  65.     Cleanup();
  66. }
  67.  
  68. oresult OField::Copy(const OField &other)
  69. {
  70.     m_name = 0;
  71.     m_data = 0;
  72.     
  73.     m_index = other.m_index;
  74.     
  75.     return(OOracleObject::Copy(other));
  76. }
  77.  
  78. oresult OField::Close(void)
  79. {
  80.     return(Cleanup());
  81. }
  82.  
  83. oresult OField::Cleanup(void)
  84. { 
  85.     if (m_name)
  86.     {
  87.         OObjectFreeString(m_name);
  88.         m_name = 0;
  89.     }
  90.     
  91.     if (m_data)
  92.     {
  93.         OObjectFreeString(m_data);
  94.         m_data = 0;
  95.     }
  96.     
  97.     return(OOracleObject::Cleanup());   
  98. }
  99.  
  100. // overloaded assignment operator
  101. OField &OField::operator=(const OField &other)
  102. {
  103.     if (&other == this)
  104.         return(*this); // self assignment - do nothing
  105.     
  106.     // clear out our old state
  107.     if (OSUCCESS == Cleanup())
  108.     {
  109.         Copy(other); // call copy constructor
  110.     }
  111.     // if the cleanup failed (possible but unlikely) we don't do the copy
  112.     //    and as a result, we pass on the unmodified (or partly cleaned!) object
  113.     
  114.     return(*this);
  115. } 
  116.  
  117. ODynaset OField::GetDynaset(void) const
  118. {
  119.     ODynaset odyn;
  120.     
  121.     if (ActionGetStart(&odyn) != OSUCCESS)
  122.         return(odyn); // returning unopened object - indicates error
  123.     
  124.     // we just reopen the dynaset
  125.     ((IDispatch *) Internal())->AddRef(); // since we're adding another reference to it
  126.     
  127.     odyn.OpenHelper(Internal(), Internal());
  128.     
  129.     return(odyn);
  130. }
  131.  
  132. short OField::GetServerType(void) const
  133. {
  134.     if (ActionStart() != OSUCCESS)
  135.         return(0); // indicates error
  136.     
  137.     return (short) (((_IOraDynaset *) (Internal()))->_getFieldServerType(m_index));
  138. }
  139.  
  140.  
  141. short OField::GetPrecision(void) const
  142. {
  143.     if (ActionStart() != OSUCCESS)
  144.         return(0);
  145.     
  146.     return (short) (((_IOraDynaset *) (Internal()))->_getFieldPrecision(m_index));
  147. }
  148.  
  149.  
  150. short OField::GetScale(void) const
  151. {
  152.     if (ActionStart() != OSUCCESS)
  153.         return(0);
  154.     
  155.     return (short) (((_IOraDynaset *) (Internal()))->_getFieldScale(m_index));
  156. }
  157.  
  158. oboolean OField::IsTruncated(void) const
  159. {
  160.     if (ActionStart() != OSUCCESS)
  161.         return(FALSE);
  162.     
  163.     int ftype = GetServerType();
  164.     if (ftype != OTYPE_LONG && ftype != OTYPE_LONGRAW)
  165.     { // this field isn't a long
  166.         SetInternalError(OERROR_BADARG);
  167.         return(FALSE);
  168.     }
  169.     
  170.     int istrunc = ((_IOraDynaset *) (Internal()))->_isFieldTruncated(m_index);
  171.     return(istrunc ? TRUE : FALSE);  
  172. }
  173.  
  174. oboolean OField::IsNullOK(void) const
  175. {
  176.     if (ActionStart() != OSUCCESS)
  177.         return(FALSE);
  178.     
  179.     int isok = ((_IOraDynaset *) (Internal()))->_isFieldNullOK(m_index);
  180.     return(isok ? TRUE : FALSE);
  181. }
  182.  
  183. long OField::GetSize(void) const
  184. {
  185.     if (ActionStart() != OSUCCESS)
  186.         return(0);
  187.     
  188.     return(((_IOraDynaset *) Internal())->_getFieldSize(m_index));
  189. }
  190.  
  191. long OField::GetServerSize(void) const
  192. {
  193.     if (ActionStart() != OSUCCESS)
  194.         return(0);
  195.     
  196.     return(((_IOraDynaset *) Internal())->_getFieldDataSize(m_index));
  197. }
  198.  
  199. const char *OField::GetName(void) const
  200. {
  201.     if (ActionStart() != OSUCCESS)
  202.         return(NULL);
  203.     
  204.     if (!m_name)
  205.     {
  206.         char *cp = ((_IOraDynaset *) Internal())->_getFieldName(m_index);
  207.         /*
  208.             we want to change the state of this const field by changing
  209.             the value of m_name.  Note that we're not really changing the
  210.             field, we're only changing what we know about the field
  211.         */
  212.         OField *fp = (OField *) this;
  213.         fp->m_name = cp;
  214.     }
  215.     
  216.     return(m_name);
  217. }
  218.  
  219. oresult OField::GetValue(OValue *val) const
  220. {
  221.     if (! val)
  222.     {
  223.         SetInternalError(OERROR_BADARG);
  224.         return(OFAILURE);
  225.     }
  226.         
  227.     if (ActionStart() != OSUCCESS)
  228.     {
  229.         val->Clear(); // set value to NULL
  230.         return(OFAILURE); // error
  231.     }
  232.     
  233.     OOLEvar *vres = (OOLEvar *) val->Internal();
  234.     
  235.     ((_IOraDynaset *) Internal())->_getFieldValue(vres->GetVariant(), m_index);
  236.     vres->HaveSetVariant();
  237.     
  238.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  239. } 
  240.  
  241. oresult OField::GetValue(int *val) const
  242. {
  243.     if (! val)
  244.     {
  245.         SetInternalError(OERROR_BADARG);
  246.         return(OFAILURE);
  247.     }
  248.         
  249.     *val = (int) (*this);
  250.     return ((ErrorNumber() == OERROR_NONE) ? OSUCCESS : OFAILURE);
  251. }
  252.  
  253. oresult OField::GetValue(long *val) const
  254. {
  255.     if (! val)
  256.     {
  257.         SetInternalError(OERROR_BADARG);
  258.         return(OFAILURE);
  259.     }
  260.         
  261.     *val = (long) (*this);
  262.     return ((ErrorNumber() == OERROR_NONE) ? OSUCCESS : OFAILURE);
  263. }
  264.  
  265. oresult OField::GetValue(double *val) const
  266. {
  267.     if (! val)
  268.     {
  269.         SetInternalError(OERROR_BADARG);
  270.         return(OFAILURE);
  271.     }
  272.         
  273.     *val = (double) (*this);
  274.     return ((ErrorNumber() == OERROR_NONE) ? OSUCCESS : OFAILURE);
  275. }
  276.  
  277. oresult OField::GetValue(void __huge *longval, long len, long *readlen) const
  278. { // get a long value
  279.     if (! longval || ! readlen)
  280.     {
  281.         SetInternalError(OERROR_BADARG);
  282.         return(OFAILURE);
  283.     }
  284.         
  285.     // this is going to be heavyweight - so just call dynaset's code
  286.     ODynaset tempdyn = GetDynaset();
  287.     if (!tempdyn.IsOpen())
  288.         return(OFAILURE);  // error set in GetDynaset
  289.     
  290.     return(tempdyn.GetFieldValue(m_index, longval, len, readlen));    
  291. }
  292.  
  293. oresult OField::GetValue(const char **val) const
  294. {
  295.     if (! val)
  296.     {
  297.         SetInternalError(OERROR_BADARG);
  298.         return(OFAILURE);
  299.     }
  300.         
  301.     *val = (const char *) (*this);
  302.     return ((ErrorNumber() == OERROR_NONE) ? OSUCCESS : OFAILURE);
  303. }
  304.  
  305. oresult OField::SetValue(const OValue &val)
  306. {
  307.     if (ActionStart() != OSUCCESS)
  308.         return(OFAILURE);
  309.     
  310.     VARIANT *vres = ((OOLEvar *) (val.Internal()))->GetVariant();
  311.     
  312.     // set field value 
  313. //BUG #271184
  314.     HRESULT hr = ((_IOraDynaset *) Internal())->_updateFieldValue(vres, m_index);
  315.  
  316.     if (OERROR_NONE != ErrorNumber())
  317.         return OFAILURE;
  318.     else if (FAILED(hr))
  319.     {
  320.         SetInternalError(OERROR_INVRECORD);
  321.         return OFAILURE;
  322.     }
  323.     return OSUCCESS;    
  324. }      
  325.  
  326. oresult OField::SetValue(int val)
  327. {
  328.     if (ActionStart() != OSUCCESS)
  329.         return(OFAILURE);
  330.     
  331.     // set up VARIANT
  332.     OOLEvar vres;
  333.     vres.SetValue(val);
  334.     
  335.     // set field value
  336.     HRESULT hr = ((_IOraDynaset *) Internal())->_updateFieldValue(vres.GetVariant(), m_index);
  337.  
  338.     if (OERROR_NONE != ErrorNumber())
  339.         return OFAILURE;
  340.     else if (FAILED(hr))
  341.     {
  342.         SetInternalError(OERROR_INVRECORD);
  343.         return OFAILURE;
  344.     }
  345.     return OSUCCESS;
  346. }
  347.  
  348. oresult OField::SetValue(long val)
  349. {
  350.     if (ActionStart() != OSUCCESS)
  351.         return(OFAILURE);
  352.     
  353.     // set up VARIANT
  354.     OOLEvar vres;
  355.     vres.SetValue(val);
  356.     
  357.     // set field value
  358.     HRESULT hr = ((_IOraDynaset *) Internal())->_updateFieldValue(vres.GetVariant(), m_index);
  359.  
  360.     if (OERROR_NONE != ErrorNumber())
  361.         return OFAILURE;
  362.     else if (FAILED(hr))
  363.     {
  364.         SetInternalError(OERROR_INVRECORD);
  365.         return OFAILURE;
  366.     }
  367.     return OSUCCESS;    
  368. }
  369.  
  370. oresult OField::SetValue(double val)
  371. {
  372.     if (ActionStart() != OSUCCESS)
  373.         return(OFAILURE);
  374.     
  375.     // set up VARIANT
  376.     OOLEvar vres;
  377.     vres.SetValue(val);
  378.     
  379.     // set field value
  380.     HRESULT hr = ((_IOraDynaset *) Internal())->_updateFieldValue(vres.GetVariant(), m_index);
  381.  
  382.     if (OERROR_NONE != ErrorNumber())
  383.         return OFAILURE;
  384.     else if (FAILED(hr))
  385.     {
  386.         SetInternalError(OERROR_INVRECORD);
  387.         return OFAILURE;
  388.     }
  389.     return OSUCCESS;    
  390. }
  391.  
  392. oresult OField::SetValue(const char *val)
  393. {
  394.     if (ActionStart() != OSUCCESS)
  395.         return(OFAILURE);
  396.     
  397.     // set up VARIANT
  398.     OOLEvar vres;
  399.     vres.SetValue(val);
  400.     
  401.     // set field value
  402.     HRESULT hr = ((_IOraDynaset *) Internal())->_updateFieldValue(vres.GetVariant(), m_index);
  403.  
  404.     if (OERROR_NONE != ErrorNumber())
  405.         return OFAILURE;
  406.     else if (FAILED(hr))
  407.     {
  408.         SetInternalError(OERROR_INVRECORD);
  409.         return OFAILURE;
  410.     }
  411.     return OSUCCESS;    
  412. }
  413.  
  414. oresult OField::SetValue(const void __huge *longval, long len)
  415. { // set a long value
  416.     // this is going to be heavyweight - so just call dynaset's code
  417.     ODynaset tempdyn = GetDynaset();
  418.     if (!tempdyn.IsOpen())
  419.         return(OFAILURE);  // error set in GetDynaset
  420.     
  421.     return(tempdyn.SetFieldValue(m_index, longval, len));    
  422. }
  423.  
  424. oresult OField::AppendChunk(const void *chunkp, unsigned short numbytes)
  425. {
  426.     if (numbytes < 1)
  427.     {
  428.         SetInternalError (OERROR_BADARG);
  429.         return(OFAILURE);
  430.     }
  431.  
  432.     int fieldtype = GetServerType ();
  433.     if (fieldtype != OTYPE_LONG && fieldtype != OTYPE_LONGRAW)
  434.     {
  435.         SetInternalError (OERROR_BADTYPE);
  436.         return(OFAILURE);
  437.     }
  438.     
  439.     if (ActionStart() != OSUCCESS)
  440.         return(OFAILURE);
  441.     
  442.     // create a tempbuffer with the data in it
  443.     BSTR tempb = OObjectAllocStringLen((char *) chunkp, numbytes);
  444.     if (!tempb)
  445.     {
  446.         SetInternalError(OERROR_MEMORY);
  447.         return(OFAILURE);
  448.     }
  449.     
  450.     HRESULT hc = ((_IOraDynaset *) Internal())->_appendChunk(tempb, m_index);
  451.     if (FAILED(hc))
  452.     { // couldn't get the interface
  453.         SetInternalError(OERROR_NOINTER);
  454.     }
  455.     
  456.     OObjectFreeString(tempb);
  457.     
  458.     return((ErrorNumber() == OERROR_NONE) ? OSUCCESS : OFAILURE);
  459. }
  460.  
  461. oresult OField::GetChunk(const char **chunkp, long offset, unsigned short numbytes) const
  462. {
  463.     *chunkp = NULL;  // in case of error
  464.  
  465.     if (offset < 1 || numbytes < 1)
  466.     {
  467.         SetInternalError (OERROR_BADARG);
  468.         return(OFAILURE);
  469.     }
  470.     
  471.     int fieldtype = GetServerType ();
  472.     if (fieldtype != OTYPE_LONG && fieldtype != OTYPE_LONGRAW)
  473.     {
  474.         SetInternalError (OERROR_BADTYPE);
  475.         return(OFAILURE);
  476.     }
  477.     
  478.     if (ActionStart() != OSUCCESS)
  479.         return(OFAILURE);
  480.     
  481.     // we need a non-const version of "this" to manipulate m_data
  482.     OField *this2p = (OField *) this;
  483.     
  484.     if (m_data)
  485.     {
  486.         OObjectFreeString(this2p->m_data);
  487.         this2p->m_data = 0;
  488.     }
  489.     
  490.     HRESULT hc = ((_IOraDynaset *) Internal())->_getFieldChunk(&(this2p->m_data), m_index, offset,numbytes);
  491.     if (FAILED(hc))
  492.     { // couldn't get the interface
  493.         SetInternalError(OERROR_NOINTER);
  494.     }
  495.  
  496.     if (ErrorNumber() != OERROR_NONE)
  497.     {
  498.         // free the memory, if any
  499.         OObjectFreeString(this2p->m_data);
  500.         this2p->m_data = 0;
  501.         
  502.         return(OFAILURE);
  503.     }
  504.     else
  505.     { // success
  506.         *chunkp = m_data;
  507.         return(OSUCCESS);
  508.     }
  509. }                                           
  510.  
  511. oresult OField::OpenHelper(void *obji, void *otheri)
  512. {    
  513.     Cleanup();
  514.     if (!obji)
  515.     { // some error
  516.         SetOtherError(otheri);
  517.         return(OFAILURE);
  518.     }
  519.     
  520.     // obji is the field interface pointer.  We also want the dynaset interface and an index
  521.     
  522.     // get the dynaset & index
  523.     
  524.     IDispatch *idisp = ((_IOraField *) obji)->getDynaset();
  525.     
  526.     void *tempi;
  527.     HRESULT hc = idisp->QueryInterface(IID_IOraDynaset, &tempi);
  528.     idisp->Release();
  529.     if (FAILED(hc))
  530.     { // couldn't get the interface
  531.         ((IDispatch *) obji)->Release(); // we don't want field interface anymore
  532.         SetInternalError(OERROR_NOINTER);
  533.         return(OFAILURE);
  534.     }
  535.     
  536.     if (SetObjectInterface(tempi) != OSUCCESS)
  537.     {
  538.         ((IDispatch *) obji)->Release(); // we don't want field interface anymore
  539.         SetInternalError(OERROR_NOINTER);
  540.         return(OFAILURE);
  541.     }
  542.     
  543.     // now we have the dynaset - get the field's index
  544.     // we aren't going to keep the name
  545.     char *fname = ((_IOraField *) obji)->get_Name();
  546.     m_index = (short) ((_IOraDynaset *) Internal())->_getFieldIndex(fname);
  547.     OObjectFreeString(fname);
  548.     
  549.     // we're done
  550.     ((IDispatch *) obji)->Release(); // we don't want field interface anymore
  551.         
  552.     return(OSUCCESS);
  553. }
  554.  
  555. OField::operator int() const
  556. {
  557.     if (ActionStart() != OSUCCESS)
  558.         return(0);
  559.     
  560.     int val;
  561.     OOLEvar vres;
  562.     ((_IOraDynaset *) Internal())->_getFieldValue(vres.GetVariant(), m_index);
  563.     vres.HaveSetVariant();
  564.     
  565.     vres.GetValue(&val);
  566.     return(val);
  567. }
  568.  
  569. OField::operator long() const
  570. {
  571.     if (ActionStart() != OSUCCESS)
  572.         return(0);
  573.     
  574.     long val;
  575.     OOLEvar vres;
  576.     ((_IOraDynaset *) Internal())->_getFieldValue(vres.GetVariant(), m_index);
  577.     vres.HaveSetVariant();
  578.     
  579.     vres.GetValue(&val);
  580.     return(val);
  581. }
  582.  
  583. OField::operator double() const
  584. {
  585.     if (ActionStart() != OSUCCESS)
  586.         return(0.0);
  587.     
  588.     double val;
  589.     OOLEvar vres;
  590.     ((_IOraDynaset *) Internal())->_getFieldValue(vres.GetVariant(), m_index);
  591.     vres.HaveSetVariant();
  592.     
  593.     vres.GetValue(&val);
  594.     return(val);
  595. }
  596.  
  597. OField::operator const char *() const
  598. {
  599.     if (ActionStart() != OSUCCESS)
  600.         return(NULL);
  601.     
  602.     // for memory management we need non-const version of "this"
  603.     OField *of2 = (OField *) this;
  604.     
  605.     if (m_data)
  606.     {
  607.         OObjectFreeString(m_data);
  608.         of2->m_data = 0;
  609.     }
  610.     
  611.     OOLEvar vres;
  612.     const char *val;
  613.     ((_IOraDynaset *) Internal())->_getFieldValue(vres.GetVariant(), m_index);
  614.     vres.HaveSetVariant();
  615.     // now the string is in a BSTR owned by the VARIANT in vres
  616.     
  617.     vres.GetValue(&val); // get a pointer to the string
  618.     
  619.     // copy it so we don't lose it when vres is destroyed
  620.     of2->m_data = OObjectAllocString((const char *) val);
  621.     return(m_data);
  622. }
  623.  
  624.  
  625.  
  626.