public void ExistingEntitiesShouldBeSelectedUsingRuntimeTypes()
{
using (var db = new UnitTestsContext())
{
var now = DateTime.Now;
// Save 200 numbers (1 to 200) to the database.
var numbers = GenerateNumbers(1, 200, now).ToArray();
db.BulkInsertAll(new BulkInsertRequest <Number>
{
Entities = numbers,
EnableRecursiveInsert = EnableRecursiveInsert.Yes
});
// Create a list of 100 numbers with values 151 to 250
numbers = GenerateNumbers(151, 100, now).ToArray();
// Numbers 151 to 200 out of 151 to 250 should be selected.
var request = typeof(BulkSelectRequest <>).MakeGenericType(typeof(Number));
var r = Activator.CreateInstance(request, new[] { "Value" }, numbers.ToList(), null);
Type ex = typeof(DbContextExtensions);
MethodInfo mi = ex.GetMethod("BulkSelectExisting");
MethodInfo miGeneric = mi.MakeGenericMethod(new[] { typeof(Number), typeof(Number) });
object[] args = { db, r };
var existingNumbers = (List <Number>)miGeneric.Invoke(null, args);
Assert.AreEqual(50, existingNumbers.Count);
for (int i = 0; i < 50; i++)
{
Assert.AreSame(numbers[i], existingNumbers[i]);
}
}
}
public void OneToManyWhereTheOneAlreadyExists()
{
using (var db = new UnitTestsContext())
{
var now = DateTime.Now;
Parity even = new Parity {
Name = "Even", UpdatedAt = now, UpdatedBy = "Måns"
};
Parity odd = new Parity {
Name = "Odd", UpdatedAt = now, UpdatedBy = "Måns"
};
db.BulkInsertAll(new[] { even, odd });
var numbers = GenerateNumbers(1, 100, even, odd, now).ToArray();
db.BulkInsertAll(numbers);
Assert.AreEqual(100, db.Numbers.Count());
var dbNumbers = db.Numbers.Include(n => n.Parity).ToArray();
foreach (var number in dbNumbers.Where(n => n.Value % 2 == 0))
{
Assert.AreEqual("Even", number.Parity.Name);
Assert.AreEqual(now.ToString("yyyyMMddHHmmss"), number.UpdatedAt.ToString("yyyyMMddHHmmss"));
}
foreach (var number in dbNumbers.Where(n => n.Value % 2 != 0))
{
Assert.AreEqual("Odd", number.Parity.Name);
Assert.AreEqual(now.ToString("yyyyMMddHHmmss"), number.UpdatedAt.ToString("yyyyMMddHHmmss"));
}
}
}
public void OneToManyWhereAllIsNew()
{
using (var db = new UnitTestsContext())
{
var now = DateTime.Now;
var numbers = GenerateNumbers(1, 100, now).ToArray();
var request = new BulkInsertRequest <Number>
{
Entities = numbers,
EnableRecursiveInsert = EnableRecursiveInsert.Yes,
};
db.BulkInsertAll(request);
Assert.AreEqual(100, db.Numbers.Count());
var dbNumbers = db.Numbers.Include(n => n.Parity).ToArray();
foreach (var number in dbNumbers.Where(n => n.Value % 2 == 0))
{
Assert.AreEqual("Even", number.Parity.Name);
Assert.AreEqual(now.ToString("yyyyMMddHHmmss"), number.UpdatedAt.ToString("yyyyMMddHHmmss"));
}
foreach (var number in dbNumbers.Where(n => n.Value % 2 != 0))
{
Assert.AreEqual("Odd", number.Parity.Name);
Assert.AreEqual(now.ToString("yyyyMMddHHmmss"), number.UpdatedAt.ToString("yyyyMMddHHmmss"));
}
}
}
public void EntityHierarchyShouldBeInserted()
{
using (var db = new UnitTestsContext())
{
var now = DateTime.Now;
var numbers = GenerateNumbers(1, 10, now).ToArray(); // 1-10
var primes = GeneratePrimeNumbers(10, numbers, now); // 1,2,3,5,7
var request = new BulkInsertRequest <Prime>
{
Entities = primes,
EnableRecursiveInsert = EnableRecursiveInsert.Yes,
};
db.BulkInsertAll(request);
var actualNumbers = db.Numbers.ToArray();
var actualPrimes = db.Primes.ToArray();
Assert.AreEqual(5, actualNumbers.Length);
Assert.AreEqual(5, actualPrimes.Length);
Assert.AreEqual(1, actualPrimes[0].Number.Value);
Assert.AreEqual(2, actualPrimes[1].Number.Value);
Assert.AreEqual(3, actualPrimes[2].Number.Value);
Assert.AreEqual(5, actualPrimes[3].Number.Value);
Assert.AreEqual(7, actualPrimes[4].Number.Value);
}
}
public void ComplexTypesShouldBeInserted()
{
using (var db = new UnitTestsContext())
{
// The level entities are used to test EF complex types.
var expectedLevels = new[]
{
new Level1
{
Level2 = new Level2
{
Level2Name = "L2",
Updated = new DateTime(2018, 1, 1)
}
}
};
db.BulkInsertAll(expectedLevels);
var actualLevels = db.Levels.ToArray();
Assert.AreEqual(expectedLevels.Length, actualLevels.Length);
Assert.AreEqual(expectedLevels[0].Id, actualLevels[0].Id);
Assert.AreEqual(expectedLevels[0].Level2.Level2Name, actualLevels[0].Level2.Level2Name);
Assert.AreEqual(expectedLevels[0].Level2.Updated.Ticks, actualLevels[0].Level2.Updated.Ticks);
}
}
public void AlreadyExistingEntityWithIdentityKeyShouldNotBeInserted()
{
using (var db = new UnitTestsContext())
{
var p = new Person
{
FirstName = "Måns",
LastName = "Tånneryd",
BirthDate = new DateTime(1968, 10, 04)
};
db.BulkInsertAll(new BulkInsertRequest <Person>
{
Entities = new[] { p }.ToList()
});
Assert.AreEqual(1, db.People.Count());
db.BulkInsertAll(new BulkInsertRequest <Person>
{
Entities = new[] { p }.ToList()
});
Assert.AreEqual(1, db.People.Count());
}
}
public void CoursesWithSingleInstructorShouldBeBulkInserted()
{
using (var db = new UnitTestsContext())
{
var instructors = GetInstructors().ToArray();
var courses = GetCourses().ToArray();
courses[0].Instructors.Add(instructors[0]);
courses[1].Instructors.Add(instructors[0]);
courses[2].Instructors.Add(instructors[0]);
courses[3].Instructors.Add(instructors[1]);
courses[4].Instructors.Add(instructors[1]);
var request = new BulkInsertRequest <Course>
{
Entities = courses.ToList(),
EnableRecursiveInsert = EnableRecursiveInsert.Yes,
AllowNotNullSelfReferences = AllowNotNullSelfReferences.No
};
db.BulkInsertAll(request);
var dbInstructors = db.Instructors
.Include(i => i.Courses)
.ToArray();
var dbCourses = db.Courses.ToArray();
Assert.AreEqual(2, dbInstructors.Length);
Assert.AreEqual(5, dbInstructors.SelectMany(i => i.Courses).Count());
Assert.AreEqual(3, dbInstructors[0].Courses.Count);
Assert.AreEqual(2, dbInstructors[1].Courses.Count);
Assert.AreSame(dbCourses[0].Instructors.Single(), dbCourses[1].Instructors.Single());
Assert.AreSame(dbCourses[0].Instructors.Single(), dbCourses[2].Instructors.Single());
Assert.AreSame(dbCourses[3].Instructors.Single(), dbCourses[4].Instructors.Single());
}
}
public void JoinTablesWithGuidKeysShouldBeProperlyInserted()
{
using (var db = new UnitTestsContext())
{
var blog = new Blog {
Name = "My Blog"
};
var firstPost = new Post
{
Blog = blog,
Text = "My first blogpost.",
};
var visitor = new Visitor
{
Name = "Visitor1"
};
firstPost.Visitors.Add(visitor);
var req = new BulkInsertRequest <Post>
{
Entities = new[] { firstPost }.ToList(),
AllowNotNullSelfReferences = AllowNotNullSelfReferences.No,
SortUsingClusteredIndex = true,
EnableRecursiveInsert = EnableRecursiveInsert.Yes
};
var response = db.BulkInsertAll(req);
var posts = db.Posts
.Include(p => p.Blog)
.ToArray();
Assert.AreEqual(1, posts.Count());
}
}
public void AddingMotherWithChild()
{
var child = new Person
{
FirstName = "Arvid",
LastName = "Andersson",
BirthDate = new DateTime(2018, 1, 1),
};
var mother = new Person
{
FirstName = "Anna",
LastName = "Andersson",
BirthDate = new DateTime(1980, 1, 1),
};
mother.Children.Add(child);
using (var db = new UnitTestsContext())
{
var request = new BulkInsertRequest <Person>
{
Entities = new List <Person> {
mother
},
EnableRecursiveInsert = EnableRecursiveInsert.Yes,
};
db.BulkInsertAll(request);
var people = db.People.ToArray();
Assert.AreEqual(2, people.Length);
}
}
public void AlreadyExistingEntityWithUserGeneratedKeyShouldNotBeInserted()
{
using (var db = new UnitTestsContext())
{
var team1 = new TeamWithUserGeneratedGuidKey()
{
Id = Guid.NewGuid(),
Name = "Team #1",
};
db.BulkInsertAll(new BulkInsertRequest <TeamWithUserGeneratedGuidKey>
{
Entities = new[] { team1 }.ToList()
});
Assert.AreEqual(1, db.TeamsWithUserGeneratedGuids.Count());
db.BulkInsertAll(new BulkInsertRequest <TeamWithUserGeneratedGuidKey>
{
Entities = new[] { team1 }.ToList()
});
Assert.AreEqual(1, db.TeamsWithUserGeneratedGuids.Count());
}
}
public void AddingEmployeeWithCompany()
{
var employee = new Employee
{
Name = "John",
};
var employer = new Company
{
Name = "World Inc",
};
employer.ParentCompany = employer;
employee.Employer = employer;
using (var db = new UnitTestsContext())
{
var request = new BulkInsertRequest <Employee>
{
Entities = new List <Employee> {
employee
},
EnableRecursiveInsert = EnableRecursiveInsert.Yes,
AllowNotNullSelfReferences = AllowNotNullSelfReferences.Yes
};
db.BulkInsertAll(request);
var actual = db.Companies.Include(e => e.Employees).Single();
Assert.AreEqual("World Inc", actual.Name);
Assert.AreSame(actual, actual.ParentCompany);
Assert.AreEqual("John", actual.Employees.Single().Name);
}
}
public void DeleteNotExistingEntities2()
{
var p0 = new Person
{
FirstName = "Angelica",
LastName = "Tånneryd",
BirthDate = DateTime.Now
};
var p1 = new Person
{
FirstName = "Arvid",
LastName = "Tånneryd",
BirthDate = DateTime.Now,
EmployeeNumber = 0,
Mother = p0
};
var p2 = new Person
{
FirstName = "Viktor",
LastName = "Tånneryd",
BirthDate = DateTime.Now,
EmployeeNumber = 0,
Mother = p0
};
using (var db = new UnitTestsContext())
{
db.People.AddRange(new[] { p0, p1, p2 });
db.SaveChanges();
var people = db.People.OrderBy(p => p.FirstName).ToArray();
Assert.AreEqual(3, people.Length);
Assert.AreEqual(p0.Id, people[0].Id);
Assert.AreEqual(p1.Id, people[1].Id);
Assert.AreEqual(p2.Id, people[2].Id);
// Delete all children of p0 in the database
// that are not in the Items list. Make sure
// that we can differentiate between null and
// column default values.
// Setting the EmployeeNumber values to null
// should make those two objects NOT match
// with the records in the database and thus
// only the mother record should be left after
// this operation.
p1.EmployeeNumber = null;
p2.EmployeeNumber = null;
db.BulkDeleteNotExisting <Person, Person>(new BulkDeleteRequest <Person>(
new[] { new SqlCondition("MotherId", p0.Id) },
new[] { "FirstName", "EmployeeNumber", "LastName" })
{
Items = new[] { p1, p2 }.ToList()
});
people = db.People.OrderBy(p => p.FirstName).ToArray();
Assert.AreEqual(1, people.Length);
Assert.AreEqual(p0.Id, people[0].Id);
}
}
public void ZeroShouldNotMatchNullWhenSelectExisting()
{
using (var db = new UnitTestsContext())
{
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 1), Name = "ERICB", Value = 80
});
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 2), Name = "ERICB", Value = 81
});
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 3), Name = "ERICB", Value = 82
});
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 4), Name = "ERICB", Value = 0
});
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 5), Name = "ERICB", Value = 86
});
db.SaveChanges();
var prices = new[]
{
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 1), Name = "ERICB", Value = 80
}),
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 2), Name = "ERICB", Value = 81
}),
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 3), Name = "ERICB", Value = 82
}),
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 4), Name = "ERICB", Value = null
}),
db.Prices.Add(new Price()
{
Date = new DateTime(2019, 1, 5), Name = "ERICB", Value = 86
})
};
var existing = db.BulkSelectExisting <Price, Price>(
new BulkSelectRequest <Price>(new[] { "Date", "Name", "Value" }, prices));
Assert.AreEqual(4, existing.Count);
Assert.AreSame(prices[0], existing[0]);
Assert.AreSame(prices[1], existing[1]);
Assert.AreSame(prices[2], existing[2]);
Assert.AreSame(prices[4], existing[3]);
}
}
public void StackOverflowTest()
{
using (var db = new UnitTestsContext())
{
var i1 = new Instructor
{
FirstName = "Mickey",
LastName = "Mouse",
HireDate = new DateTime(1928, 5, 15),
OfficeAssignment = new OfficeAssignment {
Location = "Room 1A"
}
};
db.Instructors.Add(i1);
db.SaveChanges();
var d1 = new Department
{
Name = "Computer Science",
Budget = 10000000,
};
var c1 = new Course
{
Credits = 4,
Title = "Foundations of Data Science",
Department = d1
};
db.Courses.Add(c1);
db.SaveChanges();
i1.Courses.Add(c1);
db.SaveChanges();
Assert.AreEqual(1, db.Instructors.SelectMany(i => i.Courses).Distinct().Count());
var instructor = db.Instructors
.Include(i => i.Courses.Select(c => c.Department))
.Include(i => i.OfficeAssignment)
.Single();
instructor.InstructorID = 0;
instructor.OfficeAssignment.InstructorID = 0;
var request = new BulkInsertRequest <Instructor>
{
Entities = new[] { instructor }.ToList(),
EnableRecursiveInsert = EnableRecursiveInsert.Yes,
AllowNotNullSelfReferences = AllowNotNullSelfReferences.No
};
db.BulkInsertAll(request);
Assert.AreEqual(2, db.Instructors.SelectMany(i => i.Courses).Count());
}
}
public void AddingEmployeeToSubsidiary()
{
var corporateGroup = new Company
{
Name = "Global Corporation Inc",
};
corporateGroup.ParentCompany = corporateGroup;
var employer = new Company
{
Name = "Subsidiary Corporation Inc",
};
employer.ParentCompany = corporateGroup;
var john = new Employee
{
Name = "John",
Employer = employer
};
var adam = new Employee
{
Name = "Adam",
Employer = employer
};
using (var db = new UnitTestsContext())
{
var request = new BulkInsertRequest <Employee>
{
Entities = new List <Employee> {
john, adam
},
EnableRecursiveInsert = EnableRecursiveInsert.Yes,
AllowNotNullSelfReferences = AllowNotNullSelfReferences.Yes
};
db.BulkInsertAll(request);
var actual = db.Employees
.Include(e => e.Employer.ParentCompany)
.OrderBy(e => e.Name).ToArray();
Assert.AreEqual("Adam", actual[0].Name);
Assert.AreEqual("Subsidiary Corporation Inc", actual[0].Employer.Name);
Assert.AreSame(actual[0].Employer, actual[1].Employer);
Assert.AreEqual("John", actual[1].Name);
Assert.AreEqual("Subsidiary Corporation Inc", actual[1].Employer.Name);
Assert.AreEqual("Global Corporation Inc", actual[0].Employer.ParentCompany.Name);
Assert.AreEqual("Global Corporation Inc", actual[1].Employer.ParentCompany.Name);
Assert.AreSame(actual[0].Employer.ParentCompany, actual[1].Employer.ParentCompany);
}
}
public void ModifiedEntityShouldBeUpdated()
{
using (var db = new UnitTestsContext())
{
var blog = new Blog {
Name = "My Blog"
};
var firstPost = new Post
{
Text = "My first blogpost.",
PostKeywords = new List <Keyword>()
{
new Keyword {
Text = "first"
}
}
};
var secondPost = new Post
{
Text = "My second blogpost.",
PostKeywords = new List <Keyword>()
{
new Keyword {
Text = "second"
}
}
};
blog.BlogPosts.Add(firstPost);
blog.BlogPosts.Add(secondPost);
var req = new BulkInsertRequest <Blog>
{
Entities = new[] { blog }.ToList(),
AllowNotNullSelfReferences = AllowNotNullSelfReferences.No,
SortUsingClusteredIndex = true,
EnableRecursiveInsert = EnableRecursiveInsert.Yes
};
var response = db.BulkInsertAll(req);
var b = db.Blogs.Single();
Assert.AreEqual("My Blog", b.Name);
b.Name = "My (modified) Blog";
db.BulkUpdateAll(new BulkUpdateRequest
{
Entities = new [] { b },
KeyPropertyNames = new [] { "Id" }
});
b = db.Blogs.Single();
Assert.AreEqual("My (modified) Blog", b.Name);
}
}
public void RowWithReservedSqlKeywordAsColumnNameShouldBeInserted()
{
using (var db = new UnitTestsContext())
{
var e = new ReservedSqlKeyword
{
Identity = 10
};
db.BulkInsertAll(new[] { e });
Assert.AreEqual(10, e.Identity);
}
}
public void InsertEntityWithComputedColumnInTableWithIdentityPrimaryKeyShouldWork()
{
using (var db = new UnitTestsContext())
{
var instructor = new Instructor
{
FirstName = "Måns",
LastName = "Tånneryd",
HireDate = DateTime.Now.Date,
};
db.BulkInsertAll(new[] { instructor });
}
}
public void InsertEntityWithComputedColumnInTableWithUserGeneratedPrimaryKeyShouldWork()
{
using (var db = new UnitTestsContext())
{
for (int i = 0; i < 10; i++)
{
db.Journals.Add(new Journal()
{
Id = Guid.NewGuid()
});
}
db.SaveChanges();
var batchInvoice = new BatchInvoice {
Id = Guid.NewGuid()
};
foreach (var journal in db.Journals.ToList())
{
var invoice = new Invoice()
{
Id = Guid.NewGuid(), Gross = 10, Net = 3
};
invoice.Journals.Add(new InvoiceItem()
{
JournalId = journal.Id
});
batchInvoice.Invoices.Add(new BatchInvoiceItem()
{
Id = Guid.NewGuid(), Invoice = invoice
});
}
var req = new BulkInsertRequest <BatchInvoice>
{
Entities = new[] { batchInvoice }.ToList(),
AllowNotNullSelfReferences = AllowNotNullSelfReferences.No,
SortUsingClusteredIndex = true,
EnableRecursiveInsert = EnableRecursiveInsert.Yes
};
var response = db.BulkInsertAll(req);
Assert.AreEqual(1, db.BatchInvoices.ToArray().Count());
Assert.AreEqual(10, db.BatchInvoiceItems.ToArray().Count());
Assert.AreEqual(10, db.Invoices.ToArray().Count());
Assert.AreEqual(10, db.InvoiceItems.ToArray().Count());
}
}
public void ExistingEntitiesShouldBeSelectedOnSingleKey()
{
using (var db = new UnitTestsContext())
{
var now = DateTime.Now;
// Save 200 numbers (1 to 200) to the database.
var numbers = GenerateNumbers(1, 200, now).ToArray();
db.BulkInsertAll(new BulkInsertRequest <Number>
{
Entities = numbers,
EnableRecursiveInsert = EnableRecursiveInsert.Yes
});
// Create a list of 100 numbers with values 151 to 250
var nums = GenerateNumbers(151, 100, now)
.Select(n => new Num {
Val = n.Value
})
.ToList();
// Numbers 151 to 200 from the database should be selected.
var existingNumbers = db.BulkSelect <Num, Number>(new BulkSelectRequest <Num>
{
Items = nums.ToArray(),
KeyPropertyMappings = new[]
{
new KeyPropertyMapping
{
ItemPropertyName = "Val",
EntityPropertyName = "Value"
},
}
}).ToArray();
Assert.AreEqual(existingNumbers.Length, 50);
var expectedNumbers = numbers.Skip(150).Take(50).ToArray();
for (int i = 0; i < 50; i++)
{
Assert.AreEqual(expectedNumbers[i].Id, existingNumbers[i].Id);
Assert.AreEqual(expectedNumbers[i].ParityId, existingNumbers[i].ParityId);
Assert.AreEqual(expectedNumbers[i].UpdatedAt.ToString(CultureInfo.InvariantCulture), existingNumbers[i].UpdatedAt.ToString(CultureInfo.InvariantCulture));
Assert.AreEqual(expectedNumbers[i].UpdatedBy, existingNumbers[i].UpdatedBy);
Assert.AreEqual(expectedNumbers[i].Value, existingNumbers[i].Value);
}
}
}
public void OneToManyWithGuidPrimaryKeyInsertingTheTopEntity()
{
using (var db = new UnitTestsContext())
{
var blog = new Blog {
Name = "My Blog"
};
var firstPost = new Post
{
Text = "My first blogpost.",
PostKeywords = new List <Keyword>()
{
new Keyword {
Text = "first"
}
}
};
var secondPost = new Post
{
Text = "My second blogpost.",
PostKeywords = new List <Keyword>()
{
new Keyword {
Text = "second"
}
}
};
blog.BlogPosts.Add(firstPost);
blog.BlogPosts.Add(secondPost);
var req = new BulkInsertRequest <Blog>
{
Entities = new[] { blog }.ToList(),
AllowNotNullSelfReferences = AllowNotNullSelfReferences.No,
SortUsingClusteredIndex = true,
EnableRecursiveInsert = EnableRecursiveInsert.Yes
};
var response = db.BulkInsertAll(req);
var posts = db.Posts
.Include(p => p.Blog)
.ToArray();
Assert.AreEqual(2, posts.Count());
Assert.AreEqual(posts[1].Blog, posts[0].Blog);
}
}
public void OrderOfNExpected()
{
using (var db = new UnitTestsContext())
{
var coaches = new List <CoachWithUserGeneratedGuidKey>();
for (int i = 0; i < 1000; i++)
{
var c = new CoachWithUserGeneratedGuidKey
{
Id = Guid.NewGuid(),
Firstname = $"Coach {i}",
Lastname = $"Lastname",
};
for (int j = 0; j < 25; j++)
{
var t = new TeamWithUserGeneratedGuidKey()
{
Id = Guid.NewGuid(),
Name = $"Team {j}"
};
c.Teams.Add(t);
}
coaches.Add(c);
}
db.BulkInsertAll(new BulkInsertRequest <CoachWithUserGeneratedGuidKey>
{
Entities = coaches,
EnableRecursiveInsert = EnableRecursiveInsert.Yes
});
var actual = db.CoachesWithUserGeneratedGuids
.Include(c => c.Teams)
.ToArray();
Assert.AreEqual(1000, actual.Count());
foreach (var coach in actual.ToArray())
{
Assert.AreEqual(25, coach.Teams.Count);
}
}
}
public void SelectExistingFromTableWithUserGeneratedGuidAsPrimaryKey()
{
using (var db = new UnitTestsContext())
{
var teams = new List <TeamWithUserGeneratedGuidKey>();
// Add ten teams to the database (Team 0 - Team 9)
for (int i = 0; i < 10; i++)
{
teams.Add(new TeamWithUserGeneratedGuidKey()
{
Id = Guid.NewGuid(), Name = $"Team #{i}"
});
}
// Save the ten first teams to the database.
db.BulkInsertAll(new BulkInsertRequest <TeamWithUserGeneratedGuidKey>
{
Entities = teams,
});
// Add another ten teams (Team 10 - Team 19) to
// the list but not to the database.
for (int i = 10; i < 20; i++)
{
teams.Add(new TeamWithUserGeneratedGuidKey()
{
Id = Guid.NewGuid(), Name = $"Team #{i}"
});
}
// The only teams we should get back out of the 20 teams (Team 0 - Team 19)
// are the first ten that we saved to the database.
var existingTeams = db.BulkSelectExisting <TeamWithUserGeneratedGuidKey, TeamWithUserGeneratedGuidKey>(new BulkSelectRequest <TeamWithUserGeneratedGuidKey>(new[] { "Id" }, teams));
existingTeams = existingTeams.OrderBy(t => t.Name).ToList();
Assert.AreEqual(10, existingTeams.Count);
for (int i = 0; i < 10; i++)
{
Assert.AreEqual(teams[i].Id, existingTeams[i].Id);
Assert.AreEqual(teams[i].Name, existingTeams[i].Name);
}
}
}
public void EntitiesOfDifferentTypeMatchingExistingEntitiesShouldBeSelected()
{
using (var db = new UnitTestsContext())
{
var now = DateTime.Now;
// Save 200 numbers (1 to 200) to the database.
var numbers = GenerateNumbers(1, 200, now).ToArray();
db.BulkInsertAll(new BulkInsertRequest <Number>
{
Entities = numbers,
EnableRecursiveInsert = EnableRecursiveInsert.Yes
});
// Create a list of 100 numbers with values 151 to 250
var nums = GenerateNumbers(151, 100, now)
.Select(n => new Num {
Val = n.Value
})
.ToList();
// Numbers 151 to 200 out of 151 to 250 should be selected.
var existingNumbers = db.BulkSelectExisting <Num, Number>(new BulkSelectRequest <Num>
{
Items = nums,
KeyPropertyMappings = new[]
{
new KeyPropertyMapping
{
ItemPropertyName = "Val",
EntityPropertyName = "Value"
},
}
}).ToArray();
Assert.AreEqual(50, existingNumbers.Length);
for (int i = 0; i < 50; i++)
{
Assert.AreEqual(nums[i], existingNumbers[i]);
}
}
}
public void AddingEmployeeToCompanyWithoutParentCompanySet()
{
try
{
var employer = new Company
{
Name = "World Inc",
};
var john = new Employee
{
Name = "John",
Employer = employer
};
var adam = new Employee
{
Name = "Adam",
Employer = employer
};
using (var db = new UnitTestsContext())
{
var request = new BulkInsertRequest <Employee>
{
Entities = new List <Employee> {
john, adam
},
EnableRecursiveInsert = EnableRecursiveInsert.Yes,
AllowNotNullSelfReferences = AllowNotNullSelfReferences.Yes
};
db.BulkInsertAll(request);
}
}
catch (System.Data.SqlClient.SqlException e)
{
Console.WriteLine(e.Message);
var expectedMessage =
@"The ALTER TABLE statement conflicted with the FOREIGN KEY SAME TABLE constraint ""FK_dbo_Company_dbo_Company_ParentCompanyId"". The conflict occurred in database ""Tanneryd.BulkOperations.EF6.NET47.ModelFirst.Tests.Models.EF.UnitTestContext"", table ""dbo.Company"", column 'Id'.";
Assert.AreEqual(expectedMessage, e.Message);
throw;
}
}
public void BulkInsertIntoTableWithoutNavPropertiesShouldWork()
{
using (var db = new UnitTestsContext())
{
var entities = new List <Price>
{
new Price()
{
Date = new DateTime(2019, 1, 1), Name = "ERICB", Value = 80
},
new Price()
{
Date = new DateTime(2019, 1, 2), Name = "ERICB", Value = 81
},
new Price()
{
Date = new DateTime(2019, 1, 3), Name = "ERICB", Value = 82
},
new Price()
{
Date = new DateTime(2019, 1, 4), Name = "ERICB", Value = 0
},
new Price()
{
Date = new DateTime(2019, 1, 5), Name = "ERICB", Value = 86
}
};
var request = new BulkInsertRequest <Price>
{
AllowNotNullSelfReferences = AllowNotNullSelfReferences.No,
EnableRecursiveInsert = EnableRecursiveInsert.NoButRetrieveGeneratedPrimaryKeys,
Entities = entities.ToArray()
};
db.BulkInsertAll(request);
}
}
public void RowWithCompositePrimaryKeyShouldBeInserted()
{
using (var db = new UnitTestsContext())
{
var x = new Coordinate
{
Value = 1
};
var y = new Coordinate
{
Value = 2
};
var p = new Point
{
XCoordinate = x,
YCoordinate = y,
Value = 100
};
db.BulkInsertAll(new[] { p }, null, true);
Assert.AreEqual(100, p.Value);
}
}
public void FillingUpTableWithPrimaryKeyColumnOnlyShouldBePossible()
{
using (var db = new UnitTestsContext())
{
var entities = new List <EmptyTable>();
for (int i = 0; i < 1000; i++)
{
entities.Add(new EmptyTable());
}
var request = new BulkInsertRequest <EmptyTable>
{
AllowNotNullSelfReferences = AllowNotNullSelfReferences.No,
EnableRecursiveInsert = EnableRecursiveInsert.NoButRetrieveGeneratedPrimaryKeys,
Entities = entities
};
db.BulkInsertAll(request);
//for (int i = 0; i < 1000; i++)
//{
// Console.WriteLine(entities[i].Id);
//}
}
}
public void PrimaryKeyColumnMappedToPropertyWithDifferentNameShouldBeAllowed()
{
using (var db = new UnitTestsContext())
{
var now = DateTime.Now;
// The Parity table is defined with a pk column named Key but
// it is mapped to the property Id. There was a user reporting that
// this did not work properly so we want to test it.
var parities = new[]
{
new Parity {
Name = "Even", UpdatedAt = now, UpdatedBy = "Måns"
},
new Parity {
Name = "Odd", UpdatedAt = now, UpdatedBy = "Måns"
},
};
db.BulkInsertAll(parities);
Assert.IsTrue(parities[0].Id > 0);
Assert.IsTrue(parities[1].Id > 0);
}
}
protected void CleanupUnitTestContext()
{
var db = new UnitTestsContext();
db.BatchInvoiceItems.RemoveRange(db.BatchInvoiceItems.ToArray());
db.InvoiceItems.RemoveRange(db.InvoiceItems.ToArray());
db.Invoices.RemoveRange(db.Invoices.ToArray());
db.Journals.RemoveRange(db.Journals.ToArray());
db.BatchInvoices.RemoveRange(db.BatchInvoices.ToArray());
db.SaveChanges();
db.Database.ExecuteSqlCommand(@"DELETE FROM [dbo].[PlayerWithDbGeneratedGuid]");
db.Database.ExecuteSqlCommand(@"DELETE FROM [dbo].[CoachWithDbGeneratedGuid]");
db.Database.ExecuteSqlCommand(@"DELETE FROM [dbo].[TeamWithDbGeneratedGuid]");
db.Database.ExecuteSqlCommand(@"DELETE FROM [dbo].[CoachTeamsWithDbGeneratedGuid]");
db.Database.ExecuteSqlCommand(@"DELETE FROM [dbo].[PlayerWithUserGeneratedGuid]");
db.Database.ExecuteSqlCommand(@"DELETE FROM [dbo].[CoachWithUserGeneratedGuid]");
db.Database.ExecuteSqlCommand(@"DELETE FROM [dbo].[TeamWithUserGeneratedGuid]");
db.Database.ExecuteSqlCommand(@"DELETE FROM [dbo].[CoachTeamsWithUserGeneratedGuid]");
db.OfficeAssignments.RemoveRange(db.OfficeAssignments.ToArray());
foreach (var i in db.Instructors)
{
i.Courses.Clear();
}
db.Instructors.RemoveRange(db.Instructors.ToArray());
db.Courses.RemoveRange(db.Courses.ToArray());
db.Departments.RemoveRange(db.Departments.ToArray());
db.SaveChanges();
db.ReservedSqlKeywords.RemoveRange(db.ReservedSqlKeywords.ToArray());
db.Coordinates.RemoveRange(db.Coordinates.ToArray());
db.Points.RemoveRange(db.Points.ToArray());
db.SaveChanges();
db.Blogs.RemoveRange(db.Blogs.ToArray());
db.Posts.RemoveRange(db.Posts.ToArray());
db.Keywords.RemoveRange(db.Keywords.ToArray());
db.Visitors.RemoveRange(db.Visitors.ToArray());
db.SaveChanges();
db.People.RemoveRange(db.People.ToArray());
db.SaveChanges();
db.Employees.RemoveRange(db.Employees.ToArray());
db.Companies.RemoveRange(db.Companies.ToArray());
db.SaveChanges();
db.Composites.RemoveRange(db.Composites.ToArray());
db.Primes.RemoveRange(db.Primes.ToArray());
db.Numbers.RemoveRange(db.Numbers.ToArray());
db.Parities.RemoveRange(db.Parities.ToArray());
db.SaveChanges();
db.Levels.RemoveRange(db.Levels.ToArray());
db.SaveChanges();
db.Prices.RemoveRange(db.Prices.ToArray());
db.SaveChanges();
db.LogItems.RemoveRange(db.LogItems.ToArray());
db.SaveChanges();
var cmdText = @"
BEGIN
ALTER TABLE [dbo].[Instructor] DROP COLUMN FullName
ALTER TABLE [dbo].[Instructor] ADD FullName AS (FirstName + ' ' + LastName) PERSISTED NOT NULL
ALTER TABLE [dbo].[Invoice] DROP COLUMN Tax
ALTER TABLE [dbo].[Invoice] ADD Tax AS (Gross - Net) PERSISTED NOT NULL
END";
db.Database.ExecuteSqlCommand(cmdText);
}
