lsm/SqlSugar
1
0
Fork 0
mirror of https://gitee.com/dotnetchina/SqlSugar.git synced 2025-08-23 13:06:50 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Update SubInsert

Browse Source
This commit is contained in:
skx 2020-11-13 21:36:52 +08:00
parent fe638adf37
commit cdce78f067
8 changed files with 282 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

75
Src/Asp.Net/SqlServerTest/Demo/Demo3_Insertable.cs
View File

@ -56,7 +56,13 @@ namespace OrmTest
};
db.Insertable(insertObjs).UseSqlServer().ExecuteBlueCopy();
db.CodeFirst.InitTables<SubInsertTest, SubInsertTestItem, SubInsertTestItem1, SubInsertTestItem2>();
db.CodeFirst.InitTables<RootTable0, TwoItem, TwoItem2, TwoItem3>();
db.CodeFirst.InitTables<ThreeItem2>();
db.DbMaintenance.TruncateTable("RootTable0");
db.DbMaintenance.TruncateTable("TwoItem");
db.DbMaintenance.TruncateTable("TwoItem2");
db.DbMaintenance.TruncateTable("TwoItem3");
db.DbMaintenance.TruncateTable("ThreeItem2");
Console.WriteLine("SubInsert Start");
db.Insertable(new Order()
@ -72,41 +78,72 @@ namespace OrmTest
OrderId=0,
Price=1,
ItemId=1
},
new OrderItem(){
CreateTime=DateTime.Now,
OrderId=0,
Price=2,
ItemId=2
}
}
})
.AddSubList(it => it.Items.First().OrderId).ExecuteReturnPrimaryKey();
db.Insertable(new List<SubInsertTest>() {
new SubInsertTest()
db.Insertable(new List<RootTable0>() {
new RootTable0()
{
Name="aa",
SubInsertTestItem1=new SubInsertTestItem1() {
a="nn"
},
SubInsertTestItem=new SubInsertTestItem()
{
Name ="item" ,
TestId=2
TwoItem2=new TwoItem2() {
Id="1",
ThreeItem2=new List<ThreeItem2>(){
new ThreeItem2(){ Name="a", TwoItem2Id="1" }
}
},
new SubInsertTest()
TwoItem=new TwoItem()
{
Name="aa",
SubInsertTestItem1=new SubInsertTestItem1() {
a="nn"
Name ="itema" ,
RootId=2
},
SubInsertTestItem=new SubInsertTestItem()
TwoItem3=new List<TwoItem3>(){
new TwoItem3(){ Id=0, Name="a",Desc="" },
}
},
new RootTable0()
{
Name ="item" ,
TestId=2
Name="bb",
TwoItem2=new TwoItem2() {
Id="2"
},
TwoItem=new TwoItem()
{
Name ="itemb" ,
RootId=2,
},
TwoItem3=new List<TwoItem3>(){
new TwoItem3(){ Id=1, Name="b",Desc="" },
new TwoItem3(){ Id=2, Name="b1",Desc="1" },
}
}
})
.AddSubList(it => it.SubInsertTestItem.TestId)
.AddSubList(it => it.SubInsertTestItem1)
.AddSubList(it => it.TwoItem.RootId)
.AddSubList(it => new GetSubInsertTree()
{
Expression = it.TwoItem2.RootId,
ChildExpression=new List<GetSubInsertTree>() {
new GetSubInsertTree(){
Expression=it.TwoItem2.ThreeItem2.First().TwoItem2Id
}
}
})
.AddSubList(it => it.TwoItem3)
.ExecuteReturnPrimaryKey();
Console.WriteLine("#### Insertable End ####");
}

37
Src/Asp.Net/SqlServerTest/Models/SubInsertTest.cs
View File

@ -6,34 +6,47 @@ using System.Threading.Tasks;
namespace OrmTest
{
public class SubInsertTest
public class RootTable0
{
[SqlSugar.SugarColumn(IsPrimaryKey =true,IsIdentity =true)]
public int Id { get; set; }
public string Name { get; set; }
[SqlSugar.SugarColumn(IsIgnore =true)]
public SubInsertTestItem SubInsertTestItem { get; set; }
public TwoItem TwoItem { get; set; }
[SqlSugar.SugarColumn(IsIgnore = true)]
public SubInsertTestItem1 SubInsertTestItem1 { get; set; }
public TwoItem2 TwoItem2 { get; set; }
[SqlSugar.SugarColumn(IsIgnore = true)]
public List<SubInsertTestItem2> SubInsertTestItem2 { get; set; }
public List<TwoItem3> TwoItem3 { get; set; }
}
public class SubInsertTestItem
public class TwoItem
{
[SqlSugar.SugarColumn(IsPrimaryKey = true, IsIdentity = true)]
public int Id { get; set; }
public int TestId { get; set; }
public int RootId { get; set; }
public string Name { get; set; }
}
public class SubInsertTestItem1
public class TwoItem2
{
public string a { get; set; }
[SqlSugar.SugarColumn(IsPrimaryKey = true)]
public string Id { get; set; }
public int RootId { get; set; }
[SqlSugar.SugarColumn(IsIgnore =true)]
public List<ThreeItem2> ThreeItem2 { get; set; }
}
public class SubInsertTestItem2
public class TwoItem3
{
public int OrderId { get; set; }
public int xid { get; set; }
public string a { get; set; }
[SqlSugar.SugarColumn(IsPrimaryKey = true)]
public int Id { get; set; }
public string Name { get; set; }
public string Desc { get; set; }
}
public class ThreeItem2
{
[SqlSugar.SugarColumn(IsPrimaryKey = true)]
public int Id { get; set; }
public string Name { get; set; }
public string TwoItem2Id { get; set; }
}
}

12
Src/Asp.Net/SqlSugar/Abstract/InsertableProvider/InsertableProvider.cs
View File

@ -262,20 +262,20 @@ namespace SqlSugar
{
return new SubInsertable<T>();
}
string subMemberName;
object sublist;
SubInsertable<T> result = new SubInsertable<T>();
result.GetList(this.InsertObjs,items, out subMemberName, out sublist);
result.InsertObjects = this.InsertObjs;
result.Context = this.Context;
result.SubList = new Dictionary<string, object>();
result.SubList.Add(subMemberName, sublist);
result.SubList = new List<SubInsertTreeExpression>();
result.SubList.Add(new SubInsertTreeExpression() { Expression= items });
result.InsertBuilder = this.InsertBuilder;
result.Pk = GetPrimaryKeys().First();
result.Entity = this.EntityInfo;
return result;
}
public ISubInsertable<T> AddSubList(Expression<Func<T, GetSubInsertTree>> tree)
{
return null;
}
#endregion

331
Src/Asp.Net/SqlSugar/Abstract/InsertableProvider/SubInserable.cs
View File

@ -10,176 +10,180 @@ namespace SqlSugar
public class SubInsertable<T> : ISubInsertable<T> where T : class, new()
{
internal EntityInfo Entity { get; set; }
internal Dictionary<string, object> SubList { get; set; }
internal List<SubInsertTreeExpression> SubList { get; set; }
internal SqlSugarProvider Context { get; set; }
internal T [] InsertObjects { get; set; }
internal T[] InsertObjects { get; set; }
internal InsertBuilder InsertBuilder { get; set; }
internal string Pk { get; set; }
public ISubInsertable<T> AddSubList(Expression<Func<T, object>> items)
{
if (InsertObjects != null&&InsertObjects.Count() > 0)
{
string subMemberName;
object sublist;
GetList(InsertObjects, items, out subMemberName, out sublist);
if (!this.SubList.ContainsKey(subMemberName))
{
this.SubList.Add(subMemberName, sublist);
if (this.SubList == null)
this.SubList = new List<SubInsertTreeExpression>();
this.SubList.Add(new SubInsertTreeExpression() { Expression = items });
return this;
}
public ISubInsertable<T> AddSubList(Expression<Func<T, GetSubInsertTree>> tree)
{
var lamda = (tree as LambdaExpression);
var memInit = lamda.Body as MemberInitExpression;
if (memInit.Bindings != null)
{
MemberAssignment memberAssignment = (MemberAssignment)memInit.Bindings[0];
SubList.Add(new SubInsertTreeExpression() {
Expression= memberAssignment.Expression,
Childs= GetSubInsertTree(((MemberAssignment)memInit.Bindings[1]).Expression)
});
}
return this;
}
private List<SubInsertTreeExpression> GetSubInsertTree(Expression expression)
{
List<SubInsertTreeExpression> resul = new List<SubInsertTreeExpression>();
if (expression is ListInitExpression)
{
ListInitExpression exp = expression as ListInitExpression;
foreach (var item in exp.Initializers)
{
SubInsertTreeExpression tree = new SubInsertTreeExpression();
var memInit = item.Arguments[0] as MemberInitExpression;
if (memInit.Bindings != null)
{
MemberAssignment memberAssignment = (MemberAssignment)memInit.Bindings[0];
tree.Expression = memberAssignment.Expression;
}
resul.Add(tree);
}
}
else
{
}
return resul;
}
public object ExecuteReturnPrimaryKey()
{
if (InsertObjects != null && InsertObjects.Count()>0)
{
int count = 1;
foreach (var InsertObject in InsertObjects)
{
List<ConditionalModel> conModel = new List<ConditionalModel>();
int id = this.Context.Insertable(InsertObject).ExecuteReturnIdentity();
object pkValue = null;
var qureyable = this.Context.Queryable<T>();
if (id.ObjToInt() == 0)
{
var primaryProperty = this.Entity.Columns.FirstOrDefault(it =>
it.PropertyName.Equals(this.Pk, StringComparison.CurrentCultureIgnoreCase) ||
it.DbColumnName.Equals(this.Pk, StringComparison.CurrentCultureIgnoreCase)
);
pkValue = primaryProperty.PropertyInfo.GetValue(InsertObject);
qureyable.In(pkValue);
}
else
{
qureyable.In(id);
pkValue = id;
}
var data = qureyable.First();
foreach (var item in this.SubList)
{
Dictionary<string, object> insertDictionary = new Dictionary<string, object>();
if (item.Value == null)
{
continue;
}
EntityInfo subEntity = null;
if (item.Value is IEnumerable<object>)
{
var list = item.Value as IEnumerable<object>;
if (list.Count() == 0)
{
continue;
}
var type = list.First().GetType();
this.Context.InitMappingInfo(type);
subEntity = this.Context.EntityMaintenance.GetEntityInfo(type);
foreach (var sbItem in list)
{
SetItems(insertDictionary, sbItem, subEntity, item.Key, pkValue);
}
}
else if (item.Value.GetType().IsClass())
{
var type = item.Value.GetType();
this.Context.InitMappingInfo(type);
subEntity = this.Context.EntityMaintenance.GetEntityInfo(type);
SetItems(insertDictionary, item.Value, subEntity, item.Key, pkValue);
}
count += this.Context.Insertable(insertDictionary).AS(subEntity.DbTableName).ExecuteCommand();
}
}
return count;
}
else
{
return 0;
}
}
public async Task<object> ExecuteReturnPrimaryKeyAsync()
{
if (InsertObjects != null && InsertObjects.Count() > 0)
{
int count = 1;
var isIdEntity = IsIdEntity(this.Entity);
if (!isIdEntity)
{
this.Context.Insertable(InsertObjects).ExecuteCommand();
}
foreach (var InsertObject in InsertObjects)
{
List<ConditionalModel> conModel = new List<ConditionalModel>();
int id = await this.Context.Insertable(InsertObject).ExecuteReturnIdentityAsync();
object pkValue = null;
var qureyable = this.Context.Queryable<T>();
if (id.ObjToInt() == 0)
int id = 0;
if (isIdEntity)
{
var primaryProperty = this.Entity.Columns.FirstOrDefault(it =>
it.PropertyName.Equals(this.Pk, StringComparison.CurrentCultureIgnoreCase) ||
it.DbColumnName.Equals(this.Pk, StringComparison.CurrentCultureIgnoreCase)
);
pkValue = primaryProperty.PropertyInfo.GetValue(InsertObject);
qureyable.In(pkValue);
id = this.Context.Insertable(InsertObject).ExecuteReturnIdentity();
}
else
{
qureyable.In(id);
pkValue = id;
var pk = GetPrimaryKey(this.Entity,InsertObject, id);
AddChildList(this.SubList, InsertObject, pk);
}
var data =await qureyable.FirstAsync();
foreach (var item in this.SubList)
{
Dictionary<string, object> insertDictionary = new Dictionary<string, object>();
if (item.Value == null)
{
continue;
}
EntityInfo subEntity = null;
if (item.Value is IEnumerable<object>)
{
var list = item.Value as IEnumerable<object>;
if (list.Count() == 0)
{
continue;
}
var type = list.First().GetType();
this.Context.InitMappingInfo(type);
subEntity = this.Context.EntityMaintenance.GetEntityInfo(type);
foreach (var sbItem in list)
{
SetItems(insertDictionary, sbItem, subEntity, item.Key, pkValue);
}
}
else if (item.Value.GetType().IsClass())
{
var type = item.Value.GetType();
this.Context.InitMappingInfo(type);
subEntity = this.Context.EntityMaintenance.GetEntityInfo(type);
SetItems(insertDictionary, item.Value, subEntity, item.Key, pkValue);
}
count +=await this.Context.Insertable(insertDictionary).AS(subEntity.DbTableName).ExecuteCommandAsync();
}
}
return count;
return InsertObjects.Count();
}
else
{
return 0;
}
}
public Task<object> ExecuteReturnPrimaryKeyAsync()
{
return Task.FromResult(ExecuteReturnPrimaryKey());
}
private bool IsIdEntity(EntityInfo entity)
{
return entity.Columns.Where(it => it.IsIdentity).Count() > 0;
}
private void AddChildList(List<SubInsertTreeExpression> items, object insertObject, object pkValue)
{
if (items != null)
{
foreach (var item in items)
{
MemberExpression subMemberException;
string subMemberName = GetMemberName(item, out subMemberException);
string childName = GetChildName(item, subMemberException);
var childList = insertObject.GetType().GetProperty(childName).GetValue(insertObject);
if (childList != null)
{
if (!(childList is IEnumerable<object>))
{
childList = new List<object>() { childList };
}
if (!string.IsNullOrEmpty(subMemberName) &&subMemberName!=childName)
{
foreach (var child in childList as IEnumerable<object>)
{
child.GetType().GetProperty(subMemberName).SetValue(child, pkValue);
}
}
var type = (childList as IEnumerable<object>).First().GetType();
this.Context.InitMappingInfo(type);
var entityInfo = this.Context.EntityMaintenance.GetEntityInfo(type);
var isIdentity = IsIdEntity(entityInfo);
var tableName = entityInfo.DbTableName;
List<Dictionary<string, object>> insertList = new List<Dictionary<string, object>>();
var entityList = (childList as IEnumerable<object>).ToList();
foreach (var child in entityList)
{
insertList.Add(GetInsertDictionary(child, entityInfo));
}
if (!isIdentity)
{
this.Context.Insertable(insertList).AS(tableName).ExecuteCommand();
}
int i = 0;
foreach (var insert in insertList)
{
int id = 0;
if (isIdentity)
{
id = this.Context.Insertable(insert).AS(tableName).ExecuteReturnIdentity();
}
var entity = entityList[i];
var pk = GetPrimaryKey(entityInfo,entity, id);
AddChildList(item.Childs, entity, pk);
++i;
}
}
}
}
}
private Dictionary<string, object> GetInsertDictionary(object insetObject, EntityInfo subEntity)
{
Dictionary<string, object> insertDictionary = new Dictionary<string, object>();
foreach (var item in subEntity.Columns)
{
if (item.IsIdentity || item.IsIgnore)
{
}
public void GetList(T[] inserts,Expression<Func<T, object>> items, out string subMemberName, out object sublist)
else if (!string.IsNullOrEmpty(item.OracleSequenceName) && this.Context.CurrentConnectionConfig.DbType == DbType.Oracle)
{
var lambdaExpression = (items as LambdaExpression).Body;
if (lambdaExpression is UnaryExpression)
{
lambdaExpression = (lambdaExpression as UnaryExpression).Operand;
var value = "{SugarSeq:=}" + item.OracleSequenceName + ".nextval{SugarSeq:=}";
insertDictionary.Add(item.DbColumnName, value);
continue;
}
MemberExpression subMemberException = lambdaExpression as MemberExpression;
subMemberName = subMemberException.Member.Name;
else
{
insertDictionary.Add(item.DbColumnName, item.PropertyInfo.GetValue(insetObject));
}
}
return insertDictionary;
}
private static string GetChildName(SubInsertTreeExpression item, MemberExpression subMemberException)
{
string childName;
MemberExpression listMember = null;
sublist = null;
if (subMemberException.Expression is MethodCallExpression)
{
listMember = (subMemberException.Expression as MethodCallExpression).Arguments.First() as MemberExpression;
@ -191,32 +195,47 @@ namespace SqlSugar
}
if (listMember == null)
{
listMember = (items as LambdaExpression).Body as MemberExpression;
subMemberName = Guid.NewGuid().ToString();
listMember = (item.Expression as LambdaExpression).Body as MemberExpression;
}
sublist = inserts.First().GetType().GetProperty(listMember.Member.Name).GetValue(inserts.First());
childName = listMember.Member.Name;
return childName;
}
private void SetItems(Dictionary<string, object> insertDictionary, object sbItem, EntityInfo subEntity,string key,object pkValue)
private static string GetMemberName(SubInsertTreeExpression item, out MemberExpression subMemberException)
{
foreach (var item in subEntity.Columns)
string subMemberName = null;
Expression lambdaExpression;
if (item.Expression is LambdaExpression)
{
if (item.IsIdentity||item.IsIgnore)
continue;
if (!string.IsNullOrEmpty(item.OracleSequenceName)&&this.Context.CurrentConnectionConfig.DbType==DbType.Oracle)
{
var value = "{SugarSeq:=}"+item.OracleSequenceName+ ".nextval{SugarSeq:=}";
insertDictionary.Add(item.DbColumnName, value);
continue;
}
if (item.PropertyInfo.Name == key)
{
insertDictionary.Add(item.DbColumnName, pkValue);
lambdaExpression = (item.Expression as LambdaExpression).Body;
}
else
{
insertDictionary.Add(item.DbColumnName, item.PropertyInfo.GetValue(sbItem));
lambdaExpression = item.Expression;
}
if (lambdaExpression is UnaryExpression)
{
lambdaExpression = (lambdaExpression as UnaryExpression).Operand;
}
subMemberException = lambdaExpression as MemberExpression;
subMemberName = subMemberException.Member.Name;
return subMemberName;
}
private object GetPrimaryKey(EntityInfo entityInfo,object InsertObject, int id)
{
object pkValue;
if (id.ObjToInt() == 0)
{
var primaryProperty = entityInfo.Columns.FirstOrDefault(it => it.IsPrimarykey);
pkValue = primaryProperty.PropertyInfo.GetValue(InsertObject);
}
else
{
pkValue = id;
}
return pkValue;
}
}
}

21
Src/Asp.Net/SqlSugar/Entities/SubInsertTree.cs Normal file
View File

@ -0,0 +1,21 @@
using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;
namespace SqlSugar
{
public class GetSubInsertTree
{
public object Expression { get; set; }
public List<GetSubInsertTree> ChildExpression { get; set; }
}
internal class SubInsertTreeExpression
{
public Expression Expression { get; set; }
public List<SubInsertTreeExpression> Childs { get; set; }
}
}

1
Src/Asp.Net/SqlSugar/Interface/ISubInsertable.cs
View File

@ -6,6 +6,7 @@ namespace SqlSugar
public interface ISubInsertable<T>
{
ISubInsertable<T> AddSubList(Expression<Func<T, object>> items);
ISubInsertable<T> AddSubList(Expression<Func<T, GetSubInsertTree>> tree);
object ExecuteReturnPrimaryKey();
}
}

3
Src/Asp.Net/SqlSugar/Interface/Insertable.cs
View File

@ -29,7 +29,8 @@ namespace SqlSugar
IInsertable<T> IgnoreColumns(params string[]columns);
IInsertable<T> IgnoreColumns(bool ignoreNullColumn, bool isOffIdentity = false);
ISubInsertable<T> AddSubList(Expression<Func<T, object>> SubForeignKey);
ISubInsertable<T> AddSubList(Expression<Func<T, object>> subForeignKey);
ISubInsertable<T> AddSubList(Expression<Func<T, GetSubInsertTree>> tree);
IInsertable<T> EnableDiffLogEvent(object businessData = null);
IInsertable<T> RemoveDataCache();

1
Src/Asp.Net/SqlSugar/SqlSugar.csproj
View File

@ -88,6 +88,7 @@
<Compile Include="Abstract\FilterProvider\FilterProvider.cs" />
<Compile Include="Abstract\InsertableProvider\InsertableProvider.cs" />
<Compile Include="Abstract\DeleteProvider\DeleteableProvider.cs" />
<Compile Include="Entities\SubInsertTree.cs" />
<Compile Include="Infrastructure\KdbndpInserttable.cs" />
<Compile Include="Interface\ISubInsertable.cs" />
<Compile Include="Abstract\InsertableProvider\SubInserable.cs" />