sc/source/core/data/dpshttab.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <svl/zforlist.hxx>
  21
  22 #include "dpshttab.hxx"
  23 #include "dptabres.hxx"
  24 #include "document.hxx"
  25 #include "formulacell.hxx"
  26 #include "dpfilteredcache.hxx"
  27 #include "dpobject.hxx"
  28 #include "globstr.hrc"
  29 #include "rangenam.hxx"
  30 #include "queryentry.hxx"
  31
  32 #include <com/sun/star/sheet/DataPilotFieldFilter.hpp>
  33 #include <osl/diagnose.h>
  34
  35 #include <vector>
  36 #include <set>
  37
  38 using namespace ::com::sun::star;
  39 using ::com::sun::star::uno::Any;
  40 using ::com::sun::star::uno::Sequence;
  41 using ::std::vector;
  42
  43 ScSheetDPData::ScSheetDPData(ScDocument* pD, const ScSheetSourceDesc& rDesc, const ScDPCache& rCache) :
  44     ScDPTableData(pD),
  45     aQuery ( rDesc.GetQueryParam() ),
  46     bIgnoreEmptyRows( false ),
  47     bRepeatIfEmpty(false),
  48     aCacheTable(rCache)
  49 {
  50     SCSIZE nEntryCount( aQuery.GetEntryCount());
  51     for (SCSIZE j = 0; j < nEntryCount; ++j)
  52     {
  53         ScQueryEntry& rEntry = aQuery.GetEntry(j);
  54         if (rEntry.bDoQuery)
  55         {
  56             ScQueryEntry::Item& rItem = rEntry.GetQueryItem();
  57             if (rItem.meType == ScQueryEntry::ByString)
  58             {
  59                 sal_uInt32 nIndex = 0;
  60                 bool bNumber = pD->GetFormatTable()->IsNumberFormat(
  61                     rItem.maString.getString(), nIndex, rItem.mfVal);
  62                 rItem.meType = bNumber ? ScQueryEntry::ByValue : ScQueryEntry::ByString;
  63             }
  64         }
  65     }
  66 }
  67
  68 ScSheetDPData::~ScSheetDPData()
  69 {
  70 }
  71
  72 void ScSheetDPData::DisposeData()
  73 {
  74     aCacheTable.clear();
  75 }
  76
  77 long ScSheetDPData::GetColumnCount()
  78 {
  79     CreateCacheTable();
  80     return aCacheTable.getColSize();
  81 }
  82
  83 OUString ScSheetDPData::getDimensionName(long nColumn)
  84 {
  85     CreateCacheTable();
  86     if (getIsDataLayoutDimension(nColumn))
  87     {
  88         //TODO: different internal and display names?
  89         //return "Data";
  90         return ScGlobal::GetRscString(STR_PIVOT_DATA);
  91     }
  92     else if (nColumn >= aCacheTable.getColSize())
  93     {
  94         OSL_FAIL("getDimensionName: invalid dimension");
  95         return OUString();
  96     }
  97     else
  98     {
  99         return aCacheTable.getFieldName(static_cast<SCCOL>(nColumn));
 100     }
 101 }
 102
 103 bool ScSheetDPData::IsDateDimension(long nDim)
 104 {
 105     CreateCacheTable();
 106     long nColCount = aCacheTable.getColSize();
 107     if (getIsDataLayoutDimension(nDim))
 108     {
 109         return false;
 110     }
 111     else if (nDim >= nColCount)
 112     {
 113         OSL_FAIL("IsDateDimension: invalid dimension");
 114         return false;
 115     }
 116     else
 117     {
 118         return GetCacheTable().getCache().IsDateDimension( nDim);
 119     }
 120 }
 121
 122 sal_uLong ScSheetDPData::GetNumberFormat(long nDim)
 123 {
 124     CreateCacheTable();
 125     if (getIsDataLayoutDimension(nDim))
 126     {
 127         return 0;
 128     }
 129     else if (nDim >= GetCacheTable().getColSize())
 130     {
 131         OSL_FAIL("GetNumberFormat: invalid dimension");
 132         return 0;
 133     }
 134     else
 135     {
 136         return GetCacheTable().getCache().GetNumberFormat( nDim );
 137     }
 138 }
 139 sal_uInt32  ScDPTableData::GetNumberFormatByIdx( NfIndexTableOffset eIdx )
 140 {
 141     if( !mpDoc )
 142         return 0;
 143
 144     if ( SvNumberFormatter* pFormatter = mpDoc->GetFormatTable() )
 145         return pFormatter->GetFormatIndex( eIdx, LANGUAGE_SYSTEM );
 146
 147     return 0;
 148 }
 149
 150 bool ScSheetDPData::getIsDataLayoutDimension(long nColumn)
 151 {
 152     CreateCacheTable();
 153     return (nColumn ==(long)( aCacheTable.getColSize()));
 154 }
 155
 156 void ScSheetDPData::SetEmptyFlags( bool bIgnoreEmptyRowsP, bool bRepeatIfEmptyP )
 157 {
 158     bIgnoreEmptyRows = bIgnoreEmptyRowsP;
 159     bRepeatIfEmpty   = bRepeatIfEmptyP;
 160 }
 161
 162 bool ScSheetDPData::IsRepeatIfEmpty()
 163 {
 164     return bRepeatIfEmpty;
 165 }
 166
 167 void ScSheetDPData::CreateCacheTable()
 168 {
 169     // Scan and store the data from the source range.
 170     if (!aCacheTable.empty())
 171         // already cached.
 172         return;
 173
 174     aCacheTable.fillTable(aQuery, bIgnoreEmptyRows, bRepeatIfEmpty);
 175 }
 176
 177 void ScSheetDPData::FilterCacheTable(const vector<ScDPFilteredCache::Criterion>& rCriteria, const std::unordered_set<sal_Int32>& rCatDims)
 178 {
 179     CreateCacheTable();
 180     aCacheTable.filterByPageDimension(
 181         rCriteria, (IsRepeatIfEmpty() ? rCatDims : std::unordered_set<sal_Int32>()));
 182 }
 183
 184 void ScSheetDPData::GetDrillDownData(const vector<ScDPFilteredCache::Criterion>& rCriteria, const std::unordered_set<sal_Int32>& rCatDims, Sequence< Sequence<Any> >& rData)
 185 {
 186     CreateCacheTable();
 187     sal_Int32 nRowSize = aCacheTable.getRowSize();
 188     if (!nRowSize)
 189         return;
 190
 191     aCacheTable.filterTable(
 192         rCriteria, rData, IsRepeatIfEmpty() ? rCatDims : std::unordered_set<sal_Int32>());
 193 }
 194
 195 void ScSheetDPData::CalcResults(CalcInfo& rInfo, bool bAutoShow)
 196 {
 197     CreateCacheTable();
 198     CalcResultsFromCacheTable(aCacheTable, rInfo, bAutoShow);
 199 }
 200
 201 const ScDPFilteredCache& ScSheetDPData::GetCacheTable() const
 202 {
 203     return aCacheTable;
 204 }
 205
 206 void ScSheetDPData::ReloadCacheTable()
 207 {
 208     aCacheTable.clear();
 209     CreateCacheTable();
 210 }
 211
 212 ScSheetSourceDesc::ScSheetSourceDesc(ScDocument* pDoc) :
 213     mpDoc(pDoc) {}
 214
 215 void ScSheetSourceDesc::SetSourceRange(const ScRange& rRange)
 216 {
 217     maSourceRange = rRange;
 218     maRangeName.clear(); // overwrite existing range name if any.
 219 }
 220
 221 const ScRange& ScSheetSourceDesc::GetSourceRange() const
 222 {
 223     if (!maRangeName.isEmpty())
 224     {
 225         // Obtain the source range from the range name first.
 226         maSourceRange = ScRange();
 227         ScRangeName* pRangeName = mpDoc->GetRangeName();
 228         do
 229         {
 230             if (!pRangeName)
 231                 break;
 232
 233             OUString aUpper = ScGlobal::pCharClass->uppercase(maRangeName);
 234             const ScRangeData* pData = pRangeName->findByUpperName(aUpper);
 235             if (!pData)
 236                 break;
 237
 238             // range name found.  Fow now, we only use the first token and
 239             // ignore the rest.
 240             ScRange aRange;
 241             if (!pData->IsReference(aRange))
 242                 break;
 243
 244             maSourceRange = aRange;
 245         }
 246         while (false);
 247     }
 248     return maSourceRange;
 249 }
 250
 251 void ScSheetSourceDesc::SetRangeName(const OUString& rName)
 252 {
 253     maRangeName = rName;
 254 }
 255
 256 bool ScSheetSourceDesc::HasRangeName() const
 257 {
 258     return !maRangeName.isEmpty();
 259 }
 260
 261 void ScSheetSourceDesc::SetQueryParam(const ScQueryParam& rParam)
 262 {
 263     maQueryParam = rParam;
 264 }
 265
 266 bool ScSheetSourceDesc::operator== (const ScSheetSourceDesc& rOther) const
 267 {
 268     return maSourceRange == rOther.maSourceRange &&
 269         maRangeName == rOther.maRangeName &&
 270         maQueryParam  == rOther.maQueryParam;
 271 }
 272
 273 const ScDPCache* ScSheetSourceDesc::CreateCache(const ScDPDimensionSaveData* pDimData) const
 274 {
 275     if (!mpDoc)
 276         return NULL;
 277
 278     sal_uLong nErrId = CheckSourceRange();
 279     if (nErrId)
 280     {
 281         OSL_FAIL( "Error Create Cache\n" );
 282         return NULL;
 283     }
 284
 285     // All cache instances are managed centrally by ScDPCollection.
 286     ScDPCollection* pDPs = mpDoc->GetDPCollection();
 287     if (HasRangeName())
 288     {
 289         // Name-based data source.
 290         ScDPCollection::NameCaches& rCaches = pDPs->GetNameCaches();
 291         return rCaches.getCache(GetRangeName(), GetSourceRange(), pDimData);
 292     }
 293
 294     ScDPCollection::SheetCaches& rCaches = pDPs->GetSheetCaches();
 295     return rCaches.getCache(GetSourceRange(), pDimData);
 296 }
 297
 298 sal_uLong ScSheetSourceDesc::CheckSourceRange() const
 299 {
 300     if (!mpDoc)
 301         return STR_ERR_DATAPILOTSOURCE;
 302
 303     // Make sure the range is valid and sane.
 304     const ScRange& rSrcRange = GetSourceRange();
 305     if (!rSrcRange.IsValid())
 306         return STR_ERR_DATAPILOTSOURCE;
 307
 308     if (rSrcRange.aStart.Col() > rSrcRange.aEnd.Col() || rSrcRange.aStart.Row() > rSrcRange.aEnd.Row())
 309         return STR_ERR_DATAPILOTSOURCE;
 310
 311     return 0;
 312 }
 313
 314 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */