Merge pnousiainen@bk-internal.mysql.com:/home/bk/mysql-4.1

into mysql.com:/space/pekka/ndb/version/my41


ndb/include/ndbapi/NdbBlob.hpp:
  Auto merged

4 files changed, 34 insertions, 30 deletions

diff --git a/ndb/include/ndbapi/NdbBlob.hpp b/ndb/include/ndbapi/NdbBlob.hpp
index 5df61a0806c..0fb63015da2 100644
--- a/ndb/include/ndbapi/NdbBlob.hpp
+++ b/ndb/include/ndbapi/NdbBlob.hpp
@@ -36,7 +36,7 @@ class NdbColumnImpl;
  * Blob data is stored in 2 places:
  *
  * - "header" and "inline bytes" stored in the blob attribute
- * - "blob parts" stored in a separate table NDB$BLOB_<t>_<v>_<c>
+ * - "blob parts" stored in a separate table NDB$BLOB_<tid>_<cid>
  *
  * Inline and part sizes can be set via NdbDictionary::Column methods
  * when the table is created.
@@ -74,23 +74,21 @@ class NdbColumnImpl;
  * NdbBlob methods return -1 on error and 0 on success, and use output
  * parameters when necessary.
  *
- * Notes:
- * - table and its blob part tables are not created atomically
- * - scan must use the "new" interface NdbScanOperation
- * - to update a blob in a read op requires exclusive tuple lock
- * - update op in scan must do its own getBlobHandle
- * - delete creates implicit, not-accessible blob handles
- * - NdbOperation::writeTuple does not support blobs
- * - there is no support for an asynchronous interface
+ * Operation types:
+ * - insertTuple must use setValue if blob column is non-nullable
+ * - readTuple with exclusive lock can also update existing value
+ * - updateTuple can overwrite with setValue or update existing value
+ * - writeTuple always overwrites and must use setValue if non-nullable
+ * - deleteTuple creates implicit non-accessible blob handles
+ * - scan with exclusive lock can also update existing value
+ * - scan "lock takeover" update op must do its own getBlobHandle
  *
  * Bugs / limitations:
- * - scan must use exclusive locking for now
- *
- * Todo:
- * - add scan method hold-read-lock + return-keyinfo
- * - check keyinfo length when setting keys
- * - check allowed blob ops vs locking mode
- * - overload control (too many pending ops)
+ * - lock mode upgrade should be handled automatically
+ * - lock mode vs allowed operation is not checked
+ * - too many pending blob ops can blow up i/o buffers
+ * - table and its blob part tables are not created atomically
+ * - there is no support for an asynchronous interface
  */
 class NdbBlob {
 public:
@@ -173,19 +171,11 @@ public:
    */
   int readData(void* data, Uint32& bytes);
   /**
-   * Read at given position.  Does not use or update current position.
-   */
-  int readData(Uint64 pos, void* data, Uint32& bytes);
-  /**
    * Write at current position and set new position to first byte after
    * the data written.  A write past blob end extends the blob value.
    */
   int writeData(const void* data, Uint32 bytes);
   /**
-   * Write at given position. Does not use or update current position.
-   */
-  int writeData(Uint64 pos, const void* data, Uint32 bytes);
-  /**
    * Return the blob column.
    */
   const NdbDictionary::Column* getColumn();
@@ -266,14 +256,17 @@ private:
     Buf();
     ~Buf();
     void alloc(unsigned n);
+    void copyfrom(const Buf& src);
   };
   Buf theKeyBuf;
   Buf theAccessKeyBuf;
   Buf theHeadInlineBuf;
+  Buf theHeadInlineCopyBuf;     // for writeTuple
   Buf thePartBuf;
   Head* theHead;
   char* theInlineData;
   NdbRecAttr* theHeadInlineRecAttr;
+  NdbOperation* theHeadInlineReadOp;
   bool theHeadInlineUpdateFlag;
   // length and read/write position
   int theNullFlag;
@@ -294,6 +287,7 @@ private:
   bool isReadOp();
   bool isInsertOp();
   bool isUpdateOp();
+  bool isWriteOp();
   bool isDeleteOp();
   bool isScanOp();
   // computations
@@ -309,12 +303,13 @@ private:
   void getHeadFromRecAttr();
   int setHeadInlineValue(NdbOperation* anOp);
   // data operations
-  int readDataPrivate(Uint64 pos, char* buf, Uint32& bytes);
-  int writeDataPrivate(Uint64 pos, const char* buf, Uint32 bytes);
+  int readDataPrivate(char* buf, Uint32& bytes);
+  int writeDataPrivate(const char* buf, Uint32 bytes);
   int readParts(char* buf, Uint32 part, Uint32 count);
   int insertParts(const char* buf, Uint32 part, Uint32 count);
   int updateParts(const char* buf, Uint32 part, Uint32 count);
   int deleteParts(Uint32 part, Uint32 count);
+  int deletePartsUnknown(Uint32 part);
   // pending ops
   int executePendingBlobReads();
   int executePendingBlobWrites();
diff --git a/ndb/include/ndbapi/NdbConnection.hpp b/ndb/include/ndbapi/NdbConnection.hpp
index 92b940e96f7..7af5d27b922 100644
--- a/ndb/include/ndbapi/NdbConnection.hpp
+++ b/ndb/include/ndbapi/NdbConnection.hpp
@@ -526,7 +526,7 @@ private:
   int 	sendCOMMIT();                   // Send a TC_COMMITREQ signal;
   void	setGCI(int GCI);		// Set the global checkpoint identity
  
-  int	OpCompleteFailure(Uint8 abortoption);
+  int	OpCompleteFailure(Uint8 abortoption, bool setFailure = true);
   int	OpCompleteSuccess();
   void	CompletedOperations();	        // Move active ops to list of completed
  
@@ -552,7 +552,7 @@ private:
   void		setOperationErrorCode(int anErrorCode);	
 
   // Indicate something went wrong in the definition phase
-  void		setOperationErrorCodeAbort(int anErrorCode);
+  void		setOperationErrorCodeAbort(int anErrorCode, int abortOption = -1);
 
   int		checkMagicNumber();		       // Verify correct object
   NdbOperation* getNdbOperation(const class NdbTableImpl* aTable,
diff --git a/ndb/include/ndbapi/NdbIndexOperation.hpp b/ndb/include/ndbapi/NdbIndexOperation.hpp
index 7612fe54d1b..1472f1b249e 100644
--- a/ndb/include/ndbapi/NdbIndexOperation.hpp
+++ b/ndb/include/ndbapi/NdbIndexOperation.hpp
@@ -49,6 +49,9 @@ public:
    * @{
    */
 
+  /** insert is not allowed */
+  int insertTuple();
+
   /**
    * Define the NdbIndexOperation to be a standard operation of type readTuple.
    * When calling NdbConnection::execute, this operation
@@ -193,6 +196,7 @@ private:
 
   // Private attributes
   const NdbIndexImpl* m_theIndex;
+  const NdbTableImpl* m_thePrimaryTable;
   Uint32 m_theIndexDefined[NDB_MAX_ATTRIBUTES_IN_INDEX][3];
   Uint32 m_theIndexLen;	  	 // Length of the index in words
   Uint32 m_theNoOfIndexDefined;  // The number of index attributes
diff --git a/ndb/include/ndbapi/NdbOperation.hpp b/ndb/include/ndbapi/NdbOperation.hpp
index 8e0294e41e6..46d4ddab0f5 100644
--- a/ndb/include/ndbapi/NdbOperation.hpp
+++ b/ndb/include/ndbapi/NdbOperation.hpp
@@ -918,6 +918,13 @@ protected:
   // Blobs in this operation
   NdbBlob* theBlobList;
 
+  /*
+   * Abort option per operation, used by blobs.  Default -1.  If set,
+   * overrides abort option on connection level.  If set to IgnoreError,
+   * does not cause execute() to return failure.  This is different from
+   * IgnoreError on connection level.
+   */
+  Int8 m_abortOption;
 };
 
 #ifdef NDB_NO_DROPPED_SIGNAL
@@ -1160,5 +1167,3 @@ NdbOperation::setValue(Uint32 anAttrId, double aPar)
 }
 
 #endif
-
-