From 83b9d5c682b21d88133f24da0f94dd56bd79e687 Mon Sep 17 00:00:00 2001
From: 单军华
Date: Thu, 19 Jul 2018 13:38:55 +0800
Subject: [PATCH] change
---
screendisplay/Pods/FMDB/src/fmdb/FMDatabaseQueue.m | 270 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 270 insertions(+), 0 deletions(-)
diff --git a/screendisplay/Pods/FMDB/src/fmdb/FMDatabaseQueue.m b/screendisplay/Pods/FMDB/src/fmdb/FMDatabaseQueue.m
new file mode 100755
index 0000000..f3f30cf
--- /dev/null
+++ b/screendisplay/Pods/FMDB/src/fmdb/FMDatabaseQueue.m
@@ -0,0 +1,270 @@
+//
+// FMDatabaseQueue.m
+// fmdb
+//
+// Created by August Mueller on 6/22/11.
+// Copyright 2011 Flying Meat Inc. All rights reserved.
+//
+
+#import "FMDatabaseQueue.h"
+#import "FMDatabase.h"
+
+#if FMDB_SQLITE_STANDALONE
+#import <sqlite3/sqlite3.h>
+#else
+#import <sqlite3.h>
+#endif
+
+/*
+
+ Note: we call [self retain]; before using dispatch_sync, just incase
+ FMDatabaseQueue is released on another thread and we're in the middle of doing
+ something in dispatch_sync
+
+ */
+
+/*
+ * A key used to associate the FMDatabaseQueue object with the dispatch_queue_t it uses.
+ * This in turn is used for deadlock detection by seeing if inDatabase: is called on
+ * the queue's dispatch queue, which should not happen and causes a deadlock.
+ */
+static const void * const kDispatchQueueSpecificKey = &kDispatchQueueSpecificKey;
+
+@interface FMDatabaseQueue () {
+ dispatch_queue_t _queue;
+ FMDatabase *_db;
+}
+@end
+
+@implementation FMDatabaseQueue
+
++ (instancetype)databaseQueueWithPath:(NSString *)aPath {
+ FMDatabaseQueue *q = [[self alloc] initWithPath:aPath];
+
+ FMDBAutorelease(q);
+
+ return q;
+}
+
++ (instancetype)databaseQueueWithURL:(NSURL *)url {
+ return [self databaseQueueWithPath:url.path];
+}
+
++ (instancetype)databaseQueueWithPath:(NSString *)aPath flags:(int)openFlags {
+ FMDatabaseQueue *q = [[self alloc] initWithPath:aPath flags:openFlags];
+
+ FMDBAutorelease(q);
+
+ return q;
+}
+
++ (instancetype)databaseQueueWithURL:(NSURL *)url flags:(int)openFlags {
+ return [self databaseQueueWithPath:url.path flags:openFlags];
+}
+
++ (Class)databaseClass {
+ return [FMDatabase class];
+}
+
+- (instancetype)initWithURL:(NSURL *)url flags:(int)openFlags vfs:(NSString *)vfsName {
+ return [self initWithPath:url.path flags:openFlags vfs:vfsName];
+}
+
+- (instancetype)initWithPath:(NSString*)aPath flags:(int)openFlags vfs:(NSString *)vfsName {
+ self = [super init];
+
+ if (self != nil) {
+
+ _db = [[[self class] databaseClass] databaseWithPath:aPath];
+ FMDBRetain(_db);
+
+#if SQLITE_VERSION_NUMBER >= 3005000
+ BOOL success = [_db openWithFlags:openFlags vfs:vfsName];
+#else
+ BOOL success = [_db open];
+#endif
+ if (!success) {
+ NSLog(@"Could not create database queue for path %@", aPath);
+ FMDBRelease(self);
+ return 0x00;
+ }
+
+ _path = FMDBReturnRetained(aPath);
+
+ _queue = dispatch_queue_create([[NSString stringWithFormat:@"fmdb.%@", self] UTF8String], NULL);
+ dispatch_queue_set_specific(_queue, kDispatchQueueSpecificKey, (__bridge void *)self, NULL);
+ _openFlags = openFlags;
+ _vfsName = [vfsName copy];
+ }
+
+ return self;
+}
+
+- (instancetype)initWithPath:(NSString *)aPath flags:(int)openFlags {
+ return [self initWithPath:aPath flags:openFlags vfs:nil];
+}
+
+- (instancetype)initWithURL:(NSURL *)url flags:(int)openFlags {
+ return [self initWithPath:url.path flags:openFlags vfs:nil];
+}
+
+- (instancetype)initWithURL:(NSURL *)url {
+ return [self initWithPath:url.path];
+}
+
+- (instancetype)initWithPath:(NSString *)aPath {
+ // default flags for sqlite3_open
+ return [self initWithPath:aPath flags:SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE vfs:nil];
+}
+
+- (instancetype)init {
+ return [self initWithPath:nil];
+}
+
+
+- (void)dealloc {
+ FMDBRelease(_db);
+ FMDBRelease(_path);
+ FMDBRelease(_vfsName);
+
+ if (_queue) {
+ FMDBDispatchQueueRelease(_queue);
+ _queue = 0x00;
+ }
+#if ! __has_feature(objc_arc)
+ [super dealloc];
+#endif
+}
+
+- (void)close {
+ FMDBRetain(self);
+ dispatch_sync(_queue, ^() {
+ [self->_db close];
+ FMDBRelease(_db);
+ self->_db = 0x00;
+ });
+ FMDBRelease(self);
+}
+
+- (void)interrupt {
+ [[self database] interrupt];
+}
+
+- (FMDatabase*)database {
+ if (!_db) {
+ _db = FMDBReturnRetained([[[self class] databaseClass] databaseWithPath:_path]);
+
+#if SQLITE_VERSION_NUMBER >= 3005000
+ BOOL success = [_db openWithFlags:_openFlags vfs:_vfsName];
+#else
+ BOOL success = [_db open];
+#endif
+ if (!success) {
+ NSLog(@"FMDatabaseQueue could not reopen database for path %@", _path);
+ FMDBRelease(_db);
+ _db = 0x00;
+ return 0x00;
+ }
+ }
+
+ return _db;
+}
+
+- (void)inDatabase:(void (^)(FMDatabase *db))block {
+#ifndef NDEBUG
+ /* Get the currently executing queue (which should probably be nil, but in theory could be another DB queue
+ * and then check it against self to make sure we're not about to deadlock. */
+ FMDatabaseQueue *currentSyncQueue = (__bridge id)dispatch_get_specific(kDispatchQueueSpecificKey);
+ assert(currentSyncQueue != self && "inDatabase: was called reentrantly on the same queue, which would lead to a deadlock");
+#endif
+
+ FMDBRetain(self);
+
+ dispatch_sync(_queue, ^() {
+
+ FMDatabase *db = [self database];
+ block(db);
+
+ if ([db hasOpenResultSets]) {
+ NSLog(@"Warning: there is at least one open result set around after performing [FMDatabaseQueue inDatabase:]");
+
+#if defined(DEBUG) && DEBUG
+ NSSet *openSetCopy = FMDBReturnAutoreleased([[db valueForKey:@"_openResultSets"] copy]);
+ for (NSValue *rsInWrappedInATastyValueMeal in openSetCopy) {
+ FMResultSet *rs = (FMResultSet *)[rsInWrappedInATastyValueMeal pointerValue];
+ NSLog(@"query: '%@'", [rs query]);
+ }
+#endif
+ }
+ });
+
+ FMDBRelease(self);
+}
+
+- (void)beginTransaction:(BOOL)useDeferred withBlock:(void (^)(FMDatabase *db, BOOL *rollback))block {
+ FMDBRetain(self);
+ dispatch_sync(_queue, ^() {
+
+ BOOL shouldRollback = NO;
+
+ if (useDeferred) {
+ [[self database] beginDeferredTransaction];
+ }
+ else {
+ [[self database] beginTransaction];
+ }
+
+ block([self database], &shouldRollback);
+
+ if (shouldRollback) {
+ [[self database] rollback];
+ }
+ else {
+ [[self database] commit];
+ }
+ });
+
+ FMDBRelease(self);
+}
+
+- (void)inDeferredTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block {
+ [self beginTransaction:YES withBlock:block];
+}
+
+- (void)inTransaction:(void (^)(FMDatabase *db, BOOL *rollback))block {
+ [self beginTransaction:NO withBlock:block];
+}
+
+- (NSError*)inSavePoint:(void (^)(FMDatabase *db, BOOL *rollback))block {
+#if SQLITE_VERSION_NUMBER >= 3007000
+ static unsigned long savePointIdx = 0;
+ __block NSError *err = 0x00;
+ FMDBRetain(self);
+ dispatch_sync(_queue, ^() {
+
+ NSString *name = [NSString stringWithFormat:@"savePoint%ld", savePointIdx++];
+
+ BOOL shouldRollback = NO;
+
+ if ([[self database] startSavePointWithName:name error:&err]) {
+
+ block([self database], &shouldRollback);
+
+ if (shouldRollback) {
+ // We need to rollback and release this savepoint to remove it
+ [[self database] rollbackToSavePointWithName:name error:&err];
+ }
+ [[self database] releaseSavePointWithName:name error:&err];
+
+ }
+ });
+ FMDBRelease(self);
+ 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
+}
+
+@end
--
Gitblit v1.8.0