icolumnsrowsetimpl.h

GIS系统支持库Geospatial Data Abstraction Library代码.GDAL is a translator library for raster geospatial dat

                            lstrcpyW(data.m_pszSpatialRefSystem,L"" );
                        }

                        if (!m_rgRowData.Add(data))
                        {
                            return E_OUTOFMEMORY;
                        }
                    }

                    return S_OK;
                }
        };

    STDMETHOD(GetAvailableColumns)(
        ULONG *pcOptColumns,
        DBID **prgOptColumns)
        {
            ATLTRACE2(atlTraceDBProvider, 0, "IColumnsRowsetImpl::GetAvailableColumns()\n");

            if (!pcOptColumns || !prgOptColumns)
            {
                return E_INVALIDARG;
            }

            const ULONG c_numOptColumns = 3;

            *pcOptColumns = c_numOptColumns;

            DBID *pOptCols = (DBID*)CoTaskMemAlloc(sizeof(DBID) * c_numOptColumns);

            memset(pOptCols, 0, sizeof(DBID) * c_numOptColumns);

            pOptCols[0] = DBCOLUMN_BASETABLENAME;
            pOptCols[1] =  DBCOLUMN_BASECOLUMNNAME;
            pOptCols[2] =  DBCOLUMN_KEYCOLUMN;
      
            *pcOptColumns = c_numOptColumns;
            *prgOptColumns = pOptCols;

            return S_OK;
        }

    STDMETHOD(GetColumnsRowset)(
        IUnknown *pUnkOuter,
        ULONG cOptColumns,
        const DBID rgOptColumns[],
        REFIID riid,
        ULONG cPropertySets,
        DBPROPSET rgPropertySets[],
        IUnknown **ppColRowset)
        {
            ATLTRACE2(atlTraceDBProvider, 0, "IColumnsRowsetImpl::GetColumnsRowset()\n");

            // need to create our columns rowset, 
            // then populate it from the actual rowset that we represent...
      
            // We can do that by using IColumnsInfo...

            CColumnsRowsetRowset *pColRowset = 0;

            HRESULT hr = CreateRowset(
                pUnkOuter, 
                riid, 
                cPropertySets, 
                rgPropertySets,
                pColRowset,
                ppColRowset);

            if (SUCCEEDED(hr))
            {
                if (pColRowset)
                {
                    T *pT = (T*)this;

                    CComQIPtr<IColumnsInfo> spColumnsInfo = pT->GetUnknown();

                    if (spColumnsInfo)
                    {
                        ULONG numCols = 0;
                        DBCOLUMNINFO *pColInfo = 0;
                        OLECHAR *pNotUsed = 0;

                        hr = spColumnsInfo->GetColumnInfo(&numCols, &pColInfo, &pNotUsed);

                        if (pNotUsed)
                        {
                            CoTaskMemFree(pNotUsed);
                        }

                        if (SUCCEEDED(hr))
                        {
                            hr = pColRowset->PopulateRowset(numCols, pColInfo,
                                                            pT->m_poDS,
                                                            pT->m_iLayer );
                        }

                        CoTaskMemFree(pColInfo);
                    }
                }
                else
                {
                    hr = E_UNEXPECTED;
                }
            }
      
            return hr;
        }

    private :

        HRESULT CreateRowset(
            IUnknown * pUnkOuter,	
            REFIID riid,				
            ULONG cPropertySets,
            DBPROPSET rgPropertySets[],
            CColumnsRowsetRowset *&pRowsetObj,
            IUnknown **ppRowset)
        {
            HRESULT hr;

            T* pT = (T*)this;

            if (ppRowset != NULL)
            {
                *ppRowset = NULL;
            }

            if ((pUnkOuter != NULL) && !InlineIsEqualUnknown(riid))
            {
                return DB_E_NOAGGREGATION;
            }

            CComPolyObject<CColumnsRowsetRowset>* pPolyObj;
	      
            if (FAILED(hr = CComPolyObject<CColumnsRowsetRowset>::CreateInstance(pUnkOuter, &pPolyObj)))
            {
                return hr;
            }
	      
            // Ref the created COM object and Auto release it on failure
	      
            CComPtr<IUnknown> spUnk;
	      
            hr = pPolyObj->QueryInterface(&spUnk);
	      
            if (FAILED(hr))
            {
                delete pPolyObj; // must hand delete as it is not ref'd
                return hr;
            }
	      
            // Get a pointer to the Rowset instance
            pRowsetObj = &(pPolyObj->m_contained);

            if (FAILED(hr = pRowsetObj->FInit(pT)))
            {
                return hr;
            }

            // Set Properties that were passed in.

            const GUID* ppGuid[1];
            ppGuid[0] = &DBPROPSET_ROWSET;

            // Call SetProperties.  The true in the last parameter indicates
            // the special behavior that takes place on rowset creation (i.e.
            // it succeeds as long as any of the properties were not marked
            // as DBPROPS_REQUIRED.

            hr = pRowsetObj->SetProperties(0, cPropertySets, rgPropertySets, 1, ppGuid, true);

            if (FAILED(hr))
            {
                return hr;
            }

            pRowsetObj->SetSite(pT->GetUnknown());

            if (InlineIsEqualGUID(riid, IID_NULL) || ppRowset == NULL)
            {
                if (ppRowset != NULL)
                    *ppRowset = NULL;
                return hr;
            }

            if (InlineIsEqualGUID(riid, IID_NULL) || ppRowset == NULL)
            {
                if (ppRowset != NULL)
                    *ppRowset = NULL;
                return hr;
            }
            hr = pPolyObj->QueryInterface(riid, (void**)ppRowset);
            if (FAILED(hr))
                return hr;
            for (int iBind = 0; iBind < pT->m_rgBindings.GetSize(); iBind++)
            {
                T::_BindType* pBind = NULL;
                T::_BindType* pBindSrc = NULL;
                ATLTRY(pBind = new T::_BindType);
                if (pBind == NULL)
                {
                    ATLTRACE2(atlTraceDBProvider, 0, "Failed to allocate memory for new Binding\n");
                    return E_OUTOFMEMORY;
                }
                // auto cleanup on failure
                CAutoMemRelease<T::_BindType> amr(pBind);
                pBindSrc = pT->m_rgBindings.GetValueAt(iBind);
                if (pBindSrc == NULL)
                {
                    ATLTRACE2(atlTraceDBProvider, 0, "The map appears to be corrupted, failing!!\n");
                    return E_FAIL;
                }
                if (!pRowsetObj->m_rgBindings.Add(pT->m_rgBindings.GetKeyAt(iBind), pBind))
                {
                    ATLTRACE2(atlTraceDBProvider, 0, "Failed to add hAccessor to Map\n");
                    return E_OUTOFMEMORY;
                }
                if (pBindSrc->cBindings)
                {
                    ATLTRY(pBind->pBindings = new DBBINDING[pBindSrc->cBindings])
                        if (pBind->pBindings == NULL)
                        {
                            ATLTRACE2(atlTraceDBProvider, 0, "Failed to Allocate dbbinding Array\n");
                            // We added it, must now remove on failure
                            pRowsetObj->m_rgBindings.Remove(pT->m_rgBindings.GetKeyAt(iBind));
                            return E_OUTOFMEMORY;
                        }
                }
                else
                {
                    pBind->pBindings = NULL; // NULL Accessor
                }

                pBind->dwAccessorFlags = pBindSrc->dwAccessorFlags;
                pBind->cBindings = pBindSrc->cBindings;
                pBind->dwRef = 1;
                memcpy (pBind->pBindings, pBindSrc->pBindings, (pBindSrc->cBindings)*sizeof(DBBINDING));
                pBind = amr.Detach();
            }

            return hr;
        }

};

#endif // __I_COLUMNS_ROWSET_IMPL__INCLUDED__