Attachment #55196 for issue #90022

View | Details | Raw Unified | Return to issue 90022
Collapse All | Expand All

Lines 198-204 public: Link Here

(-)sc/inc/dpcachetable.hxx (-1 / +5 lines)
198		198
199	/** Set filter on/off flag to each row to control visibility. The caller	199	/** Set filter on/off flag to each row to control visibility. The caller
200	must ensure that the table is filled before calling this function. */	200	must ensure that the table is filled before calling this function. */
201	void filterByPageDimension(const ::std::vector<ScDPDimension*>& rPageDims);	201	void filterByPageDimension(const ::std::vector<Criterion>& rCriteria, bool bRepeatIfEmpty = false);
202		202
203	/** Get the cell instance at specified location within the data grid. Note	203	/** Get the cell instance at specified location within the data grid. Note
204	that the data grid doesn't include the header row. Don't delete the	204	that the data grid doesn't include the header row. Don't delete the
Lines 229-234 public: Link Here
229	bool empty() const;	229	bool empty() const;
230		230
231	private:	231	private:
		232	/**
		233	* Check if a given row meets all specified criteria.
		234	*/
		235	bool isRowQualified(sal_Int32 nRow, const ::std::vector<Criterion>& rCriteria, bool bRepeatIfEmpty) const;
232	void getValueData(ScDocument* pDoc, const ScAddress& rPos, Cell& rCell);	236	void getValueData(ScDocument* pDoc, const ScAddress& rPos, Cell& rCell);
233	ScDPCacheTable::Cell getSelectedDimension(ScDPDimension* pDim) const;	237	ScDPCacheTable::Cell getSelectedDimension(ScDPDimension* pDim) const;
234		238

Lines 196-201 class ScDPGroupTableData : public ScDPTableData Link Here

(-)sc/inc/dpgroup.hxx (-1 / +3 lines)
196	void GetNumGroupInfo( long nDimension, ScDPNumGroupInfo& rInfo,	196	void GetNumGroupInfo( long nDimension, ScDPNumGroupInfo& rInfo,
197	bool& rNonInteger, sal_Unicode& rDecimal );	197	bool& rNonInteger, sal_Unicode& rDecimal );
198		198
		199	void ModifyFilterCriteria(::std::vector<ScDPCacheTable::Criterion>& rCriteria) const;
		200
199	public:	201	public:
200	// takes ownership of pSource	202	// takes ownership of pSource
201	ScDPGroupTableData( ScDPTableData* pSource, ScDocument* pDocument );	203	ScDPGroupTableData( ScDPTableData* pSource, ScDocument* pDocument );
Lines 217-223 public: Link Here
217	virtual void SetEmptyFlags( BOOL bIgnoreEmptyRows, BOOL bRepeatIfEmpty );	219	virtual void SetEmptyFlags( BOOL bIgnoreEmptyRows, BOOL bRepeatIfEmpty );
218		220
219	virtual void CreateCacheTable();	221	virtual void CreateCacheTable();
220	virtual void FilterCacheTable(const ::std::vector<ScDPDimension*>& rPageDims);	222	virtual void FilterCacheTable(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria);
221	virtual void GetDrillDownData(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria,	223	virtual void GetDrillDownData(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria,
222	::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rData);	224	::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rData);
223	virtual void CalcResults(CalcInfo& rInfo, bool bAutoShow);	225	virtual void CalcResults(CalcInfo& rInfo, bool bAutoShow);

Lines 89-95 public: Link Here

(-)sc/inc/dpsdbtab.hxx (-1 / +1 lines)
89	virtual void SetEmptyFlags( BOOL bIgnoreEmptyRows, BOOL bRepeatIfEmpty );	89	virtual void SetEmptyFlags( BOOL bIgnoreEmptyRows, BOOL bRepeatIfEmpty );
90		90
91	virtual void CreateCacheTable();	91	virtual void CreateCacheTable();
92	virtual void FilterCacheTable(const ::std::vector<ScDPDimension*>& rPageDims);	92	virtual void FilterCacheTable(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria);
93	virtual void GetDrillDownData(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria,	93	virtual void GetDrillDownData(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria,
94	::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rData);	94	::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rData);
95	virtual void CalcResults(CalcInfo& rInfo, bool bAutoShow);	95	virtual void CalcResults(CalcInfo& rInfo, bool bAutoShow);

Lines 82-88 public: Link Here

(-)sc/inc/dpshttab.hxx (-1 / +1 lines)
82	virtual bool IsRepeatIfEmpty();	82	virtual bool IsRepeatIfEmpty();
83		83
84	virtual void CreateCacheTable();	84	virtual void CreateCacheTable();
85	virtual void FilterCacheTable(const ::std::vector<ScDPDimension*>& rPageDims);	85	virtual void FilterCacheTable(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria);
86	virtual void GetDrillDownData(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria,	86	virtual void GetDrillDownData(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria,
87	::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rData);	87	::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rData);
88	virtual void CalcResults(CalcInfo& rInfo, bool bAutoShow);	88	virtual void CalcResults(CalcInfo& rInfo, bool bAutoShow);

Lines 166-172 public: Link Here

(-)sc/inc/dptabdat.hxx (-1 / +1 lines)
166	virtual bool IsRepeatIfEmpty();	166	virtual bool IsRepeatIfEmpty();
167		167
168	virtual void CreateCacheTable();	168	virtual void CreateCacheTable();
169	virtual void FilterCacheTable(const ::std::vector<ScDPDimension*>& rPageDims);	169	virtual void FilterCacheTable(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria);
170	virtual void GetDrillDownData(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria,	170	virtual void GetDrillDownData(const ::std::vector<ScDPCacheTable::Criterion>& rCriteria,
171	::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rData);	171	::com::sun::star::uno::Sequence< ::com::sun::star::uno::Sequence< ::com::sun::star::uno::Any > >& rData);
172	virtual void CalcResults(CalcInfo& rInfo, bool bAutoShow);	172	virtual void CalcResults(CalcInfo& rInfo, bool bAutoShow);




    return maRowsVisible[nRow];
}

void ScDPCacheTable::filterByPageDimension(const vector<Criterion>& rCriteria, bool bRepeatIfEmpty)
{
    sal_Int32 nRowSize = getRowSize();
    sal_Int32 nColSize = getColSize();
    if (nRowSize != static_cast<sal_Int32>(maRowsVisible.size()))
    {
        // sizes of the two tables differ!
        return;
    }

    for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
        maRowsVisible[nRow] = isRowQualified(nRow, rCriteria, bRepeatIfEmpty);
        maRowsVisible[nRow] = true;
        const vector<Cell>& rRow = maTable[nRow];
        vector<ScDPDimension*>::const_iterator itr = rPageDims.begin(), itrEnd = rPageDims.end();
        for (; itr != itrEnd; ++itr)
        {
            ScDPDimension* pDim = *itr;
            if (!pDim->HasSelectedPage())
                // 'show all' is selected.
                continue;

            ScDPCacheTable::Cell aDimCell = getSelectedDimension(pDim);
            
            sal_Int32 nCol = pDim->GetDimension();
            const Cell& rCell = rRow[nCol];
            if (aDimCell.mnStrId != rCell.mnStrId)
            {
                // Selected page dimension value does not match the current value.  Skip it.
                maRowsVisible[nRow] = false;
                break;
            }
        }
    }
}

const ::ScDPCacheTable::Cell* ScDPCacheTable::getCell(SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const

            // This row is filtered out.
            continue;

        if (!isRowQualified(nRow, rCriteria, bRepeatIfEmpty))

        vector<Criterion>::const_iterator itrEnd = rCriteria.end();
        for (vector<Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
        {
            if (itr->mnFieldIndex >= nColSize)
                // specified field is outside the source data columns.  Don't
                // use this criterion.
                continue;

            const Cell* pCell = getCell(static_cast<SCCOL>(itr->mnFieldIndex), nRow, bRepeatIfEmpty);
            if (!pCell)
            {
                // This should never happen, but just in case...
                bRetainRow = false;
                break;
            }

            if (!itr->mpFilter->match(*pCell))
            {
                bRetainRow = false;
                break;
            }
        }

        if (!bRetainRow)
            continue;

        // Insert this row into table.

    return maTable.empty();
}

bool ScDPCacheTable::isRowQualified(sal_Int32 nRow, const vector<Criterion>& rCriteria, bool bRepeatIfEmpty) const
{
    sal_Int32 nColSize = getColSize();
    vector<Criterion>::const_iterator itrEnd = rCriteria.end();
    for (vector<Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
    {
        if (itr->mnFieldIndex >= nColSize)
            // specified field is outside the source data columns.  Don't
            // use this criterion.
            continue;

        const Cell* pCell = getCell(static_cast<SCCOL>(itr->mnFieldIndex), nRow, bRepeatIfEmpty);
        if (!pCell)
            // This should never happen, but just in case...
            return false;

        if (!itr->mpFilter->match(*pCell))
            return false;
    }
    return true;
}

void ScDPCacheTable::getValueData(ScDocument* pDoc, const ScAddress& rPos, Cell& rCell)
{
    ScBaseCell* pCell = pDoc->GetCell(rPos);

Lines 1136-1153 void ScDPGroupTableData::CreateCacheTable() Link Here

(-)sc/source/core/data/dpgroup.cxx (-8 / +16 lines)
1136	pSourceData->CreateCacheTable();	1136	pSourceData->CreateCacheTable();
1137	}	1137	}
1138		1138
1139	void ScDPGroupTableData::FilterCacheTable(const vector<ScDPDimension*>& rPageDims)	1139	void ScDPGroupTableData::ModifyFilterCriteria(vector<ScDPCacheTable::Criterion>& rCriteria) const
1140	{
1141	pSourceData->FilterCacheTable(rPageDims);
1142	}
1143
1144	void ScDPGroupTableData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, Sequence< Sequence<Any> >& rData)
1145	{	1140	{
1146	typedef hash_map<long, const ScDPGroupDimension*> GroupFieldMapType;	1141	typedef hash_map<long, const ScDPGroupDimension*> GroupFieldMapType;
1147	GroupFieldMapType aGroupFieldIds;	1142	GroupFieldMapType aGroupFieldIds;
1148	{	1143	{
1149	ScDPGroupDimensionVec::const_iterator itrEnd = aGroups.end();	1144	ScDPGroupDimensionVec::const_iterator itr = aGroups.begin(), itrEnd = aGroups.end();
1150	for (ScDPGroupDimensionVec::const_iterator itr = aGroups.begin(); itr != itrEnd; ++itr)	1145	for (; itr != itrEnd; ++itr)
1151	aGroupFieldIds.insert( hash_map<long, const ScDPGroupDimension>::value_type(itr->GetGroupDim(), &(itr)) );	1146	aGroupFieldIds.insert( hash_map<long, const ScDPGroupDimension>::value_type(itr->GetGroupDim(), &(itr)) );
1152	}	1147	}
1153		1148
Lines 1240-1246 void ScDPGroupTableData::GetDrillDownData(const vector<ScDPCacheTable::Criterion Link Here
1240	}	1235	}
1241	}	1236	}
1242	}	1237	}
		1238	rCriteria.swap(aNewCriteria);
		1239	}
1243		1240
		1241	void ScDPGroupTableData::FilterCacheTable(const vector<ScDPCacheTable::Criterion>& rCriteria)
		1242	{
		1243	vector<ScDPCacheTable::Criterion> aNewCriteria(rCriteria);
		1244	ModifyFilterCriteria(aNewCriteria);
		1245	pSourceData->FilterCacheTable(aNewCriteria);
		1246	}
		1247
		1248	void ScDPGroupTableData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, Sequence< Sequence<Any> >& rData)
		1249	{
		1250	vector<ScDPCacheTable::Criterion> aNewCriteria(rCriteria);
		1251	ModifyFilterCriteria(aNewCriteria);
1244	pSourceData->GetDrillDownData(aNewCriteria, rData);	1252	pSourceData->GetDrillDownData(aNewCriteria, rData);
1245	}	1253	}
1246		1254

Lines 287-296 void ScDatabaseDPData::CreateCacheTable() Link Here

(-)sc/source/core/data/dpsdbtab.cxx (-2 / +2 lines)
287	pImpl->aCacheTable.fillTable(pImpl->xRowSet, *pImpl->pFormatter->GetNullDate());	287	pImpl->aCacheTable.fillTable(pImpl->xRowSet, *pImpl->pFormatter->GetNullDate());
288	}	288	}
289		289
290	void ScDatabaseDPData::FilterCacheTable(const vector<ScDPDimension*>& rPageDims)	290	void ScDatabaseDPData::FilterCacheTable(const vector<ScDPCacheTable::Criterion>& rCriteria)
291	{	291	{
292	CreateCacheTable();	292	CreateCacheTable();
293	pImpl->aCacheTable.filterByPageDimension(rPageDims);	293	pImpl->aCacheTable.filterByPageDimension(rCriteria, IsRepeatIfEmpty());
294	}	294	}
295		295
296	void ScDatabaseDPData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, Sequence< Sequence<Any> >& rData)	296	void ScDatabaseDPData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, Sequence< Sequence<Any> >& rData)

Lines 266-275 void ScSheetDPData::CreateCacheTable() Link Here

(-)sc/source/core/data/dpshttab.cxx (-2 / +2 lines)
266	pImpl->bIgnoreEmptyRows);	266	pImpl->bIgnoreEmptyRows);
267	}	267	}
268		268
269	void ScSheetDPData::FilterCacheTable(const vector<ScDPDimension*>& rPageDims)	269	void ScSheetDPData::FilterCacheTable(const vector<ScDPCacheTable::Criterion>& rCriteria)
270	{	270	{
271	CreateCacheTable();	271	CreateCacheTable();
272	pImpl->aCacheTable.filterByPageDimension(rPageDims);	272	pImpl->aCacheTable.filterByPageDimension(rCriteria, IsRepeatIfEmpty());
273	}	273	}
274		274
275	void ScSheetDPData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, Sequence< Sequence<Any> >& rData)	275	void ScSheetDPData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>& rCriteria, Sequence< Sequence<Any> >& rData)

Lines 191-199 void ScDPTableData::CreateCacheTable() Link Here

(-)sc/source/core/data/dptabdat.cxx (-2 / +2 lines)
191	fprintf(stdout, "ScDPTableData::CreateCacheTable: un-implemented...\n");fflush(stdout);	191	fprintf(stdout, "ScDPTableData::CreateCacheTable: un-implemented...\n");fflush(stdout);
192	}	192	}
193		193
194	void ScDPTableData::FilterCacheTable(const vector<ScDPDimension*>&)	194	void ScDPTableData::FilterCacheTable(const vector<ScDPCacheTable::Criterion>&)
195	{	195	{
196	fprintf(stdout, "ScDPTableData::FilterCacheTable: un-implemented...\n");fflush(stdout);	196	fprintf(stdout, "ScDPTableData::FilterCacheTable: un-implemented...\n");
197	}	197	}
198		198
199	void ScDPTableData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>&, Sequence< Sequence<Any> >&)	199	void ScDPTableData::GetDrillDownData(const vector<ScDPCacheTable::Criterion>&, Sequence< Sequence<Any> >&)




		else
		{
            {
                // filter table by page dimensions.
                vector<ScDPCacheTable::Criterion> aCriteria;
                for (i = 0; i < nPageDimCount; ++i)
                {
                    ScDPDimension* pDim = GetDimensionsObject()->getByIndex(nPageDims[i]);
                    if (!pDim || !pDim->HasSelectedPage())
                        continue;

                    long nField = pDim->GetDimension();
                    const ScDPItemData& rData = pDim->GetSelectedData();
                    aCriteria.push_back(ScDPCacheTable::Criterion());
                    ScDPCacheTable::Criterion& r = aCriteria.back();
                    r.mnFieldIndex = static_cast<sal_Int32>(nField);
                    sal_Int32 nStrId = ScSharedString::getStringId(rData.aString);
                    r.mpFilter.reset(
                        new ScDPCacheTable::SingleFilter(nStrId, rData.fValue, rData.bHasValue));
                }
                if (!aCriteria.empty())
                    pData->FilterCacheTable(aCriteria);
            }
            aInfo.aPageDims.reserve(nPageDimCount);
            for (i = 0; i < nPageDimCount; ++i)

Return to issue 90022

Lines 544-583 bool ScDPCacheTable::isRowActive(sal_Int32 nRow) const Link Here

(-)sc/source/core/data/dpcachetable.cxx (-52 / +27 lines)
544	return maRowsVisible[nRow];	544	return maRowsVisible[nRow];
545	}	545	}
546		546
547	void ScDPCacheTable::filterByPageDimension(const vector<ScDPDimension*>& rPageDims)	547	void ScDPCacheTable::filterByPageDimension(const vector<Criterion>& rCriteria, bool bRepeatIfEmpty)
548	{	548	{
549	sal_Int32 nRowSize = getRowSize();	549	sal_Int32 nRowSize = getRowSize();
550		550	sal_Int32 nColSize = getColSize();
551	if (nRowSize != static_cast<sal_Int32>(maRowsVisible.size()))	551	if (nRowSize != static_cast<sal_Int32>(maRowsVisible.size()))
552	{	552	{
553	fprintf(stdout, "ScDPCacheTable::filterByPageDimension: the sizes of the two tables differ.\n");fflush(stdout);	553	// sizes of the two tables differ!
554	return;	554	return;
555	}	555	}
556		556
557	for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)	557	for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
558	{	558	maRowsVisible[nRow] = isRowQualified(nRow, rCriteria, bRepeatIfEmpty);
559	maRowsVisible[nRow] = true;
560	const vector<Cell>& rRow = maTable[nRow];
561	vector<ScDPDimension*>::const_iterator itr = rPageDims.begin(), itrEnd = rPageDims.end();
562	for (; itr != itrEnd; ++itr)
563	{
564	ScDPDimension* pDim = *itr;
565	if (!pDim->HasSelectedPage())
566	// 'show all' is selected.
567	continue;
568
569	ScDPCacheTable::Cell aDimCell = getSelectedDimension(pDim);
570
571	sal_Int32 nCol = pDim->GetDimension();
572	const Cell& rCell = rRow[nCol];
573	if (aDimCell.mnStrId != rCell.mnStrId)
574	{
575	// Selected page dimension value does not match the current value. Skip it.
576	maRowsVisible[nRow] = false;
577	break;
578	}
579	}
580	}
581	}	559	}
582		560
583	const ::ScDPCacheTable::Cell* ScDPCacheTable::getCell(SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const	561	const ::ScDPCacheTable::Cell* ScDPCacheTable::getCell(SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
Lines 668-699 void ScDPCacheTable::filterTable(const vector<Criterion>& rCriteria, Sequence< S Link Here
668	// This row is filtered out.	646	// This row is filtered out.
669	continue;	647	continue;
670		648
671	bool bRetainRow = true;	649	if (!isRowQualified(nRow, rCriteria, bRepeatIfEmpty))
672
673	vector<Criterion>::const_iterator itrEnd = rCriteria.end();
674	for (vector<Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
675	{
676	if (itr->mnFieldIndex >= nColSize)
677	// specified field is outside the source data columns. Don't
678	// use this criterion.
679	continue;
680
681	const Cell* pCell = getCell(static_cast<SCCOL>(itr->mnFieldIndex), nRow, bRepeatIfEmpty);
682	if (!pCell)
683	{
684	// This should never happen, but just in case...
685	bRetainRow = false;
686	break;
687	}
688
689	if (!itr->mpFilter->match(*pCell))
690	{
691	bRetainRow = false;
692	break;
693	}
694	}
695
696	if (!bRetainRow)
697	continue;	650	continue;
698		651
699	// Insert this row into table.	652	// Insert this row into table.
Lines 756-761 bool ScDPCacheTable::empty() const Link Here
756	return maTable.empty();	709	return maTable.empty();
757	}	710	}
758		711
		712	bool ScDPCacheTable::isRowQualified(sal_Int32 nRow, const vector<Criterion>& rCriteria, bool bRepeatIfEmpty) const
		713	{
		714	sal_Int32 nColSize = getColSize();
		715	vector<Criterion>::const_iterator itrEnd = rCriteria.end();
		716	for (vector<Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
		717	{
		718	if (itr->mnFieldIndex >= nColSize)
		719	// specified field is outside the source data columns. Don't
		720	// use this criterion.
		721	continue;
		722
		723	const Cell* pCell = getCell(static_cast<SCCOL>(itr->mnFieldIndex), nRow, bRepeatIfEmpty);
		724	if (!pCell)
		725	// This should never happen, but just in case...
		726	return false;
		727
		728	if (!itr->mpFilter->match(*pCell))
		729	return false;
		730	}
		731	return true;
		732	}
		733
759	void ScDPCacheTable::getValueData(ScDocument* pDoc, const ScAddress& rPos, Cell& rCell)	734	void ScDPCacheTable::getValueData(ScDocument* pDoc, const ScAddress& rPos, Cell& rCell)
760	{	735	{
761	ScBaseCell* pCell = pDoc->GetCell(rPos);	736	ScBaseCell* pCell = pDoc->GetCell(rPos);

Lines 834-848 void ScDPSource::CreateRes_Impl() Link Here

(-)sc/source/core/data/dptabsrc.cxx (-5 / +15 lines)
834	else	834	else
835	{	835	{
836	{	836	{
837	vector<ScDPDimension*> aPageDims;	837	// filter table by page dimensions.
838	aPageDims.reserve(nPageDimCount);	838	vector<ScDPCacheTable::Criterion> aCriteria;
839	for (i = 0; i < nPageDimCount; ++i)	839	for (i = 0; i < nPageDimCount; ++i)
840	{	840	{
841	ScDPDimension* pDim = GetDimensionsObject()->getByIndex(nPageDims[i]);	841	ScDPDimension* pDim = GetDimensionsObject()->getByIndex(nPageDims[i]);
842	if (pDim)	842	if (!pDim \|\| !pDim->HasSelectedPage())
843	aPageDims.push_back(pDim);	843	continue;
		844
		845	long nField = pDim->GetDimension();
		846	const ScDPItemData& rData = pDim->GetSelectedData();
		847	aCriteria.push_back(ScDPCacheTable::Criterion());
		848	ScDPCacheTable::Criterion& r = aCriteria.back();
		849	r.mnFieldIndex = static_cast<sal_Int32>(nField);
		850	sal_Int32 nStrId = ScSharedString::getStringId(rData.aString);
		851	r.mpFilter.reset(
		852	new ScDPCacheTable::SingleFilter(nStrId, rData.fValue, rData.bHasValue));
844	}	853	}
845	pData->FilterCacheTable(aPageDims);	854	if (!aCriteria.empty())
		855	pData->FilterCacheTable(aCriteria);
846	}	856	}
847	aInfo.aPageDims.reserve(nPageDimCount);	857	aInfo.aPageDims.reserve(nPageDimCount);
848	for (i = 0; i < nPageDimCount; ++i)	858	for (i = 0; i < nPageDimCount; ++i)