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 UnitTestContext())
{
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 AddingCompanyWithEmployee()
{
var employee = new Employee
{
Name = "John",
};
var employer = new Company
{
Name = "World Inc",
};
employer.ParentCompany = employer;
employer.Employees.Add(employee);
using (var db = new CompanyContext())
{
var request = new BulkInsertRequest <Company>
{
Entities = new List <Company> {
employer
},
Recursive = true,
AllowNotNullSelfReferences = true
};
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 AddingChildWithMother()
{
var mother = new Person
{
FirstName = "Anna",
LastName = "Andersson",
BirthDate = new DateTime(1980, 1, 1),
};
var child = new Person
{
FirstName = "Arvid",
LastName = "Andersson",
BirthDate = new DateTime(2018, 1, 1),
Mother = mother,
};
using (var db = new PeopleContext())
{
var request = new BulkInsertRequest <Person>
{
Entities = new List <Person> {
child
},
Recursive = true,
};
db.BulkInsertAll(request);
var people = db.People.ToArray();
Assert.AreEqual(2, people.Length);
}
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
public questStatus PerformBulkInsert(BulkInsertRequest bulkInsertRequest)
{
// Initialize
questStatus status = null;
// Read Filter
FilterId filterId = new FilterId(bulkInsertRequest.FilterId);
Filter filter = null;
FiltersMgr filtersMgr = new FiltersMgr(this.UserSession);
status = filtersMgr.Read(filterId, out filter);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
bulkInsertRequest.Filter = filter;
// Determine if bulk insert filter procedure exists.
FilterProcedure filterProcedure = null;
status = _dbBulkInsertMgr.GetFilterProcedure(bulkInsertRequest, "Insert", out filterProcedure);
if (!questStatusDef.IsSuccessOrWarning(status))
{
return(status);
}
// Perform bulk insert filter procedure if exists.
if (questStatusDef.IsSuccess(status))
{
return(PerformBulkInsertFilterProcedure(bulkInsertRequest, filterProcedure));
}
// Validate bulk insert request
BulkInsertResponse bulkInsertResponse = null;
status = ValidateRequest(bulkInsertRequest, out bulkInsertResponse);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Generate the SQL
status = _dbBulkInsertMgr.GenerateBulkInsertSQL(bulkInsertRequest);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Perform bulk insert.
status = _dbBulkInsertMgr.PerformBulkInsert(bulkInsertRequest);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
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 UnitTestContext())
{
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 OneToManyWhereAllIsNew()
{
using (var db = new NumberContext())
{
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 JoinTablesWithGuidKeysShouldBeProperlyInserted()
{
using (var db = new BlogContext())
{
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 CoursesWithSingleInstructorShouldBeBulkInserted()
{
using (var db = new SchoolContext())
{
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(),
Recursive = true,
AllowNotNullSelfReferences = false
};
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 InstructorsWithMulitpleCoursesShouldBeBulkInserted()
{
using (var db = new SchoolContext())
{
var instructors = GetInstructors().ToArray();
var courses = GetCourses().ToArray();
instructors[0].Courses.Add(courses[0]);
instructors[0].Courses.Add(courses[1]);
instructors[0].Courses.Add(courses[2]);
instructors[1].Courses.Add(courses[3]);
instructors[1].Courses.Add(courses[4]);
var request = new BulkInsertRequest <Instructor>
{
Entities = instructors.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 EntityHierarchyShouldBeInserted()
{
using (var db = new NumberContext())
{
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,
Recursive = true,
};
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);
}
}
private questStatus getNumEntities(BulkInsertRequest bulkInsertRequest, out int numEntities)
{
// Initialize
numEntities = 0;
// If one table, return 1.
if (bulkInsertRequest.Filter.FilterTableList.Count == 1)
{
numEntities = 1;
return(new questStatus(Severity.Success));
}
// Figure out number of entities.
List <string> entityNameList = new List <string>();
foreach (BulkInsertColumnValue bulkInsertColumnValue in bulkInsertRequest.Rows[0].Columns)
{
string[] pp = bulkInsertColumnValue.Name.Split('_');
string entityName = pp[0];
string existingEntityName = entityNameList.Find(delegate(string t) { return(t == entityName); });
if (existingEntityName == null)
{
entityNameList.Add(entityName);
}
}
numEntities = entityNameList.Count();
return(new questStatus(Severity.Success));
}
public void EntityHierarchyShouldBeInserted()
{
using (var db = new NumberContext())
{
var now = DateTime.Now;
var parities = new[]
{
new Parity {
Name = "Even", UpdatedAt = now, UpdatedBy = "Måns"
},
new Parity {
Name = "Odd", UpdatedAt = now, UpdatedBy = "Måns"
},
};
var numbers = GenerateNumbers(1, 100, parities[0], parities[1], now).ToArray();
var primes = GeneratePrimeNumbers(100, numbers, now);
var request = new BulkInsertRequest <Prime>
{
Entities = primes,
Recursive = true,
};
db.BulkInsertAll(request);
}
}
public void StackOverflowTest()
{
using (var db = new SchoolContext())
{
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 questStatus PerformBulkInsert(BulkInsertRequest bulkInsertRequest)
{
// Initialize
questStatus status = null;
// Execute bulk insert SQL
try
{
// Get tableset
TablesetId tablesetId = new TablesetId(bulkInsertRequest.Filter.TablesetId);
Tableset tableset = null;
DbTablesetsMgr dbTablesetsMgr = new DbTablesetsMgr(this.UserSession);
status = dbTablesetsMgr.Read(tablesetId, out tableset);
if (!questStatusDef.IsSuccessOrWarning(status))
{
return(status);
}
// Get database
DatabaseId databaseId = new DatabaseId(tableset.DatabaseId);
Quest.Functional.MasterPricing.Database database = null;
DbDatabasesMgr dbDatabasesMgr = new DbDatabasesMgr(this.UserSession);
status = dbDatabasesMgr.Read(databaseId, out database);
if (!questStatusDef.IsSuccessOrWarning(status))
{
return(status);
}
// Execute sql
using (SqlConnection sqlConnection = new SqlConnection(database.ConnectionString))
{
sqlConnection.Open();
using (SqlCommand cmd = sqlConnection.CreateCommand())
{
cmd.CommandText = bulkInsertRequest.SQL;
cmd.CommandType = CommandType.Text;
int numRows = cmd.ExecuteNonQuery();
if (numRows != bulkInsertRequest.Rows.Count)
{
return(new questStatus(Severity.Error, String.Format("ERROR: Bulk insert SQL execution failed: Rows: {0}", numRows)));
}
}
}
}
catch (System.Exception ex)
{
return(new questStatus(Severity.Fatal, String.Format("EXCEPTION: executing bulk insert SQL {0} SQL: {1}",
bulkInsertRequest.SQL, ex.Message)));
}
return(new questStatus(Severity.Success));
}
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 UnitTestContext())
{
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 UnitTestContext())
{
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 string GetJsonBulkInsert <T>(BulkInsertRequest <T> request)
{
JsonSerializerSettings serializerSettings = new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore,
};
//serializerSettings.Converters.Add(new IsoDateTimeConverter() { DateTimeFormat = "yyyy-MM-ddTHH:mm:ssZ" });
foreach (T record in request.Records)
{
T recordToInsert = (T)record;
//recordToInsert.CreatedById = null;
//recordToInsert.CreatedDate = null;
//recordToInsert.LastModifiedById = null;
//recordToInsert.LastModifiedDate = null;
//recordToInsert.LastViewedDate = null;
//recordToInsert.SystemModstamp = null;
//recordToInsert.LastReferencedDate = null;
}
string requestJson = JsonConvert.SerializeObject(request, Formatting.Indented, serializerSettings);
// Create JSON Line https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/requests_composite_sobject_tree.htm#topic-title
JObject obj = JObject.Parse(requestJson);
JArray reccords = (JArray)obj["records"];
foreach (var reccord in reccords)
{
var recordObject = (JObject)reccord;
Console.WriteLine(recordObject["ID"]);
Attributes attribute =
new Attributes
{
type = typeof(T).Name,
referenceId = recordObject["ID"].ToString(),
};
var attributeObject = JObject.FromObject(attribute);
recordObject.Add(new JProperty("attributes", attributeObject));
recordObject.Remove("ID");
}
return(obj.ToString(Formatting.Indented));
}
public questStatus PerformBulkInsertFilterProcedure(BulkInsertRequest bulkInsertRequest, FilterProcedure filterProcedure)
{
// Initialize
questStatus status = null;
// Perform operation.
status = _dbBulkInsertMgr.PerformBulkInsertFilterProcedure(bulkInsertRequest, filterProcedure);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
public void InsertBatchInvoiceWithInvoiceForEachExistingJournal()
{
using (var db = new InvoiceContext())
{
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()
};
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 InsertEntityWithComputedColumnInTableWithUserGeneratedPrimaryKeyShouldWork()
{
using (var db = new UnitTestContext())
{
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 async Task <BulkInsertReply> CreateRecordBulk <T>(BulkInsertRequest <T> bulkInsertrequest)
{
var objectName = GetSalesForceObjectName <T>();
HttpRequestMessage request = new HttpRequestMessage
{
RequestUri = new Uri(_connectionDetail.RestUrl + "/data/v37.0/composite/tree/" + objectName),
Method = HttpMethod.Post,
};
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
request.Headers.Add("Authorization", _connectionDetail.RestSessionId);
string requestJson = GetJsonBulkInsert <T>(bulkInsertrequest);
Console.WriteLine(requestJson);
request.Content = new StringContent(requestJson, Encoding.UTF8, "application/json");
HttpClient httpClient = new HttpClient();
HttpResponseMessage responseMessage = await httpClient.SendAsync(request);
// Console.WriteLine(responseMessage.StatusCode);
switch (responseMessage.StatusCode)
{
case HttpStatusCode.Created:
string jsonData = responseMessage.Content.ReadAsStringAsync().Result;
// Console.WriteLine(jsonData);
BulkInsertReply bulkInsertReply = JsonConvert.DeserializeObject <BulkInsertReply>(jsonData);
return(bulkInsertReply);
case HttpStatusCode.BadRequest:
Console.WriteLine(responseMessage.Content.ReadAsStringAsync().Result);
break;
case HttpStatusCode.Unauthorized:
Console.WriteLine(responseMessage.Content.ReadAsStringAsync().Result);
break;
default:
Console.WriteLine(responseMessage.Content.ReadAsStringAsync().Result);
break;
}
return(null);
}
/*==================================================================================================================================
* Public Methods
*=================================================================================================================================*/
#region Filter Procedure Utility Routines
/*----------------------------------------------------------------------------------------------------------------------------------
* Filter Procedure Utility Routines
*---------------------------------------------------------------------------------------------------------------------------------*/
public questStatus GetFilterProcedure(BulkInsertRequest bulkInsertRequest, string Action, out FilterProcedure filterProcedure)
{
// Initialize
questStatus status = null;
filterProcedure = null;
// Get the filter procedures.
FilterId filterId = new FilterId(bulkInsertRequest.FilterId);
List <FilterProcedure> filterProcedureList = null;
DbFilterProceduresMgr dbFilterProceduresMgr = new DbFilterProceduresMgr(this.UserSession);
status = dbFilterProceduresMgr.Read(filterId, out filterProcedureList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Determine if given action exists.
FilterProcedure INSERTsproc = filterProcedureList.Find(delegate(FilterProcedure fp) { return(fp.Action == Action); });
if (INSERTsproc == null)
{
return(new questStatus(Severity.Warning, String.Format("No {0} filter procedure", Action)));
}
// Get parameters
FilterProcedureId filterProcedureId = new FilterProcedureId(INSERTsproc.Id);
List <FilterProcedureParameter> filterProcedureParameterList = null;
DbFilterProcedureParametersMgr dbFilterProcedureParametersMgr = new DbFilterProcedureParametersMgr(this.UserSession);
status = dbFilterProcedureParametersMgr.Read(filterProcedureId, out filterProcedureParameterList);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
// Return filter procedure with parameters.
INSERTsproc.ParameterList = filterProcedureParameterList;
filterProcedure = INSERTsproc;
return(new questStatus(Severity.Success));
}
public void CoursesWithSingleInstructorShouldBeBulkInserted()
{
using (var db = new UnitTestContext())
{
var instructors = GetInstructors().ToArray();
var courses = GetCourses().ToArray();
courses[0].CourseInstructors.Add(new CourseInstructor {
Instructor = instructors[0]
});
courses[1].CourseInstructors.Add(new CourseInstructor {
Instructor = instructors[0]
});
courses[2].CourseInstructors.Add(new CourseInstructor {
Instructor = instructors[0]
});
courses[3].CourseInstructors.Add(new CourseInstructor {
Instructor = instructors[1]
});
courses[4].CourseInstructors.Add(new CourseInstructor {
Instructor = 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.CourseInstructors)
.ThenInclude(ci => ci.Course)
.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 OneToManyWithGuidPrimaryKeyInsertingTheTopEntity()
{
using (var db = new BlogContext())
{
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 OneToManyWithGuidPrimaryKeyInsertingTheChildEntities()
{
using (var db = new BlogContext())
{
var blog = new Blog {
Name = "My Blog"
};
var firstPost = new Post
{
Blog = blog,
Text = "My first blogpost.",
PostKeywords = new List <Keyword>()
{
new Keyword {
Text = "first"
}
}
};
var secondPost = new Post
{
Blog = blog,
Text = "My second blogpost.",
PostKeywords = new List <Keyword>()
{
new Keyword {
Text = "second"
}
}
};
var req = new BulkInsertRequest <Post>
{
Entities = new[] { firstPost, secondPost }.ToList(),
AllowNotNullSelfReferences = false,
SortUsingClusteredIndex = true,
Recursive = true
};
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 Methods
*=================================================================================================================================*/
public questStatus DoBulkInsert(BulkInsertViewModel bulkInsertViewModel)
{
// Initialize
questStatus status = null;
// Build bulk insert request
BulkInsertRequest bulkInsertRequest = new BulkInsertRequest();
BufferMgr.TransferBuffer(bulkInsertViewModel, bulkInsertRequest, true);
bulkInsertRequest.TablesetId = bulkInsertViewModel.TablesetId;
foreach (BulkInsertRowDataViewModel RowData in bulkInsertViewModel.Rows)
{
BulkInsertRow bulkInsertRow = new BulkInsertRow();
foreach (NameValueViewModel nameValueViewModel in RowData.Columns)
{
BulkInsertColumnValue bulkInsertColumnValue = new BulkInsertColumnValue();
bulkInsertColumnValue.Name = nameValueViewModel.ColumnName;
if ((string.IsNullOrWhiteSpace(nameValueViewModel.ColumnValue)) && (nameValueViewModel.ColumnValue != null))
{
bulkInsertColumnValue.Value = nameValueViewModel.ColumnValue.Trim();
}
else
{
bulkInsertColumnValue.Value = nameValueViewModel.ColumnValue;
}
bulkInsertRow.Columns.Add(bulkInsertColumnValue);
}
bulkInsertRequest.Rows.Add(bulkInsertRow);
}
// Perform bulk insert.
BulkInsertMgr bulkInsertMgr = new BulkInsertMgr(this.UserSession);
status = bulkInsertMgr.PerformBulkInsert(bulkInsertRequest);
if (!questStatusDef.IsSuccess(status))
{
return(status);
}
return(new questStatus(Severity.Success));
}
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 AddingEmployeeToSubsidiary()
{
var employer = new Company
{
Name = "World Inc",
};
employer.ParentCompany = employer;
var john = new Employee
{
Name = "John",
Employer = employer
};
var adam = new Employee
{
Name = "Adam",
Employer = employer
};
using (var db = new CompanyContext())
{
var request = new BulkInsertRequest <Employee>
{
Entities = new List <Employee> {
john, adam
},
Recursive = true,
AllowNotNullSelfReferences = true
};
db.BulkInsertAll(request);
var actual = db.Employees.Include(e => e.Employer).OrderBy(e => e.Name).ToArray();
Assert.AreEqual("Adam", actual[0].Name);
Assert.AreEqual("World Inc", actual[0].Employer.Name);
Assert.AreSame(actual[0].Employer, actual[0].Employer.ParentCompany);
Assert.AreEqual("John", actual[1].Name);
Assert.AreEqual("World Inc", actual[1].Employer.Name);
Assert.AreSame(actual[1].Employer, actual[1].Employer.ParentCompany);
}
}
public void OneToManyWithGuidPrimaryKey()
{
using (var db = new BlogContext())
{
var blog = new Blog {
Name = "My Blog"
};
var firstPost = new Post
{
Blog = blog,
Text = "My first blogpost.",
PostKeywords = new List <Keyword>()
{
new Keyword {
Text = "first"
}
}
};
var secondPost = new Post
{
Blog = blog,
Text = "My second blogpost.",
PostKeywords = new List <Keyword>()
{
new Keyword {
Text = "second"
}
}
};
var req = new BulkInsertRequest <Blog>
{
Entities = new[] { blog }.ToList(),
AllowNotNullSelfReferences = false,
SortUsingClusteredIndex = true,
Recursive = true
};
var response = db.BulkInsertAll(req);
}
}
public void BulkInsertIntoTableWithoutNavPropertiesShouldWork()
{
using (var db = new UnitTestContext())
{
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);
}
}