You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1504 lines
44 KiB
1504 lines
44 KiB
#import "FMDatabase.h" |
|
#import "unistd.h" |
|
#import <objc/runtime.h> |
|
|
|
#if FMDB_SQLITE_STANDALONE |
|
#import <sqlite3/sqlite3.h> |
|
#else |
|
#import <sqlite3.h> |
|
#endif |
|
|
|
@interface FMDatabase () |
|
|
|
- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args; |
|
- (BOOL)executeUpdate:(NSString*)sql error:(NSError**)outErr withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args; |
|
|
|
@end |
|
|
|
@implementation FMDatabase |
|
@synthesize cachedStatements=_cachedStatements; |
|
@synthesize logsErrors=_logsErrors; |
|
@synthesize crashOnErrors=_crashOnErrors; |
|
@synthesize checkedOut=_checkedOut; |
|
@synthesize traceExecution=_traceExecution; |
|
|
|
#pragma mark FMDatabase instantiation and deallocation |
|
|
|
+ (instancetype)databaseWithPath:(NSString*)aPath { |
|
return FMDBReturnAutoreleased([[self alloc] initWithPath:aPath]); |
|
} |
|
|
|
- (instancetype)init { |
|
return [self initWithPath:nil]; |
|
} |
|
|
|
- (instancetype)initWithPath:(NSString*)aPath { |
|
|
|
assert(sqlite3_threadsafe()); // whoa there big boy- gotta make sure sqlite it happy with what we're going to do. |
|
|
|
self = [super init]; |
|
|
|
if (self) { |
|
_databasePath = [aPath copy]; |
|
_openResultSets = [[NSMutableSet alloc] init]; |
|
_db = nil; |
|
_logsErrors = YES; |
|
_crashOnErrors = NO; |
|
_maxBusyRetryTimeInterval = 2; |
|
} |
|
|
|
return self; |
|
} |
|
|
|
#if ! __has_feature(objc_arc) |
|
- (void)finalize { |
|
[self close]; |
|
[super finalize]; |
|
} |
|
#endif |
|
|
|
- (void)dealloc { |
|
[self close]; |
|
FMDBRelease(_openResultSets); |
|
FMDBRelease(_cachedStatements); |
|
FMDBRelease(_dateFormat); |
|
FMDBRelease(_databasePath); |
|
FMDBRelease(_openFunctions); |
|
|
|
#if ! __has_feature(objc_arc) |
|
[super dealloc]; |
|
#endif |
|
} |
|
|
|
- (NSString *)databasePath { |
|
return _databasePath; |
|
} |
|
|
|
+ (NSString*)FMDBUserVersion { |
|
return @"2.6.2"; |
|
} |
|
|
|
// returns 0x0240 for version 2.4. This makes it super easy to do things like: |
|
// /* need to make sure to do X with FMDB version 2.4 or later */ |
|
// if ([FMDatabase FMDBVersion] >= 0x0240) { … } |
|
|
|
+ (SInt32)FMDBVersion { |
|
|
|
// we go through these hoops so that we only have to change the version number in a single spot. |
|
static dispatch_once_t once; |
|
static SInt32 FMDBVersionVal = 0; |
|
|
|
dispatch_once(&once, ^{ |
|
NSString *prodVersion = [self FMDBUserVersion]; |
|
|
|
if ([[prodVersion componentsSeparatedByString:@"."] count] < 3) { |
|
prodVersion = [prodVersion stringByAppendingString:@".0"]; |
|
} |
|
|
|
NSString *junk = [prodVersion stringByReplacingOccurrencesOfString:@"." withString:@""]; |
|
|
|
char *e = nil; |
|
FMDBVersionVal = (int) strtoul([junk UTF8String], &e, 16); |
|
|
|
}); |
|
|
|
return FMDBVersionVal; |
|
} |
|
|
|
#pragma mark SQLite information |
|
|
|
+ (NSString*)sqliteLibVersion { |
|
return [NSString stringWithFormat:@"%s", sqlite3_libversion()]; |
|
} |
|
|
|
+ (BOOL)isSQLiteThreadSafe { |
|
// make sure to read the sqlite headers on this guy! |
|
return sqlite3_threadsafe() != 0; |
|
} |
|
|
|
- (void*)sqliteHandle { |
|
return _db; |
|
} |
|
|
|
- (const char*)sqlitePath { |
|
|
|
if (!_databasePath) { |
|
return ":memory:"; |
|
} |
|
|
|
if ([_databasePath length] == 0) { |
|
return ""; // this creates a temporary database (it's an sqlite thing). |
|
} |
|
|
|
return [_databasePath fileSystemRepresentation]; |
|
|
|
} |
|
|
|
#pragma mark Open and close database |
|
|
|
- (BOOL)open { |
|
if (_db) { |
|
return YES; |
|
} |
|
|
|
int err = sqlite3_open([self sqlitePath], (sqlite3**)&_db ); |
|
if(err != SQLITE_OK) { |
|
NSLog(@"error opening!: %d", err); |
|
return NO; |
|
} |
|
|
|
if (_maxBusyRetryTimeInterval > 0.0) { |
|
// set the handler |
|
[self setMaxBusyRetryTimeInterval:_maxBusyRetryTimeInterval]; |
|
} |
|
|
|
|
|
return YES; |
|
} |
|
|
|
- (BOOL)openWithFlags:(int)flags { |
|
return [self openWithFlags:flags vfs:nil]; |
|
} |
|
- (BOOL)openWithFlags:(int)flags vfs:(NSString *)vfsName { |
|
#if SQLITE_VERSION_NUMBER >= 3005000 |
|
if (_db) { |
|
return YES; |
|
} |
|
|
|
int err = sqlite3_open_v2([self sqlitePath], (sqlite3**)&_db, flags, [vfsName UTF8String]); |
|
if(err != SQLITE_OK) { |
|
NSLog(@"error opening!: %d", err); |
|
return NO; |
|
} |
|
|
|
if (_maxBusyRetryTimeInterval > 0.0) { |
|
// set the handler |
|
[self setMaxBusyRetryTimeInterval:_maxBusyRetryTimeInterval]; |
|
} |
|
|
|
return YES; |
|
#else |
|
NSLog(@"openWithFlags requires SQLite 3.5"); |
|
return NO; |
|
#endif |
|
} |
|
|
|
|
|
- (BOOL)close { |
|
|
|
[self clearCachedStatements]; |
|
[self closeOpenResultSets]; |
|
|
|
if (!_db) { |
|
return YES; |
|
} |
|
|
|
int rc; |
|
BOOL retry; |
|
BOOL triedFinalizingOpenStatements = NO; |
|
|
|
do { |
|
retry = NO; |
|
rc = sqlite3_close(_db); |
|
if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) { |
|
if (!triedFinalizingOpenStatements) { |
|
triedFinalizingOpenStatements = YES; |
|
sqlite3_stmt *pStmt; |
|
while ((pStmt = sqlite3_next_stmt(_db, nil)) !=0) { |
|
NSLog(@"Closing leaked statement"); |
|
sqlite3_finalize(pStmt); |
|
retry = YES; |
|
} |
|
} |
|
} |
|
else if (SQLITE_OK != rc) { |
|
NSLog(@"error closing!: %d", rc); |
|
} |
|
} |
|
while (retry); |
|
|
|
_db = nil; |
|
return YES; |
|
} |
|
|
|
#pragma mark Busy handler routines |
|
|
|
// NOTE: appledoc seems to choke on this function for some reason; |
|
// so when generating documentation, you might want to ignore the |
|
// .m files so that it only documents the public interfaces outlined |
|
// in the .h files. |
|
// |
|
// This is a known appledoc bug that it has problems with C functions |
|
// within a class implementation, but for some reason, only this |
|
// C function causes problems; the rest don't. Anyway, ignoring the .m |
|
// files with appledoc will prevent this problem from occurring. |
|
|
|
static int FMDBDatabaseBusyHandler(void *f, int count) { |
|
FMDatabase *self = (__bridge FMDatabase*)f; |
|
|
|
if (count == 0) { |
|
self->_startBusyRetryTime = [NSDate timeIntervalSinceReferenceDate]; |
|
return 1; |
|
} |
|
|
|
NSTimeInterval delta = [NSDate timeIntervalSinceReferenceDate] - (self->_startBusyRetryTime); |
|
|
|
if (delta < [self maxBusyRetryTimeInterval]) { |
|
int requestedSleepInMillseconds = (int) arc4random_uniform(50) + 50; |
|
int actualSleepInMilliseconds = sqlite3_sleep(requestedSleepInMillseconds); |
|
if (actualSleepInMilliseconds != requestedSleepInMillseconds) { |
|
NSLog(@"WARNING: Requested sleep of %i milliseconds, but SQLite returned %i. Maybe SQLite wasn't built with HAVE_USLEEP=1?", requestedSleepInMillseconds, actualSleepInMilliseconds); |
|
} |
|
return 1; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
- (void)setMaxBusyRetryTimeInterval:(NSTimeInterval)timeout { |
|
|
|
_maxBusyRetryTimeInterval = timeout; |
|
|
|
if (!_db) { |
|
return; |
|
} |
|
|
|
if (timeout > 0) { |
|
sqlite3_busy_handler(_db, &FMDBDatabaseBusyHandler, (__bridge void *)(self)); |
|
} |
|
else { |
|
// turn it off otherwise |
|
sqlite3_busy_handler(_db, nil, nil); |
|
} |
|
} |
|
|
|
- (NSTimeInterval)maxBusyRetryTimeInterval { |
|
return _maxBusyRetryTimeInterval; |
|
} |
|
|
|
|
|
// we no longer make busyRetryTimeout public |
|
// but for folks who don't bother noticing that the interface to FMDatabase changed, |
|
// we'll still implement the method so they don't get suprise crashes |
|
- (int)busyRetryTimeout { |
|
NSLog(@"%s:%d", __FUNCTION__, __LINE__); |
|
NSLog(@"FMDB: busyRetryTimeout no longer works, please use maxBusyRetryTimeInterval"); |
|
return -1; |
|
} |
|
|
|
- (void)setBusyRetryTimeout:(int)i { |
|
#pragma unused(i) |
|
NSLog(@"%s:%d", __FUNCTION__, __LINE__); |
|
NSLog(@"FMDB: setBusyRetryTimeout does nothing, please use setMaxBusyRetryTimeInterval:"); |
|
} |
|
|
|
#pragma mark Result set functions |
|
|
|
- (BOOL)hasOpenResultSets { |
|
return [_openResultSets count] > 0; |
|
} |
|
|
|
- (void)closeOpenResultSets { |
|
|
|
//Copy the set so we don't get mutation errors |
|
NSSet *openSetCopy = FMDBReturnAutoreleased([_openResultSets copy]); |
|
for (NSValue *rsInWrappedInATastyValueMeal in openSetCopy) { |
|
FMResultSet *rs = (FMResultSet *)[rsInWrappedInATastyValueMeal pointerValue]; |
|
|
|
[rs setParentDB:nil]; |
|
[rs close]; |
|
|
|
[_openResultSets removeObject:rsInWrappedInATastyValueMeal]; |
|
} |
|
} |
|
|
|
- (void)resultSetDidClose:(FMResultSet *)resultSet { |
|
NSValue *setValue = [NSValue valueWithNonretainedObject:resultSet]; |
|
|
|
[_openResultSets removeObject:setValue]; |
|
} |
|
|
|
#pragma mark Cached statements |
|
|
|
- (void)clearCachedStatements { |
|
|
|
for (NSMutableSet *statements in [_cachedStatements objectEnumerator]) { |
|
for (FMStatement *statement in [statements allObjects]) { |
|
[statement close]; |
|
} |
|
} |
|
|
|
[_cachedStatements removeAllObjects]; |
|
} |
|
|
|
- (FMStatement*)cachedStatementForQuery:(NSString*)query { |
|
|
|
NSMutableSet* statements = [_cachedStatements objectForKey:query]; |
|
|
|
return [[statements objectsPassingTest:^BOOL(FMStatement* statement, BOOL *stop) { |
|
|
|
*stop = ![statement inUse]; |
|
return *stop; |
|
|
|
}] anyObject]; |
|
} |
|
|
|
|
|
- (void)setCachedStatement:(FMStatement*)statement forQuery:(NSString*)query { |
|
|
|
query = [query copy]; // in case we got handed in a mutable string... |
|
[statement setQuery:query]; |
|
|
|
NSMutableSet* statements = [_cachedStatements objectForKey:query]; |
|
if (!statements) { |
|
statements = [NSMutableSet set]; |
|
} |
|
|
|
[statements addObject:statement]; |
|
|
|
[_cachedStatements setObject:statements forKey:query]; |
|
|
|
FMDBRelease(query); |
|
} |
|
|
|
#pragma mark Key routines |
|
|
|
- (BOOL)rekey:(NSString*)key { |
|
NSData *keyData = [NSData dataWithBytes:(void *)[key UTF8String] length:(NSUInteger)strlen([key UTF8String])]; |
|
|
|
return [self rekeyWithData:keyData]; |
|
} |
|
|
|
- (BOOL)rekeyWithData:(NSData *)keyData { |
|
#ifdef SQLITE_HAS_CODEC |
|
if (!keyData) { |
|
return NO; |
|
} |
|
|
|
int rc = sqlite3_rekey(_db, [keyData bytes], (int)[keyData length]); |
|
|
|
if (rc != SQLITE_OK) { |
|
NSLog(@"error on rekey: %d", rc); |
|
NSLog(@"%@", [self lastErrorMessage]); |
|
} |
|
|
|
return (rc == SQLITE_OK); |
|
#else |
|
#pragma unused(keyData) |
|
return NO; |
|
#endif |
|
} |
|
|
|
- (BOOL)setKey:(NSString*)key { |
|
NSData *keyData = [NSData dataWithBytes:[key UTF8String] length:(NSUInteger)strlen([key UTF8String])]; |
|
|
|
return [self setKeyWithData:keyData]; |
|
} |
|
|
|
- (BOOL)setKeyWithData:(NSData *)keyData { |
|
#ifdef SQLITE_HAS_CODEC |
|
if (!keyData) { |
|
return NO; |
|
} |
|
|
|
int rc = sqlite3_key(_db, [keyData bytes], (int)[keyData length]); |
|
|
|
return (rc == SQLITE_OK); |
|
#else |
|
#pragma unused(keyData) |
|
return NO; |
|
#endif |
|
} |
|
|
|
#pragma mark Date routines |
|
|
|
+ (NSDateFormatter *)storeableDateFormat:(NSString *)format { |
|
|
|
NSDateFormatter *result = FMDBReturnAutoreleased([[NSDateFormatter alloc] init]); |
|
result.dateFormat = format; |
|
result.timeZone = [NSTimeZone timeZoneForSecondsFromGMT:0]; |
|
result.locale = FMDBReturnAutoreleased([[NSLocale alloc] initWithLocaleIdentifier:@"en_US"]); |
|
return result; |
|
} |
|
|
|
|
|
- (BOOL)hasDateFormatter { |
|
return _dateFormat != nil; |
|
} |
|
|
|
- (void)setDateFormat:(NSDateFormatter *)format { |
|
FMDBAutorelease(_dateFormat); |
|
_dateFormat = FMDBReturnRetained(format); |
|
} |
|
|
|
- (NSDate *)dateFromString:(NSString *)s { |
|
return [_dateFormat dateFromString:s]; |
|
} |
|
|
|
- (NSString *)stringFromDate:(NSDate *)date { |
|
return [_dateFormat stringFromDate:date]; |
|
} |
|
|
|
#pragma mark State of database |
|
|
|
- (BOOL)goodConnection { |
|
|
|
if (!_db) { |
|
return NO; |
|
} |
|
|
|
FMResultSet *rs = [self executeQuery:@"select name from sqlite_master where type='table'"]; |
|
|
|
if (rs) { |
|
[rs close]; |
|
return YES; |
|
} |
|
|
|
return NO; |
|
} |
|
|
|
- (void)warnInUse { |
|
NSLog(@"The FMDatabase %@ is currently in use.", self); |
|
|
|
#ifndef NS_BLOCK_ASSERTIONS |
|
if (_crashOnErrors) { |
|
NSAssert(false, @"The FMDatabase %@ is currently in use.", self); |
|
abort(); |
|
} |
|
#endif |
|
} |
|
|
|
- (BOOL)databaseExists { |
|
|
|
if (!_db) { |
|
|
|
NSLog(@"The FMDatabase %@ is not open.", self); |
|
|
|
#ifndef NS_BLOCK_ASSERTIONS |
|
if (_crashOnErrors) { |
|
NSAssert(false, @"The FMDatabase %@ is not open.", self); |
|
abort(); |
|
} |
|
#endif |
|
|
|
return NO; |
|
} |
|
|
|
return YES; |
|
} |
|
|
|
#pragma mark Error routines |
|
|
|
- (NSString*)lastErrorMessage { |
|
return [NSString stringWithUTF8String:sqlite3_errmsg(_db)]; |
|
} |
|
|
|
- (BOOL)hadError { |
|
int lastErrCode = [self lastErrorCode]; |
|
|
|
return (lastErrCode > SQLITE_OK && lastErrCode < SQLITE_ROW); |
|
} |
|
|
|
- (int)lastErrorCode { |
|
return sqlite3_errcode(_db); |
|
} |
|
|
|
- (int)lastExtendedErrorCode { |
|
return sqlite3_extended_errcode(_db); |
|
} |
|
|
|
- (NSError*)errorWithMessage:(NSString*)message { |
|
NSDictionary* errorMessage = [NSDictionary dictionaryWithObject:message forKey:NSLocalizedDescriptionKey]; |
|
|
|
return [NSError errorWithDomain:@"FMDatabase" code:sqlite3_errcode(_db) userInfo:errorMessage]; |
|
} |
|
|
|
- (NSError*)lastError { |
|
return [self errorWithMessage:[self lastErrorMessage]]; |
|
} |
|
|
|
#pragma mark Update information routines |
|
|
|
- (sqlite_int64)lastInsertRowId { |
|
|
|
if (_isExecutingStatement) { |
|
[self warnInUse]; |
|
return NO; |
|
} |
|
|
|
_isExecutingStatement = YES; |
|
|
|
sqlite_int64 ret = sqlite3_last_insert_rowid(_db); |
|
|
|
_isExecutingStatement = NO; |
|
|
|
return ret; |
|
} |
|
|
|
- (int)changes { |
|
if (_isExecutingStatement) { |
|
[self warnInUse]; |
|
return 0; |
|
} |
|
|
|
_isExecutingStatement = YES; |
|
|
|
int ret = sqlite3_changes(_db); |
|
|
|
_isExecutingStatement = NO; |
|
|
|
return ret; |
|
} |
|
|
|
#pragma mark SQL manipulation |
|
|
|
- (void)bindObject:(id)obj toColumn:(int)idx inStatement:(sqlite3_stmt*)pStmt { |
|
|
|
if ((!obj) || ((NSNull *)obj == [NSNull null])) { |
|
sqlite3_bind_null(pStmt, idx); |
|
} |
|
|
|
// FIXME - someday check the return codes on these binds. |
|
else if ([obj isKindOfClass:[NSData class]]) { |
|
const void *bytes = [obj bytes]; |
|
if (!bytes) { |
|
// it's an empty NSData object, aka [NSData data]. |
|
// Don't pass a NULL pointer, or sqlite will bind a SQL null instead of a blob. |
|
bytes = ""; |
|
} |
|
sqlite3_bind_blob(pStmt, idx, bytes, (int)[obj length], SQLITE_STATIC); |
|
} |
|
else if ([obj isKindOfClass:[NSDate class]]) { |
|
if (self.hasDateFormatter) |
|
sqlite3_bind_text(pStmt, idx, [[self stringFromDate:obj] UTF8String], -1, SQLITE_STATIC); |
|
else |
|
sqlite3_bind_double(pStmt, idx, [obj timeIntervalSince1970]); |
|
} |
|
else if ([obj isKindOfClass:[NSNumber class]]) { |
|
|
|
if (strcmp([obj objCType], @encode(char)) == 0) { |
|
sqlite3_bind_int(pStmt, idx, [obj charValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(unsigned char)) == 0) { |
|
sqlite3_bind_int(pStmt, idx, [obj unsignedCharValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(short)) == 0) { |
|
sqlite3_bind_int(pStmt, idx, [obj shortValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(unsigned short)) == 0) { |
|
sqlite3_bind_int(pStmt, idx, [obj unsignedShortValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(int)) == 0) { |
|
sqlite3_bind_int(pStmt, idx, [obj intValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(unsigned int)) == 0) { |
|
sqlite3_bind_int64(pStmt, idx, (long long)[obj unsignedIntValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(long)) == 0) { |
|
sqlite3_bind_int64(pStmt, idx, [obj longValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(unsigned long)) == 0) { |
|
sqlite3_bind_int64(pStmt, idx, (long long)[obj unsignedLongValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(long long)) == 0) { |
|
sqlite3_bind_int64(pStmt, idx, [obj longLongValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(unsigned long long)) == 0) { |
|
sqlite3_bind_int64(pStmt, idx, (long long)[obj unsignedLongLongValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(float)) == 0) { |
|
sqlite3_bind_double(pStmt, idx, [obj floatValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(double)) == 0) { |
|
sqlite3_bind_double(pStmt, idx, [obj doubleValue]); |
|
} |
|
else if (strcmp([obj objCType], @encode(BOOL)) == 0) { |
|
sqlite3_bind_int(pStmt, idx, ([obj boolValue] ? 1 : 0)); |
|
} |
|
else { |
|
sqlite3_bind_text(pStmt, idx, [[obj description] UTF8String], -1, SQLITE_STATIC); |
|
} |
|
} |
|
else { |
|
sqlite3_bind_text(pStmt, idx, [[obj description] UTF8String], -1, SQLITE_STATIC); |
|
} |
|
} |
|
|
|
- (void)extractSQL:(NSString *)sql argumentsList:(va_list)args intoString:(NSMutableString *)cleanedSQL arguments:(NSMutableArray *)arguments { |
|
|
|
NSUInteger length = [sql length]; |
|
unichar last = '\0'; |
|
for (NSUInteger i = 0; i < length; ++i) { |
|
id arg = nil; |
|
unichar current = [sql characterAtIndex:i]; |
|
unichar add = current; |
|
if (last == '%') { |
|
switch (current) { |
|
case '@': |
|
arg = va_arg(args, id); |
|
break; |
|
case 'c': |
|
// warning: second argument to 'va_arg' is of promotable type 'char'; this va_arg has undefined behavior because arguments will be promoted to 'int' |
|
arg = [NSString stringWithFormat:@"%c", va_arg(args, int)]; |
|
break; |
|
case 's': |
|
arg = [NSString stringWithUTF8String:va_arg(args, char*)]; |
|
break; |
|
case 'd': |
|
case 'D': |
|
case 'i': |
|
arg = [NSNumber numberWithInt:va_arg(args, int)]; |
|
break; |
|
case 'u': |
|
case 'U': |
|
arg = [NSNumber numberWithUnsignedInt:va_arg(args, unsigned int)]; |
|
break; |
|
case 'h': |
|
i++; |
|
if (i < length && [sql characterAtIndex:i] == 'i') { |
|
// warning: second argument to 'va_arg' is of promotable type 'short'; this va_arg has undefined behavior because arguments will be promoted to 'int' |
|
arg = [NSNumber numberWithShort:(short)(va_arg(args, int))]; |
|
} |
|
else if (i < length && [sql characterAtIndex:i] == 'u') { |
|
// warning: second argument to 'va_arg' is of promotable type 'unsigned short'; this va_arg has undefined behavior because arguments will be promoted to 'int' |
|
arg = [NSNumber numberWithUnsignedShort:(unsigned short)(va_arg(args, uint))]; |
|
} |
|
else { |
|
i--; |
|
} |
|
break; |
|
case 'q': |
|
i++; |
|
if (i < length && [sql characterAtIndex:i] == 'i') { |
|
arg = [NSNumber numberWithLongLong:va_arg(args, long long)]; |
|
} |
|
else if (i < length && [sql characterAtIndex:i] == 'u') { |
|
arg = [NSNumber numberWithUnsignedLongLong:va_arg(args, unsigned long long)]; |
|
} |
|
else { |
|
i--; |
|
} |
|
break; |
|
case 'f': |
|
arg = [NSNumber numberWithDouble:va_arg(args, double)]; |
|
break; |
|
case 'g': |
|
// warning: second argument to 'va_arg' is of promotable type 'float'; this va_arg has undefined behavior because arguments will be promoted to 'double' |
|
arg = [NSNumber numberWithFloat:(float)(va_arg(args, double))]; |
|
break; |
|
case 'l': |
|
i++; |
|
if (i < length) { |
|
unichar next = [sql characterAtIndex:i]; |
|
if (next == 'l') { |
|
i++; |
|
if (i < length && [sql characterAtIndex:i] == 'd') { |
|
//%lld |
|
arg = [NSNumber numberWithLongLong:va_arg(args, long long)]; |
|
} |
|
else if (i < length && [sql characterAtIndex:i] == 'u') { |
|
//%llu |
|
arg = [NSNumber numberWithUnsignedLongLong:va_arg(args, unsigned long long)]; |
|
} |
|
else { |
|
i--; |
|
} |
|
} |
|
else if (next == 'd') { |
|
//%ld |
|
arg = [NSNumber numberWithLong:va_arg(args, long)]; |
|
} |
|
else if (next == 'u') { |
|
//%lu |
|
arg = [NSNumber numberWithUnsignedLong:va_arg(args, unsigned long)]; |
|
} |
|
else { |
|
i--; |
|
} |
|
} |
|
else { |
|
i--; |
|
} |
|
break; |
|
default: |
|
// something else that we can't interpret. just pass it on through like normal |
|
break; |
|
} |
|
} |
|
else if (current == '%') { |
|
// percent sign; skip this character |
|
add = '\0'; |
|
} |
|
|
|
if (arg != nil) { |
|
[cleanedSQL appendString:@"?"]; |
|
[arguments addObject:arg]; |
|
} |
|
else if (add == (unichar)'@' && last == (unichar) '%') { |
|
[cleanedSQL appendFormat:@"NULL"]; |
|
} |
|
else if (add != '\0') { |
|
[cleanedSQL appendFormat:@"%C", add]; |
|
} |
|
last = current; |
|
} |
|
} |
|
|
|
#pragma mark Execute queries |
|
|
|
- (FMResultSet *)executeQuery:(NSString *)sql withParameterDictionary:(NSDictionary *)arguments { |
|
return [self executeQuery:sql withArgumentsInArray:nil orDictionary:arguments orVAList:nil]; |
|
} |
|
|
|
- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args { |
|
|
|
if (![self databaseExists]) { |
|
return 0x00; |
|
} |
|
|
|
if (_isExecutingStatement) { |
|
[self warnInUse]; |
|
return 0x00; |
|
} |
|
|
|
_isExecutingStatement = YES; |
|
|
|
int rc = 0x00; |
|
sqlite3_stmt *pStmt = 0x00; |
|
FMStatement *statement = 0x00; |
|
FMResultSet *rs = 0x00; |
|
|
|
if (_traceExecution && sql) { |
|
NSLog(@"%@ executeQuery: %@", self, sql); |
|
} |
|
|
|
if (_shouldCacheStatements) { |
|
statement = [self cachedStatementForQuery:sql]; |
|
pStmt = statement ? [statement statement] : 0x00; |
|
[statement reset]; |
|
} |
|
|
|
if (!pStmt) { |
|
|
|
rc = sqlite3_prepare_v2(_db, [sql UTF8String], -1, &pStmt, 0); |
|
|
|
if (SQLITE_OK != rc) { |
|
if (_logsErrors) { |
|
NSLog(@"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); |
|
NSLog(@"DB Query: %@", sql); |
|
NSLog(@"DB Path: %@", _databasePath); |
|
} |
|
|
|
if (_crashOnErrors) { |
|
NSAssert(false, @"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); |
|
abort(); |
|
} |
|
|
|
sqlite3_finalize(pStmt); |
|
_isExecutingStatement = NO; |
|
return nil; |
|
} |
|
} |
|
|
|
id obj; |
|
int idx = 0; |
|
int queryCount = sqlite3_bind_parameter_count(pStmt); // pointed out by Dominic Yu (thanks!) |
|
|
|
// If dictionaryArgs is passed in, that means we are using sqlite's named parameter support |
|
if (dictionaryArgs) { |
|
|
|
for (NSString *dictionaryKey in [dictionaryArgs allKeys]) { |
|
|
|
// Prefix the key with a colon. |
|
NSString *parameterName = [[NSString alloc] initWithFormat:@":%@", dictionaryKey]; |
|
|
|
if (_traceExecution) { |
|
NSLog(@"%@ = %@", parameterName, [dictionaryArgs objectForKey:dictionaryKey]); |
|
} |
|
|
|
// Get the index for the parameter name. |
|
int namedIdx = sqlite3_bind_parameter_index(pStmt, [parameterName UTF8String]); |
|
|
|
FMDBRelease(parameterName); |
|
|
|
if (namedIdx > 0) { |
|
// Standard binding from here. |
|
[self bindObject:[dictionaryArgs objectForKey:dictionaryKey] toColumn:namedIdx inStatement:pStmt]; |
|
// increment the binding count, so our check below works out |
|
idx++; |
|
} |
|
else { |
|
NSLog(@"Could not find index for %@", dictionaryKey); |
|
} |
|
} |
|
} |
|
else { |
|
|
|
while (idx < queryCount) { |
|
|
|
if (arrayArgs && idx < (int)[arrayArgs count]) { |
|
obj = [arrayArgs objectAtIndex:(NSUInteger)idx]; |
|
} |
|
else if (args) { |
|
obj = va_arg(args, id); |
|
} |
|
else { |
|
//We ran out of arguments |
|
break; |
|
} |
|
|
|
if (_traceExecution) { |
|
if ([obj isKindOfClass:[NSData class]]) { |
|
NSLog(@"data: %ld bytes", (unsigned long)[(NSData*)obj length]); |
|
} |
|
else { |
|
NSLog(@"obj: %@", obj); |
|
} |
|
} |
|
|
|
idx++; |
|
|
|
[self bindObject:obj toColumn:idx inStatement:pStmt]; |
|
} |
|
} |
|
|
|
if (idx != queryCount) { |
|
NSLog(@"Error: the bind count is not correct for the # of variables (executeQuery)"); |
|
sqlite3_finalize(pStmt); |
|
_isExecutingStatement = NO; |
|
return nil; |
|
} |
|
|
|
FMDBRetain(statement); // to balance the release below |
|
|
|
if (!statement) { |
|
statement = [[FMStatement alloc] init]; |
|
[statement setStatement:pStmt]; |
|
|
|
if (_shouldCacheStatements && sql) { |
|
[self setCachedStatement:statement forQuery:sql]; |
|
} |
|
} |
|
|
|
// the statement gets closed in rs's dealloc or [rs close]; |
|
rs = [FMResultSet resultSetWithStatement:statement usingParentDatabase:self]; |
|
[rs setQuery:sql]; |
|
|
|
NSValue *openResultSet = [NSValue valueWithNonretainedObject:rs]; |
|
[_openResultSets addObject:openResultSet]; |
|
|
|
[statement setUseCount:[statement useCount] + 1]; |
|
|
|
FMDBRelease(statement); |
|
|
|
_isExecutingStatement = NO; |
|
|
|
return rs; |
|
} |
|
|
|
- (FMResultSet *)executeQuery:(NSString*)sql, ... { |
|
va_list args; |
|
va_start(args, sql); |
|
|
|
id result = [self executeQuery:sql withArgumentsInArray:nil orDictionary:nil orVAList:args]; |
|
|
|
va_end(args); |
|
return result; |
|
} |
|
|
|
- (FMResultSet *)executeQueryWithFormat:(NSString*)format, ... { |
|
va_list args; |
|
va_start(args, format); |
|
|
|
NSMutableString *sql = [NSMutableString stringWithCapacity:[format length]]; |
|
NSMutableArray *arguments = [NSMutableArray array]; |
|
[self extractSQL:format argumentsList:args intoString:sql arguments:arguments]; |
|
|
|
va_end(args); |
|
|
|
return [self executeQuery:sql withArgumentsInArray:arguments]; |
|
} |
|
|
|
- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments { |
|
return [self executeQuery:sql withArgumentsInArray:arguments orDictionary:nil orVAList:nil]; |
|
} |
|
|
|
- (FMResultSet *)executeQuery:(NSString *)sql values:(NSArray *)values error:(NSError * __autoreleasing *)error { |
|
FMResultSet *rs = [self executeQuery:sql withArgumentsInArray:values orDictionary:nil orVAList:nil]; |
|
if (!rs && error) { |
|
*error = [self lastError]; |
|
} |
|
return rs; |
|
} |
|
|
|
- (FMResultSet *)executeQuery:(NSString*)sql withVAList:(va_list)args { |
|
return [self executeQuery:sql withArgumentsInArray:nil orDictionary:nil orVAList:args]; |
|
} |
|
|
|
#pragma mark Execute updates |
|
|
|
- (BOOL)executeUpdate:(NSString*)sql error:(NSError**)outErr withArgumentsInArray:(NSArray*)arrayArgs orDictionary:(NSDictionary *)dictionaryArgs orVAList:(va_list)args { |
|
|
|
if (![self databaseExists]) { |
|
return NO; |
|
} |
|
|
|
if (_isExecutingStatement) { |
|
[self warnInUse]; |
|
return NO; |
|
} |
|
|
|
_isExecutingStatement = YES; |
|
|
|
int rc = 0x00; |
|
sqlite3_stmt *pStmt = 0x00; |
|
FMStatement *cachedStmt = 0x00; |
|
|
|
if (_traceExecution && sql) { |
|
NSLog(@"%@ executeUpdate: %@", self, sql); |
|
} |
|
|
|
if (_shouldCacheStatements) { |
|
cachedStmt = [self cachedStatementForQuery:sql]; |
|
pStmt = cachedStmt ? [cachedStmt statement] : 0x00; |
|
[cachedStmt reset]; |
|
} |
|
|
|
if (!pStmt) { |
|
rc = sqlite3_prepare_v2(_db, [sql UTF8String], -1, &pStmt, 0); |
|
|
|
if (SQLITE_OK != rc) { |
|
if (_logsErrors) { |
|
NSLog(@"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); |
|
NSLog(@"DB Query: %@", sql); |
|
NSLog(@"DB Path: %@", _databasePath); |
|
} |
|
|
|
if (_crashOnErrors) { |
|
NSAssert(false, @"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]); |
|
abort(); |
|
} |
|
|
|
if (outErr) { |
|
*outErr = [self errorWithMessage:[NSString stringWithUTF8String:sqlite3_errmsg(_db)]]; |
|
} |
|
|
|
sqlite3_finalize(pStmt); |
|
|
|
_isExecutingStatement = NO; |
|
return NO; |
|
} |
|
} |
|
|
|
id obj; |
|
int idx = 0; |
|
int queryCount = sqlite3_bind_parameter_count(pStmt); |
|
|
|
// If dictionaryArgs is passed in, that means we are using sqlite's named parameter support |
|
if (dictionaryArgs) { |
|
|
|
for (NSString *dictionaryKey in [dictionaryArgs allKeys]) { |
|
|
|
// Prefix the key with a colon. |
|
NSString *parameterName = [[NSString alloc] initWithFormat:@":%@", dictionaryKey]; |
|
|
|
if (_traceExecution) { |
|
NSLog(@"%@ = %@", parameterName, [dictionaryArgs objectForKey:dictionaryKey]); |
|
} |
|
// Get the index for the parameter name. |
|
int namedIdx = sqlite3_bind_parameter_index(pStmt, [parameterName UTF8String]); |
|
|
|
FMDBRelease(parameterName); |
|
|
|
if (namedIdx > 0) { |
|
// Standard binding from here. |
|
[self bindObject:[dictionaryArgs objectForKey:dictionaryKey] toColumn:namedIdx inStatement:pStmt]; |
|
|
|
// increment the binding count, so our check below works out |
|
idx++; |
|
} |
|
else { |
|
NSString *message = [NSString stringWithFormat:@"Could not find index for %@", dictionaryKey]; |
|
|
|
if (_logsErrors) { |
|
NSLog(@"%@", message); |
|
} |
|
if (outErr) { |
|
*outErr = [self errorWithMessage:message]; |
|
} |
|
} |
|
} |
|
} |
|
else { |
|
|
|
while (idx < queryCount) { |
|
|
|
if (arrayArgs && idx < (int)[arrayArgs count]) { |
|
obj = [arrayArgs objectAtIndex:(NSUInteger)idx]; |
|
} |
|
else if (args) { |
|
obj = va_arg(args, id); |
|
} |
|
else { |
|
//We ran out of arguments |
|
break; |
|
} |
|
|
|
if (_traceExecution) { |
|
if ([obj isKindOfClass:[NSData class]]) { |
|
NSLog(@"data: %ld bytes", (unsigned long)[(NSData*)obj length]); |
|
} |
|
else { |
|
NSLog(@"obj: %@", obj); |
|
} |
|
} |
|
|
|
idx++; |
|
|
|
[self bindObject:obj toColumn:idx inStatement:pStmt]; |
|
} |
|
} |
|
|
|
|
|
if (idx != queryCount) { |
|
NSString *message = [NSString stringWithFormat:@"Error: the bind count (%d) is not correct for the # of variables in the query (%d) (%@) (executeUpdate)", idx, queryCount, sql]; |
|
if (_logsErrors) { |
|
NSLog(@"%@", message); |
|
} |
|
if (outErr) { |
|
*outErr = [self errorWithMessage:message]; |
|
} |
|
|
|
sqlite3_finalize(pStmt); |
|
_isExecutingStatement = NO; |
|
return NO; |
|
} |
|
|
|
/* Call sqlite3_step() to run the virtual machine. Since the SQL being |
|
** executed is not a SELECT statement, we assume no data will be returned. |
|
*/ |
|
|
|
rc = sqlite3_step(pStmt); |
|
|
|
if (SQLITE_DONE == rc) { |
|
// all is well, let's return. |
|
} |
|
else if (SQLITE_INTERRUPT == rc) { |
|
if (_logsErrors) { |
|
NSLog(@"Error calling sqlite3_step. Query was interrupted (%d: %s) SQLITE_INTERRUPT", rc, sqlite3_errmsg(_db)); |
|
NSLog(@"DB Query: %@", sql); |
|
} |
|
} |
|
else if (rc == SQLITE_ROW) { |
|
NSString *message = [NSString stringWithFormat:@"A executeUpdate is being called with a query string '%@'", sql]; |
|
if (_logsErrors) { |
|
NSLog(@"%@", message); |
|
NSLog(@"DB Query: %@", sql); |
|
} |
|
if (outErr) { |
|
*outErr = [self errorWithMessage:message]; |
|
} |
|
} |
|
else { |
|
if (outErr) { |
|
*outErr = [self errorWithMessage:[NSString stringWithUTF8String:sqlite3_errmsg(_db)]]; |
|
} |
|
|
|
if (SQLITE_ERROR == rc) { |
|
if (_logsErrors) { |
|
NSLog(@"Error calling sqlite3_step (%d: %s) SQLITE_ERROR", rc, sqlite3_errmsg(_db)); |
|
NSLog(@"DB Query: %@", sql); |
|
} |
|
} |
|
else if (SQLITE_MISUSE == rc) { |
|
// uh oh. |
|
if (_logsErrors) { |
|
NSLog(@"Error calling sqlite3_step (%d: %s) SQLITE_MISUSE", rc, sqlite3_errmsg(_db)); |
|
NSLog(@"DB Query: %@", sql); |
|
} |
|
} |
|
else { |
|
// wtf? |
|
if (_logsErrors) { |
|
NSLog(@"Unknown error calling sqlite3_step (%d: %s) eu", rc, sqlite3_errmsg(_db)); |
|
NSLog(@"DB Query: %@", sql); |
|
} |
|
} |
|
} |
|
|
|
if (_shouldCacheStatements && !cachedStmt) { |
|
cachedStmt = [[FMStatement alloc] init]; |
|
|
|
[cachedStmt setStatement:pStmt]; |
|
|
|
[self setCachedStatement:cachedStmt forQuery:sql]; |
|
|
|
FMDBRelease(cachedStmt); |
|
} |
|
|
|
int closeErrorCode; |
|
|
|
if (cachedStmt) { |
|
[cachedStmt setUseCount:[cachedStmt useCount] + 1]; |
|
closeErrorCode = sqlite3_reset(pStmt); |
|
} |
|
else { |
|
/* Finalize the virtual machine. This releases all memory and other |
|
** resources allocated by the sqlite3_prepare() call above. |
|
*/ |
|
closeErrorCode = sqlite3_finalize(pStmt); |
|
} |
|
|
|
if (closeErrorCode != SQLITE_OK) { |
|
if (_logsErrors) { |
|
NSLog(@"Unknown error finalizing or resetting statement (%d: %s)", closeErrorCode, sqlite3_errmsg(_db)); |
|
NSLog(@"DB Query: %@", sql); |
|
} |
|
} |
|
|
|
_isExecutingStatement = NO; |
|
return (rc == SQLITE_DONE || rc == SQLITE_OK); |
|
} |
|
|
|
|
|
- (BOOL)executeUpdate:(NSString*)sql, ... { |
|
va_list args; |
|
va_start(args, sql); |
|
|
|
BOOL result = [self executeUpdate:sql error:nil withArgumentsInArray:nil orDictionary:nil orVAList:args]; |
|
|
|
va_end(args); |
|
return result; |
|
} |
|
|
|
- (BOOL)executeUpdate:(NSString*)sql withArgumentsInArray:(NSArray *)arguments { |
|
return [self executeUpdate:sql error:nil withArgumentsInArray:arguments orDictionary:nil orVAList:nil]; |
|
} |
|
|
|
- (BOOL)executeUpdate:(NSString*)sql values:(NSArray *)values error:(NSError * __autoreleasing *)error { |
|
return [self executeUpdate:sql error:error withArgumentsInArray:values orDictionary:nil orVAList:nil]; |
|
} |
|
|
|
- (BOOL)executeUpdate:(NSString*)sql withParameterDictionary:(NSDictionary *)arguments { |
|
return [self executeUpdate:sql error:nil withArgumentsInArray:nil orDictionary:arguments orVAList:nil]; |
|
} |
|
|
|
- (BOOL)executeUpdate:(NSString*)sql withVAList:(va_list)args { |
|
return [self executeUpdate:sql error:nil withArgumentsInArray:nil orDictionary:nil orVAList:args]; |
|
} |
|
|
|
- (BOOL)executeUpdateWithFormat:(NSString*)format, ... { |
|
va_list args; |
|
va_start(args, format); |
|
|
|
NSMutableString *sql = [NSMutableString stringWithCapacity:[format length]]; |
|
NSMutableArray *arguments = [NSMutableArray array]; |
|
|
|
[self extractSQL:format argumentsList:args intoString:sql arguments:arguments]; |
|
|
|
va_end(args); |
|
|
|
return [self executeUpdate:sql withArgumentsInArray:arguments]; |
|
} |
|
|
|
|
|
int FMDBExecuteBulkSQLCallback(void *theBlockAsVoid, int columns, char **values, char **names); // shhh clang. |
|
int FMDBExecuteBulkSQLCallback(void *theBlockAsVoid, int columns, char **values, char **names) { |
|
|
|
if (!theBlockAsVoid) { |
|
return SQLITE_OK; |
|
} |
|
|
|
int (^execCallbackBlock)(NSDictionary *resultsDictionary) = (__bridge int (^)(NSDictionary *__strong))(theBlockAsVoid); |
|
|
|
NSMutableDictionary *dictionary = [NSMutableDictionary dictionaryWithCapacity:(NSUInteger)columns]; |
|
|
|
for (NSInteger i = 0; i < columns; i++) { |
|
NSString *key = [NSString stringWithUTF8String:names[i]]; |
|
id value = values[i] ? [NSString stringWithUTF8String:values[i]] : [NSNull null]; |
|
[dictionary setObject:value forKey:key]; |
|
} |
|
|
|
return execCallbackBlock(dictionary); |
|
} |
|
|
|
- (BOOL)executeStatements:(NSString *)sql { |
|
return [self executeStatements:sql withResultBlock:nil]; |
|
} |
|
|
|
- (BOOL)executeStatements:(NSString *)sql withResultBlock:(FMDBExecuteStatementsCallbackBlock)block { |
|
|
|
int rc; |
|
char *errmsg = nil; |
|
|
|
rc = sqlite3_exec([self sqliteHandle], [sql UTF8String], block ? FMDBExecuteBulkSQLCallback : nil, (__bridge void *)(block), &errmsg); |
|
|
|
if (errmsg && [self logsErrors]) { |
|
NSLog(@"Error inserting batch: %s", errmsg); |
|
sqlite3_free(errmsg); |
|
} |
|
|
|
return (rc == SQLITE_OK); |
|
} |
|
|
|
- (BOOL)executeUpdate:(NSString*)sql withErrorAndBindings:(NSError**)outErr, ... { |
|
|
|
va_list args; |
|
va_start(args, outErr); |
|
|
|
BOOL result = [self executeUpdate:sql error:outErr withArgumentsInArray:nil orDictionary:nil orVAList:args]; |
|
|
|
va_end(args); |
|
return result; |
|
} |
|
|
|
|
|
#pragma clang diagnostic push |
|
#pragma clang diagnostic ignored "-Wdeprecated-implementations" |
|
- (BOOL)update:(NSString*)sql withErrorAndBindings:(NSError**)outErr, ... { |
|
va_list args; |
|
va_start(args, outErr); |
|
|
|
BOOL result = [self executeUpdate:sql error:outErr withArgumentsInArray:nil orDictionary:nil orVAList:args]; |
|
|
|
va_end(args); |
|
return result; |
|
} |
|
|
|
#pragma clang diagnostic pop |
|
|
|
#pragma mark Transactions |
|
|
|
- (BOOL)rollback { |
|
BOOL b = [self executeUpdate:@"rollback transaction"]; |
|
|
|
if (b) { |
|
_inTransaction = NO; |
|
} |
|
|
|
return b; |
|
} |
|
|
|
- (BOOL)commit { |
|
BOOL b = [self executeUpdate:@"commit transaction"]; |
|
|
|
if (b) { |
|
_inTransaction = NO; |
|
} |
|
|
|
return b; |
|
} |
|
|
|
- (BOOL)beginDeferredTransaction { |
|
|
|
BOOL b = [self executeUpdate:@"begin deferred transaction"]; |
|
if (b) { |
|
_inTransaction = YES; |
|
} |
|
|
|
return b; |
|
} |
|
|
|
- (BOOL)beginTransaction { |
|
|
|
BOOL b = [self executeUpdate:@"begin exclusive transaction"]; |
|
if (b) { |
|
_inTransaction = YES; |
|
} |
|
|
|
return b; |
|
} |
|
|
|
- (BOOL)inTransaction { |
|
return _inTransaction; |
|
} |
|
|
|
- (BOOL)interrupt |
|
{ |
|
if (_db) { |
|
sqlite3_interrupt([self sqliteHandle]); |
|
return YES; |
|
} |
|
return NO; |
|
} |
|
|
|
static NSString *FMDBEscapeSavePointName(NSString *savepointName) { |
|
return [savepointName stringByReplacingOccurrencesOfString:@"'" withString:@"''"]; |
|
} |
|
|
|
- (BOOL)startSavePointWithName:(NSString*)name error:(NSError**)outErr { |
|
#if SQLITE_VERSION_NUMBER >= 3007000 |
|
NSParameterAssert(name); |
|
|
|
NSString *sql = [NSString stringWithFormat:@"savepoint '%@';", FMDBEscapeSavePointName(name)]; |
|
|
|
return [self executeUpdate:sql error:outErr withArgumentsInArray:nil orDictionary:nil orVAList:nil]; |
|
#else |
|
NSString *errorMessage = NSLocalizedString(@"Save point functions require SQLite 3.7", nil); |
|
if (self.logsErrors) NSLog(@"%@", errorMessage); |
|
return NO; |
|
#endif |
|
} |
|
|
|
- (BOOL)releaseSavePointWithName:(NSString*)name error:(NSError**)outErr { |
|
#if SQLITE_VERSION_NUMBER >= 3007000 |
|
NSParameterAssert(name); |
|
|
|
NSString *sql = [NSString stringWithFormat:@"release savepoint '%@';", FMDBEscapeSavePointName(name)]; |
|
|
|
return [self executeUpdate:sql error:outErr withArgumentsInArray:nil orDictionary:nil orVAList:nil]; |
|
#else |
|
NSString *errorMessage = NSLocalizedString(@"Save point functions require SQLite 3.7", nil); |
|
if (self.logsErrors) NSLog(@"%@", errorMessage); |
|
return NO; |
|
#endif |
|
} |
|
|
|
- (BOOL)rollbackToSavePointWithName:(NSString*)name error:(NSError**)outErr { |
|
#if SQLITE_VERSION_NUMBER >= 3007000 |
|
NSParameterAssert(name); |
|
|
|
NSString *sql = [NSString stringWithFormat:@"rollback transaction to savepoint '%@';", FMDBEscapeSavePointName(name)]; |
|
|
|
return [self executeUpdate:sql error:outErr withArgumentsInArray:nil orDictionary:nil orVAList:nil]; |
|
#else |
|
NSString *errorMessage = NSLocalizedString(@"Save point functions require SQLite 3.7", nil); |
|
if (self.logsErrors) NSLog(@"%@", errorMessage); |
|
return NO; |
|
#endif |
|
} |
|
|
|
- (NSError*)inSavePoint:(void (^)(BOOL *rollback))block { |
|
#if SQLITE_VERSION_NUMBER >= 3007000 |
|
static unsigned long savePointIdx = 0; |
|
|
|
NSString *name = [NSString stringWithFormat:@"dbSavePoint%ld", savePointIdx++]; |
|
|
|
BOOL shouldRollback = NO; |
|
|
|
NSError *err = 0x00; |
|
|
|
if (![self startSavePointWithName:name error:&err]) { |
|
return err; |
|
} |
|
|
|
if (block) { |
|
block(&shouldRollback); |
|
} |
|
|
|
if (shouldRollback) { |
|
// We need to rollback and release this savepoint to remove it |
|
[self rollbackToSavePointWithName:name error:&err]; |
|
} |
|
[self releaseSavePointWithName:name error:&err]; |
|
|
|
return err; |
|
#else |
|
NSString *errorMessage = NSLocalizedString(@"Save point functions require SQLite 3.7", nil); |
|
if (self.logsErrors) NSLog(@"%@", errorMessage); |
|
return [NSError errorWithDomain:@"FMDatabase" code:0 userInfo:@{NSLocalizedDescriptionKey : errorMessage}]; |
|
#endif |
|
} |
|
|
|
|
|
#pragma mark Cache statements |
|
|
|
- (BOOL)shouldCacheStatements { |
|
return _shouldCacheStatements; |
|
} |
|
|
|
- (void)setShouldCacheStatements:(BOOL)value { |
|
|
|
_shouldCacheStatements = value; |
|
|
|
if (_shouldCacheStatements && !_cachedStatements) { |
|
[self setCachedStatements:[NSMutableDictionary dictionary]]; |
|
} |
|
|
|
if (!_shouldCacheStatements) { |
|
[self setCachedStatements:nil]; |
|
} |
|
} |
|
|
|
#pragma mark Callback function |
|
|
|
void FMDBBlockSQLiteCallBackFunction(sqlite3_context *context, int argc, sqlite3_value **argv); // -Wmissing-prototypes |
|
void FMDBBlockSQLiteCallBackFunction(sqlite3_context *context, int argc, sqlite3_value **argv) { |
|
#if ! __has_feature(objc_arc) |
|
void (^block)(sqlite3_context *context, int argc, sqlite3_value **argv) = (id)sqlite3_user_data(context); |
|
#else |
|
void (^block)(sqlite3_context *context, int argc, sqlite3_value **argv) = (__bridge id)sqlite3_user_data(context); |
|
#endif |
|
if (block) { |
|
block(context, argc, argv); |
|
} |
|
} |
|
|
|
|
|
- (void)makeFunctionNamed:(NSString*)name maximumArguments:(int)count withBlock:(void (^)(void *context, int argc, void **argv))block { |
|
|
|
if (!_openFunctions) { |
|
_openFunctions = [NSMutableSet new]; |
|
} |
|
|
|
id b = FMDBReturnAutoreleased([block copy]); |
|
|
|
[_openFunctions addObject:b]; |
|
|
|
/* I tried adding custom functions to release the block when the connection is destroyed- but they seemed to never be called, so we use _openFunctions to store the values instead. */ |
|
#if ! __has_feature(objc_arc) |
|
sqlite3_create_function([self sqliteHandle], [name UTF8String], count, SQLITE_UTF8, (void*)b, &FMDBBlockSQLiteCallBackFunction, 0x00, 0x00); |
|
#else |
|
sqlite3_create_function([self sqliteHandle], [name UTF8String], count, SQLITE_UTF8, (__bridge void*)b, &FMDBBlockSQLiteCallBackFunction, 0x00, 0x00); |
|
#endif |
|
} |
|
|
|
@end |
|
|
|
|
|
|
|
@implementation FMStatement |
|
@synthesize statement=_statement; |
|
@synthesize query=_query; |
|
@synthesize useCount=_useCount; |
|
@synthesize inUse=_inUse; |
|
|
|
#if ! __has_feature(objc_arc) |
|
- (void)finalize { |
|
[self close]; |
|
[super finalize]; |
|
} |
|
#endif |
|
|
|
- (void)dealloc { |
|
[self close]; |
|
FMDBRelease(_query); |
|
#if ! __has_feature(objc_arc) |
|
[super dealloc]; |
|
#endif |
|
} |
|
|
|
- (void)close { |
|
if (_statement) { |
|
sqlite3_finalize(_statement); |
|
_statement = 0x00; |
|
} |
|
|
|
_inUse = NO; |
|
} |
|
|
|
- (void)reset { |
|
if (_statement) { |
|
sqlite3_reset(_statement); |
|
} |
|
|
|
_inUse = NO; |
|
} |
|
|
|
- (NSString*)description { |
|
return [NSString stringWithFormat:@"%@ %ld hit(s) for query %@", [super description], _useCount, _query]; |
|
} |
|
|
|
|
|
@end |
|
|
|
|