Пример #1
0
        public List <MetaInformationSchema> GetMetaInformationSchemaFromLists(List.InformationSchemaTable tables,
                                                                              List.InformationSchemaTableConstraint tableConstraints,
                                                                              List.InformationSchemaColumn tableColumns,
                                                                              List.InformationSchemaConstraintColumnUsage constraintColumnUsage)
        {
            List <MetaInformationSchema> allSchemas         = new List <MetaInformationSchema>();
            PredicateFunctions           predicateFunctions = new PredicateFunctions();

            if (tables != null)
            {
                foreach (Data.InformationSchemaTable table in tables)
                {
                    MetaInformationSchema oneSchema = new MetaInformationSchema();
                    oneSchema.MetaTable = table;

                    predicateFunctions.TableNameHolder = table.TableName;

                    if (tableConstraints != null)
                    {
                        oneSchema.MetaTableConstraints.AddRange(tableConstraints.FindAll(predicateFunctions.FindTableConstraintByTableName));
                    }
                    if (tableColumns != null)
                    {
                        oneSchema.MetaColumns.AddRange(tableColumns.FindAll(predicateFunctions.FindTableColumnByTableName));
                    }
                    if (constraintColumnUsage != null)
                    {
                        oneSchema.MetaConstraintColumnUsage.AddRange(constraintColumnUsage.FindAll(predicateFunctions.FindConstraintColumnUsageByTableName));
                    }
                    allSchemas.Add(oneSchema);
                }
            }
            return(allSchemas);
        }
        public MetaInformationSchema GetSchemaByTableName(string tableName, List <MetaInformationSchema> schemas)
        {
            MetaInformationSchema schema             = null;
            PredicateFunctions    predicateFunctions = new PredicateFunctions();

            predicateFunctions.TableNameHolder = tableName;
            schema = schemas.Find(predicateFunctions.FindMetaInformationSchemaByTableName);
            return(schema);
        }
Пример #3
0
        private void FillMetaColumnToConstraintColumnUsage()
        {
            PredicateFunctions predicateFunctions = new PredicateFunctions();

            foreach (Data.InformationSchemaColumn column in MetaColumns)
            {
                predicateFunctions.TableNameHolder  = column.TableName;
                predicateFunctions.ColumnNameHolder = column.ColumnName;
                List.InformationSchemaConstraintColumnUsage columnUsage =
                    new List.InformationSchemaConstraintColumnUsage();
                columnUsage.AddRange(this.MetaConstraintColumnUsage.FindAll(predicateFunctions.FindConstraintColumnUsageByColumnNameAndTableName));
                if (columnUsage.Count > 0)
                {
                    _metaColumnToConstraintColumnUsage.Add(column, columnUsage);
                }
            }
        }
Пример #4
0
        public MetaSprocSqlDependency GetMetaSprocSqlDependencyForOneSproc(List <MetaSqlDependency> dependenciesForSproc,
                                                                           string sprocName)
        {
            PredicateFunctions predicateFunctions  = new PredicateFunctions();
            string             sprocTypeString     = Constants.MetaSqlOrSprocDependencyConstants.STORED_PROCEDURE_TYPE;
            string             userTableTypeString = Constants.MetaSqlOrSprocDependencyConstants.USER_TABLE_TYPE;

            List.MetaSqlDependency sprocTypeDependencies     = new List.MetaSqlDependency();
            List.MetaSqlDependency userTableTypeDependencies = new List.MetaSqlDependency();
            Dictionary <string, List <MetaSqlDependency> > listOfUserTableToColumnsReferenced =
                new Dictionary <string, List <MetaSqlDependency> >();
            List <string> distinctUserTablesList = new List <string>();

            predicateFunctions.ReferencedTypeHolder = sprocTypeString;

            sprocTypeDependencies.AddRange(dependenciesForSproc.FindAll(predicateFunctions.FindMetaSqlDependenciesByReferencedType));

            predicateFunctions.ReferencedTypeHolder = userTableTypeString;

            userTableTypeDependencies.AddRange(dependenciesForSproc.FindAll(predicateFunctions.FindMetaSqlDependenciesByReferencedType));

            if (userTableTypeDependencies.Count > 0)
            {
                distinctUserTablesList = GetDistinctUserTableList(userTableTypeDependencies);
                foreach (string distinctUserTableName in distinctUserTablesList)
                {
                    List <MetaSqlDependency> columnsReferenced = new List <MetaSqlDependency>();
                    predicateFunctions.ReferencedObjectHolder = distinctUserTableName;
                    columnsReferenced.AddRange(userTableTypeDependencies.FindAll(predicateFunctions.FindMetaSqlDependenciesByReferencedObject));
                    if (columnsReferenced.Count > 0)
                    {
                        listOfUserTableToColumnsReferenced.Add(distinctUserTableName, columnsReferenced);
                    }
                }
            }
            MetaSprocSqlDependency metaSprocSqlDependency =
                new MetaSprocSqlDependency(sprocName,
                                           sprocTypeDependencies,
                                           userTableTypeDependencies,
                                           listOfUserTableToColumnsReferenced,
                                           distinctUserTablesList);

            return(metaSprocSqlDependency);
        }
Пример #5
0
        public void SetRecursiveSprocDependencyDictionary()
        {
            PredicateFunctions predicateFunctions = new PredicateFunctions();


            foreach (MetaSprocSqlDependency metaSprocSqlDependency in _metaSprocSqlDependencyList)
            {
                List <string> distinctSprocDependencyNames =
                    GetDistinctSprocDependecyList(metaSprocSqlDependency.SprocDependencies);

                foreach (string sprocDependencyName in distinctSprocDependencyNames)
                {
                    predicateFunctions.SprocNameHolder = sprocDependencyName;
                    MetaSprocSqlDependency sprocRecursiveDependency =
                        _metaSprocSqlDependencyList.Find(predicateFunctions.FindMetaSqlSprocBySprocName);
                    sprocRecursiveDependency.RecursiveSprocNameToMetaSprocSqlDependency.Add(sprocDependencyName, sprocRecursiveDependency);
                }
            }
        }