metadataengine/server/src/mdssqldbmaintenance.cpp
branchRCL_3
changeset 19 b73252188534
parent 0 c53acadfccc6
child 20 f23c07ec56e2
equal deleted inserted replaced
18:63c982fb92f2 19:b73252188534
    48     {
    48     {
    49     }
    49     }
    50 
    50 
    51 TBool CMdSSqlDbMaintenance::ValidateL(  )
    51 TBool CMdSSqlDbMaintenance::ValidateL(  )
    52     {
    52     {
       
    53     //validate content of critical tables
    53     _LIT( KValidateTableExistence, "SELECT COUNT(*) FROM MdE_Preferences;" );
    54     _LIT( KValidateTableExistence, "SELECT COUNT(*) FROM MdE_Preferences;" );
    54 
    55     _LIT( KValidateObjectDef, "SELECT COUNT(*) FROM ObjectDef;" );
       
    56     _LIT( KValidatePropertyDef, "SELECT COUNT(*) FROM PropertyDef;" );
       
    57     _LIT( KValidateRelationDef, "SELECT COUNT(*) FROM RelationDef;" );
       
    58     _LIT( KValidateCol2Prop, "SELECT COUNT(*) FROM Col2Prop;" );
       
    59 
       
    60     TInt test(KErrNone);
       
    61     TUint32 count(0);
       
    62     
       
    63     RRowData emptyRowData;
       
    64     CleanupClosePushL( emptyRowData );
       
    65         
    55     RMdsStatement validationQuery;
    66     RMdsStatement validationQuery;
    56     CleanupClosePushL( validationQuery );
    67     CleanupClosePushL( validationQuery );
    57     RRowData emptyRowData;
    68     
    58     CleanupClosePushL( emptyRowData );
       
    59     CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();
    69     CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();
    60 	TRAPD( test, connection.ExecuteQueryL( KValidateTableExistence, validationQuery, emptyRowData ) );
    70     
    61 	CleanupStack::PopAndDestroy( 2, &validationQuery );
    71 	TRAP( test, connection.ExecuteQueryL( KValidateTableExistence, validationQuery, emptyRowData ) );
       
    72 	if(test == KErrNone)
       
    73         {
       
    74         emptyRowData.AppendL( TColumn( count ) );
       
    75         TRAP( test, connection.NextRowL(validationQuery, emptyRowData));
       
    76         if(test == KErrNone)
       
    77             {
       
    78             emptyRowData.Column(0).Get( count );
       
    79                     
       
    80             if(count <= 0)
       
    81                 {
       
    82                 test = KErrCorrupt;
       
    83                 }
       
    84             }
       
    85         }
       
    86 	
       
    87 	CleanupStack::PopAndDestroy( &validationQuery );
       
    88 	emptyRowData.Reset();
       
    89 	
       
    90 	RMdsStatement objectDefQuery;
       
    91 	CleanupClosePushL( objectDefQuery );
       
    92 	
       
    93 	if( test == KErrNone )
       
    94         {
       
    95         TRAP( test, connection.ExecuteQueryL( KValidateObjectDef, objectDefQuery, emptyRowData ) );
       
    96         
       
    97         if(test == KErrNone)
       
    98             {
       
    99             emptyRowData.AppendL( TColumn( count ) );
       
   100             TRAP( test, connection.NextRowL(objectDefQuery, emptyRowData));
       
   101             if(test == KErrNone)
       
   102                 {
       
   103                 emptyRowData.Column(0).Get( count );
       
   104                         
       
   105                 if(count <= 0)
       
   106                     {
       
   107                     test = KErrCorrupt;
       
   108                     }
       
   109                 }
       
   110             }
       
   111         }
       
   112     
       
   113 	CleanupStack::PopAndDestroy( &objectDefQuery );
       
   114 	emptyRowData.Reset();
       
   115 	
       
   116 	RMdsStatement propertyDefQuery;
       
   117 	CleanupClosePushL( propertyDefQuery );
       
   118 
       
   119 	if( test == KErrNone )
       
   120 	    {
       
   121         TRAP( test, connection.ExecuteQueryL( KValidatePropertyDef, propertyDefQuery, emptyRowData ) );
       
   122         if(test == KErrNone)
       
   123             {
       
   124             emptyRowData.AppendL( TColumn( count ) );
       
   125             TRAP( test, connection.NextRowL(propertyDefQuery, emptyRowData));
       
   126             if(test == KErrNone)
       
   127                 {
       
   128                 emptyRowData.Column(0).Get( count );
       
   129                 
       
   130                 if(count <= 0)
       
   131                     {
       
   132                     test = KErrCorrupt;
       
   133                     }
       
   134                 }
       
   135             }
       
   136 	    }
       
   137 	
       
   138 	CleanupStack::PopAndDestroy( &propertyDefQuery );
       
   139 	emptyRowData.Reset();
       
   140 	
       
   141     RMdsStatement relationDefQuery;
       
   142     CleanupClosePushL( relationDefQuery );
       
   143 	
       
   144 	if( test == KErrNone )
       
   145 	    {
       
   146 	    TRAP( test, connection.ExecuteQueryL( KValidateRelationDef, relationDefQuery, emptyRowData ) );
       
   147 	    if(test == KErrNone)
       
   148 	        {
       
   149             emptyRowData.AppendL( TColumn( count ) );
       
   150             TRAP( test, connection.NextRowL(relationDefQuery, emptyRowData));
       
   151             
       
   152             if(test == KErrNone)
       
   153                 {
       
   154                 emptyRowData.Column(0).Get( count );
       
   155                 
       
   156                 if(count <= 0)
       
   157                     {
       
   158                     test = KErrCorrupt;
       
   159                     }
       
   160                 }
       
   161             }
       
   162 	    }
       
   163 	
       
   164 	CleanupStack::PopAndDestroy( &relationDefQuery );
       
   165 	emptyRowData.Reset();
       
   166     
       
   167     RMdsStatement col2propQuery;
       
   168     CleanupClosePushL( col2propQuery );
       
   169     
       
   170     if( test == KErrNone )
       
   171         {
       
   172         TRAP( test, connection.ExecuteQueryL( KValidateCol2Prop, col2propQuery, emptyRowData ) );
       
   173         if(test == KErrNone)
       
   174             {
       
   175             emptyRowData.AppendL( TColumn( count ) );
       
   176             TRAP( test, connection.NextRowL(col2propQuery, emptyRowData));
       
   177             
       
   178             if(test == KErrNone)
       
   179                 {
       
   180                 emptyRowData.Column(0).Get( count );
       
   181                 
       
   182                 if(count <= 0)
       
   183                     
       
   184                     {
       
   185                     test = KErrCorrupt;
       
   186                     }
       
   187                 }
       
   188             }
       
   189           }
       
   190     CleanupStack::PopAndDestroy( &col2propQuery );
       
   191     emptyRowData.Reset();
       
   192      
       
   193     CleanupStack::PopAndDestroy( &emptyRowData );
       
   194     
       
   195     if(test == KErrCorrupt )
       
   196         {
       
   197         User::Leave( test );
       
   198         }
       
   199     
    62     return ( test == KErrNone );
   200     return ( test == KErrNone );
    63     }
   201     }
    64 
   202 
    65 
   203 
    66 void CMdSSqlDbMaintenance::CreateDatabaseL()
   204 void CMdSSqlDbMaintenance::CreateDatabaseL()