public void TestCondition2()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlCondition <Relation2> condition = new SqlCondition <Relation2>();
Assert.Equal("(StudentId > @StudentId OR ClassId <> @ClassId)", (condition > "StudentId" | condition != "ClassId").ToString());
}
public void TestCondition()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlCondition <Relation2> condition = new SqlCondition <Relation2>();
Assert.Equal("StudentId > @StudentId", (condition > "StudentId").ToString());
}
public void TestUnionCondition2()
{
SqlPackage <Student> package = new SqlPackage <Student>();
SqlCondition <Student> condition = new SqlCondition <Student>();
var result = SqlUnion <Student> .Union(Sql <Student> .SelectAllByCondition + (condition > "Sid").Full);
Assert.Equal("SELECT * FROM `1` WHERE Sid > @Sid", result);
}
public void TestSelectRelation33()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
Assert.Equal("SELECT `StudentId` FROM `关系映射表` WHERE `Id`=@Id AND `ClassId`=@ClassId", RelationSql <Student, Relation, Relation, Class> .GetFromTable);
Assert.Equal("SELECT `StudentId` FROM `关系映射表` WHERE `ClassId`=@Cid AND `Id`=@Id", RelationSql <Student, Relation, Class, Relation> .GetFromSource);
}
public void TestUnionCondition1()
{
SqlPackage <Student> package = new SqlPackage <Student>();
SqlCondition <Student> condition = new SqlCondition <Student>();
var result = SqlUnion <Student> .Union(Sql <Student> .SelectAllByCondition + (condition > "Sid").Full, "table1", "table2", "table3");
Assert.Equal("SELECT * FROM `table1` WHERE Sid > @Sid UNION SELECT * FROM `table2` WHERE Sid > @Sid UNION SELECT * FROM `table3` WHERE Sid > @Sid", result);
}
public void TestNormalScript3()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
string test = "c+Id-ClassId ^c<=Id&(c==StudentName|c!= ClassId)^(3,10)";
Assert.Equal("(Id <= @Id AND (StudentName = @StudentName OR ClassId <> @ClassId)) ORDER BY Id ASC,ClassId DESC OFFSET 20 ROW FETCH NEXT 10 rows only",
test.Condition <Relation2>(test).Full);
}
public void TestInsertRelation32()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
Assert.Equal("INSERT INTO `关系映射表` (`StudentId`,`Id`)VALUES(@StudentId,@Id)", RelationSql <Student, Relation, Relation> .AddFromTable);
Assert.Equal("INSERT INTO `关系映射表` (`Id`,`ClassId`)VALUES(@Id,@ClassId)", RelationSql <Relation, Relation, Class> .AddFromTable);
Assert.Equal("INSERT INTO `关系映射表` (`StudentId`,`ClassId`)VALUES(@Sid,@Cid)", RelationSql <Student, Relation, Class> .AddFromSource);
Assert.Equal("INSERT INTO `关系映射表` (`ClassId`,`StudentId`)VALUES(@Cid,@Sid)", RelationSql <Class, Relation, Student> .AddFromSource);
}
public void TestUpdateRelation32()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
Assert.Equal("UPDATE `关系映射表` SET `StudentId`=@StudentId WHERE `Id`=@Id", RelationSql <Student, Relation, Relation> .ModifyFromTable);
Assert.Equal("UPDATE `关系映射表` SET `Id`=@Id WHERE `ClassId`=@ClassId", RelationSql <Relation, Relation, Class> .ModifyFromTable);
Assert.Equal("UPDATE `关系映射表` SET `StudentId`=@Sid WHERE `ClassId`=@Cid", RelationSql <Student, Relation, Class> .ModifyFromSource);
Assert.Equal("UPDATE `关系映射表` SET `ClassId`=@Cid WHERE `StudentId`=@Sid", RelationSql <Class, Relation, Student> .ModifyFromSource);
}
public void TestDeleteAftRelation32()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
Assert.Equal("DELETE FROM `关系映射表` WHERE `Id`=@Id", RelationSql <Student, Relation, Relation> .DeleteAftFromTable);
Assert.Equal("DELETE FROM `关系映射表` WHERE `ClassId`=@ClassId", RelationSql <Relation, Relation, Class> .DeleteAftFromTable);
Assert.Equal("DELETE FROM `关系映射表` WHERE `ClassId`=@Cid", RelationSql <Student, Relation, Class> .DeleteAftFromSource);
Assert.Equal("DELETE FROM `关系映射表` WHERE `StudentId`=@Sid", RelationSql <Class, Relation, Student> .DeleteAftFromSource);
}
public void TestValueProperty()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlPackage <Student> package1 = new SqlPackage <Student>();
Student student = new Student();
Sql <Student> .SetPrimary(student, 1);
Assert.Equal(1, (int)RelationSql <Student, Relation2, Student1, Class, Class1> .Getters[0](student));
}
public void TestRefField()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlPackage <Class1> package1 = new SqlPackage <Class1>();
Class1 myClass = new Class1();
Sql <Class1> .SetPrimary(myClass, "abc");
Assert.Equal("abc", (string)RelationSql <Class1, Relation2, Student1, Class, Student> .Getters[0](myClass));
}
public void TestValueField()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlPackage <Class> package1 = new SqlPackage <Class>();
Class myClass = new Class();
Sql <Class> .SetPrimary(myClass, 1);
Assert.Equal(1, (int)RelationSql <Class, Relation2, Student1, Student, Class1> .Getters[0](myClass));
}
public void TestRefProperty()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlPackage <Student1> package1 = new SqlPackage <Student1>();
Student1 student = new Student1();
Sql <Student1> .SetPrimary(student, "abc");
Assert.Equal("abc", (string)RelationSql <Student1, Relation2, Student, Class, Class1> .Getters[0](student));
}
public void TestSelectRelation32()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
Assert.Equal("Id", MakerModel <Relation> .PrimaryKey);
Assert.Equal('`', MakerModel <Relation> .Left);
Assert.Equal('`', MakerModel <Relation> .Right);
Assert.Equal("关系映射表", MakerModel <Relation> .TableName);
Assert.NotNull(MakerModel <Relation> .StringMapping);
Assert.NotNull(MakerModel <Relation> .ColumnMapping);
}
public void TestCondition3()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlCondition <Relation2> c = new SqlCondition <Relation2>();
Assert.Equal(
"((StudentId > @StudentId OR ClassId = @ClassId) AND ClassName <> @ClassName)",
((c > "StudentId" | c == "ClassId") & c != "ClassName").ToString()
);
}
/// <summary>
/// 开局必须调用的函数
/// </summary>
/// <param name="interfaceName">如果自己有特殊接口，那么可以写自己的接口名</param>
public static void Run(params string[] interfaceNames)
{
if (interfaceNames.Length == 0)
{
interfaceNames = new string[] { "IVasilyNormal", "IVasilyRelation" };
}
List <Type> types = new List <Type>();
Assembly assmbly = Assembly.GetEntryAssembly();
if (assmbly == null)
{
return;
}
IEnumerator <Type> typeCollection = assmbly.ExportedTypes.GetEnumerator();
Type temp_Type = null;
while (typeCollection.MoveNext())
{
temp_Type = typeCollection.Current;
if (temp_Type.IsClass && !temp_Type.IsAbstract)
{
var temp_Name = temp_Type.Name.Split('-')[0];
if (!RelationExtentsionTyps.ContainsKey(temp_Name))
{
RelationExtentsionTyps[temp_Name] = temp_Type;
}
for (int i = 0; i < interfaceNames.Length; i += 1)
{
if (temp_Type.GetInterface(interfaceNames[i]) != null)
{
types.Add(temp_Type);
}
}
}
}
if (UseParallel)
{
Parallel.ForEach(types, (element) =>
{
SqlPackage package = new SqlPackage(element);
});
}
else
{
foreach (var item in types)
{
SqlPackage package = new SqlPackage(item);
}
}
}
public void TestPageCondition3()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlCondition <Relation2> c = new SqlCondition <Relation2>();
Assert.Equal(
"((StudentId > @StudentId OR ClassId = @ClassId) AND ClassName <> @ClassName) ORDER BY StudentId ASC,ClassId DESC",
//升序-----------降序-----排序链接-----------------条件----------------------------
//↓ ↓ ↓
(c + "StudentId" - "ClassId" ^ (c > "StudentId" | c == "ClassId") & c != "ClassName").ToString()
);
}
public void TestOrderCondition2()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlCondition <Relation2> c = new SqlCondition <Relation2>();
Assert.Equal(
"((StudentId > @StudentId OR ClassId = @ClassId) AND ClassName <> @ClassName) ORDER BY StudentId ASC",
//----------------------------条件----------------排序链接--升序------------
// ↓ ↓
((c > "StudentId" | c == "ClassId") & c != "ClassName" ^ c + "StudentId").ToString()
);
}
public void TestPageCondition1()
{
SqlPackage <Relation2> package = new SqlPackage <Relation2>();
SqlCondition <Relation2> c = new SqlCondition <Relation2>();
var cp = new { StudentId = 1, ClassId = 2, ClassName = "abc" }.
Condition(((c > "StudentId" | c == "ClassId") & c != "ClassName") ^ (2, 10));
Assert.Equal(
"((StudentId > @StudentId OR ClassId = @ClassId) AND ClassName <> @ClassName) OFFSET 10 ROW FETCH NEXT 10 rows only",
cp.Full
);
}
public void TestPageCondition2()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
SqlCondition <Relation> c = new SqlCondition <Relation>();
var cp =
new { StudentId = 1, ClassId = 2, ClassName = "abc" }.
Condition(c > "StudentId" | c == "ClassId" & c != "Id" ^ (2, 10));
Assert.Equal(
"(StudentId > @StudentId OR (ClassId = @ClassId AND Id <> @Id)) LIMIT 10,10",
cp.Full
);
}
public Demo_Union()
{
SqlPackage <One> package = new SqlPackage <One>();
condition = new SqlCondition <One>();
}
public void TestSourceArray()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
Assert.Equal("Sid,Id", string.Join(',', RelationSql <Student, Relation, Relation> .SourceConditions));
}
public void TestSourceCount()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
Assert.Equal("SELECT Count(*) FROM `关系映射表` WHERE `StudentId`=@Sid", RelationSql <Relation, Relation, Student> .CountFromSource);
}
public void TestTableCount()
{
SqlPackage <Relation> package = new SqlPackage <Relation>();
Assert.Equal("SELECT Count(*) FROM `关系映射表` WHERE `Id`=@Id", RelationSql <Student, Relation, Relation> .CountFromTable);
}
