|
1 // Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies). |
|
2 // All rights reserved. |
|
3 // This component and the accompanying materials are made available |
|
4 // under the terms of "Eclipse Public License v1.0" |
|
5 // which accompanies this distribution, and is available |
|
6 // at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
7 // |
|
8 // Initial Contributors: |
|
9 // Nokia Corporation - initial contribution. |
|
10 // |
|
11 // Contributors: |
|
12 // |
|
13 // Description: |
|
14 // |
|
15 |
|
16 #include "UT_STD.H" |
|
17 |
|
18 // Class CDbTableIndexDef |
|
19 |
|
20 EXPORT_C CDbTableIndexDef::CDbTableIndexDef() |
|
21 {} |
|
22 |
|
23 EXPORT_C CDbTableIndexDef::~CDbTableIndexDef() |
|
24 { |
|
25 delete iName; |
|
26 } |
|
27 |
|
28 EXPORT_C void CDbTableIndexDef::ConstructL(const TDesC& aName) |
|
29 // |
|
30 // Construct with an empty key |
|
31 // |
|
32 { |
|
33 iName=aName.AllocL(); |
|
34 } |
|
35 |
|
36 // Class RDbIndexes |
|
37 |
|
38 void RDbIndexes::Close() |
|
39 { |
|
40 TSglQueIter<CDbTableIndexDef> iter(iRep); |
|
41 for (CDbTableIndexDef* def;(def=iter++)!=0;) |
|
42 delete def; |
|
43 } |
|
44 |
|
45 CDbTableIndexDef* RDbIndexes::Find(const TDesC& aName) const |
|
46 // |
|
47 // Locate and index on the table by name |
|
48 // |
|
49 { |
|
50 TSglQueIter<CDbTableIndexDef> iter(CONST_CAST(TSglQue<CDbTableIndexDef>&,iRep)); |
|
51 for (CDbTableIndexDef* def;(def=iter++)!=0;) |
|
52 if (aName.CompareF(def->Name())==0) |
|
53 return def; |
|
54 return 0; |
|
55 } |
|
56 |
|
57 CDbTableIndexDef& RDbIndexes::FindL(const TDesC& aName) const |
|
58 // |
|
59 // Leave if not found |
|
60 // |
|
61 { |
|
62 CDbTableIndexDef* def=Find(aName); |
|
63 if (def==NULL) |
|
64 __LEAVE(KErrNotFound); |
|
65 return *def; |
|
66 } |
|
67 |
|
68 EXPORT_C TInt RDbIndexes::Count() const |
|
69 { |
|
70 TInt count = 0; |
|
71 TSglQueIterC<CDbTableIndexDef> iter( iRep ); |
|
72 for ( ; iter++ != 0; ) |
|
73 ++count; |
|
74 return count; |
|
75 } |
|
76 |
|
77 // Class TDbColumnDef |
|
78 |
|
79 EXPORT_C void TDbColumnDef::SetL(const TDbColumnDef& aCol) |
|
80 // |
|
81 // Replace assignment as this can leave |
|
82 // |
|
83 { |
|
84 iMaxLength=aCol.iMaxLength; |
|
85 iType=aCol.iType; |
|
86 iAttributes=aCol.iAttributes; |
|
87 iFlags=aCol.iFlags; |
|
88 iName=aCol.iName->AllocL(); |
|
89 } |
|
90 |
|
91 EXPORT_C void TDbColumnDef::SetL(const TDbCol& aCol) |
|
92 { |
|
93 iMaxLength=aCol.iMaxLength; |
|
94 iType=TUint8(aCol.iType); |
|
95 iAttributes=TUint8(aCol.iAttributes); |
|
96 iName=aCol.iName.AllocL(); |
|
97 } |
|
98 |
|
99 void TDbColumnDef::AsTDbCol(TDbCol& aColumn) const |
|
100 { |
|
101 aColumn.iType=Type(); |
|
102 aColumn.iMaxLength=iMaxLength; |
|
103 aColumn.iAttributes=iAttributes; |
|
104 aColumn.iName=*iName; |
|
105 } |
|
106 |
|
107 // Class HDbColumnSet |
|
108 |
|
109 HDbColumnSet* HDbColumnSet::NewL(TInt aCount) |
|
110 { |
|
111 return new(User::AllocL(_FOFF(HDbColumnSet,iColumns[aCount]))) HDbColumnSet(aCount); |
|
112 } |
|
113 |
|
114 HDbColumnSet::HDbColumnSet(TInt aCount) |
|
115 : iAttributes(0), iIndex(NULL), iEnd(&iColumns[aCount]) |
|
116 { |
|
117 Mem::FillZ(&iColumns[0],aCount*sizeof(iColumns[0])); |
|
118 } |
|
119 |
|
120 HDbColumnSet::~HDbColumnSet() |
|
121 { |
|
122 User::Free(iIndex); |
|
123 const TIteratorC end=End(); |
|
124 for (TIteratorC iter=Begin();iter<end;++iter) |
|
125 delete iter->iName; |
|
126 } |
|
127 |
|
128 EXPORT_C TInt HDbColumnSet::Count() const |
|
129 { |
|
130 return End()-Begin(); |
|
131 } |
|
132 |
|
133 void HDbColumnSet::Complete() |
|
134 // |
|
135 // Called on completion of the column set |
|
136 // |
|
137 { |
|
138 TUint attrib=0; |
|
139 const TIteratorC end=End(); |
|
140 for (TIteratorC iter=Begin();iter<end;++iter) |
|
141 { |
|
142 if (TDbCol::IsLong(iter->Type())) |
|
143 attrib|=ELongColumns; |
|
144 if (iter->iAttributes&TDbCol::EAutoIncrement) |
|
145 attrib|=EAutoIncrement; |
|
146 } |
|
147 iAttributes=attrib; |
|
148 } |
|
149 |
|
150 EXPORT_C HDbColumnSet::TIteratorC HDbColumnSet::ColumnL(const TDesC& aColumn) const |
|
151 // |
|
152 // Lookup name in the name index (binary search) |
|
153 // |
|
154 { |
|
155 const TIteratorC* index=IndexL(); |
|
156 TInt left=0; |
|
157 TInt right=Count(); |
|
158 while (left<right) |
|
159 { |
|
160 TInt mid=(left+right)>>1; |
|
161 TInt c=index[mid]->iName->CompareF(aColumn); |
|
162 if (c<0) |
|
163 left=mid+1; |
|
164 else if (c>0) |
|
165 right=mid; |
|
166 else |
|
167 return index[mid]; // matched entry |
|
168 } |
|
169 return 0; // no match |
|
170 } |
|
171 |
|
172 EXPORT_C TDbColNo HDbColumnSet::ColNoL(const TDesC& aColumn) const |
|
173 // |
|
174 // Return ordinal for given column name |
|
175 // |
|
176 { |
|
177 TIteratorC col=ColumnL(aColumn); |
|
178 return col ? 1+(col-Begin()) : KDbNullColNo; |
|
179 } |
|
180 |
|
181 const HDbColumnSet::TIteratorC* HDbColumnSet::IndexL() const |
|
182 // |
|
183 // Return the by-name lookup index, building it if required |
|
184 // |
|
185 { |
|
186 TIteratorC* index=iIndex; |
|
187 if (!index) |
|
188 { |
|
189 CONST_CAST(TIteratorC*&,iIndex)=index=(TIteratorC*)User::AllocL(Count()*sizeof(TIteratorC)); |
|
190 TInt ii=0; |
|
191 TIteratorC col=Begin(); |
|
192 TIteratorC end=End(); |
|
193 do |
|
194 { |
|
195 // binary search for insertion point |
|
196 TInt left=0; |
|
197 TInt right=ii; |
|
198 while (left<right) |
|
199 { |
|
200 TInt mid=(left+right)>>1; |
|
201 TInt c=index[mid]->iName->CompareF(*col->iName); |
|
202 __ASSERT(c!=0); // names are unique |
|
203 if (c<0) |
|
204 left=mid+1; |
|
205 else |
|
206 right=mid; |
|
207 } |
|
208 // insert the entry |
|
209 Mem::Move(index+left+1,index+left,(ii-left)*sizeof(TIteratorC)); |
|
210 index[left]=col; |
|
211 } while (++ii,++col<end); |
|
212 } |
|
213 return index; |
|
214 } |
|
215 |
|
216 // Class CDbTableDef |
|
217 |
|
218 EXPORT_C CDbTableDef::CDbTableDef() |
|
219 {} |
|
220 |
|
221 EXPORT_C CDbTableDef::~CDbTableDef() |
|
222 { |
|
223 delete iColumns; |
|
224 delete iName; |
|
225 iIndexes.Close(); |
|
226 } |
|
227 |
|
228 EXPORT_C void CDbTableDef::ConstructL(const TDesC& aName,TInt aColumnCount) |
|
229 { |
|
230 iName=aName.AllocL(); |
|
231 iColumns=HDbColumnSet::NewL(aColumnCount); |
|
232 } |
|
233 |
|
234 void CDbTableDef::ExchangeColumnSet(HDbColumnSet* aSet) |
|
235 { |
|
236 delete iColumns; |
|
237 iColumns=aSet; |
|
238 Changed(); |
|
239 } |
|
240 |
|
241 EXPORT_C void CDbTableDef::Changed() |
|
242 // |
|
243 // evaluate cached info about the set |
|
244 // |
|
245 { |
|
246 iColumns->Complete(); |
|
247 } |
|
248 |
|
249 const CDbTableIndexDef* CDbTableDef::FindKey(const TDesC& aColumn,TBool aFirstColumn) const |
|
250 // |
|
251 // Find an index which keys on the given column |
|
252 // |
|
253 { |
|
254 TSglQueIterC<CDbTableIndexDef> indexes(Indexes().AsQue()); |
|
255 for (const CDbTableIndexDef* def;(def=indexes++)!=0;) |
|
256 { |
|
257 const CDbKey& key=def->Key(); |
|
258 TInt ii=0; |
|
259 do |
|
260 { |
|
261 if (aColumn.CompareF(key[ii].iName)==0) |
|
262 return def; |
|
263 if (aFirstColumn) |
|
264 break; |
|
265 } while (++ii<key.Count()); |
|
266 } |
|
267 return 0; |
|
268 } |
|
269 |
|
270 // Class RDbTableSchema |
|
271 |
|
272 void RDbTableSchema::Discard() |
|
273 { |
|
274 TSglQueIter<CDbTableDef> iter(iRep); |
|
275 for (CDbTableDef* def;(def=iter++)!=0;) |
|
276 delete def; |
|
277 iRep.Reset(); |
|
278 iLoaded=EFalse; |
|
279 } |
|
280 |
|
281 CDbTableDef* RDbTableSchema::Find(const TDesC& aTable) |
|
282 { |
|
283 __ASSERT(IsLoaded()); |
|
284 TSglQueIter<CDbTableDef> iter(iRep); |
|
285 for (CDbTableDef* def;(def=iter++)!=0;) |
|
286 if (aTable.CompareF(def->Name())==0) |
|
287 return def; |
|
288 return 0; |
|
289 } |
|
290 |
|
291 CDbTableDef& RDbTableSchema::FindL(const TDesC& aTable) |
|
292 // |
|
293 // Leave if not found |
|
294 // |
|
295 { |
|
296 CDbTableDef* def=Find(aTable); |
|
297 if (def==NULL) |
|
298 __LEAVE(KErrNotFound); |
|
299 return *def; |
|
300 } |
|
301 |
|
302 // Class RDbTables |
|
303 |
|
304 void RDbTables::Close() |
|
305 { |
|
306 TSglQueIter<CDbTable> iter(iRep); |
|
307 for (CDbTable* table;(table=iter++)!=0;) |
|
308 table->Discard(); |
|
309 } |
|
310 |
|
311 CDbTable* RDbTables::Find(const TDesC& aTable) |
|
312 { |
|
313 TSglQueIter<CDbTable> iter(iRep); |
|
314 for (CDbTable* table;(table=iter++)!=0;) |
|
315 if (aTable.CompareF(table->Def().Name())==0) |
|
316 return table; |
|
317 return 0; |
|
318 } |