Is the database cursor not working correctly?

Question

Hello, all
I got a problem when retrieving all the key/data pairs from a database by using the cursor. After some debugging, I realized that the problem is due to the reuse of a DatabaseEntry object to get data from multiple entries. For example, there are two records in a database
key | data
1 "aaaaaaaa"
2 "bbbb"
If I want to know the length of data for each key/data pair, I expected the returning result would be:
the length of key 1's data is 8
the length of key 1's data is 5
However, when I use a cursor to retrieve the result back, it returns the following result:
the length of key 1's data is 8
the length of key 1's data is 8
The code to reproduce the incorrect result is attached below. One way to fix this code is to new a DatabaseEntry object within the loop. But the following code come from the berkeley db documentation (http://www.oracle.com/technology/documentation/berkeley-db/db/gsg/JAVA/Positioning.html). So I think it is good to report this problem.
OS: ubuntu
DB version: 4.7
Programming language: Java
import com.sleepycat.db.*;
import java.io.*;
public class TestDB {
     public static final int byteArrayToInt(byte [] b) {
          return (b[0] << 24)
          + ((b[1] & 0xFF) << 16)
          + ((b[2] & 0xFF) << 8)
          + (b[3] & 0xFF);
     public static final byte[] intToByteArray(int value) {
          return new byte[]{
                    (byte)(value >>> 24), (byte)(value >> 16 & 0xff), (byte)(value >> 8 & 0xff), (byte)(value & 0xff) };
     public static void main(String[] args) {
          Database myDatabase = null;
          Cursor cursor = null;     
          try {
          // Open the database. Create it if it does not already exist.
          DatabaseConfig dbConfig = new DatabaseConfig();
          dbConfig.setAllowCreate(true);
          dbConfig.setType(DatabaseType.HASH);
          myDatabase = new Database ("/tmp/cosmos/sampleDatabase.db",
          null,
          dbConfig);
          int key1 = 0;
          byte[] data1 = "aaaaaaaa".getBytes();          
          DatabaseEntry dbKey1 = new DatabaseEntry(intToByteArray(key1));
          DatabaseEntry dbData1 = new DatabaseEntry(data1);
          myDatabase.put(null, dbKey1, dbData1);
          int key2 = 1;
          byte[] data2 = "bbbbb".getBytes();           
          DatabaseEntry dbKey2 = new DatabaseEntry(intToByteArray(key2));
          DatabaseEntry dbData2 = new DatabaseEntry(data2);
          myDatabase.put(null, dbKey2, dbData2);
          cursor = myDatabase.openCursor(null, null);
          DatabaseEntry foundKey = new DatabaseEntry();
          DatabaseEntry foundData = new DatabaseEntry();
          while (cursor.getNext(foundKey, foundData, LockMode.DEFAULT) ==
          OperationStatus.SUCCESS) {
               int key = Util.byteArrayToInt(foundKey.getData());
          System.out.println("the length of Key " + key + "'data is " + foundData.getData().length);
          } catch (DatabaseException dbe) {
          // Exception handling goes here
          } catch (FileNotFoundException fnfe) {
          // Exception handling goes here
          } finally {
               try {
                    cursor.close();
                    myDatabase.close();
               } catch (DatabaseException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
}

Answer 1

Hi,
When a DatabaseEntry is reused when doing retrieval we internally use realloc to reuse the memory, hence the behavior you've observed.
You should use the DatabaseEntry.getSize() method to determine the byte size of the data array. This will provide the correct results you're looking for, as after retrieving an entry we internally set in the size of the retrieved DBT:
System.out.println("the length of Key " + key + "'data is " + foundData.getSize());
Regards,
Andrei