| /************************************************************** |
| * |
| * 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_connectivity.hxx" |
| #include "dbase/DIndexIter.hxx" |
| #include <com/sun/star/sdb/SQLFilterOperator.hpp> |
| |
| using namespace ::com::sun::star::sdb; |
| using namespace connectivity; |
| using namespace connectivity::dbase; |
| using namespace connectivity::file; |
| using namespace ::com::sun::star::sdb; |
| //================================================================== |
| // OIndexIterator |
| //================================================================== |
| //------------------------------------------------------------------ |
| OIndexIterator::~OIndexIterator() |
| { |
| // m_pIndex->UnLock(); |
| m_pIndex->release(); |
| } |
| |
| //------------------------------------------------------------------ |
| sal_uIntPtr OIndexIterator::First() |
| { |
| return Find(sal_True); |
| } |
| |
| //------------------------------------------------------------------ |
| sal_uIntPtr OIndexIterator::Next() |
| { |
| return Find(sal_False); |
| } |
| //------------------------------------------------------------------ |
| sal_uIntPtr OIndexIterator::Find(sal_Bool bFirst) |
| { |
| // ONDXIndex* m_pIndex = GetNDXIndex(); |
| |
| sal_uIntPtr nRes = STRING_NOTFOUND; |
| // if (!m_pIndex->IsOpen()) |
| // return nRes; |
| |
| if (bFirst) |
| { |
| m_aRoot = m_pIndex->getRoot(); |
| m_aCurLeaf = NULL; |
| } |
| |
| if (!m_pOperator) |
| { |
| // Vorbereitung , auf kleinstes Element positionieren |
| if (bFirst) |
| { |
| ONDXPage* pPage = m_aRoot; |
| while (pPage && !pPage->IsLeaf()) |
| pPage = pPage->GetChild(m_pIndex); |
| |
| m_aCurLeaf = pPage; |
| m_nCurNode = NODE_NOTFOUND; |
| } |
| ONDXKey* pKey = GetNextKey(); |
| nRes = pKey ? pKey->GetRecord() : STRING_NOTFOUND; |
| } |
| else if (m_pOperator->IsA(TYPE(OOp_ISNOTNULL))) |
| nRes = GetNotNull(bFirst); |
| else if (m_pOperator->IsA(TYPE(OOp_ISNULL))) |
| nRes = GetNull(bFirst); |
| else if (m_pOperator->IsA(TYPE(OOp_LIKE))) |
| nRes = GetLike(bFirst); |
| else if (m_pOperator->IsA(TYPE(OOp_COMPARE))) |
| nRes = GetCompare(bFirst); |
| |
| return nRes; |
| } |
| |
| //------------------------------------------------------------------ |
| ONDXKey* OIndexIterator::GetFirstKey(ONDXPage* pPage, const OOperand& rKey) |
| { |
| // sucht den vorgegeben key |
| // Besonderheit: gelangt der Algorithmus ans Ende |
| // wird immer die aktuelle Seite und die Knotenposition vermerkt |
| // auf die die Bedingung <= zutrifft |
| // dieses findet beim Insert besondere Beachtung |
| // ONDXIndex* m_pIndex = GetNDXIndex(); |
| OOp_COMPARE aTempOp(SQLFilterOperator::GREATER); |
| sal_uInt16 i = 0; |
| |
| if (pPage->IsLeaf()) |
| { |
| // im blatt wird die eigentliche Operation ausgefuehrt, sonst die temp. (>) |
| while (i < pPage->Count() && !m_pOperator->operate(&((*pPage)[i]).GetKey(),&rKey)) |
| i++; |
| } |
| else |
| while (i < pPage->Count() && !aTempOp.operate(&((*pPage)[i]).GetKey(),&rKey)) |
| i++; |
| |
| |
| ONDXKey* pFoundKey = NULL; |
| if (!pPage->IsLeaf()) |
| { |
| // weiter absteigen |
| ONDXPagePtr aPage = (i==0) ? pPage->GetChild(m_pIndex) |
| : ((*pPage)[i-1]).GetChild(m_pIndex, pPage); |
| pFoundKey = aPage.Is() ? GetFirstKey(aPage, rKey) : NULL; |
| } |
| else if (i == pPage->Count()) |
| { |
| pFoundKey = NULL; |
| } |
| else |
| { |
| pFoundKey = &(*pPage)[i].GetKey(); |
| if (!m_pOperator->operate(pFoundKey,&rKey)) |
| pFoundKey = NULL; |
| |
| m_aCurLeaf = pPage; |
| m_nCurNode = pFoundKey ? i : i - 1; |
| } |
| return pFoundKey; |
| } |
| |
| //------------------------------------------------------------------ |
| sal_uIntPtr OIndexIterator::GetCompare(sal_Bool bFirst) |
| { |
| ONDXKey* pKey = NULL; |
| // ONDXIndex* m_pIndex = GetNDXIndex(); |
| sal_Int32 ePredicateType = PTR_CAST(file::OOp_COMPARE,m_pOperator)->getPredicateType(); |
| |
| if (bFirst) |
| { |
| // Vorbereitung , auf kleinstes Element positionieren |
| ONDXPage* pPage = m_aRoot; |
| switch (ePredicateType) |
| { |
| case SQLFilterOperator::NOT_EQUAL: |
| case SQLFilterOperator::LESS: |
| case SQLFilterOperator::LESS_EQUAL: |
| while (pPage && !pPage->IsLeaf()) |
| pPage = pPage->GetChild(m_pIndex); |
| |
| m_aCurLeaf = pPage; |
| m_nCurNode = NODE_NOTFOUND; |
| } |
| |
| |
| switch (ePredicateType) |
| { |
| case SQLFilterOperator::NOT_EQUAL: |
| while ( ( ( pKey = GetNextKey() ) != NULL ) && !m_pOperator->operate(pKey,m_pOperand)) ; |
| break; |
| case SQLFilterOperator::LESS: |
| while ( ( ( pKey = GetNextKey() ) != NULL ) && pKey->getValue().isNull()) ; |
| break; |
| case SQLFilterOperator::LESS_EQUAL: |
| while ( ( pKey = GetNextKey() ) != NULL ) ; |
| break; |
| case SQLFilterOperator::GREATER_EQUAL: |
| case SQLFilterOperator::EQUAL: |
| pKey = GetFirstKey(m_aRoot,*m_pOperand); |
| break; |
| case SQLFilterOperator::GREATER: |
| pKey = GetFirstKey(m_aRoot,*m_pOperand); |
| if ( !pKey ) |
| while ( ( ( pKey = GetNextKey() ) != NULL ) && !m_pOperator->operate(pKey,m_pOperand)) ; |
| } |
| } |
| else |
| { |
| switch (ePredicateType) |
| { |
| case SQLFilterOperator::NOT_EQUAL: |
| while ( ( ( pKey = GetNextKey() ) != NULL ) && !m_pOperator->operate(pKey,m_pOperand)) |
| ; |
| break; |
| case SQLFilterOperator::LESS: |
| case SQLFilterOperator::LESS_EQUAL: |
| case SQLFilterOperator::EQUAL: |
| if ( ( ( pKey = GetNextKey() ) == NULL ) || !m_pOperator->operate(pKey,m_pOperand)) |
| { |
| pKey = NULL; |
| m_aCurLeaf = NULL; |
| } |
| break; |
| case SQLFilterOperator::GREATER_EQUAL: |
| case SQLFilterOperator::GREATER: |
| pKey = GetNextKey(); |
| } |
| } |
| |
| return pKey ? pKey->GetRecord() : STRING_NOTFOUND; |
| } |
| |
| //------------------------------------------------------------------ |
| sal_uIntPtr OIndexIterator::GetLike(sal_Bool bFirst) |
| { |
| // ONDXIndex* m_pIndex = GetNDXIndex(); |
| if (bFirst) |
| { |
| ONDXPage* pPage = m_aRoot; |
| |
| while (pPage && !pPage->IsLeaf()) |
| pPage = pPage->GetChild(m_pIndex); |
| |
| m_aCurLeaf = pPage; |
| m_nCurNode = NODE_NOTFOUND; |
| } |
| |
| ONDXKey* pKey; |
| while ( ( ( pKey = GetNextKey() ) != NULL ) && !m_pOperator->operate(pKey,m_pOperand)) |
| ; |
| return pKey ? pKey->GetRecord() : STRING_NOTFOUND; |
| } |
| |
| //------------------------------------------------------------------ |
| sal_uIntPtr OIndexIterator::GetNull(sal_Bool bFirst) |
| { |
| // ONDXIndex* m_pIndex = GetNDXIndex(); |
| if (bFirst) |
| { |
| ONDXPage* pPage = m_aRoot; |
| while (pPage && !pPage->IsLeaf()) |
| pPage = pPage->GetChild(m_pIndex); |
| |
| m_aCurLeaf = pPage; |
| m_nCurNode = NODE_NOTFOUND; |
| } |
| |
| ONDXKey* pKey; |
| if ( ( ( pKey = GetNextKey() ) == NULL ) || !pKey->getValue().isNull()) |
| { |
| pKey = NULL; |
| m_aCurLeaf = NULL; |
| } |
| return pKey ? pKey->GetRecord() : STRING_NOTFOUND; |
| } |
| |
| //------------------------------------------------------------------ |
| sal_uIntPtr OIndexIterator::GetNotNull(sal_Bool bFirst) |
| { |
| ONDXKey* pKey; |
| // ONDXIndex* m_pIndex = GetNDXIndex(); |
| if (bFirst) |
| { |
| // erst alle NULL werte abklappern |
| for (sal_uIntPtr nRec = GetNull(bFirst); |
| nRec != STRING_NOTFOUND; |
| nRec = GetNull(sal_False)) |
| ; |
| pKey = m_aCurLeaf.Is() ? &(*m_aCurLeaf)[m_nCurNode].GetKey() : NULL; |
| } |
| else |
| pKey = GetNextKey(); |
| |
| return pKey ? pKey->GetRecord() : STRING_NOTFOUND; |
| } |
| |
| //------------------------------------------------------------------ |
| ONDXKey* OIndexIterator::GetNextKey() |
| { |
| // ONDXIndex* m_pIndex = GetNDXIndex(); |
| if (m_aCurLeaf.Is() && ((++m_nCurNode) >= m_aCurLeaf->Count())) |
| { |
| ONDXPage* pPage = m_aCurLeaf; |
| // naechste Seite suchen |
| while (pPage) |
| { |
| ONDXPage* pParentPage = pPage->GetParent(); |
| if (pParentPage) |
| { |
| sal_uInt16 nPos = pParentPage->Search(pPage); |
| if (nPos != pParentPage->Count() - 1) |
| { // Seite gefunden |
| pPage = (*pParentPage)[nPos+1].GetChild(m_pIndex,pParentPage); |
| break; |
| } |
| } |
| pPage = pParentPage; |
| } |
| |
| // jetzt wieder zum Blatt |
| while (pPage && !pPage->IsLeaf()) |
| pPage = pPage->GetChild(m_pIndex); |
| |
| m_aCurLeaf = pPage; |
| m_nCurNode = 0; |
| } |
| return m_aCurLeaf.Is() ? &(*m_aCurLeaf)[m_nCurNode].GetKey() : NULL; |
| } |
| |
