List:Commits« Previous MessageNext Message »
From:jon Date:January 31 2006 12:48pm
Subject:bk commit into 5.1 tree (jon:1.2101)
View as plain text  
Below is the list of changes that have just been committed into a local
5.1 repository of jon. When jon does a push these changes will
be propagated to the main repository and, within 24 hours after the
push, to the public repository.
For information on how to access the public repository
see http://dev.mysql.com/doc/mysql/en/installing-source-tree.html

ChangeSet
  1.2101 06/01/31 22:48:33 jon@stripped +3 -0
  Fixes/updates for NDB API docs.

  storage/ndb/include/ndbapi/NdbIndexScanOperation.hpp
    1.24 06/01/31 22:48:24 jon@stripped +61 -50
    Fixes/updates for NDB API docs.

  storage/ndb/include/ndbapi/NdbIndexOperation.hpp
    1.12 06/01/31 22:48:24 jon@stripped +53 -55
    Fixes/updates for NDB API docs.

  storage/ndb/include/ndbapi/NdbEventOperation.hpp
    1.19 06/01/31 22:48:24 jon@stripped +99 -92
    Fixes/updates for NDB API docs.

# This is a BitKeeper patch.  What follows are the unified diffs for the
# set of deltas contained in the patch.  The rest of the patch, the part
# that BitKeeper cares about, is below these diffs.
# User:	jon
# Host:	gigan.site
# Root:	/home/jon/bk/mysql-5.1-ndbapi-working

--- 1.23/storage/ndb/include/ndbapi/NdbIndexScanOperation.hpp	2005-11-07 21:19:05 +10:00
+++ 1.24/storage/ndb/include/ndbapi/NdbIndexScanOperation.hpp	2006-01-31 22:48:24 +10:00
@@ -21,7 +21,7 @@
 
 /**
  * @class NdbIndexScanOperation
- * @brief Class of scan operations for use to scan ordered index
+ * @brief Class of scan operations for use in scanning an ordered index.
  */
 class NdbIndexScanOperation : public NdbScanOperation {
 #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
@@ -35,27 +35,32 @@
 
 public:
   /**
-   * readTuples using ordered index
+   * Reads tuples using an ordered index.
    * 
-   * @param lock_mode Lock mode
-   * @param scan_flags see @ref ScanFlag
-   * @param parallel No of fragments to scan in parallel (0=max)
+   * @param lock_mode  Lock mode.
+   * @param scan_flags See @ref ScanFlag.
+   * @param parallel   Number of fragments to be scanned in parallel 
+   *                   (0 = maximum).
    */ 
   virtual int readTuples(LockMode lock_mode = LM_Read, 
                          Uint32 scan_flags = 0, Uint32 parallel = 0);
 
 #ifndef DOXYGEN_SHOULD_SKIP_INTERNAL
   /**
-   * readTuples using ordered index
+   * Reads tuples using an ordered index.
    * 
-   * @param lock_mode Lock mode
-   * @param batch     No of rows to fetch from each fragment at a time
-   * @param parallel  No of fragments to scan in parallel
-   * @param order_by  Order result set in index order
-   * @param order_desc Order descending, ignored unless order_by
-   * @param read_range_no Enable reading of range no using @ref get_range_no
-   * @returns 0 for success and -1 for failure
-   * @see NdbScanOperation::readTuples
+   * @param lock_mode Lock mode.
+   * @param batch     Number of rows to fetch from each fragment at a 
+                      time.
+   * @param parallel  Number of fragments to scan in parallel.
+   * @param order_by  Whether or not to order the result set in index 
+                      order.
+   * @param order_desc Order descending (ignored unless 
+   *                   <code>order_by</code> is set).
+   * @param read_range_no Enable reading of range number using 
+   *                      @ref get_range_no()
+   * @returns 0 on success, -1 on failure.
+   * @see NdbScanOperation::readTuples()
    */ 
   inline int readTuples(LockMode lock_mode,
                         Uint32 batch, 
@@ -72,8 +77,8 @@
 #endif
 
   /**
-   * Type of ordered index key bound.  The values (0-4) will not change
-   * and can be used explicitly (e.g. they could be computed).
+   * Type of ordered index key bound. The values (0-4) will not change
+   * and can be used explicitly; this means that they can be computed.
    */
   enum BoundType {
     BoundLE = 0,        ///< lower bound
@@ -84,37 +89,43 @@
   };
 
   /**
-   * Define bound on index key in range scan.
+   * Defines a bound on an index key in a range scan.
    *
-   * Each index key can have lower and/or upper bound.  Setting the key
-   * equal to a value defines both upper and lower bounds.  The bounds
-   * can be defined in any order.  Conflicting definitions is an error.
-   *
-   * For equality, it is better to use BoundEQ instead of the equivalent
-   * pair of BoundLE and BoundGE.  This is especially true when table
-   * partition key is an initial part of the index key.
-   *
-   * The sets of lower and upper bounds must be on initial sequences of
-   * index keys.  All but possibly the last bound must be non-strict.
-   * So "a >= 2 and b > 3" is ok but "a > 2 and b >= 3" is not.
+   * Each index key can have a lower bound, upper bound, or both. 
+   * Setting the key equal to a given value is used to define both upper 
+   * and lower bounds. The bounds can be defined in any order. 
+   * Conflicting definitions cause an error.
+   *
+   * For equality, it is better to use <var>BoundEQ</var> instead of the 
+   * equivalent pairing of <var>BoundLE</var> and <var>BoundGE</var>. 
+   * This is especially true when the table partition key is an initial 
+   * part of the index key.
+   *
+   * Sets of lower and upper bounds must be on initial sequences of
+   * index keys. All but possibly the last bound must be non-strict.
+   * For example, <b>a >= 2 and b > 3</b> is permissible but <b>a > 2 
+   * and b >= 3</b> is not.
    *
    * The scan may currently return tuples for which the bounds are not
-   * satisfied.  For example, "a <= 2 and b <= 3" scans the index up to
-   * (a=2, b=3) but also returns any (a=1, b=4).
-   *
-   * NULL is treated like a normal value which is less than any not-NULL
-   * value and equal to another NULL value.  To compare against NULL use
-   * setBound with null pointer (0).
-   *
-   * An index stores also all-NULL keys.  Doing index scan with empty
-   * bound set returns all table tuples.
+   * satisfied.  For example, <b>a <= 2 and b <= 3</b> not only scans 
+   * the index up to <b>(a=2, b=3)</b> but also returns any 
+   * <b>(a=1, b=4)</b>.
+   *
+   * <code>NULL</code> is treated like a normal value which is less than 
+   * any non-<code>NULL</code> value and equal to another 
+   * <code>NULL</code> value. To compare with <code>NULL</code>, use
+   * setBound() with the null pointer (0).
+   *
+   * An index also stores all <code>NULL</code> keys. Performing an 
+   * index scan with an empty set of bounds returns all tuples in the 
+   * table.
    *
    * @param attr        Attribute name, alternatively:
-   * @param type        Type of bound
-   * @param value       Pointer to bound value, 0 for NULL
-   * @return            0 if successful otherwise -1
+   * @param type        Type of bound.
+   * @param value       Pointer to bound value, 0 for <code>NULL</code>.
+   * @return            0 on success, otherwise -1.
    *
-   * @note See comment under equal() about data format and length.
+   * @note See comments under equal() about data format and length.
    */
 #ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
   int setBound(const char* attr, int type, const void* value, Uint32 len);
@@ -122,8 +133,8 @@
   int setBound(const char* attr, int type, const void* value);
 
   /**
-   * Define bound on index key in range scan using index column id.
-   * See the other setBound() method for details.
+   * Defines a bound on an index key in a range scan using the index 
+   * column ID. See the other setBound() method for details.
    */
 #ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
   int setBound(Uint32 anAttrId, int type, const void* aValue, Uint32 len);
@@ -131,29 +142,29 @@
   int setBound(Uint32 anAttrId, int type, const void* aValue);
 
   /**
-   * Reset bounds and put operation in list that will be
-   *   sent on next execute
+   * Resets bounds and puts operations in a list to be sent on the next 
+   * scan execution.
    */
   int reset_bounds(bool forceSend = false);
 
   /**
-   * Marks end of a bound, 
-   *  used when batching index reads (multiple ranges)
+   * Marks the end of a bound; used when batching index reads 
+   * (multiple ranges).
    */
   int end_of_bound(Uint32 range_no);
   
   /**
-   * Return range no for current row
+   * Returns the range number for the current row.
    */
   int get_range_no();
   
   /**
-   * Is current scan sorted
+   * Tests whether the current scan is sorted.
    */
   bool getSorted() const { return m_ordered; }
 
   /**
-   * Is current scan sorted descending
+   * Tests whether the current scan sorts in descending order.
    */
   bool getDescending() const { return m_descending; }
 

--- 1.18/storage/ndb/include/ndbapi/NdbEventOperation.hpp	2006-01-19 23:00:03 +10:00
+++ 1.19/storage/ndb/include/ndbapi/NdbEventOperation.hpp	2006-01-31 22:48:24 +10:00
@@ -24,12 +24,10 @@
  * @class NdbEventOperation
  * @brief Class of operations for getting change events from database.  
  *
- * Brief description on how to work with events:
+ * Brief description - how to work with events:
  *
- * - An event, represented by an NdbDictionary::Event, i created in the 
- *   Database through
- *   NdbDictionary::Dictionary::createEvent() (note that this can be done 
- *   by any application or thread and not necessarily by the "listener")
+ * - An event, represented by an NdbDictionary::Event, is created in the 
+ *   Database through NdbDictionary::Dictionary::createEvent().  
  * - To listen to events, an NdbEventOperation object is instantiated by 
  *   Ndb::createEventOperation()
  * - execute() starts the event flow. Use Ndb::pollEvents() to wait
@@ -37,123 +35,131 @@
  *   through the events that have occured.
  * - The instance is removed by Ndb::dropEventOperation()
  *
- * For more info see:
- * @ref ndbapi_event.cpp
+ *   @note  An event can be created by any application or thread and 
+ *          is not limited to being done only by the event listener.
+ *
+ * For more information see @ref ndbapi_event.cpp.
  *
  * Known limitations:
  *
- * - Maximum number of active NdbEventOperations are now set at compile time.
- * Today 100.  This will become a configuration parameter later.
- * - Maximum number of NdbEventOperations tied to same event are maximum 16
- * per process.
+ * - The total maximum number of active NdbEventOperation instances is 
+ *   currently set at compile time to 100. This is expected eventually 
+ *   to become a configurable parameter.
+ * - The maximum number of NdbEventOperations tied to the same event is 
+ *   16 per process.
  *
  * Known issues:
  *
- * - When several NdbEventOperation's are tied to the same event in the same
- * process they will share the circular buffer. The BufferLength will then
- * be the same for all and decided by the first NdbEventOperation 
- * instantiation. Just make sure to instantiate the "largest" one first.
- * - Today all events INSERT/DELETE/UPDATE and all changed attributes are
- * sent to the API, even if only specific attributes have been specified.
- * These are however hidden from the user and only relevant data is shown
- * after  Ndb::nextEvent().
- * - "False" exits from Ndb::pollEvents() may occur and thus
- * the subsequent Ndb::nextEvent() will return NULL,
- * since there was no available data. Just do Ndb::pollEvents() again.
- * - Event code does not check table schema version. Make sure to drop events
- * after table is dropped. Will be fixed in later
- * versions.
- * - If a node failure has occured not all events will be recieved
- * anymore. Drop NdbEventOperation and Create again after nodes are up
- * again. Will be fixed in later versions.
+ * - When several NdbEventOperation objects are tied to the same event 
+ *   and the same process, they share the circular buffer. The 
+ *   BufferLength is then the same for all of them and determined by the 
+ *   first NdbEventOperation to be instantiated. For this reason, you 
+ *   should instantiate the one requiring the most space first.
+ * - All <code>INSERT</code>, <code>DELETE</code>, and 
+ *   <code>UPDATE</code> events - as well as all changed attributes - 
+ *   are sent to the API, even if only some attributes have been 
+ *   specified. However, these are hidden from the user, and only 
+ *   relevant data are shown after an Ndb::nextEvent() call.
+ * - False exits from Ndb::pollEvents() may occur. In such cases, a
+ *   subsequent call to Ndb::nextEvent() will return <code>NULL</code>
+ *   since there was no available data. To work around this issue, 
+ *   simply perform another Ndb::pollEvents().
+ * - Event code does not check the table schema version. Be sure to drop 
+ *   events after the table is dropped. We plan to fix this in a future
+ *   version.
+ * - All events may not be received any longer following a node failure.
+ *   Once the nodes are up again, you should drop the 
+ *   NdbEventOperation() and re-create it. We intend to fix this issue 
+ *   in a future version.
  *
  * Test status:
  *
- * - Tests have been run on 1-node and 2-node systems
+ * - Tests have been run on 1-node and 2-node systems.
  *
  * Useful API programs:
  *
- * - ndb_select_all -d sys 'NDB$EVENTS_0'
- * shows contents in the system table containing created events.
+ * - <code>ndb_select_all -d sys 'NDB$EVENTS_0'</code> shows the 
+ *   contents of the system table holding created events.
  *
- * @note this is an inteface to viewing events that is subject to change
+ * @note This interface to viewing events is subject to change.
  */
 class NdbEventOperation {
 public:
   /**
-   * State of the NdbEventOperation object
+   * State of the NdbEventOperation object.
    */
   enum State {
-    EO_CREATED,   ///< Created but execute() not called
-    EO_EXECUTING, ///< execute() called
-    EO_DROPPED,   ///< Waiting to be deleted, Object unusable.
-    EO_ERROR      ///< An error has occurred. Object unusable.
+    EO_CREATED,   ///< Created, but execute() not yet called.
+    EO_EXECUTING, ///< execute() called.
+    EO_DROPPED,   ///< Waiting to be deleted, object unusable.
+    EO_ERROR      ///< An error has occurred, object unusable.
   };
   /**
-   * Retrieve current state of the NdbEventOperation object
+   * Retrieves the current state of the NdbEventOperation object.
    */
   State getState();
   /**
-   * See NdbDictionary::Event.  Default is false.
+   * See NdbDictionary::Event(). Default is <code>false</code>.
    */
   void mergeEvents(bool flag);
 
   /**
-   * Activates the NdbEventOperation to start receiving events. The
-   * changed attribute values may be retrieved after Ndb::nextEvent() 
-   * has returned not NULL. The getValue() methods must be called
-   * prior to execute().
+   * Activates the NdbEventOperation, so that it starts receiving 
+   * events. Changed attribute values may be retrieved once 
+   * Ndb::nextEvent() has returned a non-<code>NULL</code> value. The 
+   * getValue() methods must be called prior to calling execute().
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int execute();
 
   /**
-   * Defines a retrieval operation of an attribute value.
-   * The NDB API allocate memory for the NdbRecAttr object that
-   * will hold the returned attribute value. 
-   *
-   * @note Note that it is the applications responsibility
-   *       to allocate enough memory for aValue (if non-NULL).
-   *       The buffer aValue supplied by the application must be
-   *       aligned appropriately.  The buffer is used directly
-   *       (avoiding a copy penalty) only if it is aligned on a
-   *       4-byte boundary and the attribute size in bytes
-   *       (i.e. NdbRecAttr::attrSize() times NdbRecAttr::arraySize() is
-   *       a multiple of 4).
-   *
-   * @note There are two versions, getValue() and
-   *       getPreValue() for retrieving the current and
-   *       previous value repectively.
-   *
-   * @note This method does not fetch the attribute value from 
-   *       the database!  The NdbRecAttr object returned by this method 
-   *       is <em>not</em> readable/printable before the 
-   *       execute() has been made and
-   *       Ndb::nextEvent() has returned not NULL.
+   * Defines an operation retrieving an attribute value. The NDB API 
+   * allocates memory for the NdbRecAttr object that is to hold the 
+   * returned attribute value. 
+   *
+   * @note It is the application's responsibility to allocate sufficient 
+   *       memory for <var>aValue</var> (if non-<code>NULL</code>). The 
+   *       <var>aValue</var> buffer supplied by the application must be
+   *       aligned appropriately. The buffer is used directly (so 
+   *       avoiding a copy penalty) only if it is aligned on a 4-byte 
+   *       boundary and the attribute size in bytes 
+   *       (NdbRecAttr::attrSize() times NdbRecAttr::arraySize()) is
+   *       an even multiple of 4.
+   *
+   * @note There are two methods - getValue() and getPreValue() - for 
+   *       retrieving the current and previous values, respectively.
+   *
+   * @note This method does <em>not</em> fetch the attribute value from 
+   *       the database! The NdbRecAttr object returned by this method 
+   *       cannot be read or printed until execute() has been called and
+   *       Ndb::nextEvent() has returned a non-<code>NULL</code> value.
    *       If a specific attribute has not changed the corresponding 
-   *       NdbRecAttr will be in state UNDEFINED.  This is checked by 
-   *       NdbRecAttr::isNULL() which then returns -1.
-   *
-   * @param anAttrName  Attribute name 
-   * @param aValue      If this is non-NULL, then the attribute value 
-   *                    will be returned in this parameter.<br>
-   *                    If NULL, then the attribute value will only 
-   *                    be stored in the returned NdbRecAttr object.
+   *       NdbRecAttr in the <code>UNDEFINED</code> state. This can be 
+   *       checked using NdbRecAttr::isNULL(), which should then return 
+   *       -1.
+   *
+   * @param anAttrName  Attribute name.
+   * @param aValue      If this is non <code>NULL</code>, then the 
+   *                    attribute value will be returned in this 
+   *                    parameter.<br>
+   *                    If it is <code>NULL</code>, then the attribute 
+   *                    value is only stored in the returned NdbRecAttr 
+   *                    object.
    * @return            An NdbRecAttr object to hold the value of 
-   *                    the attribute, or a NULL pointer 
-   *                    (indicating error).
+   *                    the attribute, or a <code>NULL</code> pointer 
+   *                    (indicating that an error has occurred).
    */
   NdbRecAttr *getValue(const char *anAttrName, char *aValue = 0);
   /**
-   * See getValue().
+   * See @ref getValue().
    */
   NdbRecAttr *getPreValue(const char *anAttrName, char *aValue = 0);
 
   /**
-   * These methods replace getValue/getPreValue for blobs.  Each
-   * method creates a blob handle NdbBlob.  The handle supports only
-   * read operations.  See NdbBlob.
+   * These methods replace the getValue() and getPreValue() methods for 
+   * blobs. Each method creates a blob handle NdbBlob. The handle supports 
+   * only read operations. See NdbBlob.
    */
   NdbBlob* getBlobHandle(const char *anAttrName);
   NdbBlob* getPreBlobHandle(const char *anAttrName);
@@ -161,38 +167,39 @@
   int isOverrun() const;
 
   /**
-   * In the current implementation a nodefailiure may cause loss of events,
-   * in which case isConsistent() will return false
+   * In the current implementation, a node failure may cause events to 
+   * be lost, in which case isConsistent() will return 
+   * <code>false</code>.
    */
   bool isConsistent() const;
 
   /**
-   * Query for occured event type.
+   * Determines the type of the event that occurred.
    *
-   * @note Only valid after Ndb::nextEvent() has been called and 
-   * returned a not NULL value
+   * @note Valid only after Ndb::nextEvent() has been called and has
+   * returned a non-<code>NULL</code> value.
    *
-   * @return type of event
+   * @return Type of event.
    */
   NdbDictionary::Event::TableEvent getEventType() const;
 
   /**
-   * Retrieve the GCI of the latest retrieved event
+   * Retrieves the GCI of the most recent event retrieved.
    *
-   * @return GCI number
+   * @return GCI number.
    */
   Uint64 getGCI() const;
 
   /**
-   * Retrieve the complete GCI in the cluster (not necessarily
-   * associated with an event)
+   * Retrieves the complete GCI in the cluster (not necessarily
+   * associated with an event).
    *
-   * @return GCI number
+   * @return GCI number.
    */
   Uint64 getLatestGCI() const;
 
   /**
-   * Get the latest error
+   * Gets the most recent error.
    *
    * @return   Error object.
    */			     

--- 1.11/storage/ndb/include/ndbapi/NdbIndexOperation.hpp	2005-10-06 18:26:06 +10:00
+++ 1.12/storage/ndb/include/ndbapi/NdbIndexOperation.hpp	2006-01-31 22:48:24 +10:00
@@ -43,64 +43,62 @@
   int insertTuple();
 
   /**
-   * Define the NdbIndexOperation to be a standard operation of type readTuple.
-   * When calling NdbTransaction::execute, this operation
-   * reads a tuple.
+   * Defines the NdbIndexOperation as a standard operation of type 
+   * <code>readTuple</code>. When calling NdbTransaction::execute(), 
+   * this operation reads a tuple.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int readTuple(LockMode);
 
 #ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
   /**
-   * Define the NdbIndexOperation to be a standard operation of type readTuple.
-   * When calling NdbTransaction::execute, this operation
-   * reads a tuple.
+   * Defines the NdbIndexOperation as a standard operation of type 
+   * <code>readTuple</code>. When calling NdbTransaction::execute(), 
+   * this operation reads a tuple.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int readTuple();
 
   /**
-   * Define the NdbIndexOperation to be a standard operation of type
-   * readTupleExclusive.
-   * When calling NdbTransaction::execute, this operation
-   * read a tuple using an exclusive lock.
+   * Defines the NdbIndexOperation as a standard operation of type
+   * r<code>eadTupleExclusive</code>. When calling 
+   * NdbTransaction::execute(), this operation reads a tuple using an 
+   * exclusive lock.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int readTupleExclusive();
 
   /**
-   * Define the NdbIndexOperation to be a standard operation of type simpleRead.
-   * When calling NdbTransaction::execute, this operation
-   * reads an existing tuple (using shared read lock),
-   * but releases lock immediately after read.
-   *
-   * @note  Using this operation twice in the same transaction
-   *        may produce different results (e.g. if there is another
-   *        transaction which updates the value between the
-   *        simple reads).
-   *
-   * Note that simpleRead can read the value from any database node while
-   * standard read always read the value on the database node which is
-   * primary for the record.
+   * Defines the NdbIndexOperation as a standard operation of type 
+   * <code>simpleRead</code>. When calling NdbTransaction::execute(), 
+   * this operation reads an existing tuple using a shared read lock,
+   * but releases the lock immediately following the read.
+   *
+   * @note  Using this operation twice in the same transaction may 
+   *        produce different results (for example, if another
+   *        transaction updates the value between the simple reads).
+   *
+   * Note that simpleRead() can read the value from any storage node 
+   * while a standard read always reads the value on the storage node 
+   * which is primary for the record.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int simpleRead();
 
   /**
-   * Define the NdbOperation to be a standard operation of type committedRead.
-   * When calling NdbTransaction::execute, this operation 
-   * read latest committed value of the record.
-   *
-   * This means that if another transaction is updating the 
-   * record, then the current transaction will not wait.  
-   * It will instead use the latest committed value of the 
-   * record.
+   * Defines the NdbOperation as a standard operation of type 
+   * <code>committedRead</code>. When calling NdbTransaction::execute(), 
+   * this operation reads the latest committed value of the record.
+   *
+   * This means that if another transaction is updating the record, then 
+   * the current transaction does not wait, instead using the latest 
+   * committed value of the record.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int dirtyRead();
 
@@ -108,36 +106,36 @@
 #endif
 
   /**
-   * Define the NdbIndexOperation to be a standard operation of type 
-   * updateTuple.
+   * Defines the NdbIndexOperation as a standard operation of type 
+   * <code>updateTuple</code>.
    *
-   * When calling NdbTransaction::execute, this operation
-   * updates a tuple in the table.
+   * When calling NdbTransaction::execute(), this operation updates a 
+   * tuple in the table.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int updateTuple();
 
   /**
-   * Define the NdbIndexOperation to be a standard operation of type 
-   * deleteTuple.
+   * Defines the NdbIndexOperation as a standard operation of type 
+   * <code>deleteTuple</code>.
    *
-   * When calling NdbTransaction::execute, this operation
-   * deletes a tuple.
+   * When calling NdbTransaction::execute(), this operation deletes a 
+   * tuple.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int deleteTuple();
 
 #ifndef DOXYGEN_SHOULD_SKIP_DEPRECATED
   /**
-   * Define the NdbIndexOperation to be a standard operation of type 
-   * dirtyUpdate.
+   * Defines the NdbIndexOperation as a standard operation of type 
+   * <code>dirtyUpdate</code>.
    *
-   * When calling NdbTransaction::execute, this operation
-   * updates without two-phase commit.
+   * When calling NdbTransaction::execute(), this operation updates 
+   * without a two-phase commit.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int dirtyUpdate();
 #endif
@@ -150,16 +148,16 @@
    */
 
   /**
-   * Update a tuple using an interpreted program.
+   * Updates a tuple using an interpreted program.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int interpretedUpdateTuple();
 
   /**
-   * Delete a tuple using an interpreted program.
+   * Deletes a tuple using an interpreted program.
    *
-   * @return 0 if successful otherwise -1.
+   * @return 0 on success, otherwise -1.
    */
   int interpretedDeleteTuple();
 #endif
Thread
bk commit into 5.1 tree (jon:1.2101)jon31 Jan