| /* Copyright (c) 2001-2010, The HSQL Development Group |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * Neither the name of the HSQL Development Group nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL HSQL DEVELOPMENT GROUP, HSQLDB.ORG, |
| * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| |
| package org.hsqldb.persist; |
| |
| import java.io.File; |
| import java.io.IOException; |
| import java.util.concurrent.locks.Lock; |
| import java.util.concurrent.locks.ReadWriteLock; |
| import java.util.concurrent.locks.ReentrantReadWriteLock; |
| |
| import org.hsqldb.Database; |
| import org.hsqldb.HsqlException; |
| import org.hsqldb.error.Error; |
| import org.hsqldb.error.ErrorCode; |
| import org.hsqldb.lib.FileAccess; |
| import org.hsqldb.lib.FileArchiver; |
| import org.hsqldb.lib.FileUtil; |
| import org.hsqldb.lib.StopWatch; |
| import org.hsqldb.lib.Storage; |
| import org.hsqldb.lib.StringUtil; |
| import org.hsqldb.rowio.RowInputBinary180; |
| import org.hsqldb.rowio.RowInputBinaryDecode; |
| import org.hsqldb.rowio.RowInputInterface; |
| import org.hsqldb.rowio.RowOutputBinary180; |
| import org.hsqldb.rowio.RowOutputBinaryEncode; |
| import org.hsqldb.rowio.RowOutputInterface; |
| import org.hsqldb.store.BitMap; |
| |
| /** |
| * Acts as a manager for CACHED table persistence.<p> |
| * |
| * This contains the top level functionality. Provides file management services |
| * and access.<p> |
| * |
| * Rewritten for 1.8.0 together with Cache. |
| * |
| * @author Fred Toussi (fredt@users dot sourceforge.net) |
| * @version 1.9.0 |
| * @since 1.7.2 |
| */ |
| public class DataFileCache { |
| |
| protected FileAccess fa; |
| |
| // We are using persist.Logger-instance-specific FrameworkLogger |
| // because it is Database-instance specific. |
| // If add any static level logging, should instantiate a standard, |
| // context-agnostic FrameworkLogger for that purpose. |
| // flags |
| public static final int FLAG_ISSHADOWED = 1; |
| public static final int FLAG_ISSAVED = 2; |
| public static final int FLAG_ROWINFO = 3; |
| public static final int FLAG_190 = 4; |
| |
| // file format fields |
| static final int LONG_EMPTY_SIZE = 4; // empty space size |
| static final int LONG_FREE_POS_POS = 12; // where iFreePos is saved |
| static final int LONG_EMPTY_INDEX_POS = 20; // empty space index |
| static final int FLAGS_POS = 28; |
| static final int MIN_INITIAL_FREE_POS = 32; |
| |
| // |
| DataFileBlockManager freeBlocks; |
| private static final int initIOBufferSize = 256; |
| |
| // |
| protected String dataFileName; |
| protected String backupFileName; |
| protected Database database; |
| |
| // this flag is used externally to determine if a backup is required |
| protected boolean fileModified; |
| protected int cacheFileScale; |
| |
| // post openning constant fields |
| protected boolean cacheReadonly; |
| |
| // |
| protected int cachedRowPadding = 8; |
| protected int initialFreePos = MIN_INITIAL_FREE_POS; |
| protected boolean hasRowInfo = false; |
| |
| // reusable input / output streams |
| protected RowInputInterface rowIn; |
| public RowOutputInterface rowOut; |
| |
| // |
| public long maxDataFileSize; |
| |
| // |
| boolean is180; |
| |
| // |
| protected Storage dataFile; |
| protected volatile long fileFreePosition; |
| protected int maxCacheRows; // number of Rows |
| protected long maxCacheBytes; // number of bytes |
| protected int maxFreeBlocks; |
| protected Cache cache; |
| |
| // |
| private RAShadowFile shadowFile; |
| |
| // |
| ReadWriteLock lock = new ReentrantReadWriteLock(); |
| Lock readLock = lock.readLock(); |
| Lock writeLock = lock.writeLock(); |
| |
| public DataFileCache(Database db, String baseFileName) { |
| |
| initParams(db, baseFileName); |
| |
| cache = new Cache(this); |
| } |
| |
| /** |
| * initial external parameters are set here. |
| */ |
| protected void initParams(Database database, String baseFileName) { |
| |
| this.dataFileName = baseFileName + ".data"; |
| this.backupFileName = baseFileName + ".backup"; |
| this.database = database; |
| fa = database.logger.getFileAccess(); |
| cacheFileScale = database.logger.getCacheFileScale(); |
| cachedRowPadding = 8; |
| |
| if (cacheFileScale > 8) { |
| cachedRowPadding = cacheFileScale; |
| } |
| |
| if (initialFreePos < cacheFileScale) { |
| initialFreePos = cacheFileScale; |
| } |
| |
| cacheReadonly = database.logger.propFilesReadOnly; |
| maxCacheRows = database.logger.propCacheMaxRows; |
| maxCacheBytes = database.logger.propCacheMaxSize; |
| maxDataFileSize = (long) Integer.MAX_VALUE * cacheFileScale; |
| maxFreeBlocks = database.logger.propMaxFreeBlocks; |
| dataFile = null; |
| shadowFile = null; |
| } |
| |
| /** |
| * Opens the *.data file for this cache, setting the variables that |
| * allow access to the particular database version of the *.data file. |
| */ |
| public void open(boolean readonly) { |
| |
| fileFreePosition = 0; |
| |
| database.logger.logInfoEvent("open start"); |
| |
| try { |
| boolean isNio = database.logger.propNioDataFile; |
| int fileType; |
| |
| if (database.logger.isStoredFileAccess()) { |
| fileType = ScaledRAFile.DATA_FILE_STORED; |
| } else if (database.isFilesInJar()) { |
| fileType = ScaledRAFile.DATA_FILE_JAR; |
| } else if (isNio) { |
| fileType = ScaledRAFile.DATA_FILE_NIO; |
| } else { |
| fileType = ScaledRAFile.DATA_FILE_RAF; |
| } |
| |
| if (readonly || database.isFilesInJar()) { |
| dataFile = ScaledRAFile.newScaledRAFile(database, |
| dataFileName, readonly, fileType); |
| |
| initBuffers(); |
| |
| return; |
| } |
| |
| boolean preexists = false; |
| long freesize = 0; |
| |
| if (fa.isStreamElement(dataFileName)) { |
| preexists = true; |
| } |
| |
| dataFile = ScaledRAFile.newScaledRAFile(database, dataFileName, |
| readonly, fileType); |
| |
| if (preexists) { |
| dataFile.seek(FLAGS_POS); |
| |
| int flags = dataFile.readInt(); |
| boolean isSaved = BitMap.isSet(flags, FLAG_ISSAVED); |
| |
| database.logger.propIncrementBackup = BitMap.isSet(flags, |
| FLAG_ISSHADOWED); |
| is180 = !BitMap.isSet(flags, FLAG_190); |
| |
| if (!isSaved) { |
| boolean restored = true; |
| |
| dataFile.close(); |
| |
| if (database.logger.propIncrementBackup) { |
| restored = restoreBackupIncremental(); |
| } else { |
| restoreBackup(); |
| } |
| |
| dataFile = ScaledRAFile.newScaledRAFile(database, |
| dataFileName, readonly, fileType); |
| |
| if (!restored) { |
| initNewFile(); |
| |
| is180 = false; |
| } |
| } |
| |
| dataFile.seek(LONG_EMPTY_SIZE); |
| |
| freesize = dataFile.readLong(); |
| |
| dataFile.seek(LONG_FREE_POS_POS); |
| |
| fileFreePosition = dataFile.readLong(); |
| |
| if (fileFreePosition < initialFreePos) { |
| fileFreePosition = initialFreePos; |
| } |
| |
| if (database.logger.propIncrementBackup |
| && fileFreePosition != initialFreePos) { |
| shadowFile = new RAShadowFile(database, dataFile, |
| backupFileName, |
| fileFreePosition, 1 << 14); |
| } |
| } else { |
| initNewFile(); |
| } |
| |
| initBuffers(); |
| |
| fileModified = false; |
| freeBlocks = new DataFileBlockManager(maxFreeBlocks, |
| cacheFileScale, freesize); |
| |
| database.logger.logInfoEvent("open end"); |
| } catch (Throwable t) { |
| database.logger.logSevereEvent("open failed", t); |
| close(false); |
| |
| throw Error.error(t, ErrorCode.FILE_IO_ERROR, |
| ErrorCode.M_DataFileCache_open, new Object[] { |
| t.getMessage(), dataFileName |
| }); |
| } |
| } |
| |
| void initNewFile() throws IOException { |
| |
| fileFreePosition = initialFreePos; |
| |
| dataFile.seek(LONG_FREE_POS_POS); |
| dataFile.writeLong(initialFreePos); |
| |
| // set shadowed flag; |
| int flags = 0; |
| |
| if (database.logger.propIncrementBackup) { |
| flags = BitMap.set(flags, FLAG_ISSHADOWED); |
| } |
| |
| flags = BitMap.set(flags, FLAG_190); |
| |
| dataFile.seek(FLAGS_POS); |
| dataFile.writeInt(flags); |
| dataFile.synch(); |
| } |
| |
| void setIncrementBackup(boolean value) { |
| |
| writeLock.lock(); |
| |
| try { |
| dataFile.seek(FLAGS_POS); |
| |
| int flags = dataFile.readInt(); |
| |
| if (value) { |
| flags = BitMap.set(flags, FLAG_ISSHADOWED); |
| } else { |
| flags = BitMap.unset(flags, FLAG_ISSHADOWED); |
| } |
| |
| dataFile.seek(FLAGS_POS); |
| dataFile.writeInt(flags); |
| dataFile.synch(); |
| } catch (Throwable t) { |
| database.logger.logSevereEvent("backupFile failed", t); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| /** |
| * Restores a compressed backup or the .data file. |
| */ |
| private boolean restoreBackup() { |
| |
| // in case data file cannot be deleted, reset it |
| deleteOrResetFreePos(); |
| |
| try { |
| FileAccess fa = database.logger.getFileAccess(); |
| |
| if (fa.isStreamElement(backupFileName)) { |
| FileArchiver.unarchive(backupFileName, dataFileName, fa, |
| FileArchiver.COMPRESSION_ZIP); |
| |
| return true; |
| } |
| |
| return false; |
| } catch (Throwable t) { |
| throw Error.error(t, ErrorCode.FILE_IO_ERROR, |
| ErrorCode.M_Message_Pair, new Object[] { |
| t.getMessage(), backupFileName |
| }); |
| } |
| } |
| |
| /** |
| * Restores in from an incremental backup |
| */ |
| private boolean restoreBackupIncremental() { |
| |
| try { |
| if (fa.isStreamElement(backupFileName)) { |
| RAShadowFile.restoreFile(database, backupFileName, |
| dataFileName); |
| deleteBackup(); |
| |
| return true; |
| } |
| |
| return false; |
| } catch (IOException e) { |
| throw Error.error(ErrorCode.FILE_IO_ERROR, e); |
| } |
| } |
| |
| /** |
| * Parameter write indicates either an orderly close, or a fast close |
| * without backup. |
| * |
| * When false, just closes the file. |
| * |
| * When true, writes out all cached rows that have been modified and the |
| * free position pointer for the *.data file and then closes the file. |
| */ |
| public void close(boolean write) { |
| |
| writeLock.lock(); |
| |
| try { |
| if (cacheReadonly) { |
| if (dataFile != null) { |
| dataFile.close(); |
| |
| dataFile = null; |
| } |
| |
| return; |
| } |
| |
| database.logger.logInfoEvent("DataFileCache.close(" + write |
| + ") : start"); |
| |
| if (write) { |
| cache.saveAll(); |
| database.logger.logInfoEvent( |
| "DataFileCache.close() : save data"); |
| |
| if (fileModified || freeBlocks.isModified()) { |
| |
| // set empty |
| dataFile.seek(LONG_EMPTY_SIZE); |
| dataFile.writeLong(freeBlocks.getLostBlocksSize()); |
| |
| // set end |
| dataFile.seek(LONG_FREE_POS_POS); |
| dataFile.writeLong(fileFreePosition); |
| |
| // set saved flag; |
| dataFile.seek(FLAGS_POS); |
| |
| int flags = dataFile.readInt(); |
| |
| flags = BitMap.set(flags, FLAG_ISSAVED); |
| |
| dataFile.seek(FLAGS_POS); |
| dataFile.writeInt(flags); |
| database.logger.logInfoEvent( |
| "DataFileCache.close() : flags"); |
| |
| // |
| dataFile.seek(fileFreePosition); |
| database.logger.logInfoEvent( |
| "DataFileCache.close() : seek end"); |
| } |
| } |
| |
| if (dataFile != null) { |
| dataFile.synch(); |
| dataFile.close(); |
| database.logger.logInfoEvent("DataFileCache.close() : close"); |
| |
| dataFile = null; |
| } |
| |
| if (shadowFile != null) { |
| shadowFile.close(); |
| |
| shadowFile = null; |
| } |
| |
| boolean empty = fileFreePosition == initialFreePos; |
| |
| if (empty) { |
| deleteFile(); |
| deleteBackup(); |
| } |
| } catch (Throwable t) { |
| database.logger.logSevereEvent("Close failed", t); |
| |
| throw Error.error(t, ErrorCode.FILE_IO_ERROR, |
| ErrorCode.M_DataFileCache_close, new Object[] { |
| t.getMessage(), dataFileName |
| }); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| protected void initBuffers() { |
| |
| if (rowOut == null |
| || rowOut.getOutputStream().getBuffer().length |
| > initIOBufferSize) { |
| if (is180) { |
| rowOut = new RowOutputBinary180(256, cachedRowPadding); |
| } else { |
| rowOut = new RowOutputBinaryEncode(database.logger.getCrypto(), |
| 256, cachedRowPadding); |
| } |
| } |
| |
| if (rowIn == null || rowIn.getBuffer().length > initIOBufferSize) { |
| if (is180) { |
| rowIn = new RowInputBinary180(new byte[256]); |
| } else { |
| rowIn = new RowInputBinaryDecode(database.logger.getCrypto(), |
| new byte[256]); |
| } |
| } |
| } |
| |
| DataFileDefrag defrag() { |
| |
| writeLock.lock(); |
| |
| try { |
| cache.saveAll(); |
| |
| DataFileDefrag dfd = new DataFileDefrag(database, this, |
| dataFileName); |
| |
| dfd.process(); |
| close(true); |
| cache.clear(); |
| |
| if (!database.logger.propIncrementBackup) { |
| backupFile(); |
| } |
| |
| database.schemaManager.setTempIndexRoots(dfd.getIndexRoots()); |
| database.logger.log.writeScript(false); |
| database.getProperties().setDBModified( |
| HsqlDatabaseProperties.FILES_NEW); |
| database.logger.log.closeLog(); |
| database.logger.log.deleteLog(); |
| database.logger.log.renameNewScript(); |
| renameDataFile(); |
| renameBackupFile(); |
| database.getProperties().setDBModified( |
| HsqlDatabaseProperties.FILES_NOT_MODIFIED); |
| open(false); |
| dfd.updateTransactionRowIDs(); |
| database.schemaManager.setIndexRoots(dfd.getIndexRoots()); |
| |
| if (database.logger.log.dbLogWriter != null) { |
| database.logger.log.openLog(); |
| } |
| |
| database.getProperties().setDBModified( |
| HsqlDatabaseProperties.FILES_MODIFIED); |
| |
| return dfd; |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| /** |
| * Used when a row is deleted as a result of some DML or DDL statement. |
| * Removes the row from the cache data structures. |
| * Adds the file space for the row to the list of free positions. |
| */ |
| public void remove(int i, PersistentStore store) { |
| |
| writeLock.lock(); |
| |
| try { |
| CachedObject r = release(i); |
| |
| if (r != null) { |
| int size = r.getStorageSize(); |
| |
| freeBlocks.add(i, size); |
| } |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| public void removePersistence(int i, PersistentStore store) {} |
| |
| /** |
| * Allocates file space for the row. <p> |
| * |
| * Free space is requested from the block manager if it exists. |
| * Otherwise the file is grown to accommodate it. |
| */ |
| int setFilePos(CachedObject r) { |
| |
| int rowSize = r.getStorageSize(); |
| int i = freeBlocks == null ? -1 |
| : freeBlocks.get(rowSize); |
| |
| if (i == -1) { |
| i = (int) (fileFreePosition / cacheFileScale); |
| |
| long newFreePosition = fileFreePosition + rowSize; |
| |
| if (newFreePosition > maxDataFileSize) { |
| throw Error.error(ErrorCode.DATA_FILE_IS_FULL); |
| } |
| |
| fileFreePosition = newFreePosition; |
| } |
| |
| r.setPos(i); |
| |
| return i; |
| } |
| |
| public void add(CachedObject object) { |
| |
| writeLock.lock(); |
| |
| try { |
| int i = setFilePos(object); |
| |
| cache.put(i, object); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| public int getStorageSize(int i) { |
| |
| readLock.lock(); |
| |
| try { |
| CachedObject value = cache.get(i); |
| |
| if (value != null) { |
| return value.getStorageSize(); |
| } |
| } finally { |
| readLock.unlock(); |
| } |
| |
| return readSize(i); |
| } |
| |
| public void replace(CachedObject object) { |
| |
| writeLock.lock(); |
| |
| try { |
| int pos = object.getPos(); |
| |
| cache.replace(pos, object); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| public CachedObject get(CachedObject object, PersistentStore store, |
| boolean keep) { |
| |
| readLock.lock(); |
| |
| int pos; |
| |
| try { |
| if (object.isInMemory()) { |
| if (keep) { |
| object.keepInMemory(true); |
| } |
| |
| return object; |
| } |
| |
| pos = object.getPos(); |
| |
| if (pos < 0) { |
| return null; |
| } |
| |
| object = cache.get(pos); |
| |
| if (object != null) { |
| if (keep) { |
| object.keepInMemory(true); |
| } |
| |
| return object; |
| } |
| } finally { |
| readLock.unlock(); |
| } |
| |
| return getFromFile(pos, store, keep); |
| } |
| |
| public CachedObject get(int pos, PersistentStore store, boolean keep) { |
| |
| CachedObject object; |
| |
| if (pos < 0) { |
| return null; |
| } |
| |
| readLock.lock(); |
| |
| try { |
| object = cache.get(pos); |
| |
| if (object != null) { |
| if (keep) { |
| object.keepInMemory(true); |
| } |
| |
| return object; |
| } |
| } finally { |
| readLock.unlock(); |
| } |
| |
| return getFromFile(pos, store, keep); |
| } |
| |
| private CachedObject getFromFile(int pos, PersistentStore store, |
| boolean keep) { |
| |
| CachedObject object = null; |
| |
| writeLock.lock(); |
| |
| try { |
| object = cache.get(pos); |
| |
| if (object != null) { |
| if (keep) { |
| object.keepInMemory(true); |
| } |
| |
| return object; |
| } |
| |
| for (int j = 0; j < 2; j++) { |
| try { |
| RowInputInterface rowInput = readObject(pos); |
| |
| if (rowInput == null) { |
| return null; |
| } |
| |
| object = store.get(rowInput); |
| |
| break; |
| } catch (OutOfMemoryError err) { |
| cache.forceCleanUp(); |
| System.gc(); |
| |
| if (j > 0) { |
| throw err; |
| } |
| } |
| } |
| |
| // for text tables with empty rows at the beginning, |
| // pos may move forward in readObject |
| pos = object.getPos(); |
| |
| cache.put(pos, object); |
| |
| if (keep) { |
| object.keepInMemory(true); |
| } |
| |
| store.set(object); |
| |
| return object; |
| } catch (HsqlException e) { |
| database.logger.logSevereEvent(dataFileName + " getFromFile " |
| + pos, e); |
| |
| throw e; |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| RowInputInterface getRaw(int i) { |
| |
| writeLock.lock(); |
| |
| try { |
| return readObject(i); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| protected int readSize(int pos) { |
| |
| writeLock.lock(); |
| |
| try { |
| dataFile.seek((long) pos * cacheFileScale); |
| |
| return dataFile.readInt(); |
| } catch (IOException e) { |
| throw Error.error(ErrorCode.DATA_FILE_ERROR, e); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| protected RowInputInterface readObject(int pos) { |
| |
| try { |
| dataFile.seek((long) pos * cacheFileScale); |
| |
| int size = dataFile.readInt(); |
| |
| rowIn.resetRow(pos, size); |
| dataFile.read(rowIn.getBuffer(), 4, size - 4); |
| |
| return rowIn; |
| } catch (IOException e) { |
| throw Error.error(ErrorCode.DATA_FILE_ERROR, e); |
| } |
| } |
| |
| public CachedObject release(int pos) { |
| |
| writeLock.lock(); |
| |
| try { |
| return cache.release(pos); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| protected void saveRows(CachedObject[] rows, int offset, int count) { |
| |
| try { |
| copyShadow(rows, offset, count); |
| setFileModified(); |
| |
| for (int i = offset; i < offset + count; i++) { |
| CachedObject r = rows[i]; |
| |
| saveRowNoLock(r); |
| |
| rows[i] = null; |
| } |
| } catch (HsqlException e) { |
| database.logger.logSevereEvent("saveRows failed", e); |
| |
| throw e; |
| } catch (Throwable e) { |
| database.logger.logSevereEvent("saveRows failed", e); |
| |
| throw Error.error(ErrorCode.DATA_FILE_ERROR, e); |
| } finally { |
| initBuffers(); |
| } |
| } |
| |
| /** |
| * Writes out the specified Row. Will write only the Nodes or both Nodes |
| * and table row data depending on what is not already persisted to disk. |
| */ |
| public void saveRow(CachedObject row) { |
| |
| writeLock.lock(); |
| |
| try { |
| copyShadow(row); |
| setFileModified(); |
| saveRowNoLock(row); |
| } catch (Throwable e) { |
| database.logger.logSevereEvent("saveRow failed", e); |
| |
| throw Error.error(ErrorCode.DATA_FILE_ERROR, e); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| private void saveRowNoLock(CachedObject row) { |
| |
| try { |
| rowOut.reset(); |
| row.write(rowOut); |
| dataFile.seek((long) row.getPos() * cacheFileScale); |
| dataFile.write(rowOut.getOutputStream().getBuffer(), 0, |
| rowOut.getOutputStream().size()); |
| } catch (IOException e) { |
| throw Error.error(ErrorCode.DATA_FILE_ERROR, e); |
| } |
| } |
| |
| protected void copyShadow(CachedObject[] rows, int offset, |
| int count) throws IOException { |
| |
| if (shadowFile != null) { |
| for (int i = offset; i < offset + count; i++) { |
| CachedObject row = rows[i]; |
| long seekpos = (long) row.getPos() * cacheFileScale; |
| |
| shadowFile.copy(seekpos, row.getStorageSize()); |
| } |
| |
| shadowFile.close(); |
| } |
| } |
| |
| protected void copyShadow(CachedObject row) throws IOException { |
| |
| if (shadowFile != null) { |
| long seekpos = (long) row.getPos() * cacheFileScale; |
| |
| shadowFile.copy(seekpos, row.getStorageSize()); |
| shadowFile.close(); |
| } |
| } |
| |
| /** |
| * Saves the *.data file as compressed *.backup. |
| * |
| * @throws HsqlException |
| */ |
| void backupFile() { |
| |
| writeLock.lock(); |
| |
| try { |
| if (database.logger.propIncrementBackup) { |
| if (fa.isStreamElement(backupFileName)) { |
| deleteBackup(); |
| } |
| |
| return; |
| } |
| |
| if (fa.isStreamElement(dataFileName)) { |
| FileArchiver.archive(dataFileName, backupFileName + ".new", |
| database.logger.getFileAccess(), |
| FileArchiver.COMPRESSION_ZIP); |
| } |
| } catch (IOException e) { |
| database.logger.logSevereEvent("backupFile failed", e); |
| |
| throw Error.error(ErrorCode.DATA_FILE_ERROR, e); |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| void renameBackupFile() { |
| |
| writeLock.lock(); |
| |
| try { |
| if (database.logger.propIncrementBackup) { |
| deleteBackup(); |
| |
| return; |
| } |
| |
| if (fa.isStreamElement(backupFileName + ".new")) { |
| deleteBackup(); |
| fa.renameElement(backupFileName + ".new", backupFileName); |
| } |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| /** |
| * Renames the *.data.new file. |
| * |
| * @throws HsqlException |
| */ |
| void renameDataFile() { |
| |
| writeLock.lock(); |
| |
| try { |
| if (fa.isStreamElement(dataFileName + ".new")) { |
| deleteFile(); |
| fa.renameElement(dataFileName + ".new", dataFileName); |
| } |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| void deleteFile() { |
| |
| writeLock.lock(); |
| |
| try { |
| |
| // first attemp to delete |
| fa.removeElement(dataFileName); |
| |
| // OOo related code |
| if (database.logger.isStoredFileAccess()) { |
| return; |
| } |
| |
| // OOo end |
| if (fa.isStreamElement(dataFileName)) { |
| |
| //#ifdef JAVA2FULL |
| try { |
| File file = new File(database.getCanonicalPath()); |
| File[] list = file.getParentFile().listFiles(); |
| |
| for (int i = 0; i < list.length; i++) { |
| if (list[i].getName().endsWith(".old") |
| && list[i].getName().startsWith( |
| file.getName())) { |
| list[i].delete(); |
| } |
| } |
| } catch (Throwable t) {} |
| |
| //#endif JAVA2FULL |
| fa.removeElement(dataFileName); |
| |
| if (fa.isStreamElement(dataFileName)) { |
| String discardName = newDiscardFileName(); |
| |
| fa.renameElement(dataFileName, discardName); |
| } |
| } |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| String newDiscardFileName() { |
| |
| String timestamp = StringUtil.toPaddedString( |
| Integer.toHexString((int) System.currentTimeMillis()), 8, '0', |
| true); |
| String discardName = dataFileName + "." + timestamp + ".old"; |
| |
| return discardName; |
| } |
| |
| void deleteBackup() { |
| |
| writeLock.lock(); |
| |
| try { |
| if (fa.isStreamElement(backupFileName)) { |
| fa.removeElement(backupFileName); |
| } |
| } finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| /** |
| * This method deletes a data file or resets its free position. |
| * this is used only for nio files - not OOo files |
| */ |
| void deleteOrResetFreePos() { |
| |
| deleteFile(); |
| |
| // OOo related code |
| if (database.logger.isStoredFileAccess()) { |
| return; |
| } |
| |
| // OOo end |
| if (!database.logger.getFileAccess().isStreamElement(dataFileName)) { |
| return; |
| } |
| |
| try { |
| dataFile = new ScaledRAFileSimple(dataFileName, "rw"); |
| |
| initNewFile(); |
| } catch (IOException e) { |
| database.logger.logSevereEvent("deleteOrResetFreePos failed", e); |
| } finally { |
| if (dataFile != null) { |
| try { |
| dataFile.close(); |
| |
| dataFile = null; |
| } catch (IOException e) { |
| database.logger.logWarningEvent("Failed to close RA file", |
| e); |
| } |
| } |
| } |
| } |
| |
| public int capacity() { |
| return maxCacheRows; |
| } |
| |
| public long bytesCapacity() { |
| return maxCacheBytes; |
| } |
| |
| public long getTotalCachedBlockSize() { |
| return cache.getTotalCachedBlockSize(); |
| } |
| |
| public int getFreeBlockCount() { |
| return freeBlocks.size(); |
| } |
| |
| public int getTotalFreeBlockSize() { |
| return 0; |
| } |
| |
| public long getFileFreePos() { |
| return fileFreePosition; |
| } |
| |
| public int getCachedObjectCount() { |
| return cache.size(); |
| } |
| |
| public int getAccessCount() { |
| return cache.incrementAccessCount(); |
| } |
| |
| public String getFileName() { |
| return dataFileName; |
| } |
| |
| public boolean hasRowInfo() { |
| return hasRowInfo; |
| } |
| |
| public boolean isFileModified() { |
| return fileModified; |
| } |
| |
| public boolean isFileOpen() { |
| return dataFile != null; |
| } |
| |
| protected void setFileModified() { |
| |
| writeLock.lock(); |
| |
| try { |
| if (!fileModified) { |
| |
| // unset saved flag; |
| dataFile.seek(FLAGS_POS); |
| |
| int flags = dataFile.readInt(); |
| |
| flags = BitMap.unset(flags, FLAG_ISSAVED); |
| |
| dataFile.seek(FLAGS_POS); |
| dataFile.writeInt(flags); |
| dataFile.synch(); |
| Error.printSystemOut( |
| cache.saveAllTimer.currentElapsedTimeToMessage( |
| "flags set time: ")); |
| |
| fileModified = true; |
| } |
| } catch (Throwable t) {} |
| finally { |
| writeLock.unlock(); |
| } |
| } |
| |
| public boolean isDataReadOnly() { |
| return this.cacheReadonly; |
| } |
| } |
