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/numformat.hxx>
  21 #include <svl/zforlist.hxx>
  22 #include <unotools/charclass.hxx>
  23
  24 #include <dpcache.hxx>
  25 #include <dpshttab.hxx>
  26 #include <document.hxx>
  27 #include <dpfilteredcache.hxx>
  28 #include <dpobject.hxx>
  29 #include <globstr.hrc>
  30 #include <scresid.hxx>
  31 #include <rangenam.hxx>
  32 #include <queryentry.hxx>
  33
  34 #include <osl/diagnose.h>
  35
  36 #include <vector>
  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(const 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 sal_Int32 ScSheetDPData::GetColumnCount()
  78 {
  79     CreateCacheTable();
  80     return aCacheTable.getColSize();
  81 }
  82
  83 OUString ScSheetDPData::getDimensionName(sal_Int32 nColumn)
  84 {
  85     CreateCacheTable();
  86     if (getIsDataLayoutDimension(nColumn))
  87     {
  88         //TODO: different internal and display names?
  89         //return "Data";
  90         return ScResId(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(sal_Int32 nDim)
 104 {
 105     CreateCacheTable();
 106     tools::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_uInt32 ScSheetDPData::GetNumberFormat(sal_Int32 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(sal_Int32 nColumn)
 151 {
 152     CreateCacheTable();
 153     return (nColumn ==static_cast<tools::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(std::vector<ScDPFilteredCache::Criterion>&& rCriteria, std::unordered_set<sal_Int32>&& rCatDims)
 178 {
 179     CreateCacheTable();
 180     aCacheTable.filterByPageDimension(
 181         rCriteria, (IsRepeatIfEmpty() ? std::move(rCatDims) : std::unordered_set<sal_Int32>()));
 182 }
 183
 184 void ScSheetDPData::GetDrillDownData(std::vector<ScDPFilteredCache::Criterion>&& rCriteria, 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() ? std::move(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 #if DUMP_PIVOT_TABLE
 213
 214 void ScSheetDPData::Dump() const
 215 {
 216     // TODO : Implement this.
 217 }
 218
 219 #endif
 220
 221 ScSheetSourceDesc::ScSheetSourceDesc(ScDocument* pDoc) :
 222     mpDoc(pDoc) {}
 223
 224 void ScSheetSourceDesc::SetSourceRange(const ScRange& rRange)
 225 {
 226     maSourceRange = rRange;
 227     maRangeName.clear(); // overwrite existing range name if any.
 228 }
 229
 230 const ScRange& ScSheetSourceDesc::GetSourceRange() const
 231 {
 232     if (!maRangeName.isEmpty())
 233     {
 234         // Obtain the source range from the range name first.
 235         maSourceRange = ScRange();
 236         ScRangeName* pRangeName = mpDoc->GetRangeName();
 237         do
 238         {
 239             if (!pRangeName)
 240                 break;
 241
 242             OUString aUpper = ScGlobal::getCharClass().uppercase(maRangeName);
 243             const ScRangeData* pData = pRangeName->findByUpperName(aUpper);
 244             if (!pData)
 245                 break;
 246
 247             // range name found.  Fow now, we only use the first token and
 248             // ignore the rest.
 249             ScRange aRange;
 250             if (!pData->IsReference(aRange))
 251                 break;
 252
 253             maSourceRange = aRange;
 254         }
 255         while (false);
 256     }
 257     return maSourceRange;
 258 }
 259
 260 void ScSheetSourceDesc::SetRangeName(const OUString& rName)
 261 {
 262     maRangeName = rName;
 263 }
 264
 265 bool ScSheetSourceDesc::HasRangeName() const
 266 {
 267     return !maRangeName.isEmpty();
 268 }
 269
 270 void ScSheetSourceDesc::SetQueryParam(const ScQueryParam& rParam)
 271 {
 272     maQueryParam = rParam;
 273 }
 274
 275 bool ScSheetSourceDesc::operator== (const ScSheetSourceDesc& rOther) const
 276 {
 277     return maSourceRange == rOther.maSourceRange &&
 278         maRangeName == rOther.maRangeName &&
 279         maQueryParam  == rOther.maQueryParam;
 280 }
 281
 282 const ScDPCache* ScSheetSourceDesc::CreateCache(const ScDPDimensionSaveData* pDimData) const
 283 {
 284     if (!mpDoc)
 285         return nullptr;
 286
 287     TranslateId pErrId = CheckSourceRange();
 288     if (pErrId)
 289     {
 290         OSL_FAIL( "Error Create Cache" );
 291         return nullptr;
 292     }
 293
 294     // All cache instances are managed centrally by ScDPCollection.
 295     ScDPCollection* pDPs = mpDoc->GetDPCollection();
 296     if (HasRangeName())
 297     {
 298         // Name-based data source.
 299         ScDPCollection::NameCaches& rCaches = pDPs->GetNameCaches();
 300         return rCaches.getCache(GetRangeName(), GetSourceRange(), pDimData);
 301     }
 302
 303     ScDPCollection::SheetCaches& rCaches = pDPs->GetSheetCaches();
 304     return rCaches.getCache(GetSourceRange(), pDimData);
 305 }
 306
 307 TranslateId ScSheetSourceDesc::CheckSourceRange() const
 308 {
 309     if (!mpDoc)
 310         return STR_ERR_DATAPILOTSOURCE;
 311
 312     // Make sure the range is valid and sane.
 313     const ScRange& rSrcRange = GetSourceRange();
 314     if (!rSrcRange.IsValid())
 315         return STR_ERR_DATAPILOTSOURCE;
 316
 317     if (rSrcRange.aStart.Col() > rSrcRange.aEnd.Col() || rSrcRange.aStart.Row() > rSrcRange.aEnd.Row())
 318         return STR_ERR_DATAPILOTSOURCE;
 319
 320     return {};
 321 }
 322
 323 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */