tk/FreeSql
1
0
Fork 0
mirror of https://github.com/nsnail/FreeSql.git synced 2025-11-04 01:05:27 +08:00
Code Issues Packages Projects Releases Wiki Activity

- 增加 ISelect ToDelete/ToUpdate 方法，实现更复杂的删除/更新操作；

Browse Source
This commit is contained in:
28810
2019-10-30 20:35:42 +08:00
parent db7fe82403
commit 21b4b0d5d3
21 changed files with 1594 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

7
FreeSql.DbContext/FreeSql.DbContext.xml
View File

@@ -99,6 +99,13 @@
清空状态数据
</summary>
</member>
<member name="M:FreeSql.DbSet`1.RemoveAsync(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
根据 lambda 条件删除数据
</summary>
<param name="predicate"></param>
<returns></returns>
</member>
<member name="M:FreeSql.DbSet`1.Add(`0)">
<summary>
添加

134
FreeSql.Tests/FreeSql.Tests.Provider.MySqlConnector/MySqlConnector/Curd/MySqlSelectTest.cs
View File

@@ -1358,5 +1358,139 @@ namespace FreeSql.Tests.MySqlConnector
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.mysql.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel1Pk>().Count());
g.mysql.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel2Pk>().Count());
g.mysql.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel3Pk>().Count());
g.mysql.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.mysql.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd1Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd2Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd3Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/Default/Curd/OdbcSelectTest.cs
View File

@@ -1202,5 +1202,139 @@ namespace FreeSql.Tests.Odbc.Default
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.odbc.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.odbc.Select<ToDel1Pk>().Count());
g.odbc.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.odbc.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.odbc.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.odbc.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.odbc.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.odbc.Select<ToDel2Pk>().Count());
g.odbc.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.odbc.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.odbc.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.odbc.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.odbc.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.odbc.Select<ToDel3Pk>().Count());
g.odbc.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.odbc.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.odbc.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.odbc.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.odbc.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.odbc.Select<ToUpd1Pk>().Count());
g.odbc.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.odbc.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.odbc.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.odbc.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.odbc.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.odbc.Select<ToUpd2Pk>().Count());
g.odbc.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.odbc.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.odbc.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.odbc.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.odbc.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.odbc.Select<ToUpd3Pk>().Count());
g.odbc.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.odbc.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.odbc.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.odbc.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/MySql/Curd/MySqlSelectTest.cs
View File

@@ -1348,5 +1348,139 @@ namespace FreeSql.Tests.Odbc.MySql
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.mysql.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel1Pk>().Count());
g.mysql.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel2Pk>().Count());
g.mysql.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel3Pk>().Count());
g.mysql.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.mysql.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd1Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd2Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd3Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/Oracle/Curd/OracleSelectTest.cs
View File

@@ -1232,5 +1232,139 @@ namespace FreeSql.Tests.Odbc.Oracle
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.oracle.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToDel1Pk>().Count());
g.oracle.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.oracle.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.oracle.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.oracle.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToDel2Pk>().Count());
g.oracle.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.oracle.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.oracle.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.oracle.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToDel3Pk>().Count());
g.oracle.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.oracle.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.oracle.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.oracle.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToUpd1Pk>().Count());
g.oracle.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.oracle.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.oracle.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.oracle.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToUpd2Pk>().Count());
g.oracle.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.oracle.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.oracle.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.oracle.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToUpd3Pk>().Count());
g.oracle.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.oracle.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.oracle.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/PostgreSQL/Curd/PostgreSQLSelectTest.cs
View File

@@ -1306,5 +1306,139 @@ namespace FreeSql.Tests.Odbc.PostgreSQL
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.pgsql.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToDel1Pk>().Count());
g.pgsql.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.pgsql.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.pgsql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.pgsql.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToDel2Pk>().Count());
g.pgsql.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.pgsql.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.pgsql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.pgsql.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToDel3Pk>().Count());
g.pgsql.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.pgsql.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.pgsql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.pgsql.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToUpd1Pk>().Count());
g.pgsql.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.pgsql.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.pgsql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.pgsql.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToUpd2Pk>().Count());
g.pgsql.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.pgsql.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.pgsql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.pgsql.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToUpd3Pk>().Count());
g.pgsql.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.pgsql.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.pgsql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests.Provider.Odbc/SqlServer/Curd/SqlServerSelectTest.cs
View File

@@ -1220,5 +1220,139 @@ namespace FreeSql.Tests.Odbc.SqlServer
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.sqlserver.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToDel1Pk>().Count());
g.sqlserver.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlserver.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.sqlserver.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlserver.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToDel2Pk>().Count());
g.sqlserver.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlserver.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.sqlserver.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlserver.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToDel3Pk>().Count());
g.sqlserver.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlserver.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.sqlserver.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.sqlserver.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToUpd1Pk>().Count());
g.sqlserver.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlserver.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.sqlserver.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlserver.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToUpd2Pk>().Count());
g.sqlserver.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlserver.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.sqlserver.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlserver.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToUpd3Pk>().Count());
g.sqlserver.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlserver.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.sqlserver.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests/MySql/Curd/MySqlSelectTest.cs
View File

@@ -1348,5 +1348,139 @@ namespace FreeSql.Tests.MySql
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.mysql.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel1Pk>().Count());
g.mysql.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel2Pk>().Count());
g.mysql.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToDel3Pk>().Count());
g.mysql.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.mysql.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.mysql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.mysql.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd1Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd2Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.mysql.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.mysql.Select<ToUpd3Pk>().Count());
g.mysql.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.mysql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.mysql.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.mysql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests/Oracle/Curd/OracleSelectTest.cs
View File

@@ -1232,5 +1232,139 @@ namespace FreeSql.Tests.Oracle
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.oracle.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToDel1Pk>().Count());
g.oracle.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.oracle.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.oracle.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.oracle.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToDel2Pk>().Count());
g.oracle.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.oracle.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.oracle.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.oracle.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToDel3Pk>().Count());
g.oracle.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.oracle.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.oracle.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.oracle.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToUpd1Pk>().Count());
g.oracle.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.oracle.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.oracle.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.oracle.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToUpd2Pk>().Count());
g.oracle.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.oracle.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.oracle.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.oracle.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.oracle.Select<ToUpd3Pk>().Count());
g.oracle.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.oracle.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.oracle.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.oracle.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests/PostgreSQL/Curd/PostgreSQLSelectTest.cs
View File

@@ -1306,5 +1306,139 @@ namespace FreeSql.Tests.PostgreSQL
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.pgsql.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToDel1Pk>().Count());
g.pgsql.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.pgsql.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.pgsql.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.pgsql.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToDel2Pk>().Count());
g.pgsql.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.pgsql.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.pgsql.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.pgsql.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToDel3Pk>().Count());
g.pgsql.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.pgsql.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.pgsql.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.pgsql.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToUpd1Pk>().Count());
g.pgsql.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.pgsql.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.pgsql.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.pgsql.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToUpd2Pk>().Count());
g.pgsql.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.pgsql.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.pgsql.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.pgsql.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.pgsql.Select<ToUpd3Pk>().Count());
g.pgsql.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.pgsql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.pgsql.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.pgsql.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests/SqlServer/Curd/SqlServerSelectTest.cs
View File

@@ -1229,5 +1229,139 @@ namespace FreeSql.Tests.SqlServer
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.sqlserver.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToDel1Pk>().Count());
g.sqlserver.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlserver.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.sqlserver.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlserver.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToDel2Pk>().Count());
g.sqlserver.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlserver.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.sqlserver.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlserver.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToDel3Pk>().Count());
g.sqlserver.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlserver.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.sqlserver.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.sqlserver.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToUpd1Pk>().Count());
g.sqlserver.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlserver.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.sqlserver.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlserver.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToUpd2Pk>().Count());
g.sqlserver.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlserver.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.sqlserver.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlserver.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlserver.Select<ToUpd3Pk>().Count());
g.sqlserver.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlserver.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlserver.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.sqlserver.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

134
FreeSql.Tests/FreeSql.Tests/Sqlite/Curd/SqliteSelectTest.cs
View File

@@ -1209,5 +1209,139 @@ namespace FreeSql.Tests.Sqlite
.Where(a => a.Tag.Id == tag1.Id || a.Tag.Id == tag2.Id)
.ToList(true);
}
public class ToDel1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToDel2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToDel3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToDelete()
{
g.sqlite.Select<ToDel1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlite.Select<ToDel1Pk>().Count());
g.sqlite.Insert(new[] {
new ToDel1Pk{ name = "name1"},
new ToDel1Pk{ name = "name2"},
new ToDel1Pk{ name = "nick1"},
new ToDel1Pk{ name = "nick2"},
new ToDel1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlite.Select<ToDel1Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlite.Select<ToDel1Pk>().Count());
Assert.Equal(3, g.sqlite.Select<ToDel1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlite.Select<ToDel2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlite.Select<ToDel2Pk>().Count());
g.sqlite.Insert(new[] {
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToDel2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlite.Select<ToDel2Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlite.Select<ToDel2Pk>().Count());
Assert.Equal(3, g.sqlite.Select<ToDel2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlite.Select<ToDel3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlite.Select<ToDel3Pk>().Count());
g.sqlite.Insert(new[] {
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToDel3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlite.Select<ToDel3Pk>().Where(a => a.name.StartsWith("name")).ToDelete().ExecuteAffrows());
Assert.Equal(3, g.sqlite.Select<ToDel3Pk>().Count());
Assert.Equal(3, g.sqlite.Select<ToDel3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
public class ToUpd1Pk
{
[Column(IsIdentity = true)]
public int id { get; set; }
public string name { get; set; }
}
public class ToUpd2Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public string pk2 { get; set; }
public string name { get; set; }
}
public class ToUpd3Pk
{
[Column(IsPrimary = true)]
public Guid pk1 { get; set; }
[Column(IsPrimary = true)]
public int pk2 { get; set; }
[Column(IsPrimary = true)]
public string pk3 { get; set; }
public string name { get; set; }
}
[Fact]
public void ToUpdate()
{
g.sqlite.Select<ToUpd1Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlite.Select<ToUpd1Pk>().Count());
g.sqlite.Insert(new[] {
new ToUpd1Pk{ name = "name1"},
new ToUpd1Pk{ name = "name2"},
new ToUpd1Pk{ name = "nick1"},
new ToUpd1Pk{ name = "nick2"},
new ToUpd1Pk{ name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlite.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlite.Select<ToUpd1Pk>().Count());
Assert.Equal(5, g.sqlite.Select<ToUpd1Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlite.Select<ToUpd2Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlite.Select<ToUpd2Pk>().Count());
g.sqlite.Insert(new[] {
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "name2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick1"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick2"},
new ToUpd2Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = "pk2", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlite.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlite.Select<ToUpd2Pk>().Count());
Assert.Equal(5, g.sqlite.Select<ToUpd2Pk>().Where(a => a.name.StartsWith("nick")).Count());
g.sqlite.Select<ToUpd3Pk>().ToDelete().ExecuteAffrows();
Assert.Equal(0, g.sqlite.Select<ToUpd3Pk>().Count());
g.sqlite.Insert(new[] {
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "name2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick1"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick2"},
new ToUpd3Pk{ pk1 = FreeUtil.NewMongodbId(), pk2 = 1, pk3 = "pk3", name = "nick3"}
}).ExecuteAffrows();
Assert.Equal(2, g.sqlite.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("name")).ToUpdate().Set(a => a.name, "nick?").ExecuteAffrows());
Assert.Equal(5, g.sqlite.Select<ToUpd3Pk>().Count());
Assert.Equal(5, g.sqlite.Select<ToUpd3Pk>().Where(a => a.name.StartsWith("nick")).Count());
}
}
}

30
FreeSql/FreeSql.xml
View File

@@ -611,7 +611,8 @@
</member>
<member name="M:FreeSql.IDelete`1.Where(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
lambda表达式条件，仅支持实体基础成员（不包含导航对象）
lambda表达式条件，仅支持实体基础成员（不包含导航对象）<para></para>
若想使用导航对象，请使用 ISelect.ToDelete() 方法
</summary>
<param name="exp">lambda表达式条件</param>
<returns></returns>
@@ -870,6 +871,30 @@
</summary>
<returns></returns>
</member>
<member name="M:FreeSql.ISelect0`2.ToDelete">
<summary>
将查询转为删除对象，以便支持导航对象或其他查询功能删除数据，如下：<para></para>
fsql.Select&lt;T1&gt;().Where(a => a.Options.xxx == 1).ToDelete().ExecuteAffrows()<para></para>
注意：此方法不是将数据查询到内存循环删除，上面的代码产生如下 SQL 执行：<para></para>
DELETE FROM `T1` WHERE id in (select a.id from T1 a left join Options b on b.t1id = a.id where b.xxx = 1)<para></para>
复杂删除使用该方案的好处：<para></para>
1、删除前可预览测试数据，防止错误删除操作；<para></para>
2、支持更加复杂的删除操作（IDelete 默认只支持简单的操作）；
</summary>
<returns></returns>
</member>
<member name="M:FreeSql.ISelect0`2.ToUpdate">
<summary>
将查询转为更新对象，以便支持导航对象或其他查询功能更新数据，如下：<para></para>
fsql.Select&lt;T1&gt;().Where(a => a.Options.xxx == 1).ToUpdate().Set(a => a.Title, "111").ExecuteAffrows()<para></para>
注意：此方法不是将数据查询到内存循环更新，上面的代码产生如下 SQL 执行：<para></para>
UPDATE `T1` SET Title = '111' WHERE id in (select a.id from T1 a left join Options b on b.t1id = a.id where b.xxx = 1)<para></para>
复杂更新使用该方案的好处：<para></para>
1、更新前可预览测试数据，防止错误更新操作；<para></para>
2、支持更加复杂的更新操作（IUpdate 默认只支持简单的操作）；
</summary>
<returns></returns>
</member>
<member name="M:FreeSql.ISelect0`2.AsTable(System.Func{System.Type,System.String,System.String})">
<summary>
设置表名规则，可用于分库/分表，参数1：实体类型；参数2：默认表名；返回值：新表名； <para></para>
@@ -1710,7 +1735,8 @@
</member>
<member name="M:FreeSql.IUpdate`1.Where(System.Linq.Expressions.Expression{System.Func{`0,System.Boolean}})">
<summary>
lambda表达式条件，仅支持实体基础成员（不包含导航对象）
lambda表达式条件，仅支持实体基础成员（不包含导航对象）<para></para>
若想使用导航对象，请使用 ISelect.ToUpdate() 方法
</summary>
<param name="exp">lambda表达式条件</param>
<returns></returns>

3
FreeSql/Interface/Curd/IDelete.cs
View File

@@ -23,7 +23,8 @@ namespace FreeSql
IDelete<T1> WithConnection(DbConnection connection);
/// <summary>
/// lambda表达式条件，仅支持实体基础成员（不包含导航对象）
/// lambda表达式条件，仅支持实体基础成员（不包含导航对象）<para></para>
/// 若想使用导航对象，请使用 ISelect.ToDelete() 方法
/// </summary>
/// <param name="exp">lambda表达式条件</param>
/// <returns></returns>

25
FreeSql/Interface/Curd/ISelect/ISelect0.cs
View File

@@ -8,7 +8,7 @@ using System.Threading.Tasks;
namespace FreeSql
{
public partial interface ISelect0<TSelect, T1>
public partial interface ISelect0<TSelect, T1> where T1 : class
{
#if net40
@@ -82,6 +82,29 @@ namespace FreeSql
/// <returns></returns>
T1 First();
/// <summary>
/// 将查询转为删除对象，以便支持导航对象或其他查询功能删除数据，如下：<para></para>
/// fsql.Select&lt;T1&gt;().Where(a => a.Options.xxx == 1).ToDelete().ExecuteAffrows()<para></para>
/// 注意：此方法不是将数据查询到内存循环删除，上面的代码产生如下 SQL 执行：<para></para>
/// DELETE FROM `T1` WHERE id in (select a.id from T1 a left join Options b on b.t1id = a.id where b.xxx = 1)<para></para>
/// 复杂删除使用该方案的好处：<para></para>
/// 1、删除前可预览测试数据，防止错误删除操作；<para></para>
/// 2、支持更加复杂的删除操作（IDelete 默认只支持简单的操作）；
/// </summary>
/// <returns></returns>
IDelete<T1> ToDelete();
/// <summary>
/// 将查询转为更新对象，以便支持导航对象或其他查询功能更新数据，如下：<para></para>
/// fsql.Select&lt;T1&gt;().Where(a => a.Options.xxx == 1).ToUpdate().Set(a => a.Title, "111").ExecuteAffrows()<para></para>
/// 注意：此方法不是将数据查询到内存循环更新，上面的代码产生如下 SQL 执行：<para></para>
/// UPDATE `T1` SET Title = '111' WHERE id in (select a.id from T1 a left join Options b on b.t1id = a.id where b.xxx = 1)<para></para>
/// 复杂更新使用该方案的好处：<para></para>
/// 1、更新前可预览测试数据，防止错误更新操作；<para></para>
/// 2、支持更加复杂的更新操作（IUpdate 默认只支持简单的操作）；
/// </summary>
/// <returns></returns>
IUpdate<T1> ToUpdate();
/// <summary>
/// 设置表名规则，可用于分库/分表，参数1：实体类型；参数2：默认表名；返回值：新表名； <para></para>
/// 设置多次，可查询分表后的多个子表记录，以 UNION ALL 形式执行。 <para></para>

3
FreeSql/Interface/Curd/IUpdate.cs
View File

@@ -92,7 +92,8 @@ namespace FreeSql
IUpdate<T1> SetRaw(string sql, object parms = null);
/// <summary>
/// lambda表达式条件，仅支持实体基础成员（不包含导航对象）
/// lambda表达式条件，仅支持实体基础成员（不包含导航对象）<para></para>
/// 若想使用导航对象，请使用 ISelect.ToUpdate() 方法
/// </summary>
/// <param name="exp">lambda表达式条件</param>
/// <returns></returns>

37
FreeSql/Internal/CommonProvider/SelectProvider/Select0Provider.cs
View File

@@ -833,6 +833,43 @@ namespace FreeSql.Internal.CommonProvider
return (map, field.ToString());
}
string GetToDeleteWhere(string alias)
{
var pks = _tables[0].Table.Primarys;
if (pks.Length == 1)
return $"{_commonUtils.QuoteSqlName(_tables[0].Table.Primarys[0].Attribute.Name)} in (select * from ({this.ToSql($"{_tables[0].Alias}.{_commonUtils.QuoteSqlName(_tables[0].Table.Primarys[0].Attribute.Name)}")}) {alias})";
else
{
var concatTypes = new Type[pks.Length * 2 - 1];
var concatMainCols = new string[pks.Length * 2 - 1];
var concatInCols = new string[pks.Length * 2 - 1];
var concatSplit = _commonUtils.FormatSql("{0}", $",{alias},");
for (var a = 0; a < pks.Length; a++)
{
concatTypes[a * 2] = pks[a].CsType;
concatMainCols[a * 2] = _commonUtils.QuoteSqlName(pks[a].Attribute.Name);
concatInCols[a * 2] = $"{_tables[0].Alias}.{_commonUtils.QuoteSqlName(pks[a].Attribute.Name)}";
if (a < pks.Length - 1)
{
concatTypes[a * 2 + 1] = typeof(string);
concatMainCols[a * 2 + 1] = concatSplit;
concatInCols[a * 2 + 1] = concatSplit;
}
}
return $"{_commonUtils.StringConcat(concatMainCols, concatTypes)} in (select * from ({this.ToSql($"{_commonUtils.StringConcat(concatInCols, concatTypes)} as as1")}) {alias})";
}
}
public IDelete<T1> ToDelete()
{
if (_tables[0].Table.Primarys.Any() == false) throw new Exception($"ToDelete 功能要求实体类 {_tables[0].Table.CsName} 必须有主键");
return _orm.Delete<T1>().Where(GetToDeleteWhere("ftb_del"));
}
public IUpdate<T1> ToUpdate()
{
if (_tables[0].Table.Primarys.Any() == false) throw new Exception($"ToUpdate 功能要求实体类 {_tables[0].Table.CsName} 必须有主键");
return _orm.Update<T1>().Where(GetToDeleteWhere("ftb_upd"));
}
protected List<Dictionary<Type, string>> GetTableRuleUnions()
{
var unions = new List<Dictionary<Type, string>>();

6
FreeSql/Internal/UtilsExpressionTree.cs
View File

@@ -297,7 +297,11 @@ namespace FreeSql.Internal
foreach (var col in trytb.Primarys)
col.Attribute.IsPrimary = true;
}
foreach (var col in trytb.Primarys) col.Attribute.IsNullable = false;
foreach (var col in trytb.Primarys)
{
col.Attribute.IsNullable = false;
col.Attribute.DbType = col.Attribute.DbType.Replace("NOT NULL", "");
}
tbc.AddOrUpdate(entity, trytb, (oldkey, oldval) => trytb);
#region 查找导航属性的关系、virtual 属性延时加载，动态产生新的重写类

6
Providers/FreeSql.Provider.Odbc/Default/OdbcAdapter.cs
View File

@@ -71,7 +71,11 @@ namespace FreeSql.Odbc.Default
var sb = new StringBuilder();
var news = new string[objs.Length];
for (var a = 0; a < objs.Length; a++)
news[a] = types[a] == typeof(string) ? objs[a] : $"cast({objs[a]} as nvarchar)";
{
if (types[a] == typeof(string)) news[a] = objs[a];
else if (types[a].NullableTypeOrThis() == typeof(Guid)) news[a] = $"cast({objs[a]} as char(36))";
else news[a] = $"cast({objs[a]} as nvarchar)";
}
return string.Join(" + ", news);
}

6
Providers/FreeSql.Provider.Odbc/SqlServer/OdbcSqlServerUtils.cs
View File

@@ -62,7 +62,11 @@ namespace FreeSql.Odbc.SqlServer
var sb = new StringBuilder();
var news = new string[objs.Length];
for (var a = 0; a < objs.Length; a++)
news[a] = types[a] == typeof(string) ? objs[a] : $"cast({objs[a]} as nvarchar)";
{
if (types[a] == typeof(string)) news[a] = objs[a];
else if (types[a].NullableTypeOrThis() == typeof(Guid)) news[a] = $"cast({objs[a]} as char(36))";
else news[a] = $"cast({objs[a]} as nvarchar)";
}
return string.Join(" + ", news);
}
public override string Mod(string left, string right, Type leftType, Type rightType) => $"{left} % {right}";

6
Providers/FreeSql.Provider.SqlServer/SqlServerUtils.cs
View File

@@ -62,7 +62,11 @@ namespace FreeSql.SqlServer
var sb = new StringBuilder();
var news = new string[objs.Length];
for (var a = 0; a < objs.Length; a++)
news[a] = types[a] == typeof(string) ? objs[a] : $"cast({objs[a]} as nvarchar)";
{
if (types[a] == typeof(string)) news[a] = objs[a];
else if (types[a].NullableTypeOrThis() == typeof(Guid)) news[a] = $"cast({objs[a]} as char(36))";
else news[a] = $"cast({objs[a]} as nvarchar)";
}
return string.Join(" + ", news);
}
public override string Mod(string left, string right, Type leftType, Type rightType) => $"{left} % {right}";