国内WASDK WA实现层
view | history | commit | commitdiff
hank
2017-03-03 71172661cf242ba67cf68c387ce24079ead55930
commit | author | age
6e1425 1 #import <Foundation/Foundation.h>
H 2 #import "FMResultSet.h"
3 #import "FMDatabasePool.h"
4
5
6 #if ! __has_feature(objc_arc)
7     #define FMDBAutorelease(__v) ([__v autorelease]);
8     #define FMDBReturnAutoreleased FMDBAutorelease
9
10     #define FMDBRetain(__v) ([__v retain]);
11     #define FMDBReturnRetained FMDBRetain
12
13     #define FMDBRelease(__v) ([__v release]);
14
15     #define FMDBDispatchQueueRelease(__v) (dispatch_release(__v));
16 #else
17     // -fobjc-arc
18     #define FMDBAutorelease(__v)
19     #define FMDBReturnAutoreleased(__v) (__v)
20
21     #define FMDBRetain(__v)
22     #define FMDBReturnRetained(__v) (__v)
23
24     #define FMDBRelease(__v)
25
26 // If OS_OBJECT_USE_OBJC=1, then the dispatch objects will be treated like ObjC objects
27 // and will participate in ARC.
28 // See the section on "Dispatch Queues and Automatic Reference Counting" in "Grand Central Dispatch (GCD) Reference" for details. 
29     #if OS_OBJECT_USE_OBJC
30         #define FMDBDispatchQueueRelease(__v)
31     #else
32         #define FMDBDispatchQueueRelease(__v) (dispatch_release(__v));
33     #endif
34 #endif
35
36 #if !__has_feature(objc_instancetype)
37     #define instancetype id
38 #endif
39
40
41 typedef int(^FMDBExecuteStatementsCallbackBlock)(NSDictionary *resultsDictionary);
42
43
44 /** A SQLite ([http://sqlite.org/](http://sqlite.org/)) Objective-C wrapper.
45  
46  ### Usage
47  The three main classes in FMDB are:
48
49  - `FMDatabase` - Represents a single SQLite database.  Used for executing SQL statements.
50  - `<FMResultSet>` - Represents the results of executing a query on an `FMDatabase`.
51  - `<FMDatabaseQueue>` - If you want to perform queries and updates on multiple threads, you'll want to use this class.
52
53  ### See also
54  
55  - `<FMDatabasePool>` - A pool of `FMDatabase` objects.
56  - `<FMStatement>` - A wrapper for `sqlite_stmt`.
57  
58  ### External links
59  
60  - [FMDB on GitHub](https://github.com/ccgus/fmdb) including introductory documentation
61  - [SQLite web site](http://sqlite.org/)
62  - [FMDB mailing list](http://groups.google.com/group/fmdb)
63  - [SQLite FAQ](http://www.sqlite.org/faq.html)
64  
65  @warning Do not instantiate a single `FMDatabase` object and use it across multiple threads. Instead, use `<FMDatabaseQueue>`.
66
67  */
68
69 #pragma clang diagnostic push
70 #pragma clang diagnostic ignored "-Wobjc-interface-ivars"
71
72
73 @interface FMDatabase : NSObject  {
74     
75     void*               _db;
76     NSString*           _databasePath;
77     BOOL                _logsErrors;
78     BOOL                _crashOnErrors;
79     BOOL                _traceExecution;
80     BOOL                _checkedOut;
81     BOOL                _shouldCacheStatements;
82     BOOL                _isExecutingStatement;
83     BOOL                _inTransaction;
84     NSTimeInterval      _maxBusyRetryTimeInterval;
85     NSTimeInterval      _startBusyRetryTime;
86     
87     NSMutableDictionary *_cachedStatements;
88     NSMutableSet        *_openResultSets;
89     NSMutableSet        *_openFunctions;
90
91     NSDateFormatter     *_dateFormat;
92 }
93
94 ///-----------------
95 /// @name Properties
96 ///-----------------
97
98 /** Whether should trace execution */
99
100 @property (atomic, assign) BOOL traceExecution;
101
102 /** Whether checked out or not */
103
104 @property (atomic, assign) BOOL checkedOut;
105
106 /** Crash on errors */
107
108 @property (atomic, assign) BOOL crashOnErrors;
109
110 /** Logs errors */
111
112 @property (atomic, assign) BOOL logsErrors;
113
114 /** Dictionary of cached statements */
115
116 @property (atomic, retain) NSMutableDictionary *cachedStatements;
117
118 ///---------------------
119 /// @name Initialization
120 ///---------------------
121
122 /** Create a `FMDatabase` object.
123  
124  An `FMDatabase` is created with a path to a SQLite database file.  This path can be one of these three:
125
126  1. A file system path.  The file does not have to exist on disk.  If it does not exist, it is created for you.
127  2. An empty string (`@""`).  An empty database is created at a temporary location.  This database is deleted with the `FMDatabase` connection is closed.
128  3. `nil`.  An in-memory database is created.  This database will be destroyed with the `FMDatabase` connection is closed.
129
130  For example, to create/open a database in your Mac OS X `tmp` folder:
131
132     FMDatabase *db = [FMDatabase databaseWithPath:@"/tmp/tmp.db"];
133
134  Or, in iOS, you might open a database in the app's `Documents` directory:
135
136     NSString *docsPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0];
137     NSString *dbPath   = [docsPath stringByAppendingPathComponent:@"test.db"];
138     FMDatabase *db     = [FMDatabase databaseWithPath:dbPath];
139
140  (For more information on temporary and in-memory databases, read the sqlite documentation on the subject: [http://www.sqlite.org/inmemorydb.html](http://www.sqlite.org/inmemorydb.html))
141
142  @param inPath Path of database file
143
144  @return `FMDatabase` object if successful; `nil` if failure.
145
146  */
147
148 + (instancetype)databaseWithPath:(NSString*)inPath;
149
150 /** Initialize a `FMDatabase` object.
151  
152  An `FMDatabase` is created with a path to a SQLite database file.  This path can be one of these three:
153
154  1. A file system path.  The file does not have to exist on disk.  If it does not exist, it is created for you.
155  2. An empty string (`@""`).  An empty database is created at a temporary location.  This database is deleted with the `FMDatabase` connection is closed.
156  3. `nil`.  An in-memory database is created.  This database will be destroyed with the `FMDatabase` connection is closed.
157
158  For example, to create/open a database in your Mac OS X `tmp` folder:
159
160     FMDatabase *db = [FMDatabase databaseWithPath:@"/tmp/tmp.db"];
161
162  Or, in iOS, you might open a database in the app's `Documents` directory:
163
164     NSString *docsPath = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES)[0];
165     NSString *dbPath   = [docsPath stringByAppendingPathComponent:@"test.db"];
166     FMDatabase *db     = [FMDatabase databaseWithPath:dbPath];
167
168  (For more information on temporary and in-memory databases, read the sqlite documentation on the subject: [http://www.sqlite.org/inmemorydb.html](http://www.sqlite.org/inmemorydb.html))
169
170  @param inPath Path of database file
171  
172  @return `FMDatabase` object if successful; `nil` if failure.
173
174  */
175
176 - (instancetype)initWithPath:(NSString*)inPath;
177
178
179 ///-----------------------------------
180 /// @name Opening and closing database
181 ///-----------------------------------
182
183 /** Opening a new database connection
184  
185  The database is opened for reading and writing, and is created if it does not already exist.
186
187  @return `YES` if successful, `NO` on error.
188
189  @see [sqlite3_open()](http://sqlite.org/c3ref/open.html)
190  @see openWithFlags:
191  @see close
192  */
193
194 - (BOOL)open;
195
196 /** Opening a new database connection with flags and an optional virtual file system (VFS)
197
198  @param flags one of the following three values, optionally combined with the `SQLITE_OPEN_NOMUTEX`, `SQLITE_OPEN_FULLMUTEX`, `SQLITE_OPEN_SHAREDCACHE`, `SQLITE_OPEN_PRIVATECACHE`, and/or `SQLITE_OPEN_URI` flags:
199
200  `SQLITE_OPEN_READONLY`
201
202  The database is opened in read-only mode. If the database does not already exist, an error is returned.
203  
204  `SQLITE_OPEN_READWRITE`
205  
206  The database is opened for reading and writing if possible, or reading only if the file is write protected by the operating system. In either case the database must already exist, otherwise an error is returned.
207  
208  `SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE`
209  
210  The database is opened for reading and writing, and is created if it does not already exist. This is the behavior that is always used for `open` method.
211   
212  @return `YES` if successful, `NO` on error.
213
214  @see [sqlite3_open_v2()](http://sqlite.org/c3ref/open.html)
215  @see open
216  @see close
217  */
218
219 - (BOOL)openWithFlags:(int)flags;
220
221 /** Opening a new database connection with flags and an optional virtual file system (VFS)
222  
223  @param flags one of the following three values, optionally combined with the `SQLITE_OPEN_NOMUTEX`, `SQLITE_OPEN_FULLMUTEX`, `SQLITE_OPEN_SHAREDCACHE`, `SQLITE_OPEN_PRIVATECACHE`, and/or `SQLITE_OPEN_URI` flags:
224  
225  `SQLITE_OPEN_READONLY`
226  
227  The database is opened in read-only mode. If the database does not already exist, an error is returned.
228  
229  `SQLITE_OPEN_READWRITE`
230  
231  The database is opened for reading and writing if possible, or reading only if the file is write protected by the operating system. In either case the database must already exist, otherwise an error is returned.
232  
233  `SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE`
234  
235  The database is opened for reading and writing, and is created if it does not already exist. This is the behavior that is always used for `open` method.
236  
237  @param vfsName   If vfs is given the value is passed to the vfs parameter of sqlite3_open_v2.
238  
239  @return `YES` if successful, `NO` on error.
240  
241  @see [sqlite3_open_v2()](http://sqlite.org/c3ref/open.html)
242  @see open
243  @see close
244  */
245
246 - (BOOL)openWithFlags:(int)flags vfs:(NSString *)vfsName;
247
248 /** Closing a database connection
249  
250  @return `YES` if success, `NO` on error.
251  
252  @see [sqlite3_close()](http://sqlite.org/c3ref/close.html)
253  @see open
254  @see openWithFlags:
255  */
256
257 - (BOOL)close;
258
259 /** Test to see if we have a good connection to the database.
260  
261  This will confirm whether:
262  
263  - is database open
264  - if open, it will try a simple SELECT statement and confirm that it succeeds.
265
266  @return `YES` if everything succeeds, `NO` on failure.
267  */
268
269 - (BOOL)goodConnection;
270
271
272 ///----------------------
273 /// @name Perform updates
274 ///----------------------
275
276 /** Execute single update statement
277  
278  This method executes a single SQL update statement (i.e. any SQL that does not return results, such as `UPDATE`, `INSERT`, or `DELETE`. This method employs [`sqlite3_prepare_v2`](http://sqlite.org/c3ref/prepare.html), [`sqlite3_bind`](http://sqlite.org/c3ref/bind_blob.html) to bind values to `?` placeholders in the SQL with the optional list of parameters, and [`sqlite_step`](http://sqlite.org/c3ref/step.html) to perform the update.
279
280  The optional values provided to this method should be objects (e.g. `NSString`, `NSNumber`, `NSNull`, `NSDate`, and `NSData` objects), not fundamental data types (e.g. `int`, `long`, `NSInteger`, etc.). This method automatically handles the aforementioned object types, and all other object types will be interpreted as text values using the object's `description` method.
281
282  @param sql The SQL to be performed, with optional `?` placeholders.
283  
284  @param outErr A reference to the `NSError` pointer to be updated with an auto released `NSError` object if an error if an error occurs. If `nil`, no `NSError` object will be returned.
285  
286  @param ... Optional parameters to bind to `?` placeholders in the SQL statement. These should be Objective-C objects (e.g. `NSString`, `NSNumber`, etc.), not fundamental C data types (e.g. `int`, `char *`, etc.).
287
288  @return `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
289
290  @see lastError
291  @see lastErrorCode
292  @see lastErrorMessage
293  @see [`sqlite3_bind`](http://sqlite.org/c3ref/bind_blob.html)
294  */
295
296 - (BOOL)executeUpdate:(NSString*)sql withErrorAndBindings:(NSError**)outErr, ...;
297
298 /** Execute single update statement
299  
300  @see executeUpdate:withErrorAndBindings:
301  
302  @warning **Deprecated**: Please use `<executeUpdate:withErrorAndBindings>` instead.
303  */
304
305 - (BOOL)update:(NSString*)sql withErrorAndBindings:(NSError**)outErr, ... __attribute__ ((deprecated));
306
307 /** Execute single update statement
308
309  This method executes a single SQL update statement (i.e. any SQL that does not return results, such as `UPDATE`, `INSERT`, or `DELETE`. This method employs [`sqlite3_prepare_v2`](http://sqlite.org/c3ref/prepare.html), [`sqlite3_bind`](http://sqlite.org/c3ref/bind_blob.html) to bind values to `?` placeholders in the SQL with the optional list of parameters, and [`sqlite_step`](http://sqlite.org/c3ref/step.html) to perform the update.
310
311  The optional values provided to this method should be objects (e.g. `NSString`, `NSNumber`, `NSNull`, `NSDate`, and `NSData` objects), not fundamental data types (e.g. `int`, `long`, `NSInteger`, etc.). This method automatically handles the aforementioned object types, and all other object types will be interpreted as text values using the object's `description` method.
312  
313  @param sql The SQL to be performed, with optional `?` placeholders.
314
315  @param ... Optional parameters to bind to `?` placeholders in the SQL statement. These should be Objective-C objects (e.g. `NSString`, `NSNumber`, etc.), not fundamental C data types (e.g. `int`, `char *`, etc.).
316
317  @return `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
318  
319  @see lastError
320  @see lastErrorCode
321  @see lastErrorMessage
322  @see [`sqlite3_bind`](http://sqlite.org/c3ref/bind_blob.html)
323  
324  @note This technique supports the use of `?` placeholders in the SQL, automatically binding any supplied value parameters to those placeholders. This approach is more robust than techniques that entail using `stringWithFormat` to manually build SQL statements, which can be problematic if the values happened to include any characters that needed to be quoted.
325  
326  @note If you want to use this from Swift, please note that you must include `FMDatabaseVariadic.swift` in your project. Without that, you cannot use this method directly, and instead have to use methods such as `<executeUpdate:withArgumentsInArray:>`.
327  */
328
329 - (BOOL)executeUpdate:(NSString*)sql, ...;
330
331 /** Execute single update statement
332
333  This method executes a single SQL update statement (i.e. any SQL that does not return results, such as `UPDATE`, `INSERT`, or `DELETE`. This method employs [`sqlite3_prepare_v2`](http://sqlite.org/c3ref/prepare.html) and [`sqlite_step`](http://sqlite.org/c3ref/step.html) to perform the update. Unlike the other `executeUpdate` methods, this uses printf-style formatters (e.g. `%s`, `%d`, etc.) to build the SQL. Do not use `?` placeholders in the SQL if you use this method.
334
335  @param format The SQL to be performed, with `printf`-style escape sequences.
336
337  @param ... Optional parameters to bind to use in conjunction with the `printf`-style escape sequences in the SQL statement.
338
339  @return `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
340
341  @see executeUpdate:
342  @see lastError
343  @see lastErrorCode
344  @see lastErrorMessage
345  
346  @note This method does not technically perform a traditional printf-style replacement. What this method actually does is replace the printf-style percent sequences with a SQLite `?` placeholder, and then bind values to that placeholder. Thus the following command
347
348     [db executeUpdateWithFormat:@"INSERT INTO test (name) VALUES (%@)", @"Gus"];
349
350  is actually replacing the `%@` with `?` placeholder, and then performing something equivalent to `<executeUpdate:>`
351
352     [db executeUpdate:@"INSERT INTO test (name) VALUES (?)", @"Gus"];
353
354  There are two reasons why this distinction is important. First, the printf-style escape sequences can only be used where it is permissible to use a SQLite `?` placeholder. You can use it only for values in SQL statements, but not for table names or column names or any other non-value context. This method also cannot be used in conjunction with `pragma` statements and the like. Second, note the lack of quotation marks in the SQL. The `VALUES` clause was _not_ `VALUES ('%@')` (like you might have to do if you built a SQL statement using `NSString` method `stringWithFormat`), but rather simply `VALUES (%@)`.
355  */
356
357 - (BOOL)executeUpdateWithFormat:(NSString *)format, ... NS_FORMAT_FUNCTION(1,2);
358
359 /** Execute single update statement
360  
361  This method executes a single SQL update statement (i.e. any SQL that does not return results, such as `UPDATE`, `INSERT`, or `DELETE`. This method employs [`sqlite3_prepare_v2`](http://sqlite.org/c3ref/prepare.html) and [`sqlite3_bind`](http://sqlite.org/c3ref/bind_blob.html) binding any `?` placeholders in the SQL with the optional list of parameters.
362  
363  The optional values provided to this method should be objects (e.g. `NSString`, `NSNumber`, `NSNull`, `NSDate`, and `NSData` objects), not fundamental data types (e.g. `int`, `long`, `NSInteger`, etc.). This method automatically handles the aforementioned object types, and all other object types will be interpreted as text values using the object's `description` method.
364  
365  @param sql The SQL to be performed, with optional `?` placeholders.
366  
367  @param arguments A `NSArray` of objects to be used when binding values to the `?` placeholders in the SQL statement.
368  
369  @return `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
370  
371  @see executeUpdate:values:error:
372  @see lastError
373  @see lastErrorCode
374  @see lastErrorMessage
375  */
376
377 - (BOOL)executeUpdate:(NSString*)sql withArgumentsInArray:(NSArray *)arguments;
378
379 /** Execute single update statement
380  
381  This method executes a single SQL update statement (i.e. any SQL that does not return results, such as `UPDATE`, `INSERT`, or `DELETE`. This method employs [`sqlite3_prepare_v2`](http://sqlite.org/c3ref/prepare.html) and [`sqlite3_bind`](http://sqlite.org/c3ref/bind_blob.html) binding any `?` placeholders in the SQL with the optional list of parameters.
382  
383  The optional values provided to this method should be objects (e.g. `NSString`, `NSNumber`, `NSNull`, `NSDate`, and `NSData` objects), not fundamental data types (e.g. `int`, `long`, `NSInteger`, etc.). This method automatically handles the aforementioned object types, and all other object types will be interpreted as text values using the object's `description` method.
384  
385  This is similar to `<executeUpdate:withArgumentsInArray:>`, except that this also accepts a pointer to a `NSError` pointer, so that errors can be returned.
386
387  In Swift 2, this throws errors, as if it were defined as follows:
388  
389  `func executeUpdate(sql: String!, values: [AnyObject]!) throws -> Bool`
390  
391  @param sql The SQL to be performed, with optional `?` placeholders.
392  
393  @param values A `NSArray` of objects to be used when binding values to the `?` placeholders in the SQL statement.
394
395  @param error A `NSError` object to receive any error object (if any).
396
397  @return `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
398  
399  @see lastError
400  @see lastErrorCode
401  @see lastErrorMessage
402  
403  */
404
405 - (BOOL)executeUpdate:(NSString*)sql values:(NSArray *)values error:(NSError * __autoreleasing *)error;
406
407 /** Execute single update statement
408
409  This method executes a single SQL update statement (i.e. any SQL that does not return results, such as `UPDATE`, `INSERT`, or `DELETE`. This method employs [`sqlite3_prepare_v2`](http://sqlite.org/c3ref/prepare.html) and [`sqlite_step`](http://sqlite.org/c3ref/step.html) to perform the update. Unlike the other `executeUpdate` methods, this uses printf-style formatters (e.g. `%s`, `%d`, etc.) to build the SQL.
410
411  The optional values provided to this method should be objects (e.g. `NSString`, `NSNumber`, `NSNull`, `NSDate`, and `NSData` objects), not fundamental data types (e.g. `int`, `long`, `NSInteger`, etc.). This method automatically handles the aforementioned object types, and all other object types will be interpreted as text values using the object's `description` method.
412
413  @param sql The SQL to be performed, with optional `?` placeholders.
414
415  @param arguments A `NSDictionary` of objects keyed by column names that will be used when binding values to the `?` placeholders in the SQL statement.
416
417  @return `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
418
419  @see lastError
420  @see lastErrorCode
421  @see lastErrorMessage
422 */
423
424 - (BOOL)executeUpdate:(NSString*)sql withParameterDictionary:(NSDictionary *)arguments;
425
426
427 /** Execute single update statement
428
429  This method executes a single SQL update statement (i.e. any SQL that does not return results, such as `UPDATE`, `INSERT`, or `DELETE`. This method employs [`sqlite3_prepare_v2`](http://sqlite.org/c3ref/prepare.html) and [`sqlite_step`](http://sqlite.org/c3ref/step.html) to perform the update. Unlike the other `executeUpdate` methods, this uses printf-style formatters (e.g. `%s`, `%d`, etc.) to build the SQL.
430
431  The optional values provided to this method should be objects (e.g. `NSString`, `NSNumber`, `NSNull`, `NSDate`, and `NSData` objects), not fundamental data types (e.g. `int`, `long`, `NSInteger`, etc.). This method automatically handles the aforementioned object types, and all other object types will be interpreted as text values using the object's `description` method.
432
433  @param sql The SQL to be performed, with optional `?` placeholders.
434
435  @param args A `va_list` of arguments.
436
437  @return `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
438
439  @see lastError
440  @see lastErrorCode
441  @see lastErrorMessage
442  */
443
444 - (BOOL)executeUpdate:(NSString*)sql withVAList: (va_list)args;
445
446 /** Execute multiple SQL statements
447  
448  This executes a series of SQL statements that are combined in a single string (e.g. the SQL generated by the `sqlite3` command line `.dump` command). This accepts no value parameters, but rather simply expects a single string with multiple SQL statements, each terminated with a semicolon. This uses `sqlite3_exec`. 
449
450  @param  sql  The SQL to be performed
451  
452  @return      `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
453
454  @see executeStatements:withResultBlock:
455  @see [sqlite3_exec()](http://sqlite.org/c3ref/exec.html)
456
457  */
458
459 - (BOOL)executeStatements:(NSString *)sql;
460
461 /** Execute multiple SQL statements with callback handler
462  
463  This executes a series of SQL statements that are combined in a single string (e.g. the SQL generated by the `sqlite3` command line `.dump` command). This accepts no value parameters, but rather simply expects a single string with multiple SQL statements, each terminated with a semicolon. This uses `sqlite3_exec`.
464
465  @param sql       The SQL to be performed.
466  @param block     A block that will be called for any result sets returned by any SQL statements. 
467                   Note, if you supply this block, it must return integer value, zero upon success (this would be a good opportunity to use SQLITE_OK),
468                   non-zero value upon failure (which will stop the bulk execution of the SQL).  If a statement returns values, the block will be called with the results from the query in NSDictionary *resultsDictionary.
469                   This may be `nil` if you don't care to receive any results.
470
471  @return          `YES` upon success; `NO` upon failure. If failed, you can call `<lastError>`,
472                   `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
473  
474  @see executeStatements:
475  @see [sqlite3_exec()](http://sqlite.org/c3ref/exec.html)
476
477  */
478
479 - (BOOL)executeStatements:(NSString *)sql withResultBlock:(FMDBExecuteStatementsCallbackBlock)block;
480
481 /** Last insert rowid
482  
483  Each entry in an SQLite table has a unique 64-bit signed integer key called the "rowid". The rowid is always available as an undeclared column named `ROWID`, `OID`, or `_ROWID_` as long as those names are not also used by explicitly declared columns. If the table has a column of type `INTEGER PRIMARY KEY` then that column is another alias for the rowid.
484  
485  This routine returns the rowid of the most recent successful `INSERT` into the database from the database connection in the first argument. As of SQLite version 3.7.7, this routines records the last insert rowid of both ordinary tables and virtual tables. If no successful `INSERT`s have ever occurred on that database connection, zero is returned.
486  
487  @return The rowid of the last inserted row.
488  
489  @see [sqlite3_last_insert_rowid()](http://sqlite.org/c3ref/last_insert_rowid.html)
490
491  */
492
493 - (int64_t)lastInsertRowId;
494
495 /** The number of rows changed by prior SQL statement.
496  
497  This function returns the number of database rows that were changed or inserted or deleted by the most recently completed SQL statement on the database connection specified by the first parameter. Only changes that are directly specified by the INSERT, UPDATE, or DELETE statement are counted.
498  
499  @return The number of rows changed by prior SQL statement.
500  
501  @see [sqlite3_changes()](http://sqlite.org/c3ref/changes.html)
502  
503  */
504
505 - (int)changes;
506
507
508 ///-------------------------
509 /// @name Retrieving results
510 ///-------------------------
511
512 /** Execute select statement
513
514  Executing queries returns an `<FMResultSet>` object if successful, and `nil` upon failure.  Like executing updates, there is a variant that accepts an `NSError **` parameter.  Otherwise you should use the `<lastErrorMessage>` and `<lastErrorMessage>` methods to determine why a query failed.
515  
516  In order to iterate through the results of your query, you use a `while()` loop.  You also need to "step" (via `<[FMResultSet next]>`) from one record to the other.
517  
518  This method employs [`sqlite3_bind`](http://sqlite.org/c3ref/bind_blob.html) for any optional value parameters. This  properly escapes any characters that need escape sequences (e.g. quotation marks), which eliminates simple SQL errors as well as protects against SQL injection attacks. This method natively handles `NSString`, `NSNumber`, `NSNull`, `NSDate`, and `NSData` objects. All other object types will be interpreted as text values using the object's `description` method.
519
520  @param sql The SELECT statement to be performed, with optional `?` placeholders.
521
522  @param ... Optional parameters to bind to `?` placeholders in the SQL statement. These should be Objective-C objects (e.g. `NSString`, `NSNumber`, etc.), not fundamental C data types (e.g. `int`, `char *`, etc.).
523
524  @return A `<FMResultSet>` for the result set upon success; `nil` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
525  
526  @see FMResultSet
527  @see [`FMResultSet next`](<[FMResultSet next]>)
528  @see [`sqlite3_bind`](http://sqlite.org/c3ref/bind_blob.html)
529  
530  @note If you want to use this from Swift, please note that you must include `FMDatabaseVariadic.swift` in your project. Without that, you cannot use this method directly, and instead have to use methods such as `<executeQuery:withArgumentsInArray:>`.
531  */
532
533 - (FMResultSet *)executeQuery:(NSString*)sql, ...;
534
535 /** Execute select statement
536
537  Executing queries returns an `<FMResultSet>` object if successful, and `nil` upon failure.  Like executing updates, there is a variant that accepts an `NSError **` parameter.  Otherwise you should use the `<lastErrorMessage>` and `<lastErrorMessage>` methods to determine why a query failed.
538  
539  In order to iterate through the results of your query, you use a `while()` loop.  You also need to "step" (via `<[FMResultSet next]>`) from one record to the other.
540  
541  @param format The SQL to be performed, with `printf`-style escape sequences.
542
543  @param ... Optional parameters to bind to use in conjunction with the `printf`-style escape sequences in the SQL statement.
544
545  @return A `<FMResultSet>` for the result set upon success; `nil` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
546
547  @see executeQuery:
548  @see FMResultSet
549  @see [`FMResultSet next`](<[FMResultSet next]>)
550
551  @note This method does not technically perform a traditional printf-style replacement. What this method actually does is replace the printf-style percent sequences with a SQLite `?` placeholder, and then bind values to that placeholder. Thus the following command
552  
553     [db executeQueryWithFormat:@"SELECT * FROM test WHERE name=%@", @"Gus"];
554  
555  is actually replacing the `%@` with `?` placeholder, and then performing something equivalent to `<executeQuery:>`
556  
557     [db executeQuery:@"SELECT * FROM test WHERE name=?", @"Gus"];
558  
559  There are two reasons why this distinction is important. First, the printf-style escape sequences can only be used where it is permissible to use a SQLite `?` placeholder. You can use it only for values in SQL statements, but not for table names or column names or any other non-value context. This method also cannot be used in conjunction with `pragma` statements and the like. Second, note the lack of quotation marks in the SQL. The `WHERE` clause was _not_ `WHERE name='%@'` (like you might have to do if you built a SQL statement using `NSString` method `stringWithFormat`), but rather simply `WHERE name=%@`.
560  
561  */
562
563 - (FMResultSet *)executeQueryWithFormat:(NSString*)format, ... NS_FORMAT_FUNCTION(1,2);
564
565 /** Execute select statement
566
567  Executing queries returns an `<FMResultSet>` object if successful, and `nil` upon failure.  Like executing updates, there is a variant that accepts an `NSError **` parameter.  Otherwise you should use the `<lastErrorMessage>` and `<lastErrorMessage>` methods to determine why a query failed.
568  
569  In order to iterate through the results of your query, you use a `while()` loop.  You also need to "step" (via `<[FMResultSet next]>`) from one record to the other.
570  
571  @param sql The SELECT statement to be performed, with optional `?` placeholders.
572
573  @param arguments A `NSArray` of objects to be used when binding values to the `?` placeholders in the SQL statement.
574
575  @return A `<FMResultSet>` for the result set upon success; `nil` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
576
577  @see -executeQuery:values:error:
578  @see FMResultSet
579  @see [`FMResultSet next`](<[FMResultSet next]>)
580  */
581
582 - (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments;
583
584 /** Execute select statement
585  
586  Executing queries returns an `<FMResultSet>` object if successful, and `nil` upon failure.  Like executing updates, there is a variant that accepts an `NSError **` parameter.  Otherwise you should use the `<lastErrorMessage>` and `<lastErrorMessage>` methods to determine why a query failed.
587  
588  In order to iterate through the results of your query, you use a `while()` loop.  You also need to "step" (via `<[FMResultSet next]>`) from one record to the other.
589  
590  This is similar to `<executeQuery:withArgumentsInArray:>`, except that this also accepts a pointer to a `NSError` pointer, so that errors can be returned.
591  
592  In Swift 2, this throws errors, as if it were defined as follows:
593  
594  `func executeQuery(sql: String!, values: [AnyObject]!) throws  -> FMResultSet!`
595
596  @param sql The SELECT statement to be performed, with optional `?` placeholders.
597  
598  @param values A `NSArray` of objects to be used when binding values to the `?` placeholders in the SQL statement.
599
600  @param error A `NSError` object to receive any error object (if any).
601
602  @return A `<FMResultSet>` for the result set upon success; `nil` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
603  
604  @see FMResultSet
605  @see [`FMResultSet next`](<[FMResultSet next]>)
606  
607  @note When called from Swift, only use the first two parameters, `sql` and `values`. This but throws the error.
608
609  */
610
611 - (FMResultSet *)executeQuery:(NSString *)sql values:(NSArray *)values error:(NSError * __autoreleasing *)error;
612
613 /** Execute select statement
614
615  Executing queries returns an `<FMResultSet>` object if successful, and `nil` upon failure.  Like executing updates, there is a variant that accepts an `NSError **` parameter.  Otherwise you should use the `<lastErrorMessage>` and `<lastErrorMessage>` methods to determine why a query failed.
616  
617  In order to iterate through the results of your query, you use a `while()` loop.  You also need to "step" (via `<[FMResultSet next]>`) from one record to the other.
618  
619  @param sql The SELECT statement to be performed, with optional `?` placeholders.
620
621  @param arguments A `NSDictionary` of objects keyed by column names that will be used when binding values to the `?` placeholders in the SQL statement.
622
623  @return A `<FMResultSet>` for the result set upon success; `nil` upon failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
624
625  @see FMResultSet
626  @see [`FMResultSet next`](<[FMResultSet next]>)
627  */
628
629 - (FMResultSet *)executeQuery:(NSString *)sql withParameterDictionary:(NSDictionary *)arguments;
630
631
632 // Documentation forthcoming.
633 - (FMResultSet *)executeQuery:(NSString*)sql withVAList: (va_list)args;
634
635 ///-------------------
636 /// @name Transactions
637 ///-------------------
638
639 /** Begin a transaction
640  
641  @return `YES` on success; `NO` on failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
642  
643  @see commit
644  @see rollback
645  @see beginDeferredTransaction
646  @see inTransaction
647  */
648
649 - (BOOL)beginTransaction;
650
651 /** Begin a deferred transaction
652  
653  @return `YES` on success; `NO` on failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
654  
655  @see commit
656  @see rollback
657  @see beginTransaction
658  @see inTransaction
659  */
660
661 - (BOOL)beginDeferredTransaction;
662
663 /** Commit a transaction
664
665  Commit a transaction that was initiated with either `<beginTransaction>` or with `<beginDeferredTransaction>`.
666  
667  @return `YES` on success; `NO` on failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
668  
669  @see beginTransaction
670  @see beginDeferredTransaction
671  @see rollback
672  @see inTransaction
673  */
674
675 - (BOOL)commit;
676
677 /** Rollback a transaction
678
679  Rollback a transaction that was initiated with either `<beginTransaction>` or with `<beginDeferredTransaction>`.
680
681  @return `YES` on success; `NO` on failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
682  
683  @see beginTransaction
684  @see beginDeferredTransaction
685  @see commit
686  @see inTransaction
687  */
688
689 - (BOOL)rollback;
690
691 /** Identify whether currently in a transaction or not
692  
693  @return `YES` if currently within transaction; `NO` if not.
694  
695  @see beginTransaction
696  @see beginDeferredTransaction
697  @see commit
698  @see rollback
699  */
700
701 - (BOOL)inTransaction;
702
703
704 ///----------------------------------------
705 /// @name Cached statements and result sets
706 ///----------------------------------------
707
708 /** Clear cached statements */
709
710 - (void)clearCachedStatements;
711
712 /** Close all open result sets */
713
714 - (void)closeOpenResultSets;
715
716 /** Whether database has any open result sets
717  
718  @return `YES` if there are open result sets; `NO` if not.
719  */
720
721 - (BOOL)hasOpenResultSets;
722
723 /** Return whether should cache statements or not
724  
725  @return `YES` if should cache statements; `NO` if not.
726  */
727
728 - (BOOL)shouldCacheStatements;
729
730 /** Set whether should cache statements or not
731  
732  @param value `YES` if should cache statements; `NO` if not.
733  */
734
735 - (void)setShouldCacheStatements:(BOOL)value;
736
737
738 ///-------------------------
739 /// @name Encryption methods
740 ///-------------------------
741
742 /** Set encryption key.
743  
744  @param key The key to be used.
745
746  @return `YES` if success, `NO` on error.
747
748  @see https://www.zetetic.net/sqlcipher/
749  
750  @warning You need to have purchased the sqlite encryption extensions for this method to work.
751  */
752
753 - (BOOL)setKey:(NSString*)key;
754
755 /** Reset encryption key
756
757  @param key The key to be used.
758
759  @return `YES` if success, `NO` on error.
760
761  @see https://www.zetetic.net/sqlcipher/
762
763  @warning You need to have purchased the sqlite encryption extensions for this method to work.
764  */
765
766 - (BOOL)rekey:(NSString*)key;
767
768 /** Set encryption key using `keyData`.
769  
770  @param keyData The `NSData` to be used.
771
772  @return `YES` if success, `NO` on error.
773
774  @see https://www.zetetic.net/sqlcipher/
775  
776  @warning You need to have purchased the sqlite encryption extensions for this method to work.
777  */
778
779 - (BOOL)setKeyWithData:(NSData *)keyData;
780
781 /** Reset encryption key using `keyData`.
782
783  @param keyData The `NSData` to be used.
784
785  @return `YES` if success, `NO` on error.
786
787  @see https://www.zetetic.net/sqlcipher/
788
789  @warning You need to have purchased the sqlite encryption extensions for this method to work.
790  */
791
792 - (BOOL)rekeyWithData:(NSData *)keyData;
793
794
795 ///------------------------------
796 /// @name General inquiry methods
797 ///------------------------------
798
799 /** The path of the database file
800  
801  @return path of database.
802  
803  */
804
805 - (NSString *)databasePath;
806
807 /** The underlying SQLite handle 
808  
809  @return The `sqlite3` pointer.
810  
811  */
812
813 - (void*)sqliteHandle;
814
815
816 ///-----------------------------
817 /// @name Retrieving error codes
818 ///-----------------------------
819
820 /** Last error message
821  
822  Returns the English-language text that describes the most recent failed SQLite API call associated with a database connection. If a prior API call failed but the most recent API call succeeded, this return value is undefined.
823
824  @return `NSString` of the last error message.
825  
826  @see [sqlite3_errmsg()](http://sqlite.org/c3ref/errcode.html)
827  @see lastErrorCode
828  @see lastError
829  
830  */
831
832 - (NSString*)lastErrorMessage;
833
834 /** Last error code
835  
836  Returns the numeric result code or extended result code for the most recent failed SQLite API call associated with a database connection. If a prior API call failed but the most recent API call succeeded, this return value is undefined.
837
838  @return Integer value of the last error code.
839
840  @see [sqlite3_errcode()](http://sqlite.org/c3ref/errcode.html)
841  @see lastErrorMessage
842  @see lastError
843
844  */
845
846 - (int)lastErrorCode;
847
848 /** Had error
849
850  @return `YES` if there was an error, `NO` if no error.
851  
852  @see lastError
853  @see lastErrorCode
854  @see lastErrorMessage
855  
856  */
857
858 - (BOOL)hadError;
859
860 /** Last error
861
862  @return `NSError` representing the last error.
863  
864  @see lastErrorCode
865  @see lastErrorMessage
866  
867  */
868
869 - (NSError*)lastError;
870
871
872 // description forthcoming
873 - (void)setMaxBusyRetryTimeInterval:(NSTimeInterval)timeoutInSeconds;
874 - (NSTimeInterval)maxBusyRetryTimeInterval;
875
876
877 ///------------------
878 /// @name Save points
879 ///------------------
880
881 /** Start save point
882  
883  @param name Name of save point.
884  
885  @param outErr A `NSError` object to receive any error object (if any).
886  
887  @return `YES` on success; `NO` on failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
888  
889  @see releaseSavePointWithName:error:
890  @see rollbackToSavePointWithName:error:
891  */
892
893 - (BOOL)startSavePointWithName:(NSString*)name error:(NSError**)outErr;
894
895 /** Release save point
896
897  @param name Name of save point.
898  
899  @param outErr A `NSError` object to receive any error object (if any).
900  
901  @return `YES` on success; `NO` on failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
902
903  @see startSavePointWithName:error:
904  @see rollbackToSavePointWithName:error:
905  
906  */
907
908 - (BOOL)releaseSavePointWithName:(NSString*)name error:(NSError**)outErr;
909
910 /** Roll back to save point
911
912  @param name Name of save point.
913  @param outErr A `NSError` object to receive any error object (if any).
914  
915  @return `YES` on success; `NO` on failure. If failed, you can call `<lastError>`, `<lastErrorCode>`, or `<lastErrorMessage>` for diagnostic information regarding the failure.
916  
917  @see startSavePointWithName:error:
918  @see releaseSavePointWithName:error:
919  
920  */
921
922 - (BOOL)rollbackToSavePointWithName:(NSString*)name error:(NSError**)outErr;
923
924 /** Start save point
925
926  @param block Block of code to perform from within save point.
927  
928  @return The NSError corresponding to the error, if any. If no error, returns `nil`.
929
930  @see startSavePointWithName:error:
931  @see releaseSavePointWithName:error:
932  @see rollbackToSavePointWithName:error:
933  
934  */
935
936 - (NSError*)inSavePoint:(void (^)(BOOL *rollback))block;
937
938 ///----------------------------
939 /// @name SQLite library status
940 ///----------------------------
941
942 /** Test to see if the library is threadsafe
943
944  @return `NO` if and only if SQLite was compiled with mutexing code omitted due to the SQLITE_THREADSAFE compile-time option being set to 0.
945
946  @see [sqlite3_threadsafe()](http://sqlite.org/c3ref/threadsafe.html)
947  */
948
949 + (BOOL)isSQLiteThreadSafe;
950
951 /** Run-time library version numbers
952  
953  @return The sqlite library version string.
954  
955  @see [sqlite3_libversion()](http://sqlite.org/c3ref/libversion.html)
956  */
957
958 + (NSString*)sqliteLibVersion;
959
960
961 + (NSString*)FMDBUserVersion;
962
963 + (SInt32)FMDBVersion;
964
965
966 ///------------------------
967 /// @name Make SQL function
968 ///------------------------
969
970 /** Adds SQL functions or aggregates or to redefine the behavior of existing SQL functions or aggregates.
971  
972  For example:
973  
974     [queue inDatabase:^(FMDatabase *adb) {
975
976         [adb executeUpdate:@"create table ftest (foo text)"];
977         [adb executeUpdate:@"insert into ftest values ('hello')"];
978         [adb executeUpdate:@"insert into ftest values ('hi')"];
979         [adb executeUpdate:@"insert into ftest values ('not h!')"];
980         [adb executeUpdate:@"insert into ftest values ('definitely not h!')"];
981
982         [adb makeFunctionNamed:@"StringStartsWithH" maximumArguments:1 withBlock:^(sqlite3_context *context, int aargc, sqlite3_value **aargv) {
983             if (sqlite3_value_type(aargv[0]) == SQLITE_TEXT) {
984                 @autoreleasepool {
985                     const char *c = (const char *)sqlite3_value_text(aargv[0]);
986                     NSString *s = [NSString stringWithUTF8String:c];
987                     sqlite3_result_int(context, [s hasPrefix:@"h"]);
988                 }
989             }
990             else {
991                 NSLog(@"Unknown formart for StringStartsWithH (%d) %s:%d", sqlite3_value_type(aargv[0]), __FUNCTION__, __LINE__);
992                 sqlite3_result_null(context);
993             }
994         }];
995
996         int rowCount = 0;
997         FMResultSet *ars = [adb executeQuery:@"select * from ftest where StringStartsWithH(foo)"];
998         while ([ars next]) {
999             rowCount++;
1000             NSLog(@"Does %@ start with 'h'?", [rs stringForColumnIndex:0]);
1001         }
1002         FMDBQuickCheck(rowCount == 2);
1003     }];
1004
1005  @param name Name of function
1006
1007  @param count Maximum number of parameters
1008
1009  @param block The block of code for the function
1010
1011  @see [sqlite3_create_function()](http://sqlite.org/c3ref/create_function.html)
1012  */
1013
1014 - (void)makeFunctionNamed:(NSString*)name maximumArguments:(int)count withBlock:(void (^)(void *context, int argc, void **argv))block;
1015
1016
1017 ///---------------------
1018 /// @name Date formatter
1019 ///---------------------
1020
1021 /** Generate an `NSDateFormatter` that won't be broken by permutations of timezones or locales.
1022  
1023  Use this method to generate values to set the dateFormat property.
1024  
1025  Example:
1026
1027     myDB.dateFormat = [FMDatabase storeableDateFormat:@"yyyy-MM-dd HH:mm:ss"];
1028
1029  @param format A valid NSDateFormatter format string.
1030  
1031  @return A `NSDateFormatter` that can be used for converting dates to strings and vice versa.
1032  
1033  @see hasDateFormatter
1034  @see setDateFormat:
1035  @see dateFromString:
1036  @see stringFromDate:
1037  @see storeableDateFormat:
1038
1039  @warning Note that `NSDateFormatter` is not thread-safe, so the formatter generated by this method should be assigned to only one FMDB instance and should not be used for other purposes.
1040
1041  */
1042
1043 + (NSDateFormatter *)storeableDateFormat:(NSString *)format;
1044
1045 /** Test whether the database has a date formatter assigned.
1046  
1047  @return `YES` if there is a date formatter; `NO` if not.
1048  
1049  @see hasDateFormatter
1050  @see setDateFormat:
1051  @see dateFromString:
1052  @see stringFromDate:
1053  @see storeableDateFormat:
1054  */
1055
1056 - (BOOL)hasDateFormatter;
1057
1058 /** Set to a date formatter to use string dates with sqlite instead of the default UNIX timestamps.
1059  
1060  @param format Set to nil to use UNIX timestamps. Defaults to nil. Should be set using a formatter generated using FMDatabase::storeableDateFormat.
1061  
1062  @see hasDateFormatter
1063  @see setDateFormat:
1064  @see dateFromString:
1065  @see stringFromDate:
1066  @see storeableDateFormat:
1067  
1068  @warning Note there is no direct getter for the `NSDateFormatter`, and you should not use the formatter you pass to FMDB for other purposes, as `NSDateFormatter` is not thread-safe.
1069  */
1070
1071 - (void)setDateFormat:(NSDateFormatter *)format;
1072
1073 /** Convert the supplied NSString to NSDate, using the current database formatter.
1074  
1075  @param s `NSString` to convert to `NSDate`.
1076  
1077  @return The `NSDate` object; or `nil` if no formatter is set.
1078  
1079  @see hasDateFormatter
1080  @see setDateFormat:
1081  @see dateFromString:
1082  @see stringFromDate:
1083  @see storeableDateFormat:
1084  */
1085
1086 - (NSDate *)dateFromString:(NSString *)s;
1087
1088 /** Convert the supplied NSDate to NSString, using the current database formatter.
1089  
1090  @param date `NSDate` of date to convert to `NSString`.
1091
1092  @return The `NSString` representation of the date; `nil` if no formatter is set.
1093  
1094  @see hasDateFormatter
1095  @see setDateFormat:
1096  @see dateFromString:
1097  @see stringFromDate:
1098  @see storeableDateFormat:
1099  */
1100
1101 - (NSString *)stringFromDate:(NSDate *)date;
1102
1103 @end
1104
1105
1106 /** Objective-C wrapper for `sqlite3_stmt`
1107  
1108  This is a wrapper for a SQLite `sqlite3_stmt`. Generally when using FMDB you will not need to interact directly with `FMStatement`, but rather with `<FMDatabase>` and `<FMResultSet>` only.
1109  
1110  ### See also
1111  
1112  - `<FMDatabase>`
1113  - `<FMResultSet>`
1114  - [`sqlite3_stmt`](http://www.sqlite.org/c3ref/stmt.html)
1115  */
1116
1117 @interface FMStatement : NSObject {
1118     void *_statement;
1119     NSString *_query;
1120     long _useCount;
1121     BOOL _inUse;
1122 }
1123
1124 ///-----------------
1125 /// @name Properties
1126 ///-----------------
1127
1128 /** Usage count */
1129
1130 @property (atomic, assign) long useCount;
1131
1132 /** SQL statement */
1133
1134 @property (atomic, retain) NSString *query;
1135
1136 /** SQLite sqlite3_stmt
1137  
1138  @see [`sqlite3_stmt`](http://www.sqlite.org/c3ref/stmt.html)
1139  */
1140
1141 @property (atomic, assign) void *statement;
1142
1143 /** Indication of whether the statement is in use */
1144
1145 @property (atomic, assign) BOOL inUse;
1146
1147 ///----------------------------
1148 /// @name Closing and Resetting
1149 ///----------------------------
1150
1151 /** Close statement */
1152
1153 - (void)close;
1154
1155 /** Reset statement */
1156
1157 - (void)reset;
1158
1159 @end
1160
1161 #pragma clang diagnostic pop
1162