Physical file of the "Database" object keep growing

Question

Hello,
My Application is using BDB. Version 4.3.29.
We are using the Database object for saving our byte array data to BDB(see the code below)
The written data is initialized by: Byte[] Data = new byte[size].
And we always use the same key for the insert operation. By the BDB API it should overwrite the existing entry, correct me if I’m wrong)
The data size may vary, I.e. it can grow, or decrease.
After monitoring the physical file that sits on dist, we have noticed that the physical file only grows, but never decrease its size. Even when the written data is of a 0 length.
Please explain the issue. What are we doing wrong? Or what additional parameters should be used in order for the phisical file to change its size.i.e. decrease it.
Thank you in advance.
Shira Faigenbaum
Opening the BDB:
DataBase m_dataBase = m_DBEnv().openDatabase(transaction, tablePath + File.separator + m_name, null, m_DatabaseConfig);
The code that we have, for the PUT operation:
DatabaseEntry keyDbt = new DatabaseEntry(new byte[4]);
keyDbt.setSize(4);
keyDbt.setUserBuffer(4, true);
keyDbt.setRecordNumber(DATA_KEY);
DatabaseEntry dataDbt = new DatabaseEntry(data);
dataDbt.setSize(data.length);
dataDbt.setUserBuffer(length, true);
synchronized (transaction)
m_dataBase.put(transaction.getTransaction(), keyDbt, dataDbt);
}

Answer 1

Hi,
There is a bit a lot of code, but here is the program.
thanks
Shira
public class BDBsizeNotReducingExxample
     Environment m_dbEnv;
     private Database m_dataBase = null;
     private byte[] m_serializationBuffer = new byte[256];
     private Object m_data = null;
     public static void main(String[] args)
          BDBsizeNotReducingExxample DbsizeNotReducingExxample = new BDBsizeNotReducingExxample();
          DbsizeNotReducingExxample.opendbEnv();
          DbsizeNotReducingExxample.openDB();
          DbsizeNotReducingExxample.saveData();
     private void opendbEnv()
          try
               EnvironmentConfig ec = new EnvironmentConfig();
               ec.setCacheSize(16 * 1024 * 1024);
ec.setErrorStream(new LogOutputStream());
ec.setVerboseDeadlock(true);
               ec.setVerboseWaitsFor(true);           
ec.setVerboseRecovery(true);      
          ec.setMaxLockers(1024);
               ec.setMaxLocks(100000);                ec.setMaxLockObjects(100000);               ec.setTxnMaxActive(20);
               ec.setLogRegionSize(600 * 1024);     
ec.setLockDetectMode(LockDetectMode.DEFAULT);
ec.setAllowCreate(true);
               ec.setTransactional(true);
          ec.setRunRecovery(true);          ec.setInitializeCache(true);
               ec.setInitializeLocking(true);     ec.setInitializeLogging(true);
               File f = new File("/Application/Persistency");
               //open the environment try to open data base without fatal recovery
               try
                    m_dbEnv = new Environment(f, ec);
               catch (RunRecoveryException dbrre_1)
                    ec.setRunFatalRecovery(true);
                    m_dbEnv = new Environment(f, ec);
               //archive and checkpoint at gatherer start up
               CheckpointConfig cpc = new CheckpointConfig();
               cpc.setForce(true);
               m_dbEnv.checkpoint(cpc);
          catch (Exception e)
               PersistencyUtils.handleFatalException(e);
     private class LogOutputStream extends OutputStream
          public void write(int b) throws IOException
               //some clss just to print the errors
     private void openDB()
          DatabaseEntry keyDbt = new DatabaseEntry(new byte[4]);
     keyDbt.setSize(4);
     keyDbt.setUserBuffer(4, true);
     keyDbt.setRecordNumber(0);
     DatabaseEntry dataDbt = new DatabaseEntry();
     dataDbt.setReuseBuffer(false);
try
     String tablePath = "/Application/Persistency/";
     DirUtil.mkdirs(new File(tablePath));
     PersistencyUtils.verifyFreeDiskSpace();
Transaction transaction = m_dbEnv.beginTransaction(null, null);
//DatabaseConfig use btree
m_dataBase = m_dbEnv.openDatabase(transaction, tablePath + "/Data", null, PersistencyUtils.getDatabaseConfig());
if (m_dataBase.get(transaction, keyDbt, dataDbt, null) != OperationStatus.SUCCESS)
     dataDbt = null;
transaction.commit();
catch (Exception e)
     PersistencyUtils.handleFatalException(e);
if (dataDbt != null)
     byte[] data = dataDbt.getData();
     if (data != null)
          m_serializer.deserialize(m_data, data, 0, data.length);
private void saveData()
int length = m_serializer.serialize(m_data, m_serializationBuffer, 0);
//this function changes the size of the m_serializationBuffer, increase and decrease its size!!!
adjustSerializationBufferToTheRealLength(m_serializationBuffer, length);
DatabaseEntry keyDbt = new DatabaseEntry(new byte[4]);
keyDbt.setSize(4);
keyDbt.setUserBuffer(4, true);
keyDbt.setRecordNumber(0);
DatabaseEntry dataDbt = new DatabaseEntry(m_serializationBuffer);
dataDbt.setSize(length);
dataDbt.setUserBuffer(length, true);
synchronized (currentTransaction)
     m_dataBase.put(transaction.getTransaction(), keyDbt, dataDbt);
}