Exemple #1
0
        public override void LoadFields(MetadataList fields, MetadataLoadingOptions loadingOptions)
        {
            MetadataItem      obj      = fields.Parent.Object;
            MetadataNamespace schema   = obj.Schema;
            MetadataNamespace database = obj.Database;

            if (schema != null && database != null && obj.Server == null)
            {
                string[] restrictions = new string[3];
                restrictions[0] = database.Name;
                restrictions[1] = schema.Name;
                restrictions[2] = obj.Name;

                using (DataTable dataTable = _connection.GetSchema("Columns", restrictions))
                {
                    MetadataFieldsFetcherFromDatatable mff = new MetadataFieldsFetcherFromDatatable(fields.SQLContext);

                    mff.Datatable = dataTable;

                    mff.NameFieldName = "COLUMN_NAME";

                    mff.NullableFieldName = "IS_NULLABLE";
                    mff.NullableValue     = "YES";

                    mff.ServerTypeFieldName = "DATA_TYPE";
                    mff.SizeFieldName       = "CHARACTER_MAXIMUM_LENGTH";
                    mff.PrecisionFieldName  = "NUMERIC_PRECISION";
                    mff.ScaleFieldName      = "NUMERIC_SCALE";

                    mff.DefaultValueFieldName = "COLUMN_DEFAULT";

                    mff.LoadFields(fields);
                }

                base.LoadFields(fields, loadingOptions);
            }
        }
Exemple #2
0
        private void LoadFieldsFromGetSchema(MetadataList fields, MetadataLoadingOptions loadingOptions)
        {
            SQLContext sqlContext = fields.SQLContext;

            string olddb = Connection.Database;

            try
            {
                // load tables
                string[] restrictions = new string[3];

                if (sqlContext.SyntaxProvider.IsSupportDatabases())
                {
                    MetadataNamespace database = fields.Parent.Database;
                    if (database != null)
                    {
                        restrictions[0] = database.Name;
                    }
                    else
                    {
                        return;
                    }
                }
                else
                {
                    restrictions[0] = null;
                }

                if (sqlContext.SyntaxProvider.IsSupportSchemas())
                {
                    MetadataNamespace schema = fields.Parent.Schema;
                    if (schema != null)
                    {
                        restrictions[1] = schema.Name;
                    }
                    else
                    {
                        return;
                    }
                }
                else
                {
                    restrictions[1] = null;
                }

                MetadataObject obj = fields.Parent.Object;
                if (obj == null)
                {
                    return;
                }

                restrictions[2] = obj.Name;

                try
                {
                    if (!string.IsNullOrEmpty(restrictions[0]) && Connection.Database != restrictions[0])
                    {
                        Connection.ChangeDatabase(restrictions[0]);
                    }

                    DataTable schemaTable = _connection.GetSchema("Columns", restrictions);
                    schemaTable.DefaultView.Sort = "ORDINAL_POSITION";
                    DataTable ordinalSortedColumns = schemaTable.DefaultView.ToTable();

                    MetadataFieldsFetcherFromDatatable mof = new MetadataFieldsFetcherFromDatatable(sqlContext);
                    mof.NameFieldName        = "COLUMN_NAME";
                    mof.ServerTypeFieldName  = "TYPE_NAME";
                    mof.SizeFieldName        = "COLUMN_SIZE";
                    mof.ScaleFieldName       = "DECIMAL_DIGITS";
                    mof.DescriptionFieldName = "REMARKS";
                    mof.Datatable            = ordinalSortedColumns;

                    mof.LoadFields(fields);
                }
                catch
                {
                    // loading from OLEDB catalog failed
                }
            }
            finally
            {
                if (Connection.Database != olddb)
                {
                    Connection.ChangeDatabase(olddb);
                }
            }
        }