lpw
2024-06-12 09e73ac42fe2feb7925d954fed88a2eaa57697f7
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
//
//  FMDatabasePool.h
//  fmdb
//
//  Created by August Mueller on 6/22/11.
//  Copyright 2011 Flying Meat Inc. All rights reserved.
//
 
#import <Foundation/Foundation.h>
 
NS_ASSUME_NONNULL_BEGIN
 
@class FMDatabase;
 
/** Pool of @c FMDatabase  objects.
 
 See also
 
 - @c FMDatabaseQueue 
 - @c FMDatabase 
 
 @warning Before using @c FMDatabasePool , please consider using @c FMDatabaseQueue  instead.
 
 If you really really really know what you're doing and @c FMDatabasePool  is what
 you really really need (ie, you're using a read only database), OK you can use
 it.  But just be careful not to deadlock!
 
 For an example on deadlocking, search for:
 `ONLY_USE_THE_POOL_IF_YOU_ARE_DOING_READS_OTHERWISE_YOULL_DEADLOCK_USE_FMDATABASEQUEUE_INSTEAD`
 in the main.m file.
 */
 
@interface FMDatabasePool : NSObject
 
/** Database path */
 
@property (atomic, copy, nullable) NSString *path;
 
/** Delegate object */
 
@property (atomic, unsafe_unretained, nullable) id delegate;
 
/** Maximum number of databases to create */
 
@property (atomic, assign) NSUInteger maximumNumberOfDatabasesToCreate;
 
/** Open flags */
 
@property (atomic, readonly) int openFlags;
 
/**  Custom virtual file system name */
 
@property (atomic, copy, nullable) NSString *vfsName;
 
 
///---------------------
/// @name Initialization
///---------------------
 
/** Create pool using path.
 
 @param aPath The file path of the database.
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
+ (instancetype)databasePoolWithPath:(NSString * _Nullable)aPath;
 
/** Create pool using file URL.
 
 @param url The file @c NSURL  of the database.
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
+ (instancetype)databasePoolWithURL:(NSURL * _Nullable)url;
 
/** Create pool using path and specified flags
 
 @param aPath The file path of the database.
 @param openFlags Flags passed to the openWithFlags method of the database.
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
+ (instancetype)databasePoolWithPath:(NSString * _Nullable)aPath flags:(int)openFlags;
 
/** Create pool using file URL and specified flags
 
 @param url The file @c NSURL  of the database.
 @param openFlags Flags passed to the openWithFlags method of the database.
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
+ (instancetype)databasePoolWithURL:(NSURL * _Nullable)url flags:(int)openFlags;
 
/** Create pool using path.
 
 @param aPath The file path of the database.
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
- (instancetype)initWithPath:(NSString * _Nullable)aPath;
 
/** Create pool using file URL.
 
 @param url The file `NSURL of the database.
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
- (instancetype)initWithURL:(NSURL * _Nullable)url;
 
/** Create pool using path and specified flags.
 
 @param aPath The file path of the database.
 @param openFlags Flags passed to the openWithFlags method of the database
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
- (instancetype)initWithPath:(NSString * _Nullable)aPath flags:(int)openFlags;
 
/** Create pool using file URL and specified flags.
 
 @param url The file @c NSURL  of the database.
 @param openFlags Flags passed to the openWithFlags method of the database
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
- (instancetype)initWithURL:(NSURL * _Nullable)url flags:(int)openFlags;
 
/** Create pool using path and specified flags.
 
 @param aPath The file path of the database.
 @param openFlags Flags passed to the openWithFlags method of the database
 @param vfsName The name of a custom virtual file system
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
- (instancetype)initWithPath:(NSString * _Nullable)aPath flags:(int)openFlags vfs:(NSString * _Nullable)vfsName;
 
/** Create pool using file URL and specified flags.
 
 @param url The file @c NSURL  of the database.
 @param openFlags Flags passed to the openWithFlags method of the database
 @param vfsName The name of a custom virtual file system
 
 @return The @c FMDatabasePool  object. @c nil  on error.
 */
 
- (instancetype)initWithURL:(NSURL * _Nullable)url flags:(int)openFlags vfs:(NSString * _Nullable)vfsName;
 
/** Returns the Class of 'FMDatabase' subclass, that will be used to instantiate database object.
 
 Subclasses can override this method to return specified Class of 'FMDatabase' subclass.
 
 @return The Class of 'FMDatabase' subclass, that will be used to instantiate database object.
 */
 
+ (Class)databaseClass;
 
///------------------------------------------------
/// @name Keeping track of checked in/out databases
///------------------------------------------------
 
/** Number of checked-in databases in pool
 */
 
@property (nonatomic, readonly) NSUInteger countOfCheckedInDatabases;
 
/** Number of checked-out databases in pool
 */
 
@property (nonatomic, readonly) NSUInteger countOfCheckedOutDatabases;
 
/** Total number of databases in pool
 */
 
@property (nonatomic, readonly) NSUInteger countOfOpenDatabases;
 
/** Release all databases in pool */
 
- (void)releaseAllDatabases;
 
///------------------------------------------
/// @name Perform database operations in pool
///------------------------------------------
 
/** Synchronously perform database operations in pool.
 
 @param block The code to be run on the @c FMDatabasePool  pool.
 */
 
- (void)inDatabase:(__attribute__((noescape)) void (^)(FMDatabase *db))block;
 
/** Synchronously perform database operations in pool using transaction.
 
 @param block The code to be run on the @c FMDatabasePool  pool.
 
 @warning   Unlike SQLite's `BEGIN TRANSACTION`, this method currently performs
            an exclusive transaction, not a deferred transaction. This behavior
            is likely to change in future versions of FMDB, whereby this method
            will likely eventually adopt standard SQLite behavior and perform
            deferred transactions. If you really need exclusive tranaction, it is
            recommended that you use `inExclusiveTransaction`, instead, not only
            to make your intent explicit, but also to future-proof your code.
  */
 
- (void)inTransaction:(__attribute__((noescape)) void (^)(FMDatabase *db, BOOL *rollback))block;
 
/** Synchronously perform database operations in pool using exclusive transaction.
 
 @param block The code to be run on the @c FMDatabasePool  pool.
 */
 
- (void)inExclusiveTransaction:(__attribute__((noescape)) void (^)(FMDatabase *db, BOOL *rollback))block;
 
/** Synchronously perform database operations in pool using deferred transaction.
 
 @param block The code to be run on the @c FMDatabasePool  pool.
 */
 
- (void)inDeferredTransaction:(__attribute__((noescape)) void (^)(FMDatabase *db, BOOL *rollback))block;
 
/** Synchronously perform database operations on queue, using immediate transactions.
 
 @param block The code to be run on the queue of @c FMDatabaseQueue 
 */
 
- (void)inImmediateTransaction:(__attribute__((noescape)) void (^)(FMDatabase *db, BOOL *rollback))block;
 
/** Synchronously perform database operations in pool using save point.
 
 @param block The code to be run on the @c FMDatabasePool  pool.
 
 @return @c NSError  object if error; @c nil  if successful.
 
 @warning You can not nest these, since calling it will pull another database out of the pool and you'll get a deadlock. If you need to nest, use @c startSavePointWithName:error:  instead.
*/
 
- (NSError * _Nullable)inSavePoint:(__attribute__((noescape)) void (^)(FMDatabase *db, BOOL *rollback))block;
 
@end
 
 
/** FMDatabasePool delegate category
 
 This is a category that defines the protocol for the FMDatabasePool delegate
 */
 
@interface NSObject (FMDatabasePoolDelegate)
 
/** Asks the delegate whether database should be added to the pool. 
 
 @param pool     The @c FMDatabasePool  object.
 @param database The @c FMDatabase  object.
 
 @return @c YES if it should add database to pool; @c NO if not.
 
 */
 
- (BOOL)databasePool:(FMDatabasePool*)pool shouldAddDatabaseToPool:(FMDatabase*)database;
 
/** Tells the delegate that database was added to the pool.
 
 @param pool     The @c FMDatabasePool  object.
 @param database The @c FMDatabase  object.
 
 */
 
- (void)databasePool:(FMDatabasePool*)pool didAddDatabase:(FMDatabase*)database;
 
@end
 
NS_ASSUME_NONNULL_END