// write rows equivalent to TypeText and use its tests
void TestPredicate2::RunL()
{
Create(TypeLongText::KType);
TBuf<1022> fill=_S("abcdefghijklmnopqrstuvqxyz");
fill.AppendFill('.',fill.MaxLength()-fill.Length());
for (TInt row=0;row<=TInt(elementsof(TypeText::KValues));++row)
{
TheTable.InsertL();
TheTable.SetColL(1,row);
if (row>0)
{
RDbColWriteStream blob;
blob.OpenLC(TheTable,2);
switch (row)
{
case 0:
break;
case 1: case 2: case 3: case 4: case 5: case 10: case 11:
blob.WriteL(TPtrC(TypeText::KValues[row-1]));
break;
case 6:
blob.WriteL(fill);
blob.WriteL(_L("like"));
break;
case 7:
blob.WriteL(_L("like"));
blob.WriteL(fill);
break;
case 8:
blob.WriteL(fill);
blob.WriteL(_L("like"));
blob.WriteL(fill);
break;
case 9:
blob.WriteL(fill);
blob.WriteL(_L("live"));
blob.WriteL(fill);
break;
}
blob.CommitL();
CleanupStack::PopAndDestroy();
}
TheTable.PutL();
}
TheTable.Close();
TInt r=TheDatabase.Commit();
TEST2(r, KErrNone);
TestViewL(TypeText::KTests,elementsof(TypeText::KTests),elementsof(TypeText::KValues));
CDbKey& key=*CDbKey::NewLC();
key.AddL(TDbKeyCol(_L("Test"),120));
r=TheDatabase.CreateIndex(_L("Key"),_L("Compare"),key);
TEST2(r, KErrNone);
CleanupStack::PopAndDestroy();
TestViewL(TypeText::KTests,elementsof(TypeText::KTests),elementsof(TypeText::KValues));
r=TheDatabase.Execute(_L("DROP TABLE Compare"));
TEST2(r, KErrNone);
}
void CLogServDatabaseMarshall::CreateIndiciesL()
{
// Get the array size
TResourceReader reader;
iResourceInterface.CreateResourceReaderLC(reader, R_LOG_INDEXES);
const TInt indexes = reader.ReadInt16();
// Read in the array
for(TInt c1 = 0; c1 < indexes; c1++)
{
const TPtrC name(reader.ReadTPtrC());
const TPtrC table(reader.ReadTPtrC());
// Get the number of keys
const TInt keys = reader.ReadInt16();
CDbKey* key = CDbKey::NewLC();
for(TInt c2 = 0; c2 < keys; c2++)
{
TPtrC col = reader.ReadTPtrC();
TUint order = reader.ReadUint16();
TInt len = reader.ReadInt16();
// Add the key
key->AddL(TDbKeyCol(col, len, (TDbKeyCol::TOrder)order));
}
// Make key unique if required
if (reader.ReadInt8())
key->MakeUnique();
// Set comparison
const TDbTextComparison comparison = static_cast<TDbTextComparison>(reader.ReadInt8());
key->SetComparison(comparison);
// Create the index
User::LeaveIfError(iDatabase.CreateIndex(name, table, *key));
CleanupStack::PopAndDestroy(key);
}
CleanupStack::PopAndDestroy(); // reader
}
// ---------------------------------------------------------
// RFavouritesSrvTable::CreateStructureL
// ---------------------------------------------------------
//
void RFavouritesSrvTable::CreateStructureL( RDbNamedDatabase& aDb )
{
// Create columns.
CDbColSet* colset = CDbColSet::NewLC();
TDbCol col( KFavouritesDbUidColName, EDbColInt32 );
col.iAttributes = TDbCol::EAutoIncrement;
colset->AddL( col );
colset->AddL( TDbCol( KFavouritesDbParentColName, EDbColInt32 ) );
colset->AddL( TDbCol( KFavouritesDbTypeColName, EDbColInt32 ) );
colset->AddL( TDbCol
( KFavouritesDbNameColName, EDbColText, KFavouritesMaxName ) );
colset->AddL( TDbCol
( KFavouritesDbUrlColName, EDbColLongText, KFavouritesMaxUrl ) );
colset->AddL( TDbCol( KFavouritesDbApIdColName, EDbColUint32 ) );
colset->AddL( TDbCol( KFavouritesDbApValueKindColName, EDbColInt32 ) );
colset->AddL( TDbCol
( KFavouritesDbUserNameColName, EDbColText, KFavouritesMaxUserName ) );
colset->AddL( TDbCol
( KFavouritesDbPasswordColName, EDbColText, KFavouritesMaxPassword ) );
colset->AddL( TDbCol( KFavouritesDbExtraDataColName, EDbColLongBinary ) );
colset->AddL( TDbCol( KFavouritesDbFactoryItemColName, EDbColBit ) );
colset->AddL( TDbCol( KFavouritesDbReadOnlyColName, EDbColBit ) );
colset->AddL( TDbCol( KFavouritesDbContextIdColName, EDbColInt32 ) );
colset->AddL( TDbCol( KFavouritesDbModifiedColName, EDbColDateTime ) );
colset->AddL( TDbCol( KFavouritesDbPrefUidColName, EDbColInt32 ) );
colset->AddL
( TDbCol( KFavouritesDbBrowserDataColName, EDbColLongBinary ) );
colset->AddL( TDbCol( KFavouritesDbHiddenColName, EDbColBit ) );
User::LeaveIfError
( aDb.CreateTable( KFavouritesTableName, *colset ) );
CleanupStack::PopAndDestroy(); // colset
// Create index by uid.
CDbKey* key = CDbKey::NewLC();
// Create key on Uid column, ascending order.
key->AddL( TDbKeyCol ( KFavouritesDbUidColName ) );
User::LeaveIfError( aDb.CreateIndex
( KFavouritesDbUidIdxName, KFavouritesTableName, *key ) );
CleanupStack::PopAndDestroy(); // key
}
void bases::InnerConstructL(bool aConvertOnly, CCellMap* aCellMap)
{
CALLSTACKITEM_N(_CL("bases"), _CL("ConstructL"));
iConvertOnly=aConvertOnly;
if (!aConvertOnly) {
Mlogger::ConstructL(AppContextAccess());
Mlog_base_impl::ConstructL();
iBBSubSessionNotif->AddNotificationL(KCellIdTuple, ETrue);
iEvent.iData.SetValue(&iLocation); iEvent.iData.SetOwnsValue(EFalse);
cell_hash=CGenericIntMap::NewL();
// initial values
learning_done=false;
first_time=GetTime();
previous_time=previous_day=first_time;
scale=1.0;
}
TInt dbver=0;
MoveIntoDataDirL(AppContext(), database_file);
TFileName database_filename_install, database_filename;
database_filename_install.Format(_L("%S%S"), &AppDir(), &database_file_install);
database_filename.Format(_L("%S%S"), &DataDir(), &database_file);
if (BaflUtils::FileExists(Fs(), database_filename_install)) {
User::LeaveIfError(BaflUtils::CopyFile(Fs(), database_filename_install, database_filename));
User::LeaveIfError(BaflUtils::DeleteFile(Fs(), database_filename_install));
Settings().WriteSettingL(SETTING_BASEDB_VERSION, LATEST_DBVER);
learning_done=true;
}
dbver=LATEST_DBVER;
Settings().GetSettingL(SETTING_BASEDB_VERSION, dbver);
auto_ptr<CDbColSet> cols(CDbColSet::NewL());
TInt colno=1;
cols->AddL(TDbCol(col_id, EDbColUint32)); colno_id=colno++;
cols->AddL(TDbCol(col_t, EDbColReal64) ); colno_t=colno++;
cols->AddL(TDbCol(col_f, EDbColUint32) ); colno_f=colno++;
cols->AddL(TDbCol(col_isbase, EDbColBit) ); colno_isbase=colno++;
cols->AddL(TDbCol(col_last_seen, EDbColDateTime) ); colno_last_seen=colno++;
cols->AddL(TDbCol(col_iscurrent, EDbColBit) ); colno_iscurrent=colno++;
TInt store_exists;
CC_TRAP(store_exists, store = CPermanentFileStore::OpenL(Fs(), database_filename, EFileRead|EFileWrite));
if (store_exists!=KErrNone) {
dbver=LATEST_DBVER;
Settings().WriteSettingL(SETTING_BASEDB_VERSION, LATEST_DBVER);
}
if (dbver<2) {
cols->AddL(TDbCol(col_cellid, EDbColText)); colno_cellid=colno++;
}
cols->AddL(TDbCol(col_merged_to, EDbColUint32)); colno_merged_to=colno++;
cols->AddL(TDbCol(col_unaged_t, EDbColReal64) ); colno_unaged_t=colno++;
cols->AddL(TDbCol(col_rescaled, EDbColUint32) ); colno_rescaled=colno++;
if (store_exists==KErrNone) {
db.OpenL(store, store->Root());
User::LeaveIfError(db.Recover());
db_open=true;
RDebug::Print(_L("converting database..."));
User::LeaveIfError(db.AlterTable(table_cells, *cols));
RDebug::Print(_L("converting database done."));
User::LeaveIfError(table.Open(db, table_cells));
table_open=true;
// read cells in order
read_from_database(aConvertOnly, aCellMap);
} else {
if (aConvertOnly) return;
// construct database
store = CPermanentFileStore::ReplaceL(Fs(), database_filename, EFileRead|EFileWrite);
store->SetTypeL(store->Layout());
TStreamId id=db.CreateL(store);
db_open=true;
store->SetRootL(id);
store->CommitL();
User::LeaveIfError(db.CreateTable(table_cells, *cols));
auto_ptr<CDbKey> idx_key(CDbKey::NewL());
idx_key->AddL(TDbKeyCol(col_id));
idx_key->MakeUnique();
User::LeaveIfError(db.CreateIndex(idx_id, table_cells, *idx_key));
idx_key->Clear();
idx_key->AddL(TDbKeyCol(col_t));
User::LeaveIfError(db.CreateIndex(idx_t, table_cells, *idx_key));
User::LeaveIfError(table.Open(db, table_cells));
table_open=true;
User::LeaveIfError(table.SetIndex(idx_id));
Settings().WriteSettingL(SETTING_BASEDB_VERSION, LATEST_DBVER);
}
if (aConvertOnly) return;
if (! bases_info) {
bases_info=new (ELeave) cell_list_node(0, first_time);
bases_info->id=0;
bases_info->t=scale;
bases_info->merged_to=0;
bases_info->last_seen=first_time;
update_database(bases_info, false);
}
iGraph=CDirectedGraph::NewL(db, _L("GRAPH"));
iMerged=CMerged::NewL(db, _L("MERGE"));
iCandidates=CList<TCandidate>::NewL();
iTimer=CTimeOut::NewL(*this);
iTimer->Wait(CELL_REFRESH);
}
