/** * Get the underlying Transaction Manager */ public synchronized TransactionManager getTransactionManager() { checkIfClosed(); return recordFile.txnMgr; }
/** * Load name directory */ @SuppressWarnings("unchecked") private Map<String, Long> getNameDirectory() throws IOException { // retrieve directory of named hashtable long nameDirectory_recid = getRoot( NAME_DIRECTORY_ROOT ); if ( nameDirectory_recid == 0 ) { nameDirectory = new HashMap<String, Long>(); nameDirectory_recid = insert( nameDirectory ); setRoot( NAME_DIRECTORY_ROOT, nameDirectory_recid ); } else { nameDirectory = ( Map<String, Long> ) fetch( nameDirectory_recid ); } return nameDirectory; }
public void setNamedObject( String name, long recid ) throws IOException { checkIfClosed(); Map<String,Long> nameDirectory = getNameDirectory(); if ( recid == 0 ) { // remove from hashtable nameDirectory.remove( name ); } else { nameDirectory.put( name, new Long( recid ) ); } saveNameDirectory( nameDirectory ); }
public long getNamedObject( String name ) throws IOException { checkIfClosed(); Map<String,Long> nameDirectory = getNameDirectory(); Long recid = (Long) nameDirectory.get( name ); if ( recid == null ) { return 0; } return recid.longValue(); }
public synchronized void defrag() throws IOException { checkIfClosed(); commit(); final String filename2 = _filename+"_defrag"+System.currentTimeMillis(); final String filename1 = _filename; BaseRecordManager recman2 = new BaseRecordManager(filename2); recman2.disableTransactions(); byte[] bb = b.toByteArray(); recman2.forceInsert(logicalRowId, bb); recman2.commit(); recman2.setRoot(NAME_DIRECTORY_ROOT,getRoot(NAME_DIRECTORY_ROOT)); recman2.commit(); recman2.close(); close(); List<File> filesToDelete = new ArrayList<File>(); reopen();
RecordManager recman = new BaseRecordManager( name ); ( ( BaseRecordManager ) recman ).disableTransactions();
RecordManager recman = new BaseRecordManager( name ); ( (BaseRecordManager) recman ).disableTransactions(); boolean compress = value.equalsIgnoreCase("TRUE"); if(compress) ( (BaseRecordManager) recman ).setCompress(true);
/** * Creates a new instance of EventLog for a replica * * @param partitionTxn The Transaction to use * @param directoryService The DirectoryService instance * @param replicaId The replica ID * @throws IOException if we weren't able to log the event */ public ReplicaEventLog( PartitionTxn partitionTxn, DirectoryService directoryService, int replicaId ) throws IOException { PROVIDER_LOG.debug( "Creating the replication queue for replica {}", replicaId ); SchemaManager schemaManager = directoryService.getSchemaManager(); this.replicaId = replicaId; this.searchCriteria = new NotificationCriteria( schemaManager ); this.searchCriteria.setEventMask( EventType.ALL_EVENT_TYPES_MASK ); // Create the journal file, or open if already exists File replDir = directoryService.getInstanceLayout().getReplDirectory(); journalFile = new File( replDir, REPLICA_EVENT_LOG_NAME_PREFIX + replicaId ); recman = new BaseRecordManager( journalFile.getAbsolutePath() ); TransactionManager transactionManager = ( ( BaseRecordManager ) recman ).getTransactionManager(); transactionManager.setMaximumTransactionsInLog( 200 ); SerializableComparator<String> comparator = new SerializableComparator<>( SchemaConstants.CSN_ORDERING_MATCH_MR_OID ); comparator.setSchemaManager( schemaManager ); journal = new JdbmTable<>( schemaManager, journalFile.getName(), recman, comparator, StringSerializer.INSTANCE, new ReplicaEventMessageSerializer( schemaManager ) ); this.partitionTxn = partitionTxn; }
/** * Deletes a record. * * @param recid the rowid for the record that should be deleted. * @throws IOException when one of the underlying I/O operations fails. */ public void delete( long recid ) throws IOException { LockElement element; checkIfClosed(); if ( recid <= 0 ) { throw new IllegalArgumentException( I18n.err( I18n.ERR_536, recid ) ); } LOG.debug( "BaseRecordManager.delete() recid {}", recid ); element = beginIO( recid, IOType.WRITE_IO ); try { Location logRowId = new Location( recid ); Location physRowId = logMgr.fetch( logRowId ); physMgr.delete( physRowId ); logMgr.delete( logRowId ); } finally { this.endIO( recid, element, IOType.WRITE_IO ); } }
private void reopen() throws IOException { _physFileFree = new RecordFile( _filename + DBF, FREE_BLOCK_SIZE); _physPagemanFree = new PageManager(_physFileFree); _physFile = new RecordFile( _filename + DBR, DATA_BLOCK_SIZE); _physPageman = new PageManager( _physFile ); _physMgr = new PhysicalRowIdManager( _physFile, _physPageman, new FreePhysicalRowIdPageManager(_physFileFree, _physPagemanFree)); _logicFileFree= new RecordFile( _filename +IDF,FREE_BLOCK_SIZE ); _logicPagemanFree = new PageManager( _logicFileFree ); if(TRANS_BLOCK_SIZE>256*8) throw new InternalError(); //to big page, slot number would not fit into page _logicFile = new RecordFile( _filename +IDR,TRANS_BLOCK_SIZE ); _logicPageman = new PageManager( _logicFile ); _logicMgr = new LogicalRowIdManager( _logicFile, _logicPageman, new FreeLogicalRowIdPageManager(_logicFileFree, _logicPagemanFree)); long versionNumber = getRoot(STORE_VERSION_NUMBER_ROOT); if(versionNumber>STORE_FORMAT_VERSION) throw new IOException("Unsupported version of store. Please update JDBM. Minimal supported ver:"+STORE_FORMAT_VERSION+", store ver:"+versionNumber); setRoot(STORE_VERSION_NUMBER_ROOT, STORE_FORMAT_VERSION); }
BaseRecordManager recMan = new BaseRecordManager( file.getAbsolutePath() );
/** * Fetches a record using standard java object serialization. * * @param recid the recid for the record that must be fetched. * @return the object contained in the record. * @throws IOException when one of the underlying I/O operations fails. */ public Object fetch( long recid ) throws IOException { return fetch( recid, DefaultSerializer.INSTANCE ); }
/** * Inserts a new record using a custom serializer. * * @param obj the object for the new record. * @param serializer a custom serializer * @return the rowid for the new record. * @throws IOException when one of the underlying I/O operations fails. */ public synchronized <A> long insert( A obj, Serializer<A> serializer ) throws IOException { checkIfClosed(); if(bufferInUse){ //current reusable buffer is in use, have to fallback into creating new instances byte[] buffer = new byte[1024]; OpenByteArrayOutputStream bao = new OpenByteArrayOutputStream(buffer); SerializerOutput out = new SerializerOutput(bao); return insert2(obj,serializer,buffer,bao,out); } try{ bufferInUse = true; return insert2(obj, serializer,_insertBuffer,_insertBAO,_insertOut); }finally{ bufferInUse = false; } }
public synchronized <A> void update( long recid, A obj, Serializer<A> serializer ) throws IOException { checkIfClosed(); if ( recid <= 0 ) { throw new IllegalArgumentException( "Argument 'recid' is invalid: " + recid ); } if(bufferInUse){ //current reusable buffer is in use, have to create new instances byte[] buffer = new byte[1024]; OpenByteArrayOutputStream bao = new OpenByteArrayOutputStream(buffer); SerializerOutput out = new SerializerOutput(bao); update2(recid,obj,serializer,buffer,bao,out); return; } try{ bufferInUse = true; update2(recid, obj, serializer,_insertBuffer, _insertBAO, _insertOut); }finally{ bufferInUse = false; } }
/** * Updates a record using standard java object serialization. * * @param recid the recid for the record that is to be updated. * @param obj the new object for the record. * @throws IOException when one of the underlying I/O operations fails. */ public void update( long recid, Object obj ) throws IOException { update( recid, obj, DefaultSerializer.INSTANCE ); }
/** * Inserts a new record using standard java object serialization. * * @param obj the object for the new record. * @return the rowid for the new record. * @throws IOException when one of the underlying I/O operations fails. */ public long insert( Object obj ) throws IOException { return insert( obj, DefaultSerializer.INSTANCE ); }
public synchronized void delete( long logRowId ) throws IOException { checkIfClosed(); if ( logRowId <= 0 ) { throw new IllegalArgumentException( "Argument 'recid' is invalid: " + logRowId ); } if ( DEBUG ) { System.out.println( "BaseRecordManager.delete() recid " + logRowId ) ; } logRowId = decompressRecid(logRowId); long physRowId = _logicMgr.fetch( logRowId ); _physMgr.delete( physRowId ); _logicMgr.delete( logRowId ); }
public synchronized <A> A fetch( long recid, Serializer<A> serializer ) throws IOException { checkIfClosed(); if ( recid <= 0 ) { throw new IllegalArgumentException( "Argument 'recid' is invalid: " + recid ); } if(bufferInUse){ //current reusable buffer is in use, have to create new instances byte[] buffer = new byte[1024]; OpenByteArrayOutputStream bao = new OpenByteArrayOutputStream(buffer); SerializerOutput out = new SerializerOutput(bao); OpenByteArrayInputStream bai = new OpenByteArrayInputStream(buffer); SerializerInput in = new SerializerInput(bai); return fetch2(recid,serializer,buffer,bao,out, bai,in); } try{ bufferInUse = true; return fetch2(recid, serializer,_insertBuffer,_insertBAO,_insertOut,_insertBAI, _insertIn); }finally{ bufferInUse = false; } }
int cacheSize; recman = new BaseRecordManager( name ); ( ( BaseRecordManager ) recman ).disableTransactions();