Inheritance diagram for Deveel.Data.Store.SingleFileStoreSystem:

Classes
class	StoreInfo

Public Member Functions
	SingleFileStoreSystem (IDatabaseContext context, IConfiguration configuration)

void	Dispose ()

bool	StoreExists (string name)

SingleFileStore	CreateStore (string name)

SingleFileStore	OpenStore (string name)

bool	CloseStore (SingleFileStore store)

bool	DeleteStore (SingleFileStore store)

void	SetCheckPoint ()
	Sets a new check point at the current state of this store system. More...

void	Lock (string lockName)

void	Unlock (string lockName)

Public Member Functions inherited from Deveel.Data.Store.IStoreSystem
bool	StoreExists (String name)
	Returns true if the store with the given name exists within the system, or false otherwise. More...

IStore	CreateStore (String name)
	Creates and returns a new persistent Store object given the unique name of the store. More...

IStore	OpenStore (String name)
	Opens an existing persistent Store object in the system and returns the IStore object that contains its data. More...

void	Lock (String lockName)
	Attempts to lock this store system exclusively so that no other process may access or change the persistent data in the store. More...

void	Unlock (String lockName)
	Unlocks the exclusive access to the persistent store objects. More...

Public Attributes
const string	DefaultFileExtension = "db"

Package Functions
Stream	LoadStoreData (int id)

Properties
string	FileName `[get, set]`

string	TempFileName `[get]`

string	LockFileName `[get]`

bool	ReadOnly `[get, set]`

bool	IsReadOnly `[get, set]`

IFileSystem	FileSystem `[get]`

object	CheckPointLock `[get]`

Private Member Functions
	~SingleFileStoreSystem ()

void	Configure (IConfiguration config)

void	Dispose (bool disposing)

void	OpenOrCreateFile ()

void	LoadStores (IFile dataFile)

void	LoadHeaders (BinaryReader reader)

IStore IStoreSystem.	CreateStore (string name)

IStore IStoreSystem.	OpenStore (string name)

bool IStoreSystem.	CloseStore (IStore store)
	Closes a store that has been either created or opened with the CreateStore or OpenStore methods. More...

bool IStoreSystem.	DeleteStore (IStore store)
	Permanently deletes a store from the system - use with care! More...

long	GetDataStartOffset ()

void	WriteStores (Stream stream)

long	WriteStoreInfo (BinaryWriter writer, long offset, SingleFileStore store)

void	WriteHeaders (Stream stream, long dataStartOffset)

int	FindMaxStoreId ()

bool	TryFindStore (string storeName, out SingleFileStore store)

Private Attributes
IDatabaseContext	context

bool	disposed

readonly object	checkPointLock = new object()

IDictionary< int, SingleFileStore >	stores

IDictionary< string, int >	nameIdMap

IDictionary< int, StoreInfo >	storeInfo

int	storeId

const int	Magic = 0xf09a671

Detailed Description

Definition at line 28 of file SingleFileStoreSystem.cs.

Constructor & Destructor Documentation

Deveel.Data.Store.SingleFileStoreSystem.SingleFileStoreSystem	(	IDatabaseContext	context,
		IConfiguration	configuration
	)

inline

Definition at line 45 of file SingleFileStoreSystem.cs.

                                                                                              {
             if (context == null)
                 throw new ArgumentNullException("context");
 
             this.context = context;
 
             Configure(configuration);
 
             OpenOrCreateFile();
         }

Deveel.Data.Store.SingleFileStoreSystem.~SingleFileStoreSystem ( )

inlineprivate

Definition at line 56 of file SingleFileStoreSystem.cs.

                                  {
             Dispose(false);
         }

Member Function Documentation

bool IStoreSystem. Deveel.Data.Store.SingleFileStoreSystem.CloseStore ( IStore store )

inlineprivate

Closes a store that has been either created or opened with the CreateStore or OpenStore methods.

Parameters

store

Returns: Returns true if the store was successfully closed.

Implements Deveel.Data.Store.IStoreSystem.

Definition at line 277 of file SingleFileStoreSystem.cs.

                                                    {
             return CloseStore((SingleFileStore) store);
         }

bool Deveel.Data.Store.SingleFileStoreSystem.CloseStore ( SingleFileStore store )

inline

Definition at line 281 of file SingleFileStoreSystem.cs.

                                                       {
             try {
                 SingleFileStore fileStore;
                 if (!TryFindStore(store.Name, out fileStore))
                     throw new IOException("The store was not found in this database.");
 
                 fileStore.Close();
                 return true;
             } catch (IOException) {
                 throw;
             } catch (Exception ex) {
                 throw new IOException("Unable to close the store.", ex);
             }
         }

void Deveel.Data.Store.SingleFileStoreSystem.Configure ( IConfiguration config )

inlineprivate

Definition at line 60 of file SingleFileStoreSystem.cs.

                                                       {
             var basePath = config.GetString("database.basePath");
             var fileName = config.GetString("database.fileName");
             var fullPath = config.GetString("database.fullPath");
 
             if (String.IsNullOrEmpty(basePath)) {
                 if (String.IsNullOrEmpty(fullPath)) {
                     FileName = fileName;
                 } else {
                     FileName = fullPath;
                 }
             } else if (String.IsNullOrEmpty(fileName)) {
                 if (!String.IsNullOrEmpty(basePath)) {
                     fileName = String.Format("{0}.{1}", context.DatabaseName(), DefaultFileExtension);
                     FileName = FileSystem.CombinePath(basePath, fileName);
                 } else if (!String.IsNullOrEmpty(fullPath)) {
                     FileName = fullPath;
                 }
             } else if (String.IsNullOrEmpty(fullPath)) {
                 FileName = FileSystem.CombinePath(basePath, fileName);
             }
 
             if (String.IsNullOrEmpty(FileName))
                 throw new DatabaseConfigurationException("Could not configure the file name of the database.");
         }

IStore IStoreSystem. Deveel.Data.Store.SingleFileStoreSystem.CreateStore ( string name )

inlineprivate

Definition at line 237 of file SingleFileStoreSystem.cs.

                                                      {
             return CreateStore(name);
         }

SingleFileStore Deveel.Data.Store.SingleFileStoreSystem.CreateStore ( string name )

inline

Definition at line 241 of file SingleFileStoreSystem.cs.

                                                         {
             lock (checkPointLock) {
                 SingleFileStore store;
                 if (TryFindStore(name, out store))
                     throw new IOException(string.Format("The store '{0}' already exists in this database.", name));
 
                 if (nameIdMap == null)
                     nameIdMap = new Dictionary<string, int>();
                 
                 if (stores == null)
                     stores = new Dictionary<int, SingleFileStore>();    
 
                 var id = ++storeId;
                 store = new SingleFileStore(this, name, id);
                 store.Open();
                 stores[id] = store;
                 nameIdMap[name] = id;
                 return store;
             }
         }

bool IStoreSystem. Deveel.Data.Store.SingleFileStoreSystem.DeleteStore ( IStore store )

inlineprivate

Permanently deletes a store from the system - use with care!

Parameters

store

Note that it is quite likely that a store may fail to delete in which case the delete operation should be re-tried after a short timeout.

Returns: Returns true if the store was successfully deleted and the resources associated with it were freed. Returns false if the store could not be deleted.

Implements Deveel.Data.Store.IStoreSystem.

Definition at line 296 of file SingleFileStoreSystem.cs.

                                                     {
             return DeleteStore((SingleFileStore) store);
         }

bool Deveel.Data.Store.SingleFileStoreSystem.DeleteStore ( SingleFileStore store )

inline

Definition at line 300 of file SingleFileStoreSystem.cs.

                                                        {
             try {
                 if (stores == null || !stores.ContainsKey(store.Id))
                     return false;
 
                 return stores.Remove(store.Id);
             } catch (IOException) {
                 throw;
             } catch (Exception ex) {
                 throw new IOException("Unable to delete the store.", ex);
             } finally {
                 if (nameIdMap != null)
                     nameIdMap.Remove(store.Name);
             }
         }

void Deveel.Data.Store.SingleFileStoreSystem.Dispose ( )

inline

Definition at line 98 of file SingleFileStoreSystem.cs.

                               {
             Dispose(true);
             GC.SuppressFinalize(this);
         }

void Deveel.Data.Store.SingleFileStoreSystem.Dispose ( bool disposing )

inlineprivate

Definition at line 103 of file SingleFileStoreSystem.cs.

                                              {
             if (disposing) {
                 if (stores != null) {
                     foreach (var store in stores.Values) {
                         if (store != null)
                             store.Dispose();
                     }
 
                     stores.Clear();
                 }
             }
 
             disposed = true;
             storeInfo = null;
             stores = null;
         }

int Deveel.Data.Store.SingleFileStoreSystem.FindMaxStoreId ( )

inlineprivate

Definition at line 407 of file SingleFileStoreSystem.cs.

                                      {
             return stores == null ? 0 : stores.Max(x => x.Value.Id);
         }

long Deveel.Data.Store.SingleFileStoreSystem.GetDataStartOffset ( )

inlineprivate

Definition at line 344 of file SingleFileStoreSystem.cs.

                                           {
             long offset = 24;
 
             foreach (var store in stores.Values) {
                 var nameLength = Encoding.Unicode.GetByteCount(store.Name);
 
                 offset += 4 + nameLength + 4 + 8 + 8;
             }
 
             return offset;
         }

void Deveel.Data.Store.SingleFileStoreSystem.LoadHeaders ( BinaryReader reader )

inlineprivate

Definition at line 169 of file SingleFileStoreSystem.cs.

                                                       {
             var magic = reader.ReadInt32();
 
             if (magic != Magic)
                 throw new IOException("The magic number in the header is invalid.");
 
             var version = reader.ReadInt32();
             var lastModified = reader.ReadInt64();
             var storeCount = reader.ReadInt32();
 
             // the maximum number of the stores
             storeId = reader.ReadInt32();
 
             storeInfo = new Dictionary<int, StoreInfo>(storeCount);
 
             for (int i = 0; i < storeCount; i++) {
                 var strLength = reader.ReadInt32();
                 var nameChars = reader.ReadChars(strLength);
 
                 var name = new string(nameChars);
                 var id = reader.ReadInt32();
                 var offset = reader.ReadInt64();
                 var size = reader.ReadInt64();
 
                 storeInfo[id] = new StoreInfo(name, id, offset, size);
 
                 if (nameIdMap == null)
                     nameIdMap = new Dictionary<string, int>();
 
                 nameIdMap[name] = id;
             }
         }

Stream Deveel.Data.Store.SingleFileStoreSystem.LoadStoreData ( int id )

inlinepackage

Definition at line 202 of file SingleFileStoreSystem.cs.

                                               {
             StoreInfo info;
             if (storeInfo == null ||
                 !storeInfo.TryGetValue(id, out info))
                 return null;
 
             var size = info.Size;
             var offset = info.Offset;
 
             using (var dataFile = FileSystem.OpenFile(FileName, true)) {
                 using (var stream = new FileStream(dataFile)) {
                     stream.Seek(offset, SeekOrigin.Begin);
 
                     var buffer = new byte[size];
 
                     var outputStream = new MemoryStream();
 
                     // TODO: support larger portions...
                     stream.Read(buffer, 0, (int) size);
 
                     outputStream.Write(buffer, 0, buffer.Length);
 
                     if (outputStream.Length != size)
                         throw new IOException("Corruption when reading the store.");
 
                     return outputStream;
                 }
             }
         }

void Deveel.Data.Store.SingleFileStoreSystem.LoadStores ( IFile dataFile )

inlineprivate

Definition at line 161 of file SingleFileStoreSystem.cs.

                                                 {
             using (var fileStream = new FileStream(dataFile)) {
                 using (var reader = new BinaryReader(fileStream, Encoding.Unicode)) {
                     LoadHeaders(reader);
                 }
             }
         }

void Deveel.Data.Store.SingleFileStoreSystem.Lock ( string lockName )

inline

Definition at line 426 of file SingleFileStoreSystem.cs.

                                           {
             SingleFileStore store;
             if (!TryFindStore(lockName, out store))
                 return;
 
             store.Lock();
         }

void Deveel.Data.Store.SingleFileStoreSystem.OpenOrCreateFile ( )

inlineprivate

Definition at line 130 of file SingleFileStoreSystem.cs.

                                         {
             bool created = false;
 
             IFile dataFile;
 
             if (FileSystem.FileExists(FileName)) {
                 dataFile = FileSystem.OpenFile(FileName, ReadOnly);
             } else if (ReadOnly) {
                 throw new InvalidOperationException(
                     string.Format("The file '{0}' does not exist and the store is configured to be read-only.", FileName));
             } else {
                 dataFile = FileSystem.CreateFile(FileName);
                 created = true;
             }
 
             try {
                 if (!created) {
                     LoadStores(dataFile);
                 } else {
                     using (var stream = new FileStream(dataFile)) {
                         WriteHeaders(stream, 24);
 
                         stream.Flush();
                     }
                 }
             } finally {
                 if (dataFile != null)
                     dataFile.Dispose();
             }
         }

IStore IStoreSystem. Deveel.Data.Store.SingleFileStoreSystem.OpenStore ( string name )

inlineprivate

Definition at line 262 of file SingleFileStoreSystem.cs.

                                                    {
             return OpenStore(name);
         }

SingleFileStore Deveel.Data.Store.SingleFileStoreSystem.OpenStore ( string name )

inline

Definition at line 266 of file SingleFileStoreSystem.cs.

                                                       {
             lock (checkPointLock) {
                 SingleFileStore store;
                 if (!TryFindStore(name, out store))
                     throw new IOException(string.Format("The store '{0}' does not exist in this database.", name));
 
                 store.Open();
                 return store;
             }
         }

void Deveel.Data.Store.SingleFileStoreSystem.SetCheckPoint ( )

inline

Sets a new check point at the current state of this store system.

This is intended to help journalling check point and recovery systems. A check point is set whenever data is committed to the database. Some systems can be designed to be able to roll forward or backward to different check points. Each check point represents a stable state in the database life cycle.

A checkpoint based system greatly improves stability because if a crash occurs in an intermediate state the changes can simply be rolled back to the last stable state.

An implementation may choose not to implement check points in which case this would be a no-op.

Implements Deveel.Data.Store.IStoreSystem.

Definition at line 316 of file SingleFileStoreSystem.cs.

                                     {
             lock (checkPointLock) {
                 try {
                     if (FileSystem.FileExists(TempFileName))
                         FileSystem.DeleteFile(TempFileName);
 
                     using (var dataFile = FileSystem.CreateFile(TempFileName)) {
                         using (var stream = new FileStream(dataFile)) {
                             var dataStartOffset = GetDataStartOffset();
                             WriteHeaders(stream, dataStartOffset);
                             WriteStores(stream);
 
                             stream.Flush();
                         }
                     }
 
                     if (FileSystem.FileExists(FileName))
                         FileSystem.DeleteFile(FileName);
 
                     FileSystem.RenameFile(TempFileName, FileName);
                 } catch (IOException) {
                     throw;
                 } catch (Exception ex) {
                     throw new IOException("An error occurred while saving data to database file.", ex);
                 }
             }
         }

bool Deveel.Data.Store.SingleFileStoreSystem.StoreExists ( string name )

inline

Definition at line 232 of file SingleFileStoreSystem.cs.

                                              {
             SingleFileStore store;
             return TryFindStore(name, out store);
         }

bool Deveel.Data.Store.SingleFileStoreSystem.TryFindStore	(	string	storeName,
		out SingleFileStore	store
	)

inlineprivate

Definition at line 411 of file SingleFileStoreSystem.cs.

                                                                                {
             int id;
             if (nameIdMap == null || !nameIdMap.TryGetValue(storeName, out id)) {
                 store = null;
                 return false;
             }
 
             if (stores == null || !stores.TryGetValue(id, out store)) {
                 store = null;
                 return false;
             }
 
             return true;
         }

void Deveel.Data.Store.SingleFileStoreSystem.Unlock ( string lockName )

inline

Definition at line 434 of file SingleFileStoreSystem.cs.

                                             {
             SingleFileStore store;
             if (!TryFindStore(lockName, out store))
                 return;
 
             store.Unlock();
         }

void Deveel.Data.Store.SingleFileStoreSystem.WriteHeaders	(	Stream	stream,
		long	dataStartOffset
	)

inlineprivate

Definition at line 384 of file SingleFileStoreSystem.cs.

                                                                        {
             var writer = new BinaryWriter(stream, Encoding.Unicode);
             writer.Write(Magic);
             writer.Write(1);
             writer.Write(DateTime.UtcNow.Ticks);
 
             var storeCount = stores == null ? 0 : stores.Count;
             var topId = FindMaxStoreId();
 
             writer.Write(storeCount);
             writer.Write(topId);
 
             long offset = dataStartOffset;
 
             if (stores != null) {
                 storeInfo = new Dictionary<int, StoreInfo>(stores.Count);
 
                 foreach (var store in stores.Values) {
                     offset = WriteStoreInfo(writer, offset, store);
                 }
             }
         }

long Deveel.Data.Store.SingleFileStoreSystem.WriteStoreInfo	(	BinaryWriter	writer,
		long	offset,
		SingleFileStore	store
	)

inlineprivate

Definition at line 364 of file SingleFileStoreSystem.cs.

                                                                                              {
             var nameLength = store.Name.Length;
             var name = store.Name;
             var id = store.Id;
             var size = store.DataLength;
 
             writer.Write(nameLength);
             writer.Write(name.ToCharArray());
 
             writer.Write(id);
             writer.Write(offset);
             writer.Write(size);
 
             storeInfo[store.Id] = new StoreInfo(name, id, offset, size);
 
             offset += store.DataLength;
 
             return offset;
         }

void Deveel.Data.Store.SingleFileStoreSystem.WriteStores ( Stream stream )

inlineprivate

Definition at line 356 of file SingleFileStoreSystem.cs.

                                                 {
             if (stores != null) {
                 foreach (var store in stores.Values) {
                     store.WriteTo(stream);
                 }
             }
         }

Member Data Documentation

readonly object Deveel.Data.Store.SingleFileStoreSystem.checkPointLock = new object()

private

Definition at line 33 of file SingleFileStoreSystem.cs.

IDatabaseContext Deveel.Data.Store.SingleFileStoreSystem.context

private

Definition at line 29 of file SingleFileStoreSystem.cs.

const string Deveel.Data.Store.SingleFileStoreSystem.DefaultFileExtension = "db"

Definition at line 41 of file SingleFileStoreSystem.cs.

bool Deveel.Data.Store.SingleFileStoreSystem.disposed

private

Definition at line 31 of file SingleFileStoreSystem.cs.

const int Deveel.Data.Store.SingleFileStoreSystem.Magic = 0xf09a671

private

Definition at line 43 of file SingleFileStoreSystem.cs.

IDictionary<string, int> Deveel.Data.Store.SingleFileStoreSystem.nameIdMap

private

Definition at line 36 of file SingleFileStoreSystem.cs.

int Deveel.Data.Store.SingleFileStoreSystem.storeId

private

Definition at line 39 of file SingleFileStoreSystem.cs.

IDictionary<int, StoreInfo> Deveel.Data.Store.SingleFileStoreSystem.storeInfo

private

Definition at line 37 of file SingleFileStoreSystem.cs.

IDictionary<int, SingleFileStore> Deveel.Data.Store.SingleFileStoreSystem.stores

private

Definition at line 35 of file SingleFileStoreSystem.cs.

Property Documentation

object Deveel.Data.Store.SingleFileStoreSystem.CheckPointLock

get

Definition at line 126 of file SingleFileStoreSystem.cs.

string Deveel.Data.Store.SingleFileStoreSystem.FileName

getset

Definition at line 86 of file SingleFileStoreSystem.cs.

IFileSystem Deveel.Data.Store.SingleFileStoreSystem.FileSystem

getprivate

Definition at line 122 of file SingleFileStoreSystem.cs.

bool Deveel.Data.Store.SingleFileStoreSystem.IsReadOnly

getset

Definition at line 120 of file SingleFileStoreSystem.cs.

string Deveel.Data.Store.SingleFileStoreSystem.LockFileName

getprivate

Definition at line 92 of file SingleFileStoreSystem.cs.

bool Deveel.Data.Store.SingleFileStoreSystem.ReadOnly

getset

Definition at line 96 of file SingleFileStoreSystem.cs.

string Deveel.Data.Store.SingleFileStoreSystem.TempFileName

getprivate

Definition at line 88 of file SingleFileStoreSystem.cs.

The documentation for this class was generated from the following file:

/var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb/Deveel.Data.Store/SingleFileStoreSystem.cs

Classes

Public Member Functions

Public Attributes

Package Functions

Properties

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation

Property Documentation