/// <summary>
/// This will create a new dbContext, based on <paramref name="dbContext"/> reusing all shared data
/// </summary>
/// <param name="dbContext"></param>
public DBContext(DBContext dbContext)
{
#region Immutable objects
_DBPluginManager = dbContext.DBPluginManager;
_DBSettingsManager = dbContext.DBSettingsManager;
_IGraphFSSession = dbContext._IGraphFSSession;
#endregion
_SessionSettings = new DBSessionSettings(dbContext.SessionSettings);
_DBObjectManager = new ObjectManagement.DBObjectManager(this, _IGraphFSSession);
//
_DBIndexManager = new Indices.DBIndexManager(_IGraphFSSession, this);
_DBTypeManager = new DBTypeManager(dbContext.DBTypeManager);
_DBObjectCache = _DBObjectManager.GetSimpleDBObjectCache(this);
}
/// <summary>
/// The constructor.
/// </summary>
/// <param name="myIGraphDBSession">The filesystem where the information is stored.</param>
/// <param name="DatabaseRootPath">The database root path.</param>
public DBContext(IGraphFSSession graphFSSession, ObjectLocation myDatabaseRootPath, EntityUUID myUserID, Dictionary<String, ADBSettingsBase> myDBSettings, Boolean myRebuildIndices, DBPluginManager myDBPluginManager, DBSessionSettings sessionSettings = null)
{
_DBPluginManager = myDBPluginManager;
_DBTypeManager = new TypeManagement.DBTypeManager(graphFSSession, myDatabaseRootPath, myUserID, myDBSettings, this);
_DBSettingsManager = new DBSettingsManager(_DBPluginManager.Settings, myDBSettings, graphFSSession, new ObjectLocation(myDatabaseRootPath.Name, DBConstants.DBSettingsLocation));
_DBObjectManager = new DBObjectManager(this, graphFSSession);
_DBIndexManager = new DBIndexManager(graphFSSession, this);
_SessionSettings = sessionSettings;
_DBObjectCache = _DBObjectManager.GetSimpleDBObjectCache(this);
_IGraphFSSession = graphFSSession;
//init types
var initExcept = _DBTypeManager.Init(graphFSSession, myDatabaseRootPath, myRebuildIndices);
if (initExcept.Failed())
{
throw new GraphDBException(initExcept.IErrors);
}
}
/// <summary>
/// A reference to this index after it was loaded into the memory
/// or connected by a proxy class
/// </summary>
private Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>> GetIndexReference(DBIndexManager indexManager)
{
if (_indexReference == null)
{
if (!indexManager.HasIndex(IndexType))
{
// the index type does not exist anymore - return null or throw exception
return new Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>>(new GraphDBError("Index is away!"));
}
var emptyIdx = indexManager.GetIndex(IndexType);
if (!emptyIdx.Success())
{
return emptyIdx;
}
var indexExceptional = indexManager.LoadOrCreateDBIndex(FileSystemLocation, emptyIdx.Value);
if (indexExceptional.Failed())
{
return new Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>>(indexExceptional);
}
_indexReference = indexExceptional.Value;
}
return new Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>>(_indexReference);
}
public abstract Exceptional ClearAndRemoveFromDisc(DBIndexManager indexManager);
public override Exceptional ClearAndRemoveFromDisc(DBIndexManager indexManager)
{
_indexReference = null;
return indexManager.RemoveDBIndex(FileSystemLocation);
}
internal Exceptional Insert(IndexKey indexKey, HashSet<ObjectUUID> hashSet, int shard, DBIndexManager dBIndexManager, GraphDBType myTypeOfDBObject)
{
//get the actual shard
var currentIdxShard = GetIndexReference(dBIndexManager, shard);
if (!currentIdxShard.Success())
{
return new Exceptional(currentIdxShard);
}
#region Check for uniqueness - TODO: remove me as soon as we have a unique indexObject implementation
if (IsUniqueAttributeIndex)
{
if (currentIdxShard.Value.ContainsKey(indexKey))
{
return new Exceptional(new Error_UniqueConstrainViolation(myTypeOfDBObject.Name, IndexName));
}
}
#endregion
UInt64 previousKeyCount = currentIdxShard.Value.KeyCount();
HashSet<ObjectUUID> value = null;
currentIdxShard.Value.TryGetValue(indexKey, out value);
if (value == null)
{
currentIdxShard.Value.Set(indexKey, hashSet, IndexSetStrategy.MERGE);
IncreaseKeyCount();
IncreaseValueCount((UInt64)hashSet.Count);
}
else
{
currentIdxShard.Value.Add(indexKey, hashSet);
IncreaseValueCount((UInt64)currentIdxShard.Value[indexKey].Count);
}
return Exceptional.OK;
}
internal Exceptional Remove(IndexKey indexKey, int shard, DBIndexManager myDBIndexManager)
{
//get the actual shard
var currentIdxShard = GetIndexReference(myDBIndexManager, shard);
if (!currentIdxShard.Success())
{
return new Exceptional(currentIdxShard);
}
HashSet<ObjectUUID> removedItems = null;
currentIdxShard.Value.TryGetValue(indexKey, out removedItems);
if (removedItems != null)
{
currentIdxShard.Value.Remove(indexKey);
DecreaseKeyCount();
DecreaseValueCount((UInt64)removedItems.Count);
}
return Exceptional.OK;
}
/// <summary>
/// A reference to this index after it was loaded into the memory
/// or connected by a proxy class
/// </summary>
/// <param name="indexManager">The database index manager</param>
/// <param name="idxShard">The shard that should be loaded</param>
/// <returns>A versioned idx object</returns>
public Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>> GetIndexReference(DBIndexManager indexManager, int idxShard)
{
if (!indexManager.HasIndex(IndexType))
{
// the index type does not exist anymore - return null or throw exception
return new Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>>(new GraphDBError("Index is away!"));
}
var emptyIdx = new VersionedHashIndexObject<IndexKey, ObjectUUID>();
var indexExceptional = indexManager.LoadOrCreateShardedDBIndex(FileSystemLocation + idxShard.ToString(), emptyIdx, this);
if (indexExceptional.Failed())
{
return new Exceptional<IVersionedIndexObject<IndexKey, ObjectUUID>>(indexExceptional);
}
return indexExceptional;
}
public override Exceptional ClearAndRemoveFromDisc(DBIndexManager indexManager)
{
lock (_lockObject)
{
_valueCount = 0;
_keyCount = 0;
}
return indexManager.RemoveDBIndex(FileSystemLocation);
}
public override Exceptional ClearAndRemoveFromDisc(DBIndexManager indexManager)
{
//do not clear anything, just update the number of objects
lock (_lockObject)
{
_numberOfObjects = 0;
}
return new Exceptional();
}
private Exceptional Insert(IndexKey indexKey, HashSet<ObjectUUID> hashSet, int shard, DBIndexManager dBIndexManager, GraphDBType myTypeOfDBObject)
{
#region Check for uniqueness - TODO: remove me as soon as we have a unique indexObject implementation
if (IsUniqueAttributeIndex)
{
if (_indexDatastructure.ContainsKey(indexKey))
{
return new Exceptional(new Error_UniqueConstrainViolation(myTypeOfDBObject.Name, IndexName));
}
}
#endregion
UInt64 previousKeyCount = _keyCount;
HashSet<ObjectUUID> value = null;
_indexDatastructure.TryGetValue(indexKey, out value);
if (value == null)
{
_indexDatastructure.Set(indexKey, hashSet, IndexSetStrategy.MERGE);
IncreaseKeyCount();
IncreaseValueCount((UInt64)hashSet.Count);
}
else
{
_indexDatastructure.Add(indexKey, hashSet);
IncreaseValueCount((UInt64)_indexDatastructure[indexKey].Count);
}
return Exceptional.OK;
}
public override Exceptional ClearAndRemoveFromDisc(DBIndexManager indexManager)
{
return new Exceptional(new Error_InvalidIndexOperation(IndexName, "Clear"));
}
