/// <summary>
/// Loads the full object graph for the
/// <see cref="DataModel"/> objects that are returned from the specified
/// <paramref name="query"/>, within the specified database
/// <paramref name="transactionContext"/>.
/// </summary>
/// <param name="query"></param>
/// <param name="transactionContext"></param>
/// <param name="depth"></param>
/// <param name="loadedModels">
/// Used for keeping recursive loading from resulting
/// in infinite loops. Evaluate each loaded item from
/// a database result set against this collection; if
/// there is a match, use the collection item,
/// otherwise use the database loaded item, deep-load
/// it, and add it to this collection.
/// </param>
/// <returns></returns>
public virtual DataModelCollection <TModel> DeepLoadModels <TModel>(
DataModelQuery <TModel> query, int?depth, DbTransaction transactionContext,
List <DataModel> loadedModels) where TModel : DataModel
{
DataModelCollection <TModel> entities = LoadModels(query);
DataModel e;
bool hasForeignKey = false;
if (entities.Count > 0)
{
e = entities[0];
foreach (var field_kvp in e.EntityMappings.FieldMappings)
{
DataModelColumnAttribute field = field_kvp.Value;
if (field.IsForeignKey)
{
hasForeignKey = true;
break;
}
}
if (!hasForeignKey &&
(e.EntityMappings.ForeignModelMappings == null ||
e.EntityMappings.ForeignModelMappings.Count == 0))
{
return(entities);
}
}
for (int i = 0; i < entities.Count; i++)
{
if (depth == null || depth > 0)
{
TModel entity = entities[i];
if (hasForeignKey && !loadedModels.Contains(entity))
{
foreach (var field_kvp in entity.EntityMappings.FieldMappings)
{
DataModelColumnAttribute field = field_kvp.Value;
if (field.IsForeignKey && field.ForeignKeyMapping.AssignToMember != null)
{
LoadMember(entity, field, field_kvp.Key,
transactionContext, loadedModels);
loadedModels.Add(entity);
}
}
}
if (entity.EntityMappings.ForeignModelMappings != null &&
entity.EntityMappings.ForeignModelMappings.Count > 0
)
{
DataModelQuery <TModel> query2 = EntityToIdentifyingQuery(entity);
entity = (depth == null)
? DeepLoadModel(query2, transactionContext, loadedModels)
: DeepLoadModel(query2, depth - 1, transactionContext, loadedModels);
//loadedModels.Add(entity);
entities[i] = entity;
}
}
}
return(entities);
}
private static string QueryToSortExpression <TModel>(DataModelQuery <TModel> query) where TModel : DataModel
{
var sb = new StringBuilder();
foreach (var item in query.OrderBy)
{
if (sb.Length > 0)
{
sb.Append(", ");
}
sb.Append(item.FieldName);
sb.Append(" ");
switch (item.SortDirection)
{
case Sort.Ascending:
sb.Append("ASC");
break;
case Sort.Descending:
sb.Append("DESC");
break;
}
}
return(sb.ToString());
}
protected DataModelCollection <TModel> DeepLoadModels <TModel>(
DataModelQuery <TModel> query, DbTransaction transactionContext,
List <DataModel> loadedModels
) where TModel : DataModel
{
return((DataModelCollection <TModel>)DeepLoadModels(query, null, transactionContext, loadedModels));
}
/// <summary>
/// Returns the count of records that match the specified query criteria.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <param name="transactionContext"></param>
/// <returns></returns>
public override long GetCount <TModel>(DataModelQuery <TModel> query, DbTransaction transactionContext)
{
DbConnection tmpConn = null;
if (transactionContext == null)
{
tmpConn = CreateAndOpenConnection();
transactionContext = tmpConn.BeginTransaction();
}
try
{
var cmdBuilder = CreateCommandBuilder(query);
cmdBuilder.SelectionItems = "COUNT(*) AS ResultValue";
using (var cmd = cmdBuilder.CreateDbCommand(transactionContext))
{
var retval = cmd.ExecuteScalar();
return(Convert.ToInt64(retval));
}
}
finally
{
if (tmpConn != null)
{
transactionContext.Commit();
tmpConn.Close();
}
}
}
private TModel DeepLoadModel <TModel>(
DataModelQuery <TModel> query, DbTransaction transactionContext,
List <DataModel> loadedModels
) where TModel : DataModel
{
return(DeepLoadModel(query, null, transactionContext, loadedModels));
}
/// <summary>
/// Returns a loaded instance of the specified type using the specified
/// <paramref name="query"/> and <paramref name="transactionContext"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="transactionContext"></param>
/// <returns></returns>
public override T LoadModel <T>(DataModelQuery <T> query, DbTransaction transactionContext)
{
if (transactionContext != null)
{
throw new NotImplementedException("MemoryDataProvider does not support DbTransactions");
}
var map = DataModel.GetMapping <T>();
var table = Tables[map.TableMapping.Table];
var rows = table.Select(QueryToExpression(query));
if (rows.Length == 0)
{
return(null);
}
var t = DataModel.GetUnwrappedType(typeof(T));
T ret = null;
if (t != typeof(T))
{
var subret = Activator.CreateInstance(t);
var retT = typeof(DataModel <>).MakeGenericType(t);
ret = (T)Activator.CreateInstance(retT, new[] { subret });
ret.Load(rows[0]);
ret.DataProvider = this;
}
if (ret == null)
{
ret = (T)Activator.CreateInstance(typeof(T));
ret.Load(rows[0]);
ret.DataProvider = this;
}
return(ret);
}
private string QueryToExpression <TModel>(DataModelQuery <TModel> query) where TModel : DataModel
{
if (!string.IsNullOrEmpty(query.RawExpression))
{
return(query.RawExpression);
}
Type t = typeof(DataModel);
if (query.GetType().IsGenericType)
{
t = query.GetType().GetGenericArguments()[0];
}
var map = DataModelMap.GetEntityMapping(t);
var sb = new StringBuilder();
foreach (var condition in query.Conditions)
{
if (condition.EvalSubject != null &&
condition.FieldMap == null)
{
switch (condition.FindFieldMappingBy)
{
case FieldMappingKeyType.ClrMember:
condition.FieldMap = map.FieldMappings[condition.EvalSubject];
break;
case FieldMappingKeyType.DbColumn:
condition.FieldMap = map.GetFieldMappingByDbColumnName(condition.EvalSubject);
break;
}
}
if (condition.FieldMap != null)
{
if (sb.Length > 0)
{
sb.Append(" AND ");
}
sb.Append(condition.FieldMap.ColumnName);
sb.Append(CompareOpToExpression(condition.CompareOp));
sb.Append(ValueToExpression(condition.FieldMap, condition.CompareValue));
}
else
{
if (sb.Length > 0)
{
sb.Append(" AND ");
}
sb.Append(condition.EvalSubject);
sb.Append(CompareOpToExpression(condition.CompareOp));
if (condition.CompareOp != Compare.Null &&
condition.CompareOp != Compare.NotNull)
{
sb.Append(ValueToExpression(
DbTypeConverter.ToDbType(condition.CompareValue.GetType()),
condition.CompareValue));
}
}
}
return(sb.ToString());
}
public void DeepLoadEntityManyToManyTest()
{
var usersTable = CreateAndPopulateMockTable("User");
var groupsTable = CreateAndPopulateMockTable("Group");
var groupUserTable = CreateAndPopulateMockTable("GroupUser");
var memProvider = new MemoryDataProvider();
memProvider.AddTable(usersTable);
memProvider.AddTable(groupsTable);
memProvider.AddTable(groupUserTable);
var query = new DataModelQuery <DataModel <Group> >();
var egroups = memProvider.DeepLoadModels(query);
var groups = new DataModelCollection <DataModel <Group> >(egroups);
Assert.IsTrue(groups.Count == 2, "Groups did not load");
Assert.IsNotNull(groups[0].Entity, "Group 0 Entity was not set");
Assert.IsNotNull(groups[0].Entity.Users, "Group 0 Users were not set");
Assert.IsTrue(groups[0].Entity.Users.Count == 2, "Users count (group 0 of 0,1) is not 2");
Assert.IsNotNull(groups[1].Entity, "Group 1 Entity was not set");
Assert.IsNotNull(groups[0].Entity.Users, "Group 1 Users were not set");
Assert.IsTrue(groups[1].Entity.Users.Count == 2, "Users count (group 1 of 0,1) is not 2");
Assert.IsTrue(groups[0].Entity.Users[0].ID
!= groups[1].Entity.Users[0].ID, "Same user loaded between groups");
Assert.IsTrue(groups[0].Entity.Users[0].ID
!= groups[1].Entity.Users[1].ID, "Same user loaded between groups");
Assert.IsTrue(groups[1].Entity.Users[0].ID
!= groups[0].Entity.Users[0].ID, "Same user loaded between groups");
}
public void DeepLoadEntityOneToManyTest()
{
var companyTable = CreateAndPopulateMockTable("Company");
var contactTable = CreateAndPopulateMockTable("Contact");
var memProvider = new MemoryDataProvider();
memProvider.AddTable(companyTable);
memProvider.AddTable(contactTable);
var query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"].IsEqualTo(1);
var decompany = memProvider.DeepLoadModel(query) as DataModel <Company>;
Assert.IsNotNull(decompany);
Company company = decompany.Entity;
Assert.IsNotNull(company);
Assert.IsNotNull(company.Contacts, "Contacts not populated");
Assert.IsTrue(company.Contacts.Count == 2, company.Contacts.Count
+ " loaded (expected 2).");
Assert.IsTrue(company.Contacts[0].Name == "Betty Sue" ||
company.Contacts[0].Name == "John Doe");
Assert.IsTrue(company.Contacts[1].Name == "Betty Sue" ||
company.Contacts[1].Name == "John Doe");
}
/// <summary>
/// Returns a query that identifies the entity.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="entity"></param>
/// <returns></returns>
public static DataModelQuery <TModel> EntityToIdentifyingQuery <TModel>(TModel model) where TModel : DataModel
{
var query = new DataModelQuery <TModel>();
bool pkfound = false;
int pkc = 0;
if (model.EntityMappings.PrimaryKeyColumns.Length > 0)
{
foreach (var field_kvp in model.EntityMappings.FieldMappings)
{
DataModelColumnAttribute field = field_kvp.Value;
if (field.IsPrimaryKey)
{
string memName = field_kvp.Key;
pkfound = (model[memName] != null);
if (pkfound)
{
query.WhereProperty[memName].IsEqualTo(model[memName]);
pkc++;
}
}
}
}
if (!pkfound || model.EntityMappings.PrimaryKeyColumns.Length != pkc)
{
foreach (var field_kvp in model.EntityMappings.FieldMappings)
{
string memName = field_kvp.Key;
query.WhereProperty[memName].IsEqualTo(model[memName]);
}
}
return(query);
}
/// <summary>
/// When implemented, loads the full object graph for the
/// <see cref="DataModel"/> objects that are returned from the specified
/// <paramref name="query"/>, within the specified database
/// <paramref name="transactionContext"/>.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <param name="depth"></param>
/// <param name="transactionContext"></param>
/// <returns></returns>
public DataModelCollection <TModel> DeepLoadModels <TModel>(
DataModelQuery <TModel> query, int?depth, DbTransaction transactionContext)
where TModel : DataModel
{
var lst = new List <DataModel>();
return((DataModelCollection <TModel>)DeepLoadModels(query, depth, transactionContext, lst));
}
public void GetTypedQueryTest()
{
var myCustomEntityQuery = new DataModelQuery <DataModel <MockObject> >();
Assert.IsNotNull(myCustomEntityQuery);
Assert.AreEqual(myCustomEntityQuery.GetType(),
typeof(DataModelQuery <DataModel <MockObject> >));
}
public void SetQueryConditionTest2()
{
var myCustomEntityQuery = new DataModelQuery <DataModel <MockObject> >();
myCustomEntityQuery.WhereColumn["customentity_id"].IsGreaterThan(-1);
Assert.AreEqual(myCustomEntityQuery.Conditions[0].CompareOp, Compare.GreaterThan);
Assert.AreEqual(myCustomEntityQuery.Conditions[0].CompareValue, -1);
Assert.AreEqual(myCustomEntityQuery.Conditions[0].EvalSubject, "customentity_id");
}
public void SetQueryConditionTest3()
{
var myCustomEntityQuery = new DataModelQuery <DataModel <MockObject> >()
.WhereProperty["ID"] == (object)3;
Assert.AreEqual(myCustomEntityQuery.Conditions[0].CompareOp, Compare.Equal);
Assert.AreEqual(myCustomEntityQuery.Conditions[0].CompareValue, 3);
Assert.AreEqual(myCustomEntityQuery.Conditions[0].EvalSubject, "ID");
}
/// <summary>
/// Prepares this object for being serialized into command text
/// that the <see cref="Provider"/> can process.
/// </summary>
protected virtual void PrepareForCommandText()
{
bool pkAsQuery = false;
switch (StatementCommand)
{
case SqlStatement.SELECT:
if (Query.Pagination != null &&
(Query.Pagination.Page > 1 ||
Query.Pagination.ItemsPerPage < int.MaxValue))
{
PreparePagination(Query.Pagination);
}
else if (MaxRowCount < long.MaxValue)
{
if (MaxRowCount == 1)
{
PrepareSingleRowSelection();
}
else
{
PrepareLimitedRowCountSelection(MaxRowCount);
}
}
break;
case SqlStatement.INSERT:
foreach (var p in ModelMap.FieldMappings)
{
if (p.Value.ReturnAsOutputOnInsert)
{
PrepareInsertOutputParamCommand(p.Value.InsertParam);
break;
}
}
break;
case SqlStatement.UPDATE:
pkAsQuery = Query == null;
break;
case SqlStatement.DELETE:
pkAsQuery = Query == null;
break;
}
if (pkAsQuery)
{
Query = new DataModelQuery <TModel>();
foreach (string pk in ModelMap.PrimaryKeyColumns)
{
Query.WhereColumn[pk].IsEqualTo(DataModel.ColumnMappedValue[pk]);
}
}
}
public void DeepLoadEntityManyToOneTest1()
{
var sqlFactory = SqlClientFactory.Instance;
var dbProvider = new DbDataProvider(sqlFactory, TestSqlConnection);
var query = new DataModelQuery <Contact>()
.WhereProperty["ID"] == 1;
var contact = dbProvider.DeepLoadModel(query) as Contact;
Assert.IsNotNull(contact);
Assert.IsTrue(contact.Name == "Bobby Joe");
Assert.IsNotNull(contact.Company);
Assert.IsTrue(contact.Company.CompanyName == "Foobar, Ltd.");
}
public void DeepLoadEntityManyToOneTest3()
{
var companyTable = CreateAndPopulateMockTable("Company");
var contactTable = CreateAndPopulateMockTable("Contact");
var memProvider = new MemoryDataProvider();
memProvider.AddTable(companyTable);
memProvider.AddTable(contactTable);
var query = new DataModelQuery <Contact>()
.WhereProperty["ID"].IsEqualTo(3);
var contact = memProvider.DeepLoadModel(query) as Contact;
Assert.IsNotNull(contact);
Assert.IsTrue(contact.Name == "John Doe");
Assert.IsNotNull(contact.Company);
Assert.IsTrue(contact.Company.CompanyName == "Acme, Inc.");
}
/// <summary>
/// When implemented, loads the full object graph for the first
/// <see cref="DataModel"/> that is returned from the specified
/// <paramref name="query"/>, within the specified database
/// <paramref name="transactionContext"/>.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <param name="transactionContext"></param>
/// <param name="depth"></param>
/// <returns></returns>
public TModel DeepLoadModel <TModel>(
DataModelQuery <TModel> query, int?depth, DbTransaction transactionContext)
where TModel : DataModel
{
DataModel ret = DeepLoadModel(query, depth, transactionContext, null);
if (ret is TModel)
{
return((TModel)ret);
}
if (ret.Entity is TModel)
{
return((TModel)ret.Entity);
}
Type t = typeof(DataModel <>).MakeGenericType(ret.GetType());
ret = (DataModel)Activator.CreateInstance(t, ret);
return((TModel)ret);
}
/// <summary>
/// Returns a collection of loaded instances of the specified type using the specified
/// <paramref name="query"/> and <paramref name="transactionContext"/>.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="query"></param>
/// <param name="transactionContext"></param>
/// <returns></returns>
public override DataModelCollection <T> LoadModels <T>(DataModelQuery <T> query, DbTransaction transactionContext)
{
if (transactionContext != null)
{
throw new NotImplementedException("MemoryDataProvider does not support DbTransactions");
}
var map = DataModel.GetMapping <T>();
var table = Tables[map.TableMapping.Table];
var rows = table.Select(QueryToExpression(query), QueryToSortExpression(query));
var retcol = new DataModelCollection <T>();
if (rows.Length == 0)
{
return(retcol);
}
var t = DataModel.GetUnwrappedType(typeof(T));
foreach (DataRow row in rows)
{
T ret;
while (t.IsGenericType && t.IsOrInherits(typeof(IEnumerable)))
{
t = t.GetGenericArguments().Last();
}
if (t != typeof(T))
{
var subret = Activator.CreateInstance(t);
var retT = typeof(DataModel <>).MakeGenericType(t);
ret = (T)Activator.CreateInstance(retT, new[] { subret });
ret.Load(row);
ret.DataProvider = this;
}
else
{
ret = (T)Activator.CreateInstance(typeof(T));
ret.Load(row);
ret.DataProvider = this;
}
retcol.Add(ret);
}
retcol.DataProvider = this;
return(retcol);
}
public void DeepLoadEntityManyToOneTest4()
{
var companyTable = CreateAndPopulateMockTable("Company");
var contactTable = CreateAndPopulateMockTable("Contact");
var memProvider = new MemoryDataProvider();
memProvider.AddTable(companyTable);
memProvider.AddTable(contactTable);
var query = new DataModelQuery <Contact>()
.WhereProperty["ID"].IsEqualTo(4);
var contact = memProvider.DeepLoadModel(query) as Contact;
Assert.IsNotNull(contact);
Assert.IsTrue(contact.Name == "Jane Lane");
Assert.IsNotNull(contact.Company);
Assert.IsTrue(contact.Company.CompanyName == "Foobar, Ltd.");
Assert.IsTrue(contact.Company.Contacts != null);
Assert.IsTrue(contact.Company.Contacts.Count > 0);
}
public void DeepLoadEntityOneToManyTest2()
{
var sqlFactory = SqlClientFactory.Instance;
var dbProvider = new DbDataProvider(sqlFactory, TestSqlConnection);
var query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"] == 2;
var decompany = dbProvider.DeepLoadModel(query) as DataModel <Company>;
Assert.IsNotNull(decompany);
Company company = decompany.Entity;
Assert.IsNotNull(company);
Assert.IsNotNull(company.Contacts, "Contacts not populated");
Assert.IsTrue(company.Contacts.Count == 2, company.Contacts.Count.ToString() + " loaded (expected 2).");
Assert.IsTrue(company.Contacts[0].Name == "Bobby Joe" ||
company.Contacts[0].Name == "Jane Lane");
Assert.IsTrue(company.Contacts[1].Name == "Bobby Joe" ||
company.Contacts[1].Name == "Jane Lane");
}
public void DeepLoadEntityTest()
{
DataProviderBase mockRepos = new MemoryDataProvider();
var table = ((MemoryDataProvider)mockRepos).AddTable("mock_table");
PopulateMockTable(table);
var table2 = ((MemoryDataProvider)mockRepos).AddTable("mock_table2");
PopulateMockTable(table2);
var query = new DataModelQuery <DataModel <DataModelRelationshipMetadataTest.MockPocoChild> >()
.WhereProperty["ID"].IsEqualTo(2);
var e = mockRepos.DeepLoadModel(query)
as DataModel <DataModelRelationshipMetadataTest.MockPocoChild>;
Assert.IsNotNull(e, "Nothing was returned from DeepLoad query.");
Assert.IsNotNull(e.Entity.MockPoco, "Child object not assigned in DeepLoad");
Assert.IsTrue(e.Entity.MockPoco.MockDecimalValue == e.Entity.MockDecimalValue,
"Child object field value mismatch");
}
public void DeepSaveEntityTest()
{
// todo: test all four relationship types
try
{
var sqlFactory = SqlClientFactory.Instance;
var dbProvider = new DbDataProvider(sqlFactory, TestSqlConnection);
var query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"] == 1;
var decompany = dbProvider.DeepLoadModel(query);
var company = decompany.Entity;
company.CompanyName += "_";
foreach (var c in company.Contacts)
{
c.Name += "_";
}
decompany.Save(true);
query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"] == 1;
decompany = dbProvider.DeepLoadModel(query);
company = decompany.Entity;
Assert.IsTrue(company.CompanyName.Length > 1 &&
company.CompanyName.EndsWith("_"));
Assert.IsTrue(company.Contacts[0]
.Name.Length > 1 &&
company.Contacts[0]
.Name.EndsWith("_"));
Assert.IsTrue(company.Contacts[company.Contacts.Count - 1]
.Name.Length > 1 &&
company.Contacts[company.Contacts.Count - 1]
.Name.EndsWith("_"));
}
finally
{
// clean-up
ReloadData_CompanyContact();
}
}
/// <summary>
/// Loads the first <see cref="DataModel"/> that
/// the specified <paramref name="query"/> finds,
/// within the specified database <paramref name="transactionContext"/>.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <param name="transactionContext"></param>
/// <returns></returns>
public override TModel LoadModel <TModel>(DataModelQuery <TModel> query, DbTransaction transactionContext)
{
DbConnection tmpConn = null;
if (transactionContext == null)
{
tmpConn = CreateAndOpenConnection();
transactionContext = tmpConn.BeginTransaction(ProviderDefaults.IsolationLevel);
}
try
{
DbConnection conn = transactionContext.Connection;
DbDataProviderCommandBuilder <TModel> cmdBuilder = CreateCommandBuilder(query);
using (DbCommand cmd = cmdBuilder.CreateDbCommand(transactionContext)) // conn.CreateCommand())
{
cmd.Transaction = transactionContext;
using (DbDataReader dr = cmd.ExecuteReader(cmdBuilder.ExecuteBehavior ?? CommandBehavior.SingleRow))
{
if (dr.Read())
{
var ret = (TModel)Activator.CreateInstance(typeof(TModel));
ret.DataProvider = this;
ret.Load(dr);
return(ret);
}
return(null);
}
}
}
finally
{
if (tmpConn != null)
{
transactionContext.Commit();
tmpConn.Close();
}
}
}
public void DeepSaveEntityTest()
{
// todo: test all four relationship types
var companyTable = CreateAndPopulateMockTable("Company");
var contactTable = CreateAndPopulateMockTable("Contact");
var memProvider = new MemoryDataProvider();
memProvider.AddTable(companyTable);
memProvider.AddTable(contactTable);
var query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"].IsEqualTo(1);
var decompany = memProvider.DeepLoadModel(query);
var company = decompany.Entity;
company.CompanyName += "_";
foreach (var c in company.Contacts)
{
c.Name += "_";
}
decompany.Save(true);
query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"].IsEqualTo(1);
decompany = memProvider.DeepLoadModel(query);
company = decompany.Entity;
Assert.IsTrue(company.CompanyName.Length > 1 &&
company.CompanyName.EndsWith("_"));
Assert.IsTrue(company.Contacts[0]
.Name.Length > 1 &&
company.Contacts[0]
.Name.EndsWith("_"));
Assert.IsTrue(company.Contacts[company.Contacts.Count - 1]
.Name.Length > 1 &&
company.Contacts[company.Contacts.Count - 1]
.Name.EndsWith("_"));
}
public void DeepLoadEntityManyToManyTest()
{
var sqlFactory = SqlClientFactory.Instance;
var dbProvider = new DbDataProvider(sqlFactory, TestSqlConnection);
var query = new DataModelQuery <DataModel <Group> >();
var groups = dbProvider.DeepLoadModels(query);
Assert.IsTrue(groups.Count == 2, "Groups did not load");
Assert.IsNotNull(groups[0].Entity, "Group 0 Entity was not set");
Assert.IsNotNull(groups[0].Entity.Users, "Group 0 Users were not set");
Assert.IsTrue(groups[0].Entity.Users.Count == 2, "Users count (group 0 of 0,1) is not 2");
Assert.IsNotNull(groups[1].Entity, "Group 1 Entity was not set");
Assert.IsNotNull(groups[0].Entity.Users, "Group 1 Users were not set");
Assert.IsTrue(groups[1].Entity.Users.Count == 2, "Users count (group 1 of 0,1) is not 2");
Assert.IsTrue(groups[0].Entity.Users[0].ID
!= groups[1].Entity.Users[0].ID, "Same user loaded between groups");
Assert.IsTrue(groups[0].Entity.Users[0].ID
!= groups[1].Entity.Users[1].ID, "Same user loaded between groups");
Assert.IsTrue(groups[1].Entity.Users[0].ID
!= groups[0].Entity.Users[0].ID, "Same user loaded between groups");
}
/// <summary>
/// Returns the count of records that match the specified query criteria.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <param name="transactionContext"></param>
/// <returns></returns>
public override long GetCount <TModel>(DataModelQuery <TModel> query, DbTransaction transactionContext)
{
return((long)Tables[DataModelMap.GetEntityMapping(typeof(TModel)).TableMapping.ToString()].Rows.Count);
}
public void DeepSaveEntitiesTest()
{
try
{
var sqlFactory = SqlClientFactory.Instance;
var dbProvider = new DbDataProvider(sqlFactory, TestSqlConnection);
var query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"] == 1;
var decompany = dbProvider.DeepLoadModel(query);
var company = decompany.Entity;
company.CompanyName += "_";
foreach (var c in company.Contacts)
{
c.Name += "_";
}
var query2 = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"] == 2;
var decompany2 = dbProvider.DeepLoadModel(query2);
var company2 = decompany2.Entity;
company2.CompanyName = "_" + company2.CompanyName;
foreach (var c in company2.Contacts)
{
c.Name = "_" + c.Name;
}
var col = new DataModelCollection <DataModel <Company> >();
col.Add(decompany);
col.Add(decompany2);
col.DataProvider = dbProvider;
col.Save(true);
query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"] == 1;
decompany = dbProvider.DeepLoadModel(query);
company = decompany.Entity;
Assert.IsTrue(company.CompanyName.Length > 1 &&
company.CompanyName.EndsWith("_"));
Assert.IsTrue(company.Contacts[0]
.Name.Length > 1 &&
company.Contacts[0]
.Name.EndsWith("_"));
Assert.IsTrue(company.Contacts[company.Contacts.Count - 1]
.Name.Length > 1 &&
company.Contacts[company.Contacts.Count - 1]
.Name.EndsWith("_"));
query = new DataModelQuery <DataModel <Company> >()
.WhereProperty["ID"] == 2;
decompany = dbProvider.DeepLoadModel(query);
company = decompany.Entity;
Assert.IsTrue(company.CompanyName.Length > 1 &&
company.CompanyName.StartsWith("_"));
Assert.IsTrue(company.Contacts[0]
.Name.Length > 1 &&
company.Contacts[0]
.Name.StartsWith("_"));
Assert.IsTrue(company.Contacts[company.Contacts.Count - 1]
.Name.Length > 1 &&
company.Contacts[company.Contacts.Count - 1]
.Name.StartsWith("_"));
}
finally
{
ReloadData_CompanyContact(); // clean-up
}
}
/// <summary>
/// Overridable. Generates an instance of a <see cref="DbDataProviderCommandBuilder{TModel}"/>
/// which builds <see cref="DbCommand"/>s for execution by a vendor-specific
/// <see cref="DbDataProvider"/> instance.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <returns></returns>
protected virtual DbDataProviderCommandBuilder <TModel> CreateCommandBuilder <TModel>(DataModelQuery <TModel> query)
where TModel : DataModel
{
var ret = new DbDataProviderCommandBuilder <TModel>(this, query);
return(ret);
}
/// <summary>
/// Loads a set of <see cref="DataModel"/> objects
/// using the specified <paramref name="query"/> within the
/// specified database <paramref name="transactionContext"/>.
/// </summary>
/// <typeparam name="TModel"></typeparam>
/// <param name="query"></param>
/// <param name="transactionContext"></param>
/// <returns></returns>
public override DataModelCollection <TModel> LoadModels <TModel>(
DataModelQuery <TModel> query, DbTransaction transactionContext)
{
DataModelMap demap = DataModel.GetMapping <TModel>();
DbConnection tmpConn = null;
if (transactionContext == null)
{
tmpConn = CreateAndOpenConnection();
transactionContext = tmpConn.BeginTransaction(ProviderDefaults.IsolationLevel);
}
DbConnection conn = transactionContext.Connection;
try
{
DbDataProviderCommandBuilder <TModel> cmdBuilder = CreateCommandBuilder(query);
using (DbCommand cmd = cmdBuilder.CreateDbCommand(transactionContext))
{
cmd.Transaction = transactionContext;
using (DbDataReader dr = cmd.ExecuteReader(cmdBuilder.ExecuteBehavior ?? CommandBehavior.Default))
{
var ret = new DataModelCollection <TModel> {
DataProvider = this
};
if (query.Pagination == null ||
query.Pagination.ItemsPerPage == int.MaxValue ||
query.Pagination.ItemsPerPage == 0 ||
cmdBuilder.PaginationIsHandled)
{
while (dr.Read())
{
var obj = (TModel)Activator.CreateInstance(typeof(TModel));
obj.DataProvider = this;
obj.Load(dr);
ret.Add(obj);
}
}
else
{
int start = query.Pagination.Page * query.Pagination.ItemsPerPage -
query.Pagination.ItemsPerPage;
bool eof = false;
for (int i = 0; i < start; i++)
{
if (!dr.Read())
{
eof = true;
break;
}
}
for (int i = 0; i < query.Pagination.ItemsPerPage && !eof; i++)
{
if (!dr.Read())
{
eof = true;
break;
}
var obj = (TModel)Activator.CreateInstance(typeof(TModel));
obj.DataProvider = this;
obj.Load(dr);
ret.Add(obj);
}
}
if (!string.IsNullOrEmpty(demap.TableMapping.SelectManyProcedure) &&
query.OrderBy.Count > 0)
{
// exec sort from last sort field to first to get correct end result
for (int i = query.OrderBy.Count - 1; i >= 0; i--)
{
string fld = query.OrderBy[i].GetFieldMapping(typeof(TModel)).TargetMember.Name;
switch (query.OrderBy[i].SortDirection)
{
case Sort.Ascending:
TModel[] asc = (from item in ret
orderby item[fld] ascending
select item).ToArray();
ret = new DataModelCollection <TModel>(asc);
break;
case Sort.Descending:
TModel[] desc = (from item in ret
orderby item[fld] descending
select item).ToArray();
ret = new DataModelCollection <TModel>(desc);
break;
}
}
}
return(ret);
}
}
}
finally
{
if (tmpConn != null)
{
transactionContext.Commit();
tmpConn.Close();
}
}
}
