public JsonController(IIdentityService identityService, ITableMapper tableMapper, DbContext _db)
{
db = _db;
_tableMapper = tableMapper;
_identitySvc = identityService;
selectTable = new SelectTable(_identitySvc, _tableMapper, _db.Db);
}
/// <summary>
/// 创建实体对象
/// </summary>
/// <param name="reader">数据流</param>
/// <param name="columnNames">查询的列</param>
/// <returns>实体对象</returns>
private object CreateEntity(IDataReader reader, string[] columnNames)
{
ITableMapper tableMapper = base.MapperContainer.GetTableMapper(typeof(TEntity));
AccessorLinker[] accessorLinkers = this.PropertyLinkers.Select(l => l.ToAccessorLinker(base.MapperContainer)).ToArray();
return(this.objectAccessor.CreateEntity(tableMapper, reader, columnNames, accessorLinkers));
}
/// <summary>
/// 扩展方法: 获取Column元数据解析器
/// </summary>
/// <param name="mapperContainer">Mapper容器</param>
/// <param name="memberExpression">指定对象成员的表达式</param>
/// <returns>Column元数据解析器</returns>
public static IColumnMapper GetColumnMapper(this IMapperContainer mapperContainer, MemberExpression memberExpression)
{
//获取当前实体类型的Table元数据解析器
ITableMapper tableMapper = mapperContainer.GetTableMapper(memberExpression.Expression.Type);
//获取Column元数据解析器
return(tableMapper.GetColumnMapper(memberExpression.Member.Name));
}
/// <summary>
/// 创建TElement类型的对象
/// </summary>
/// <param name="reader">数据流</param>
/// <param name="columnNames">查询的列</param>
/// <returns>实体对象</returns>
private TElement CreateElement(IDataReader reader, string[] columnNames)
{
ITableMapper tableMapper = base.MapperContainer.GetTableMapper(typeof(TEntity));
AccessorLinker[] accessorLinkers = this.PropertyLinkers.Select(l => l.ToAccessorLinker(base.MapperContainer)).ToArray();
TEntity entity = this.entityAccessor.CreateEntity(tableMapper, reader, columnNames, accessorLinkers) as TEntity;
return(this.Convert(entity));
}
public DataProcessor(ITableMapper tableMapper,
ITableDataBatchWriter batchWriter = null,
int batchSize = 10000)
{
TableMap = new TableMap();
TableMapper = tableMapper;
BatchSize = batchSize;
BatchWriter = batchWriter;
}
public DataProcessor(ITableMapper tableMapper,
ITableDataBatchWriter batchWriter = null,
int batchSize = 10000)
{
TableMap = new TableMap();
TableMapper = tableMapper;
BatchSize = batchSize;
BatchWriter = batchWriter;
}
/// <summary>
/// Internal Extendable method: 创建实体对象
/// </summary>
/// <param name="objectAccessor">实体对象访问器</param>
/// <param name="tableMapper">Table元数据解析器</param>
/// <param name="reader">数据流</param>
/// <param name="columnNames">查询结果列的数组</param>
/// <returns>实体对象</returns>
internal static object CreateEntity(this ObjectAccessor objectAccessor, ITableMapper tableMapper, IDataReader reader, string[] columnNames)
{
//创建对象
object entity = objectAccessor.CreateInstance();
//读取DataReader当前行,为entity各个属性赋值
objectAccessor.Fill(tableMapper.GetColumnMappers(), reader, columnNames, entity);
//返回对象
return(entity);
}
/// <summary>
/// Creates a child scope under this scope with indices associated with the <see cref="ITableMapper"/> specified
/// </summary>
/// <param name="owner">The table mapper to associate with the child scope</param>
/// <returns></returns>
public ProcessingScope CreateChildScope(ITableMapper owner)
{
ProcessingScope childScope;
if (!_children.TryGetValue(owner, out childScope))
{
_children.Add(owner, childScope = new ProcessingScope(this));
}
childScope.CurrentObject = null;
return(childScope);
}
/// <summary>
/// Internal Extendable method: 创建实体对象
/// </summary>
/// <param name="objectAccessor">实体对象访问器</param>
/// <param name="tableMapper">Table元数据解析器</param>
/// <param name="reader">数据流</param>
/// <param name="columnNames">查询结果列的数组</param>
/// <param name="accessorLinkers">对象关联属性数组</param>
/// <returns>实体对象</returns>
internal static object CreateEntity(this ObjectAccessor objectAccessor, ITableMapper tableMapper, IDataReader reader, string[] columnNames, AccessorLinker[] accessorLinkers)
{
//创建对象
object entity = objectAccessor.CreateEntity(tableMapper, reader, columnNames);
//遍历关联关系,为对象关联实体类型的属性赋值
foreach (AccessorLinker accessor in accessorLinkers)
{
object value = accessor.EntityAccessor.CreateEntity(accessor.TableMapper, reader, columnNames, accessor.AccessorLinkers);
objectAccessor.SetValue(accessor.PropertyName, entity, value);
}
//返回对象
return(entity);
}
/// <summary>
/// 获取Where节点的子sql表达式节点
/// </summary>
/// <param name="memberExpression">成员表达式</param>
/// <param name="rightSqlExpression">右边的sql条件表达式</param>
/// <returns>Where节点的子sql表达式节点</returns>
protected INodeBuilder GetWhereChildBuilder(MemberExpression memberExpression, string rightSqlExpression)
{
//若Mapper容器为空
if (_mapperContainer == null)
{
//则直接获取针对 WITH AS 临时表的sql表达式
return(new NodeBuilder(SqlType.Where, "t.{0} {1}", memberExpression.Member.Name, rightSqlExpression));
}
//若不为空,则获取针对实体类对应的表的sql表达式
// 获取当前实体类型的Table元数据解析器
ITableMapper tableMapper = _mapperContainer.GetTableMapper(memberExpression.Expression.Type);
// 获取columnMapper
IColumnMapper columnMapper = tableMapper.GetColumnMapper(memberExpression.Member.Name);
// 获取Where节点的子sql表达式节点
return(_commandTreeFactory.GetWhereChildBuilder(tableMapper.Header.TableAlias, columnMapper.ColumnName, rightSqlExpression));
}
/// <summary>
/// 获取基本类型的sql表达式节点
/// </summary>
/// <param name="memberExpression">成员表达式</param>
/// <returns>基本类型的sql表达式节点</returns>
protected ISqlBuilder GetColumnBuilder(MemberExpression memberExpression)
{
//若Mapper容器为空
if (_mapperContainer == null)
{
//则直接获取针对 WITH AS 临时表的sql表达式
return(new SqlBuilder("t.{0}", memberExpression.Member.Name));
}
//若不为空,则获取针对表的sql表达式
// 获取当前实体类型的Table元数据解析器
ITableMapper tableMapper = _mapperContainer.GetTableMapper(memberExpression.Expression.Type);
// 获取columnMapper
IColumnMapper columnMapper = tableMapper.GetColumnMapper(memberExpression.Member.Name);
// 获取sql列节点生成器
return(_commandTreeFactory.GetColumnBuilder(tableMapper.Header.TableAlias, columnMapper.ColumnName));
}
private TableMapping(Type type, CreateFlags createFlags = CreateFlags.None)
{
CreateFlags = createFlags;
var typeInfo = type.GetTypeInfo();
var mapperAttr = (TableMapperAttribute)typeInfo.GetCustomAttributes(typeof(TableMapperAttribute), true).FirstOrDefault();
var mapperType = mapperAttr != null ? mapperAttr.Mapper : typeof(DefaultTableMapper);
_mapper = Activator.CreateInstance(mapperType) as ITableMapper;
if (_mapper == null)
{
throw new Exception($"{mapperType.Name} is not of type {nameof(ITableMapper)}.");
}
Schema = _mapper.GetSchema(type);
var schemaInfo = Schema.GetTypeInfo();
var tableAttr = schemaInfo.GetCustomAttributes().OfType <TableAttribute>().FirstOrDefault();
TableName = (tableAttr != null && !string.IsNullOrEmpty(tableAttr.Name)) ? tableAttr.Name : Schema.Name;
WithoutRowId = tableAttr != null ? tableAttr.WithoutRowId : false;
Columns = _mapper.GetColumns(type, createFlags).ToArray();
foreach (var c in Columns)
{
if (c.IsAutoInc && c.IsPK)
{
_autoPk = c;
}
if (c.IsPK)
{
PK = c;
}
}
HasAutoIncPK = _autoPk != null;
GetByPrimaryKeySql = PK != null
? $"select * from \"{TableName}\" where \"{PK.Name}\" = ?"
: $"select * from \"{TableName}\" limit 1";
}
public SelectTable(IIdentityService identityService, ITableMapper tableMapper, DbContext _db)
{
_identitySvc = identityService;
_tableMapper = tableMapper;
db = _db;
}
public TableDal(ITableMapper tableMapper, IDalHelper dalHelper)
{
_tableMapper = tableMapper;
_dalHelper = dalHelper;
}
public TableDal(ITableMapper tableMapper, IDalHelper dalHelper)
{
_tableMapper = tableMapper;
_dalHelper = dalHelper;
}
public void Init()
{
_mapper = new TableMapper();
}
public void Init()
{
_mapper = new TableMapper();
}
/// <summary>
///
/// </summary>
/// <param name="identityService"></param>
/// <param name="tableMapper"></param>
/// <param name="dbClient"></param>
public SelectTable(IIdentityService identityService, ITableMapper tableMapper, SqlSugarClient dbClient)
{
_identitySvc = identityService;
_tableMapper = tableMapper;
db = dbClient;
}
/// <summary>
/// 为当前实体所Mapping的Table添加没有添加的列
/// </summary>
/// <param name="dbHelper">操作数据库的Helper对象</param>
/// <param name="commandTreeFactory">创建CommandTree的工厂</param>
/// <param name="tableMapper">Table元数据解析器</param>
public void AlterTableAddColumns(DbHelper dbHelper, ICommandTreeFactory commandTreeFactory, ITableMapper tableMapper)
{
//获取当前实体元数据解析器中某些属性Mapping的Column未包含在Table中的属性对应的ColumnMapper,并转换获取Column节点
string[] columnNames = this.GetColumns(dbHelper, tableMapper.Header).ToArray();
IColumnNode[] columnNodes = (from columnMapper
in tableMapper.GetColumnMappers()
where !columnNames.Contains(columnMapper.ColumnName)
select columnMapper.ToColumnNode()).ToArray();
//若实体元数据解析器中所有属性Mapping的列都在当前Table中,直接退出
if (columnNodes.Length == 0)
{
return;
}
//获取TableHeader
ITableHeader tableHeader = tableMapper.Header;
//创建Alter Table Columns语句生成树
ICommandTree alterTableAddColumnsTree = commandTreeFactory.GetAlterTableAddColumnsTree(tableHeader.SchemaName, tableHeader.TableName, columnNodes);
//生成并执行Alter Table Columns语句，为当前实体Mapping的Table添加为注册的列
dbHelper.ExecuteUpdate(alterTableAddColumnsTree.Compile());
}
/// <summary>
/// 创建表
/// </summary>
/// <param name="dbHelper">操作数据库的Helper</param>
/// <param name="commandTreeFactory">创建CommandTree的工厂</param>
/// <param name="tableMapper">Table元数据解析器</param>
public int CreateTable(DbHelper dbHelper, ICommandTreeFactory commandTreeFactory, ITableMapper tableMapper)
{
//获取TableHeader
ITableHeader tableHeader = tableMapper.Header;
//获取ColumnNodes
IEnumerable <IColumnNode> columnNodes = tableMapper.GetColumnMappers().Select(m => m.ToColumnNode());
//获取建表语句生成树
ICommandTree buildTableTree = commandTreeFactory.GetBuildTableTree(tableHeader.SchemaName, tableHeader.TableName, columnNodes);
//创建建表语句并执行
return(dbHelper.ExecuteUpdate(buildTableTree.Compile()));
}
public static TableDefinition Map(this TableDefinition def, ITableMapper table)
{
def.TableMappers.Add(table);
return(def);
}
