home *** CD-ROM | disk | FTP | other *** search
/ PC World Komputer 1996 February / PCWK0296.iso / po7_win / object10 / odyn.cpp < prev    next >
C/C++ Source or Header  |  1995-04-13  |  38KB  |  1,461 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 ODynaset and ODynasetMark classes
  13.                            
  14.     CREATED    ********   11/22/94
  15.     RWOOLARD    MODIFIED    03/20/95
  16.                 bug#    260389    GetFieldValue() should check its arguments
  17.                         260789    All 'Chunk' code should check column type is a long 
  18.                         260868    AppendChuknk shuld not accept NULL pointer
  19.                         262112    Loop counter in DuplicateRecord should start from 0
  20.                         271055    OEF/BOF return -1 on success
  21.                            263418    GetFieldValue does not work with dates
  22. */
  23.  
  24. #include "windows.h"
  25. #include <ole2.h>
  26. #include <olenls.h>       
  27. #include <dispatch.h>  
  28.  
  29. #ifndef ORACL_ORACLE
  30. #include "oracl.h"
  31. #endif
  32.  
  33. #ifndef ORAOBJI_ORACLE
  34. #include "oraobji.h"
  35. #endif
  36.  
  37. #ifndef _OracleInProcServer_H_
  38. #include <oratlb.h>
  39. #endif
  40.  
  41. static const IID IID_IOraDynaset =
  42. {0xf0051a80, 0x00b3, 0x101b, { 0xad, 0xf2, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  43. static const IID IID_IOraStream =
  44. {0x06beb9e0, 0xce61, 0x101b, { 0xb9, 0xd1, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  45. static const IID IID_IOraMStream =
  46. {0x08c70d00, 0xce61, 0x101b, { 0xb9, 0xd1, 0x04, 0x02, 0x1c, 0x00, 0x70, 0x02 } };
  47.  
  48. // ----- ODynaset -----------------------------------------------
  49.  
  50. ODynaset::ODynaset(void)
  51. {
  52.     m_sqlstmt = 0;  // no sql statement yet
  53. }
  54.  
  55. ODynaset::ODynaset(const ODynaset &other)
  56. {
  57.     m_sqlstmt = 0;  // no sql statement yet
  58.     Copy(other);
  59. }
  60.  
  61. ODynaset::ODynaset(const ODatabase &odb, const char *sqlst, long options)
  62. {
  63.     m_sqlstmt = 0;  // no sql statement yet
  64.     Open(odb, sqlst, options);
  65. }
  66.  
  67. ODynaset::~ODynaset(void) 
  68. {
  69.     Cleanup();
  70. }
  71.  
  72. oresult ODynaset::Close(void)
  73. {
  74.     return(Cleanup());
  75. }
  76.  
  77. oresult ODynaset::Open(const ODatabase &odb, const char *sqlst, long options)
  78. {
  79.     if (!odb.IsOpen())
  80.     { // unopened database
  81.         SetInternalError(OERROR_INVPARENT);
  82.         return(OFAILURE);
  83.     }
  84.     if (!sqlst)
  85.     {
  86.         SetInternalError(OERROR_BADARG);
  87.         return(OFAILURE);
  88.     }
  89.     
  90.     odb.ErrorReset();
  91.     IDispatch *dyni = ((_IOraDatabase *) (odb.Internal()))->get_CreateDynaset((char *) sqlst, options);
  92.     
  93.     return(OpenHelper(dyni, odb.Internal()));
  94. }
  95.  
  96. ODynaset ODynaset::Clone(void) const
  97. {
  98.     ODynaset clonedyn;
  99.     
  100.     if (ActionGetStart(&clonedyn) != OSUCCESS)
  101.         return(clonedyn); // returning unopened object - indicates error
  102.     
  103.     IDispatch *dyni = ((_IOraDynaset *) (Internal()))->get_Clone();
  104.     
  105.     oresult ores = clonedyn.OpenHelper(dyni, Internal());
  106.     if (ores != OSUCCESS)
  107.         clonedyn.Close();  // make sure it isn't partly opened
  108.     
  109.     return(clonedyn);
  110. }  
  111.  
  112. oresult ODynaset::OpenHelper(void *id, void *otheri)
  113. {
  114.     if (!id) 
  115.     { // couldn't create dynaset - error is on other object
  116.         SetOtherError(otheri);
  117.         return(OFAILURE);
  118.     }
  119.     
  120.     Cleanup();
  121.         
  122.     IDispatch *idisp = (IDispatch *) id;
  123.     
  124.     void *tempi;    
  125.     HRESULT hc = idisp->QueryInterface(IID_IOraDynaset, &tempi);
  126.     idisp->Release();
  127.     if (FAILED(hc))
  128.     { // couldn't get the interface
  129.         SetInternalError(OERROR_NOINTER);
  130.         return(OFAILURE);
  131.     }
  132.     
  133.     return(SetObjectInterface(tempi));
  134. }
  135.  
  136. OFieldCollection ODynaset::GetFields(void) const
  137. {
  138.     OFieldCollection fs;
  139.     
  140.     if (ActionGetStart(&fs) != OSUCCESS)
  141.         return(fs); // returning unopened object - indicates error
  142.     
  143.     IDispatch *connect = ((_IOraDynaset *) (Internal()))->get_Fields();
  144.  
  145.     fs.OpenHelper((void *) connect, Internal());
  146.     
  147.     return(fs);
  148. }
  149.  
  150. OSession ODynaset::GetSession(void) const
  151. {
  152.     OSession sess;
  153.     
  154.     if (ActionGetStart(&sess) != OSUCCESS)
  155.         return(sess); // returning unopened object - indicates error
  156.     
  157.     IDispatch *connect = ((_IOraDynaset *) (Internal()))->get_Session();
  158.     
  159.     sess.OpenHelper((void *) connect, Internal());
  160.     
  161.     return(sess);
  162. }
  163.  
  164. ODatabase ODynaset::GetDatabase(void) const
  165. {
  166.     ODatabase odb;
  167.     
  168.     if (ActionGetStart(&odb) != OSUCCESS)
  169.         return(odb); // returning unopened object - indicates error
  170.     
  171.     IDispatch *db = ((_IOraDynaset *) (Internal()))->get_Database();
  172.     
  173.     odb.OpenHelper((void *) db, Internal());
  174.     
  175.     return(odb);
  176. }
  177.  
  178. OField ODynaset::GetField(int index) const
  179. {
  180.     return(GetFields().GetField(index));
  181. }
  182.      
  183. OField ODynaset::GetField(const char *fieldname) const
  184. {
  185.     int index = GetFieldIndex(fieldname);
  186.     if (index < 0)
  187.     { // bad index
  188.         OField closedfield;
  189.         closedfield.SetInternalError(OERROR_INVPARENT);
  190.         return(closedfield);
  191.     }
  192.     
  193.     return(GetFields().GetField(index));
  194. }
  195.  
  196. OConnection ODynaset::GetConnection(void) const
  197. {
  198.     OConnection conn;
  199.     
  200.     if (ActionGetStart(&conn) != OSUCCESS)
  201.         return(conn); // returning unopened object - indicates error
  202.     
  203.     IDispatch *connect = ((_IOraDynaset *) (Internal()))->get_Connection();
  204.     
  205.     conn.OpenHelper((void *) connect, Internal());
  206.     
  207.     return(conn);
  208. }
  209.  
  210. ODynasetMark ODynaset::GetMark(void) const
  211. {
  212.     ODynasetMark mrk;
  213.     
  214.     if (ActionGetStart(&mrk) != OSUCCESS)
  215.         return(mrk); // returning unopened object - indicates error
  216.     
  217.     void *obji = (void *) ((_IOraDynaset *) Internal())->get_Bookmark();
  218.     mrk.OpenHelper(obji, Internal());
  219.     
  220.     return(mrk);    
  221. }
  222.  
  223. ODynasetMark ODynaset::GetLastModifiedMark(void) const
  224. {
  225.     ODynasetMark mrk;
  226.     
  227.     if (ActionGetStart(&mrk) != OSUCCESS)
  228.         return(mrk); // returning unopened object - indicates error
  229.     
  230.     void *obji = (void *) ((_IOraDynaset *) Internal())->get_LastModified();
  231.     mrk.OpenHelper(obji, Internal());
  232.     
  233.     return(mrk);    
  234. }
  235.  
  236. // overloaded assignment operator
  237. ODynaset &ODynaset::operator=(const ODynaset &other)
  238. {
  239.     if (&other == this)
  240.         return(*this); // self assignment - do nothing
  241.     
  242.     // clear out our old state
  243.     if (OSUCCESS == Cleanup())
  244.     {
  245.         Copy(other); // call copy constructor
  246.     }
  247.     // if the cleanup failed (possible but unlikely) we don't do the copy
  248.     //    and as a result, we pass on the unmodified (or partly cleaned!) object
  249.     
  250.     return(*this);
  251. } 
  252.  
  253. oresult ODynaset::Copy(const ODynaset &other)
  254. {
  255.     // don't copy the sql statement
  256.     m_sqlstmt = 0;
  257.     
  258.     return(OOracleObject::Copy(other));
  259. }
  260.  
  261. oresult ODynaset::Cleanup(void)
  262. {
  263.     if (m_sqlstmt)
  264.     {
  265.         OObjectFreeString(m_sqlstmt);
  266.         m_sqlstmt = 0;
  267.     }
  268.     
  269.     return(OOracleObject::Cleanup());
  270. }   
  271.  
  272. oresult ODynaset::Refresh(void)
  273. {
  274.     if (ActionStart() != OSUCCESS)
  275.         return(OFAILURE);
  276.     
  277.     ((_IOraDynaset *) Internal())->Refresh();  // fires refresh advisory
  278.     if (ErrorNumber() == OERROR_NONE)
  279.     {
  280.         return(OSUCCESS);
  281.     }
  282.     else
  283.         return(OFAILURE);    
  284. }
  285.     
  286. oresult ODynaset::SetSQL(const char *sql_statement)
  287. {
  288.     if (ActionStart() != OSUCCESS)
  289.         return(OFAILURE);
  290.     if (!sql_statement)
  291.     {
  292.         SetInternalError(OERROR_BADARG);
  293.         return(OFAILURE);
  294.     }
  295.     
  296.     // this will invalidate our current sql statement
  297.     if (m_sqlstmt)
  298.     {
  299.         OObjectFreeString(m_sqlstmt);
  300.         m_sqlstmt = 0;
  301.     }
  302.     
  303.     // we need to hand in a real BSTR
  304.     BSTR tempcp = OObjectAllocString(sql_statement); 
  305.     if (!tempcp)
  306.     {
  307.         SetInternalError(OERROR_MEMORY);
  308.         return(OFAILURE);
  309.     }
  310.     ((_IOraDynaset *) Internal())->put_SQL(tempcp);
  311.     
  312.     if (ErrorNumber() == OERROR_NONE)
  313.     { // success, might as well remember the sql statment
  314.         m_sqlstmt = tempcp;  // now we don't need to free tempcp
  315.         return(OSUCCESS);
  316.     }
  317.     else
  318.     {
  319.         OObjectFreeString(tempcp);
  320.         return(OFAILURE);
  321.     }    
  322. }
  323.     
  324. const char *ODynaset::GetSQL(void) const
  325. {
  326.     if (ActionStart() != OSUCCESS)
  327.         return(NULL);
  328.     
  329.     // we always refetch the SQL statement, just in case
  330.     //   a copy of this ODynaset changed the underlying dynaset's
  331.     //   SQL statement
  332.     
  333.     // we need a non-const version of "this" to change m_sqlstmt
  334.     ODynaset *this2p = (ODynaset *) this;
  335.     
  336.     if (m_sqlstmt)
  337.     {
  338.         OObjectFreeString(m_sqlstmt);
  339.         this2p->m_sqlstmt = 0;
  340.     }
  341.     
  342.     this2p->m_sqlstmt = ((_IOraDynaset *) Internal())->get_SQL();
  343.     
  344.     return(m_sqlstmt);
  345. }
  346.  
  347. oresult ODynaset::MoveFirst(void)
  348. {
  349.     if (ActionStart() != OSUCCESS)
  350.         return(OFAILURE);
  351.     
  352.     ((_IOraDynaset *) Internal())->MoveFirst();
  353.     
  354.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  355. }
  356.  
  357. oresult ODynaset::MoveLast(void)
  358. {
  359.     if (ActionStart() != OSUCCESS)
  360.         return(OFAILURE);
  361.     
  362.     ((_IOraDynaset *) Internal())->MoveLast();
  363.     
  364.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  365. }
  366.  
  367. oresult ODynaset::MoveNext(oboolean gopast)
  368. {
  369.     if (ActionStart() != OSUCCESS)
  370.         return(OFAILURE);
  371.     
  372.     if (gopast)
  373.         ((_IOraDynaset *) Internal())->MoveNext();
  374.     else
  375.     {
  376.         ((_IOraDynaset *) Internal())->_moveNext();
  377.     }
  378.     
  379.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  380. }
  381.  
  382. oresult ODynaset::MovePrev(oboolean gopast)
  383. {
  384.     if (ActionStart() != OSUCCESS)
  385.         return(OFAILURE);
  386.     
  387.     if (gopast)
  388.         ((_IOraDynaset *) Internal())->MovePrevious();
  389.     else
  390.     {
  391.         ((_IOraDynaset *) Internal())->_movePrev();
  392.     }
  393.     
  394.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  395. }
  396.  
  397. oresult ODynaset::MoveToMark(const ODynasetMark &odmark)
  398. {
  399.     if (ActionStart() != OSUCCESS)
  400.         return(OFAILURE);
  401.     
  402.     if (!odmark.IsOpen())
  403.     {
  404.         SetInternalError(OERROR_INVBKMRK);
  405.         return(OFAILURE);
  406.     }
  407.     const BSTR themark = ((const BSTR) (odmark.Internal())); // get the mark
  408.     ((_IOraDynaset *) Internal())->put_Bookmark(themark);
  409.     
  410.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  411. }
  412.  
  413. oboolean ODynaset::IsEOF(void) const
  414. {
  415.     if (ActionStart() != OSUCCESS)
  416.         return(TRUE);
  417.     
  418. // BUG #271055 get_EOF returns -1 on success !!
  419.     return(((_IOraDynaset *) Internal())->get_EOF() ? TRUE : FALSE);
  420. }
  421.  
  422. oboolean ODynaset::IsBOF(void) const
  423. {
  424.     if (ActionStart() != OSUCCESS)
  425.         return(TRUE);
  426.     
  427. // BUG #271055 get_BOF returns -1 on success !!
  428.     return(((_IOraDynaset *) Internal())->get_BOF() ? TRUE : FALSE);
  429. }
  430.  
  431. oboolean ODynaset::IsFirst(void) const
  432. {
  433.     if (ActionStart() != OSUCCESS)
  434.         return(FALSE);          
  435.         
  436.     return(((_IOraDynaset *) Internal())->get_IsFirst() ? TRUE : FALSE);
  437. }
  438.  
  439. oboolean ODynaset::IsLast(void) const
  440. {
  441.     if (ActionStart() != OSUCCESS)
  442.         return(FALSE);
  443.     
  444.     int    test = ((_IOraDynaset *) Internal())->get_IsLast();    
  445.     return(test ? TRUE : FALSE);
  446. }
  447.  
  448. oboolean ODynaset::IsValidRecord(void) const
  449. {
  450.     // we tell if the current row is valid by trying to get a bookmark
  451.     if (ActionStart() != OSUCCESS)
  452.         return(FALSE);
  453.     
  454.     ODynasetMark tempmark = GetMark();
  455.     // if that failed then an error will be set on bookmark (which goes away
  456.     //    and on the dynaset
  457.     
  458.     return (tempmark.IsOpen());
  459. }   
  460.  
  461. oboolean ODynaset::CanTransact(void) const
  462. {
  463.     if (ActionStart() != OSUCCESS)
  464.         return(FALSE);
  465.     
  466.     BOOL cantran = ((_IOraDynaset *) Internal())->get_Transactions();
  467.     return(cantran ? TRUE : FALSE);    
  468. }
  469.  
  470. oboolean ODynaset::CanUpdate(void) const
  471. {
  472.     if (ActionStart() != OSUCCESS)
  473.         return(FALSE);
  474.     
  475.     BOOL canup = ((_IOraDynaset *) Internal())->get_Updatable();
  476.     return(canup ? TRUE : FALSE);    
  477. }
  478.  
  479. oboolean ODynaset::CanRefresh(void) const
  480. {
  481.     // can always refresh if we're open
  482.     return (IsOpen());
  483. }
  484.  
  485. oboolean ODynaset::CanScroll(void) const
  486. {
  487.     // we can always scroll if we can mark
  488.     return CanMark();
  489. }
  490.  
  491. oboolean ODynaset::CanMark(void) const
  492. {
  493.     if (ActionStart() != OSUCCESS)
  494.         return(FALSE);
  495.     
  496.     BOOL canmark = ((_IOraDynaset *) Internal())->get_Bookmarkable();
  497.     return(canmark ? TRUE : FALSE);    
  498. }
  499.  
  500. long ODynaset::GetOptions(void) const
  501. {
  502.     if (ActionStart() != OSUCCESS)
  503.         return(ODYNASET_DEFAULT);
  504.     
  505.     return(((_IOraDynaset *) Internal())->get_Options());    
  506. }
  507.  
  508. int ODynaset::GetEditMode(void) const
  509. {
  510.     int editmode;
  511.     
  512.     if (ActionStart() != OSUCCESS)
  513.         return(ODYNASET_EDIT_NOEDIT);
  514.     
  515.     editmode = ((_IOraDynaset *) Internal())->get_EditMode();
  516.     
  517.     return(editmode); // values are ODYNASET_EDIT_*
  518. }
  519.  
  520. oresult ODynaset::StartEdit(void)
  521. {
  522.     if (ActionStart() != OSUCCESS)
  523.         return(OFAILURE);
  524.     
  525.     ((_IOraDynaset *) Internal())->Edit();
  526.     
  527.     return((0 == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  528. }
  529.  
  530. oresult ODynaset::CancelEdit(void)
  531. {
  532.     if (ActionStart() != OSUCCESS)
  533.         return(OFAILURE);
  534.     
  535.     ((_IOraDynaset *) Internal())->UpdateControls();
  536.     
  537.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  538. }
  539.  
  540. oresult ODynaset::Update(void)
  541. {
  542.     if (ActionStart() != OSUCCESS)
  543.         return(OFAILURE);
  544.     
  545.     ((_IOraDynaset *) Internal())->Update();
  546.     
  547.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  548. }
  549.  
  550. oresult ODynaset::AddNewRecord(void)
  551. {
  552.     if (ActionStart() != OSUCCESS)
  553.         return(OFAILURE);
  554.     
  555.     ((_IOraDynaset *) Internal())->AddNew();
  556.     
  557.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  558. }
  559.  
  560. // special struct for DuplicateRecord
  561. struct VarList
  562. {
  563.     VARIANT  *val;
  564.     VarList   *next;
  565. };
  566.  
  567. oresult ODynaset::DuplicateRecord(void)
  568. {
  569.     if (ActionStart() != OSUCCESS)
  570.         return(OFAILURE);
  571.     
  572.     if (!IsValidRecord())
  573.     {
  574.         SetInternalError(OERROR_INVRECORD);
  575.         return(OFAILURE);
  576.     }
  577.     
  578.     // first get all the values of the current record
  579.     
  580.     // start list of values
  581.     VarList *vhead = new VarList;
  582.     VarList *curr = vhead;
  583.     
  584.     short findex;
  585.     int nfields = GetFieldCount();
  586. //BUG #262112    
  587.     for (findex = 0; findex < nfields; findex++)
  588.     {
  589.         curr->val = new VARIANT;
  590.         VariantInit(curr->val);
  591.         ((_IOraDynaset *) Internal())->_getFieldValue(curr->val, findex);
  592.         
  593.         if (findex < nfields - 1)
  594.         { // start next item
  595.             curr->next = new VarList;
  596.             curr = curr->next;
  597.         }
  598.         else
  599.         { // this is the last item
  600.             curr->next = 0;
  601.         }
  602.     }
  603.     
  604.     // now add a new record
  605.     ((_IOraDynaset *) Internal())->AddNew();                                       
  606.     
  607.     if (OERROR_NONE == ErrorNumber())
  608.     { // we were able to add the new record.  Set field values
  609.         findex = 0;
  610.         curr = vhead;
  611.         while (curr)
  612.         {
  613.             ((_IOraDynaset *) Internal())->_updateFieldValue(curr->val, findex++);
  614.             if (OERROR_NONE != ErrorNumber())
  615.                 break;  // bail out on error
  616.             curr = curr->next;
  617.         }
  618.     }
  619.     
  620.     // now get rid of all of the values
  621.     curr = vhead;
  622.     VarList *nextp;
  623.     while (curr)
  624.     {
  625.         nextp = curr->next;
  626.         VariantClear(curr->val);
  627.         delete curr->val;
  628.         delete curr;
  629.         curr = nextp;
  630.     }
  631.     
  632.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  633. }
  634.  
  635. oresult ODynaset::DeleteRecord(void)
  636. {
  637.     if (ActionStart() != OSUCCESS)
  638.         return(OFAILURE);
  639.     
  640.     ((_IOraDynaset *) Internal())->Delete();
  641.     
  642.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  643. }
  644.  
  645. int ODynaset::GetFieldCount(void) const
  646. {
  647.     if (ActionStart() != OSUCCESS)
  648.         return(0);
  649.     
  650.     return(((_IOraDynaset *) Internal())->_getFieldCount());
  651. }    
  652.  
  653. long ODynaset::GetRecordCount(void) const
  654. {
  655.     if (ActionStart() != OSUCCESS)
  656.         return(0);
  657.     
  658.     return(((_IOraDynaset *) Internal())->get_RecordCount());
  659. }    
  660.  
  661. int ODynaset::GetFieldIndex(const char *fieldname) const
  662. {
  663.     if (ActionStart() != OSUCCESS)
  664.         return(-1);
  665.     if (!fieldname)
  666.     {
  667.         SetInternalError(OERROR_BADARG);
  668.         return(-1);
  669.     }
  670.     
  671.     // pass in a real BSTR for fieldname (ARGHH)
  672.     BSTR tempf = OObjectAllocString(fieldname);
  673.     int index = ((_IOraDynaset *) Internal())->_getFieldIndex((char *) tempf);
  674.     OObjectFreeString(tempf);
  675.     
  676.     return((0 == ErrorNumber()) ? index : -1);    
  677. }
  678.  
  679. oboolean ODynaset::IsFieldTruncated(int index) const
  680. {
  681.     if (ActionStart() != OSUCCESS)
  682.         return(FALSE);
  683.  
  684.     int ftype = GetFieldServerType(index);
  685. //BUG #260789    
  686.     if (ftype != OTYPE_LONG && ftype != OTYPE_LONGRAW)
  687.     { // this field isn't a long
  688.         SetInternalError(OERROR_BADARG);
  689.         return(FALSE);
  690.     }
  691.     
  692.     int istrunc = ((_IOraDynaset *) (Internal()))->_isFieldTruncated(index);
  693.     return(istrunc ? TRUE : FALSE);  
  694. }
  695.  
  696. oboolean ODynaset::IsFieldTruncated(const char *fieldname) const
  697. {
  698.     int index = GetFieldIndex(fieldname);
  699.     if (index < 0)
  700.         return(FALSE);
  701.     return(IsFieldTruncated(index));
  702. }
  703.  
  704. short ODynaset::GetFieldServerType(int index) const
  705. {
  706.     if (ActionStart() != OSUCCESS)
  707.         return(0);
  708.     
  709.     return (short) (((_IOraDynaset *) (Internal()))->_getFieldServerType(index));
  710. }
  711.  
  712. short ODynaset::GetFieldServerType(const char *fieldname) const
  713. {
  714.     int index = GetFieldIndex(fieldname);
  715.     if (index < 0)
  716.         return(0);
  717.     return (GetFieldServerType(index));
  718. }
  719.  
  720. short ODynaset::GetFieldPrecision(int index) const
  721. {
  722.     if (ActionStart() != OSUCCESS)
  723.         return(0);
  724.     
  725.     return (short) (((_IOraDynaset *) (Internal()))->_getFieldPrecision(index));
  726. }
  727.  
  728. short ODynaset::GetFieldPrecision(const char *fieldname) const
  729. {
  730.     int index = GetFieldIndex(fieldname);
  731.     if (index < 0)
  732.         return(0);
  733.     return(GetFieldPrecision(index));
  734. }
  735.  
  736. short ODynaset::GetFieldScale(int index) const
  737. {
  738.     if (ActionStart() != OSUCCESS)
  739.         return(0);
  740.     
  741.     return (short) (((_IOraDynaset *) (Internal()))->_getFieldScale(index));
  742. }
  743.  
  744. short ODynaset::GetFieldScale(const char *fieldname) const
  745. {
  746.     int index = GetFieldIndex(fieldname);
  747.     if (index < 0)
  748.         return(0);
  749.     return(GetFieldScale(index));
  750. }
  751.  
  752. long ODynaset::GetFieldSize(int index) const
  753. {
  754.     if (ActionStart() != OSUCCESS)
  755.         return(0);
  756.     
  757.     return(((_IOraDynaset *) (Internal()))->_getFieldSize(index));
  758. }
  759.  
  760. long ODynaset::GetFieldSize(const char *fieldname) const
  761. {
  762.     int index = GetFieldIndex(fieldname);
  763.     if (index < 0)
  764.         return(0);
  765.     return(GetFieldSize(index));
  766. }
  767.  
  768. long ODynaset::GetFieldServerSize(int index) const
  769. {
  770.     if (ActionStart() != OSUCCESS)
  771.         return(0);
  772.     
  773.     return(((_IOraDynaset *) (Internal()))->_getFieldDataSize(index));
  774. }
  775.  
  776. long ODynaset::GetFieldServerSize(const char *fieldname) const
  777. {
  778.     int index = GetFieldIndex(fieldname);
  779.     if (index < 0)
  780.         return(0);
  781.     return(GetFieldServerSize(index));
  782. }
  783.  
  784. oboolean ODynaset::IsFieldNullOK(int index) const
  785. {
  786.      if (ActionStart() != OSUCCESS)
  787.         return(FALSE);
  788.     
  789.     int isok = ((_IOraDynaset *) (Internal()))->_isFieldNullOK(index);
  790.     return(isok ? TRUE : FALSE);
  791. }
  792.  
  793. oboolean ODynaset::IsFieldNullOK(const char *fieldname) const
  794. {
  795.     int index = GetFieldIndex(fieldname);
  796.     if (index < 0)
  797.         return(0);
  798.     return(IsFieldNullOK(index));
  799. }
  800.  
  801. oresult ODynaset::GetFieldValue(int index, OValue *val) const
  802. {                   
  803. //BUG #260389
  804.     if (! val)
  805.     {
  806.         SetInternalError(OERROR_BADARG);
  807.         return(OFAILURE);
  808.     }
  809.         
  810.     if (ActionStart() != OSUCCESS)
  811.     {
  812.         val->Clear(); // clear it
  813.         return(OFAILURE);
  814.     }
  815.     
  816.     // get pointer to OOLEvar inside the OValue
  817.     //   we then directly set the VARIANT in the OOLEvar - which sets the OValue
  818.     OOLEvar *vres = (OOLEvar *) val->Internal();
  819.     ((_IOraDynaset *) Internal())->_getFieldValue(vres->GetVariant(), index);
  820.     vres->HaveSetVariant();
  821.     
  822.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  823. }
  824.  
  825. oresult ODynaset::GetFieldValue(const char *fieldname, OValue *val) const
  826. {
  827. //BUG #260389
  828.     if (! val || ! fieldname)
  829.     {
  830.         SetInternalError(OERROR_BADARG);
  831.         return(OFAILURE);
  832.     }
  833.         
  834.     int index = GetFieldIndex(fieldname);
  835.     if (index < 0)
  836.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled
  837.     return(GetFieldValue(index, val));
  838. }
  839.  
  840. oresult ODynaset::GetFieldValue(int index, int *val) const
  841. {
  842. //BUG #260389
  843.     if (! val)
  844.     {
  845.         SetInternalError(OERROR_BADARG);
  846.         return(OFAILURE);
  847.     }
  848.         
  849.     if (ActionStart() != OSUCCESS)
  850.         return(OFAILURE);
  851.  
  852.     OOLEvar vres;
  853.     ((_IOraDynaset *) Internal())->_getFieldValue(vres.GetVariant(), index);
  854.     vres.HaveSetVariant();
  855.     
  856.     return(vres.GetValue(val));
  857. }
  858.  
  859. oresult ODynaset::GetFieldValue(const char *fieldname, int *val) const
  860. {
  861. //BUG #260389
  862.     if (! val || ! fieldname)
  863.     {
  864.         SetInternalError(OERROR_BADARG);
  865.         return(OFAILURE);
  866.     }
  867.         
  868.     int index = GetFieldIndex(fieldname);
  869.     if (index < 0)
  870.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled
  871.     return(GetFieldValue(index, val));
  872. }
  873.  
  874. oresult ODynaset::GetFieldValue(int index, long *val) const
  875. {
  876. //BUG #260389
  877.     if (! val)
  878.     {
  879.         SetInternalError(OERROR_BADARG);
  880.         return(OFAILURE);
  881.     }
  882.         
  883.     if (ActionStart() != OSUCCESS)
  884.         return(OFAILURE);
  885.  
  886.     OOLEvar vres;
  887.     ((_IOraDynaset *) Internal())->_getFieldValue(vres.GetVariant(), index);
  888.     vres.HaveSetVariant();
  889.     
  890.     return(vres.GetValue(val));
  891. }
  892.  
  893. oresult ODynaset::GetFieldValue(const char *fieldname, long *val) const
  894. {
  895. //BUG #260389
  896.     if (! val || ! fieldname)
  897.     {
  898.         SetInternalError(OERROR_BADARG);
  899.         return(OFAILURE);
  900.     }
  901.         
  902.     int index = GetFieldIndex(fieldname);
  903.     if (index < 0)
  904.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled
  905.     return(GetFieldValue(index, val));
  906. }
  907.  
  908. oresult ODynaset::GetFieldValue(int index, double *val) const
  909. {
  910. //BUG #260389
  911.     if (! val)
  912.     {
  913.         SetInternalError(OERROR_BADARG);
  914.         return(OFAILURE);
  915.     }
  916.         
  917.     if (ActionStart() != OSUCCESS)
  918.         return(OFAILURE);
  919.  
  920.     OOLEvar vres;
  921.     ((_IOraDynaset *) Internal())->_getFieldValue(vres.GetVariant(), index);
  922.     vres.HaveSetVariant();
  923.     
  924.     return(vres.GetValue(val));
  925. }
  926.  
  927. oresult ODynaset::GetFieldValue(const char *fieldname, double *val) const
  928. {
  929. //BUG #260389
  930.     if (! val || ! fieldname)
  931.     {
  932.         SetInternalError(OERROR_BADARG);
  933.         return(OFAILURE);
  934.     }
  935.         
  936.     int index = GetFieldIndex(fieldname);
  937.     if (index < 0)
  938.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled
  939.     return(GetFieldValue(index, val));
  940. }
  941.  
  942. oresult ODynaset::GetFieldValue(int index, char *val, unsigned short maxlen) const
  943. {
  944. //BUG #260389
  945.     if (! val || maxlen < 1)
  946.     {
  947.         SetInternalError(OERROR_BADARG);
  948.         return(OFAILURE);
  949.     }
  950.     
  951.     // we need to get the value and then copy the characters - up to the maximum length
  952.     OValue oval;
  953.     
  954.     if (GetFieldValue(index, &oval) != OSUCCESS)
  955.         return(OFAILURE);
  956.  
  957. // BUG #263418    GetFieldValue does not work with dates   
  958.     // what is the length of the string?
  959.     OOLEvar *vres = (OOLEvar *) oval.Internal();
  960.     // Need to call the GetValue method just to convert the OOLEvar into a string.
  961.     // This is required if the variant is a date, but not if it is a string already.
  962.     // The overhead of doing this is no more than that of getting the variant type
  963.     // and only calling for dates. Note that buf is just a pointer and will be set
  964.     // point at the string, but it is never used.
  965.     const char *buf;
  966.     vres->GetValue (&buf);
  967.     // now we can get the length
  968.     unsigned int slen = vres->GetStringLength();
  969.     if (slen > (unsigned int) maxlen-1)
  970.         slen = maxlen-1; // -1 to leave space for null termination
  971.     
  972.     // copy string (DBCS problem)
  973.     memcpy(val, (const char *) oval, slen);
  974.     // null terminate
  975.     val[slen] = '\0';
  976.     
  977.     return(OSUCCESS);
  978. }
  979.  
  980. oresult ODynaset::GetFieldValue(const char *fieldname, char *val, unsigned short maxlen) const
  981. {
  982. //BUG #260389
  983.     if (! val || ! fieldname || maxlen < 1)
  984.     {
  985.         SetInternalError(OERROR_BADARG);
  986.         return(OFAILURE);
  987.     }
  988.         
  989.     int index = GetFieldIndex(fieldname);
  990.     if (index < 0)
  991.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled
  992.     return(GetFieldValue(index, val, maxlen));
  993. }
  994.  
  995. oresult ODynaset::GetFieldValue(int index, void __huge *longval, long len, long *readlen) const
  996. {
  997. //BUG #260389
  998.     if (! longval || len < 1 || ! readlen)
  999.     {
  1000.         SetInternalError(OERROR_BADARG);
  1001.         return(OFAILURE);
  1002.     }
  1003.         
  1004.     if (ActionStart() != OSUCCESS)
  1005.     {
  1006.         *readlen = 0;
  1007.         return(OFAILURE);
  1008.     }
  1009.     int ftype = GetFieldServerType(index);
  1010. //BUG #260789    
  1011.     if (ftype != OTYPE_LONG && ftype != OTYPE_LONGRAW)
  1012.     { // this field isn't a long (which we don't allow yet)
  1013.         *readlen = 0;
  1014.         SetInternalError(OERROR_BADTYPE);
  1015.         return(OFAILURE);
  1016.     }
  1017.  
  1018.     if (len < 1)
  1019.     { // this field isn't a long, or negative length (which we don't allow yet)
  1020.         *readlen = 0;
  1021.         SetInternalError(OERROR_BADARG);
  1022.         return(OFAILURE);
  1023.     }
  1024.     
  1025.     // fetch the long field value
  1026.     OOLEvar vres;
  1027.     ((_IOraDynaset *) Internal())->_fetchLongFieldValue(vres.GetVariant(), index, len);
  1028.     vres.HaveSetVariant();
  1029.     
  1030.     if (vres.IsNull())
  1031.     { // there was nothing in the field
  1032.         *readlen = 0;
  1033.         return(OSUCCESS);
  1034.     }
  1035.     
  1036.     // we've got something - try to get data from it
  1037.     VARIANT *varp = vres.GetVariant();
  1038.     if (V_VT(varp) != VT_UNKNOWN)
  1039.     { // we don't have expected interface
  1040.         SetInternalError(OERROR_SYSTEM);
  1041.         return(OFAILURE);
  1042.     }
  1043.     
  1044.     // get the _IOraStream interface
  1045.     IUnknown *unkp = V_UNKNOWN(varp);
  1046.     void *istr;    
  1047.     HRESULT hc = unkp->QueryInterface(IID_IOraMStream, &istr);
  1048.     // unkp->Release(); don't release because VARIANT owns it
  1049.     if (FAILED(hc))
  1050.     { // couldn't get the interface
  1051.         SetInternalError(OERROR_NOINTER);
  1052.         return(OFAILURE);
  1053.     }
  1054.     
  1055.     // use the _IOraStream interface to copy the bytes
  1056.     // figure out how long the stream is
  1057.     long pos;
  1058.     ((_IOraMStream *) istr)->Seek(0L, STREAM_SEEK_CUR, &pos);
  1059.     if (pos < len)
  1060.     { // we weren't able to read as many bytes as asked for
  1061.         len = pos; // adjust # of bytes we will try to read
  1062.         /*
  1063.             With 16bit OCI we will only be able to tell the length
  1064.             of the long (before reading it all) if len < 64K.  So
  1065.             if len >= 64K pos will always == len
  1066.         */
  1067.     }
  1068.     
  1069.     // now seek to beginning
  1070.     ((_IOraMStream *) istr)->Seek(0L, STREAM_SEEK_SET, &pos);
  1071.     
  1072.     // and read
  1073.     hc = ((_IOraMStream *) istr)->Read(longval, len, readlen);
  1074.     
  1075.     ((_IOraMStream *) istr)->Release();
  1076.     if (FAILED(hc))
  1077.     {
  1078.         SetInternalError(GetScode(hc));
  1079.         return(OFAILURE);
  1080.     }    
  1081.     
  1082.     return(OSUCCESS);
  1083. }
  1084.  
  1085. oresult ODynaset::GetFieldValue(const char *fieldname, void __huge *longval, long len, long *readlen) const
  1086. {
  1087. //BUG #260389
  1088.     if (! longval || ! fieldname || ! readlen)
  1089.     {
  1090.         SetInternalError(OERROR_BADARG);
  1091.         return(OFAILURE);
  1092.     }
  1093.         
  1094.     int index = GetFieldIndex(fieldname);
  1095.     if (index < 0)
  1096.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled
  1097.     return(GetFieldValue(index, longval, len, readlen));
  1098. }
  1099.  
  1100. oresult ODynaset::GetFieldChunk(int index, void *chunkp, long offset, unsigned short len) const 
  1101. {
  1102.     if (! chunkp || len < 1 || offset < 1)
  1103.     {
  1104.         SetInternalError(OERROR_BADARG);
  1105.         return(OFAILURE);
  1106.     }
  1107.         
  1108.     if (ActionStart() != OSUCCESS)
  1109.         return(OFAILURE);
  1110.     
  1111.     int fieldtype = GetFieldServerType (index);
  1112. //BUG #260789    
  1113.     if (fieldtype != OTYPE_LONG && fieldtype != OTYPE_LONGRAW)
  1114.     {
  1115.         SetInternalError (OERROR_BADTYPE);
  1116.         return(OFAILURE);
  1117.     }
  1118.     
  1119.     BSTR tempp;
  1120.     HRESULT hc = ((_IOraDynaset *) Internal())->_getFieldChunk(&tempp, index, offset, len);
  1121.     if (FAILED(hc))
  1122.     { // couldn't get the interface
  1123.         SetInternalError(OERROR_NOINTER);
  1124.     }
  1125.  
  1126.     if (ErrorNumber() != OERROR_NONE)
  1127.     {
  1128.         // clean up
  1129.         SysFreeString(tempp);
  1130.         return(OFAILURE);
  1131.     }
  1132.     else
  1133.     { // copy the string to the user's buffer
  1134.         memcpy((void *) chunkp, (const void *) tempp, len);
  1135.         
  1136.         // clean up
  1137.         SysFreeString(tempp);
  1138.         return(OSUCCESS);
  1139.     }
  1140. }
  1141.  
  1142. oresult ODynaset::GetFieldChunk(const char *fieldname, void *chunkp, long offset, unsigned short len) const
  1143. {
  1144.     if (! fieldname)
  1145.     {   // Other bad arguments are handled by the overloaded GetFieldChunk called at end of routine
  1146.         SetInternalError(OERROR_BADARG);
  1147.         return(OFAILURE);
  1148.     }
  1149.  
  1150.     int index = GetFieldIndex(fieldname);
  1151.     if (index < 0)
  1152.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled
  1153.     return(GetFieldChunk(index, chunkp, offset, len));
  1154. }
  1155.  
  1156. oresult ODynaset::SetFieldValue(int index, const void __huge *longval, long len)
  1157. {
  1158.     if (ActionStart() != OSUCCESS)
  1159.         return(OFAILURE);
  1160.     
  1161.     // create the IOraStream interface
  1162.     _IOraMStream *istr;
  1163.     ((_IOraDynaset *) Internal())->_createMStream(&istr);
  1164.     
  1165.     // now write the data to the stream
  1166.     long readlen;
  1167.     HRESULT hc = istr->Write((void *) longval, len, &readlen);
  1168.     if (FAILED(hc) || readlen != len)
  1169.     {
  1170.         istr->Release();
  1171.         SetInternalError(OERROR_MEMORY);
  1172.         return(OFAILURE);
  1173.     }
  1174.     
  1175.     // hand this to the field
  1176.     VARIANT val;
  1177.     VariantInit(&val);
  1178.     V_VT(&val) = VT_UNKNOWN;
  1179.     V_UNKNOWN(&val) = istr;
  1180.     
  1181.     ((_IOraDynaset *) Internal())->_updateFieldValue(&val, index);
  1182.     
  1183.     VariantClear(&val);  // releases stream
  1184.     
  1185.     return((ErrorNumber() == OERROR_NONE) ? OSUCCESS : OFAILURE); 
  1186. }
  1187.  
  1188. oresult ODynaset::SetFieldValue(const char *fieldname, const void __huge *longval, long len)
  1189. {
  1190.     int index = GetFieldIndex(fieldname);
  1191.     if (index < 0)
  1192.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled
  1193.     return(SetFieldValue(index, longval, len));
  1194. }
  1195.  
  1196. //BUG #260868
  1197. oresult ODynaset::AppendFieldChunk(int index, const void *chunkp, unsigned short len)
  1198. {
  1199.     if (! chunkp || len < 1)
  1200.     {
  1201.         SetInternalError (OERROR_BADARG);
  1202.         return(OFAILURE);
  1203.     }
  1204.     if (ActionStart() != OSUCCESS)
  1205.         return(OFAILURE);
  1206.         
  1207.     int fieldtype = GetFieldServerType (index);
  1208. //BUG #260789    
  1209.     if (fieldtype != OTYPE_LONG && fieldtype != OTYPE_LONGRAW)
  1210.     {   // This field is not a long
  1211.         SetInternalError (OERROR_BADTYPE);
  1212.         return(OFAILURE);
  1213.     }
  1214.     
  1215.     // create a tempbuffer with the data in it
  1216.     char *tempb = OObjectAllocStringLen((char *) chunkp, len);
  1217.     if (!tempb)
  1218.     {
  1219.         SetInternalError(OERROR_MEMORY);
  1220.         return(OFAILURE);
  1221.     }
  1222.     
  1223.     HRESULT hc = ((_IOraDynaset *) Internal())->_appendChunk(tempb, index);
  1224.     if (FAILED(hc))
  1225.     { // couldn't get the interface
  1226.         SetInternalError(OERROR_NOINTER);
  1227.     }
  1228.  
  1229.     OObjectFreeString(tempb);
  1230.     
  1231.     return((ErrorNumber() == OERROR_NONE) ? OSUCCESS : OFAILURE);
  1232. }
  1233.  
  1234. //BUG #260868
  1235. oresult ODynaset::AppendFieldChunk(const char *fieldname, const void *chunkp, unsigned short len)
  1236. {
  1237.     if (! fieldname)
  1238.     {
  1239.         SetInternalError (OERROR_BADARG);
  1240.         return(OFAILURE);
  1241.     }
  1242.  
  1243.     int index = GetFieldIndex(fieldname);
  1244.     if (index < 0)
  1245.         return(OFAILURE);  // return without calling GetFieldValue so errors don't get muddled 
  1246.     
  1247.     return(AppendFieldChunk(index, chunkp, len));
  1248. }
  1249.  
  1250. oresult ODynaset::SetFieldValue(int index, const OValue &val)
  1251. {
  1252.     if (ActionStart() != OSUCCESS)
  1253.         return(OFAILURE);
  1254.  
  1255.     VARIANT *vres = ((OOLEvar *) (val.Internal()))->GetVariant();
  1256.     
  1257.     // set field value
  1258.     ((_IOraDynaset *) Internal())->_updateFieldValue(vres, index);
  1259.  
  1260.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  1261. }
  1262.  
  1263. oresult ODynaset::SetFieldValue(const char *fieldname, const OValue &val)
  1264. {
  1265.     int index = GetFieldIndex(fieldname);
  1266.     if (index < 0)
  1267.         return(OFAILURE);  // return without calling SetFieldValue so errors don't get muddled
  1268.     return(SetFieldValue(index, val));
  1269. }
  1270.  
  1271. oresult ODynaset::SetFieldValue(int index, int val)
  1272. {
  1273.     if (ActionStart() != OSUCCESS)
  1274.         return(OFAILURE);
  1275.  
  1276.     // set up VARIANT
  1277.     OOLEvar vres;
  1278.     vres.SetValue(val);
  1279.     
  1280.     // set field value
  1281.     ((_IOraDynaset *) Internal())->_updateFieldValue(vres.GetVariant(), index);
  1282.  
  1283.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  1284. }
  1285.  
  1286. oresult ODynaset::SetFieldValue(const char *fieldname, int val)
  1287. {
  1288.     int index = GetFieldIndex(fieldname);
  1289.     if (index < 0)
  1290.         return(OFAILURE);  // return without calling SetFieldValue so errors don't get muddled
  1291.     return(SetFieldValue(index, val));
  1292. }
  1293.  
  1294. oresult ODynaset::SetFieldValue(int index, long val)
  1295. {
  1296.     if (ActionStart() != OSUCCESS)
  1297.         return(OFAILURE);
  1298.  
  1299.     // set up VARIANT
  1300.     OOLEvar vres;
  1301.     vres.SetValue(val);
  1302.     
  1303.     // set field value
  1304.     ((_IOraDynaset *) Internal())->_updateFieldValue(vres.GetVariant(), index);
  1305.  
  1306.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  1307. }
  1308.  
  1309. oresult ODynaset::SetFieldValue(const char *fieldname, long val)
  1310. {
  1311.     int index = GetFieldIndex(fieldname);
  1312.     if (index < 0)
  1313.         return(OFAILURE);  // return without calling SetFieldValue so errors don't get muddled
  1314.     return(SetFieldValue(index, val));
  1315. }
  1316.  
  1317. oresult ODynaset::SetFieldValue(int index, double val)
  1318. {
  1319.     if (ActionStart() != OSUCCESS)
  1320.         return(OFAILURE);
  1321.  
  1322.     // set up VARIANT
  1323.     OOLEvar vres;
  1324.     vres.SetValue(val);
  1325.     
  1326.     // set field value
  1327.     ((_IOraDynaset *) Internal())->_updateFieldValue(vres.GetVariant(), index);
  1328.  
  1329.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  1330. }
  1331.  
  1332. oresult ODynaset::SetFieldValue(const char *fieldname, double val)
  1333. {
  1334.     int index = GetFieldIndex(fieldname);
  1335.     if (index < 0)
  1336.         return(OFAILURE);  // return without calling SetFieldValue so errors don't get muddled
  1337.     return(SetFieldValue(index, val));
  1338. }
  1339.  
  1340. oresult ODynaset::SetFieldValue(int index, const char *val)
  1341. {
  1342.     if (ActionStart() != OSUCCESS)
  1343.         return(OFAILURE);
  1344.  
  1345.     // set up VARIANT
  1346.     OOLEvar vres;
  1347.     vres.SetValue(val);
  1348.     
  1349.     // set field value
  1350.     ((_IOraDynaset *) Internal())->_updateFieldValue(vres.GetVariant(), index);
  1351.  
  1352.     return((OERROR_NONE == ErrorNumber()) ? OSUCCESS : OFAILURE);    
  1353. }
  1354.  
  1355. oresult ODynaset::SetFieldValue(const char *fieldname, const char *val)
  1356. {
  1357.     int index = GetFieldIndex(fieldname);
  1358.     if (index < 0)
  1359.         return(OFAILURE);  // return without calling SetFieldValue so errors don't get muddled
  1360.     return(SetFieldValue(index, val));
  1361. }
  1362.  
  1363. // ----- ODynasetMark -----------------------------------------------
  1364.  
  1365. ODynasetMark::ODynasetMark(void)
  1366. {
  1367.     m_markdata = 0;  // nothing marked yet
  1368. } 
  1369.  
  1370. ODynasetMark::ODynasetMark(const ODynasetMark &other)
  1371. {
  1372.     if (other.m_markdata)
  1373.         m_markdata = OObjectAllocStringLen(other.m_markdata, OObjectStringLen(other.m_markdata));
  1374.     else
  1375.         m_markdata = 0;
  1376. }
  1377.  
  1378. ODynasetMark::~ODynasetMark(void)
  1379. {
  1380.     Cleanup();
  1381. }
  1382.  
  1383. char *ODynasetMark::Internal(void) const
  1384. {
  1385.     return m_markdata;
  1386. }
  1387.  
  1388. oboolean ODynasetMark::IsOpen(void) const
  1389. {
  1390.     return (m_markdata ? TRUE : FALSE);
  1391. }
  1392.  
  1393. ODynasetMark &ODynasetMark::operator=(const ODynasetMark &other)
  1394. {
  1395.     if (&other == this)
  1396.         return(*this);  // self reference
  1397.      
  1398.     Cleanup();  // drop current data
  1399.     
  1400.     if (other.m_markdata)
  1401.         m_markdata = OObjectAllocStringLen(other.m_markdata, OObjectStringLen(other.m_markdata));
  1402.     else
  1403.         m_markdata = 0;
  1404.     
  1405.     return(*this);
  1406. }
  1407.  
  1408. int ODynasetMark::operator==(const ODynasetMark &other) const
  1409. {
  1410.     // closed marks never equal anything
  1411.     if (!m_markdata || ! other.m_markdata)
  1412.         return(0);
  1413.     
  1414.     // just do a bytewise comparison of the mark data
  1415.     // markdata is a BSTR - compare for its full length (even over null bytes)
  1416.     unsigned int marklen = OObjectStringLen(m_markdata);
  1417.     
  1418.     if (0 == memcmp(m_markdata, other.m_markdata, marklen))
  1419.         return(1); // complete match
  1420.     else
  1421.         return(0); // not equal
  1422. }
  1423.  
  1424. int ODynasetMark::operator!=(const ODynasetMark &other) const
  1425. {
  1426.     return(!(this->operator==(other)));
  1427. }
  1428.  
  1429. oresult ODynasetMark::Close(void)
  1430. {
  1431.     return(Cleanup());
  1432. }
  1433.  
  1434. oresult ODynasetMark::Cleanup(void)
  1435. {
  1436.     if (m_markdata)
  1437.         OObjectFreeString(m_markdata);
  1438.     
  1439.     m_markdata = 0;
  1440.     
  1441.     return(OSUCCESS);
  1442. }
  1443.  
  1444. oresult ODynasetMark::OpenHelper(void *obji, void *otheri)
  1445. {
  1446.     Cleanup();
  1447.     if (!obji)
  1448.     {
  1449.         SetOtherError(otheri);
  1450.         return(OFAILURE);
  1451.     }
  1452.     
  1453.     // otherwise everything is fine
  1454.     m_markdata = (char *) obji;
  1455.     ErrorReset();
  1456.     
  1457.     return(OSUCCESS);   
  1458. }
  1459.  
  1460.  
  1461.