List:Commits« Previous MessageNext Message »
From:Craig L Russell Date:October 5 2010 6:12am
Subject:bzr commit into clusterj branch (Craig.Russell:334)
View as plain text  
#At file:///Users/clr/ndb/root/clusterj-working/ based on revid:craig.russell@stripped

  334 Craig L Russell	2010-10-04
      Define BufferManager in DbImpl to handle all shared buffers for data transformation in operations

    modified:
      clusterj-tie/src/main/java/com/mysql/clusterj/tie/ClusterTransactionImpl.java
      clusterj-tie/src/main/java/com/mysql/clusterj/tie/DbImpl.java
      clusterj-tie/src/main/java/com/mysql/clusterj/tie/OperationImpl.java
      clusterj-tie/src/main/java/com/mysql/clusterj/tie/ResultDataImpl.java
      clusterj-tie/src/main/java/com/mysql/clusterj/tie/ScanOperationImpl.java
      clusterj-tie/src/main/java/com/mysql/clusterj/tie/ScanResultDataImpl.java
      clusterj-tie/src/main/resources/com/mysql/clusterj/tie/Bundle.properties
=== modified file 'clusterj-tie/src/main/java/com/mysql/clusterj/tie/ClusterTransactionImpl.java'
--- a/clusterj-tie/src/main/java/com/mysql/clusterj/tie/ClusterTransactionImpl.java	2010-10-04 18:23:11 +0000
+++ b/clusterj-tie/src/main/java/com/mysql/clusterj/tie/ClusterTransactionImpl.java	2010-10-05 06:12:02 +0000
@@ -38,6 +38,7 @@ import com.mysql.clusterj.core.store.Tab
 import com.mysql.clusterj.core.util.I18NHelper;
 import com.mysql.clusterj.core.util.Logger;
 import com.mysql.clusterj.core.util.LoggerFactoryService;
+import com.mysql.clusterj.tie.DbImpl.BufferManager;
 
 import com.mysql.ndbjtie.ndbapi.NdbErrorConst;
 import com.mysql.ndbjtie.ndbapi.NdbIndexOperation;
@@ -103,10 +104,13 @@ class ClusterTransactionImpl implements 
     /** The transaction id to join this transaction to */
     private String joinTransactionId;
 
+    private BufferManager bufferManager;
+
     public ClusterTransactionImpl(DbImpl db, Dictionary ndbDictionary, String joinTransactionId) {
         this.db = db;
         this.ndbDictionary = ndbDictionary;
         this.joinTransactionId = joinTransactionId;
+        this.bufferManager = db.getBufferManager();
     }
 
     public void close() {
@@ -453,4 +457,8 @@ class ClusterTransactionImpl implements 
         this.autocommit = autocommit;
     }
 
+    public BufferManager getBufferManager() {
+        return bufferManager;
+    }
+
 }

=== modified file 'clusterj-tie/src/main/java/com/mysql/clusterj/tie/DbImpl.java'
--- a/clusterj-tie/src/main/java/com/mysql/clusterj/tie/DbImpl.java	2010-09-20 19:49:26 +0000
+++ b/clusterj-tie/src/main/java/com/mysql/clusterj/tie/DbImpl.java	2010-10-05 06:12:02 +0000
@@ -19,6 +19,7 @@
 package com.mysql.clusterj.tie;
 
 import java.nio.ByteBuffer;
+import java.nio.CharBuffer;
 import java.util.List;
 
 import com.mysql.ndbjtie.ndbapi.Ndb;
@@ -71,6 +72,9 @@ class DbImpl implements com.mysql.cluste
     /** The partition key scratch buffer */
     private ByteBuffer partitionKeyScratchBuffer = ByteBuffer.allocateDirect(10000);
 
+    /** The BufferManager for this instance, used for all operations for the session */
+    private BufferManager bufferManager = new BufferManager();
+
     /** The NdbDictionary for this Ndb */
     private Dictionary ndbDictionary;
 
@@ -228,4 +232,133 @@ class DbImpl implements com.mysql.cluste
         throw new ClusterJFatalInternalException("Not Implemented");
     }
 
+    /** Get the buffer manager for this DbImpl. All operations that need byte buffers
+     * use this instance to manage the shared buffers.
+     * @return the buffer manager
+     */
+    public BufferManager getBufferManager() {
+        return bufferManager;
+    }
+
+    public class BufferManager {
+        /** String byte buffer initial size */
+        public static final int STRING_BYTE_BUFFER_INITIAL_SIZE = 1000;
+
+        /** String byte buffer current size */
+        private int stringByteBufferCurrentSize = STRING_BYTE_BUFFER_INITIAL_SIZE;
+
+        /** Buffers for String encoding; reused for each String column in the operation.
+         * These buffers share common data but have their own position and limit. */
+        ByteBuffer stringByteBuffer = null;
+        CharBuffer stringCharBuffer = null;
+
+        /** String storage buffer initial size (used for non-primitive output data) */
+        public static final int STRING_STORAGE_BUFFER_INITIAL_SIZE = 500;
+
+        /** Shared buffer for string output operations */
+        private ByteBuffer stringStorageBuffer = ByteBuffer.allocateDirect(STRING_STORAGE_BUFFER_INITIAL_SIZE);
+
+        /** Result data buffer initial size */
+        private static final int RESULT_DATA_BUFFER_INITIAL_SIZE = 8000;
+
+        /** Buffer to hold result data */
+        private ByteBuffer resultDataBuffer = ByteBuffer.allocateDirect(RESULT_DATA_BUFFER_INITIAL_SIZE);
+
+        /** Guarantee the size of the string storage buffer to be a minimum size. If the current
+         * string storage buffer is not big enough, allocate a bigger one. The current buffer
+         * will be garbage collected.
+         * @param size the minimum size required
+         */
+        public void guaranteeStringStorageBufferSize(int sizeNeeded) {
+            if (sizeNeeded > stringStorageBuffer.capacity()) {
+                logger.warn(local.message("WARN_Reallocated_Byte_Buffer",
+                        "string storage", stringStorageBuffer.capacity(), sizeNeeded));
+                // the existing shared buffer will be garbage collected
+                stringStorageBuffer = ByteBuffer.allocateDirect(sizeNeeded);
+            }
+        }
+
+        /** Copy the contents of the parameter String into a reused string buffer.
+         * The ByteBuffer can subsequently be encoded into a ByteBuffer.
+         * @param value the string
+         * @return the byte buffer with the String in it
+         */
+        public ByteBuffer copyStringToByteBuffer(String value) {
+            if (value == null) {
+                stringByteBuffer.limit(0);
+                return stringByteBuffer;
+            }
+            int sizeNeeded = value.length() * 2;
+            guaranteeStringByteBufferSize(sizeNeeded);
+            stringCharBuffer.append(value);
+            // characters in java are always two bytes (UCS-16)
+            stringByteBuffer.limit(stringCharBuffer.position() * 2);
+            return stringByteBuffer;
+        }
+
+        /** Reset the string storage buffer so it can be used for another operation.
+         * 
+         */
+        public void clearStringStorageBuffer() {
+            stringStorageBuffer.clear();
+        }
+
+        public ByteBuffer getStringStorageBuffer(int sizeNeeded) {
+            guaranteeStringStorageBufferSize(sizeNeeded);
+            return stringStorageBuffer;
+        }
+
+        public ByteBuffer getStringByteBuffer(int sizeNeeded) {
+            guaranteeStringByteBufferSize(sizeNeeded);
+            return stringByteBuffer;
+        }
+
+        /** Guarantee the size of the string byte buffer to be a minimum size. If the current
+         * string byte buffer is not big enough, allocate a bigger one. The current buffer
+         * will be garbage collected.
+         * @param size the minimum size required
+         */
+        protected void guaranteeStringByteBufferSize(int sizeNeeded) {
+            if (sizeNeeded > stringByteBufferCurrentSize) {
+                stringByteBufferCurrentSize = sizeNeeded;
+                stringByteBuffer = ByteBuffer.allocateDirect(stringByteBufferCurrentSize);
+                stringCharBuffer = stringByteBuffer.asCharBuffer();
+            }
+            if (stringByteBuffer == null) {
+                stringByteBuffer = ByteBuffer.allocateDirect(stringByteBufferCurrentSize);
+                stringCharBuffer = stringByteBuffer.asCharBuffer();
+            } else {
+                stringByteBuffer.clear();
+                stringCharBuffer.clear();
+            }
+        }
+
+        /** Get the string char buffer. This buffer is paired with the string byte buffer.
+         * They share the same data but have independent position and limit.
+         * @return the string char buffer
+         */
+        public CharBuffer getStringCharBuffer() {
+            return stringCharBuffer;
+        }
+
+        /** Get the result data buffer. This buffer is used to hold the result of a
+         * key or scan operation.
+         * @param sizeNeeded the size that the buffer must be able to hold
+         * @return the result data buffer
+         */
+        public ByteBuffer getResultDataBuffer(int sizeNeeded) {
+            if (sizeNeeded > resultDataBuffer.capacity()) {
+                if (sizeNeeded > resultDataBuffer.capacity()) {
+                    logger.warn(local.message("WARN_Reallocated_Byte_Buffer",
+                            "result data", resultDataBuffer.capacity(), sizeNeeded));
+                }
+                // the existing result data buffer will be garbage collected
+                resultDataBuffer = ByteBuffer.allocateDirect(sizeNeeded);
+            }
+            resultDataBuffer.clear();
+            return resultDataBuffer;
+        }
+
+    }
+
 }

=== modified file 'clusterj-tie/src/main/java/com/mysql/clusterj/tie/OperationImpl.java'
--- a/clusterj-tie/src/main/java/com/mysql/clusterj/tie/OperationImpl.java	2010-09-30 22:26:24 +0000
+++ b/clusterj-tie/src/main/java/com/mysql/clusterj/tie/OperationImpl.java	2010-10-05 06:12:02 +0000
@@ -21,7 +21,6 @@ package com.mysql.clusterj.tie;
 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.nio.ByteBuffer;
-import java.nio.CharBuffer;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
@@ -36,6 +35,7 @@ import com.mysql.clusterj.core.store.Tab
 import com.mysql.clusterj.core.util.I18NHelper;
 import com.mysql.clusterj.core.util.Logger;
 import com.mysql.clusterj.core.util.LoggerFactoryService;
+import com.mysql.clusterj.tie.DbImpl.BufferManager;
 
 import com.mysql.ndbjtie.mysql.CharsetMapConst;
 import com.mysql.ndbjtie.ndbapi.NdbBlob;
@@ -55,21 +55,6 @@ class OperationImpl implements Operation
     static final Logger logger = LoggerFactoryService.getFactory()
             .getInstance(OperationImpl.class);
 
-    /** String storage buffer initial size (used for non-primitive output data) 
-     * including two byte length field to be sent directly to ndb api.*/
-    public static final int STRING_STORAGE_BUFFER_INITIAL_SIZE = 502;
-
-    /** String byte buffer initial size */
-    public static final int STRING_BYTE_BUFFER_INITIAL_SIZE = 1000;
-
-    /** String byte buffer current size */
-    private int stringByteBufferCurrentSize = STRING_BYTE_BUFFER_INITIAL_SIZE;
-
-    /** Scratch buffers for String encoding; reused for each String column in the operation.
-     * These buffers share common data but have their own position and limit. */
-    ByteBuffer stringByteBuffer = null;
-    CharBuffer stringCharBuffer = null;
-
     private NdbOperation ndbOperation;
 
     protected List<Column> storeColumns = new ArrayList<Column>();
@@ -88,12 +73,11 @@ class OperationImpl implements Operation
     /** The lengths of fields in the buffer for each column (may be null for non-read operations) */
     protected int[] lengths;
 
-    /** Shared buffer for output operations, with a minimum size of 8 */
-    protected ByteBuffer stringStorageBuffer = ByteBuffer.allocateDirect(STRING_STORAGE_BUFFER_INITIAL_SIZE);
-
     /** The maximum length of any column in this operation */
     protected int maximumColumnLength;
 
+    protected BufferManager bufferManager;
+
     /** Constructor used for insert and delete operations that do not need to read data.
      * 
      * @param operation the operation
@@ -102,6 +86,7 @@ class OperationImpl implements Operation
     public OperationImpl(NdbOperation operation, ClusterTransactionImpl transaction) {
         this.ndbOperation = operation;
         this.clusterTransaction = transaction;
+        this.bufferManager = clusterTransaction.getBufferManager();
     }
 
     /** Constructor used for read operations. The table is used to obtain data used
@@ -111,8 +96,7 @@ class OperationImpl implements Operation
      * @param transaction the transaction
      */
     public OperationImpl(Table storeTable, NdbOperation operation, ClusterTransactionImpl transaction) {
-        this.ndbOperation = operation;
-        this.clusterTransaction = transaction;
+        this(operation, transaction);
         TableImpl tableImpl = (TableImpl)storeTable;
         this.maximumColumnId = tableImpl.getMaximumColumnId();
         this.bufferSize = tableImpl.getBufferSize();
@@ -182,8 +166,9 @@ class OperationImpl implements Operation
     }
 
     public void equalString(Column storeColumn, String value) {
-        ByteBuffer buffer = Utility.convertValue(storeColumn, value);
-        int returnCode = ndbOperation.equal(storeColumn.getName(), buffer);
+        ByteBuffer stringStorageBuffer = copyStringToByteBuffer(storeColumn, value);
+        int returnCode = ndbOperation.equal(storeColumn.getName(), stringStorageBuffer);
+        bufferManager.clearStringStorageBuffer();
         handleError(returnCode, ndbOperation);
     }
 
@@ -217,7 +202,7 @@ class OperationImpl implements Operation
     public ResultData resultData() {
         if (logger.isDetailEnabled()) logger.detail("storeColumns: " + Arrays.toString(storeColumns.toArray()));
         ResultDataImpl result = new ResultDataImpl(ndbOperation, storeColumns, maximumColumnId, bufferSize,
-                offsets, lengths, maximumColumnLength);
+                offsets, lengths, maximumColumnLength, bufferManager);
         clusterTransaction.executeNoCommit(false, true);
         NdbErrorConst error = ndbOperation.getNdbError();
         int errorCode = error.code();
@@ -289,13 +274,20 @@ class OperationImpl implements Operation
     }
 
     public void setString(Column storeColumn, String value) {
-        ByteBuffer inputByteBuffer = copyStringToByteBuffer(value);
+        ByteBuffer stringStorageBuffer = copyStringToByteBuffer(storeColumn, value);
+        int returnCode = ndbOperation.setValue(storeColumn.getColumnId(), stringStorageBuffer);
+        bufferManager.clearStringStorageBuffer();
+        handleError(returnCode, ndbOperation);
+    }
+
+    private ByteBuffer copyStringToByteBuffer(Column storeColumn, String value) {
+        ByteBuffer inputByteBuffer = bufferManager.copyStringToByteBuffer(value);
         // assume output size is not larger than input size
         int sizeNeeded = inputByteBuffer.limit() - inputByteBuffer.position();
         boolean done = false;
         int offset = storeColumn.getPrefixLength();
+        ByteBuffer stringStorageBuffer = bufferManager.getStringStorageBuffer(sizeNeeded);
         while (!done) {
-            guaranteeStringStorageBufferSize(sizeNeeded);
             int returnCode = Utility.encode(storeColumn.getCharsetNumber(), offset,
                     sizeNeeded, inputByteBuffer, stringStorageBuffer);
             switch (returnCode) {
@@ -312,9 +304,7 @@ class OperationImpl implements Operation
                         returnCode));
             }
         }
-        int returnCode = ndbOperation.setValue(storeColumn.getColumnId(), stringStorageBuffer);
-        resetStringStorageBuffer();
-        handleError(returnCode, ndbOperation);
+        return stringStorageBuffer;
     }
 
     protected void handleError(int returnCode, NdbOperation ndbOperation) {
@@ -333,50 +323,4 @@ class OperationImpl implements Operation
         }
     }
 
-    /** Guarantee the size of the string storage buffer to be a minimum size. If the current
-     * string storage buffer is not big enough, allocate a bigger one. The current buffer
-     * will be garbage collected.
-     * @param size the minimum size required
-     */
-    protected void guaranteeStringStorageBufferSize(int sizeNeeded) {
-        if (sizeNeeded > stringStorageBuffer.capacity()) {
-            // the existing shared buffer will be garbage collected
-            stringStorageBuffer = ByteBuffer.allocateDirect(sizeNeeded);
-        }
-    }
-
-    /** Reset the string storage buffer so it can be used for another operation.
-     * 
-     */
-    private void resetStringStorageBuffer() {
-        int capacity = stringStorageBuffer.capacity();
-        stringStorageBuffer.position(0);
-        stringStorageBuffer.limit(capacity);
-    }
-
-    /** Copy the contents of the parameter String into a reused string buffer.
-     * The ByteBuffer can subsequently be encoded into a ByteBuffer.
-     * @param value the string
-     * @return the byte buffer with the String in it
-     */
-    private ByteBuffer copyStringToByteBuffer(String value) {
-        int sizeNeeded = value.length() * 2;
-        if (sizeNeeded > stringByteBufferCurrentSize) {
-            stringByteBufferCurrentSize = sizeNeeded;
-            stringByteBuffer = ByteBuffer.allocateDirect(sizeNeeded);
-            stringCharBuffer = stringByteBuffer.asCharBuffer();
-        }
-        if (stringByteBuffer == null) {
-            stringByteBuffer = ByteBuffer.allocateDirect(STRING_BYTE_BUFFER_INITIAL_SIZE);
-            stringCharBuffer = stringByteBuffer.asCharBuffer();
-        } else {
-            stringByteBuffer.clear();
-            stringCharBuffer.clear();
-        }
-        stringCharBuffer.append(value);
-        // characters in java are always two bytes (UCS-16)
-        stringByteBuffer.limit(stringCharBuffer.position() * 2);
-        return stringByteBuffer;
-    }
-
 }

=== modified file 'clusterj-tie/src/main/java/com/mysql/clusterj/tie/ResultDataImpl.java'
--- a/clusterj-tie/src/main/java/com/mysql/clusterj/tie/ResultDataImpl.java	2010-09-30 22:26:24 +0000
+++ b/clusterj-tie/src/main/java/com/mysql/clusterj/tie/ResultDataImpl.java	2010-10-05 06:12:02 +0000
@@ -36,6 +36,7 @@ import com.mysql.clusterj.core.store.Res
 import com.mysql.clusterj.core.util.I18NHelper;
 import com.mysql.clusterj.core.util.Logger;
 import com.mysql.clusterj.core.util.LoggerFactoryService;
+import com.mysql.clusterj.tie.DbImpl.BufferManager;
 
 import com.mysql.ndbjtie.ndbapi.NdbBlob;
 import com.mysql.ndbjtie.ndbapi.NdbOperation;
@@ -68,7 +69,7 @@ class ResultDataImpl implements ResultDa
     /** The flag indicating that there are no more results */
     private boolean nextDone;
 
-    /** The ByteBuffer containing the results */
+    /** The ByteBuffer containing the results, obtained from buffer manager */
     private ByteBuffer byteBuffer = null;
 
     /** Offsets into the ByteBuffer containing the results */
@@ -80,15 +81,8 @@ class ResultDataImpl implements ResultDa
     /** The Columns in this result */
     private final Column[] storeColumns;
 
-    /** String byte buffer current size */
-    private int stringByteBufferCurrentSize = 0;
-
-    /** String byte buffer minimum size if a buffer is needed for this result */
-    private int stringByteBufferMinimumSize;
-
-    /** Scratch buffers for String decoding; reused for each String column in the operation. */
-    private ByteBuffer stringByteBuffer = null;
-    private CharBuffer stringCharBuffer = null;
+    /** The buffer manager */
+    private BufferManager bufferManager;
 
     /** Construct the ResultDataImpl based on an NdbOperation, a list of columns
      * to include in the result, and the pre-computed buffer layout for the result.
@@ -100,15 +94,16 @@ class ResultDataImpl implements ResultDa
      * @param lengths the array of lengths indexed by column id
      */
     public ResultDataImpl(NdbOperation ndbOperation, List<Column> storeColumns,
-            int maximumColumnId, int bufferSize, int[] offsets, int[] lengths, int maximumLength) {
+            int maximumColumnId, int bufferSize, int[] offsets, int[] lengths, int maximumLength,
+            BufferManager bufferManager) {
         this.ndbOperation = ndbOperation;
+        this.bufferManager = bufferManager;
         // save the column list
         this.storeColumns = storeColumns.toArray(new Column[storeColumns.size()]);
         this.offsets = offsets;
         this.lengths = lengths;
-        byteBuffer = ByteBuffer.allocateDirect(bufferSize);
+        byteBuffer = bufferManager.getResultDataBuffer(bufferSize);
         byteBuffer.order(ByteOrder.nativeOrder());
-        stringByteBufferMinimumSize = maximumLength;
         // iterate the list of store columns and allocate an NdbRecAttr (via getValue) for each
         ndbRecAttrs = new NdbRecAttr[maximumColumnId + 1];
         for (Column storeColumn: storeColumns) {
@@ -258,14 +253,16 @@ class ResultDataImpl implements ResultDa
         byteBuffer.limit(offset + actualLength);
 
         // most character sets decode to twice the size; some up to four times
-        guaranteeStringByteBufferSize(actualLength * 4);
+        ByteBuffer inputByteBuffer = bufferManager.getStringByteBuffer(actualLength * 4);
+        CharBuffer outputCharBuffer = bufferManager.getStringCharBuffer();
         String result = Utility.decode(byteBuffer, storeColumn.getCharsetNumber(),
-                stringByteBuffer, stringCharBuffer);
+                inputByteBuffer, outputCharBuffer);
         if (result == null) {
             // buffer not big enough; try again with a somewhat bigger buffer
-            guaranteeStringByteBufferSize(actualLength * 6);
+            inputByteBuffer = bufferManager.getStringByteBuffer(actualLength * 6);
+            outputCharBuffer = bufferManager.getStringCharBuffer();
             result = Utility.decode(byteBuffer, storeColumn.getCharsetNumber(),
-                    stringByteBuffer, stringCharBuffer);
+                    inputByteBuffer, outputCharBuffer);
             if (result == null) {
                 throw new ClusterJFatalInternalException(
                         local.message("ERR_Decode_Buffer_Too_Small", storeColumn.getCharsetNumber(),
@@ -441,19 +438,4 @@ class ResultDataImpl implements ResultDa
         return storeColumns;
     }
 
-    /** Guarantee the size of the string byte buffer to be a minimum size. If the current
-     * string byte buffer is not big enough, allocate a bigger one. The current buffer
-     * will be garbage collected.
-     * @param size the minimum size required
-     */
-    protected void guaranteeStringByteBufferSize(int sizeNeeded) {
-        if (sizeNeeded > stringByteBufferCurrentSize) {
-            int allocateSize = Math.max(sizeNeeded, stringByteBufferMinimumSize);
-            // the existing shared buffer will be garbage collected
-            stringByteBufferCurrentSize = allocateSize;
-            stringByteBuffer = ByteBuffer.allocateDirect(allocateSize);
-            stringCharBuffer = stringByteBuffer.asCharBuffer();
-        }
-    }
-
 }

=== modified file 'clusterj-tie/src/main/java/com/mysql/clusterj/tie/ScanOperationImpl.java'
--- a/clusterj-tie/src/main/java/com/mysql/clusterj/tie/ScanOperationImpl.java	2010-09-30 22:26:24 +0000
+++ b/clusterj-tie/src/main/java/com/mysql/clusterj/tie/ScanOperationImpl.java	2010-10-05 06:12:02 +0000
@@ -68,7 +68,7 @@ class ScanOperationImpl extends Operatio
     @Override
     public ResultData resultData() {
         ResultData result = new ScanResultDataImpl(ndbScanOperation, storeColumns,
-                maximumColumnId, bufferSize, offsets, lengths, maximumColumnLength);
+                maximumColumnId, bufferSize, offsets, lengths, maximumColumnLength, bufferManager);
         clusterTransaction.executeNoCommit(false, true);
         return result;
     }

=== modified file 'clusterj-tie/src/main/java/com/mysql/clusterj/tie/ScanResultDataImpl.java'
--- a/clusterj-tie/src/main/java/com/mysql/clusterj/tie/ScanResultDataImpl.java	2010-09-30 22:26:24 +0000
+++ b/clusterj-tie/src/main/java/com/mysql/clusterj/tie/ScanResultDataImpl.java	2010-10-05 06:12:02 +0000
@@ -25,6 +25,7 @@ import com.mysql.clusterj.core.store.Col
 import com.mysql.clusterj.core.util.I18NHelper;
 import com.mysql.clusterj.core.util.Logger;
 import com.mysql.clusterj.core.util.LoggerFactoryService;
+import com.mysql.clusterj.tie.DbImpl.BufferManager;
 
 import com.mysql.ndbjtie.ndbapi.NdbScanOperation;
 
@@ -50,8 +51,10 @@ class ScanResultDataImpl extends ResultD
     protected final int CACHE_EMPTY = 2;
 
     public ScanResultDataImpl(NdbScanOperation ndbScanOperation, List<Column> storeColumns,
-            int maximumColumnId, int bufferSize, int[] offsets, int[] lengths, int maximumColumnLength) {
-        super(ndbScanOperation, storeColumns, maximumColumnId, bufferSize, offsets, lengths, maximumColumnLength);
+            int maximumColumnId, int bufferSize, int[] offsets, int[] lengths, int maximumColumnLength,
+            BufferManager bufferManager) {
+        super(ndbScanOperation, storeColumns, maximumColumnId, bufferSize, offsets, lengths, maximumColumnLength,
+                bufferManager);
         this.ndbScanOperation = ndbScanOperation;
     }
 

=== modified file 'clusterj-tie/src/main/resources/com/mysql/clusterj/tie/Bundle.properties'
--- a/clusterj-tie/src/main/resources/com/mysql/clusterj/tie/Bundle.properties	2010-09-20 19:49:26 +0000
+++ b/clusterj-tie/src/main/resources/com/mysql/clusterj/tie/Bundle.properties	2010-10-05 06:12:02 +0000
@@ -46,3 +46,4 @@ ERR_Unknown_Lock_Mode:The lock mode {0} 
 WARN_Recode_Buffer_Too_Small:The recode buffer size {0} had to be increased (doubled).
 ERR_Transaction_Start_Failed:Transaction start failed with table {0}, \
 buffer position {1}, buffer limit {2}, buffer capacity {3}, length {4}.
+WARN_Reallocated_Byte_Buffer:Reallocated {0} buffer size from {1} to {2}.


Attachment: [text/bzr-bundle] bzr/craig.russell@oracle.com-20101005061202-naimvktqh73zb3v2.bundle
Thread
bzr commit into clusterj branch (Craig.Russell:334)Craig L Russell5 Oct