예제 #1
0
        public virtual void Test_OneBatch_NoOperations()
        {
            Assert.IsFalse(BatchCommitted, "The BatchCommitted flag should start off false.");

            using (Batch batch = BatchState.StartBatch())
            {
                batch.Committed += new EventHandler(batch_Committed);
            }

            Assert.IsTrue(BatchCommitted, "The BatchCommitted flag wasn't changed to true.");
        }
 public void ClearData(string dataDirectory)
 {
     if (DataAccess.IsInitialized)
     {
         using (Batch batch = BatchState.StartBatch())
         {
             foreach (IEntity entity in DataAccess.Data.Indexer.GetEntities())
             {
                 DataAccess.Data.Deleter.Delete(entity);
             }
         }
     }
 }
예제 #3
0
        public virtual void Test_TwoBatches_Nested()
        {
            Assert.IsFalse(BatchCommitted, "The BatchCommitted flag should start off false.");

            using (Batch batch = BatchState.StartBatch())
            {
                batch.Committed += new EventHandler(batch_Committed);

                using (Batch batch2 = BatchState.StartBatch())
                {
                    batch2.Committed += new EventHandler(batch_Committed);
                }

                Assert.IsFalse(BatchCommitted, "The nested batch committed when it shouldn't have. It should leave it for the outer batch.");
            }

            Assert.IsTrue(BatchCommitted, "The BatchCommitted flag wasn't changed to true.");
        }
예제 #4
0
        /// <summary>
        /// Deletes the provided entity.
        /// </summary>
        /// <param name="entity">The entity to delete.</param>
        public override void Delete(IEntity entity)
        {
            if (entity == null)
            {
                throw new ArgumentNullException("entity");
            }

            using (LogGroup logGroup = LogGroup.StartDebug("Deleting provided '" + entity.ShortTypeName + "' entity."))
            {
                Db4oDataStore store = (Db4oDataStore)GetDataStore(entity);

                if (DataAccess.Data.IsStored(entity))
                {
                    using (Batch batch = BatchState.StartBatch())
                    {
                        IDataReader reader = Provider.InitializeDataReader();
                        reader.AutoRelease = false;

                        entity = reader.GetEntity(entity);

                        if (entity == null)
                        {
                            throw new Exception("The entity wasn't found.");
                        }

                        // PreDelete must be called to ensure all references are correctly managed
                        PreDelete(entity);

                        // Delete the entity
                        if (entity != null)
                        {
                            store.ObjectContainer.Delete(entity);

                            store.Commit();
                        }
                    }
                }
            }
        }
예제 #5
0
        /// <summary>
        /// Updates the provided entity.
        /// </summary>
        /// <param name="entity">The entity to update.</param>
        public override void Update(IEntity entity)
        {
            using (LogGroup logGroup = LogGroup.Start("Updating the provided entity.", NLog.LogLevel.Debug))
            {
                if (entity == null)
                {
                    throw new ArgumentNullException("entity");
                }

                Db4oDataStore store = (Db4oDataStore)GetDataStore(entity);

                if (!store.IsStored(entity))
                {
                    throw new ArgumentException("entity", "The provided entity of type '" + entity.GetType() + "' is not found in the store with name '" + store.Name + "'.");
                }

                if (entity.ID == Guid.Empty)
                {
                    throw new ArgumentException("entity.ID must be set.");
                }

                using (Batch batch = BatchState.StartBatch())
                {
                    LogWriter.Debug("Entity type: " + entity.GetType().ToString());
                    LogWriter.Debug("Entity ID: " + entity.ID);

                    // Preupdate must be called to ensure all references are correctly stored
                    PreUpdate(entity);

                    // Get a bound copy of the entity
                    IDataReader reader = Provider.InitializeDataReader();
                    reader.AutoRelease = false;                     // Tell the reader not to unbind the entity from the store because it's still within the data access system

                    IEntity existingEntity = reader.GetEntity(entity);

                    if (existingEntity != null)
                    {
                        // Activate the found entity
                        Provider.Activator.Activate(existingEntity);

                        // Copy the provided data to the bound entity
                        entity.CopyTo(existingEntity);

                        // Remove all the referenced entities
                        existingEntity.Deactivate();

                        store.ObjectContainer.Store(existingEntity);

                        LogWriter.Debug("Entity updated.");

                        PostUpdate(entity);

                        store.Commit();
                    }
                    else
                    {
                        throw new InvalidOperationException("Cannot update an entity that doesn't already exist in the data store. Save the entity first.");
                    }
                }
            }
        }
예제 #6
0
        /// <summary>
        /// Saves the provided entity into the provided data store.
        /// </summary>
        /// <param name="entity">The entity to save to the data store.</param>
        /// <param name="handleReferences">A value indicating whether to delete old references and save new references.</param>
        public override void Save(IEntity entity, bool handleReferences)
        {
            using (LogGroup logGroup = LogGroup.StartDebug("Saving entity of type '" + entity.ShortTypeName + "'."))
            {
                if (entity == null)
                {
                    throw new ArgumentNullException("entity");
                }

                if (entity.ID == Guid.Empty)
                {
                    throw new ArgumentException("entity.ID must be set.");
                }

                // Clone the entity so that it doesn't get bound to the store
                IEntity clonedEntity = entity.Clone();

                Db4oDataStore store = (Db4oDataStore)GetDataStore(clonedEntity);

                if (store.ObjectContainer == null)
                {
                    throw new InvalidOperationException("The ObjectContainer has not been initialized on the '" + store.Name + "' data store.");
                }

                using (Batch batch = BatchState.StartBatch())
                {
                    if (EntitiesUtilities.IsReference(clonedEntity.GetType()) && DataAccess.Data.IsStored(clonedEntity))
                    {
                        LogWriter.Debug("Existing reference found. Skipping save.");
                        // Just skip the saving altogether, if the reference already exists
                    }
                    else
                    {
                        if (clonedEntity == null)
                        {
                            throw new ArgumentNullException("entity");
                        }

                        LogWriter.Debug("Entity type: " + clonedEntity.GetType().ToString());
                        LogWriter.Debug("Entity ID: " + clonedEntity.ID.ToString());

                        PreSave(clonedEntity, handleReferences);

                        if (clonedEntity != null)
                        {
                            DataUtilities.StripReferences(clonedEntity);

                            // Save the entity
                            store.ObjectContainer.Store(clonedEntity);

                            // Post save the original entity NOT the cloned entity
                            PostSave(entity);

                            store.Commit();

                            LogWriter.Debug("Entity stored in '" + store.Name + "' store.");
                        }
                        else
                        {
                            LogWriter.Debug("Cloned entity == null. Not stored.");
                        }
                    }
                }
            }
        }
예제 #7
0
        public virtual void Test_OneBatch_TwoOperations()
        {
            // Check the flags to ensure they've been reset
            Assert.IsFalse(BatchCommitted, "The BatchCommitted flag should start off false.");
            Assert.IsFalse(StoreCommitted, "The StoreCommitted flag should start off false.");

            // Create mock entities
            TestUser user = new TestUser();

            user.ID        = Guid.NewGuid();
            user.FirstName = "First";
            user.LastName  = "Last";

            TestUser user2 = new TestUser();

            user2.ID        = Guid.NewGuid();
            user2.FirstName = "First2";
            user2.LastName  = "Last2";

            // Start the data operation batch
            using (Batch batch = BatchState.StartBatch())
            {
                // Handle the Committed even of the batch
                batch.Committed += new EventHandler(batch_Committed);

                // Ensure that the flags are still set to defaults
                Assert.IsFalse(BatchCommitted, "The BatchCommitted flag should remain false until the batch disposes.");
                Assert.IsFalse(StoreCommitted, "The StoreCommitted flag should remain false until the batch disposes.");

                // Get the data store for the mock entities
                IDataStore store = DataAccess.Data.Stores[user.GetType()];

                // Handle the committed even of the data store
                store.Committed += new EventHandler(store_Committed);

                // Save the first mock user
                DataAccess.Data.Saver.Save(user);

                Assert.AreEqual(1, BatchState.Batches.ToArray()[0].DataStores.Count, "Invalid number of data stores found.");

                Assert.AreEqual(1, BatchState.Batches.Count, "Invalid number of batches found.");

                Assert.IsFalse(BatchCommitted, "#1 The BatchCommitted flag should remain false until the batch disposes, even after saving an entity.");
                Assert.IsFalse(StoreCommitted, "#1 The StoreCommitted flag should remain false until the batch disposes, even after saving an entity.");

                // TODO: Check if needed. Should be but is causing problems with the test.
                DisposeMockData(false);                 // Pass false to stop the disposal triggering automatic commit
                InitializeMockData();

                StoreCommitted = false;
                BatchCommitted = false;

                store = DataAccess.Data.Stores[user.GetType()];

                store.Committed += new EventHandler(store_Committed);

                TestUser foundUser = DataAccess.Data.Reader.GetEntity <TestUser>("ID", user.ID);

                Assert.IsNull(foundUser, "The user was returned when it shouldn't have been committed yet.");

                DataAccess.Data.Saver.Save(user2);

                Assert.IsFalse(BatchCommitted, "#2 The BatchCommitted flag should remain false until the batch disposes, even after saving an entity.");
                Assert.IsFalse(StoreCommitted, "#2 The StoreCommitted flag should remain false until the batch disposes, even after saving an entity.");

                store = DataAccess.Data.Stores[user.GetType()];

                store.Committed += new EventHandler(store_Committed);
            }             // Commit should happen here, when batch disposes

            Assert.IsTrue(BatchCommitted, "The BatchCommitted flag wasn't changed to true.");
            Assert.IsTrue(StoreCommitted, "The StoreCommitted flag wasn't changed to true.");

            DisposeMockData();
            InitializeMockData();

            TestUser foundUser2 = DataAccess.Data.Reader.GetEntity <TestUser>("ID", user2.ID);

            Assert.IsNotNull(foundUser2, "The user wasn't returned when it should have been.");

            Assert.AreEqual(user2.ID.ToString(), foundUser2.ID.ToString(), "The found user ID doesn't match the expected ID.");
        }