1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
24*b1cdbd2cSJim Jagielski #include "precompiled_sc.hxx"
25*b1cdbd2cSJim Jagielski
26*b1cdbd2cSJim Jagielski #include "dpcachetable.hxx"
27*b1cdbd2cSJim Jagielski #include "document.hxx"
28*b1cdbd2cSJim Jagielski #include "address.hxx"
29*b1cdbd2cSJim Jagielski #include "cell.hxx"
30*b1cdbd2cSJim Jagielski #include "dptabdat.hxx"
31*b1cdbd2cSJim Jagielski #include "dptabsrc.hxx"
32*b1cdbd2cSJim Jagielski #include "dpobject.hxx"
33*b1cdbd2cSJim Jagielski #include "queryparam.hxx"
34*b1cdbd2cSJim Jagielski
35*b1cdbd2cSJim Jagielski #include <com/sun/star/i18n/LocaleDataItem.hpp>
36*b1cdbd2cSJim Jagielski #include <com/sun/star/sdbc/DataType.hpp>
37*b1cdbd2cSJim Jagielski #include <com/sun/star/sdbc/XRow.hpp>
38*b1cdbd2cSJim Jagielski #include <com/sun/star/sdbc/XRowSet.hpp>
39*b1cdbd2cSJim Jagielski #include <com/sun/star/sdbc/XResultSetMetaData.hpp>
40*b1cdbd2cSJim Jagielski #include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp>
41*b1cdbd2cSJim Jagielski #include <com/sun/star/util/Date.hpp>
42*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
43*b1cdbd2cSJim Jagielski #include <com/sun/star/sheet/DataPilotFieldGroupBy.hpp>
44*b1cdbd2cSJim Jagielski
45*b1cdbd2cSJim Jagielski #include <memory>
46*b1cdbd2cSJim Jagielski
47*b1cdbd2cSJim Jagielski using namespace ::com::sun::star;
48*b1cdbd2cSJim Jagielski
49*b1cdbd2cSJim Jagielski using ::rtl::OUString;
50*b1cdbd2cSJim Jagielski using ::std::vector;
51*b1cdbd2cSJim Jagielski using ::std::pair;
52*b1cdbd2cSJim Jagielski using ::std::hash_map;
53*b1cdbd2cSJim Jagielski using ::std::hash_set;
54*b1cdbd2cSJim Jagielski using ::std::auto_ptr;
55*b1cdbd2cSJim Jagielski using ::com::sun::star::i18n::LocaleDataItem;
56*b1cdbd2cSJim Jagielski using ::com::sun::star::uno::Exception;
57*b1cdbd2cSJim Jagielski using ::com::sun::star::uno::Reference;
58*b1cdbd2cSJim Jagielski using ::com::sun::star::uno::Sequence;
59*b1cdbd2cSJim Jagielski using ::com::sun::star::uno::Any;
60*b1cdbd2cSJim Jagielski using ::com::sun::star::uno::UNO_QUERY;
61*b1cdbd2cSJim Jagielski using ::com::sun::star::uno::UNO_QUERY_THROW;
62*b1cdbd2cSJim Jagielski using ::com::sun::star::sheet::DataPilotFieldFilter;
63*b1cdbd2cSJim Jagielski
64*b1cdbd2cSJim Jagielski
lcl_HasQueryEntry(const ScQueryParam & rParam)65*b1cdbd2cSJim Jagielski static sal_Bool lcl_HasQueryEntry( const ScQueryParam& rParam )
66*b1cdbd2cSJim Jagielski {
67*b1cdbd2cSJim Jagielski return rParam.GetEntryCount() > 0 &&
68*b1cdbd2cSJim Jagielski rParam.GetEntry(0).bDoQuery;
69*b1cdbd2cSJim Jagielski }
70*b1cdbd2cSJim Jagielski
71*b1cdbd2cSJim Jagielski // ----------------------------------------------------------------------------
72*b1cdbd2cSJim Jagielski
FilterItem()73*b1cdbd2cSJim Jagielski ScDPCacheTable::FilterItem::FilterItem() :
74*b1cdbd2cSJim Jagielski mfValue(0.0),
75*b1cdbd2cSJim Jagielski mbHasValue(false)
76*b1cdbd2cSJim Jagielski {
77*b1cdbd2cSJim Jagielski }
match(const ScDPItemData & rCellData) const78*b1cdbd2cSJim Jagielski bool ScDPCacheTable::FilterItem::match( const ScDPItemData& rCellData ) const
79*b1cdbd2cSJim Jagielski {
80*b1cdbd2cSJim Jagielski if (rCellData.GetString()!= maString &&
81*b1cdbd2cSJim Jagielski (!rCellData.IsValue()|| rCellData.GetValue()!= mfValue))
82*b1cdbd2cSJim Jagielski return false;
83*b1cdbd2cSJim Jagielski return true;
84*b1cdbd2cSJim Jagielski }
85*b1cdbd2cSJim Jagielski // ----------------------------------------------------------------------------
86*b1cdbd2cSJim Jagielski
SingleFilter(String aString,double fValue,bool bHasValue)87*b1cdbd2cSJim Jagielski ScDPCacheTable::SingleFilter::SingleFilter(String aString, double fValue, bool bHasValue)
88*b1cdbd2cSJim Jagielski {
89*b1cdbd2cSJim Jagielski maItem.maString = aString;
90*b1cdbd2cSJim Jagielski maItem.mfValue = fValue;
91*b1cdbd2cSJim Jagielski maItem.mbHasValue = bHasValue;
92*b1cdbd2cSJim Jagielski }
93*b1cdbd2cSJim Jagielski
match(const ScDPItemData & rCellData) const94*b1cdbd2cSJim Jagielski bool ScDPCacheTable::SingleFilter::match( const ScDPItemData& rCellData ) const
95*b1cdbd2cSJim Jagielski {
96*b1cdbd2cSJim Jagielski return maItem.match(rCellData);
97*b1cdbd2cSJim Jagielski }
98*b1cdbd2cSJim Jagielski
getMatchString()99*b1cdbd2cSJim Jagielski const String ScDPCacheTable::SingleFilter::getMatchString()
100*b1cdbd2cSJim Jagielski {
101*b1cdbd2cSJim Jagielski return maItem.maString;
102*b1cdbd2cSJim Jagielski }
103*b1cdbd2cSJim Jagielski
getMatchValue() const104*b1cdbd2cSJim Jagielski double ScDPCacheTable::SingleFilter::getMatchValue() const
105*b1cdbd2cSJim Jagielski {
106*b1cdbd2cSJim Jagielski return maItem.mfValue;
107*b1cdbd2cSJim Jagielski }
108*b1cdbd2cSJim Jagielski
hasValue() const109*b1cdbd2cSJim Jagielski bool ScDPCacheTable::SingleFilter::hasValue() const
110*b1cdbd2cSJim Jagielski {
111*b1cdbd2cSJim Jagielski return maItem.mbHasValue;
112*b1cdbd2cSJim Jagielski }
113*b1cdbd2cSJim Jagielski
114*b1cdbd2cSJim Jagielski // ----------------------------------------------------------------------------
115*b1cdbd2cSJim Jagielski
GroupFilter()116*b1cdbd2cSJim Jagielski ScDPCacheTable::GroupFilter::GroupFilter()
117*b1cdbd2cSJim Jagielski {
118*b1cdbd2cSJim Jagielski }
119*b1cdbd2cSJim Jagielski
match(const ScDPItemData & rCellData) const120*b1cdbd2cSJim Jagielski bool ScDPCacheTable::GroupFilter::match( const ScDPItemData& rCellData ) const
121*b1cdbd2cSJim Jagielski {
122*b1cdbd2cSJim Jagielski vector<FilterItem>::const_iterator itrEnd = maItems.end();
123*b1cdbd2cSJim Jagielski for (vector<FilterItem>::const_iterator itr = maItems.begin(); itr != itrEnd; ++itr)
124*b1cdbd2cSJim Jagielski {
125*b1cdbd2cSJim Jagielski bool bMatch = itr->match( rCellData);
126*b1cdbd2cSJim Jagielski if (bMatch)
127*b1cdbd2cSJim Jagielski return true;
128*b1cdbd2cSJim Jagielski }
129*b1cdbd2cSJim Jagielski return false;
130*b1cdbd2cSJim Jagielski }
131*b1cdbd2cSJim Jagielski
addMatchItem(const String & rStr,double fVal,bool bHasValue)132*b1cdbd2cSJim Jagielski void ScDPCacheTable::GroupFilter::addMatchItem(const String& rStr, double fVal, bool bHasValue)
133*b1cdbd2cSJim Jagielski {
134*b1cdbd2cSJim Jagielski FilterItem aItem;
135*b1cdbd2cSJim Jagielski aItem.maString = rStr;
136*b1cdbd2cSJim Jagielski aItem.mfValue = fVal;
137*b1cdbd2cSJim Jagielski aItem.mbHasValue = bHasValue;
138*b1cdbd2cSJim Jagielski maItems.push_back(aItem);
139*b1cdbd2cSJim Jagielski }
140*b1cdbd2cSJim Jagielski
getMatchItemCount() const141*b1cdbd2cSJim Jagielski size_t ScDPCacheTable::GroupFilter::getMatchItemCount() const
142*b1cdbd2cSJim Jagielski {
143*b1cdbd2cSJim Jagielski return maItems.size();
144*b1cdbd2cSJim Jagielski }
145*b1cdbd2cSJim Jagielski
146*b1cdbd2cSJim Jagielski // ----------------------------------------------------------------------------
147*b1cdbd2cSJim Jagielski
Criterion()148*b1cdbd2cSJim Jagielski ScDPCacheTable::Criterion::Criterion() :
149*b1cdbd2cSJim Jagielski mnFieldIndex(-1),
150*b1cdbd2cSJim Jagielski mpFilter(static_cast<FilterBase*>(NULL))
151*b1cdbd2cSJim Jagielski {
152*b1cdbd2cSJim Jagielski }
153*b1cdbd2cSJim Jagielski
154*b1cdbd2cSJim Jagielski // ----------------------------------------------------------------------------
155*b1cdbd2cSJim Jagielski
ScDPCacheTable(ScDocument * pDoc,long nId)156*b1cdbd2cSJim Jagielski ScDPCacheTable::ScDPCacheTable( ScDocument* pDoc,long nId ) :
157*b1cdbd2cSJim Jagielski mpCache( NULL ),
158*b1cdbd2cSJim Jagielski mpNoneCache( NULL )
159*b1cdbd2cSJim Jagielski {
160*b1cdbd2cSJim Jagielski if ( nId >= 0 )
161*b1cdbd2cSJim Jagielski mpCache = pDoc->GetDPObjectCache( nId );
162*b1cdbd2cSJim Jagielski else
163*b1cdbd2cSJim Jagielski { //create a temp cache object
164*b1cdbd2cSJim Jagielski InitNoneCache( NULL );
165*b1cdbd2cSJim Jagielski }
166*b1cdbd2cSJim Jagielski }
167*b1cdbd2cSJim Jagielski
~ScDPCacheTable()168*b1cdbd2cSJim Jagielski ScDPCacheTable::~ScDPCacheTable()
169*b1cdbd2cSJim Jagielski {
170*b1cdbd2cSJim Jagielski }
171*b1cdbd2cSJim Jagielski
getRowSize() const172*b1cdbd2cSJim Jagielski sal_Int32 ScDPCacheTable::getRowSize() const
173*b1cdbd2cSJim Jagielski {
174*b1cdbd2cSJim Jagielski return GetCache()->GetRowCount();
175*b1cdbd2cSJim Jagielski }
176*b1cdbd2cSJim Jagielski
getColSize() const177*b1cdbd2cSJim Jagielski sal_Int32 ScDPCacheTable::getColSize() const
178*b1cdbd2cSJim Jagielski {
179*b1cdbd2cSJim Jagielski return GetCache()->GetColumnCount();
180*b1cdbd2cSJim Jagielski }
181*b1cdbd2cSJim Jagielski
fillTable(const ScQueryParam & rQuery,sal_Bool * pSpecial,bool bIgnoreEmptyRows,bool bRepeatIfEmpty)182*b1cdbd2cSJim Jagielski void ScDPCacheTable::fillTable( const ScQueryParam& rQuery, sal_Bool* pSpecial,
183*b1cdbd2cSJim Jagielski bool bIgnoreEmptyRows, bool bRepeatIfEmpty )
184*b1cdbd2cSJim Jagielski {
185*b1cdbd2cSJim Jagielski if ( mpCache == NULL )
186*b1cdbd2cSJim Jagielski InitNoneCache( NULL );
187*b1cdbd2cSJim Jagielski //check cache
188*b1cdbd2cSJim Jagielski const SCROW nRowCount = getRowSize();
189*b1cdbd2cSJim Jagielski const SCCOL nColCount = (SCCOL) getColSize();
190*b1cdbd2cSJim Jagielski if ( nRowCount <= 0 || nColCount <= 0)
191*b1cdbd2cSJim Jagielski return;
192*b1cdbd2cSJim Jagielski
193*b1cdbd2cSJim Jagielski maRowsVisible.clear();
194*b1cdbd2cSJim Jagielski maRowsVisible.reserve(nRowCount);
195*b1cdbd2cSJim Jagielski
196*b1cdbd2cSJim Jagielski
197*b1cdbd2cSJim Jagielski // Initialize field entries container.
198*b1cdbd2cSJim Jagielski maFieldEntries.clear();
199*b1cdbd2cSJim Jagielski maFieldEntries.reserve(nColCount);
200*b1cdbd2cSJim Jagielski
201*b1cdbd2cSJim Jagielski // Data rows
202*b1cdbd2cSJim Jagielski for (SCCOL nCol = 0; nCol < nColCount; ++nCol)
203*b1cdbd2cSJim Jagielski {
204*b1cdbd2cSJim Jagielski SCROW nMemCount = GetCache()->GetDimMemberCount( nCol );
205*b1cdbd2cSJim Jagielski if ( nMemCount )
206*b1cdbd2cSJim Jagielski {
207*b1cdbd2cSJim Jagielski std::vector< SCROW > pAdded( nMemCount, -1 );
208*b1cdbd2cSJim Jagielski
209*b1cdbd2cSJim Jagielski for (SCROW nRow = 0; nRow < nRowCount; ++nRow )
210*b1cdbd2cSJim Jagielski {
211*b1cdbd2cSJim Jagielski SCROW nIndex = GetCache()->GetItemDataId( nCol, nRow, bRepeatIfEmpty );
212*b1cdbd2cSJim Jagielski SCROW nOrder = GetCache()->GetOrder( nCol, nIndex );
213*b1cdbd2cSJim Jagielski
214*b1cdbd2cSJim Jagielski if ( nCol == 0 )
215*b1cdbd2cSJim Jagielski maRowsVisible.push_back(false);
216*b1cdbd2cSJim Jagielski
217*b1cdbd2cSJim Jagielski if ( lcl_HasQueryEntry(rQuery) &&
218*b1cdbd2cSJim Jagielski !GetCache()->ValidQuery( nRow , rQuery, pSpecial ) )
219*b1cdbd2cSJim Jagielski continue;
220*b1cdbd2cSJim Jagielski if ( bIgnoreEmptyRows && GetCache()->IsRowEmpty( nRow ) )
221*b1cdbd2cSJim Jagielski continue;
222*b1cdbd2cSJim Jagielski // Insert a new row into cache table.
223*b1cdbd2cSJim Jagielski if ( nCol == 0 )
224*b1cdbd2cSJim Jagielski maRowsVisible.back() = true;
225*b1cdbd2cSJim Jagielski
226*b1cdbd2cSJim Jagielski pAdded[nOrder] = nIndex;
227*b1cdbd2cSJim Jagielski }
228*b1cdbd2cSJim Jagielski maFieldEntries.push_back( vector<SCROW>() );
229*b1cdbd2cSJim Jagielski for ( SCROW nRow = 0; nRow < nMemCount; nRow++ )
230*b1cdbd2cSJim Jagielski {
231*b1cdbd2cSJim Jagielski if ( pAdded[nRow] != -1 )
232*b1cdbd2cSJim Jagielski maFieldEntries.back().push_back( pAdded[nRow] );
233*b1cdbd2cSJim Jagielski }
234*b1cdbd2cSJim Jagielski }
235*b1cdbd2cSJim Jagielski }
236*b1cdbd2cSJim Jagielski }
237*b1cdbd2cSJim Jagielski
fillTable()238*b1cdbd2cSJim Jagielski void ScDPCacheTable::fillTable()
239*b1cdbd2cSJim Jagielski {
240*b1cdbd2cSJim Jagielski if ( mpCache == NULL )
241*b1cdbd2cSJim Jagielski InitNoneCache( NULL );
242*b1cdbd2cSJim Jagielski //check cache
243*b1cdbd2cSJim Jagielski const SCROW nRowCount = getRowSize();
244*b1cdbd2cSJim Jagielski const SCCOL nColCount = (SCCOL) getColSize();
245*b1cdbd2cSJim Jagielski if ( nRowCount <= 0 || nColCount <= 0)
246*b1cdbd2cSJim Jagielski return;
247*b1cdbd2cSJim Jagielski
248*b1cdbd2cSJim Jagielski maRowsVisible.clear();
249*b1cdbd2cSJim Jagielski maRowsVisible.reserve(nRowCount);
250*b1cdbd2cSJim Jagielski
251*b1cdbd2cSJim Jagielski
252*b1cdbd2cSJim Jagielski // Initialize field entries container.
253*b1cdbd2cSJim Jagielski maFieldEntries.clear();
254*b1cdbd2cSJim Jagielski maFieldEntries.reserve(nColCount);
255*b1cdbd2cSJim Jagielski
256*b1cdbd2cSJim Jagielski // Data rows
257*b1cdbd2cSJim Jagielski for (SCCOL nCol = 0; nCol < nColCount; ++nCol)
258*b1cdbd2cSJim Jagielski {
259*b1cdbd2cSJim Jagielski SCROW nMemCount = GetCache()->GetDimMemberCount( nCol );
260*b1cdbd2cSJim Jagielski if ( nMemCount )
261*b1cdbd2cSJim Jagielski {
262*b1cdbd2cSJim Jagielski std::vector< SCROW > pAdded( nMemCount, -1 );
263*b1cdbd2cSJim Jagielski
264*b1cdbd2cSJim Jagielski for (SCROW nRow = 0; nRow < nRowCount; ++nRow )
265*b1cdbd2cSJim Jagielski {
266*b1cdbd2cSJim Jagielski SCROW nIndex = GetCache()->GetItemDataId( nCol, nRow, false );
267*b1cdbd2cSJim Jagielski SCROW nOrder = GetCache()->GetOrder( nCol, nIndex );
268*b1cdbd2cSJim Jagielski
269*b1cdbd2cSJim Jagielski if ( nCol == 0 )
270*b1cdbd2cSJim Jagielski maRowsVisible.push_back(true);
271*b1cdbd2cSJim Jagielski
272*b1cdbd2cSJim Jagielski
273*b1cdbd2cSJim Jagielski pAdded[nOrder] = nIndex;
274*b1cdbd2cSJim Jagielski }
275*b1cdbd2cSJim Jagielski maFieldEntries.push_back( vector<SCROW>() );
276*b1cdbd2cSJim Jagielski for ( SCROW nRow = 0; nRow < nMemCount; nRow++ )
277*b1cdbd2cSJim Jagielski {
278*b1cdbd2cSJim Jagielski if ( pAdded[nRow] != -1 )
279*b1cdbd2cSJim Jagielski maFieldEntries.back().push_back( pAdded[nRow] );
280*b1cdbd2cSJim Jagielski }
281*b1cdbd2cSJim Jagielski }
282*b1cdbd2cSJim Jagielski }
283*b1cdbd2cSJim Jagielski return;
284*b1cdbd2cSJim Jagielski }
285*b1cdbd2cSJim Jagielski
isRowActive(sal_Int32 nRow) const286*b1cdbd2cSJim Jagielski bool ScDPCacheTable::isRowActive(sal_Int32 nRow) const
287*b1cdbd2cSJim Jagielski {
288*b1cdbd2cSJim Jagielski if (nRow < 0 || static_cast<size_t>(nRow) >= maRowsVisible.size())
289*b1cdbd2cSJim Jagielski // row index out of bound
290*b1cdbd2cSJim Jagielski return false;
291*b1cdbd2cSJim Jagielski
292*b1cdbd2cSJim Jagielski return maRowsVisible[nRow];
293*b1cdbd2cSJim Jagielski }
294*b1cdbd2cSJim Jagielski
filterByPageDimension(const vector<Criterion> & rCriteria,const hash_set<sal_Int32> & rRepeatIfEmptyDims)295*b1cdbd2cSJim Jagielski void ScDPCacheTable::filterByPageDimension(const vector<Criterion>& rCriteria, const hash_set<sal_Int32>& rRepeatIfEmptyDims)
296*b1cdbd2cSJim Jagielski {
297*b1cdbd2cSJim Jagielski sal_Int32 nRowSize = getRowSize();
298*b1cdbd2cSJim Jagielski if (nRowSize != static_cast<sal_Int32>(maRowsVisible.size()))
299*b1cdbd2cSJim Jagielski {
300*b1cdbd2cSJim Jagielski // sizes of the two tables differ!
301*b1cdbd2cSJim Jagielski return;
302*b1cdbd2cSJim Jagielski }
303*b1cdbd2cSJim Jagielski
304*b1cdbd2cSJim Jagielski // #i117661# If maRowsVisible is already false from source filtering, don't set to true again.
305*b1cdbd2cSJim Jagielski // filterByPageDimension is called only once after initializing with fillTable
306*b1cdbd2cSJim Jagielski // (this is enforced in ScDPSource::FilterCacheTableByPageDimensions).
307*b1cdbd2cSJim Jagielski
308*b1cdbd2cSJim Jagielski for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
309*b1cdbd2cSJim Jagielski maRowsVisible[nRow] = maRowsVisible[nRow] && isRowQualified(nRow, rCriteria, rRepeatIfEmptyDims);
310*b1cdbd2cSJim Jagielski }
311*b1cdbd2cSJim Jagielski
getCell(SCCOL nCol,SCROW nRow,bool bRepeatIfEmpty) const312*b1cdbd2cSJim Jagielski const ScDPItemData* ScDPCacheTable::getCell(SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
313*b1cdbd2cSJim Jagielski {
314*b1cdbd2cSJim Jagielski SCROW nId= GetCache()->GetItemDataId(nCol, nRow, bRepeatIfEmpty);
315*b1cdbd2cSJim Jagielski return GetCache()->GetItemDataById( nCol, nId );
316*b1cdbd2cSJim Jagielski }
317*b1cdbd2cSJim Jagielski
getValue(ScDPValueData & rVal,SCCOL nCol,SCROW nRow,bool bRepeatIfEmpty) const318*b1cdbd2cSJim Jagielski void ScDPCacheTable::getValue( ScDPValueData& rVal, SCCOL nCol, SCROW nRow, bool bRepeatIfEmpty) const
319*b1cdbd2cSJim Jagielski {
320*b1cdbd2cSJim Jagielski const ScDPItemData* pData = getCell( nCol, nRow, bRepeatIfEmpty );
321*b1cdbd2cSJim Jagielski
322*b1cdbd2cSJim Jagielski if (pData)
323*b1cdbd2cSJim Jagielski {
324*b1cdbd2cSJim Jagielski rVal.fValue = pData->IsValue() ? pData->GetValue() : 0.0;
325*b1cdbd2cSJim Jagielski rVal.nType = pData->GetType();
326*b1cdbd2cSJim Jagielski }
327*b1cdbd2cSJim Jagielski else
328*b1cdbd2cSJim Jagielski rVal.Set(0.0, SC_VALTYPE_EMPTY);
329*b1cdbd2cSJim Jagielski }
getFieldName(SCCOL nIndex) const330*b1cdbd2cSJim Jagielski String ScDPCacheTable::getFieldName(SCCOL nIndex) const
331*b1cdbd2cSJim Jagielski {
332*b1cdbd2cSJim Jagielski return (GetCache()->GetDimensionName( nIndex ));
333*b1cdbd2cSJim Jagielski }
334*b1cdbd2cSJim Jagielski
getFieldIndex(const String & rStr) const335*b1cdbd2cSJim Jagielski sal_Int32 ScDPCacheTable::getFieldIndex(const String& rStr) const
336*b1cdbd2cSJim Jagielski {
337*b1cdbd2cSJim Jagielski return GetCache()->GetDimensionIndex( rStr );
338*b1cdbd2cSJim Jagielski }
339*b1cdbd2cSJim Jagielski
getFieldEntries(sal_Int32 nColumn) const340*b1cdbd2cSJim Jagielski const ::std::vector<SCROW>& ScDPCacheTable::getFieldEntries( sal_Int32 nColumn ) const
341*b1cdbd2cSJim Jagielski {
342*b1cdbd2cSJim Jagielski if (nColumn < 0 || static_cast<size_t>(nColumn) >= maFieldEntries.size())
343*b1cdbd2cSJim Jagielski {
344*b1cdbd2cSJim Jagielski // index out of bound. Hopefully this code will never be reached.
345*b1cdbd2cSJim Jagielski static const ::std::vector<SCROW> emptyEntries;
346*b1cdbd2cSJim Jagielski return emptyEntries;
347*b1cdbd2cSJim Jagielski }
348*b1cdbd2cSJim Jagielski return maFieldEntries[nColumn];
349*b1cdbd2cSJim Jagielski }
350*b1cdbd2cSJim Jagielski
filterTable(const vector<Criterion> & rCriteria,Sequence<Sequence<Any>> & rTabData,const hash_set<sal_Int32> & rRepeatIfEmptyDims)351*b1cdbd2cSJim Jagielski void ScDPCacheTable::filterTable(const vector<Criterion>& rCriteria, Sequence< Sequence<Any> >& rTabData,
352*b1cdbd2cSJim Jagielski const hash_set<sal_Int32>& rRepeatIfEmptyDims)
353*b1cdbd2cSJim Jagielski {
354*b1cdbd2cSJim Jagielski sal_Int32 nRowSize = getRowSize();
355*b1cdbd2cSJim Jagielski sal_Int32 nColSize = getColSize();
356*b1cdbd2cSJim Jagielski
357*b1cdbd2cSJim Jagielski if (!nRowSize)
358*b1cdbd2cSJim Jagielski // no data to filter.
359*b1cdbd2cSJim Jagielski return;
360*b1cdbd2cSJim Jagielski
361*b1cdbd2cSJim Jagielski // Row first, then column.
362*b1cdbd2cSJim Jagielski vector< Sequence<Any> > tableData;
363*b1cdbd2cSJim Jagielski tableData.reserve(nRowSize+1);
364*b1cdbd2cSJim Jagielski
365*b1cdbd2cSJim Jagielski // Header first.
366*b1cdbd2cSJim Jagielski Sequence<Any> headerRow(nColSize);
367*b1cdbd2cSJim Jagielski for (SCCOL nCol = 0; nCol < nColSize; ++nCol)
368*b1cdbd2cSJim Jagielski {
369*b1cdbd2cSJim Jagielski OUString str;
370*b1cdbd2cSJim Jagielski str = getFieldName( nCol);
371*b1cdbd2cSJim Jagielski Any any;
372*b1cdbd2cSJim Jagielski any <<= str;
373*b1cdbd2cSJim Jagielski headerRow[nCol] = any;
374*b1cdbd2cSJim Jagielski }
375*b1cdbd2cSJim Jagielski tableData.push_back(headerRow);
376*b1cdbd2cSJim Jagielski
377*b1cdbd2cSJim Jagielski
378*b1cdbd2cSJim Jagielski for (sal_Int32 nRow = 0; nRow < nRowSize; ++nRow)
379*b1cdbd2cSJim Jagielski {
380*b1cdbd2cSJim Jagielski if (!maRowsVisible[nRow])
381*b1cdbd2cSJim Jagielski // This row is filtered out.
382*b1cdbd2cSJim Jagielski continue;
383*b1cdbd2cSJim Jagielski
384*b1cdbd2cSJim Jagielski if (!isRowQualified(nRow, rCriteria, rRepeatIfEmptyDims))
385*b1cdbd2cSJim Jagielski continue;
386*b1cdbd2cSJim Jagielski
387*b1cdbd2cSJim Jagielski // Insert this row into table.
388*b1cdbd2cSJim Jagielski
389*b1cdbd2cSJim Jagielski Sequence<Any> row(nColSize);
390*b1cdbd2cSJim Jagielski for (SCCOL nCol = 0; nCol < nColSize; ++nCol)
391*b1cdbd2cSJim Jagielski {
392*b1cdbd2cSJim Jagielski Any any;
393*b1cdbd2cSJim Jagielski bool bRepeatIfEmpty = rRepeatIfEmptyDims.count(nCol) > 0;
394*b1cdbd2cSJim Jagielski // Wang Xu Ming - DataPilot migration
395*b1cdbd2cSJim Jagielski const ScDPItemData* pData= getCell(nCol, nRow, bRepeatIfEmpty);
396*b1cdbd2cSJim Jagielski if ( pData->IsValue() )
397*b1cdbd2cSJim Jagielski any <<= pData->GetValue();
398*b1cdbd2cSJim Jagielski else
399*b1cdbd2cSJim Jagielski {
400*b1cdbd2cSJim Jagielski OUString string (pData->GetString() );
401*b1cdbd2cSJim Jagielski any <<= string;
402*b1cdbd2cSJim Jagielski }
403*b1cdbd2cSJim Jagielski row[nCol] = any;
404*b1cdbd2cSJim Jagielski }
405*b1cdbd2cSJim Jagielski tableData.push_back(row);
406*b1cdbd2cSJim Jagielski }
407*b1cdbd2cSJim Jagielski
408*b1cdbd2cSJim Jagielski // convert vector to Seqeunce
409*b1cdbd2cSJim Jagielski sal_Int32 nTabSize = static_cast<sal_Int32>(tableData.size());
410*b1cdbd2cSJim Jagielski rTabData.realloc(nTabSize);
411*b1cdbd2cSJim Jagielski for (sal_Int32 i = 0; i < nTabSize; ++i)
412*b1cdbd2cSJim Jagielski rTabData[i] = tableData[i];
413*b1cdbd2cSJim Jagielski }
414*b1cdbd2cSJim Jagielski
clear()415*b1cdbd2cSJim Jagielski void ScDPCacheTable::clear()
416*b1cdbd2cSJim Jagielski {
417*b1cdbd2cSJim Jagielski maFieldEntries.clear();
418*b1cdbd2cSJim Jagielski maRowsVisible.clear();
419*b1cdbd2cSJim Jagielski }
420*b1cdbd2cSJim Jagielski
swap(ScDPCacheTable & rOther)421*b1cdbd2cSJim Jagielski void ScDPCacheTable::swap(ScDPCacheTable& rOther)
422*b1cdbd2cSJim Jagielski {
423*b1cdbd2cSJim Jagielski maFieldEntries.swap(rOther.maFieldEntries);
424*b1cdbd2cSJim Jagielski maRowsVisible.swap(rOther.maRowsVisible);
425*b1cdbd2cSJim Jagielski }
426*b1cdbd2cSJim Jagielski
empty() const427*b1cdbd2cSJim Jagielski bool ScDPCacheTable::empty() const
428*b1cdbd2cSJim Jagielski {
429*b1cdbd2cSJim Jagielski return ( mpCache == NULL&& mpNoneCache == NULL ) || maFieldEntries.size()==0;
430*b1cdbd2cSJim Jagielski }
431*b1cdbd2cSJim Jagielski
isRowQualified(sal_Int32 nRow,const vector<Criterion> & rCriteria,const hash_set<sal_Int32> & rRepeatIfEmptyDims) const432*b1cdbd2cSJim Jagielski bool ScDPCacheTable::isRowQualified(sal_Int32 nRow, const vector<Criterion>& rCriteria,
433*b1cdbd2cSJim Jagielski const hash_set<sal_Int32>& rRepeatIfEmptyDims) const
434*b1cdbd2cSJim Jagielski {
435*b1cdbd2cSJim Jagielski sal_Int32 nColSize = getColSize();
436*b1cdbd2cSJim Jagielski vector<Criterion>::const_iterator itrEnd = rCriteria.end();
437*b1cdbd2cSJim Jagielski for (vector<Criterion>::const_iterator itr = rCriteria.begin(); itr != itrEnd; ++itr)
438*b1cdbd2cSJim Jagielski {
439*b1cdbd2cSJim Jagielski if (itr->mnFieldIndex >= nColSize)
440*b1cdbd2cSJim Jagielski // specified field is outside the source data columns. Don't
441*b1cdbd2cSJim Jagielski // use this criterion.
442*b1cdbd2cSJim Jagielski continue;
443*b1cdbd2cSJim Jagielski
444*b1cdbd2cSJim Jagielski // Check if the 'repeat if empty' flag is set for this field.
445*b1cdbd2cSJim Jagielski bool bRepeatIfEmpty = rRepeatIfEmptyDims.count(itr->mnFieldIndex) > 0;
446*b1cdbd2cSJim Jagielski const ScDPItemData* pCellData = getCell(static_cast<SCCOL>(itr->mnFieldIndex), nRow, bRepeatIfEmpty);
447*b1cdbd2cSJim Jagielski if (!itr->mpFilter->match(*pCellData))
448*b1cdbd2cSJim Jagielski return false;
449*b1cdbd2cSJim Jagielski }
450*b1cdbd2cSJim Jagielski return true;
451*b1cdbd2cSJim Jagielski }
452*b1cdbd2cSJim Jagielski
453*b1cdbd2cSJim Jagielski
InitNoneCache(ScDocument * pDoc)454*b1cdbd2cSJim Jagielski void ScDPCacheTable::InitNoneCache( ScDocument* pDoc )
455*b1cdbd2cSJim Jagielski {
456*b1cdbd2cSJim Jagielski mpCache = NULL;
457*b1cdbd2cSJim Jagielski if ( mpNoneCache )
458*b1cdbd2cSJim Jagielski delete mpNoneCache;
459*b1cdbd2cSJim Jagielski mpNoneCache = new ScDPTableDataCache( pDoc );
460*b1cdbd2cSJim Jagielski }
461*b1cdbd2cSJim Jagielski
GetCache() const462*b1cdbd2cSJim Jagielski ScDPTableDataCache* ScDPCacheTable::GetCache() const
463*b1cdbd2cSJim Jagielski {
464*b1cdbd2cSJim Jagielski if ( mpCache )
465*b1cdbd2cSJim Jagielski return mpCache;
466*b1cdbd2cSJim Jagielski return mpNoneCache;
467*b1cdbd2cSJim Jagielski }
468*b1cdbd2cSJim Jagielski // End Comments
469