1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/dbms/utable/UT_QUERY.CPP Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,828 @@
1.4 +// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "UT_STD.H"
1.20 +#include "D32COMP.H"
1.21 +#include <d32dbmsconstants.h>
1.22 +
1.23 +// Class RDbAccessPlan::TPlan
1.24 +
1.25 +TInt RDbAccessPlan::TPlan::OrderByPlan(const TPlan& aLeft,const TPlan& aRight)
1.26 + {
1.27 + TUint lpos=aLeft.Type();
1.28 + TUint rpos=aRight.Type();
1.29 + __ASSERT(lpos!=0 && rpos!=0 ); // should be no table iterators
1.30 + return lpos-rpos;
1.31 + }
1.32 +
1.33 +RDbAccessPlan::TPlan::TType RDbAccessPlan::TPlan::Type() const
1.34 +//
1.35 +// flag values: 0=A, 1=C, 2=B, 3=D, 8=E/F, 10=G/H, 16=M/N, 18=S/T, 20=I/J, 21=K/L, 22=O/P, 23=Q/R
1.36 +// This determines order of plans
1.37 +//
1.38 + {
1.39 + static const TUint KPosition[]={EPlanA,EPlanC,EPlanB,EPlanD,0,0,0,0,EPlanEF,0,EPlanGH,0,0,0,0,0,EPlanMN,
1.40 + 0,EPlanST,0,EPlanIJ,EPlanKL,EPlanOP,EPlanQR};
1.41 + __ASSERT_ALWAYS(((iFlags&EMask) < (sizeof(KPosition)/sizeof(KPosition[0]))), User::Invariant());
1.42 + return TType(KPosition[iFlags&EMask]);
1.43 + }
1.44 +
1.45 +// Class RDbAccessPlan::TBounds
1.46 +
1.47 +RDbAccessPlan::TBounds::TBounds(const TPlan& aPlan)
1.48 + : iLowerPred(aPlan.iLower),iUpperPred(aPlan.iUpper),iLower(0),iUpper(0),iInclusion(0)
1.49 + {
1.50 + SetLowerBounds();
1.51 + SetUpperBounds();
1.52 + if (aPlan.iIndex->Key()[0].iOrder==TDbKeyCol::EDesc)
1.53 + {
1.54 + TDbLookupKey* t=iLower;
1.55 + iLower=iUpper;
1.56 + iUpper=t;
1.57 + iInclusion=(iInclusion>>1)|(iInclusion<<1);
1.58 + }
1.59 + }
1.60 +
1.61 +void RDbAccessPlan::TBounds::GetLookupKey(const CSqlCompPredicate& aCompPredicate,TDbLookupKey& aLookup)
1.62 + {
1.63 + const RSqlLiteral& value=aCompPredicate.Value();
1.64 + switch (aCompPredicate.ColType())
1.65 + {
1.66 + default:
1.67 + __ASSERT(0);
1.68 + case EDbColBit:
1.69 + case EDbColInt8:
1.70 + case EDbColUint8:
1.71 + case EDbColInt16:
1.72 + case EDbColUint16:
1.73 + case EDbColInt32:
1.74 + case EDbColUint32:
1.75 + case EDbColInt64:
1.76 + aLookup.Add(value.Int64());
1.77 + break;
1.78 + case EDbColReal32:
1.79 + case EDbColReal64:
1.80 + aLookup.Add(value.Real64());
1.81 + break;
1.82 + case EDbColDateTime:
1.83 + aLookup.Add(value.Time());
1.84 + break;
1.85 + case EDbColText8:
1.86 + case EDbColLongText8:
1.87 + aLookup.Add(value.Text8());
1.88 + break;
1.89 + case EDbColText16:
1.90 + case EDbColLongText16:
1.91 + aLookup.Add(value.Text16());
1.92 + break;
1.93 + }
1.94 + }
1.95 +
1.96 +void RDbAccessPlan::TBounds::SetLowerBounds()
1.97 + {
1.98 + if (!iLowerPred) // iLower already set to 0
1.99 + return;
1.100 + GetLookupKey(*iLowerPred,iLowerKey);
1.101 + switch (iLowerPred->NodeType())
1.102 + {
1.103 + default:
1.104 + __ASSERT(0);
1.105 + case CSqlSearchCondition::ELessEqual:
1.106 + case CSqlSearchCondition::ELess:
1.107 + iLower=0;
1.108 + break;
1.109 + case CSqlSearchCondition::EEqual:
1.110 + case CSqlSearchCondition::EGreaterEqual:
1.111 + iInclusion|=CDbRecordIndex::EIncludeLower;
1.112 + case CSqlSearchCondition::EGreater:
1.113 + iLower=&iLowerKey;
1.114 + break;
1.115 + }
1.116 + }
1.117 +
1.118 +void RDbAccessPlan::TBounds::SetUpperBounds()
1.119 + {
1.120 + if (!iUpperPred)
1.121 + return;
1.122 + GetLookupKey(*iUpperPred,iUpperKey);
1.123 + switch (iUpperPred->NodeType())
1.124 + {
1.125 + default:
1.126 + __ASSERT(0);
1.127 + case CSqlSearchCondition::EGreaterEqual:
1.128 + case CSqlSearchCondition::EGreater:
1.129 + iUpper=0;
1.130 + break;
1.131 + case CSqlSearchCondition::EEqual:
1.132 + case CSqlSearchCondition::ELessEqual:
1.133 + iInclusion|=CDbRecordIndex::EIncludeUpper;
1.134 + case CSqlSearchCondition::ELess:
1.135 + iUpper=&iUpperKey;
1.136 + break;
1.137 + }
1.138 + }
1.139 +
1.140 +// Class RDbAccessPlan::CDbCompPredicateList
1.141 +
1.142 +RDbAccessPlan::CDbCompPredicateList* RDbAccessPlan::CDbCompPredicateList::NewLC(CSqlQuery& aQuery,TDbTextComparison aComparison,const CDbTableDef& aTableDef)
1.143 + {
1.144 + CDbCompPredicateList* self=new(ELeave) CDbCompPredicateList(aTableDef,aComparison);
1.145 + CleanupStack::PushL(self);
1.146 + CSqlSearchCondition& sc=aQuery.SearchCondition();
1.147 + self->ConstructL(sc);
1.148 + return self;
1.149 + }
1.150 +
1.151 +void RDbAccessPlan::CDbCompPredicateList::ConstructL(CSqlSearchCondition& aSearchCondition)
1.152 +//
1.153 +// fill the list with valid comp pred's
1.154 +//
1.155 + {
1.156 + TUint type=Type(aSearchCondition.NodeType());
1.157 + if (type&ECompPred)
1.158 + {
1.159 + CSqlCompPredicate* cp=aSearchCondition.CompPredicate();
1.160 + const TDesC& colName=cp->ColumnName();
1.161 + if (IsIndexed(colName))
1.162 + AppendL(cp);
1.163 + else
1.164 + iRestriction=ETrue;
1.165 + }
1.166 + else if (type&EAnd)
1.167 + {
1.168 + CSqlMultiNode* multiNode=aSearchCondition.MultiNode();
1.169 + for (TInt ii=multiNode->Count();ii--;)
1.170 + {
1.171 + CSqlSearchCondition* node=multiNode->SubNode(ii);
1.172 + ConstructL(*node);
1.173 + }
1.174 + }
1.175 + else
1.176 + iRestriction=ETrue;
1.177 + }
1.178 +
1.179 +TUint RDbAccessPlan::CDbCompPredicateList::Type(CSqlSearchCondition::TType aType) const
1.180 +//
1.181 +// converts CSqlSearchCondition::TType into flag
1.182 +//
1.183 + {
1.184 + switch (aType)
1.185 + {
1.186 + case CSqlSearchCondition::EAnd:
1.187 + return EAnd;
1.188 + case CSqlSearchCondition::ELess:
1.189 + return ELess;
1.190 + case CSqlSearchCondition::ELessEqual:
1.191 + return ELessEqual;
1.192 + case CSqlSearchCondition::EEqual:
1.193 + return EEqual;
1.194 + case CSqlSearchCondition::EGreaterEqual:
1.195 + return EGreaterEqual;
1.196 + case CSqlSearchCondition::EGreater:
1.197 + return EGreater;
1.198 + default:
1.199 + return ENone;
1.200 + }
1.201 + }
1.202 +
1.203 +TBool RDbAccessPlan::CDbCompPredicateList::IsIndexed(const TDesC& aColumnName)
1.204 +//
1.205 +// Checks if aColumnName is indexed. If its a text column the comparison method should be the same
1.206 +//
1.207 + {
1.208 + const CDbTableIndexDef* key=iTableDef.Key(aColumnName);
1.209 + if (!key)
1.210 + return EFalse;
1.211 + const TDbColumnDef* colDef=NULL;
1.212 + TRAPD(errCode, colDef=iTableDef.Columns().ColumnL(aColumnName));
1.213 + if(errCode != KErrNone)
1.214 + return EFalse;
1.215 + if (colDef->Type()>EDbColDateTime && key->Key().Comparison()!=iComparison)
1.216 + return EFalse;
1.217 + return ETrue;
1.218 + }
1.219 +
1.220 +CSqlCompPredicate* RDbAccessPlan::CDbCompPredicateList::CompPredicate(TDbColNo aColNo,TUint aType)
1.221 +//
1.222 +// Returns first CompPredicate found in the list with required type & col no, and removes from list
1.223 +//
1.224 + {
1.225 + for (TInt ii=Count();ii--;)
1.226 + {
1.227 + CSqlCompPredicate* cp=At(ii);
1.228 + TUint type=Type(cp->NodeType());
1.229 + TDbColNo colNo=cp->ColNo();
1.230 + if (!type&aType || aColNo!=colNo)
1.231 + continue;
1.232 + Delete(ii);
1.233 + return cp;
1.234 + }
1.235 + return 0;
1.236 + }
1.237 +
1.238 +// class Validate
1.239 +
1.240 +void Validate::NameL(const TDesC& aName)
1.241 + {
1.242 + if (aName.Length()<=KDbMaxName)
1.243 + {
1.244 + TLex lex(aName);
1.245 + if (!lex.Eos() && lex.Get().IsAlpha())
1.246 + {
1.247 + TChar c;
1.248 + do
1.249 + {
1.250 + if (lex.Eos())
1.251 + return;
1.252 + c=lex.Get();
1.253 + } while (c.IsAlphaDigit()||c=='_');
1.254 + }
1.255 + }
1.256 + __LEAVE(KErrBadName);
1.257 + }
1.258 +
1.259 +void Validate::UniqueNameL(TDesC const** aNames,TInt aCount,const TDesC& aName)
1.260 +//
1.261 +// Ensure that aName is not a duplicate of any of aNames, and add
1.262 +// the new name to the collection. Binary search is used for speed
1.263 +//
1.264 + {
1.265 + TInt left=0;
1.266 + TInt right=aCount;
1.267 + while (left<right)
1.268 + {
1.269 + TInt mid=(left+right)>>1;
1.270 + TInt c=aNames[mid]->CompareF(aName);
1.271 + if (c<0)
1.272 + left=mid+1;
1.273 + else if (c>0)
1.274 + right=mid;
1.275 + else
1.276 + __LEAVE(KErrArgument);
1.277 + }
1.278 + Mem::Move(aNames+left+1,aNames+left,(aCount-left)*sizeof(TDesC const*));
1.279 + aNames[left]=&aName;
1.280 + }
1.281 +
1.282 +void Validate::ColSetL(const CDbColSet& aColSet)
1.283 + {
1.284 + TDbColSetIter iter(aColSet);
1.285 + if (!iter)
1.286 + __LEAVE(KErrArgument);
1.287 + TDesC const** names=(TDesC const**)User::AllocLC(aColSet.Count()*sizeof(TDesC const*));
1.288 + do
1.289 + {
1.290 + const TDbCol& col=*iter;
1.291 + NameL(col.iName);
1.292 + UniqueNameL(names,iter.Col()-1,col.iName);
1.293 + TInt type=TInt(col.iType);
1.294 + if (type<TInt(EDbColBit)||type>TInt(EDbColLongBinary))
1.295 + __LEAVE(KErrNotSupported);
1.296 + else if (col.iMaxLength<1&&col.iMaxLength!=KDbUndefinedLength)
1.297 + __LEAVE(KErrArgument);
1.298 + else if (col.iAttributes&~(TDbCol::ENotNull|TDbCol::EAutoIncrement))
1.299 + __LEAVE(KErrNotSupported); // unknown attributes
1.300 + else if (type>EDbColUint32 && col.iAttributes&TDbCol::EAutoIncrement)
1.301 + __LEAVE(KErrArgument); // auto increment on non-integral type
1.302 + } while (++iter);
1.303 + CleanupStack::PopAndDestroy();
1.304 + }
1.305 +
1.306 +void Validate::KeyL(const CDbKey& aKey,const HDbColumnSet& aColumns)
1.307 +//
1.308 +// Check that the key is valid for the table
1.309 +//
1.310 + {
1.311 + TInt max=aKey.Count()-1;
1.312 + if (max<0)
1.313 + __LEAVE(KErrArgument);
1.314 + for (TInt ii=0;ii<=max;++ii)
1.315 + {
1.316 + const TDbKeyCol& kCol=aKey[ii];
1.317 + HDbColumnSet::TIteratorC col=aColumns.ColumnL(kCol.iName);
1.318 + if (col==NULL)
1.319 + __LEAVE(KErrNotFound);
1.320 + TInt len=kCol.iLength;
1.321 + if (len!=KDbUndefinedLength)
1.322 + {
1.323 + if (col->iType<=EDbColDateTime)
1.324 + __LEAVE(KErrArgument);
1.325 + TInt cLen=col->iMaxLength;
1.326 + if (ii<max)
1.327 + {
1.328 + if (len!=cLen)
1.329 + __LEAVE(KErrNotSupported);
1.330 + continue;
1.331 + }
1.332 + if (len<=0)
1.333 + __LEAVE(KErrArgument);
1.334 + else if (cLen!=KDbUndefinedLength && cLen<len)
1.335 + __LEAVE(KErrArgument);
1.336 + }
1.337 + }
1.338 + }
1.339 +
1.340 +// Class RDbAccessPlan
1.341 +
1.342 +TUint RDbAccessPlan::FindMatchL(const CDbTableIndexDef* aIndex)
1.343 +//
1.344 +// Checks if index best matches the order specified
1.345 +//
1.346 + {
1.347 + CDbKey& order=iQuery->SortSpecification();
1.348 + TInt count=order.Count();
1.349 + const TDbColumnDef* columnDef = iTable->Def().Columns().ColumnL(order[count-1].iName);
1.350 + __ASSERT(columnDef != NULL);
1.351 + TInt columnLength = columnDef->iMaxLength;
1.352 + const CDbKey& key=aIndex->Key();
1.353 + TUint ret=0;
1.354 + if (TextKeyL(order) && order.Comparison()!=key.Comparison())
1.355 + return ret;
1.356 + TInt kCount=key.Count();
1.357 + for (TInt ii=0,rev=0;;)
1.358 + {
1.359 + const TDbKeyCol& kcol=key[ii];
1.360 + const TDbKeyCol& ocol=order[ii];
1.361 + if (kcol.iName.CompareF(ocol.iName)!=0)
1.362 + break;
1.363 + TInt revcol=kcol.iOrder^ocol.iOrder;
1.364 + if (ii==0)
1.365 + rev=revcol;
1.366 + else if (rev!=revcol)
1.367 + break;
1.368 + if (++ii==count) // end of order key
1.369 + {
1.370 + ret|=EMatch;
1.371 + if (kcol.iLength!=columnLength)
1.372 + ret|=ETruncated;
1.373 + if (rev)
1.374 + ret|=EReverse;
1.375 + return ret;
1.376 + }
1.377 + if (ii==kCount) // end of index key
1.378 + {
1.379 + ret|=EMatch;
1.380 + if (key.IsUnique())
1.381 + { // will provide the right order by, use it
1.382 + if (rev)
1.383 + ret|=EReverse;
1.384 + return ret;
1.385 + }
1.386 + break;
1.387 + }
1.388 + }
1.389 + return ret;
1.390 + }
1.391 +
1.392 +TBool RDbAccessPlan::TextKeyL(const CDbKey& anOrder)
1.393 +//
1.394 +// return whether any of the keys are text columns
1.395 +//
1.396 + {
1.397 + const HDbColumnSet& cols=iTable->Def().Columns();
1.398 + TInt count=anOrder.Count();
1.399 + for (TInt ii=0;ii<count;++ii)
1.400 + {
1.401 + const TDbColumnDef* columnDef = cols.ColumnL(anOrder[ii].iName);
1.402 + __ASSERT(columnDef != NULL);
1.403 +
1.404 + switch (columnDef->Type())
1.405 + {
1.406 + case EDbColText8:
1.407 + case EDbColText16:
1.408 + case EDbColLongText8:
1.409 + case EDbColLongText16:
1.410 + return ETrue;
1.411 + default:
1.412 + break;
1.413 + }
1.414 + }
1.415 + return EFalse;
1.416 + }
1.417 +
1.418 +CDbTableSource* RDbAccessPlan::TableLC(CDbTableDatabase& aDatabase,const TDesC& aTable)
1.419 + {
1.420 + __ASSERT(!iSource);
1.421 + CDbTableSource* source=aDatabase.TableSourceL(aTable);
1.422 + iSource=source;
1.423 + iTable=&source->Table();
1.424 + CleanupStack::PushL(TCleanupItem(Cleanup,this));
1.425 + return source;
1.426 + }
1.427 +
1.428 +void RDbAccessPlan::Insert(CDbDataStage* aStage)
1.429 + {
1.430 + __ASSERT(iSource);
1.431 + aStage->SetSource(iSource);
1.432 + iSource=aStage;
1.433 + }
1.434 +
1.435 +void RDbAccessPlan::Cleanup(TAny* aPtr)
1.436 + {
1.437 + RDbAccessPlan& self=*STATIC_CAST(RDbAccessPlan*,aPtr);
1.438 + self.iPlans.Close();
1.439 + delete self.iSource;
1.440 + }
1.441 +
1.442 +CDbRecordIter* RDbAccessPlan::IteratorL(const TPlan& aPlan)
1.443 +//
1.444 +// Returns the right iterator
1.445 +//
1.446 + {
1.447 + if (aPlan.iFlags&TPlan::EIndex)
1.448 + return iTable->IteratorL(*aPlan.iIndex);
1.449 + if (aPlan.iFlags&TPlan::EBounded)
1.450 + return BoundedIteratorL(aPlan);
1.451 + return iTable->IteratorL();
1.452 + }
1.453 +
1.454 +CDbRecordIter* RDbAccessPlan::BoundedIteratorL(const TPlan& aPlan)
1.455 + {
1.456 + TBounds bounds(aPlan);
1.457 + CDbRecordIter* iter=iTable->IteratorL(*aPlan.iIndex,bounds.iInclusion,bounds.iLower,bounds.iUpper);
1.458 + if (aPlan.iLower)
1.459 + iQuery->RemovePredicate(aPlan.iLower);
1.460 + if (aPlan.iUpper && aPlan.iLower!=aPlan.iUpper)
1.461 + iQuery->RemovePredicate(aPlan.iUpper);
1.462 + return iter;
1.463 + }
1.464 +
1.465 +void RDbAccessPlan::RestrictionL()
1.466 + {
1.467 + CDbRestrictStage* restriction=new(ELeave) CDbRestrictStage(iComparison);
1.468 + Insert(restriction);
1.469 + CSqlSearchCondition* searchcondition=iQuery->AdoptSearchCondition();
1.470 + restriction->SetRestriction(searchcondition);
1.471 + }
1.472 +
1.473 +void RDbAccessPlan::OrderByL(const RDbTableRow& aRowBuf)
1.474 + {
1.475 + CDbOrderByStage* ordering=new(ELeave) CDbOrderByStage(aRowBuf);
1.476 + Insert(ordering);
1.477 + ordering->ConstructL(iQuery->SortSpecification());
1.478 + }
1.479 +
1.480 +void RDbAccessPlan::ProjectionL()
1.481 + {
1.482 + CDbProjectStage* projection=new(ELeave) CDbProjectStage;
1.483 + Insert(projection);
1.484 + projection->ConstructL(iQuery->ColumnList(),iTable->Def().Columns());
1.485 + }
1.486 +
1.487 +void RDbAccessPlan::WindowL(const TPlan& aPlan,const TDbWindow& aWindow)
1.488 + {
1.489 + if (aPlan.iFlags&TPlan::EWindow)
1.490 + Insert(new(ELeave) CDbWindowStage(KDbUnlimitedWindow));
1.491 + else if (aWindow.Size()!=aWindow.ENone && aWindow.Size()!=aWindow.EUnlimited)
1.492 + Insert(new(ELeave) CDbWindowStage(aWindow));
1.493 + }
1.494 +
1.495 +TBool RDbAccessPlan::IsIndexIteratorL(TPlan& aPlan,const CDbTableIndexDef* aIndex)
1.496 +//
1.497 +// If an index iterator can be used, sets aPlan, else returns EFalse
1.498 +//
1.499 + {
1.500 + if (!iQuery->HasSortSpecification())
1.501 + return EFalse;
1.502 + TUint ret=FindMatchL(aIndex);
1.503 + if ((ret&EMatch)==0)
1.504 + return EFalse;
1.505 + // can use index iterator
1.506 + aPlan.iFlags&=~TPlan::EOrder;
1.507 + if (ret&EReverse)
1.508 + aPlan.iFlags|=TPlan::EReverse;
1.509 + aPlan.iFlags|=TPlan::EIndex;
1.510 + aPlan.iIndex=aIndex;
1.511 + return ETrue;
1.512 + }
1.513 +
1.514 +TBool RDbAccessPlan::IsBoundedIteratorL(TPlan& aPlan,const CDbTableIndexDef* aIndex)
1.515 +//
1.516 +// If a bounded iterator can be used, sets aPlan, else returns EFalse
1.517 +//
1.518 + {
1.519 + if (!iQuery->HasSearchCondition())
1.520 + return EFalse;
1.521 + TDbColNo keyColNo=iTable->Def().Columns().ColNoL(aIndex->Key()[0].iName);
1.522 + CDbCompPredicateList* list=CDbCompPredicateList::NewLC(*iQuery,iComparison,iTable->Def());
1.523 + CSqlCompPredicate* cp=list->CompPredicate(keyColNo,CDbCompPredicateList::EEqual);
1.524 + if (cp==0 && (cp=list->CompPredicate(keyColNo))==0)
1.525 + {
1.526 + CleanupStack::PopAndDestroy(); // list
1.527 + return EFalse;
1.528 + }
1.529 + // boundaries
1.530 + TUint type=list->Type(cp->NodeType());
1.531 + aPlan.iLower=type&(CDbCompPredicateList::ELess|CDbCompPredicateList::ELessEqual)?0:cp;
1.532 + aPlan.iUpper=type&(CDbCompPredicateList::EGreater|CDbCompPredicateList::EGreaterEqual)?0:cp;
1.533 + // find other boundary, if present
1.534 + if (list->Count()!=0 && cp->NodeType()!=CSqlSearchCondition::EEqual)
1.535 + {
1.536 + TUint nextType=type&(CDbCompPredicateList::ELess|CDbCompPredicateList::ELessEqual) ?
1.537 + CDbCompPredicateList::EGreater|CDbCompPredicateList::EGreaterEqual :
1.538 + CDbCompPredicateList::ELess|CDbCompPredicateList::ELessEqual;
1.539 + CSqlCompPredicate* cp2=list->CompPredicate(keyColNo,nextType);
1.540 + if (cp2)
1.541 + {
1.542 + if (nextType&(CDbCompPredicateList::ELess|CDbCompPredicateList::ELessEqual))
1.543 + aPlan.iUpper=cp2;
1.544 + else
1.545 + aPlan.iLower=cp2;
1.546 + }
1.547 + }
1.548 + // check which order the index is in and reverse if descending
1.549 + const TDbKeyCol& key=aIndex->Key()[0];
1.550 + if ((key.iOrder==TDbKeyCol::EDesc && !aPlan.iUpper) || (key.iOrder==TDbKeyCol::EAsc && !aPlan.iLower))
1.551 + aPlan.iFlags|=TPlan::EReverse; // optimise the bounding for forwards iteration
1.552 + if (!list->IsRestriction() && list->Count()==0)
1.553 + aPlan.iFlags&=~TPlan::ERestrict;
1.554 + CleanupStack::PopAndDestroy(); // list
1.555 + aPlan.iFlags|=TPlan::EBounded;
1.556 + aPlan.iIndex=aIndex;
1.557 + return ETrue;
1.558 + }
1.559 +
1.560 +void RDbAccessPlan::EvaluatePlansL()
1.561 +//
1.562 +// try to find a bounded or index iterator
1.563 +//
1.564 + {
1.565 + TPlan plan;
1.566 + // initialise flags
1.567 + if (iQuery->HasSearchCondition())
1.568 + plan.iFlags|=TPlan::ERestrict;
1.569 + if (iQuery->HasSortSpecification())
1.570 + plan.iFlags|=TPlan::EOrder;
1.571 + // find the right type of iterator
1.572 + TSglQueIterC<CDbTableIndexDef> indexes(iTable->Def().Indexes().AsQue());
1.573 + for (const CDbTableIndexDef* index;(index=indexes++)!=0;)
1.574 + { // only on first column
1.575 + TPlan newPlan=plan;
1.576 + TBool foundIter=IsBoundedIteratorL(newPlan,index);
1.577 + if (!foundIter)
1.578 + foundIter=IsIndexIteratorL(newPlan,index);
1.579 + else
1.580 + EvaluateReorderStage(newPlan,index);
1.581 + if (foundIter)
1.582 + {
1.583 + EvaluateWindowStage(newPlan);
1.584 + __LEAVE_IF_ERROR(iPlans.Append(newPlan));
1.585 + }
1.586 + }
1.587 + }
1.588 +
1.589 +void RDbAccessPlan::ChoosePlanL(TPlan& aPlan)
1.590 + {
1.591 + ReducePlans();
1.592 + if (iPlans.Count()==0)
1.593 + {
1.594 + CreateTableIteratorPlan(aPlan);
1.595 + return;
1.596 + }
1.597 + TPlan::TType type=iPlans[0].Type();
1.598 + if (!iQuery->HasSearchCondition())
1.599 + {
1.600 + __ASSERT(type==TPlan::EPlanEF);
1.601 + GetSmallestKeySize(aPlan,TPlan::EPlanEF);
1.602 + }
1.603 + else if (!iQuery->HasSortSpecification())
1.604 + {
1.605 + if (type==TPlan::EPlanIJ)
1.606 + {
1.607 + GetSmallestKeySize(aPlan,TPlan::EPlanIJ);
1.608 + TInt r=IndexSpanL(aPlan);
1.609 + if (r!=CDbTable::EUnavailableSpan && !iWindow && r>60)
1.610 + CreateTableIteratorPlan(aPlan);
1.611 + }
1.612 + else if (type==TPlan::EPlanOP)
1.613 + {
1.614 + TInt r=GetTightestRestrictionL(aPlan,TPlan::EPlanOP);
1.615 + if (r==CDbTable::EUnavailableSpan) // no index stats available
1.616 + aPlan=iPlans[0]; // use first O/P as a guess
1.617 + else if ((!iWindow && r>55) || (iWindow && r>60))
1.618 + CreateTableIteratorPlan(aPlan);
1.619 + }
1.620 + else
1.621 + __ASSERT(0);
1.622 + }
1.623 + else if (type==TPlan::EPlanMN)
1.624 + {
1.625 + GetSmallestKeySize(aPlan,TPlan::EPlanMN);
1.626 + if (iAccess==RDbRowSet::EUpdatable || iWindow)
1.627 + aPlan.iFlags|=TPlan::EWindow;
1.628 + }
1.629 + else if (type==TPlan::EPlanKL)
1.630 + {
1.631 + GetSmallestKeySize(aPlan,TPlan::EPlanKL);
1.632 + TInt r=IndexSpanL(aPlan);
1.633 + if (r!=CDbTable::EUnavailableSpan && r>60)
1.634 + { // don't use K plan
1.635 + if (r<75 || GetSmallestKeySize(aPlan,TPlan::EPlanGH)==KErrNotFound)
1.636 + CreateTableIteratorPlan(aPlan);
1.637 + }
1.638 + }
1.639 + else if (type==TPlan::EPlanQR)
1.640 + {
1.641 + TInt r=GetTightestRestrictionL(aPlan,TPlan::EPlanQR);
1.642 + if (r==CDbTable::EUnavailableSpan) // no index stats available
1.643 + aPlan=iPlans[0]; // use first Q/R as a guess
1.644 + else if (r>60)
1.645 + CreateTableIteratorPlan(aPlan);
1.646 + }
1.647 + else
1.648 + {
1.649 + __ASSERT(type==TPlan::EPlanGH);
1.650 + // don't use this plan without further data, resort to default
1.651 + CreateTableIteratorPlan(aPlan);
1.652 + }
1.653 + }
1.654 +
1.655 +void RDbAccessPlan::EvaluateWindowStage(TPlan& aPlan)
1.656 + {
1.657 + if (!iWindow)
1.658 + return;
1.659 + TUint f=aPlan.iFlags|TPlan::EWindow;
1.660 + if (f&TPlan::EReorder)
1.661 + f&=~TPlan::EWindow;
1.662 + if (f&TPlan::ERestrict)
1.663 + f|=TPlan::EWindow;
1.664 + if (f&TPlan::EOrder) // order-by stage includes window
1.665 + f&=~TPlan::EWindow;
1.666 + aPlan.iFlags=f;
1.667 + }
1.668 +
1.669 +TInt RDbAccessPlan::GetTightestRestrictionL(TPlan& aPlan,TPlan::TType aType)
1.670 +//
1.671 +// aPlan is set to the smallest restricted plan with aType
1.672 +//
1.673 + {
1.674 + TInt span=KMaxTInt;
1.675 + TPlan plan;
1.676 + for (TInt ii=iPlans.Count();ii--;)
1.677 + {
1.678 + if (iPlans[ii].Type()!=aType)
1.679 + continue;
1.680 + TInt t=IndexSpanL(iPlans[ii]);
1.681 + if (t==CDbTable::EUnavailableSpan)
1.682 + continue;
1.683 + __ASSERT(t == span ? (iPlans[ii].iIndex != NULL && plan.iIndex != NULL) : ETrue);
1.684 + //coverity[uninit_use_in_call]
1.685 + if (t<span || (t==span && iPlans[ii].iIndex->Key().Count()<plan.iIndex->Key().Count()))
1.686 + {
1.687 + span=t;
1.688 + plan=iPlans[ii];
1.689 + }
1.690 + }
1.691 + aPlan=plan;
1.692 + return span!=KMaxTInt?span:CDbTable::EUnavailableSpan;
1.693 + }
1.694 +
1.695 +TInt RDbAccessPlan::GetSmallestKeySize(TPlan& aPlan,TPlan::TType aType)
1.696 +//
1.697 +// aPlan is set to the plan with smallest index with aType
1.698 +//
1.699 + {
1.700 + TInt cols=KMaxTInt;
1.701 + TPlan plan;
1.702 + for (TInt ii=iPlans.Count();ii--;)
1.703 + {
1.704 + if (iPlans[ii].Type()!=aType)
1.705 + continue;
1.706 + __ASSERT(iPlans[ii].iIndex);
1.707 + TInt count=iPlans[ii].iIndex->Key().Count();
1.708 + if (count<cols)
1.709 + {
1.710 + cols=count;
1.711 + plan=iPlans[ii];
1.712 + }
1.713 + }
1.714 + aPlan=plan;
1.715 + return cols!=KMaxTInt?cols:KErrNotFound;
1.716 + }
1.717 +
1.718 +TInt RDbAccessPlan::IndexSpanL(const TPlan& aPlan)
1.719 + {
1.720 + __ASSERT(aPlan.iIndex);
1.721 + TBounds bounds(aPlan);
1.722 + return iTable->IndexSpanL(*aPlan.iIndex,bounds.iInclusion,bounds.iLower,bounds.iUpper);
1.723 + }
1.724 +
1.725 +void RDbAccessPlan::ReducePlans()
1.726 + {
1.727 + for (TInt ii=iPlans.Count();--ii>=0;)
1.728 + {
1.729 + switch (iPlans[ii].Type())
1.730 + {
1.731 + default:
1.732 + continue;
1.733 + case TPlan::EPlanGH:
1.734 + if (iWindow)
1.735 + iPlans.Remove(ii); // remove Gw/Hw
1.736 + break;
1.737 + case TPlan::EPlanST:
1.738 + iPlans[ii].iFlags|=(TPlan::EReorder|TPlan::EOrder); // convert S/T to Q/R
1.739 + EvaluateWindowStage(iPlans[ii]);
1.740 + break;
1.741 + };
1.742 + }
1.743 +// explicit conversion required as GCC can't find the TLinearOrder instantiation
1.744 + iPlans.Sort(TLinearOrder<TPlan>(TPlan::OrderByPlan));
1.745 + }
1.746 +
1.747 +void RDbAccessPlan::CreateTableIteratorPlan(TPlan& aPlan)
1.748 + {
1.749 + aPlan.iFlags&=~(TPlan::EIndex|TPlan::EBounded);
1.750 + if (iQuery->HasSearchCondition())
1.751 + aPlan.iFlags=TPlan::ERestrict;
1.752 + if (iQuery->HasSortSpecification())
1.753 + aPlan.iFlags|=TPlan::EOrder;
1.754 + EvaluateWindowStage(aPlan);
1.755 + }
1.756 +
1.757 +void RDbAccessPlan::EvaluateReorderStage(TPlan& aPlan,const CDbTableIndexDef* aIndex)
1.758 +//
1.759 +// for a bounded iter with an order by - can the index be used?
1.760 +//
1.761 + {
1.762 + aPlan.iFlags|=TPlan::EReorder;
1.763 + if (!iQuery->HasSortSpecification())
1.764 + return;
1.765 + TUint ret=0;
1.766 + TRAPD(errCode, ret=FindMatchL(aIndex));
1.767 + if (errCode==KErrNone && ret&EMatch)
1.768 + {// do we really need a reorder stage?
1.769 + aPlan.iFlags&=~TPlan::EOrder; // don't need to order it
1.770 + aPlan.iFlags&=~TPlan::EReorder; // don't need a reorder stage
1.771 + if (ret&EReverse)
1.772 + aPlan.iFlags|=TPlan::EReverse;
1.773 + else
1.774 + aPlan.iFlags&=~TPlan::EReverse;
1.775 + }
1.776 + }
1.777 +
1.778 +void RDbAccessPlan::PrepareQueryL(CDbTableSource* aSource)
1.779 + {
1.780 + if (iQuery->HasSearchCondition())
1.781 + {
1.782 + CSqlSearchCondition& sc=iQuery->SearchCondition();
1.783 + sc.BindL(aSource->Row());
1.784 + }
1.785 + if (iQuery->HasSortSpecification())
1.786 + {
1.787 + CDbKey& order=iQuery->SortSpecification();
1.788 + order.SetComparison(iComparison);
1.789 + Validate::KeyL(order,iTable->Def().Columns());
1.790 + }
1.791 + }
1.792 +
1.793 +
1.794 +void RDbAccessPlan::BuildLC(CDbTableDatabase& aDatabase,RDbRowSet::TAccess aAccess,const TDbWindow& aWindow)
1.795 +//
1.796 +// Prepare the data pipeline
1.797 +//
1.798 + {
1.799 + __ASSERT(iQuery);
1.800 + CDbTableSource* source=TableLC(aDatabase,iQuery->Table());
1.801 + //
1.802 + if (aAccess!=RDbRowSet::EInsertOnly)
1.803 + { // insert only views do not use Iterators, Restrictions or Windows
1.804 + iWindow=aWindow.Size()==aWindow.EUnlimited;
1.805 + iAccess=aAccess;
1.806 + PrepareQueryL(source);
1.807 + EvaluatePlansL();
1.808 + TPlan plan;
1.809 + ChoosePlanL(plan);
1.810 + source->SetIterator(IteratorL(plan));
1.811 + if (plan.iFlags&TPlan::EReorder)
1.812 + Insert(new(ELeave) CDbReorderWindowStage);
1.813 + if (plan.iFlags&TPlan::EReverse)
1.814 + source->ReverseIteratorL();
1.815 + if (plan.iFlags&TPlan::ERestrict)
1.816 + RestrictionL();
1.817 + if (plan.iFlags&TPlan::EOrder)
1.818 + OrderByL(source->Row());
1.819 + WindowL(plan,aWindow);
1.820 + iPlans.Reset();
1.821 + }
1.822 + if (iQuery->HasColumnList())
1.823 + ProjectionL();
1.824 + }
1.825 +
1.826 +void RDbAccessPlan::BuildLC(CDbTableDatabase& aDatabase,const TDesC& aTable,RDbRowSet::TAccess aAccess)
1.827 + {
1.828 + CDbTableSource* source=TableLC(aDatabase,aTable);
1.829 + if (aAccess!=RDbRowSet::EInsertOnly)
1.830 + source->SetIterator(iTable->IteratorL());
1.831 + }