static internal void GenerateSchemaTable(OleDbDataReader dataReader, object handle, CommandBehavior behavior) {
     if (0 != (CommandBehavior.KeyInfo & behavior)) {
         dataReader.BuildSchemaTableRowset(handle); // tries IColumnsRowset first then IColumnsInfo
         dataReader.AppendSchemaInfo();
     }
     else {
         dataReader.BuildSchemaTableInfo(handle, false, false); // only tries IColumnsInfo
     }
     MetaData[] metadata = dataReader.MetaData;
     if ((null != metadata) && (0 < metadata.Length)) {
         dataReader.BuildSchemaTable(metadata);
     }
 }
 internal void DumpToSchemaTable(System.Data.Common.UnsafeNativeMethods.IRowset rowset)
 {
     List<System.Data.OleDb.MetaData> list = new List<System.Data.OleDb.MetaData>();
     object propertyValue = null;
     using (OleDbDataReader reader = new OleDbDataReader(this._connection, this._command, -2147483648, CommandBehavior.Default))
     {
         reader.InitializeIRowset(rowset, ChapterHandle.DB_NULL_HCHAPTER, IntPtr.Zero);
         reader.BuildSchemaTableInfo(rowset, true, false);
         propertyValue = this.GetPropertyValue(0x102);
         if (reader.FieldCount == 0)
         {
             return;
         }
         FieldNameLookup lookup = new FieldNameLookup(reader, -1);
         reader._fieldNameLookup = lookup;
         System.Data.OleDb.MetaData data20 = reader.FindMetaData("DBCOLUMN_IDNAME");
         System.Data.OleDb.MetaData data19 = reader.FindMetaData("DBCOLUMN_GUID");
         System.Data.OleDb.MetaData data18 = reader.FindMetaData("DBCOLUMN_PROPID");
         System.Data.OleDb.MetaData data17 = reader.FindMetaData("DBCOLUMN_NAME");
         System.Data.OleDb.MetaData data12 = reader.FindMetaData("DBCOLUMN_NUMBER");
         System.Data.OleDb.MetaData data16 = reader.FindMetaData("DBCOLUMN_TYPE");
         System.Data.OleDb.MetaData data11 = reader.FindMetaData("DBCOLUMN_COLUMNSIZE");
         System.Data.OleDb.MetaData data15 = reader.FindMetaData("DBCOLUMN_PRECISION");
         System.Data.OleDb.MetaData data14 = reader.FindMetaData("DBCOLUMN_SCALE");
         System.Data.OleDb.MetaData data13 = reader.FindMetaData("DBCOLUMN_FLAGS");
         System.Data.OleDb.MetaData data10 = reader.FindMetaData("DBCOLUMN_BASESCHEMANAME");
         System.Data.OleDb.MetaData data9 = reader.FindMetaData("DBCOLUMN_BASECATALOGNAME");
         System.Data.OleDb.MetaData data8 = reader.FindMetaData("DBCOLUMN_BASETABLENAME");
         System.Data.OleDb.MetaData data7 = reader.FindMetaData("DBCOLUMN_BASECOLUMNNAME");
         System.Data.OleDb.MetaData data6 = reader.FindMetaData("DBCOLUMN_ISAUTOINCREMENT");
         System.Data.OleDb.MetaData data5 = reader.FindMetaData("DBCOLUMN_ISUNIQUE");
         System.Data.OleDb.MetaData data4 = reader.FindMetaData("DBCOLUMN_KEYCOLUMN");
         reader.CreateAccessors(false);
         while (reader.ReadRowset())
         {
             reader.GetRowDataFromHandle();
             System.Data.OleDb.MetaData item = new System.Data.OleDb.MetaData();
             ColumnBinding columnBinding = data20.columnBinding;
             if (!columnBinding.IsValueNull())
             {
                 item.idname = (string) columnBinding.Value();
                 item.kind = 2;
             }
             columnBinding = data19.columnBinding;
             if (!columnBinding.IsValueNull())
             {
                 item.guid = columnBinding.Value_GUID();
                 item.kind = (2 == item.kind) ? 0 : 6;
             }
             columnBinding = data18.columnBinding;
             if (!columnBinding.IsValueNull())
             {
                 item.propid = new IntPtr((long) columnBinding.Value_UI4());
                 item.kind = (6 == item.kind) ? 1 : 5;
             }
             columnBinding = data17.columnBinding;
             if (!columnBinding.IsValueNull())
             {
                 item.columnName = (string) columnBinding.Value();
             }
             else
             {
                 item.columnName = "";
             }
             if (4 == ADP.PtrSize)
             {
                 item.ordinal = (IntPtr) data12.columnBinding.Value_UI4();
             }
             else
             {
                 item.ordinal = (IntPtr) data12.columnBinding.Value_UI8();
             }
             short dbType = (short) data16.columnBinding.Value_UI2();
             if (4 == ADP.PtrSize)
             {
                 item.size = (int) data11.columnBinding.Value_UI4();
             }
             else
             {
                 item.size = ADP.IntPtrToInt32((IntPtr) data11.columnBinding.Value_UI8());
             }
             columnBinding = data15.columnBinding;
             if (!columnBinding.IsValueNull())
             {
                 item.precision = (byte) columnBinding.Value_UI2();
             }
             columnBinding = data14.columnBinding;
             if (!columnBinding.IsValueNull())
             {
                 item.scale = (byte) columnBinding.Value_I2();
             }
             item.flags = (int) data13.columnBinding.Value_UI4();
             bool isLong = IsLong(item.flags);
             bool isFixed = IsFixed(item.flags);
             NativeDBType type = NativeDBType.FromDBType(dbType, isLong, isFixed);
             item.type = type;
             if (data6 != null)
             {
                 columnBinding = data6.columnBinding;
                 if (!columnBinding.IsValueNull())
                 {
                     item.isAutoIncrement = columnBinding.Value_BOOL();
                 }
             }
             if (data5 != null)
             {
                 columnBinding = data5.columnBinding;
                 if (!columnBinding.IsValueNull())
                 {
                     item.isUnique = columnBinding.Value_BOOL();
                 }
             }
             if (data4 != null)
             {
                 columnBinding = data4.columnBinding;
                 if (!columnBinding.IsValueNull())
                 {
                     item.isKeyColumn = columnBinding.Value_BOOL();
                 }
             }
             if (data10 != null)
             {
                 columnBinding = data10.columnBinding;
                 if (!columnBinding.IsValueNull())
                 {
                     item.baseSchemaName = columnBinding.ValueString();
                 }
             }
             if (data9 != null)
             {
                 columnBinding = data9.columnBinding;
                 if (!columnBinding.IsValueNull())
                 {
                     item.baseCatalogName = columnBinding.ValueString();
                 }
             }
             if (data8 != null)
             {
                 columnBinding = data8.columnBinding;
                 if (!columnBinding.IsValueNull())
                 {
                     item.baseTableName = columnBinding.ValueString();
                 }
             }
             if (data7 != null)
             {
                 columnBinding = data7.columnBinding;
                 if (!columnBinding.IsValueNull())
                 {
                     item.baseColumnName = columnBinding.ValueString();
                 }
             }
             list.Add(item);
         }
     }
     int count = list.Count;
     if (propertyValue is int)
     {
         count -= (int) propertyValue;
     }
     bool flag = false;
     for (int i = list.Count - 1; count <= i; i--)
     {
         System.Data.OleDb.MetaData data3 = list[i];
         data3.isHidden = true;
         if (flag)
         {
             data3.isKeyColumn = false;
         }
         else if (data3.guid.Equals(ODB.DBCOL_SPECIALCOL))
         {
             data3.isKeyColumn = false;
             flag = true;
             for (int k = list.Count - 1; i < k; k--)
             {
                 list[k].isKeyColumn = false;
             }
         }
     }
     for (int j = count - 1; 0 <= j; j--)
     {
         System.Data.OleDb.MetaData data2 = list[j];
         if (flag)
         {
             data2.isKeyColumn = false;
         }
         if (data2.guid.Equals(ODB.DBCOL_SPECIALCOL))
         {
             data2.isHidden = true;
             count--;
         }
         else if (0 >= ((int) data2.ordinal))
         {
             data2.isHidden = true;
             count--;
         }
         else if (DoColumnDropFilter(data2.flags))
         {
             data2.isHidden = true;
             count--;
         }
     }
     list.Sort();
     this._visibleFieldCount = count;
     this._metadata = list.ToArray();
 }
        internal void DumpToSchemaTable(UnsafeNativeMethods.IRowset rowset) {
            List<MetaData> metainfo = new List<MetaData>();

            object hiddenColumns = null;
            using (OleDbDataReader dataReader = new OleDbDataReader(_connection, _command, Int32.MinValue, 0)) {
                dataReader.InitializeIRowset(rowset, ChapterHandle.DB_NULL_HCHAPTER, IntPtr.Zero);
                dataReader.BuildSchemaTableInfo(rowset, true, false);

                hiddenColumns = GetPropertyValue(ODB.DBPROP_HIDDENCOLUMNS); // MDAC 55611, 72106
                if (0 == dataReader.FieldCount) {
                    return;
                }

                Debug.Assert(null == dataReader._fieldNameLookup, "lookup already exists");
                FieldNameLookup lookup = new FieldNameLookup(dataReader, -1);
                dataReader._fieldNameLookup = lookup;

                // This column, together with the DBCOLUMN_GUID and DBCOLUMN_PROPID
                // columns, forms the ID of the column. One or more (but not all) of these columns
                // will be NULL, depending on which elements of the DBID structure the provider uses.
                MetaData columnidname = dataReader.FindMetaData(ODB.DBCOLUMN_IDNAME);
                MetaData columnguid = dataReader.FindMetaData(ODB.DBCOLUMN_GUID);
                MetaData columnpropid = dataReader.FindMetaData(ODB.DBCOLUMN_PROPID);

                MetaData columnname = dataReader.FindMetaData(ODB.DBCOLUMN_NAME);
                MetaData columnordinal = dataReader.FindMetaData(ODB.DBCOLUMN_NUMBER);
                MetaData dbtype = dataReader.FindMetaData(ODB.DBCOLUMN_TYPE);
                MetaData columnsize = dataReader.FindMetaData(ODB.DBCOLUMN_COLUMNSIZE);
                MetaData numericprecision = dataReader.FindMetaData(ODB.DBCOLUMN_PRECISION);
                MetaData numericscale = dataReader.FindMetaData(ODB.DBCOLUMN_SCALE);
                MetaData columnflags = dataReader.FindMetaData(ODB.DBCOLUMN_FLAGS);
                MetaData baseschemaname = dataReader.FindMetaData(ODB.DBCOLUMN_BASESCHEMANAME);
                MetaData basecatalogname = dataReader.FindMetaData(ODB.DBCOLUMN_BASECATALOGNAME);
                MetaData basetablename = dataReader.FindMetaData(ODB.DBCOLUMN_BASETABLENAME);
                MetaData basecolumnname = dataReader.FindMetaData(ODB.DBCOLUMN_BASECOLUMNNAME);
                MetaData isautoincrement = dataReader.FindMetaData(ODB.DBCOLUMN_ISAUTOINCREMENT);
                MetaData isunique = dataReader.FindMetaData(ODB.DBCOLUMN_ISUNIQUE);
                MetaData iskeycolumn = dataReader.FindMetaData(ODB.DBCOLUMN_KEYCOLUMN);

                // @devnote: because we want to use the DBACCESSOR_OPTIMIZED bit,
                // we are required to create the accessor before fetching any rows
                dataReader.CreateAccessors(false);

                ColumnBinding binding;
                while (dataReader.ReadRowset()) {
                    dataReader.GetRowDataFromHandle();

                    MetaData info = new MetaData();

                    binding = columnidname.columnBinding; // MDAC 72627
                    if (!binding.IsValueNull()) {
                        info.idname = (string)binding.Value();
                        info.kind = ODB.DBKIND_NAME;
                    }

                    binding = columnguid.columnBinding;
                    if (!binding.IsValueNull()) {
                        info.guid = binding.Value_GUID();
                        info.kind = ((ODB.DBKIND_NAME == info.kind) ? ODB.DBKIND_GUID_NAME : ODB.DBKIND_GUID);
                    }

                    binding = columnpropid.columnBinding;
                    if (!binding.IsValueNull()) {
                        info.propid = new IntPtr(binding.Value_UI4());
                        info.kind = ((ODB.DBKIND_GUID == info.kind) ? ODB.DBKIND_GUID_PROPID : ODB.DBKIND_PROPID);
                    }

                    binding = columnname.columnBinding;
                    if (!binding.IsValueNull()) {
                        info.columnName = (string)binding.Value();
                    }
                    else {
                        info.columnName = "";
                    }

                    if (4 == ADP.PtrSize) {
                        info.ordinal = (IntPtr)columnordinal.columnBinding.Value_UI4();
                    }
                    else {
                        info.ordinal = (IntPtr)columnordinal.columnBinding.Value_UI8();
                    }
                    short wType = unchecked((short) dbtype.columnBinding.Value_UI2());

                    if (4 == ADP.PtrSize) {
                        info.size = unchecked((int) columnsize.columnBinding.Value_UI4()); // WebData 99298
                    }
                    else {
                        info.size = ADP.IntPtrToInt32((IntPtr)unchecked((long)columnsize.columnBinding.Value_UI8()));
                    }

                    binding = numericprecision.columnBinding;
                    if (!binding.IsValueNull()) {
                        info.precision = (byte)binding.Value_UI2();
                    }

                    binding = numericscale.columnBinding;
                    if (!binding.IsValueNull()) {
                        info.scale = (byte)binding.Value_I2();
                    }

                    info.flags = unchecked((int) columnflags.columnBinding.Value_UI4());

                    bool islong = OleDbDataReader.IsLong(info.flags);
                    bool isfixed = OleDbDataReader.IsFixed(info.flags);
                    NativeDBType dbType = NativeDBType.FromDBType(wType, islong, isfixed);

                    info.type = dbType;

                    if (null != isautoincrement) {
                        binding = isautoincrement.columnBinding;
                        if (!binding.IsValueNull()) {
                            info.isAutoIncrement = binding.Value_BOOL();
                        }
                    }
                    if (null != isunique) {
                        binding = isunique.columnBinding;
                        if (!binding.IsValueNull()) {
                            info.isUnique = binding.Value_BOOL();
                        }
                    }
                    if (null != iskeycolumn) {
                        binding = iskeycolumn.columnBinding;
                        if (!binding.IsValueNull()) {
                            info.isKeyColumn = binding.Value_BOOL();
                        }
                    }
                    if (null != baseschemaname) {
                        binding = baseschemaname.columnBinding;
                        if (!binding.IsValueNull()) {
                            info.baseSchemaName = binding.ValueString();
                        }
                    }
                    if (null != basecatalogname) {
                        binding = basecatalogname.columnBinding;
                        if (!binding.IsValueNull()) {
                            info.baseCatalogName = binding.ValueString();
                        }
                    }
                    if (null != basetablename) {
                        binding = basetablename.columnBinding;
                        if (!binding.IsValueNull()) {
                            info.baseTableName = binding.ValueString();
                        }
                    }
                    if (null != basecolumnname) {
                        binding = basecolumnname.columnBinding;
                        if (!binding.IsValueNull()) {
                            info.baseColumnName = binding.ValueString();
                        }
                    }
                    metainfo.Add(info);
                }
            }

            int visibleCount = metainfo.Count;
            if (hiddenColumns is Int32) {
                visibleCount -= (int)hiddenColumns;
            }

            // VSTFDevDiv 479578: 
            //  if one key column is invalidated, they all need to be invalidated. The SET is the key,
            //  and subsets likely are not accurate keys. Note the assumption that the two loops below
            //  will traverse the entire set of columns.
            bool disallowKeyColumns = false;

            for (int index = metainfo.Count - 1; visibleCount <= index; --index) {
                MetaData info = metainfo[index];

                info.isHidden = true;

                if (disallowKeyColumns) {
                    info.isKeyColumn = false;
                }
                else if (info.guid.Equals(ODB.DBCOL_SPECIALCOL)) { // MDAC 90827
                    info.isKeyColumn = false;

                    // This is the first key column to be invalidated, scan back through the 
                    //  columns we already processed to make sure none of those are marked as keys.
                    disallowKeyColumns = true;
                    for (int index2 = metainfo.Count-1; index < index2; --index2) {
                        metainfo[index2].isKeyColumn = false;
                    }
                }
            }

            for (int index = visibleCount - 1; 0 <= index; --index) {
                MetaData info = metainfo[index];

                if (disallowKeyColumns) {
                    info.isKeyColumn = false;
                }

                if (info.guid.Equals(ODB.DBCOL_SPECIALCOL)) { // MDAC 72390
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceVerbose) {
                        Debug.WriteLine("Filtered Column: DBCOLUMN_GUID=DBCOL_SPECIALCOL DBCOLUMN_NAME=" + info.columnName + " DBCOLUMN_KEYCOLUMN=" + info.isKeyColumn);
                    }
#endif
                    info.isHidden = true;
                    visibleCount--;
                }
#if WIN32
                else if (0 >= (int)info.ordinal) {
#else
                else if (0 >= (long)info.ordinal) {
#endif
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceVerbose) {
                        Debug.WriteLine("Filtered Column: DBCOLUMN_NUMBER=" + info.ordinal.ToInt64().ToString(CultureInfo.InvariantCulture) + " DBCOLUMN_NAME=" + info.columnName);
                    }
#endif
                    info.isHidden = true;
                    visibleCount--;
                }
                else if (OleDbDataReader.DoColumnDropFilter(info.flags)) {
#if DEBUG
                    if (AdapterSwitches.DataSchema.TraceVerbose) {
                        Debug.WriteLine("Filtered Column: DBCOLUMN_FLAGS=" + info.flags.ToString("X8", (System.IFormatProvider)null) + " DBCOLUMN_NAME=" + info.columnName);
                    }
#endif
                    info.isHidden = true;
                    visibleCount--;
                }
            }

            // 
            metainfo.Sort(); // MDAC 68319
            _visibleFieldCount = visibleCount;
            _metadata = metainfo.ToArray();
        }
 internal static void GenerateSchemaTable(OleDbDataReader dataReader, object handle, CommandBehavior behavior)
 {
     if ((CommandBehavior.KeyInfo & behavior) != CommandBehavior.Default)
     {
         dataReader.BuildSchemaTableRowset(handle);
         dataReader.AppendSchemaInfo();
     }
     else
     {
         dataReader.BuildSchemaTableInfo(handle, false, false);
     }
     System.Data.OleDb.MetaData[] metaData = dataReader.MetaData;
     if ((metaData != null) && (0 < metaData.Length))
     {
         dataReader.BuildSchemaTable(metaData);
     }
 }