public virtual void AddClass(NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo classInfo ) { if (classInfo.IsSystemClass()) { rapidAccessForSystemClassesByName.Add(classInfo.GetFullClassName(), classInfo); } else { rapidAccessForUserClassesByName.Add(classInfo.GetFullClassName(), classInfo); } rapidAccessForClassesByOid.Add(classInfo.GetId(), classInfo); allClassInfos.Add(classInfo); }
/// <summary>It is overiden to manage triggers</summary> public override void DeleteObjectWithOid(NeoDatis.Odb.OID oid) { // Check if oih is in the cache NeoDatis.Odb.Core.Layers.Layer2.Meta.ObjectInfoHeader oih = GetSession(true).GetCache ().GetObjectInfoHeaderFromOid(oid, false); if (oih == null) { oih = GetObjectReader().ReadObjectInfoHeaderFromOid(oid, true); } // Only necessary to check if there is some trigger NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = GetMetaModel().GetClassInfoFromId (oih.GetClassInfoId()); string className = ci.GetFullClassName(); bool hasTriggers = triggerManager.HasDeleteTriggersFor(className); NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo nnoi = null; if (hasTriggers) { nnoi = GetObjectReader().ReadNonNativeObjectInfoFromOid(ci, oid, true, false); triggerManager.ManageInsertTriggerBefore(className, nnoi); } base.DeleteObjectWithOid(oid); if (hasTriggers) { triggerManager.ManageInsertTriggerAfter(className, nnoi, oid); } }
public ClassInfoList(NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo mainClassInfo ) { this.classInfos = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <string, NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo >(); this.classInfos[mainClassInfo.GetFullClassName()] = mainClassInfo; this.mainClassInfo = mainClassInfo; }
/// <exception cref="System.IO.IOException"></exception> public virtual NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo AddClass(NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo newClassInfo, bool addDependentClasses) { NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = GetObjectWriter().AddClass(newClassInfo , addDependentClasses); NeoDatis.Odb.Impl.Core.Server.Transaction.ServerSession lsession = (NeoDatis.Odb.Impl.Core.Server.Transaction.ServerSession )GetSession(true); lsession.SetClassInfoId(newClassInfo.GetFullClassName(), ci.GetId()); return(ci); }
public override string ToString() { System.Text.StringBuilder buffer = new System.Text.StringBuilder(); if (message != null) { buffer.Append(message).Append(" | "); } if (oldCi.GetId() != newCi.GetId()) { buffer.Append("old class=").Append(oldCi.GetFullClassName()).Append(" | new class=" ).Append(newCi.GetFullClassName()); } else { buffer.Append("class=").Append(oldCi.GetFullClassName()); } buffer.Append(" | field=").Append(oldCi.GetAttributeInfo(fieldIndex).GetName()); buffer.Append(" | old=").Append(oldValue.ToString()).Append(" | new=").Append(newValue .ToString()); buffer.Append(" | obj. hier. level=").Append(objectRecursionLevel); return(buffer.ToString()); }
public virtual System.Collections.Generic.IDictionary <string, object> GetHistory( ) { System.Collections.Generic.IDictionary <string, object> map = new NeoDatis.Tool.Wrappers.Map.OdbHashMap <string, object>(); NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = null; System.Collections.Generic.IEnumerator <NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo > iterator = allClassInfos.GetEnumerator(); while (iterator.MoveNext()) { ci = iterator.Current; map.Add(ci.GetFullClassName(), ci.GetHistory()); } return(map); }
/// <summary>This method is only used by the odb explorer.</summary> /// <remarks> /// This method is only used by the odb explorer. So there is no too much /// problem with performance issue. /// </remarks> /// <param name="ci"></param> /// <returns>The index of the class info</returns> public virtual int SlowGetUserClassInfoIndex(NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci) { System.Collections.IEnumerator iterator = rapidAccessForUserClassesByName.Values. GetEnumerator(); int i = 0; NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci2 = null; while (iterator.MoveNext()) { ci2 = (NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo)iterator.Current; if (ci2.GetId() == ci.GetId()) { return(i); } i++; } throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.ClassInfoDoesNotExistInMetaModel .AddParameter(ci.GetFullClassName())); }
/// <summary> /// Used to commit meta model : classes This is useful when running in client /// server mode TODO Check this /// </summary> protected virtual void CommitMetaModel() { NeoDatis.Odb.Core.Layers.Layer2.Meta.MetaModel sessionMetaModel = session.GetMetaModel (); // If meta model has not been modified, there is nothing to do if (!sessionMetaModel.HasChanged()) { return; } if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { NeoDatis.Tool.DLogger.Debug("Start commitMetaModel"); } NeoDatis.Odb.Core.Layers.Layer2.Meta.MetaModel lastCommitedMetaModel = new NeoDatis.Odb.Core.Layers.Layer2.Meta.SessionMetaModel (); if (isLocal) { // In local mode, we must not reload the meta model as there is no // concurrent access lastCommitedMetaModel = sessionMetaModel; } else { // In ClientServer mode, re-read the meta-model from the database // base to get last update. lastCommitedMetaModel = session.GetStorageEngine().GetObjectReader().ReadMetaModel (lastCommitedMetaModel, false); } // Gets the classes that have changed (that have modified ,deleted or // inserted objects) System.Collections.Generic.IEnumerator <NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo > cis = sessionMetaModel.GetChangedClassInfo().GetEnumerator(); NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo newCi = null; NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo lastCommittedCI = null; NeoDatis.Odb.Core.Layers.Layer3.IObjectWriter writer = session.GetStorageEngine() .GetObjectWriter(); NeoDatis.Odb.OID lastCommittedObjectOIDOfThisTransaction = null; NeoDatis.Odb.OID lastCommittedObjectOIDOfPrevTransaction = null; // for all changes between old and new meta model while (cis.MoveNext()) { newCi = cis.Current; if (lastCommitedMetaModel.ExistClass(newCi.GetFullClassName())) { // The last CI represents the last committed meta model of the // database lastCommittedCI = lastCommitedMetaModel.GetClassInfoFromId(newCi.GetId()); // Just be careful to keep track of current CI committed zone // deleted objects lastCommittedCI.GetCommitedZoneInfo().SetNbDeletedObjects(newCi.GetCommitedZoneInfo ().GetNbDeletedObjects()); } else { lastCommittedCI = newCi; } lastCommittedObjectOIDOfThisTransaction = newCi.GetCommitedZoneInfo().last; lastCommittedObjectOIDOfPrevTransaction = lastCommittedCI.GetCommitedZoneInfo().last; NeoDatis.Odb.OID lastCommittedObjectOID = lastCommittedObjectOIDOfPrevTransaction; // If some object have been created then if (lastCommittedObjectOIDOfPrevTransaction != null) { // Checks if last object of committed meta model has not been // deleted if (session.GetCache().IsDeleted(lastCommittedObjectOIDOfPrevTransaction)) { // TODO This is wrong: if a committed transaction deleted a // committed object and creates x new // objects, then all these new objects will be lost: // if it has been deleted then use the last object of the // session class info lastCommittedObjectOID = lastCommittedObjectOIDOfThisTransaction; newCi.GetCommitedZoneInfo().last = lastCommittedObjectOID; } } // Connect Unconnected zone to connected zone // make next oid of last committed object point to first // uncommitted object // make previous oid of first uncommitted object point to // last committed object if (lastCommittedObjectOID != null && newCi.GetUncommittedZoneInfo().HasObjects()) { if (newCi.GetCommitedZoneInfo().HasObjects()) { // these 2 updates are executed directly without // transaction, because // We are in the commit process. writer.UpdateNextObjectFieldOfObjectInfo(lastCommittedObjectOID, newCi.GetUncommittedZoneInfo ().first, false); writer.UpdatePreviousObjectFieldOfObjectInfo(newCi.GetUncommittedZoneInfo().first , lastCommittedObjectOID, false); } else { // Committed zone has 0 object writer.UpdatePreviousObjectFieldOfObjectInfo(newCi.GetUncommittedZoneInfo().first , null, false); } } // The number of committed objects must be updated with the number // of the last committed CI because a transaction may have been // committed changing this number. // Notice that the setNbObjects receive the full CommittedCIZoneInfo // object // because it will set the number of objects and the number of // deleted objects newCi.GetCommitedZoneInfo().SetNbObjects(lastCommittedCI.GetCommitedZoneInfo()); // and don't forget to set the deleted objects // This sets the number of objects, the first object OID and the // last object OID newCi = BuildClassInfoForCommit(newCi); writer.UpdateInstanceFieldsOfClassInfo(newCi, false); if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { NeoDatis.Tool.DLogger.Debug("Analysing class " + newCi.GetFullClassName()); NeoDatis.Tool.DLogger.Debug("\t-Commited CI = " + newCi); NeoDatis.Tool.DLogger.Debug("\t-connect last commited object with oid " + lastCommittedObjectOID + " to first uncommited object " + newCi.GetUncommittedZoneInfo().first); NeoDatis.Tool.DLogger.Debug("\t-Commiting new Number of objects = " + newCi.GetNumberOfObjects ()); } } sessionMetaModel.ResetChangedClasses(); // To guarantee integrity after commit, the meta model is set to null // If the user continues using odb instance after commit the meta model // will be lazy-reloaded. Only for Client Server mode if (!isLocal) { session.SetMetaModel(null); } }
public virtual void AddUniqueIndexOn(string name, string[] indexFields, bool verbose ) { storageEngine.AddIndexOn(classInfo.GetFullClassName(), name, indexFields, verbose , false); }
public virtual void AddClassInfo(NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo classInfo ) { classInfos[classInfo.GetFullClassName()] = classInfo; }
public NonNativeObjectInfo(object @object, NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo info, NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo[] values, long[] attributesIdentification, int[] attributeIds) : base(NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType .GetFromName(info.GetFullClassName())) { //new OdbArrayList<NonNativeObjectInfo>(); this.@object = @object; this.classInfo = info; this.attributeValues = values; this.maxNbattributes = classInfo.GetMaxAttributeId(); if (attributeValues == null) { this.attributeValues = new NeoDatis.Odb.Core.Layers.Layer2.Meta.AbstractObjectInfo [maxNbattributes]; } this.objectHeader = new NeoDatis.Odb.Core.Layers.Layer2.Meta.ObjectInfoHeader(-1, null, null, (classInfo != null ? classInfo.GetId() : null), attributesIdentification , attributeIds); this.allNonNativeObjects = new NeoDatis.Tool.Wrappers.List.OdbArrayList <NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo >(); }
public override string ToString() { System.Text.StringBuilder buffer = new System.Text.StringBuilder(classInfo.GetFullClassName ()).Append("(").Append(GetOid()).Append(")="); if (attributeValues == null) { buffer.Append("null attribute values"); return(buffer.ToString()); } for (int i = 0; i < attributeValues.Length; i++) { if (i != 0) { buffer.Append(","); } string attributeName = (classInfo != null ? (classInfo.GetAttributeInfo(i)).GetName () : "?"); buffer.Append(attributeName).Append("="); object @object = attributeValues[i]; if (@object == null) { buffer.Append(" null java object - should not happen , "); } else { NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType type = NeoDatis.Odb.Core.Layers.Layer2.Meta.ODBType .GetFromClass(attributeValues[i].GetType()); if (@object is NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeNullObjectInfo) { buffer.Append("null"); continue; } if (@object is NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeDeletedObjectInfo) { buffer.Append("deleted object"); continue; } if (@object is NeoDatis.Odb.Core.Layers.Layer2.Meta.NativeObjectInfo) { NeoDatis.Odb.Core.Layers.Layer2.Meta.NativeObjectInfo noi = (NeoDatis.Odb.Core.Layers.Layer2.Meta.NativeObjectInfo )@object; buffer.Append(noi.ToString()); continue; } if (@object is NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo) { NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo nnoi = (NeoDatis.Odb.Core.Layers.Layer2.Meta.NonNativeObjectInfo )@object; buffer.Append("@").Append(nnoi.GetClassInfo().GetFullClassName()).Append("(id="). Append(nnoi.GetOid()).Append(")"); continue; } if (@object is NeoDatis.Odb.Core.Layers.Layer2.Meta.ObjectReference) { buffer.Append(@object.ToString()); continue; } buffer.Append("@").Append(NeoDatis.Tool.Wrappers.OdbClassUtil.GetClassName(type.GetName ())); } } return(buffer.ToString()); }
public virtual void DecreaseNbObjects() { nbObjects--; if (nbObjects < 0) { throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.InternalError .AddParameter("nb objects is negative! in " + ci.GetFullClassName())); } }
/// <summary>Execute query using index</summary> /// <param name="index"></param> /// <param name="inMemory"></param> /// <param name="startIndex"></param> /// <param name="endIndex"></param> /// <param name="returnObjects"></param> /// <returns></returns> /// <exception cref="System.Exception">System.Exception</exception> private NeoDatis.Odb.Objects <T> ExecuteUsingIndex <T>(NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfoIndex index, bool inMemory, int startIndex, int endIndex, bool returnObjects, NeoDatis.Odb.Core.Query.Execution.IMatchingObjectAction queryResultAction) { // Index that have not been used yet do not have persister! if (index.GetBTree().GetPersister() == null) { index.GetBTree().SetPersister(new NeoDatis.Odb.Impl.Core.Btree.LazyODBBTreePersister (storageEngine)); } bool objectMatches = false; long nbObjects = classInfo.GetNumberOfObjects(); long btreeSize = index.GetBTree().GetSize(); // the two values should be equal if (nbObjects != btreeSize) { NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = storageEngine.GetSession(true ).GetMetaModel().GetClassInfoFromId(index.GetClassInfoId()); throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.IndexIsCorrupted .AddParameter(index.GetName()).AddParameter(ci.GetFullClassName()).AddParameter( nbObjects).AddParameter(btreeSize)); } if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { NeoDatis.Tool.DLogger.Debug("loading " + nbObjects + " instance(s) of " + classInfo .GetFullClassName()); } if (ExecuteStartAndEndOfQueryAction()) { queryResultAction.Start(); } PrepareQuery(); if (query != null) { queryHasOrderBy = query.HasOrderBy(); } NeoDatis.Btree.IBTree tree = index.GetBTree(); bool isUnique = index.IsUnique(); // Iterator iterator = new BTreeIterator(tree, // OrderByConstants.ORDER_BY_ASC); System.IComparable key = ComputeIndexKey(classInfo, index); System.Collections.IList list = null; // If index is unique, get the object if (isUnique) { NeoDatis.Btree.IBTreeSingleValuePerKey treeSingle = (NeoDatis.Btree.IBTreeSingleValuePerKey )tree; object o = treeSingle.Search(key); if (o != null) { list = new System.Collections.ArrayList(); list.Add(o); } } else { NeoDatis.Btree.IBTreeMultipleValuesPerKey treeMultiple = (NeoDatis.Btree.IBTreeMultipleValuesPerKey )tree; list = treeMultiple.Search(key); } if (list != null) { System.Collections.IEnumerator iterator = list.GetEnumerator(); while (iterator.MoveNext()) { NeoDatis.Odb.OID oid = (NeoDatis.Odb.OID)iterator.Current; // FIXME Why calling this method long position = objectReader.GetObjectPositionFromItsOid(oid, true, true); orderByKey = null; objectMatches = MatchObjectWithOid(oid, returnObjects, inMemory); if (objectMatches) { queryResultAction.ObjectMatch(oid, GetCurrentObjectMetaRepresentation(), orderByKey ); } } queryResultAction.End(); return(queryResultAction.GetObjects <T>()); } if (ExecuteStartAndEndOfQueryAction()) { queryResultAction.End(); } return(queryResultAction.GetObjects <T>()); }
/// <summary> /// Query execution full scan /// <pre> /// startIndex & endIndex /// A B C D E F G H I J K L /// [1,3] : nb >=1 && nb<3 /// 1) /// analyze A /// nb = 0 /// nb E [1,3] ? no /// r=[] /// 2) /// analyze B /// nb = 1 /// nb E [1,3] ? yes /// r=[B] /// 3) analyze C /// nb = 2 /// nb E [1,3] ? yes /// r=[B,C] /// 4) analyze C /// nb = 3 /// nb E [1,3] ? no and 3> upperBound([1,3]) => exit /// </pre> /// </summary> /// <param name="inMemory"></param> /// <param name="startIndex"></param> /// <param name="endIndex"></param> /// <param name="returnObjects"></param> /// <returns></returns> /// <exception cref="System.Exception">System.Exception</exception> private NeoDatis.Odb.Objects <T> ExecuteFullScan <T>(bool inMemory, int startIndex, int endIndex, bool returnObjects, NeoDatis.Odb.Core.Query.Execution.IMatchingObjectAction queryResultAction) { bool objectInRange = false; bool objectMatches = false; if (storageEngine.IsClosed()) { throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.OdbIsClosed .AddParameter(storageEngine.GetBaseIdentification().GetIdentification())); } long nbObjects = classInfo.GetNumberOfObjects(); if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { NeoDatis.Tool.DLogger.Debug("loading " + nbObjects + " instance(s) of " + classInfo .GetFullClassName()); } if (ExecuteStartAndEndOfQueryAction()) { queryResultAction.Start(); } NeoDatis.Odb.OID currentOID = null; NeoDatis.Odb.OID prevOID = null; // TODO check if all instances are in the cache! and then load from the // cache nextOID = classInfo.GetCommitedZoneInfo().first; if (nbObjects > 0 && nextOID == null) { // This means that some changes have not been commited! // Take next position from uncommited zone nextOID = classInfo.GetUncommittedZoneInfo().first; } PrepareQuery(); if (query != null) { queryHasOrderBy = query.HasOrderBy(); } bool monitorMemory = NeoDatis.Odb.OdbConfiguration.IsMonitoringMemory(); // used when startIndex and endIndex are not negative int nbObjectsInResult = 0; for (int i = 0; i < nbObjects; i++) { //Console.WriteLine(i); if (monitorMemory && i % 10000 == 0) { NeoDatis.Odb.Impl.Tool.MemoryMonitor.DisplayCurrentMemory(string.Empty + (i + 1), true); } // Reset the order by key orderByKey = null; objectMatches = false; prevOID = currentOID; currentOID = nextOID; // This is an error if (currentOID == null) { if (NeoDatis.Odb.OdbConfiguration.ThrowExceptionWhenInconsistencyFound()) { throw new NeoDatis.Odb.ODBRuntimeException(NeoDatis.Odb.Core.NeoDatisError.NullNextObjectOid .AddParameter(classInfo.GetFullClassName()).AddParameter(i).AddParameter(nbObjects ).AddParameter(prevOID)); } break; } // If there is an endIndex condition if (endIndex != -1 && nbObjectsInResult >= endIndex) { break; } // If there is a startIndex condition if (startIndex != -1 && nbObjectsInResult < startIndex) { objectInRange = false; } else { objectInRange = true; } // There is no query if (!inMemory && query == null) { nbObjectsInResult++; // keep object position if we must if (objectInRange) { orderByKey = BuildOrderByKey(currentNnoi); // TODO Where is the key for order by queryResultAction.ObjectMatch(nextOID, orderByKey); } nextOID = objectReader.GetNextObjectOID(currentOID); } else { objectMatches = MatchObjectWithOid(currentOID, returnObjects, inMemory); if (objectMatches) { nbObjectsInResult++; if (objectInRange) { if (queryHasOrderBy) { orderByKey = BuildOrderByKey(GetCurrentObjectMetaRepresentation()); } queryResultAction.ObjectMatch(currentOID, GetCurrentObjectMetaRepresentation(), orderByKey ); if (callback != null) { callback.ReadingObject(i, -1); } } } } } if (ExecuteStartAndEndOfQueryAction()) { queryResultAction.End(); } return(queryResultAction.GetObjects <T>()); }
public virtual void DefragmentTo(string newFileName) { long start = NeoDatis.Tool.Wrappers.OdbTime.GetCurrentTimeInMs(); long totalNbObjects = 0; NeoDatis.Odb.Core.Layers.Layer3.IStorageEngine newStorage = NeoDatis.Odb.OdbConfiguration .GetCoreProvider().GetClientStorageEngine(new NeoDatis.Odb.Core.Layers.Layer3.IOFileParameter (newFileName, true, baseIdentification.GetUserName(), baseIdentification.GetPassword ())); NeoDatis.Odb.Objects <object> defragObjects = null; int j = 0; NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo ci = null; // User classes System.Collections.IEnumerator iterator = GetMetaModel().GetUserClasses().GetEnumerator (); while (iterator.MoveNext()) { ci = (NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo)iterator.Current; if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { NeoDatis.Tool.DLogger.Debug("Reading " + ci.GetCommitedZoneInfo().GetNbObjects() + " objects of type " + ci.GetFullClassName()); } defragObjects = GetObjects <object>(new NeoDatis.Odb.Impl.Core.Query.Criteria.CriteriaQuery (ci.GetFullClassName()), true, -1, -1); while (defragObjects.HasNext()) { newStorage.Store(defragObjects.Next()); totalNbObjects++; if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { if (j % 10000 == 0) { NeoDatis.Tool.DLogger.Info("\n" + totalNbObjects + " objects saved."); } } j++; } } // System classes iterator = GetMetaModel().GetSystemClasses().GetEnumerator(); while (iterator.MoveNext()) { ci = (NeoDatis.Odb.Core.Layers.Layer2.Meta.ClassInfo)iterator.Current; if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { NeoDatis.Tool.DLogger.Debug("Reading " + ci.GetCommitedZoneInfo().GetNbObjects() + " objects of type " + ci.GetFullClassName()); } defragObjects = GetObjects <object>(new NeoDatis.Odb.Impl.Core.Query.Criteria.CriteriaQuery (ci.GetFullClassName()), true, -1, -1); while (defragObjects.HasNext()) { newStorage.Store(defragObjects.Next()); totalNbObjects++; if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { if (j % 10000 == 0) { NeoDatis.Tool.DLogger.Info("\n" + totalNbObjects + " objects saved."); } } j++; } } newStorage.Commit(); newStorage.Close(); long time = NeoDatis.Tool.Wrappers.OdbTime.GetCurrentTimeInMs() - start; if (NeoDatis.Odb.OdbConfiguration.IsDebugEnabled(LogId)) { NeoDatis.Tool.DLogger.Info("New storage " + newFileName + " created with " + totalNbObjects + " objects in " + time + " ms."); } }