Пример #1
0
        internal DataTable GetSchemaRowset(Guid schema, object[] restrictions)
        {
            IntPtr hscp;

            Bid.ScopeEnter(out hscp, "<oledb.OleDbConnectionInternal.GetSchemaRowset|INFO> %d#, schema=%ls, restrictions\n", ObjectID, schema);
            try {
                if (null == restrictions)   // MDAC 62243
                {
                    restrictions = new object[0];
                }
                DataTable dataTable = null;
                using (IDBSchemaRowsetWrapper wrapper = IDBSchemaRowset()) {
                    UnsafeNativeMethods.IDBSchemaRowset dbSchemaRowset = wrapper.Value;
                    if (null == dbSchemaRowset)
                    {
                        throw ODB.SchemaRowsetsNotSupported(Provider);
                    }

                    UnsafeNativeMethods.IRowset rowset = null;
                    OleDbHResult hr;

                    Bid.Trace("<oledb.IDBSchemaRowset.GetRowset|API|OLEDB> %d#\n", ObjectID);
                    hr = dbSchemaRowset.GetRowset(ADP.PtrZero, ref schema, restrictions.Length, restrictions, ref ODB.IID_IRowset, 0, ADP.PtrZero, out rowset);
                    Bid.Trace("<oledb.IDBSchemaRowset.GetRowset|API|OLEDB|RET> %08X{HRESULT}\n", hr);

                    if (hr < 0)   // ignore infomsg
                    {
                        ProcessResults(hr);
                    }

                    if (null != rowset)
                    {
                        using (OleDbDataReader dataReader = new OleDbDataReader(Connection, null, 0, CommandBehavior.Default)) {
                            dataReader.InitializeIRowset(rowset, ChapterHandle.DB_NULL_HCHAPTER, IntPtr.Zero);
                            dataReader.BuildMetaInfo();
                            dataReader.HasRowsRead();

                            dataTable           = new DataTable();
                            dataTable.Locale    = CultureInfo.InvariantCulture;
                            dataTable.TableName = OleDbSchemaGuid.GetTextFromValue(schema);
                            OleDbDataAdapter.FillDataTable(dataReader, dataTable);
                        }
                    }
                    return(dataTable);
                }
            }
            finally {
                Bid.ScopeLeave(ref hscp);
            }
        }
        internal DataTable GetSchemaRowset(Guid schema, object[] restrictions)
        {
            if (null == restrictions)
            {
                restrictions = Array.Empty <object>();
            }
            DataTable dataTable = null;

            using (IDBSchemaRowsetWrapper wrapper = IDBSchemaRowset())
            {
                UnsafeNativeMethods.IDBSchemaRowset dbSchemaRowset = wrapper.Value;
                if (null == dbSchemaRowset)
                {
                    throw ODB.SchemaRowsetsNotSupported(Provider);
                }

                UnsafeNativeMethods.IRowset rowset = null;
                OleDbHResult hr;
                hr = dbSchemaRowset.GetRowset(ADP.PtrZero, ref schema, restrictions.Length, restrictions, ref ODB.IID_IRowset, 0, ADP.PtrZero, out rowset);

                if (hr < 0)
                { // ignore infomsg
                    ProcessResults(hr);
                }

                if (null != rowset)
                {
                    using (OleDbDataReader dataReader = new OleDbDataReader(Connection, null, 0, CommandBehavior.Default))
                    {
                        dataReader.InitializeIRowset(rowset, ChapterHandle.DB_NULL_HCHAPTER, IntPtr.Zero);
                        dataReader.BuildMetaInfo();
                        dataReader.HasRowsRead();

                        dataTable           = new DataTable();
                        dataTable.Locale    = CultureInfo.InvariantCulture;
                        dataTable.TableName = OleDbSchemaGuid.GetTextFromValue(schema);
                        OleDbDataAdapter.FillDataTable(dataReader, dataTable);
                    }
                }
                return(dataTable);
            }
        }
        override public bool NextResult() {
            IntPtr hscp;
            Bid.ScopeEnter(out hscp, "<oledb.OleDbDataReader.NextResult|API> %d#\n", ObjectID);
            try {
                bool retflag = false;
                if (IsClosed) {
                    throw ADP.DataReaderClosed("NextResult");
                }
                _fieldNameLookup = null;

                OleDbCommand command = _command;
                UnsafeNativeMethods.IMultipleResults imultipleResults = _imultipleResults;
                if (null != imultipleResults) {
                    DisposeOpenResults();
                    _hasRows = false;
                    
                    for (;;) {
                        Debug.Assert(null == _irow, "NextResult: row loop check");
                        Debug.Assert(null == _irowset, "NextResult: rowset loop check");

                        object result = null;
                        OleDbHResult hr;
                        IntPtr affected;

                        if ((null != command) && command.canceling) { // MDAC 69986
                            Close();
                            break;
                        }

                        Bid.Trace("<oledb.IMultipleResults.GetResult|API|OLEDB> %d#, IID_IRowset\n", ObjectID);
                        hr = imultipleResults.GetResult(ADP.PtrZero, ODB.DBRESULTFLAG_DEFAULT, ref ODB.IID_IRowset, out affected, out result);
                        Bid.Trace("<oledb.IMultipleResults.GetResult|API|OLEDB|RET> %08X{HRESULT}, RecordAffected=%Id\n", hr, affected);

                        if ((0 <= hr) && (null != result)) {
                            Bid.Trace("<oledb.IUnknown.QueryInterface|API|OLEDB|RowSet> %d#, IRowset\n", ObjectID);
                            _irowset = (UnsafeNativeMethods.IRowset) result;
                        }
                        _recordsAffected = AddRecordsAffected(_recordsAffected, affected);

                        if (OleDbHResult.DB_S_NORESULT == hr) {
                            DisposeNativeMultipleResults();
                            break;
                        }
                        // @devnote: infomessage events may be fired from here
                        ProcessResults(hr);

                        if (null != _irowset) {
                            BuildMetaInfo();
                            HasRowsRead();
                            retflag = true;
                            break;
                        }
                    }
                }
                else {
                    DisposeOpenResults(); // MDAC 70934
                    _hasRows = false; // MDAC 85850
                }
                return retflag;
            }
            finally {
                Bid.ScopeLeave(ref hscp);
            }
        }
        private void DisposeNativeRowset() {
            UnsafeNativeMethods.IRowset irowset = _irowset;
            _irowset = null;

            ChapterHandle chapter = _chapterHandle;
            _chapterHandle = ChapterHandle.DB_NULL_HCHAPTER;

            if (ChapterHandle.DB_NULL_HCHAPTER != chapter) { // MDAC 81441
                chapter.Dispose();
            }

            if (null != irowset) {
                Marshal.ReleaseComObject(irowset);
            }
        }
        internal void InitializeIRowset(object result, ChapterHandle chapterHandle, IntPtr recordsAffected) {
            // if from ADODB, connection will be null
            if ((null == _connection) || (ChapterHandle.DB_NULL_HCHAPTER != chapterHandle)) { // MDAC 59629
                _rowHandleFetchCount = new IntPtr(1);
            }

            Initialize();
            _recordsAffected = recordsAffected;
            _irowset = (UnsafeNativeMethods.IRowset) result; // maybe null if no results
            _chapterHandle = chapterHandle;
        }