Exemplo n.º 1
0
        public async Task SimpleInsertAsync()
        {
            var prov = GetServiceProvider();

            using ((IDisposable)prov)
            {
                var ctx = prov.GetService <TestContext>();

                var item1 = new SimpleTableWithIdentity {
                    Title = "Bla1"
                };
                var item2 = new SimpleTableWithIdentity {
                    Title = "Bla2"
                };
                var item3 = new SimpleTableWithIdentity {
                    Title = "Bla3"
                };
                ctx.SimpleTableWithIdentity.Add(item1);
                ctx.SimpleTableWithIdentity.Add(item2);
                ctx.SimpleTableWithIdentity.Add(item3);

                await ctx.SaveChangesAsync();

                Assert.AreNotEqual(0, item1.Id);
                Assert.AreNotEqual(0, item2.Id);
                Assert.AreNotEqual(0, item3.Id);
                Assert.AreNotEqual(item1.Id, item2.Id);
                Assert.AreNotEqual(item2.Id, item3.Id);
                Assert.AreNotEqual(item1.Id, item3.Id);
            }
        }
Exemplo n.º 2
0
        public async Task BulkInsertSetupTest()
        {
            var prov = GetServiceProvider();

            using ((IDisposable)prov)
            {
                var ctx = prov.GetService <TestContext>();

                var item1 = new SimpleTableWithIdentity {
                    Id = 11, Title = "Bla1"
                };
                var item2 = new SimpleTableWithIdentity {
                    Id = 12, Title = "Bla2"
                };
                var item3 = new SimpleTableWithIdentity {
                    Id = 13, Title = "Bla3"
                };

                bool wasCalled = false;

                await ctx.BulkInsertAsync(new[] { item1, item2, item3 }, p => p.Setup(x => wasCalled = true));

                var items = await ctx.SimpleTableWithIdentity.ToListAsync();

                Assert.AreEqual(3, items.Count);
                Assert.True(wasCalled);
            }
        }
Exemplo n.º 3
0
        public async Task BulkInsertCustomOptionsTest()
        {
            var prov = GetServiceProvider();

            using ((IDisposable)prov)
            {
                var ctx = prov.GetService <TestContext>();

                var item1 = new SimpleTableWithIdentity {
                    Id = 11, Title = "Bla1"
                };
                var item2 = new SimpleTableWithIdentity {
                    Id = 12, Title = "Bla2"
                };
                var item3 = new SimpleTableWithIdentity {
                    Id = 13, Title = "Bla3"
                };

                await ctx.BulkInsertAsync(new[] { item1, item2, item3 },
                                          builder => builder.IdentityInsert().SqlBulkOptions(p => SqlBulkCopyOptions.TableLock));

                var items = await ctx.SimpleTableWithIdentity.ToListAsync();

                Assert.AreEqual(3, items.Count);
                Assert.False(items.Any(p => p.Id == 11));
                Assert.False(items.Any(p => p.Id == 12));
                Assert.False(items.Any(p => p.Id == 13));
            }
        }
Exemplo n.º 4
0
        public async Task BulkInsertIdentityInsertTest()
        {
            var prov = GetServiceProvider();

            using ((IDisposable)prov)
            {
                var ctx = prov.GetService <TestContext>();

                var item1 = new SimpleTableWithIdentity {
                    Id = 11, Title = "Bla1"
                };
                var item2 = new SimpleTableWithIdentity {
                    Id = 12, Title = "Bla2"
                };
                var item3 = new SimpleTableWithIdentity {
                    Id = 13, Title = "Bla3"
                };

                await ctx.BulkInsertAsync(new[] { item1, item2, item3 }, p => p.IdentityInsert(true).PropagateValues(true));

                var items = await ctx.SimpleTableWithIdentity.ToListAsync();

                Assert.AreEqual(3, items.Count);
                Assert.True(items.Any(p => p.Id == 11));
                Assert.True(items.Any(p => p.Id == 12));
                Assert.True(items.Any(p => p.Id == 13));
            }
        }
Exemplo n.º 5
0
        public async Task BulkInsertNormalUpdateAsync()
        {
            var prov = GetServiceProvider();

            var ctx     = prov.GetService <TestContext>();
            var oldItem = new SimpleTableWithIdentity {
                Title = "oldTitle"
            };

            ctx.SimpleTableWithIdentity.Add(oldItem);
            await ctx.SaveChangesAsync();

            ctx.ChangeTracker.Entries().ToList().ForEach(p => p.State = EntityState.Detached);

            var itemToUpdate = ctx.SimpleTableWithIdentity.Find(oldItem.Id);

            itemToUpdate.Title = "newTitle";

            var item1 = new SimpleTableWithIdentity {
                Title = "Bla1"
            };
            var item2 = new SimpleTableWithIdentity {
                Title = "Bla2"
            };
            var item3 = new SimpleTableWithIdentity {
                Title = "Bla3"
            };

            ctx.SimpleTableWithIdentity.Add(item1);
            ctx.SimpleTableWithIdentity.Add(item2);
            ctx.SimpleTableWithIdentity.Add(item3);

            var changes = ctx.ChangeTracker.Entries().Where(p => p.State == EntityState.Modified).ToList();

            Assert.AreEqual(1, changes.Count);

            await ctx.SaveChangesAsync();

            ctx.ChangeTracker.Entries().ToList().ForEach(p => p.State = EntityState.Detached);

            var updated = await ctx.SimpleTableWithIdentity.FirstAsync(p => p.Id == oldItem.Id);

            Assert.AreEqual("newTitle", updated.Title);

            Assert.AreNotEqual(0, item1.Id);
            Assert.AreNotEqual(0, item2.Id);
            Assert.AreNotEqual(0, item3.Id);
            Assert.AreNotEqual(item1.Id, item2.Id);
            Assert.AreNotEqual(item2.Id, item3.Id);
            Assert.AreNotEqual(item1.Id, item3.Id);
        }
        public async Task BulkDeleteNormalInsertAndUpdateWithSaveChangesAsync()
        {
            var prov = GetServiceProvider(p => p.EnableBulkDelete().EnableBulkInsert(false));

            var ctx = prov.GetService <TestContext>();

            var items = Enumerable.Range(1, 11)
                        .Select(p => new SimpleTableWithShadowProperty
            {
                Title = $"Title {p}"
            })
                        .ToList();
            var updateItem = items.Last();

            await ctx.BulkInsertAsync(items);

            await ctx.SimpleTableWithShadowProperty.AddRangeAsync(items.Take(10));

            Assert.AreEqual(10, ctx.ChangeTracker.Entries().Count());
            ctx.ChangeTracker.Entries().ToList().ForEach(p => p.State = EntityState.Deleted);

            ctx.Entry(updateItem).State = EntityState.Unchanged;

            var newItem = new SimpleTableWithIdentity()
            {
                Title = "Normal Insert"
            };

            ctx.Add(newItem);
            updateItem.Title = "modified " + updateItem.Title;
            Assert.AreEqual(EntityState.Modified, ctx.Entry(updateItem).State);

            var result = await ctx.SaveChangesAsync();

            Assert.AreEqual(12, result);

            var dbItems = await ctx.SimpleTableWithShadowProperty.ToListAsync();

            Assert.AreEqual(1, dbItems.Count);
        }