sc/source/core/tool/doubleref.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 "doubleref.hxx"
  21 #include "formulacell.hxx"
  22 #include "global.hxx"
  23 #include "document.hxx"
  24 #include "queryparam.hxx"
  25 #include "queryentry.hxx"
  26 #include "globstr.hrc"
  27 #include "scmatrix.hxx"
  28
  29 #include <svl/sharedstringpool.hxx>
  30 #include <osl/diagnose.h>
  31
  32 #include <memory>
  33 #include <vector>
  34
  35 using ::std::unique_ptr;
  36 using ::std::vector;
  37
  38 namespace {
  39
  40 void lcl_uppercase(OUString& rStr)
  41 {
  42     rStr = ScGlobal::pCharClass->uppercase(rStr.trim());
  43 }
  44
  45 bool lcl_createStarQuery(
  46     svl::SharedStringPool& rPool, ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef, const ScDBRangeBase* pQueryRef)
  47 {
  48     // A valid StarQuery must be at least 4 columns wide. To be precise it
  49     // should be exactly 4 columns ...
  50     // Additionally, if this wasn't checked, a formula pointing to a valid 1-3
  51     // column Excel style query range immediately left to itself would result
  52     // in a circular reference when the field name or operator or value (first
  53     // to third query range column) is obtained (#i58354#). Furthermore, if the
  54     // range wasn't sufficiently specified data changes wouldn't flag formula
  55     // cells for recalculation.
  56
  57     if (pQueryRef->getColSize() < 4)
  58         return false;
  59
  60     bool bValid;
  61     OUString aCellStr;
  62     SCSIZE nIndex = 0;
  63     SCROW nRow = 0;
  64     SCROW nRows = pDBRef->getRowSize();
  65     SCSIZE nNewEntries = static_cast<SCSIZE>(nRows);
  66     pParam->Resize(nNewEntries);
  67
  68     do
  69     {
  70         ScQueryEntry& rEntry = pParam->GetEntry(nIndex);
  71
  72         bValid = false;
  73
  74         if (nIndex > 0)
  75         {
  76             // For all entries after the first one, check the and/or connector in the first column.
  77             aCellStr = pQueryRef->getString(0, nRow);
  78             lcl_uppercase(aCellStr);
  79             if ( aCellStr.equals(ScGlobal::GetRscString(STR_TABLE_UND)) )
  80             {
  81                 rEntry.eConnect = SC_AND;
  82                 bValid = true;
  83             }
  84             else if ( aCellStr.equals(ScGlobal::GetRscString(STR_TABLE_ODER)) )
  85             {
  86                 rEntry.eConnect = SC_OR;
  87                 bValid = true;
  88             }
  89         }
  90
  91         if ((nIndex < 1) || bValid)
  92         {
  93             // field name in the 2nd column.
  94             aCellStr = pQueryRef->getString(1, nRow);
  95             SCCOL nField = pDBRef->findFieldColumn(aCellStr); // TODO: must be case insensitive comparison.
  96             if (ValidCol(nField))
  97             {
  98                 rEntry.nField = nField;
  99                 bValid = true;
 100             }
 101             else
 102                 bValid = false;
 103         }
 104
 105         if (bValid)
 106         {
 107             // equality, non-equality operator in the 3rd column.
 108             aCellStr = pQueryRef->getString(2, nRow);
 109             lcl_uppercase(aCellStr);
 110             const sal_Unicode* p = aCellStr.getStr();
 111             if (p[0] == '<')
 112             {
 113                 if (p[1] == '>')
 114                     rEntry.eOp = SC_NOT_EQUAL;
 115                 else if (p[1] == '=')
 116                     rEntry.eOp = SC_LESS_EQUAL;
 117                 else
 118                     rEntry.eOp = SC_LESS;
 119             }
 120             else if (p[0] == '>')
 121             {
 122                 if (p[1] == '=')
 123                     rEntry.eOp = SC_GREATER_EQUAL;
 124                 else
 125                     rEntry.eOp = SC_GREATER;
 126             }
 127             else if (p[0] == '=')
 128                 rEntry.eOp = SC_EQUAL;
 129
 130         }
 131
 132         if (bValid)
 133         {
 134             // Finally, the right-hand-side value in the 4th column.
 135             rEntry.GetQueryItem().maString =
 136                 rPool.intern(pQueryRef->getString(3, nRow));
 137             rEntry.bDoQuery = true;
 138         }
 139         nIndex++;
 140         nRow++;
 141     }
 142     while (bValid && (nRow < nRows) /* && (nIndex < MAXQUERY) */ );
 143     return bValid;
 144 }
 145
 146 bool lcl_createExcelQuery(
 147     svl::SharedStringPool& rPool, ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef, const ScDBRangeBase* pQueryRef)
 148 {
 149     bool bValid = true;
 150     SCCOL nCols = pQueryRef->getColSize();
 151     SCROW nRows = pQueryRef->getRowSize();
 152     vector<SCCOL> aFields(nCols);
 153     SCCOL nCol = 0;
 154     while (bValid && (nCol < nCols))
 155     {
 156         OUString aQueryStr = pQueryRef->getString(nCol, 0);
 157         SCCOL nField = pDBRef->findFieldColumn(aQueryStr);
 158         if (ValidCol(nField))
 159             aFields[nCol] = nField;
 160         else
 161             bValid = false;
 162         ++nCol;
 163     }
 164
 165     if (bValid)
 166     {
 167         // Count the number of visible cells (excluding the header row).  Each
 168         // visible cell corresponds with a single query.
 169         SCSIZE nVisible = pQueryRef->getVisibleDataCellCount();
 170         if ( nVisible > SCSIZE_MAX / sizeof(void*) )
 171         {
 172             OSL_FAIL("too many filter criteria");
 173             nVisible = 0;
 174         }
 175
 176         SCSIZE nNewEntries = nVisible;
 177         pParam->Resize( nNewEntries );
 178
 179         SCSIZE nIndex = 0;
 180         SCROW nRow = 1;
 181         OUString aCellStr;
 182         while (nRow < nRows)
 183         {
 184             nCol = 0;
 185             while (nCol < nCols)
 186             {
 187                 aCellStr = pQueryRef->getString(nCol, nRow);
 188                 aCellStr = ScGlobal::pCharClass->uppercase( aCellStr );
 189                 if (!aCellStr.isEmpty())
 190                 {
 191                     if (nIndex < nNewEntries)
 192                     {
 193                         pParam->GetEntry(nIndex).nField = aFields[nCol];
 194                         pParam->FillInExcelSyntax(rPool, aCellStr, nIndex, NULL);
 195                         nIndex++;
 196                         if (nIndex < nNewEntries)
 197                             pParam->GetEntry(nIndex).eConnect = SC_AND;
 198                     }
 199                     else
 200                         bValid = false;
 201                 }
 202                 nCol++;
 203             }
 204             nRow++;
 205             if (nIndex < nNewEntries)
 206                 pParam->GetEntry(nIndex).eConnect = SC_OR;
 207         }
 208     }
 209     return bValid;
 210 }
 211
 212 bool lcl_fillQueryEntries(
 213     svl::SharedStringPool& rPool, ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef, const ScDBRangeBase* pQueryRef)
 214 {
 215     SCSIZE nCount = pParam->GetEntryCount();
 216     for (SCSIZE i = 0; i < nCount; ++i)
 217         pParam->GetEntry(i).Clear();
 218
 219     // Standard QueryTabelle
 220     bool bValid = lcl_createStarQuery(rPool, pParam, pDBRef, pQueryRef);
 221     // Excel QueryTabelle
 222     if (!bValid)
 223         bValid = lcl_createExcelQuery(rPool, pParam, pDBRef, pQueryRef);
 224
 225     nCount = pParam->GetEntryCount();
 226     if (bValid)
 227     {
 228         //  bQueryByString muss gesetzt sein
 229         for (SCSIZE i = 0; i < nCount; ++i)
 230             pParam->GetEntry(i).GetQueryItem().meType = ScQueryEntry::ByString;
 231     }
 232     else
 233     {
 234         //  nix
 235         for (SCSIZE i = 0; i < nCount; ++i)
 236             pParam->GetEntry(i).Clear();
 237     }
 238     return bValid;
 239 }
 240
 241 }
 242
 243 ScDBRangeBase::ScDBRangeBase(ScDocument* pDoc, RefType eType) :
 244     mpDoc(pDoc), meType(eType)
 245 {
 246 }
 247
 248 ScDBRangeBase::~ScDBRangeBase()
 249 {
 250 }
 251
 252 bool ScDBRangeBase::fillQueryEntries(ScQueryParamBase* pParam, const ScDBRangeBase* pDBRef) const
 253 {
 254     if (!pDBRef)
 255         return false;
 256
 257     return lcl_fillQueryEntries(getDoc()->GetSharedStringPool(), pParam, pDBRef, this);
 258 }
 259
 260 void ScDBRangeBase::fillQueryOptions(ScQueryParamBase* pParam)
 261 {
 262     pParam->bHasHeader = true;
 263     pParam->bByRow = true;
 264     pParam->bInplace = true;
 265     pParam->bCaseSens = false;
 266     pParam->bRegExp = false;
 267     pParam->bDuplicate = true;
 268 }
 269
 270 ScDBInternalRange::ScDBInternalRange(ScDocument* pDoc, const ScRange& rRange) :
 271     ScDBRangeBase(pDoc, INTERNAL), maRange(rRange)
 272 {
 273 }
 274
 275 ScDBInternalRange::~ScDBInternalRange()
 276 {
 277 }
 278
 279 SCCOL ScDBInternalRange::getColSize() const
 280 {
 281     return maRange.aEnd.Col() - maRange.aStart.Col() + 1;
 282 }
 283
 284 SCROW ScDBInternalRange::getRowSize() const
 285 {
 286     return maRange.aEnd.Row() - maRange.aStart.Row() + 1;
 287 }
 288
 289 SCSIZE ScDBInternalRange::getVisibleDataCellCount() const
 290 {
 291     SCCOL nCols = getColSize();
 292     SCROW nRows = getRowSize();
 293     if (nRows <= 1)
 294         return 0;
 295
 296     return (nRows-1)*nCols;
 297 }
 298
 299 OUString ScDBInternalRange::getString(SCCOL nCol, SCROW nRow) const
 300 {
 301     OUString aStr;
 302     const ScAddress& s = maRange.aStart;
 303     // #i109200# this is used in formula calculation, use GetInputString, not GetString
 304     // (consistent with ScDBInternalRange::getCellString)
 305     // GetStringForFormula is not used here, to allow querying for date values.
 306     getDoc()->GetInputString(s.Col() + nCol, s.Row() + nRow, maRange.aStart.Tab(), aStr);
 307     return aStr;
 308 }
 309
 310 SCCOL ScDBInternalRange::getFirstFieldColumn() const
 311 {
 312     return getRange().aStart.Col();
 313 }
 314
 315 SCCOL ScDBInternalRange::findFieldColumn(SCCOL nIndex) const
 316 {
 317     const ScRange& rRange = getRange();
 318     const ScAddress& s = rRange.aStart;
 319
 320     SCCOL nDBCol1 = s.Col();
 321
 322     // Don't handle out-of-bound condition here.  We'll do that later.
 323     return nIndex + nDBCol1 - 1;
 324 }
 325
 326 SCCOL ScDBInternalRange::findFieldColumn(const OUString& rStr, sal_uInt16* pErr) const
 327 {
 328     const ScAddress& s = maRange.aStart;
 329     const ScAddress& e = maRange.aEnd;
 330     OUString aUpper = rStr;
 331     lcl_uppercase(aUpper);
 332
 333     SCCOL nDBCol1 = s.Col();
 334     SCROW nDBRow1 = s.Row();
 335     SCTAB nDBTab1 = s.Tab();
 336     SCCOL nDBCol2 = e.Col();
 337
 338     SCCOL   nField = nDBCol1;
 339     bool bFound = false;
 340
 341     OUString aCellStr;
 342     ScAddress aLook( nDBCol1, nDBRow1, nDBTab1 );
 343     while (!bFound && (aLook.Col() <= nDBCol2))
 344     {
 345         sal_uInt16 nErr = getDoc()->GetStringForFormula( aLook, aCellStr );
 346         if (pErr)
 347             *pErr = nErr;
 348         lcl_uppercase(aCellStr);
 349         bFound = ScGlobal::GetpTransliteration()->isEqual(aCellStr, aUpper);
 350         if (!bFound)
 351             aLook.IncCol();
 352     }
 353     nField = aLook.Col();
 354
 355     return bFound ? nField : -1;
 356 }
 357
 358 ScDBQueryParamBase* ScDBInternalRange::createQueryParam(const ScDBRangeBase* pQueryRef) const
 359 {
 360     unique_ptr<ScDBQueryParamInternal> pParam(new ScDBQueryParamInternal);
 361
 362     // Set the database range first.
 363     const ScAddress& s = maRange.aStart;
 364     const ScAddress& e = maRange.aEnd;
 365     pParam->nCol1 = s.Col();
 366     pParam->nRow1 = s.Row();
 367     pParam->nCol2 = e.Col();
 368     pParam->nRow2 = e.Row();
 369     pParam->nTab  = s.Tab();
 370
 371     fillQueryOptions(pParam.get());
 372
 373     // Now construct the query entries from the query range.
 374     if (!pQueryRef->fillQueryEntries(pParam.get(), this))
 375         return NULL;
 376
 377     return pParam.release();
 378 }
 379
 380 bool ScDBInternalRange::isRangeEqual(const ScRange& rRange) const
 381 {
 382     return maRange == rRange;
 383 }
 384
 385 ScDBExternalRange::ScDBExternalRange(ScDocument* pDoc, const ScMatrixRef& pMat) :
 386     ScDBRangeBase(pDoc, EXTERNAL), mpMatrix(pMat)
 387 {
 388     SCSIZE nC, nR;
 389     mpMatrix->GetDimensions(nC, nR);
 390     mnCols = static_cast<SCCOL>(nC);
 391     mnRows = static_cast<SCROW>(nR);
 392 }
 393
 394 ScDBExternalRange::~ScDBExternalRange()
 395 {
 396 }
 397
 398 SCCOL ScDBExternalRange::getColSize() const
 399 {
 400     return mnCols;
 401 }
 402
 403 SCROW ScDBExternalRange::getRowSize() const
 404 {
 405     return mnRows;
 406 }
 407
 408 SCSIZE ScDBExternalRange::getVisibleDataCellCount() const
 409 {
 410     SCCOL nCols = getColSize();
 411     SCROW nRows = getRowSize();
 412     if (nRows <= 1)
 413         return 0;
 414
 415     return (nRows-1)*nCols;
 416 }
 417
 418 OUString ScDBExternalRange::getString(SCCOL nCol, SCROW nRow) const
 419 {
 420     if (nCol >= mnCols || nRow >= mnRows)
 421         return OUString();
 422
 423     return mpMatrix->GetString(nCol, nRow).getString();
 424 }
 425
 426 SCCOL ScDBExternalRange::getFirstFieldColumn() const
 427 {
 428     return 0;
 429 }
 430
 431 SCCOL ScDBExternalRange::findFieldColumn(SCCOL nIndex) const
 432 {
 433     return nIndex - 1;
 434 }
 435
 436 SCCOL ScDBExternalRange::findFieldColumn(const OUString& rStr, sal_uInt16* pErr) const
 437 {
 438     if (pErr)
 439         pErr = 0;
 440
 441     OUString aUpper = rStr;
 442     lcl_uppercase(aUpper);
 443     for (SCCOL i = 0; i < mnCols; ++i)
 444     {
 445         OUString aUpperVal = mpMatrix->GetString(i, 0).getString();
 446         lcl_uppercase(aUpperVal);
 447         if (aUpper.equals(aUpperVal))
 448             return i;
 449     }
 450     return -1;
 451 }
 452
 453 ScDBQueryParamBase* ScDBExternalRange::createQueryParam(const ScDBRangeBase* pQueryRef) const
 454 {
 455     unique_ptr<ScDBQueryParamMatrix> pParam(new ScDBQueryParamMatrix);
 456     pParam->mpMatrix = mpMatrix;
 457     fillQueryOptions(pParam.get());
 458
 459     // Now construct the query entries from the query range.
 460     if (!pQueryRef->fillQueryEntries(pParam.get(), this))
 461         return NULL;
 462
 463     return pParam.release();
 464 }
 465
 466 bool ScDBExternalRange::isRangeEqual(const ScRange& /*rRange*/) const
 467 {
 468     return false;
 469 }
 470
 471 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */