public ODBAdapter(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine) :
base()
{
this.storageEngine = storageEngine;
this.classIntrospector = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClassIntrospector
();
}
public virtual void Test1()
{
if (!isLocal)
{
return;
}
DeleteBase(FileName);
NeoDatis.Odb.Core.Layers.Layer3.IBaseIdentification parameter = new NeoDatis.Odb.Core.Layers.Layer3.IOFileParameter
(NeoDatis.Odb.Test.ODBTest.Directory + FileName, true, null, null);
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine = NeoDatis.Odb.OdbConfiguration
.GetCoreProvider().GetClientStorageEngine(parameter);
NeoDatis.Odb.Test.VO.Login.Function function1 = new NeoDatis.Odb.Test.VO.Login.Function
("login");
engine.Store(function1);
NeoDatis.Odb.Test.VO.Login.Function function2 = new NeoDatis.Odb.Test.VO.Login.Function
("login2");
engine.Store(function2);
engine.Commit();
engine.Close();
engine = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClientStorageEngine(parameter
);
System.Collections.Generic.IList <long> l = engine.GetAllObjectIds();
AssertEquals(2, l.Count);
engine.Close();
DeleteBase(FileName);
}
public LazyBTreeCollection(int size, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
engine, bool returnObjects) : base(size, NeoDatis.Odb.Core.OrderByConstants.OrderByAsc
)
{
this.storageEngine = engine;
this.returnObjects = returnObjects;
}
public virtual void Close()
{
if (NeoDatis.Odb.OdbConfiguration.IsInfoEnabled(LogId))
{
NeoDatis.Tool.DLogger.Info("ODBServer:Shutting down ODB Server");
}
try
{
isRunning = false;
socketServer.Close();
System.Collections.IEnumerator iterator = bases.Keys.GetEnumerator();
string baseIdentifier = null;
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine = null;
while (iterator.MoveNext())
{
baseIdentifier = (string)iterator.Current;
engine = (NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine)bases[baseIdentifier];
if (NeoDatis.Odb.OdbConfiguration.IsInfoEnabled(LogId))
{
NeoDatis.Tool.DLogger.Info("ODBServer:Closing Base " + baseIdentifier);
}
engine.Close();
}
if (thread != null)
{
thread.Interrupt();
}
}
catch (System.Exception e)
{
throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.Error.ServerError.AddParameter
("While closing server"), e);
}
}
public virtual void TestSize()
{
DeleteBase("writing.neodatis");
DeleteBase("writing");
DeleteBase("reserving.neodatis");
DeleteBase("reserving");
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine1 = NeoDatis.Odb.OdbConfiguration
.GetCoreProvider().GetClientStorageEngine(new NeoDatis.Odb.Core.Layers.Layer3.IOFileParameter
(NeoDatis.Odb.Test.ODBTest.Directory + "writing.neodatis", true, null, null));
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine2 = NeoDatis.Odb.OdbConfiguration
.GetCoreProvider().GetClientStorageEngine(new NeoDatis.Odb.Core.Layers.Layer3.IOFileParameter
(NeoDatis.Odb.Test.ODBTest.Directory + "reserving.neodatis", true, null, null));
NeoDatis.Odb.Core.Layers.Layer3.Engine.IFileSystemInterface writingFsi = engine1.
GetObjectWriter().GetFsi();
NeoDatis.Odb.Core.Layers.Layer3.Engine.IFileSystemInterface reservingFsi = engine2
.GetObjectWriter().GetFsi();
AssertEquals(writingFsi.GetLength(), reservingFsi.GetLength());
Write(writingFsi, false);
Write(reservingFsi, true);
AssertEquals(writingFsi.GetLength(), reservingFsi.GetLength());
engine1.Commit();
engine1.Close();
engine2.Commit();
engine2.Close();
DeleteBase("writing.neodatis");
DeleteBase("reserving.neodatis");
}
public virtual void TestDirectSave()
{
if (!isLocal)
{
return;
}
NeoDatis.Odb.OdbConfiguration.SetSaveHistory(true);
DeleteBase("btree.neodatis");
NeoDatis.Odb.ODB odb = Open("btree.neodatis");
Function function = new Function
("f1");
odb.Store(function);
for (int i = 0; i < 2; i++)
{
function.SetName(function.GetName() + function.GetName() + function.GetName() + function
.GetName());
odb.Store(function);
}
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine = NeoDatis.Odb.Impl.Core.Layers.Layer3.Engine.Dummy
.GetEngine(odb);
if (isLocal)
{
}
NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = engine.GetSession(true).GetMetaModel
().GetClassInfo(typeof(Function).FullName, true);
Println(ci);
AssertEquals(null, ci.GetCommitedZoneInfo().first);
AssertEquals(null, ci.GetCommitedZoneInfo().last);
AssertEquals(1, ci.GetUncommittedZoneInfo().GetNbObjects());
odb.Close();
}
/// <summary>Returns a multi class query executor (polymorphic = true)</summary>
/// <param name="query"></param>
/// <param name="engine"></param>
/// <param name="instanceBuilder"></param>
/// <returns></returns>
protected static NeoDatis.Odb.Core.Query.Execution.IQueryExecutor GetMultiClassQueryExecutor
(NeoDatis.Odb.Core.Query.IQuery query, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
engine, NeoDatis.Odb.Core.Layers.Layer2.Instance.IInstanceBuilder instanceBuilder
)
{
if (typeof(NeoDatis.Odb.Impl.Core.Query.Criteria.CriteriaQuery) == query.GetType(
))
{
return(new NeoDatis.Odb.Core.Query.Execution.MultiClassGenericQueryExecutor(new NeoDatis.Odb.Impl.Core.Query.Criteria.CriteriaQueryExecutor
(query, engine)));
}
if (typeof(NeoDatis.Odb.Impl.Core.Query.Values.ValuesCriteriaQuery) == query.GetType
())
{
return(new NeoDatis.Odb.Core.Query.Execution.MultiClassGenericQueryExecutor(new NeoDatis.Odb.Impl.Core.Query.Values.ValuesCriteriaQueryExecutor
(query, engine)));
}
if (typeof(NeoDatis.Odb.Core.Query.NQ.NativeQuery).IsAssignableFrom(query.GetType
()))
{
return(new NeoDatis.Odb.Core.Query.Execution.MultiClassGenericQueryExecutor(new NeoDatis.Odb.Impl.Core.Query.NQ.NativeQueryExecutor
(query, engine, instanceBuilder)));
}
if (typeof(NeoDatis.Odb.Core.Query.NQ.SimpleNativeQuery).IsAssignableFrom(query.GetType
()))
{
return(new NeoDatis.Odb.Core.Query.Execution.MultiClassGenericQueryExecutor(new NeoDatis.Odb.Impl.Core.Query.NQ.NativeQueryExecutor
(query, engine, instanceBuilder)));
}
throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.QueryTypeNotImplemented
.AddParameter(query.GetType().FullName));
}
/// <param name="tree"></param>
/// <param name="orderByType"></param>
/// <param name="storageEngine"></param>
/// <param name="returnObjects"></param>
public LazyODBBTreeIteratorMultiple(NeoDatis.Btree.IBTree tree, NeoDatis.Odb.Core.OrderByConstants
orderByType, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine, bool
returnObjects) : base(tree, orderByType)
{
this.storageEngine = storageEngine;
this.returnObjects = returnObjects;
}
public ValuesQueryResultAction(NeoDatis.Odb.Core.Query.IValuesQuery query, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
storageEngine, NeoDatis.Odb.Core.Layers.Layer2.Instance.IInstanceBuilder instanceBuilder
) : base()
{
this.engine = storageEngine;
this.query = query;
this.queryHasOrderBy = query.HasOrderBy();
this.instanceBuilder = instanceBuilder;
this.returnArraySize = query.GetObjectActions().Count;
System.Collections.IEnumerator iterator = query.GetObjectActions().GetEnumerator(
);
NeoDatis.Odb.Core.Query.Execution.IQueryFieldAction qfa = null;
queryFieldActions = new NeoDatis.Odb.Core.Query.Execution.IQueryFieldAction[returnArraySize
];
int i = 0;
while (iterator.MoveNext())
{
qfa = (NeoDatis.Odb.Core.Query.Execution.IQueryFieldAction)iterator.Current;
queryFieldActions[i] = qfa.Copy();
queryFieldActions[i].SetReturnInstance(query.ReturnInstance());
queryFieldActions[i].SetInstanceBuilder(instanceBuilder);
i++;
}
}
public virtual void Test1()
{
if (!isLocal)
{
return;
}
DeleteBase("unconnected");
NeoDatis.Odb.ODB odb = Open("unconnected");
NeoDatis.Odb.OID oid = odb.Store(new NeoDatis.Odb.Test.VO.Login.Function("f1"));
odb.Close();
Println("Oid=" + oid);
odb = Open("unconnected");
NeoDatis.Odb.Test.VO.Login.Function f2 = (NeoDatis.Odb.Test.VO.Login.Function)odb
.GetObjectFromId(oid);
f2.SetName("New Function");
odb.Store(f2);
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine = NeoDatis.Odb.Impl.Core.Layers.Layer3.Engine.Dummy
.GetEngine(odb);
// retrieve the class info to check connected and unconnected zone
NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = storageEngine.GetSession(true
).GetMetaModel().GetClassInfo(typeof(NeoDatis.Odb.Test.VO.Login.Function).FullName
, true);
odb.Close();
AssertEquals(1, ci.GetCommitedZoneInfo().GetNbObjects());
AssertNotNull(ci.GetCommitedZoneInfo().first);
AssertNotNull(ci.GetCommitedZoneInfo().last);
AssertEquals(0, ci.GetUncommittedZoneInfo().GetNbObjects());
AssertNull(ci.GetUncommittedZoneInfo().first);
AssertNull(ci.GetUncommittedZoneInfo().last);
odb = Open("unconnected");
AssertEquals(1, odb.GetObjects <Function>().Count
);
odb.Close();
}
public ServerSession(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine, string
sessionId) : base(engine, sessionId)
{
classInfoIds = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <string, NeoDatis.Odb.OID
>();
this.sessionManager = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClientServerSessionManager
();
}
public override void Clear()
{
base.Clear();
if (transaction != null)
{
transaction.Clear();
}
storageEngine = null;
}
public ConnectionManager(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine)
{
// A map that contains oids that are locked. The key is the oid, the value is the connection that hold the object
this.storageEngine = engine;
connections = new NeoDatis.Tool.Wrappers.Map.OdbHashMap<string, NeoDatis.Odb.Core.Server.Connection.IConnection
>();
lockedOids = new NeoDatis.Tool.Wrappers.Map.OdbHashMap<NeoDatis.Odb.OID, NeoDatis.Odb.Core.Server.Connection.IConnection
>();
}
public LocalObjectIntrospector(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine
)
{
// private MetaModel localMetaModel;
this.storageEngine = storageEngine;
this.classIntrospector = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClassIntrospector
();
this.classPool = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClassPool();
}
public ConnectionManager(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine)
{
// A map that contains oids that are locked. The key is the oid, the value is the connection that hold the object
this.storageEngine = engine;
connections = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <string, NeoDatis.Odb.Core.Server.Connection.IConnection
>();
lockedOids = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <NeoDatis.Odb.OID, NeoDatis.Odb.Core.Server.Connection.IConnection
>();
}
public DefaultClassRepresentation(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
storageEngine, NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo classInfo) : base(
)
{
this.storageEngine = storageEngine;
this.classInfo = classInfo;
this.classIntrospector = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClassIntrospector
();
}
public LocalObjectIntrospector(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine
)
{
// private MetaModel localMetaModel;
this.storageEngine = storageEngine;
this.classIntrospector = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClassIntrospector
();
this.classPool = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClassPool();
}
public DefaultClassRepresentation(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
storageEngine, NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo classInfo) : base(
)
{
this.storageEngine = storageEngine;
this.classInfo = classInfo;
this.classIntrospector = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClassIntrospector
();
}
private bool CheckIfCollectionContainsValue(System.Collections.ICollection c)
{
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine = GetQuery().GetStorageEngine
();
if (engine == null)
{
throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.QueryEngineNotSet
);
}
NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo aoi = null;
System.Collections.IEnumerator iterator = c.GetEnumerator();
// If the object to compared is native
if (objectIsNative)
{
while (iterator.MoveNext())
{
aoi = (NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo)iterator.Current;
if (aoi == null && criterionValue == null)
{
return(true);
}
if (aoi != null && criterionValue == null)
{
return(false);
}
if (criterionValue.Equals(aoi.GetObject()))
{
return(true);
}
}
return(false);
}
// Object is not native
while (iterator.MoveNext())
{
aoi = (NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo)iterator.Current;
if (aoi.IsNull() && criterionValue == null && oid == null)
{
return(true);
}
if (aoi != null & oid != null)
{
if (aoi.IsNonNativeObject())
{
NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo nnoi1 = (NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo
)aoi;
bool isEqual = nnoi1.GetOid() != null && oid != null && nnoi1.GetOid().Equals(oid
);
if (isEqual)
{
return(true);
}
}
}
}
return(false);
}
public GenericQueryExecutor(NeoDatis.Odb.Core.Query.IQuery query, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
engine)
{
this.query = query;
this.storageEngine = engine;
this.objectReader = storageEngine.GetObjectReader();
this.session = storageEngine.GetSession(true);
this.callback = NeoDatis.Odb.OdbConfiguration.GetQueryExecutorCallback();
this.executeStartAndEndOfQueryAction = true;
}
public ClientObjectIntrospector(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine
, string connectionId) : base(storageEngine)
{
clientOids = new NeoDatis.Tool.Wrappers.List.OdbArrayList <NeoDatis.Odb.OID>();
aois = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <NeoDatis.Odb.OID, NeoDatis.Odb.Core.Server.Layers.Layer2.Meta.ClientNonNativeObjectInfo
>();
objects = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <NeoDatis.Odb.OID, object>();
sessionManager = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetClientServerSessionManager
();
this.connectionId = connectionId;
}
public GroupByValuesQueryResultAction(NeoDatis.Odb.Core.Query.IValuesQuery query,
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine, NeoDatis.Odb.Core.Layers.Layer2.Instance.IInstanceBuilder
instanceBuilder) : base()
{
this.query = query;
this.queryHasOrderBy = query.HasOrderBy();
this.instanceBuilder = instanceBuilder;
this.returnArraySize = query.GetObjectActions().Count;
this.groupByFieldList = query.GetGroupByFieldList();
this.groupByResult = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <NeoDatis.Tool.Wrappers.OdbComparable
, NeoDatis.Odb.Impl.Core.Query.Values.ValuesQueryResultAction>();
}
public virtual void Test2B()
{
if (!isLocal)
{
return;
}
NeoDatis.Odb.Core.Layers.Layer3.Engine.IByteArrayConverter byteArrayConverter = NeoDatis.Odb.OdbConfiguration
.GetCoreProvider().GetByteArrayConverter();
DeleteBase("test78.neodatis");
// 155 : to avoid protected zone
NeoDatis.Odb.Core.Transaction.IWriteAction wa1 = new NeoDatis.Odb.Impl.Core.Transaction.DefaultWriteAction
(300 + 1, byteArrayConverter.IntToByteArray(1), "size");
NeoDatis.Odb.Core.Transaction.IWriteAction wa2 = new NeoDatis.Odb.Impl.Core.Transaction.DefaultWriteAction
(300 + 15, byteArrayConverter.StringToByteArray(" 1 - ol√° chico! - 1", true, -1
, true), "name");
NeoDatis.Odb.Core.Transaction.IWriteAction wa3 = new NeoDatis.Odb.Impl.Core.Transaction.DefaultWriteAction
(300 + 1, byteArrayConverter.IntToByteArray(2), "size");
NeoDatis.Odb.Core.Transaction.IWriteAction wa4 = new NeoDatis.Odb.Impl.Core.Transaction.DefaultWriteAction
(300 + 15, byteArrayConverter.StringToByteArray(" 2 - ol√° chico! - 2", true, -1
, true), "name");
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine se = NeoDatis.Odb.OdbConfiguration
.GetCoreProvider().GetClientStorageEngine(new NeoDatis.Odb.Core.Layers.Layer3.IOFileParameter
(NeoDatis.Odb.Test.ODBTest.Directory + "test78.neodatis", true, null, null));
// se.close();
NeoDatis.Odb.Core.Layers.Layer3.Engine.IFileSystemInterface fsi = se.GetObjectWriter
().GetFsi();
// new FileSystemInterface(null,se.getSession(),new
// IOFileParameter("test.neodatis",true),false,Configuration.getDefaultBufferSizeForData());
NeoDatis.Odb.Core.Transaction.ITransaction transaction = se.GetSession(true).GetTransaction
();
transaction.SetArchiveLog(true);
transaction.ManageWriteAction(wa1.GetPosition(), wa1.GetBytes(0));
transaction.ManageWriteAction(wa2.GetPosition(), wa2.GetBytes(0));
transaction.ManageWriteAction(wa3.GetPosition(), wa3.GetBytes(0));
transaction.ManageWriteAction(wa4.GetPosition(), wa4.GetBytes(0));
// transaction.getFsi().flush();
NeoDatis.Odb.Core.Transaction.IWriteAction wat1 = (NeoDatis.Odb.Core.Transaction.IWriteAction
)((NeoDatis.Odb.Impl.Core.Transaction.DefaultTransaction)transaction).GetWriteActions
()[2];
byte[] bytes = wat1.GetBytes(0);
transaction.Commit();
NeoDatis.Odb.Impl.Core.Transaction.DefaultTransaction transaction2 = NeoDatis.Odb.Impl.Core.Transaction.DefaultTransaction
.Read(NeoDatis.Odb.Test.ODBTest.Directory + transaction.GetName());
NeoDatis.Odb.Core.Transaction.IWriteAction wat2 = (NeoDatis.Odb.Core.Transaction.IWriteAction
)transaction2.GetWriteActions()[2];
AssertEquals(NeoDatis.Tool.DisplayUtility.ByteArrayToString(bytes), NeoDatis.Tool.DisplayUtility
.ByteArrayToString(wat2.GetBytes(0)));
AssertEquals(wat1.GetPosition(), wat2.GetPosition());
transaction2.Rollback();
fsi.Close();
DeleteBase("test78.neodatis");
DeleteBase(transaction.GetName());
}
public DefaultServerConnection(NeoDatis.Odb.Core.Server.Connection.ConnectionManager
connectionManager, string connectionId, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
storageEngine)
{
this.connectionManager = connectionManager;
this.id = connectionId;
this.storageEngine = storageEngine;
this.baseIdentifier = storageEngine.GetBaseIdentification().GetIdentification();
this.oidsLockedForUpdate = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <NeoDatis.Odb.OID
, long>();
actions = new int[NeoDatis.Odb.Core.Server.Connection.ConnectionAction.GetNumberOfActions
()];
}
public Connection(NeoDatis.Odb.Core.Server.Connection.ConnectionManager connectionManager
, string connectionId, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine
)
{
this.connectionManager = connectionManager;
this.id = connectionId;
this.storageEngine = storageEngine;
this.baseIdentifier = storageEngine.GetBaseIdentification().GetIdentification();
this.oidsLockedForUpdate = new System.Collections.Generic.Dictionary <NeoDatis.Odb.OID
, long>();
actions = new int[NeoDatis.Odb.Core.Server.Connection.ConnectionAction.GetNumberOfActions
()];
}
public Connection(NeoDatis.Odb.Core.Server.Connection.ConnectionManager connectionManager
, string connectionId, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine
)
{
this.connectionManager = connectionManager;
this.id = connectionId;
this.storageEngine = storageEngine;
this.baseIdentifier = storageEngine.GetBaseIdentification().GetIdentification();
this.oidsLockedForUpdate = new System.Collections.Generic.Dictionary<NeoDatis.Odb.OID
, long>();
actions = new int[NeoDatis.Odb.Core.Server.Connection.ConnectionAction.GetNumberOfActions
()];
}
public DefaultServerConnection(NeoDatis.Odb.Core.Server.Connection.ConnectionManager
connectionManager, string connectionId, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
storageEngine)
{
this.connectionManager = connectionManager;
this.id = connectionId;
this.storageEngine = storageEngine;
this.baseIdentifier = storageEngine.GetBaseIdentification().GetIdentification();
this.oidsLockedForUpdate = new NeoDatis.Tool.Wrappers.Map.OdbHashMap<NeoDatis.Odb.OID
, long>();
actions = new int[NeoDatis.Odb.Core.Server.Connection.ConnectionAction.GetNumberOfActions
()];
}
public CollectionQueryResultAction(NeoDatis.Odb.Core.Query.IQuery query, bool inMemory
, NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine, bool returnObjects
, NeoDatis.Odb.Core.Layers.Layer2.Instance.IInstanceBuilder instanceBuilder) : base
()
{
// TODO check if Object is ok here
this.query = query;
this.inMemory = inMemory;
this.storageEngine = storageEngine;
this.returnObjects = returnObjects;
this.queryHasOrderBy = query.HasOrderBy();
this.instanceBuilder = instanceBuilder;
}
public DefaultInstrumentationCallbackForStore(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
engine, NeoDatis.Odb.Core.Trigger.ITriggerManager triggerManager, bool isUpdate
) : base()
{
this.engine = engine;
this.triggerManager = triggerManager;
this.isUpdate = isUpdate;
// Just for junits
if (engine != null)
{
this.crossSessionCache = NeoDatis.Odb.Impl.Core.Transaction.CacheFactory.GetCrossSessionCache
(engine.GetBaseIdentification().GetIdentification());
}
}
public DefaultInstrumentationCallbackForStore(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
engine, NeoDatis.Odb.Core.Trigger.ITriggerManager triggerManager, bool isUpdate
) : base()
{
this.engine = engine;
this.triggerManager = triggerManager;
this.isUpdate = isUpdate;
// Just for junits
if (engine != null)
{
this.crossSessionCache = NeoDatis.Odb.Impl.Core.Transaction.CacheFactory.GetCrossSessionCache
(engine.GetBaseIdentification().GetIdentification());
}
}
/// <exception cref="System.Exception"></exception>
public virtual void Test1()
{
if (!isLocal)
{
return;
}
DeleteBase("btree45.neodatis");
NeoDatis.Odb.ODB odb = Open("btree45.neodatis");
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine = NeoDatis.Odb.Impl.Core.Layers.Layer3.Engine.Dummy
.GetEngine(odb);
NeoDatis.Odb.Impl.Core.Btree.LazyODBBTreePersister persister = new NeoDatis.Odb.Impl.Core.Btree.LazyODBBTreePersister
(storageEngine);
NeoDatis.Btree.IBTreeMultipleValuesPerKey tree = new NeoDatis.Odb.Impl.Core.Btree.ODBBTreeMultiple
("t", 3, persister);
tree.Insert(1, new NeoDatis.Odb.Test.Btree.Odb.MyObject("Value 1"));
tree.Insert(20, new NeoDatis.Odb.Test.Btree.Odb.MyObject("Value 20"));
tree.Insert(25, new NeoDatis.Odb.Test.Btree.Odb.MyObject("Value 25"));
tree.Insert(29, new NeoDatis.Odb.Test.Btree.Odb.MyObject("Value 29"));
tree.Insert(21, new NeoDatis.Odb.Test.Btree.Odb.MyObject("Value 21"));
AssertEquals(5, tree.GetRoot().GetNbKeys());
AssertEquals(0, tree.GetRoot().GetNbChildren());
AssertEquals(21, tree.GetRoot().GetMedian().GetKey());
AssertEquals("[Value 21]", tree.GetRoot().GetMedian().GetValue().ToString());
AssertEquals(0, tree.GetRoot().GetNbChildren());
// println(tree.getRoot());
tree.Insert(45, new NeoDatis.Odb.Test.Btree.Odb.MyObject("Value 45"));
AssertEquals(2, tree.GetRoot().GetNbChildren());
AssertEquals(1, tree.GetRoot().GetNbKeys());
AssertEquals(21, tree.GetRoot().GetKeyAt(0));
AssertEquals("[Value 21]", tree.GetRoot().GetValueAsObjectAt(0).ToString());
persister.Close();
odb = Open("btree45.neodatis");
storageEngine = NeoDatis.Odb.Impl.Core.Layers.Layer3.Engine.Dummy.GetEngine(odb);
persister = new NeoDatis.Odb.Impl.Core.Btree.LazyODBBTreePersister(storageEngine);
tree = (NeoDatis.Btree.IBTreeMultipleValuesPerKey)persister.LoadBTree(tree.GetId(
));
AssertEquals(6, tree.GetSize());
// println(tree.getRoot());
NeoDatis.Odb.Test.Btree.Odb.MyObject o = (NeoDatis.Odb.Test.Btree.Odb.MyObject)tree
.Search(20)[0];
AssertEquals("Value 20", o.GetName());
o = (NeoDatis.Odb.Test.Btree.Odb.MyObject)tree.Search(29)[0];
AssertEquals("Value 29", o.GetName());
o = (NeoDatis.Odb.Test.Btree.Odb.MyObject)tree.Search(45)[0];
AssertEquals("Value 45", o.GetName());
odb.Close();
DeleteBase("btree45.neodatis");
}
public LazyODBBTreePersister(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine
)
{
// See the map strategy performance test at
// test/org.neodatis.odb.test.performance.TestMapPerf
// TODO create a boolean value to know if data must be saved on update or
// only at the end
oids = new System.Collections.Generic.Dictionary<NeoDatis.Odb.OID, object>();
modifiedObjectOids = new NeoDatis.Tool.Wrappers.Map.OdbHashMap<object, int>();
modifiedObjectOidList = new NeoDatis.Tool.Wrappers.List.OdbArrayList<NeoDatis.Odb.OID
>(500);
this.engine = engine;
this.engine.AddCommitListener(this);
smap = oids;
smodifiedObjects = modifiedObjectOids;
}
public LazyODBBTreePersister(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine
)
{
// See the map strategy performance test at
// test/org.neodatis.odb.test.performance.TestMapPerf
// TODO create a boolean value to know if data must be saved on update or
// only at the end
oids = new System.Collections.Generic.Dictionary <NeoDatis.Odb.OID, object>();
modifiedObjectOids = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <object, int>();
modifiedObjectOidList = new NeoDatis.Tool.Wrappers.List.OdbArrayList <NeoDatis.Odb.OID
>(500);
this.engine = engine;
this.engine.AddCommitListener(this);
smap = oids;
smodifiedObjects = modifiedObjectOids;
}
public AbstractObjectWriter(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine
)
{
// public ISession session;
// Just for display matters
this.storageEngine = engine;
this.objectReader = storageEngine.GetObjectReader();
this.isLocalMode = this.storageEngine.IsLocal();
NeoDatis.Odb.Core.ICoreProvider provider = NeoDatis.Odb.OdbConfiguration.GetCoreProvider
();
this.byteArrayConverter = provider.GetByteArrayConverter();
this.classIntrospector = provider.GetClassIntrospector();
NativeHeaderBlockSizeByte = byteArrayConverter.IntToByteArray(NativeHeaderBlockSize
);
comparator = new NeoDatis.Odb.Impl.Core.Layers.Layer2.Meta.Compare.ObjectInfoComparator
();
}
public virtual void AddBase(string baseIdentifier, string fileName, string user,
string password)
{
NeoDatis.Odb.Core.Server.Layers.Layer3.ServerFileParameter fileParameter = new NeoDatis.Odb.Core.Server.Layers.Layer3.ServerFileParameter
(baseIdentifier, fileName, true);
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine = null;
engine = NeoDatis.Odb.OdbConfiguration.GetCoreProvider().GetServerStorageEngine(fileParameter
, user, password);
engine.Commit();
bases.Add(baseIdentifier, engine);
connectionManagers.Add(baseIdentifier, new NeoDatis.Odb.Core.Server.Connection.ConnectionManager
(engine));
if (NeoDatis.Odb.OdbConfiguration.IsInfoEnabled(LogId))
{
NeoDatis.Tool.DLogger.Info("ODBServer:Adding base : name=" + baseIdentifier + " (file="
+ fileName + ") to server");
}
}
// TODO Auto-generated constructor stub
/// <exception cref="System.Exception"></exception>
public static void Main(string[] args)
{
//LogUtil.allOn(true);
NeoDatis.Odb.Configuration.SetCheckModelCompatibility(false);
string fileName = "array1.odb";
string user = "******";
string password = "******";
NeoDatis.Odb.Core.Layers.Layer3.IBaseIdentification parameter = new NeoDatis.Odb.Core.Layers.Layer3.IOFileParameter
(fileName, false);
//IStorageEngine engine = StorageEngineFactory.get(parameter,user,password);
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine = NeoDatis.Odb.Configuration
.GetCoreProvider().GetClientStorageEngine(parameter, null, null);
System.Collections.IList l = engine.GetAllObjectIdInfos(null, true);
//"br.com.ccr.sct.dav.vo.RelFunctionProfile",true);
NeoDatis.Tool.DisplayUtility.Display("All ids", l);
engine.Close();
}
public virtual void Test1()
{
string baseName = "name.neodatis";
NeoDatis.Odb.ODB odb = Open(baseName);
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine = NeoDatis.Odb.Impl.Core.Layers.Layer3.Engine.Dummy
.GetEngine(odb);
string s = engine.GetBaseIdentification().GetIdentification();
if (isLocal)
{
AssertEquals(baseName, s);
}
else
{
AssertEquals("unit-test-data/[email protected]:13000", s);
}
}
public virtual void Test1()
{
NeoDatis.Odb.ODB odb = Open("withoid");
NeoDatis.Odb.OID oid = odb.Store(new NeoDatis.Odb.Test.VO.Login.Function("f1"));
odb.Close();
odb = Open("withoid");
NeoDatis.Odb.Test.VO.Login.Function f2 = new NeoDatis.Odb.Test.VO.Login.Function(
"f2");
NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine = NeoDatis.Odb.Impl.Core.Layers.Layer3.Engine.Dummy
.GetEngine(odb);
engine.Store(oid, f2);
odb.Close();
odb = Open("withoid");
NeoDatis.Odb.Test.VO.Login.Function f = (NeoDatis.Odb.Test.VO.Login.Function)odb.
GetObjectFromId(oid);
odb.Close();
AssertEquals("f2", f.GetName());
}
public LocalSession(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine, string
sessionId) : base(sessionId, engine.GetBaseIdentification().GetIdentification()
)
{
this.storageEngine = engine;
}
public ODBExtImpl(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine)
{
this.engine = storageEngine;
}
public ConsoleLogger(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine)
{
this.engine = engine;
i = 0;
}
public DefaultTriggerManager(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine
)
{
this.storageEngine = engine;
Init();
}
public DefaultRefactorManager(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine storageEngine
)
{
this.storageEngine = storageEngine;
}
public ClientSession(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine engine) : base
("client", engine.GetBaseIdentification().GetIdentification())
{
this.engine = engine;
}
public virtual void SetStorageEngine(NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine
storageEngine)
{
this.storageEngine = storageEngine;
}
public virtual void Close()
{
objectReader = null;
if (idManager != null)
{
idManager.Clear();
idManager = null;
}
storageEngine = null;
fsi.Close();
fsi = null;
}
public override void Clear()
{
base.Clear();
if (transaction != null)
{
transaction.Clear();
}
storageEngine = null;
}
public virtual void Clear()
{
storageEngine = null;
}
