WASdkImpl_CN.git

2.7.0

lpw

2022-10-28 961c25f2d9521808de54ef7e046f1fba08704d42

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