public void SelectManyWithProcTest2()
{
var dbProvider = ProviderDefaults.AppProvider;
var oldMapping = DataModelMap.GetEntityMapping(typeof(MockPoco));
DataModelMap.MapItems.Remove(typeof(MockPoco));
var newMapping = DataModelMap.GetEntityMapping(typeof(MockPoco));
newMapping.TableMapping.SelectManyProcedure = "sp_mock_table_SelectMany";
try
{
var q = DataModel <MockPoco> .NewQuery().WhereProperty["ID"] == 3;
var entities = dbProvider.LoadModels(q);
Assert.IsNotNull(entities);
Assert.IsTrue(entities.Count == 1);
Assert.IsTrue(entities[0].Entity.ID == 3);
}
finally
{
DataModelMap.MapItems.Remove(typeof(MockPoco));
DataModelMap.MapItems.Add(typeof(MockPoco), oldMapping);
}
}
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 DataModelFieldMappingAttribute_AutoRelationshipMapping_NoInferenceOnChild()
{
var map = DataModelMap.GetEntityMapping(typeof(MockClassForAutoRelationshipMapping));
var fields = map.FieldMappings;
Assert.IsTrue(fields.Count == 1);
Assert.IsTrue(fields.ToList()[0].Key == "ID");
}
public void DataModelFieldMappingAttribute_AutoRelationshipMapping_ChildrenPropRef()
{
var map = DataModelMap.GetEntityMapping(typeof(MockClassForAutoRelationshipMapping3));
Assert.IsTrue(map.ForeignModelMappings.Count == 1);
Assert.IsTrue(map.ForeignModelMappings.ToList()[0].Key == "ChildProp");
Assert.IsTrue(map.ForeignModelMappings["ChildProp"].TargetMember != null);
Assert.IsTrue(map.ForeignModelMappings["ChildProp"].TargetMember.Name == "ChildProp");
Assert.IsTrue(map.ForeignModelMappings["ChildProp"].Relationship == Relationship.OneToMany);
Assert.IsTrue(map.ForeignModelMappings["ChildProp"].LocalColumn == "FKChildID");
Assert.IsTrue(map.ForeignModelMappings["ChildProp"].RelatedTableColumn == "ID");
}
public void BasicDataModelMappingsCollectionSerializationTest()
{
var mi = DataModelMap.GetEntityMapping(typeof(DataModelFieldMappingAttributeTest.MockDataModel));
var mis = DataModelMap.MapItems;
var xs = new XmlSerialized <DataModelMappingsDefinition>(mis);
Assert.IsNotNull(xs);
Assert.IsTrue(xs.SerializedValue.Length > 0);
mis = xs.Deserialize();
mi = mis[typeof(DataModelFieldMappingAttributeTest.MockDataModel)];
Assert.IsNotNull(mi);
Assert.IsTrue(mi.FieldMappings.Count > 0);
}
public void GetRelationshipInfoTest3()
{
var target = DataModelMap.GetEntityMapping(typeof(Contact));
var targetFEs = target.ForeignModelMappings;
Assert.IsNotNull(targetFEs);
var contactsMeta = targetFEs["Company"];
Assert.IsNotNull(contactsMeta);
Assert.IsTrue(contactsMeta.Relationship == Relationship.ManyToOne);
Assert.IsTrue(contactsMeta.RelatedTable == "Company");
Assert.IsTrue(contactsMeta.LocalColumn == "company_id");
}
/// <summary>
/// Saves the changes that were made to the
/// specified <paramref name="dataModel"/>, within the specified
/// database <paramref name="transactionContext"/>.
/// <remarks>
/// The specified object must have the Deleted property set to true,
/// IsDirty evaluated as true, or IsNew evaluated as true, or else
/// the entity will not be saved.
/// </remarks>
/// </summary>
/// <param name="dataModel"></param>
/// <param name="transactionContext"></param>
public override void SaveModel <TModel>(TModel dataModel, DbTransaction transactionContext)
{
if (!dataModel.IsNew &&
!dataModel.IsDirty &&
!dataModel.MarkDeleted)
{
return;
}
DataModelMap demap = DataModelMap.GetEntityMapping(dataModel.GetType());
DbConnection tmpConn = null;
if (transactionContext == null)
{
tmpConn = CreateAndOpenConnection();
transactionContext = tmpConn.BeginTransaction();
}
try
{
DbDataProviderCommandBuilder <TModel> cmdBuilder = CreateCommandBuilder(dataModel);
using (DbCommand cmd = cmdBuilder.CreateDbCommand(transactionContext))
{
cmd.Transaction = transactionContext;
bool wasNew = dataModel.IsNew;
cmd.ExecuteNonQuery();
if (wasNew)
{
foreach (var field in demap.FieldMappings)
{
DataModelColumnAttribute f = field.Value;
if (f.ReturnAsOutputOnInsert)
{
dataModel[f.TargetMember.Name] = cmd.Parameters[f.InsertParam].Value;
}
}
}
}
}
finally
{
if (tmpConn != null)
{
transactionContext.Commit();
tmpConn.Close();
}
}
}
public void DataModelFieldMappingAttribute_DefaultValueInferences()
{
var map = DataModelMap.GetEntityMapping(typeof(MockClassForNullNotNullChecking));
var fields = map.FieldMappings;
Assert.AreEqual(fields["ID"].DefaultValue, default(int)); // because it's an inferred primary key
Assert.AreEqual(fields["NotNullInt"].DefaultValue, default(int));
Assert.AreEqual(fields["NullInt"].DefaultValue, default(int?));
Assert.AreEqual((string)fields["NullString"].DefaultValue, default(string));
Assert.AreEqual(fields["NotNullDecimal"].DefaultValue, default(decimal));
Assert.AreEqual(fields["NullDecimal"].DefaultValue, default(decimal?));
Assert.AreEqual(fields["NotNullDateTime"].DefaultValue, default(DateTime));
Assert.AreEqual(fields["NullDateTime"].DefaultValue, default(DateTime?));
}
public void DataModelFieldMappingAttribute_NullNotNullTest()
{
var map = DataModelMap.GetEntityMapping(typeof(MockClassForNullNotNullChecking));
var fields = map.FieldMappings;
Assert.IsFalse(fields["ID"].IsNullable); // because it's an inferred primary key
Assert.IsFalse(fields["NotNullInt"].IsNullable);
Assert.IsTrue(fields["NullInt"].IsNullable);
Assert.IsTrue(fields["NullString"].IsNullable);
Assert.IsFalse(fields["NotNullDecimal"].IsNullable);
Assert.IsTrue(fields["NullDecimal"].IsNullable);
Assert.IsFalse(fields["NotNullDateTime"].IsNullable);
Assert.IsTrue(fields["NullDateTime"].IsNullable);
}
public void RunDataModelOverrideWrapperTest()
{
var myMock = new MyMock();
var myMockDataModel = new DataModel <MyMock>(myMock);
var myMockOverride = new MyMockOverride();
var myMockOverrideDataModel = new DataModel <MyMockOverride>(myMockOverride);
var origMapping = DataModelMap.GetEntityMapping(myMockDataModel.GetType());
var overriddenMapping = DataModelMap.GetEntityMapping(myMockOverrideDataModel.GetType());
Assert.IsTrue(overriddenMapping.FieldMappings["IntValue"].ColumnName == "intvalue2");
Assert.IsTrue(origMapping.FieldMappings["IntValue"].ColumnName == "IntValue");
Assert.IsTrue(overriddenMapping.FieldMappings["IntValue"].ColumnName == "intvalue2");
Assert.IsTrue(origMapping.TableMapping.Table == "MyMock");
Assert.IsTrue(overriddenMapping.TableMapping.Table == "overridden_table");
}
public void CreateWithoutProcAndDeleteWithProcEntityTest()
{
var dbProvider = ProviderDefaults.AppProvider;
var oldMapping = DataModelMap.GetEntityMapping(typeof(MockPoco));
DataModelMap.MapItems.Remove(typeof(MockPoco));
var newMapping = DataModelMap.GetEntityMapping(typeof(MockPoco));
newMapping.TableMapping.DeleteProcedure = "sp_mock_table_Delete";
try
{
var mp = new MockPoco {
MockStringValue = "xxx"
};
var dew = new DataModel <MockPoco>(mp);
dew.DataProvider = dbProvider;
dew.Save();
var myMockEntityQuery = DataModel <MockPoco>
.NewQuery()
.WhereColumn["string_value"] == "xxx";
var entity = dbProvider.LoadModel(myMockEntityQuery);
Assert.IsNotNull(entity);
Assert.IsNotNull(entity.Entity.ID);
Assert.IsTrue(entity.Entity.ID > 0);
Assert.IsTrue(entity.Entity.MockStringValue == "xxx");
entity.MarkDeleted = true;
entity.Save();
entity = dbProvider.LoadModel(myMockEntityQuery);
Assert.IsNull(entity);
}
finally
{
DataModelMap.MapItems.Remove(typeof(MockPoco));
DataModelMap.MapItems.Add(typeof(MockPoco), oldMapping);
}
}
public void SaveModifiedEntityWithProcTest()
{
var dbProvider = ProviderDefaults.AppProvider;
var oldMapping = DataModelMap.GetEntityMapping(typeof(MockPoco));
DataModelMap.MapItems.Remove(typeof(MockPoco));
var newMapping = DataModelMap.GetEntityMapping(typeof(MockPoco));
newMapping.TableMapping.UpdateProcedure = "sp_mock_table_Update";
try
{
var myMockEntityQuery = DataModel <MockPoco> .NewQuery()
.WhereColumn["string_value"] == "abc";
var entity = dbProvider.LoadModel(myMockEntityQuery);
entity.Entity.MockStringValue = "xyz";
entity.Save();
myMockEntityQuery = DataModel <MockPoco> .NewQuery()
.WhereColumn["string_value"] == "xyz";
entity = dbProvider.LoadModel(myMockEntityQuery);
Assert.IsNotNull(entity);
Assert.AreEqual("xyz", entity.Entity.MockStringValue);
Assert.IsTrue(entity.DataProvider == dbProvider);
entity.Entity.MockStringValue = "abc";
entity.Save();
}
finally
{
DataModelMap.MapItems.Remove(typeof(MockPoco));
DataModelMap.MapItems.Add(typeof(MockPoco), oldMapping);
}
}
public void GetRelationshipInfoTest()
{
//var pretarget = DataModelMap.GetEntityMapping(typeof (MockPoco));
var target = DataModelMap.GetEntityMapping(typeof(MockPocoChild));
var fkfs = new List <DataModelColumnAttribute>();
foreach (var field_kvp in target.FieldMappings)
{
var field = field_kvp.Value;
if (field.IsForeignKey)
{
fkfs.Add(field);
}
}
Assert.IsTrue(fkfs.Count == 1, "No foreign key mapping found (or wrong count)");
var mapping = fkfs[0].ForeignKeyMapping;
Assert.AreEqual(mapping.ForeignEntity, typeof(MockPoco), "RelatesTo");
Assert.AreEqual(mapping.ForeignEntityProperty, "ID", "OnMatchProperty");
Assert.AreEqual(mapping.Relationship, Relationship.OneToOne, "Relationship");
// resolve OnMatchDataField
Assert.AreEqual(mapping.ForeignColumn, "customentity_id", "OnMatchDataField");
}
/// <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);
}
/// <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();
}
}
}
/// <summary>
/// Generates the appropriate WHERE clause text, if any, for the command.
/// </summary>
/// <returns></returns>
protected virtual string GenerateWhereClause()
{
if (Query == null)
{
return(string.Empty);
}
if (!string.IsNullOrEmpty(Query.RawExpression))
{
return(Query.RawExpression);
}
Type t = typeof(DataModel);
if (Query.GetType().IsGenericType)
{
t = Query.GetType().GetGenericArguments()[0];
}
DataModelMap map = DataModelMap.GetEntityMapping(t);
var sb = new StringBuilder();
foreach (DataModelQueryCondition <TModel> 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 (sb.Length > 0)
{
sb.AppendLine(" AND\t");
}
sb.Append(CommandBuilder.QuotePrefix);
if (condition.FieldMap != null)
{
sb.Append(condition.FieldMap.ColumnName);
}
else
{
sb.Append(condition.EvalSubject);
}
sb.Append(CommandBuilder.QuoteSuffix);
sb.Append(CompareOpToExpression(condition.CompareOp));
if (condition.CompareOp != Compare.Null &&
condition.CompareOp != Compare.NotNull)
{
if (condition.FieldMap != null)
{
sb.Append("@");
sb.Append(condition.FieldMap.ColumnName);
}
else
{
sb.Append("@");
sb.Append(condition.EvalSubject);
}
}
}
return(sb.Length == 0 ? string.Empty : " WHERE\t" + sb.ToString());
}
