Exemple #1
0
 public void ensureHeavy(PropertyBlock block) {
   if (block.getType() == PropertyType.STRING) {
     if (block.isLight()) {
       Collection<DynamicRecord> stringRecords =
           stringPropertyStore.getLightRecords(block.getSingleValueLong());
       for (DynamicRecord stringRecord : stringRecords) {
         stringRecord.setType(PropertyType.STRING.intValue());
         block.addValueRecord(stringRecord);
       }
     }
     for (DynamicRecord stringRecord : block.getValueRecords()) {
       stringPropertyStore.ensureHeavy(stringRecord);
     }
   } else if (block.getType() == PropertyType.ARRAY) {
     if (block.isLight()) {
       Collection<DynamicRecord> arrayRecords =
           arrayPropertyStore.getLightRecords(block.getSingleValueLong());
       for (DynamicRecord arrayRecord : arrayRecords) {
         arrayRecord.setType(PropertyType.ARRAY.intValue());
         block.addValueRecord(arrayRecord);
       }
     }
     for (DynamicRecord arrayRecord : block.getValueRecords()) {
       arrayPropertyStore.ensureHeavy(arrayRecord);
     }
   }
 }
Exemple #2
0
 @Override
 public void logAllWindowPoolStats(StringLogger.LineLogger logger) {
   super.logAllWindowPoolStats(logger);
   propertyKeyTokenStore.logAllWindowPoolStats(logger);
   logger.logLine(stringPropertyStore.getWindowPoolStats().toString());
   logger.logLine(arrayPropertyStore.getWindowPoolStats().toString());
 }
Exemple #3
0
 @Override
 public void makeStoreOk() {
   propertyKeyTokenStore.makeStoreOk();
   stringPropertyStore.makeStoreOk();
   arrayPropertyStore.makeStoreOk();
   super.makeStoreOk();
 }
Exemple #4
0
 @Override
 public void logVersions(StringLogger.LineLogger logger) {
   super.logVersions(logger);
   propertyKeyTokenStore.logVersions(logger);
   stringPropertyStore.logVersions(logger);
   arrayPropertyStore.logVersions(logger);
 }
 @Override
 protected void unsetRecovered() {
   super.unsetRecovered();
   stringPropertyStore.unsetRecovered();
   propertyIndexStore.unsetRecovered();
   arrayPropertyStore.unsetRecovered();
 }
Exemple #6
0
 @Override
 protected void setRecovered() {
   super.setRecovered();
   stringPropertyStore.setRecovered();
   propertyKeyTokenStore.setRecovered();
   arrayPropertyStore.setRecovered();
 }
 public PropertyRecord getRecord(long id) {
   PropertyRecord record;
   PersistenceWindow window = acquireWindow(id, OperationType.READ);
   try {
     record = getRecord(id, window, RecordLoad.NORMAL);
   } finally {
     releaseWindow(window);
   }
   for (PropertyBlock block : record.getPropertyBlocks()) {
     // assert block.inUse();
     if (block.getType() == PropertyType.STRING) {
       Collection<DynamicRecord> stringRecords =
           stringPropertyStore.getLightRecords(block.getSingleValueLong());
       for (DynamicRecord stringRecord : stringRecords) {
         stringRecord.setType(PropertyType.STRING.intValue());
         block.addValueRecord(stringRecord);
       }
     } else if (block.getType() == PropertyType.ARRAY) {
       Collection<DynamicRecord> arrayRecords =
           arrayPropertyStore.getLightRecords(block.getSingleValueLong());
       for (DynamicRecord arrayRecord : arrayRecords) {
         arrayRecord.setType(PropertyType.ARRAY.intValue());
         block.addValueRecord(arrayRecord);
       }
     }
   }
   return record;
 }
 @Override
 public void flushAll() {
   stringPropertyStore.flushAll();
   propertyIndexStore.flushAll();
   arrayPropertyStore.flushAll();
   super.flushAll();
 }
 @Override
 protected void closeStorage() {
   if (nameStore != null) {
     nameStore.close();
     nameStore = null;
   }
 }
 @Override
 public void makeStoreOk() {
   propertyIndexStore.makeStoreOk();
   stringPropertyStore.makeStoreOk();
   arrayPropertyStore.makeStoreOk();
   super.makeStoreOk();
 }
 @Override
 public void logIdUsage(StringLogger.LineLogger logger) {
   super.logIdUsage(logger);
   propertyIndexStore.logIdUsage(logger);
   stringPropertyStore.logIdUsage(logger);
   arrayPropertyStore.logIdUsage(logger);
 }
 @Override
 public void rebuildIdGenerators() {
   propertyIndexStore.rebuildIdGenerators();
   stringPropertyStore.rebuildIdGenerators();
   arrayPropertyStore.rebuildIdGenerators();
   super.rebuildIdGenerators();
 }
 @Override
 public List<WindowPoolStats> getAllWindowPoolStats() {
   List<WindowPoolStats> list = new ArrayList<WindowPoolStats>();
   list.add(nameStore.getWindowPoolStats());
   list.add(getWindowPoolStats());
   return list;
 }
 public void makeHeavy(T record) {
   record.setIsLight(false);
   Collection<DynamicRecord> keyRecords = nameStore.getRecords(record.getNameId());
   for (DynamicRecord keyRecord : keyRecords) {
     record.addNameRecord(keyRecord);
   }
 }
 @Override
 public List<WindowPoolStats> getAllWindowPoolStats() {
   List<WindowPoolStats> list = new ArrayList<WindowPoolStats>();
   list.add(stringPropertyStore.getWindowPoolStats());
   list.add(arrayPropertyStore.getWindowPoolStats());
   list.add(getWindowPoolStats());
   return list;
 }
 private void updateDynamicRecords(List<DynamicRecord> records) {
   for (DynamicRecord valueRecord : records) {
     if (valueRecord.getType() == PropertyType.STRING.intValue()) {
       stringPropertyStore.updateRecord(valueRecord);
     } else if (valueRecord.getType() == PropertyType.ARRAY.intValue()) {
       arrayPropertyStore.updateRecord(valueRecord);
     } else {
       throw new InvalidRecordException("Unknown dynamic record" + valueRecord);
     }
   }
 }
 public void updateRecord(T record) {
   PersistenceWindow window = acquireWindow(record.getId(), OperationType.WRITE);
   try {
     updateRecord(record, window);
   } finally {
     releaseWindow(window);
   }
   if (!record.isLight()) {
     for (DynamicRecord keyRecord : record.getNameRecords()) {
       nameStore.updateRecord(keyRecord);
     }
   }
 }
 public T getRecord(int id) {
   T record;
   PersistenceWindow window = acquireWindow(id, OperationType.READ);
   try {
     record = getRecord(id, window, false);
   } finally {
     releaseWindow(window);
   }
   Collection<DynamicRecord> keyRecords = nameStore.getLightRecords(record.getNameId());
   for (DynamicRecord keyRecord : keyRecords) {
     record.addNameRecord(keyRecord);
   }
   return record;
 }
 @Override
 protected void closeStorage() {
   if (stringPropertyStore != null) {
     stringPropertyStore.close();
     stringPropertyStore = null;
   }
   if (propertyIndexStore != null) {
     propertyIndexStore.close();
     propertyIndexStore = null;
   }
   if (arrayPropertyStore != null) {
     arrayPropertyStore.close();
     arrayPropertyStore = null;
   }
 }
 /*
  * This will add the value records without checking if they are already
  * in the block - so make sure to call this after checking isHeavy() or
  * you will end up with duplicates.
  */
 public void makeHeavy(PropertyBlock record) {
   if (record.getType() == PropertyType.STRING) {
     Collection<DynamicRecord> stringRecords =
         stringPropertyStore.getLightRecords(record.getSingleValueLong());
     for (DynamicRecord stringRecord : stringRecords) {
       stringRecord.setType(PropertyType.STRING.intValue());
       record.addValueRecord(stringRecord);
     }
   } else if (record.getType() == PropertyType.ARRAY) {
     Collection<DynamicRecord> arrayRecords =
         arrayPropertyStore.getLightRecords(record.getSingleValueLong());
     for (DynamicRecord arrayRecord : arrayRecords) {
       arrayRecord.setType(PropertyType.ARRAY.intValue());
       record.addValueRecord(arrayRecord);
     }
   }
 }
Exemple #21
0
 public void makeHeavyIfLight(PropertyBlock record) {
   if (record.isLight()) {
     /*
      * This will add the value records without checking if they are already
      * in the block - so we only call this after checking isLight() or
      * else we will end up with duplicates.
      */
     if (record.getType() == PropertyType.STRING) {
       Collection<DynamicRecord> stringRecords =
           stringPropertyStore.getLightRecords(record.getSingleValueLong());
       for (DynamicRecord stringRecord : stringRecords) {
         stringRecord.setType(PropertyType.STRING.intValue());
         record.addValueRecord(stringRecord);
       }
     } else if (record.getType() == PropertyType.ARRAY) {
       Collection<DynamicRecord> arrayRecords =
           arrayPropertyStore.getLightRecords(record.getSingleValueLong());
       for (DynamicRecord arrayRecord : arrayRecords) {
         arrayRecord.setType(PropertyType.ARRAY.intValue());
         record.addValueRecord(arrayRecord);
       }
     }
   }
 }
 public void freeStringBlockId(long blockId) {
   stringPropertyStore.freeBlockId(blockId);
 }
 @Override
 public void rebuildIdGenerators() {
   nameStore.rebuildIdGenerators();
   super.rebuildIdGenerators();
 }
 public int getStringBlockSize() {
   return stringPropertyStore.getBlockSize();
 }
 public void updateIdGenerators() {
   nameStore.updateHighId();
   this.updateHighId();
 }
 private Collection<DynamicRecord> allocateStringRecords(long valueBlockId, byte[] chars) {
   return stringPropertyStore.allocateRecords(valueBlockId, chars);
 }
 public void updateIdGenerators() {
   propertyIndexStore.updateIdGenerators();
   stringPropertyStore.updateHighId();
   arrayPropertyStore.updateHighId();
   this.updateHighId();
 }
 public void freeBlockId(int id) {
   nameStore.freeBlockId(id);
 }
 @Override
 public void flushAll() {
   nameStore.flushAll();
   super.flushAll();
 }
 private long nextStringBlockId() {
   return stringPropertyStore.nextBlockId();
 }