Backup metadata to recover. Since metadata will be changed while a table or an index is created or dropped, you should call this periodically.

Recover data from a corruped db. You’d better to recover a closed database. A new repair kit is developing at https://github.com/Tencent/wcdb/tree/new-repair

 WCTDatabase* database = [[WCTDatabase alloc] initWithPath:path];
 WCTDatabase* corruped = [[WCTDatabase alloc] initWithPath:corrupedDBPath];
 [corruped close:^(){
     BOOL result = [database recoverFromPath:corrupedDBPath withPageSize:4096 backupCipher:backupCipher databaseCipher:databaseCipher];
     NSLog(@"result %d", result);
 }];

Remove all database-related files.

Move all database-related files and some extra files to directory safely. You should call it on a closed database. Otherwise you will get a warning and you may get a corrupted database.

This interface is equivalent to [database moveFilesToDirectory:directory withExtraFiles:nil andError:error].

Paths to all database-related files.

Get the space used by the database files.

Setup tokenizer with name for current database

Setup multiple tokenizers with names for current database

Default config name. The default config for WCDB is : 1. PRAGMA locking_mode=NORMAL 2. PRAGMA synchronous=NORMAL 3. PRAGMA journal_mode=WAL 4. PRAGMA fullfsync=ON Setting config for this name will overwrite the default config.

Default cipher config name The default cipher config for WCDB is : 1. PRAGMA key=yourCipherKey 2. PRAGMA cipher_page_size=yourCipherPageSize. Default to 4096

Default trace config name. It’s off by default. Call [WCTStatistics SetGlobalPerformanceTrace:] to open it. The config for performance and sql tracing.

Default checkpoint config name The config for subthread checkpoint optimization

Default synchronous config name. It’s off by default. Call [WCTDatabase setSynchronousFull:] to open it. The default synchronous config for WCDB is : 1. PRAGMA synchronous=FULL

Default tokenize config name

Set config for this database.

This interface is equivalent to [database setConfig:config forName:name withOrder:INT_MAX];

Set Synchronous for this database. It will disable checkpoint opti to avoid performance degradation. Synchronous can improve the stability of the database and reduce database damage, but there will be performance degradation.

Create table and indexes from ORM if not exists. Note that it will add newly defined columns automatically. Note that it will run embedded transaction. The embedded transaction means that it will run a transaction if it’s not in other transaction, otherwise it will be executed within the existing transaction.

Get a wrapper from an existing table.

Create virtual table from ORM if not exists.

Create table from user-defined column if not exists.

This interface is equivalent to [database createTableOfName:tableName withColumnDefList:columnDefList andConstraintList:{}].

Check whether table exists

Drop table if exists.

Create table from user-defined index if not exists.

Drop index if not exists.

Add column.

Generation a WCTTransaction object to do a transaction.

Run a transaction in block.

 BOOL committed = [database runTransaction:^BOOL(){
    BOOL result = [database insertObject:object into:tableName];
    return result;//return YES to commit transaction and return NO to rollback transaction.
 } event:^(WCTTransactionEvent event) {
    switch (event) {
        case WCTTransactionEventBeginFailed:
            break;
        case WCTTransactionEventCommitFailed:
            break;
        case WCTTransactionEventRollback:
            break;
        case WCTTransactionEventRollbackFailed:
            break;
    };
 }];

This interface is equivalent to [database runTransaction:transaction event:nil];

Separate interface of runTransaction:

Separate interface of runTransaction:

Separate interface of runTransaction:

You can register a tracer to monitor the performance of all SQLs in this database. The database tracer will recover the global tracer for specifiy database.

Init a database from path. Note that all database objects with same path share the same core. So you can create multiple database objects. WCDB will manage them automatically. Note that WCDB will not generate a sqlite handle until the first operation, which is also called as lazy initialization.

Init a database from existing tag. Note that all database objects with same path share the same core. So you can create multiple database objects. WCDB will manage them automatically. Note that WCDB will not generate a sqlite handle until the first operation, which is also called as lazy initialization.

This interface is equivalent to [database setCipherKey:cipherKey andCipherPageSize:4096];

Set cipher key for a database. For an encrypted database, you must call it before all other operation. The cipher page size defaults to 4096 in WCDB, but it defaults to 1024 in other databases. So for an existing database created by other database framework, you should set it to 1024. Otherwise, you’d better to use cipher page size with 4096 or simply call setCipherKey: interface to get better performance.

Set the tag of the database. Note that WCTCore objects with same path share this tag, even they are not the same object.

Since WCDB is using lazy initialization, [initWithPath:] never return nil even the database can’t open. So you can call this to check whether the database can be opened.

Check database is already opened.

close the database. Since Multi-threaded operation is supported in WCDB, other operations in different thread can open the closed database. So this method can make sure database is closed in the “onClosed” block. All other operations will be blocked until this method returns. A close operation consists of 4 steps: 1. blockade, which blocks all other operations. 2. close, which waits until all sqlite handles return and closes them. 3. onClosed, which trigger the callback. 4. unblokade, which unblocks all other opreations. You can simply call close: to do all steps above or call these separately. Since this method will wait until all sqlite handles return, it may lead to deadlock in some bad practice. The key to avoid deadlock is to make sure all WCDB objects in current thread is dealloced. In detail: 1. You should not keep WCDB objects, including WCTInsert, WCTDelete, WCTUpdate, WCTSelect, WCTRowSelect, WCTMultiSelect, WCTStatement, WCTTransaction. These objects should not be kept. You should get them, use them, then release them(set to nil) right away. 2. WCDB objects may not be out of its' scope. 3. Further more, those WCDB objects may be kept by NSAutoReleasePool, which is done by ARC automatically. So you should make sure that all WCDB objects in NSAutoReleasePool is drained. The best practice is to call close: in sub-thread and display a loading animation in main thread.

 //close directly
 [database close:^(){
    //do something on this closed database
 }];
 //close separately
 [database blockade];
 [database close];
 //do something on this closed database
 [database unblockade];

This interface is equivalent to [database close:nil].

Blockade the database.

Unblockade the database.

Check whether database is blockaded.

Purge all free handles of this database. WCDB will cache and reuse some sqlite handles to improve performance. The max count of free sqlite handles is same as the number of concurrent threads supported by the hardware implementation. You can call it to save some memory.

Purge all free handles of all databases. Note that WCDB will call this interface automatically while it receives memory warning on iOS.