| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_sc.hxx" |
| // INCLUDE --------------------------------------------------------------- |
| #include "dptablecache.hxx" |
| #include "dptabdat.hxx" |
| #include "document.hxx" |
| #include "cell.hxx" |
| #include "globstr.hrc" |
| |
| #include <rtl/math.hxx> |
| #include "queryparam.hxx" |
| #include "dpglobal.hxx" |
| |
| #include "docoptio.hxx" //for ValidQuery |
| #include <unotools/textsearch.hxx> //for ValidQuery |
| |
| #include <com/sun/star/sdbc/DataType.hpp> |
| #include <com/sun/star/sdbc/XRow.hpp> |
| #include <com/sun/star/sdbc/XRowSet.hpp> |
| #include <com/sun/star/sdbc/XResultSetMetaData.hpp> |
| #include <com/sun/star/sdbc/XResultSetMetaDataSupplier.hpp> |
| const double D_TIMEFACTOR = 86400.0; |
| |
| using namespace ::com::sun::star; |
| |
| using ::com::sun::star::uno::Exception; |
| using ::com::sun::star::uno::Reference; |
| using ::com::sun::star::uno::UNO_QUERY; |
| using ::com::sun::star::uno::UNO_QUERY_THROW; |
| |
| // ----------------------------------------------------------------------- |
| namespace |
| { |
| sal_Bool lcl_isDate( sal_uLong nNumType ) |
| { |
| return ( (nNumType & NUMBERFORMAT_DATE) != 0 )? 1:0 ; |
| } |
| |
| sal_Bool lcl_Search( const std::vector<ScDPItemData*>& list, const ::std::vector<SCROW>& rOrder, const ScDPItemData& item, SCROW& rIndex) |
| { |
| rIndex = list.size(); |
| sal_Bool bFound = sal_False; |
| SCROW nLo = 0; |
| SCROW nHi = list.size() - 1; |
| SCROW nIndex; |
| long nCompare; |
| while (nLo <= nHi) |
| { |
| nIndex = (nLo + nHi) / 2; |
| nCompare = ScDPItemData::Compare( *list[rOrder[nIndex]], item ); |
| if (nCompare < 0) |
| nLo = nIndex + 1; |
| else |
| { |
| nHi = nIndex - 1; |
| if (nCompare == 0) |
| { |
| bFound = sal_True; |
| nLo = nIndex; |
| } |
| } |
| } |
| rIndex = nLo; |
| return bFound; |
| } |
| |
| ScDPItemData* lcl_GetItemValue(const Reference<sdbc::XRow>& xRow, sal_Int32 nType, long nCol, |
| const Date& rNullDate ) |
| { |
| short nNumType = NUMBERFORMAT_NUMBER; |
| try |
| { |
| String rStr = xRow->getString(nCol); |
| double fValue = 0.0; |
| switch (nType) |
| { |
| case sdbc::DataType::BIT: |
| case sdbc::DataType::BOOLEAN: |
| { |
| nNumType = NUMBERFORMAT_LOGICAL; |
| fValue = xRow->getBoolean(nCol) ? 1 : 0; |
| return new ScDPItemData( rStr, fValue,sal_True,nNumType); |
| } |
| //break; |
| |
| case sdbc::DataType::TINYINT: |
| case sdbc::DataType::SMALLINT: |
| case sdbc::DataType::INTEGER: |
| case sdbc::DataType::BIGINT: |
| case sdbc::DataType::FLOAT: |
| case sdbc::DataType::REAL: |
| case sdbc::DataType::DOUBLE: |
| case sdbc::DataType::NUMERIC: |
| case sdbc::DataType::DECIMAL: |
| { |
| //! do the conversion here? |
| fValue = xRow->getDouble(nCol); |
| return new ScDPItemData( rStr, fValue,sal_True); |
| } |
| //break; |
| |
| case sdbc::DataType::DATE: |
| { |
| nNumType = NUMBERFORMAT_DATE; |
| |
| util::Date aDate = xRow->getDate(nCol); |
| fValue = Date(aDate.Day, aDate.Month, aDate.Year) - rNullDate; |
| return new ScDPItemData( rStr, fValue, sal_True, nNumType ); |
| } |
| //break; |
| |
| case sdbc::DataType::TIME: |
| { |
| nNumType = NUMBERFORMAT_TIME; |
| |
| util::Time aTime = xRow->getTime(nCol); |
| fValue = ( aTime.Hours * 3600 + aTime.Minutes * 60 + |
| aTime.Seconds + aTime.HundredthSeconds / 100.0 ) / D_TIMEFACTOR; |
| return new ScDPItemData( rStr,fValue, sal_True, nNumType ); |
| } |
| //break; |
| |
| case sdbc::DataType::TIMESTAMP: |
| { |
| nNumType = NUMBERFORMAT_DATETIME; |
| |
| util::DateTime aStamp = xRow->getTimestamp(nCol); |
| fValue = ( Date( aStamp.Day, aStamp.Month, aStamp.Year ) - rNullDate ) + |
| ( aStamp.Hours * 3600 + aStamp.Minutes * 60 + |
| aStamp.Seconds + aStamp.HundredthSeconds / 100.0 ) / D_TIMEFACTOR; |
| return new ScDPItemData( rStr,fValue, sal_True, nNumType ); |
| } |
| //break; |
| case sdbc::DataType::CHAR: |
| case sdbc::DataType::VARCHAR: |
| case sdbc::DataType::LONGVARCHAR: |
| case sdbc::DataType::SQLNULL: |
| case sdbc::DataType::BINARY: |
| case sdbc::DataType::VARBINARY: |
| case sdbc::DataType::LONGVARBINARY: |
| default: |
| return new ScDPItemData ( rStr ); |
| //break; |
| } |
| } |
| catch (uno::Exception&) |
| { |
| } |
| catch ( ... ) |
| { |
| |
| } |
| return NULL; |
| } |
| } |
| // Wang Xu Ming -- 12/23/2008 |
| //Refactor cache data |
| ScDPItemData::ScDPItemData( const String& rS, double fV/* = 0.0*/, sal_Bool bHV/* = sal_False*/, const sal_uLong nNumFormatP /*= 0*/ , sal_Bool bData/* = sal_True*/) : |
| nNumFormat( nNumFormatP ), aString(rS), fValue(fV), |
| mbFlag( (MK_VAL*!!bHV) | (MK_DATA*!!bData) | (MK_ERR*!!sal_False) | (MK_DATE*!!lcl_isDate( nNumFormat ) ) ) |
| { |
| } |
| |
| ScDPItemData::ScDPItemData( ScDocument* pDoc, SCROW nRow, sal_uInt16 nCol, sal_uInt16 nDocTab ): |
| nNumFormat( 0 ), fValue(0.0), mbFlag( 0 ) |
| { |
| String aDocStr; |
| pDoc->GetString( nCol, nRow, nDocTab, aDocStr ); |
| |
| SvNumberFormatter* pFormatter = pDoc->GetFormatTable(); |
| |
| ScAddress aPos( nCol, nRow, nDocTab ); |
| ScBaseCell* pCell = pDoc->GetCell( aPos ); |
| |
| if ( pCell && pCell->GetCellType() == CELLTYPE_FORMULA && ((ScFormulaCell*)pCell)->GetErrCode() ) |
| { |
| SetString ( aDocStr ); |
| //bErr = sal_True; |
| mbFlag |= MK_ERR; |
| } |
| else if ( pDoc->HasValueData( nCol, nRow, nDocTab ) ) |
| { |
| double fVal = pDoc->GetValue(ScAddress(nCol, nRow, nDocTab)); |
| nNumFormat = pDoc->GetNumberFormat( ScAddress( nCol, nRow, nDocTab ) ); |
| sal_uLong nFormat = NUMBERFORMAT_NUMBER; |
| if ( pFormatter ) |
| nFormat = pFormatter->GetType( nNumFormat ); |
| aString = aDocStr; |
| fValue = fVal; |
| mbFlag |= MK_VAL|MK_DATA; |
| lcl_isDate( nFormat ) ? ( mbFlag |= MK_DATE ) : (mbFlag &= ~MK_DATE); |
| } |
| else if ( pDoc->HasData( nCol,nRow, nDocTab ) ) |
| SetString ( aDocStr ); |
| } |
| // End Comments |
| |
| sal_Bool ScDPItemData::IsCaseInsEqual( const ScDPItemData& r ) const |
| { //TODO: indified Date? |
| //! pass Transliteration? |
| //! inline? |
| return IsValue() ? ( r.IsValue() && rtl::math::approxEqual( fValue, r.fValue ) ) : |
| ( !r.IsValue() && |
| ScGlobal::GetpTransliteration()->isEqual( aString, r.aString ) ); |
| } |
| |
| size_t ScDPItemData::Hash() const |
| { |
| if ( IsValue() ) |
| return (size_t) rtl::math::approxFloor( fValue ); |
| else |
| // If we do unicode safe case insensitive hash we can drop |
| // ScDPItemData::operator== and use ::IsCasInsEqual |
| return rtl_ustr_hashCode_WithLength( aString.GetBuffer(), aString.Len() ); |
| } |
| |
| sal_Bool ScDPItemData::operator==( const ScDPItemData& r ) const |
| { |
| if ( IsValue() ) |
| { |
| if( (HasDatePart() != r.HasDatePart()) || (HasDatePart() && mnDatePart != r.mnDatePart) ) |
| return sal_False; |
| |
| // Wang Xu Ming -- 1/9/2009 |
| // Add Data Cache Support. |
| // Identify date |
| if ( IsDate() != r.IsDate() ) |
| return sal_False; |
| else |
| if ( r.IsValue() ) |
| return rtl::math::approxEqual( fValue, r.fValue ); |
| else |
| return sal_False; |
| // End Comments |
| } |
| else if ( r.IsValue() ) |
| return sal_False; |
| else |
| // need exact equality until we have a safe case insensitive string hash |
| return aString == r.aString; |
| } |
| |
| sal_Int32 ScDPItemData::Compare( const ScDPItemData& rA, |
| const ScDPItemData& rB ) |
| { |
| if ( rA.IsValue() ) |
| { |
| if ( rB.IsValue() ) |
| { |
| if ( rtl::math::approxEqual( rA.fValue, rB.fValue ) ) |
| { |
| // Wang Xu Ming -- 1/9/2009 |
| // Add Data Cache Support. |
| // Date > number |
| if ( rA.IsDate() == rB.IsDate() ) |
| return 0; |
| else |
| return rA.IsDate() ? 1: -1; |
| // End Comments |
| } |
| else if ( rA.fValue < rB.fValue ) |
| return -1; |
| else |
| return 1; |
| } |
| else |
| return -1; // values first |
| } |
| else if ( rB.IsValue() ) |
| return 1; // values first |
| else |
| return ScGlobal::GetCollator()->compareString( rA.aString, rB.aString ); |
| } |
| |
| #ifdef DEBUG |
| void ScDPItemData::dump() const |
| { |
| DBG_TRACE1( "Numberformat= %o", nNumFormat ); |
| DBG_TRACESTR(aString ); |
| DBG_TRACE1( "fValue= %f", fValue ); |
| DBG_TRACE1( "mbFlag= %d", mbFlag); |
| } |
| #endif |
| |
| TypedStrData* ScDPItemData::CreateTypeString( ) |
| { |
| if ( IsValue() ) |
| return new TypedStrData( aString, fValue, SC_STRTYPE_VALUE ); |
| else |
| return new TypedStrData( aString ); |
| } |
| |
| sal_uInt8 ScDPItemData::GetType() const |
| { |
| |
| if ( IsHasErr() ) |
| return SC_VALTYPE_ERROR; |
| else if ( !IsHasData() ) |
| return SC_VALTYPE_EMPTY; |
| else if ( IsValue()) |
| return SC_VALTYPE_VALUE; |
| else |
| return SC_VALTYPE_STRING; |
| |
| } |
| |
| sal_Bool ScDPItemData::IsHasData() const |
| { |
| return !!(mbFlag&MK_DATA); |
| } |
| |
| sal_Bool ScDPItemData::IsHasErr() const |
| { |
| return !!(mbFlag&MK_ERR); |
| } |
| |
| sal_Bool ScDPItemData::IsValue() const |
| { |
| return !!(mbFlag&MK_VAL); |
| } |
| |
| String ScDPItemData::GetString() const |
| { |
| |
| return aString; |
| } |
| |
| double ScDPItemData::GetValue() const |
| { |
| return fValue; |
| } |
| sal_uLong ScDPItemData::GetNumFormat() const |
| { |
| return nNumFormat; |
| } |
| |
| sal_Bool ScDPItemData::HasStringData() const |
| |
| { |
| return IsHasData()&&!IsHasErr()&&!IsValue(); |
| } |
| sal_Bool ScDPItemData::IsDate() const |
| { |
| return !!(mbFlag&MK_DATE); |
| } |
| sal_Bool ScDPItemData::HasDatePart() const |
| { |
| return !!(mbFlag&MK_DATEPART); |
| } |
| void ScDPItemData::SetDate( sal_Bool b ) |
| { |
| b ? ( mbFlag |= MK_DATE ) : ( mbFlag &= ~MK_DATE ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| //class ScDPTableDataCache |
| //To cache the pivot table data source |
| |
| sal_Bool ScDPTableDataCache::operator== ( const ScDPTableDataCache& r ) const |
| { |
| if ( GetColumnCount() == r.GetColumnCount() ) |
| { |
| for ( SCCOL i = 0 ; i < GetColumnCount(); i++ ) |
| { //check dim names |
| if ( GetDimensionName( i ) != r.GetDimensionName( i ) ) |
| return sal_False; |
| //check rows count |
| if ( GetRowCount() != r.GetRowCount() ) |
| return sal_False; |
| //check dim member values |
| size_t nMembersCount = GetDimMemberValues( i ).size(); |
| if ( GetDimMemberValues( i ).size() == r. GetDimMemberValues( i ).size() ) |
| { |
| for ( size_t j = 0; j < nMembersCount; j++ ) |
| { |
| if ( *( GetDimMemberValues( i )[j] ) == *( r.GetDimMemberValues( i )[j] ) ) |
| continue; |
| else |
| return sal_False; |
| } |
| } |
| else |
| return sal_False; |
| //check source table index |
| for ( SCROW k=0 ; k < GetRowCount(); k ++ ) |
| { |
| if ( GetItemDataId( i, k, sal_False ) == r.GetItemDataId( i,k,sal_False) ) |
| continue; |
| else |
| return sal_False; |
| } |
| } |
| } |
| return sal_True; |
| } |
| |
| ScDPTableDataCache::ScDPTableDataCache( ScDocument* pDoc ) : |
| mpDoc( pDoc ), |
| mnColumnCount ( 0 ), |
| mpTableDataValues ( NULL ), |
| mpSourceData ( NULL ), |
| mpGlobalOrder( NULL ), |
| mpIndexOrder( NULL) |
| { |
| mnID = -1; |
| } |
| |
| ScDPTableDataCache::~ScDPTableDataCache() |
| { |
| if ( IsValid() ) |
| { |
| // Wang Xu Ming -- 2/17/2009 |
| // Performance issue |
| sal_uInt16 nCol; |
| for ( nCol=0; nCol < GetColumnCount() ; nCol++ ) |
| { |
| for ( sal_uLong row = 0 ; row < mpTableDataValues[nCol].size(); row++ ) |
| delete mpTableDataValues[nCol][row]; |
| } |
| for ( nCol =0; nCol < mrLabelNames.size(); nCol++ ) |
| delete mrLabelNames[nCol]; |
| // End Comments |
| |
| mnColumnCount = 0; |
| delete [] mpTableDataValues; |
| mpTableDataValues = NULL; |
| delete [] mpSourceData; |
| mpSourceData = NULL; |
| delete [] mpGlobalOrder; |
| mpGlobalOrder = NULL; |
| delete [] mpIndexOrder; |
| mpIndexOrder = NULL; |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| void ScDPTableDataCache::AddRow( ScDPItemData* pRow, sal_uInt16 nCount ) |
| { |
| DBG_ASSERT( pRow , " empty pointer" ); |
| if ( !mrLabelNames.size() ) |
| { |
| mnColumnCount= nCount; |
| mpTableDataValues = new std::vector<ScDPItemData*>[ mnColumnCount ]; |
| mpSourceData = new std::vector<SCROW>[ mnColumnCount ]; |
| mpGlobalOrder = new std::vector<SCROW>[ mnColumnCount ]; |
| mpIndexOrder = new std::vector<SCROW>[ mnColumnCount ]; |
| |
| for ( sal_uInt16 i = 0; i < nCount ; i ++ ) |
| AddLabel( new ScDPItemData( pRow[i] ) ); |
| } |
| else |
| { |
| for ( sal_uInt16 i = 0; i < nCount && i < mnColumnCount; i ++ ) |
| AddData( i, new ScDPItemData( pRow[i] ) ); |
| } |
| } |
| |
| // ----------------------------------------------------------------------- |
| bool ScDPTableDataCache::IsValid() const |
| { //TODO: continue check valid |
| return mpTableDataValues!=NULL && mpSourceData!= NULL && mnColumnCount>0; |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| namespace { |
| |
| /** |
| * While the macro interpret level is incremented, the formula cells are |
| * (semi-)guaranteed to be interpreted. |
| */ |
| class MacroInterpretIncrementer |
| { |
| public: |
| MacroInterpretIncrementer(ScDocument* pDoc) : |
| mpDoc(pDoc) |
| { |
| mpDoc->IncMacroInterpretLevel(); |
| } |
| ~MacroInterpretIncrementer() |
| { |
| mpDoc->DecMacroInterpretLevel(); |
| } |
| private: |
| ScDocument* mpDoc; |
| }; |
| |
| } |
| |
| // ----------------------------------------------------------------------- |
| bool ScDPTableDataCache::InitFromDoc( ScDocument* pDoc, const ScRange& rRange ) |
| { |
| // Make sure the formula cells within the data range are interpreted |
| // during this call, for this method may be called from the interpretation |
| // of GETPIVOTDATA, which disables nested formula interpretation without |
| // increasing the macro level. |
| MacroInterpretIncrementer aMacroInc(pDoc); |
| |
| // |
| SCROW nStartRow = rRange.aStart.Row(); // start of data |
| SCROW nEndRow = rRange.aEnd.Row(); |
| sal_uInt16 nStartCol = rRange.aStart.Col(); |
| sal_uInt16 nEndCol = rRange.aEnd.Col(); |
| sal_uInt16 nDocTab = rRange.aStart.Tab(); |
| |
| //init |
| long nOldColumCount = mnColumnCount; |
| mnColumnCount = nEndCol - nStartCol + 1; |
| if ( IsValid() ) |
| { |
| for ( sal_uInt16 nCol=0; nCol < nOldColumCount ; nCol++ ) |
| { |
| for ( sal_uLong row = 0 ; row < mpTableDataValues[nCol].size(); row++ ) |
| delete mpTableDataValues[nCol][row]; |
| delete mrLabelNames[nCol]; |
| } |
| delete [] mpTableDataValues; |
| delete [] mpSourceData; |
| delete [] mpGlobalOrder; |
| delete [] mpIndexOrder; |
| mrLabelNames.clear(); |
| } |
| |
| mpTableDataValues = new std::vector<ScDPItemData*>[ mnColumnCount ]; |
| mpSourceData = new std::vector<SCROW>[ mnColumnCount ]; |
| mpGlobalOrder = new std::vector<SCROW>[ mnColumnCount ]; |
| mpIndexOrder = new std::vector<SCROW>[ mnColumnCount ]; |
| pDoc->FillDPCache( this, nDocTab, nStartCol, nEndCol, nStartRow, nEndRow ); |
| return sal_True; |
| } |
| |
| // ----------------------------------------------------------------------- |
| bool ScDPTableDataCache::InitFromDataBase (const Reference<sdbc::XRowSet>& xRowSet, const Date& rNullDate) |
| { |
| if (!xRowSet.is()) |
| // Dont' even waste time to go any further. |
| return false; |
| try |
| { |
| Reference<sdbc::XResultSetMetaDataSupplier> xMetaSupp(xRowSet, UNO_QUERY_THROW); |
| Reference<sdbc::XResultSetMetaData> xMeta = xMetaSupp->getMetaData(); |
| if (!xMeta.is()) |
| return false; |
| |
| long nOldColumCount = mnColumnCount; |
| mnColumnCount = xMeta->getColumnCount(); |
| if ( IsValid() ) |
| { |
| for ( sal_uInt16 nCol=0; nCol < nOldColumCount ; nCol++ ) |
| { |
| for ( sal_uLong row = 0 ; row < mpTableDataValues[nCol].size(); row++ ) |
| delete mpTableDataValues[nCol][row]; |
| delete mrLabelNames[nCol]; |
| } |
| delete [] mpTableDataValues; |
| delete [] mpSourceData; |
| delete [] mpGlobalOrder; |
| delete [] mpIndexOrder; |
| mrLabelNames.clear(); |
| } |
| // Get column titles and types. |
| mrLabelNames.reserve(mnColumnCount); |
| mpTableDataValues = new std::vector<ScDPItemData*>[ mnColumnCount ]; |
| mpSourceData = new std::vector<SCROW>[ mnColumnCount ]; |
| mpGlobalOrder = new std::vector<SCROW>[ mnColumnCount ]; |
| mpIndexOrder = new std::vector<SCROW>[ mnColumnCount ]; |
| |
| std::vector<sal_Int32> aColTypes(mnColumnCount); |
| |
| for (sal_Int32 nCol = 0; nCol < mnColumnCount; ++nCol) |
| { |
| String aColTitle = xMeta->getColumnLabel(nCol+1); |
| aColTypes[nCol] = xMeta->getColumnType(nCol+1); |
| AddLabel( new ScDPItemData( aColTitle) ); |
| } |
| |
| // Now get the data rows. |
| Reference<sdbc::XRow> xRow(xRowSet, UNO_QUERY_THROW); |
| xRowSet->first(); |
| do |
| { |
| for (sal_Int32 nCol = 0; nCol < mnColumnCount; ++nCol) |
| { |
| ScDPItemData * pNew = lcl_GetItemValue( xRow, aColTypes[nCol], nCol+1, rNullDate ); |
| if ( pNew ) |
| AddData( nCol , pNew ); |
| } |
| } |
| while (xRowSet->next()); |
| |
| xRowSet->beforeFirst(); |
| |
| return true; |
| } |
| catch (const Exception&) |
| { |
| return false; |
| } |
| } |
| // ----------------------------------------------------------------------- |
| sal_uLong ScDPTableDataCache::GetDimNumType( SCCOL nDim) const |
| { |
| DBG_ASSERT( IsValid(), " IsValid() == false " ); |
| DBG_ASSERT( nDim < mnColumnCount && nDim >=0, " dimention out of bound " ); |
| if ( mpTableDataValues[nDim].size()==0 ) |
| return NUMBERFORMAT_UNDEFINED; |
| else |
| return GetNumType(mpTableDataValues[nDim][0]->nNumFormat); |
| } |
| |
| // ----------------------------------------------------------------------- |
| bool ScDPTableDataCache::ValidQuery( SCROW nRow, const ScQueryParam &rParam, sal_Bool *pSpecial) |
| { //Copied and modified from ScTable::ValidQuery |
| if (!rParam.GetEntry(0).bDoQuery) |
| return sal_True; |
| sal_Bool bMatchWholeCell = mpDoc->GetDocOptions().IsMatchWholeCell(); |
| |
| //--------------------------------------------------------------- |
| |
| const SCSIZE nFixedBools = 32; |
| sal_Bool aBool[nFixedBools]; |
| sal_Bool aTest[nFixedBools]; |
| SCSIZE nEntryCount = rParam.GetEntryCount(); |
| sal_Bool* pPasst = ( nEntryCount <= nFixedBools ? &aBool[0] : new sal_Bool[nEntryCount] ); |
| sal_Bool* pTest = ( nEntryCount <= nFixedBools ? &aTest[0] : new sal_Bool[nEntryCount] ); |
| |
| long nPos = -1; |
| SCSIZE i = 0; |
| CollatorWrapper* pCollator = (rParam.bCaseSens ? ScGlobal::GetCaseCollator() : |
| ScGlobal::GetCollator() ); |
| ::utl::TransliterationWrapper* pTransliteration = (rParam.bCaseSens ? |
| ScGlobal::GetCaseTransliteration() : ScGlobal::GetpTransliteration()); |
| |
| while ( (i < nEntryCount) && rParam.GetEntry(i).bDoQuery ) |
| { |
| ScQueryEntry& rEntry = rParam.GetEntry(i); |
| // we can only handle one single direct query |
| // #i115431# nField in QueryParam is the sheet column, not the field within the source range |
| SCCOL nQueryCol = (SCCOL)rEntry.nField; |
| if ( nQueryCol < rParam.nCol1 ) |
| nQueryCol = rParam.nCol1; |
| if ( nQueryCol > rParam.nCol2 ) |
| nQueryCol = rParam.nCol2; |
| SCCOL nSourceField = nQueryCol - rParam.nCol1; |
| SCROW nId = GetItemDataId( nSourceField, nRow, sal_False ); |
| const ScDPItemData* pCellData = GetItemDataById( nSourceField, nId ); |
| |
| sal_Bool bOk = sal_False; |
| sal_Bool bTestEqual = sal_False; |
| |
| if ( pSpecial && pSpecial[i] ) |
| { |
| if (rEntry.nVal == SC_EMPTYFIELDS) |
| bOk = ! pCellData->IsHasData(); |
| else // if (rEntry.nVal == SC_NONEMPTYFIELDS) |
| bOk = pCellData->IsHasData(); |
| } |
| else if ( !rEntry.bQueryByString && pCellData->IsValue() ) |
| { // by Value |
| double nCellVal = pCellData->GetValue(); |
| |
| switch (rEntry.eOp) |
| { |
| case SC_EQUAL : |
| bOk = ::rtl::math::approxEqual( nCellVal, rEntry.nVal ); |
| break; |
| case SC_LESS : |
| bOk = (nCellVal < rEntry.nVal) && !::rtl::math::approxEqual( nCellVal, rEntry.nVal ); |
| break; |
| case SC_GREATER : |
| bOk = (nCellVal > rEntry.nVal) && !::rtl::math::approxEqual( nCellVal, rEntry.nVal ); |
| break; |
| case SC_LESS_EQUAL : |
| bOk = (nCellVal < rEntry.nVal) || ::rtl::math::approxEqual( nCellVal, rEntry.nVal ); |
| break; |
| case SC_GREATER_EQUAL : |
| bOk = (nCellVal > rEntry.nVal) || ::rtl::math::approxEqual( nCellVal, rEntry.nVal ); |
| break; |
| case SC_NOT_EQUAL : |
| bOk = !::rtl::math::approxEqual( nCellVal, rEntry.nVal ); |
| break; |
| default: |
| bOk= sal_False; |
| break; |
| } |
| } |
| else if ( (rEntry.eOp == SC_EQUAL || rEntry.eOp == SC_NOT_EQUAL) |
| || (rEntry.bQueryByString |
| && pCellData->HasStringData() ) |
| ) |
| { // by String |
| String aCellStr = pCellData->GetString(); |
| |
| sal_Bool bRealRegExp = (rParam.bRegExp && ((rEntry.eOp == SC_EQUAL) |
| || (rEntry.eOp == SC_NOT_EQUAL))); |
| sal_Bool bTestRegExp = sal_False; |
| if ( bRealRegExp || bTestRegExp ) |
| { |
| xub_StrLen nStart = 0; |
| xub_StrLen nEnd = aCellStr.Len(); |
| sal_Bool bMatch = (sal_Bool) rEntry.GetSearchTextPtr( rParam.bCaseSens ) |
| ->SearchFrwrd( aCellStr, &nStart, &nEnd ); |
| // from 614 on, nEnd is behind the found text |
| if ( bMatch && bMatchWholeCell |
| && (nStart != 0 || nEnd != aCellStr.Len()) ) |
| bMatch = sal_False; // RegExp must match entire cell string |
| if ( bRealRegExp ) |
| bOk = ((rEntry.eOp == SC_NOT_EQUAL) ? !bMatch : bMatch); |
| else |
| bTestEqual = bMatch; |
| } |
| if ( !bRealRegExp ) |
| { |
| if ( rEntry.eOp == SC_EQUAL || rEntry.eOp == SC_NOT_EQUAL ) |
| { |
| if ( bMatchWholeCell ) |
| { |
| bOk = pTransliteration->isEqual( aCellStr, *rEntry.pStr ); |
| |
| String aStr = *rEntry.pStr;//"f*" |
| //use another way to find "*" in aStr |
| sal_Bool bHasStar = sal_False; |
| xub_StrLen nIndex; |
| if( ( nIndex = aStr.Search('*') ) != STRING_NOTFOUND ) |
| bHasStar = sal_True; |
| if(bHasStar && (nIndex>0)) |
| { |
| for(i=0;(i<nIndex) && (i< aCellStr.Len()) ; i++) |
| { |
| if(aCellStr.GetChar( (sal_uInt16)i ) == aStr.GetChar((sal_uInt16) i )) |
| { |
| bOk=1; |
| } |
| else |
| { |
| bOk=0; |
| break; |
| } |
| } |
| } |
| //end modified |
| //Added end,20060808 |
| } |
| else |
| { |
| ::com::sun::star::uno::Sequence< sal_Int32 > xOff; |
| String aCell( pTransliteration->transliterate( |
| aCellStr, ScGlobal::eLnge, 0, aCellStr.Len(), |
| &xOff ) ); |
| String aQuer( pTransliteration->transliterate( |
| *rEntry.pStr, ScGlobal::eLnge, 0, rEntry.pStr->Len(), |
| &xOff ) ); |
| bOk = (aCell.Search( aQuer ) != STRING_NOTFOUND); |
| } |
| if ( rEntry.eOp == SC_NOT_EQUAL ) |
| bOk = !bOk; |
| } |
| else |
| { // use collator here because data was probably sorted |
| sal_Int32 nCompare = pCollator->compareString( |
| aCellStr, *rEntry.pStr ); |
| switch (rEntry.eOp) |
| { |
| case SC_LESS : |
| bOk = (nCompare < 0); |
| break; |
| case SC_GREATER : |
| bOk = (nCompare > 0); |
| break; |
| case SC_LESS_EQUAL : |
| bOk = (nCompare <= 0); |
| break; |
| case SC_GREATER_EQUAL : |
| bOk = (nCompare >= 0); |
| break; |
| case SC_NOT_EQUAL: |
| DBG_ASSERT( false , "SC_NOT_EQUAL"); |
| break; |
| case SC_TOPVAL: |
| case SC_BOTVAL: |
| case SC_TOPPERC: |
| case SC_BOTPERC: |
| default: |
| break; |
| } |
| } |
| } |
| } |
| |
| if (nPos == -1) |
| { |
| nPos++; |
| pPasst[nPos] = bOk; |
| pTest[nPos] = bTestEqual; |
| } |
| else |
| { |
| if (rEntry.eConnect == SC_AND) |
| { |
| pPasst[nPos] = pPasst[nPos] && bOk; |
| pTest[nPos] = pTest[nPos] && bTestEqual; |
| } |
| else |
| { |
| nPos++; |
| pPasst[nPos] = bOk; |
| pTest[nPos] = bTestEqual; |
| } |
| } |
| i++; |
| } |
| |
| for ( long j=1; j <= nPos; j++ ) |
| { |
| pPasst[0] = pPasst[0] || pPasst[j]; |
| pTest[0] = pTest[0] || pTest[j]; |
| } |
| |
| sal_Bool bRet = pPasst[0]; |
| if ( pPasst != &aBool[0] ) |
| delete [] pPasst; |
| if ( pTest != &aTest[0] ) |
| delete [] pTest; |
| |
| return bRet; |
| } |
| |
| // ----------------------------------------------------------------------- |
| bool ScDPTableDataCache::IsRowEmpty( SCROW nRow ) const |
| { |
| return mbEmptyRow[ nRow ]; |
| |
| } |
| |
| // ----------------------------------------------------------------------- |
| bool ScDPTableDataCache::IsEmptyMember( SCROW nRow, sal_uInt16 nColumn ) const |
| { |
| return !GetItemDataById( nColumn, GetItemDataId( nColumn, nRow, sal_False ) )->IsHasData(); |
| } |
| |
| sal_Bool ScDPTableDataCache::AddData(long nDim, ScDPItemData* pitemData, bool bCheckDate ) |
| { |
| DBG_ASSERT( IsValid(), " IsValid() == false " ); |
| DBG_ASSERT( nDim < mnColumnCount && nDim >=0 , "dimension out of bound" ); |
| SCROW nIndex = 0; |
| |
| sal_Bool bInserted = sal_False; |
| if( true == bCheckDate) |
| pitemData->SetDate( lcl_isDate( GetNumType( pitemData->nNumFormat ) ) ); |
| if ( !lcl_Search( mpTableDataValues[nDim], mpGlobalOrder[nDim], *pitemData, nIndex ) ) |
| { |
| mpTableDataValues[nDim].push_back( pitemData ); |
| mpGlobalOrder[nDim].insert( mpGlobalOrder[nDim].begin()+nIndex, mpTableDataValues[nDim].size()-1 ); |
| DBG_ASSERT( (size_t) mpGlobalOrder[nDim][nIndex] == mpTableDataValues[nDim].size()-1 ,"ScDPTableDataCache::AddData "); |
| mpSourceData[nDim].push_back( mpTableDataValues[nDim].size()-1 ); |
| bInserted = sal_True; |
| } |
| else |
| mpSourceData[nDim].push_back( mpGlobalOrder[nDim][nIndex] ); |
| //init empty row tag |
| size_t nCurRow = mpSourceData[nDim].size() -1 ; |
| |
| while ( mbEmptyRow.size() <= nCurRow ) |
| mbEmptyRow.push_back( sal_True ); |
| |
| if ( pitemData->IsHasData() ) |
| mbEmptyRow[ nCurRow ] = sal_False; |
| |
| if ( !bInserted ) |
| delete pitemData; |
| |
| return sal_True; |
| } |
| |
| String ScDPTableDataCache::GetDimensionName( sal_uInt16 nColumn ) const |
| { |
| DBG_ASSERT( /* nColumn>=0 && */ nColumn < mrLabelNames.size()-1 , "ScDPTableDataCache::GetDimensionName"); |
| DBG_ASSERT( mrLabelNames.size() == static_cast <sal_uInt16> (mnColumnCount+1), "ScDPTableDataCache::GetDimensionName"); |
| if ( static_cast<size_t>(nColumn+1) < mrLabelNames.size() ) |
| { |
| return mrLabelNames[nColumn+1]->aString; |
| } |
| else |
| return String(); |
| } |
| |
| |
| void ScDPTableDataCache::AddLabel(ScDPItemData *pData) |
| { |
| DBG_ASSERT( IsValid(), " IsValid() == false " ); |
| |
| if ( mrLabelNames.size() == 0 ) |
| mrLabelNames.push_back( new ScDPItemData( ScGlobal::GetRscString(STR_PIVOT_DATA) ) ); |
| |
| |
| //reset name if needed |
| String strNewName = pData->aString; |
| |
| // #i116457# don't modify empty column titles |
| if ( strNewName.Len() ) |
| { |
| sal_Bool bFound = sal_False; |
| long nIndex = 1; |
| do |
| { |
| for ( long i= mrLabelNames.size()-1; i>=0; i-- ) |
| { |
| if( mrLabelNames[i]->aString == strNewName ) |
| { |
| strNewName = pData->aString; |
| strNewName += String::CreateFromInt32( nIndex ); |
| nIndex ++ ; |
| bFound = sal_True; |
| } |
| } |
| bFound = !bFound; |
| } |
| while ( !bFound ); |
| } |
| |
| pData->aString = strNewName; |
| mrLabelNames.push_back( pData ); |
| } |
| |
| SCROW ScDPTableDataCache::GetItemDataId(sal_uInt16 nDim, SCROW nRow, sal_Bool bRepeatIfEmpty) const |
| { // |
| DBG_ASSERT( IsValid(), " IsValid() == false " ); |
| DBG_ASSERT( /* nDim >= 0 && */ nDim < mnColumnCount, "ScDPTableDataCache::GetItemDataId " ); |
| |
| if ( bRepeatIfEmpty ) |
| { |
| while ( nRow >0 && !mpTableDataValues[nDim][ mpSourceData[nDim][nRow] ]->IsHasData() ) |
| --nRow; |
| } |
| |
| return mpSourceData[nDim][nRow]; |
| } |
| |
| const ScDPItemData* ScDPTableDataCache::GetItemDataById(long nDim, SCROW nId) const |
| { |
| if ( nId >= GetRowCount() ) |
| return maAdditionalDatas.getData( nId - GetRowCount() ); |
| |
| if ( (size_t)nId >= mpTableDataValues[nDim].size() || nDim >= mnColumnCount || nId < 0 ) |
| return NULL; |
| else |
| return mpTableDataValues[nDim][nId]; |
| } |
| |
| SCROW ScDPTableDataCache::GetRowCount() const |
| { |
| if ( IsValid() ) |
| return mpSourceData[0].size(); |
| else |
| return 0; |
| } |
| |
| const std::vector<ScDPItemData*>& ScDPTableDataCache::GetDimMemberValues(SCCOL nDim) const |
| { |
| DBG_ASSERT( nDim>=0 && nDim < mnColumnCount ," nDim < mnColumnCount "); |
| return mpTableDataValues[nDim]; |
| } |
| |
| SCROW ScDPTableDataCache::GetSortedItemDataId(SCCOL nDim, SCROW nOrder) const |
| { |
| DBG_ASSERT ( IsValid(), "IsValid"); |
| DBG_ASSERT( nDim>=0 && nDim < mnColumnCount, "nDim < mnColumnCount"); |
| DBG_ASSERT( nOrder >= 0 && (size_t) nOrder < mpGlobalOrder[nDim].size(), "nOrder < mpGlobalOrder[nDim].size()" ); |
| |
| return mpGlobalOrder[nDim][nOrder]; |
| } |
| |
| sal_uLong ScDPTableDataCache::GetNumType(sal_uLong nFormat) const |
| { |
| SvNumberFormatter* pFormatter = mpDoc->GetFormatTable(); |
| sal_uLong nType = NUMBERFORMAT_NUMBER; |
| if ( pFormatter ) |
| nType = pFormatter->GetType( nFormat ); |
| return nType; |
| } |
| |
| sal_uLong ScDPTableDataCache::GetNumberFormat( long nDim ) const |
| { |
| if ( nDim >= mnColumnCount ) |
| return 0; |
| |
| // #i113411# take the number format from the first value entry |
| size_t nSize = mpTableDataValues[nDim].size(); |
| size_t nPos = 0; |
| while ( nPos < nSize && mpTableDataValues[nDim][nPos]->GetType() != SC_VALTYPE_VALUE ) |
| ++nPos; |
| if ( nPos < nSize ) |
| return mpTableDataValues[nDim][nPos]->nNumFormat; |
| return 0; |
| } |
| |
| sal_Bool ScDPTableDataCache::IsDateDimension( long nDim ) const |
| { |
| if ( nDim >= mnColumnCount ) |
| return false; |
| else if ( mpTableDataValues[nDim].size()==0 ) |
| return false; |
| else |
| return mpTableDataValues[nDim][0]->IsDate(); |
| |
| } |
| |
| SCROW ScDPTableDataCache::GetDimMemberCount( SCCOL nDim ) const |
| { |
| DBG_ASSERT( nDim>=0 && nDim < mnColumnCount ," ScDPTableDataCache::GetDimMemberCount : out of bound "); |
| return mpTableDataValues[nDim].size(); |
| } |
| |
| const ScDPItemData* ScDPTableDataCache::GetSortedItemData(SCCOL nDim, SCROW nOrder) const |
| { |
| SCROW n = GetSortedItemDataId( nDim, nOrder ); |
| return GetItemDataById( nDim, n ); |
| } |
| |
| SCCOL ScDPTableDataCache::GetDimensionIndex(String sName) const |
| { |
| for ( size_t n = 1; n < mrLabelNames.size(); n ++ ) //defects, label name map wrong |
| { |
| if ( mrLabelNames[n]->GetString() == sName ) |
| return (SCCOL)(n-1); |
| } |
| return -1; |
| } |
| |
| SCROW ScDPTableDataCache::GetIdByItemData(long nDim, String sItemData ) const |
| { |
| if ( nDim < mnColumnCount && nDim >=0 ) |
| { |
| for ( size_t n = 0; n< mpTableDataValues[nDim].size(); n++ ) |
| { |
| if ( mpTableDataValues[nDim][n]->GetString() == sItemData ) |
| return n; |
| } |
| } |
| |
| ScDPItemData rData ( sItemData ); |
| return GetRowCount() +maAdditionalDatas.getDataId(rData); |
| } |
| |
| SCROW ScDPTableDataCache::GetIdByItemData( long nDim, const ScDPItemData& rData ) const |
| { |
| if ( nDim < mnColumnCount && nDim >=0 ) |
| { |
| for ( size_t n = 0; n< mpTableDataValues[nDim].size(); n++ ) |
| { |
| if ( *mpTableDataValues[nDim][n] == rData ) |
| return n; |
| } |
| } |
| return GetRowCount() + maAdditionalDatas.getDataId(rData); |
| } |
| |
| SCROW ScDPTableDataCache::GetAdditionalItemID ( String sItemData ) |
| { |
| ScDPItemData rData ( sItemData ); |
| return GetAdditionalItemID( rData ); |
| } |
| |
| SCROW ScDPTableDataCache::GetAdditionalItemID( const ScDPItemData& rData ) |
| { |
| return GetRowCount() + maAdditionalDatas.insertData( rData ); |
| } |
| |
| |
| SCROW ScDPTableDataCache::GetOrder(long nDim, SCROW nIndex) const |
| { |
| DBG_ASSERT( IsValid(), " IsValid() == false " ); |
| DBG_ASSERT( nDim >=0 && nDim < mnColumnCount, "ScDPTableDataCache::GetOrder : out of bound" ); |
| |
| if ( mpIndexOrder[nDim].size() != mpGlobalOrder[nDim].size() ) |
| { //not inited |
| SCROW i = 0; |
| mpIndexOrder[nDim].resize( mpGlobalOrder[nDim].size(), 0 ); |
| for ( size_t n = 0 ; n< mpGlobalOrder[nDim].size(); n++ ) |
| { |
| i = mpGlobalOrder[nDim][n]; |
| mpIndexOrder[nDim][ i ] = n; |
| } |
| } |
| |
| DBG_ASSERT( nIndex>=0 && (size_t)nIndex < mpIndexOrder[nDim].size() , "ScDPTableDataCache::GetOrder"); |
| return mpIndexOrder[nDim][nIndex]; |
| } |
| |
| ScDocument* ScDPTableDataCache::GetDoc() const |
| { |
| return mpDoc; |
| }; |
| |
| long ScDPTableDataCache::GetColumnCount() const |
| { |
| return mnColumnCount; |
| } |
| long ScDPTableDataCache::GetId() const |
| { |
| return mnID; |
| } |
