private static Relation _ReadRelation(NetBuffer buffer)
{
RelationFlags flags = (RelationFlags)buffer.ReadByte();
int value = (flags != RelationFlags.Any) ? buffer.ReadInt32() : 0;
return(new Relation(flags, value));
}
public void OffsetWithLimit(RelationFlags flags)
{
var relation = this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
for (var a = 0; a < data.Count; a++)
{
set.Fetch.Source.GetTable(set.Table).Filter.With(filter =>
{
filter.Limit = 1;
filter.Offset = a;
});
this.AssertSequence(new[] { data[a] }, set);
}
}
public static RelationFlags EnsureMultiplicity(this RelationFlags flags, RelationFlags multiplicity)
{
if (flags.GetMultiplicity() != RelationFlags.None)
{
return(flags);
}
return(flags | multiplicity);
}
public static bool CanBeTargetedAt(Unit unit, Unit target, RelationFlags targetRelation)
{
int force = unit.GetIntProperty(PropertyType.BattleForce);
int allyMask = unit.GetIntProperty(PropertyType.BattleForceAllyMask);
int targetForce = target.GetIntProperty(PropertyType.BattleForce);
return((ForceRelation(force, targetForce, allyMask) & targetRelation) != 0);
}
public void NToManyTransientEnumerator(RelationFlags flags)
{
this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var data = new List <Transient>();
data.AddRange(new[]
{
new Transient()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Transient()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Transient()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
{
var set = this.Database.Set <Test002>(this.Transaction);
set.AddOrUpdate(data);
}
{
var set = this.Database.Set <Transient>(this.Database.Source(this.Database.Config.Table <Test002>().CreateProxy <Transient>(), this.Transaction));
this.AssertSequence(data, set);
Assert.AreEqual(new Transient(), set.Create());
}
}
protected RelationConfig(IConfig config, RelationFlags flags, string identifier, ITableConfig leftTable, IMappingTableConfig mappingTable, ITableConfig rightTable)
: this(config)
{
this.Flags = flags;
this.Identifier = identifier;
this.LeftTable = leftTable;
this.MappingTable = mappingTable;
this.RightTable = rightTable;
}
public void FindNToManyRelation(RelationFlags flags)
{
this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
this.AssertSequence(data, set);
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
var retrieved = set.Find(data[1].Id);
Assert.AreEqual(data[1], retrieved);
}
public void Where_OrderByDescending_FirstOrDefault(RelationFlags flags)
{
this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
var id = data[0].Id;
var query = this.Database.AsQueryable <Test002>(this.Transaction);
this.AssertSequence(new[] { data[2] }, new[] { query.Where(element => element.Id > id).OrderByDescending(element => element.Id).FirstOrDefault() });
}
public void IndexerBinding(RelationFlags flags)
{
this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
var query = this.Database.AsQueryable <Test002>(this.Transaction);
this.AssertSequence(new[] { data[2] }, query.Where(element => element.Id == data[2].Id));
this.AssertSequence(new[] { data[2] }, query.Where(element => element.Id == data[2].Id && element.Test004.Any(child => child.Id == data[2].Test004.First().Id)));
}
public void NToManyRelationWithInt32Key(RelationFlags flags)
{
this.Database.Config.Table <Grapefruit>().Relation(item => item.Pineapples, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Grapefruit>(this.Transaction);
var data = new List <Grapefruit>();
set.Clear();
this.AssertSequence(data, set);
data.AddRange(new[]
{
new Grapefruit()
{
Name = "1_1", Pineapples = new List <Pineapple>()
{
new Pineapple()
{
Name = "1_2"
}, new Pineapple()
{
Name = "1_3"
}
}
},
new Grapefruit()
{
Name = "2_1", Pineapples = new List <Pineapple>()
{
new Pineapple()
{
Name = "2_2"
}, new Pineapple()
{
Name = "2_3"
}
}
},
new Grapefruit()
{
Name = "3_1", Pineapples = new List <Pineapple>()
{
new Pineapple()
{
Name = "3_2"
}, new Pineapple()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
this.AssertSequence(data, set);
}
public static RelationFlags GetMultiplicity(this RelationFlags flags)
{
if (flags.HasFlag(RelationFlags.OneToOne))
{
return(RelationFlags.OneToOne);
}
else if (flags.HasFlag(RelationFlags.OneToMany))
{
return(RelationFlags.OneToMany);
}
else if (flags.HasFlag(RelationFlags.ManyToMany))
{
return(RelationFlags.ManyToMany);
}
return(RelationFlags.None);
}
public async Task CanAddUpdateDeleteAsync(RelationFlags flags)
{
const int COUNT = 1024;
var stopwatch = new Stopwatch();
var relation = this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
await set.ClearAsync().ConfigureAwait(false);
stopwatch.Start();
for (var a = 0; a < COUNT; a++)
{
await set.AddOrUpdateAsync(new Test002()
{
Name = "Name_" + a,
Test003 = new Test003()
{
Name = "Name_" + a
},
Test004 = new List <Test004>()
{
new Test004()
{
Name = "Name_" + a
},
new Test004()
{
Name = "Name_" + a
},
new Test004()
{
Name = "Name_" + a
}
}
}).ConfigureAwait(false);
}
stopwatch.Stop();
TestContext.Out.WriteLine("Added {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
stopwatch.Start();
Assert.AreEqual(COUNT, await set.CountAsync);
stopwatch.Stop();
TestContext.Out.WriteLine("Counted {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
stopwatch.Start();
using (var sequence = set.GetAsyncEnumerator())
{
while (await sequence.MoveNextAsync().ConfigureAwait(false))
{
sequence.Current.Name = "updated";
sequence.Current.Test003.Name = "updated";
sequence.Current.Test004.First().Name = "updated";
await set.AddOrUpdateAsync(sequence.Current).ConfigureAwait(false);
}
}
stopwatch.Stop();
TestContext.Out.WriteLine("Updated {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
stopwatch.Start();
using (var sequence = set.GetAsyncEnumerator())
{
while (await sequence.MoveNextAsync().ConfigureAwait(false))
{
Assert.AreEqual("updated", sequence.Current.Name);
Assert.AreEqual("updated", sequence.Current.Test003.Name);
Assert.AreEqual("updated", sequence.Current.Test004.First().Name);
}
}
stopwatch.Stop();
TestContext.Out.WriteLine("Enumerated {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
stopwatch.Start();
await set.ClearAsync().ConfigureAwait(false);
stopwatch.Stop();
TestContext.Out.WriteLine("Removed {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
Assert.AreEqual(0, await set.CountAsync);
}
public ForeignKeyAttribute(RelationFlags flags)
: this()
{
this.Flags |= flags;
}
public OneToManyRelationConfig(IConfig config, RelationFlags flags, string identifier, ITableConfig leftTable, ITableConfig rightTable, IPropertyAccessor <T, ICollection <TRelation> > accessor)
: base(config, flags, identifier, leftTable, null, rightTable, accessor)
{
}
public Relation(RelationFlags flags, int value)
{
this.flags = flags;
this.value = value;
}
public void ContainsCompoundRelation(RelationFlags flags, bool invert)
{
this.Database.Config.Table <Test002>().With(table =>
{
table.Relation(item => item.Test004, Defaults.Relation.Flags | flags).With(relation =>
{
relation.Expression.Left = relation.Expression.Clone();
relation.Expression.Operator = relation.Expression.CreateOperator(QueryOperator.OrElse);
relation.Expression.Right = relation.CreateConstraint(relation.LeftTable.Column("Test004_Id"), relation.RightTable.PrimaryKey);
});
});
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
{
var child = this.Database.Set <Test004>(this.Transaction).AddOrUpdate(new Test004()
{
Name = "2_2"
});
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1"
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
data[1].Test004_Id = child.Id;
new EntityPersister(this.Database, set.Table, this.Transaction).Update(set.Find(data[1].Id), data[1]);
data[1].Test004.Add(child);
}
{
var child = data[1].Test004.First();
var query = this.Database.AsQueryable <Test002>(this.Transaction);
if (invert)
{
this.AssertSequence(new[] { data[0], data[2] }, query.Where(element => !element.Test004.Contains(child)));
}
else
{
this.AssertSequence(new[] { data[1] }, query.Where(element => element.Test004.Contains(child)));
}
}
}
public void NToManyRelation(RelationFlags flags)
{
this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
this.AssertSequence(data, set);
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
this.AssertSequence(data, set);
data[1].Test004.First().Name = "updated";
set.AddOrUpdate(data);
this.AssertSequence(data, set);
data[1].Test004.RemoveRange(data[1].Test004);
set.AddOrUpdate(data);
this.AssertSequence(data, set);
set.Remove(data[1]);
data.RemoveAt(1);
this.AssertSequence(data, set);
}
public void CanAddUpdateDelete_GuidKey(RelationFlags flags)
{
this.Database.Config.Table <Test007>().Relation(item => item.Test009, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test007>(this.Transaction);
var data = new List <Test007>();
set.Clear();
this.AssertSequence(data, set);
data.AddRange(new[]
{
new Test007()
{
Name = "1_1", Test009 = new List <Test009>()
{
new Test009()
{
Name = "1_2"
}, new Test009()
{
Name = "1_3"
}
}
},
new Test007()
{
Name = "2_1", Test009 = new List <Test009>()
{
new Test009()
{
Name = "2_2"
}, new Test009()
{
Name = "2_3"
}
}
},
new Test007()
{
Name = "3_1", Test009 = new List <Test009>()
{
new Test009()
{
Name = "3_2"
}, new Test009()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
this.AssertSequence(data, set);
data[1].Test009.First().Name = "updated";
set.AddOrUpdate(data);
this.AssertSequence(data, set);
data[1].Test009.RemoveRange(data[1].Test009);
set.AddOrUpdate(data);
this.AssertSequence(data, set);
set.Remove(data[1]);
data.RemoveAt(1);
this.AssertSequence(data, set);
}
public CollectionRelationConfig(IConfig config, RelationFlags flags, string identifier, ITableConfig leftTable, IMappingTableConfig mappingTable, ITableConfig rightTable, IPropertyAccessor <T, ICollection <TRelation> > accessor)
: base(config, flags, identifier, leftTable, mappingTable, rightTable)
{
this.Accessor = accessor;
}
public void Contains(RelationFlags flags, bool invert)
{
this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
var child = data[1].Test004.First();
var query = this.Database.AsQueryable <Test002>(this.Transaction);
if (invert)
{
this.AssertSequence(new[] { data[0], data[2] }, query.Where(element => !element.Test004.Contains(child)));
}
else
{
this.AssertSequence(new[] { data[1] }, query.Where(element => element.Test004.Contains(child)));
}
}
public void Limit(RelationFlags flags)
{
var relation = this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
set.Fetch.Source.GetTable(set.Table).Filter.With(filter =>
{
filter.Limit = 1;
filter.Add().With(binary =>
{
binary.Left = binary.CreateColumn(set.Table.PrimaryKey);
binary.Operator = binary.CreateOperator(QueryOperator.Greater);
binary.Right = binary.CreateParameter("Id", DbType.Int64, 0, 0, 0, ParameterDirection.Input, false, null, DatabaseQueryParameterFlags.None);
});
});
for (var a = 0; a < data.Count; a++)
{
var id = data[a].Id - 1;
set.Parameters = (parameters, phase) => parameters["Id"] = id;
this.AssertSequence(new[] { data.Where(element => element.Id > id).First() }, set);
}
}
public static IRelationSelector <T, ICollection <TRelation> > By(Expression <Func <T, ICollection <TRelation> > > expression, RelationFlags flags)
{
return(By(string.Empty, expression, flags));
}
public void CanAddUpdateDelete(RelationFlags flags)
{
const int COUNT = 1024;
var stopwatch = new Stopwatch();
var relation = this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
stopwatch.Start();
for (var a = 0; a < COUNT; a++)
{
set.AddOrUpdate(new Test002()
{
Name = "Name_" + a,
Test003 = new Test003()
{
Name = "Name_" + a
},
Test004 = new List <Test004>()
{
new Test004()
{
Name = "Name_" + a
},
new Test004()
{
Name = "Name_" + a
},
new Test004()
{
Name = "Name_" + a
}
}
});
}
stopwatch.Stop();
TestContext.Out.WriteLine("Added {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
stopwatch.Start();
Assert.AreEqual(COUNT, set.Count);
stopwatch.Stop();
TestContext.Out.WriteLine("Counted {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
stopwatch.Start();
foreach (var element in set)
{
element.Name = "updated";
element.Test003.Name = "updated";
element.Test004.First().Name = "updated";
set.AddOrUpdate(element);
}
stopwatch.Stop();
TestContext.Out.WriteLine("Updated {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
stopwatch.Start();
foreach (var element in set)
{
Assert.AreEqual("updated", element.Name);
Assert.AreEqual("updated", element.Test003.Name);
Assert.AreEqual("updated", element.Test004.First().Name);
}
stopwatch.Stop();
TestContext.Out.WriteLine("Enumerated {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
stopwatch.Start();
set.Clear();
stopwatch.Stop();
TestContext.Out.WriteLine("Removed {0} records: {1:0.00} per second.", COUNT, COUNT / stopwatch.Elapsed.TotalSeconds);
Assert.AreEqual(0, set.Count);
}
public static IRelationSelector <T, ICollection <TRelation> > By(string identifier, Expression <Func <T, ICollection <TRelation> > > expression, RelationFlags flags)
{
return(RelationSelector <T, ICollection <TRelation> > .By(identifier, expression, flags));
}
public void NToManyCompoundRelation(RelationFlags flags)
{
this.Database.Config.Table <Test002>().With(table =>
{
table.Relation(item => item.Test004, Defaults.Relation.Flags | flags).With(relation =>
{
relation.Expression.Left = relation.Expression.Clone();
relation.Expression.Operator = relation.Expression.CreateOperator(QueryOperator.OrElse);
relation.Expression.Right = relation.CreateConstraint(relation.LeftTable.Column("Test004_Id"), relation.RightTable.PrimaryKey);
});
});
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
this.AssertSequence(data, set);
data[1].Test004.Clear();
set.AddOrUpdate(data);
this.AssertSequence(data, set);
var child = this.Database.Set <Test004>(this.Transaction).AddOrUpdate(new Test004()
{
Name = "2_2"
});
data[1].Test004_Id = child.Id;
new EntityPersister(this.Database, set.Table, this.Transaction).Update(set.Find(data[1].Id), data[1]);
data[1].Test004.Add(child);
this.AssertSequence(data, set);
}
public static RelationFlags SetMultiplicity(this RelationFlags flags, RelationFlags multiplicity)
{
return((flags & ~(RelationFlags.OneToOne | RelationFlags.OneToMany | RelationFlags.ManyToMany)) | multiplicity);
}
public void ExistsNToMany(RelationFlags flags, bool invert)
{
var relation = this.Database.Config.Table <Test002>().Relation(item => item.Test004, Defaults.Relation.Flags | flags);
var set = this.Database.Set <Test002>(this.Transaction);
var data = new List <Test002>();
set.Clear();
data.AddRange(new[]
{
new Test002()
{
Name = "1_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "1_2"
}, new Test004()
{
Name = "1_3"
}
}
},
new Test002()
{
Name = "2_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "2_2"
}, new Test004()
{
Name = "2_3"
}
}
},
new Test002()
{
Name = "3_1", Test004 = new List <Test004>()
{
new Test004()
{
Name = "3_2"
}, new Test004()
{
Name = "3_3"
}
}
},
});
set.AddOrUpdate(data);
var function = set.Fetch.Filter.CreateFunction(QueryFunction.Exists, set.Fetch.Filter.CreateSubQuery(this.Database.QueryFactory.Build().With(builder =>
{
var columns = relation.Expression.GetColumnMap();
builder.Output.AddColumns(this.Database.Config.Table <Test004>().Columns);
builder.Source.AddTable(this.Database.Config.Table <Test002>().Extern());
builder.Source.AddTable(this.Database.Config.Table <Test004>());
builder.RelationManager.AddRelation(relation);
builder.Filter.AddColumn(this.Database.Config.Table <Test004>().Column("Name"));
})));
if (invert)
{
set.Fetch.Filter.Expressions.Add(set.Fetch.Filter.Fragment <IUnaryExpressionBuilder>().With(unary =>
{
unary.Operator = unary.CreateOperator(QueryOperator.Not);
unary.Expression = function;
}));
}
else
{
set.Fetch.Filter.Expressions.Add(function);
}
set.Parameters = (parameters, phase) => parameters["Name"] = "2_2";
if (invert)
{
this.AssertSequence(new[] { data[0], data[2] }, set);
}
else
{
this.AssertSequence(new[] { data[1] }, set);
}
}
