Fireasy.Data系列——数据库架构的整合查询

      在Ado.Net中，DbConnection类的GetSchema方法用于获取数据库提供者的相关架构信息，比如数据类型、表、列等等，然而每种数据库架构的元数据结构都是不一样的。Fireasy.Data提供了一个扩展服务接口，以将四类数据库的架构信息整合在一起，统一定义了最大公有的架构元数据，并在此基础上提供Linq查询的支持。

 

      一、架构元数据的接口

      由于要使用统一的查询，因此需要定义一个标识接口，然后使不同的架构元数据类来实现它。

 

    /// <summary>
    /// 数据库架构元数据结构。
    /// </summary>
    public interface ISchemaMetadata
    {
    }

 

      二、架构集合的枚举

      首先定义要支持的架构的类别，基本上每一种数据库都支持以下的这些集合名称。

 

    /// <summary>
    /// 数据库架构集合的类别。
    /// </summary>
    public enum SchemaCategory
    {
        /// <summary>
        /// 所有定义的列的有关信息。
        /// </summary>
        Columns,
        /// <summary>
        /// 所支持的数据类型的有关信息。
        /// </summary>
        DataTypes,
        /// <summary>
        /// 所有定义的外键的有关信息。
        /// </summary>
        ForeignKeys,
        /// <summary>
        /// 作为索引的列的有关信息。
        /// </summary>
        Indexes,
        /// <summary>
        /// 所有定义的索引相关列的有关信息。
        /// </summary>
        IndexColumns,
        /// <summary>
        /// 所有架构集合的有关信息。 
        /// </summary>
        MetaDataCollections,
        /// <summary>
        /// 所有定义的存储过程的有关信息。
        /// </summary>
        Procedures,
        /// <summary>
        /// 存储过程中所有参数的有关信息。
        /// </summary>
        ProcedureParameters,
        /// <summary>
        /// 数据库公开所保留的关键字的有关信息。
        /// </summary>
        ReservedWords,
        /// <summary>
        /// 所支持的限制的有关信息。
        /// </summary>
        Restrictions,
        /// <summary>
        /// 所有定义的表的有关信息。
        /// </summary>
        Tables,
        /// <summary>
        /// 数据库所定义的用户的有关信息。
        /// </summary>
        Users,
        /// <summary>
        /// 所有定义的视图的有关信息。
        /// </summary>
        Views,
        /// <summary>
        /// 视图所定义的列的有关信息。
        /// </summary>
        ViewColumns
    }

 

       三、架构元数据类

       有了以上两个后，就可以定义具体的架构元数据类了，比如Table：

 

    /// <summary>
    /// 数据库表信息。
    /// </summary>
    [SchemaCategory(SchemaCategory.Tables)]
    public sealed class Table : ISchemaMetadata
    {
        /// <summary>
        /// 获取分录名称。
        /// </summary>
        [SchemaQueryableAttribute(0, ProviderType.MsSql)]
        [SchemaQueryableAttribute(0, ProviderType.SQLite)]
        [SchemaQueryableAttribute(0, ProviderType.MySql)]
        public string TableCatalog { get; internal set; }

        /// <summary>
        /// 获取架构名称。
        /// </summary>
        [SchemaQueryableAttribute(1, ProviderType.MsSql)]
        [SchemaQueryableAttribute(0, ProviderType.Oracle)]
        [SchemaQueryableAttribute(1, ProviderType.MySql)]
        public string TableSchema { get; internal set; }

        /// <summary>
        /// 获取表名称。
        /// </summary>
        [SchemaQueryableAttribute(2, ProviderType.MsSql)]
        [SchemaQueryableAttribute(1, ProviderType.Oracle)]
        [SchemaQueryableAttribute(2, ProviderType.SQLite)]
        [SchemaQueryableAttribute(2, ProviderType.MySql)]
        public string TableName { get; internal set; }

        /// <summary>
        /// 获取表类型。
        /// </summary>
        [SchemaQueryableAttribute(3, ProviderType.MsSql)]
        [SchemaQueryableAttribute(3, ProviderType.SQLite)]
        [SchemaQueryableAttribute(3, ProviderType.MySql)]
        public string TableType { get; internal set; }

        /// <summary>
        /// 获取表的描述。
        /// </summary>
        public string Description { get; internal set; }
    }

        在以上的代码中，分别用到了两个特性，SchemaCategoryAttribute标识了该类所属的架构类别，使用特性的目的，在于避免使用字符串，这个将在后面介绍。

        另一个特性SchemaQueryableAttribute特性则是定义了元数据属性在查询限制数组中的索引位置，因为每一种数据库类型对于同一个属性所限制的位置是不同的，因此需要为每一种数据库类别定义一个特性。

 

        四、架构扩展服务类

        首先定义一个抽象类，对底层的处理进行封装，然后开放每一类架构的信息获取方法出来，不同的数据库类型再进行重写，以使信息之间一一对应。

 

    /// <summary>
    /// 一个抽象类，提供获取数据库架构的方法。
    /// </summary>
    public abstract class BaseSchema : ISchemaProvider
    {
        /// <summary>
        /// 获取或设置提供者服务的上下文。
        /// </summary>
        public ServiceContext ServiceContext { get; set; }

        /// <summary>
        /// 获取指定类型的数据库架构信息。
        /// </summary>
        /// <typeparam name="T">架构信息的类型。</typeparam>
        /// <param name="predicate">用于测试架构信息是否满足条件的函数。</param>
        /// <returns></returns>
        public virtual IEnumerable<T> GetSchemas<T>(Expression<Func<T, bool>> predicate = null) where T : ISchemaMetadata
        {
            var category = GetSchemaCategory<T>();
            var restrictionValues = SchemaQueryTranslator.GetRestriction(ServiceContext.Database.Provider.ProviderType, typeof(T), predicate);
            DataTable table;

            using (var connection = ServiceContext.Database.CreateConnection())
            {
                var collectionName = GetSchemaCategoryName(category);
                try
                {
                    connection.TryOpen();
                    table = connection.GetSchema(collectionName, InitRestrictionValues(connection, category, restrictionValues));
                }
                catch (Exception ex)
                {
                    throw new SchemaNotSupportedtException(collectionName, ex);
                }
                finally
                {
                    connection.TryClose();
                }
            }
            return ReturnSchemaElements<T>(category, table);
        }

        /// <summary>
        /// 获取指定类型的数据库架构信息。
        /// </summary>
        /// <param name="collectionName">架构信息类别名称。</param>
        /// <param name="restrictionValues">列限制数组。</param>
        /// <returns></returns>
        public virtual DataTable GetSchema(string collectionName, string[] restrictionValues)
        {
            DataTable table;
            using (var connection = ServiceContext.Database.CreateConnection())
            {
                connection.TryOpen();
                table = connection.GetSchema(collectionName, restrictionValues);
                connection.TryClose();
            }
            return table;
        }
    }

        在以上的代码中，第一步：使用GetSchemaCategoryName方法获得Ado.Net中所支持集合名称，如Tables、Columns。

 

        /// 获取架构的名称。
        /// </summary>
        /// <param name="category">架构信息类别。</param>
        /// <returns></returns>
        protected virtual string GetSchemaCategoryName(SchemaCategory category)
        {
            return category.ToString();
        }

 

         如果集合名称不是使用枚举的名称，则在具体的子类中重写这个方法指定就可以了。

 

         第二步，使用SchemaQueryTranslator类对传入的Linq查询表达式进行解析，得到原生的restrictionValues，这个数组作为connection.GetSchema方法的第二个参数传入。

 

         第三步，对查询得到的DataTable进行解析，返回我们需要的IEnumerable<T>序列：

 

        private IEnumerable<T> ReturnSchemaElements<T>(SchemaCategory category, DataTable table)
        {
            IEnumerable @enum = null;
            switch (category)
            {
                case SchemaCategory.Columns:
                    @enum = GetColumns(table, null);
                    break;
                case SchemaCategory.DataTypes:
                    @enum = GetDataTypes(table, null);
                    break;
                case SchemaCategory.ForeignKeys:
                    @enum = GetForeignKeys(table, null);
                    break;
                case SchemaCategory.IndexColumns:
                    @enum = GetIndexColumns(table, null);
                    break;
                case SchemaCategory.Indexes:
                    @enum = GetIndexs(table, null);
                    break;
                case SchemaCategory.MetaDataCollections:
                    @enum = GetMetaDataCollections(table, null);
                    break;
                case SchemaCategory.ProcedureParameters:
                    @enum = GetProcedureParameters(table, null);
                    break;
                case SchemaCategory.Procedures:
                    @enum = GetProcedures(table, null);
                    break;
                case SchemaCategory.ReservedWords:
                    @enum = GetReservedWords(table, null);
                    break;
                case SchemaCategory.Restrictions:
                    @enum = GetRestrictions(table, null);
                    break;
                case SchemaCategory.Tables:
                    @enum = GetTables(table, null);
                    break;
                case SchemaCategory.Users:
                    @enum = GetUsers(table, null);
                    break;
                case SchemaCategory.ViewColumns:
                    @enum = GetViewColumns(table, null);
                    break;
                case SchemaCategory.Views:
                    @enum = GetViews(table, null);
                    break;
            }

            if (@enum != null)
            {
                foreach (var item in @enum)
                {
                    yield return (T)item;
                }
            }
        }

        每一个初始架构信息的方法都定义成了虚方法了，因此在子类中还可以进行信息的转换，就象在OracleSchema中，我们可以对Table的信息进行丰富，增加了获取表描述信息的提取：

 

        /// <summary>
        /// 获取 <see cref="Table"/> 元数据序列。
        /// </summary>
        /// <param name="table">架构信息的表。</param>
        /// <param name="action">用于填充元数据的方法。</param>
        /// <returns></returns>
        protected override IEnumerable<Table> GetTables(DataTable table, Action<Table, DataRow> action)
        {
            foreach (DataRow row in table.Rows)
            {
                var item = new Table
                    {
                        TableSchema = row["OWNER"].ToString(),
                        TableName = row["TABLE_NAME"].ToString(),
                        TableType = row["TYPE"].ToString()
                    };
                item.Description = OracleSchemaHelper.GetTableDescription(ServiceContext.Database, item.TableSchema, item.TableSchema);

                if (action != null)
                {
                    action(item, row);
                }
                yield return item;
            }
        }

 

        五、架构查询的表达式解析类

        其实本篇的重点在于此类，它对传入查询的表达式进行解析，并返回一个限制数组，如果你对表达式有所了解，相信一看就明白其中的原理了。

 

    internal sealed class SchemaQueryTranslator : Common.Linq.Expressions.ExpressionVisitor
    {
        private Dictionary<int, string> m_dic;
        private int m_index = -1;
        private int m_maxIndex;
        private readonly Type m_metadataType;
        private readonly ProviderType m_providerType;

        public SchemaQueryTranslator(ProviderType providerType, Type metadataType)
        {
            m_providerType = providerType;
            m_metadataType = metadataType;
            InitDictionary();
        }

        /// <summary>
        /// 对表达式进行解析，并返回限制数组。
        /// </summary>
        /// <param name="providerType">数据提供者类别。</param>
        /// <param name="metadataType">架构元数组类型。</param>
        /// <param name="expression">查询表达式。</param>
        /// <returns></returns>
        public static string[] GetRestriction(ProviderType providerType, Type metadataType, Expression expression)
        {
            var translator = new SchemaQueryTranslator(providerType, metadataType);
            return translator.GetRestrictionValues(expression);
        }

        private string[] GetRestrictionValues(Expression expression)
        {
            if (expression != null)
            {
                Visit(expression);
            }
            return TrimEmptyArray();
        }

        /// <summary>
        /// 初始化字典，找出架构元数据类中定义了 <see cref="SchemaQueryableAttribute"/> 特性的所有属性。
        /// </summary>
        private void InitDictionary()
        {
            m_dic = new Dictionary<int, string>();
            var properties = m_metadataType.GetProperties(BindingFlags.Public | BindingFlags.Instance);
            foreach (var property in properties)
            {
                var attribute = property.GetCustomAttributes<SchemaQueryableAttribute>().FirstOrDefault(s => s.ProviderType == m_providerType);
                if (attribute == null)
                {
                    continue;
                }
                //使用索引作为键值
                m_dic.Add(attribute.Index, null);
            }
        }

        /// <summary>
        /// 访问表达式树。
        /// </summary>
        /// <param name="expression"></param>
        /// <returns></returns>
        protected override Expression Visit(Expression expression)
        {
            switch (expression.NodeType)
            {
                case ExpressionType.MemberAccess:
                    return VisitMember((MemberExpression)expression);
                case ExpressionType.Equal:
                    return VisitBinary((BinaryExpression)expression);
                case ExpressionType.Constant:
                    return VisitConstant((ConstantExpression)expression);
            }
            return base.Visit(expression);
        }

        /// <summary>
        /// 访问二元运算表达式。
        /// </summary>
        /// <param name="binaryExp"></param>
        /// <returns></returns>
        protected override Expression VisitBinary(BinaryExpression binaryExp)
        {
            //属性在运算符的右边
            var memberExp = binaryExp.Right as MemberExpression;
            if (memberExp != null &&
                memberExp.Member.DeclaringType == m_metadataType)
            {
                Visit(binaryExp.Right);
                Visit(binaryExp.Left);
            }
            else
            {
                Visit(binaryExp.Left);
                Visit(binaryExp.Right);
            }
            //复位
            m_index = -1;
            return binaryExp;
        }

        protected override Expression VisitMember(MemberExpression memberExp)
        {
            //如果属性是架构元数据类的成员
            if (memberExp.Member.DeclaringType == m_metadataType)
            {
                var attribute = memberExp.Member.GetCustomAttributes<SchemaQueryableAttribute>().FirstOrDefault(s => s.ProviderType == m_providerType);
                if (attribute == null)
                {
                    throw new SchemaQueryNotSupportedException(memberExp.Member.Name);
                }
                //记录下当前的索引，以及目前的最大索引
                m_index = attribute.Index;
                m_maxIndex = Math.Max(m_maxIndex, m_index + 1);
                return memberExp;
            }
            else
            {
                //值或引用
                var exp = (Expression)memberExp;
                if (memberExp.Type.IsValueType)
                {
                    exp = Expression.Convert(memberExp, typeof(object));
                }
                var lambda = Expression.Lambda<Func<object>>(exp);
                var fn = lambda.Compile();
                //转换为常量表达式
                return Visit(Expression.Constant(fn(), memberExp.Type));
            }
        }

        protected override Expression VisitConstant(ConstantExpression constExp)
        {
            if (m_index == -1)
            {
                return constExp;
            }
            //没有复位的情况下，记录值
            m_dic[m_index] = constExp.Value.ToString();
            return constExp;
        }

        /// <summary>
        /// 删除空的数据元素
        /// </summary>
        /// <returns></returns>
        private string[] TrimEmptyArray()
        {
            //最大范围
            var array = new string[m_maxIndex];
            for (var i = 0; i < m_maxIndex; i++)
            {
                if (m_dic.ContainsKey(i))
                {
                    array[i] = m_dic[i];
                }
            }
            return array;
        }
    }

 

        六、测试

        没有条件的架构查询：

        [Test]
        public void GetTables()
        {
            Console.WriteLine(TimeWatcher.Watch(() =>
                InvokeTest(database =>
                    {
                        var schema = database.Provider.GetService<ISchemaProvider>();
                        foreach (var table in schema.GetSchemas<Table>())
                        {
                            PrintSchema(table);
                        }
                        Console.WriteLine();
                    })));
        }

        使用表达式的架构查询：

 

        [Test]
        public void GetTablesQuery()
        {
            Console.WriteLine(TimeWatcher.Watch(() =>
                InvokeTest(database =>
                    {
                        var schema = database.Provider.GetService<ISchemaProvider>();
                        foreach (var table in schema.GetSchemas<Table>(s => s.TableName == "products"))
                        {
                            PrintSchema(table);
                        }
                        Console.WriteLine();
                    })));
        }

 

         当然，虽然在一定程度上解决了架构查询的问题，但是仍然在于一些缺陷，主要表达在数据库之间一些微妙的差别，比如oracle的大小写敏感问题，以及它是使用owner，而sqlserver使用schema，因此还有改进的空间。