motion-yapper 0.0.1 → 0.0.2

data/vendor/Pods/YapDatabase/YapDatabase/Extensions/Views/YapDatabaseViewTypes.h

@@ -0,0 +1,99 @@
+#import <Foundation/Foundation.h>
+
+
+/**
+ * The grouping block handles both filtering and grouping.
+ * 
+ * When you add or update rows in the databse the grouping block is invoked.
+ * Your grouping block can inspect the row and determine if it should be a part of the view.
+ * If not, your grouping block simply returns 'nil' and the object is excluded from the view (removing it if needed).
+ * Otherwise your grouping block returns a group, which can be any string you want.
+ * Once the view knows what group the row belongs to,
+ * it will then determine the position of the row within the group (using the sorting block).
+ * 
+ * You should choose a block type that takes the minimum number of required parameters.
+ * The view can make various optimizations based on required parameters of the block.
+**/
+typedef id YapDatabaseViewGroupingBlock; // One of the YapDatabaseViewGroupingX types below.
+
+typedef NSString* (^YapDatabaseViewGroupingWithKeyBlock)(NSString *collection, NSString *key);
+typedef NSString* (^YapDatabaseViewGroupingWithObjectBlock)(NSString *collection, NSString *key, id object);
+typedef NSString* (^YapDatabaseViewGroupingWithMetadataBlock)(NSString *collection, NSString *key, id metadata);
+typedef NSString* (^YapDatabaseViewGroupingWithRowBlock)(NSString *collection, NSString *key, id object, id metadata);
+
+
+/**
+ * The sorting block handles sorting of objects within their group.
+ *
+ * After the view invokes the grouping block to determine what group a database row belongs to (if any),
+ * the view then needs to determine what index within that group the row should be.
+ * In order to do this, it needs to compare the new/updated row with existing rows in the same view group.
+ * This is what the sorting block is used for.
+ * So the sorting block will be invoked automatically during this process until the view has come to a conclusion.
+ * 
+ * You should choose a block type that takes the minimum number of required parameters.
+ * The view can make various optimizations based on required parameters of the block.
+ * 
+ * For example, if sorting is based on the object, and the metadata of a row is updated,
+ * then the view can deduce that the index hasn't changed (if the group hans't), and can skip this step.
+ * 
+ * Performance Note:
+ * 
+ * The view uses various optimizations (based on common patterns)
+ * to reduce the number of times it needs to invoke the sorting block.
+ *
+ * - Pattern      : row is updated, but its index in the view doesn't change.
+ *   Optimization : if an updated row doesn't change groups, the view will first compare it with
+ *                  objects to the left and right.
+ *
+ * - Pattern      : rows are added to the beginning or end or a view
+ *   Optimization : if the last change put an object at the beginning of the view, then it will test this quickly.
+ *                  if the last change put an object at the end of the view, then it will test this quickly.
+ * 
+ * These optimizations offer huge performance benefits to many common cases.
+ * For example, adding objects to a view that are sorted by timestamp of when they arrived.
+ *
+ * The optimizations are not always performed.
+ * That is, if the row is added to a group it didn't previously belong,
+ * or if the last change didn't place an item at the beginning or end of the view.
+ *
+ * If optimizations fail, or are skipped, then the view uses a binary search algorithm.
+ * 
+ * Although this may be considered "internal information",
+ * I feel it is important to explain for the following reason:
+ * 
+ * Another common pattern is to fetch a number of objects in a batch, and then insert them into the database.
+ * Now imagine a situation in which the view is sorting posts based on timestamp,
+ * and you just fetched the most recent 10 posts. You can enumerate these 10 posts in forwards or backwards
+ * while adding them to the database. One direction will hit the optimization every time. The other will cause
+ * the view to perform a binary search every time. These little one-liner optimzations are easy.
+**/
+typedef id YapDatabaseViewSortingBlock; // One of the YapDatabaseViewSortingX types below.
+
+typedef NSComparisonResult (^YapDatabaseViewSortingWithKeyBlock) \
+                 (NSString *group, NSString *collection1, NSString *key1, \
+                                   NSString *collection2, NSString *key2);
+typedef NSComparisonResult (^YapDatabaseViewSortingWithObjectBlock) \
+                 (NSString *group, NSString *collection1, NSString *key1, id object1, \
+                                   NSString *collection2, NSString *key2, id object2);
+typedef NSComparisonResult (^YapDatabaseViewSortingWithMetadataBlock) \
+                 (NSString *group, NSString *collection1, NSString *key1, id metadata, \
+                                   NSString *collection2, NSString *key2, id metadata2);
+typedef NSComparisonResult (^YapDatabaseViewSortingWithRowBlock) \
+                 (NSString *group, NSString *collection1, NSString *key1, id object1, id metadata1, \
+                                   NSString *collection2, NSString *key2, id object2, id metadata2);
+
+
+/**
+ * I wish there was a way to inspect a given block and see what kind of parameters it takes.
+ * Sadly this does not appear to be possible (at least not in any kind of standard legal way).
+ * 
+ * Thus you will have to specify what kind of block you're passing.
+**/
+typedef enum {
+	YapDatabaseViewBlockTypeWithKey       = 1,
+	YapDatabaseViewBlockTypeWithObject    = 2,
+	YapDatabaseViewBlockTypeWithMetadata  = 3,
+	YapDatabaseViewBlockTypeWithRow       = 4
+} YapDatabaseViewBlockType;
+

data/vendor/Pods/YapDatabase/YapDatabase/Internal/NSDictionary+YapDatabase.h

@@ -0,0 +1,8 @@
+#import <Foundation/Foundation.h>
+
+
+@interface NSDictionary (YapDatabase)
+
+- (BOOL)ydb_containsKey:(id)key;
+
+@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/NSDictionary+YapDatabase.m

@@ -0,0 +1,19 @@
+#import "NSDictionary+YapDatabase.h"
+
+
+@implementation NSDictionary (YapDatabase)
+
+/**
+ * Originally I named this method simply 'containsKey:'.
+ * But then immediately got a stack overflow when using the category.
+ * 
+ * Apparently Apple's code actually registers the 'containsKey:' method in the objective-c space.
+ * And invoking CFDictionaryContainsKey results in a method call back to our 'containsKey:' method,
+ * and thus we get an infinite loop.
+**/
+- (BOOL)ydb_containsKey:(id)key
+{
+	return CFDictionaryContainsKey((CFDictionaryRef)self, (const void *)key);
+}
+
+@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapCache.h

@@ -63,6 +63,7 @@
 - (void)removeObjectsForKeys:(NSArray *)keys;
 
 - (void)enumerateKeysWithBlock:(void (^)(id key, BOOL *stop))block;
+- (void)enumerateKeysAndObjectsWithBlock:(void (^)(id key, id obj, BOOL *stop))block;
 
 //
 // Some debugging stuff that gets compiled out

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapCache.m

@@ -402,6 +402,18 @@
 	}
 }
 
+- (void)enumerateKeysAndObjectsWithBlock:(void (^)(id key, id obj, BOOL *stop))block
+{
+	NSDictionary *nsdict = (__bridge NSDictionary *)cfdict;
+	
+	[nsdict enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop) {
+		
+		__unsafe_unretained YapCacheItem *cacheItem = (YapCacheItem *)obj;
+		
+		block(key, cacheItem->value, stop);
+	}];
+}
+
 - (NSString *)description
 {
 	NSMutableString *description = [NSMutableString string];

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapDatabaseDefaults.h

@@ -31,7 +31,7 @@
 @property (nonatomic, assign, readwrite) YapDatabasePolicy metadataPolicy;
 
 #if TARGET_OS_IPHONE
-@property (nonatomic, assign, readwrite) int autoFlushMemoryLevel;
+@property (nonatomic, assign, readwrite) YapDatabaseConnectionFlushMemoryFlags autoFlushMemoryFlags;
 #endif
 
 @end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapDatabaseDefaults.m

@@ -13,7 +13,7 @@
 @synthesize metadataPolicy = metadataPolicy;
 
 #if TARGET_OS_IPHONE
-@synthesize autoFlushMemoryLevel = autoFlushMemoryLevel;
+@synthesize autoFlushMemoryFlags = autoFlushMemoryFlags;
 #endif
 
 - (id)init
@@ -30,7 +30,7 @@
 		metadataPolicy = YapDatabasePolicyContainment;
 		
 		#if TARGET_OS_IPHONE
-		autoFlushMemoryLevel = YapDatabaseConnectionFlushMemoryLevelMild;
+		autoFlushMemoryFlags = YapDatabaseConnectionFlushMemoryFlags_All;
 		#endif
 	}
 	return self;
@@ -50,7 +50,7 @@
 	copy->metadataPolicy = metadataPolicy;
 	
 	#if TARGET_OS_IPHONE
-	copy->autoFlushMemoryLevel = autoFlushMemoryLevel;
+	copy->autoFlushMemoryFlags = autoFlushMemoryFlags;
 	#endif
 	
 	return copy;

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapDatabasePrivate.h

@@ -8,6 +8,7 @@
 
 #import "YapCache.h"
 #import "YapMemoryTable.h"
+#import "YapCollectionKey.h"
 
 #import "sqlite3.h"
 
@@ -25,6 +26,8 @@ NS_INLINE void sqlite_finalize_null(sqlite3_stmt **stmtPtr)
 extern NSString *const YapDatabaseRegisteredExtensionsKey;
 extern NSString *const YapDatabaseRegisteredTablesKey;
 extern NSString *const YapDatabaseExtensionsOrderKey;
+extern NSString *const YapDatabaseExtensionDependenciesKey;
+extern NSString *const YapDatabaseRemovedRowidsKey;
 extern NSString *const YapDatabaseNotificationKey;
 
 @interface YapDatabase () {
@@ -41,8 +44,8 @@ extern NSString *const YapDatabaseNotificationKey;
 	NSDictionary *registeredExtensions;
 	NSDictionary *registeredTables;
 	
-	NSDictionary *extensionDependencies;
 	NSArray *extensionsOrder;
+	NSDictionary *extensionDependencies;
 	
 	YapDatabaseConnection *registrationConnection;
 	
@@ -81,6 +84,7 @@ extern NSString *const YapDatabaseNotificationKey;
 **/
 - (BOOL)tableExists:(NSString *)tableName using:(sqlite3 *)aDb;
 - (NSArray *)columnNamesForTable:(NSString *)tableName using:(sqlite3 *)aDb;
+- (NSDictionary *)columnNamesAndAffinityForTable:(NSString *)tableName using:(sqlite3 *)aDb;
 
 /**
  * New connections inherit their default values from this structure.
@@ -104,6 +108,7 @@ extern NSString *const YapDatabaseNotificationKey;
 **/
 - (NSDictionary *)registeredTables;
 - (NSArray *)extensionsOrder;
+- (NSDictionary *)extensionDependencies;
 
 /**
  * This method is only accessible from within the snapshotQueue.
@@ -182,13 +187,15 @@ extern NSString *const YapDatabaseNotificationKey;
 	
 	sqlite3 *db;
 	
-	dispatch_queue_t connectionQueue;     // Only for YapDatabaseExtensionConnection subclasses
-	void *IsOnConnectionQueueKey;         // Only for YapDatabaseExtensionConnection subclasses
+	dispatch_queue_t connectionQueue;     // For YapDatabaseExtensionConnection subclasses
+	void *IsOnConnectionQueueKey;         // For YapDatabaseExtensionConnection subclasses
 	
 	NSArray *extensionsOrder;             // Read-only by YapDatabaseTransaction
+	NSDictionary *extensionDependencies;  // Read-only for YapDatabaseExtensionTransaction subclasses
 	
 	BOOL hasDiskChanges;
 	
+	YapCache *keyCache;
 	YapCache *objectCache;
 	YapCache *metadataCache;
 	
@@ -204,6 +211,7 @@ extern NSString *const YapDatabaseNotificationKey;
 	NSMutableDictionary *metadataChanges;
 	NSMutableSet *removedKeys;
 	NSMutableSet *removedCollections;
+	NSMutableSet *removedRowids;
 	BOOL allKeysRemoved;
 }
 
@@ -215,6 +223,7 @@ extern NSString *const YapDatabaseNotificationKey;
 
 - (sqlite3_stmt *)yapGetDataForKeyStatement;   // Against "yap" database, for internal use
 - (sqlite3_stmt *)yapSetDataForKeyStatement;   // Against "yap" database, for internal use
+- (sqlite3_stmt *)yapRemoveForKeyStatement;    // Against "yap" database, for internal use
 - (sqlite3_stmt *)yapRemoveExtensionStatement; // Against "yap" database, for internal use
 
 - (sqlite3_stmt *)getCollectionCountStatement;
@@ -223,15 +232,15 @@ extern NSString *const YapDatabaseNotificationKey;
 - (sqlite3_stmt *)getCountForRowidStatement;
 - (sqlite3_stmt *)getRowidForKeyStatement;
 - (sqlite3_stmt *)getKeyForRowidStatement;
-- (sqlite3_stmt *)getKeyDataForRowidStatement;
-- (sqlite3_stmt *)getKeyMetadataForRowidStatement;
 - (sqlite3_stmt *)getDataForRowidStatement;
+- (sqlite3_stmt *)getMetadataForRowidStatement;
 - (sqlite3_stmt *)getAllForRowidStatement;
 - (sqlite3_stmt *)getDataForKeyStatement;
 - (sqlite3_stmt *)getMetadataForKeyStatement;
 - (sqlite3_stmt *)getAllForKeyStatement;
 - (sqlite3_stmt *)insertForRowidStatement;
 - (sqlite3_stmt *)updateAllForRowidStatement;
+- (sqlite3_stmt *)updateObjectForRowidStatement;
 - (sqlite3_stmt *)updateMetadataForRowidStatement;
 - (sqlite3_stmt *)removeForRowidStatement;
 - (sqlite3_stmt *)removeCollectionStatement;
@@ -330,33 +339,30 @@ extern NSString *const YapDatabaseNotificationKey;
 - (NSData *)dataValueForKey:(NSString *)key extension:(NSString *)extensionName;
 - (void)setDataValue:(NSData *)value forKey:(NSString *)key extension:(NSString *)extensionName;
 
+- (void)removeValueForKey:(NSString *)key extension:(NSString *)extensionName;
 - (void)removeAllValuesForExtension:(NSString *)extensionName;
 
 - (NSException *)mutationDuringEnumerationException;
 
 - (BOOL)getRowid:(int64_t *)rowidPtr forKey:(NSString *)key inCollection:(NSString *)collection;
 
-- (BOOL)getKey:(NSString **)keyPtr collection:(NSString **)collectionPtr forRowid:(int64_t)rowid;
+- (YapCollectionKey *)collectionKeyForRowid:(int64_t)rowid;
 
-- (BOOL)getKey:(NSString **)keyPtr
-    collection:(NSString **)collectionPtr
-        object:(id *)objectPtr
-      forRowid:(int64_t)rowid;
+- (BOOL)getCollectionKey:(YapCollectionKey **)collectionKeyPtr object:(id *)objectPtr forRowid:(int64_t)rowid;
+- (BOOL)getCollectionKey:(YapCollectionKey **)collectionKeyPtr metadata:(id *)metadataPtr forRowid:(int64_t)rowid;
 
-- (BOOL)getKey:(NSString **)keyPtr
-    collection:(NSString **)collectionPtr
-      metadata:(id *)metadataPtr
-      forRowid:(int64_t)rowid;
+- (BOOL)getCollectionKey:(YapCollectionKey **)collectionKeyPtr
+				  object:(id *)objectPtr
+				metadata:(id *)metadataPtr
+				forRowid:(int64_t)rowid;
 
-- (BOOL)getKey:(NSString **)keyPtr
-    collection:(NSString **)collectionPtr
-        object:(id *)objectPtr
-      metadata:(id *)metadataPtr
-      forRowid:(int64_t)rowid;
-
-- (BOOL)hasRowForRowid:(int64_t)rowid;
+- (BOOL)hasRowid:(int64_t)rowid;
 
 - (id)objectForKey:(NSString *)key inCollection:(NSString *)collection withRowid:(int64_t)rowid;
+- (id)objectForCollectionKey:(YapCollectionKey *)cacheKey withRowid:(int64_t)rowid;
+
+- (id)metadataForKey:(NSString *)key inCollection:(NSString *)collection withRowid:(int64_t)rowid;
+- (id)metadataForCollectionKey:(YapCollectionKey *)cacheKey withRowid:(int64_t)rowid;
 
 - (void)_enumerateKeysInCollection:(NSString *)collection
                         usingBlock:(void (^)(int64_t rowid, NSString *key, BOOL *stop))block;
@@ -422,3 +428,19 @@ extern NSString *const YapDatabaseNotificationKey;
      withFilter:(BOOL (^)(int64_t rowid, NSString *collection, NSString *key))filter;
 
 @end
+
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+#pragma mark -
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+@interface YapDatabaseReadWriteTransaction ()
+
+- (void)replaceObject:(id)object forKey:(NSString *)key inCollection:(NSString *)collection withRowid:(int64_t)rowid;
+- (void)replaceMetadata:(id)metadata
+                 forKey:(NSString *)key
+           inCollection:(NSString *)collection
+              withRowid:(int64_t)rowid;
+
+- (void)removeObjectForKey:(NSString *)key inCollection:(NSString *)collection withRowid:(int64_t)rowid;
+
+@end

data/vendor/Pods/YapDatabase/YapDatabase/Internal/YapNull.m

@@ -24,6 +24,10 @@ static YapNull *singleton;
 {
 	NSAssert(singleton == nil, @"Must use singleton via [YapNull null]");
 	
+	#ifdef NS_BLOCK_ASSERTIONS
+	if (singleton != nil) return nil;
+	#endif
+	
 	self = [super init];
 	return self;
 }

data/vendor/Pods/YapDatabase/YapDatabase/Utilities/YapCollectionKey.h

@@ -14,6 +14,9 @@
 @property (nonatomic, strong, readonly) NSString *collection;
 @property (nonatomic, strong, readonly) NSString *key;
 
+- (BOOL)isEqualToCollectionKey:(YapCollectionKey *)collectionKey;
+
+// These methods are overriden and optimized:
 - (BOOL)isEqual:(id)anObject;
 - (NSUInteger)hash;
 

data/vendor/Pods/YapDatabase/YapDatabase/Utilities/YapCollectionKey.m

@@ -166,6 +166,11 @@ static NSUInteger YDB_MurmurHash(NSUInteger hash1, NSUInteger hash2)
 	return self; // Immutable
 }
 
+- (BOOL)isEqualToCollectionKey:(YapCollectionKey *)collectionKey
+{
+	return [key isEqualToString:collectionKey->key] && [collection isEqualToString:collectionKey->collection];
+}
+
 - (BOOL)isEqual:(id)obj
 {
 	if ([obj isMemberOfClass:[YapCollectionKey class]])

data/vendor/Pods/YapDatabase/YapDatabase/YapDatabase.h

@@ -330,7 +330,7 @@ extern NSString *const YapDatabaseAllKeysRemovedKey;
 
 #if TARGET_OS_IPHONE
 /**
- * Allows you to set the default autoFlushMemoryLevel for all new connections.
+ * Allows you to set the default autoFlushMemoryFlags for all new connections.
  *
  * When you create a connection via [database newConnection], that new connection will inherit
  * its initial configuration via the default values configured for the parent database.
@@ -339,12 +339,12 @@ extern NSString *const YapDatabaseAllKeysRemovedKey;
  * Changing the default values only affects future connections that will be created.
  * It does not affect connections that have already been created.
  * 
- * The default defaultAutoFlushMemoryLevel is YapDatabaseConnectionFlushMemoryLevelMild.
+ * The default defaultAutoFlushMemoryFlags is YapDatabaseConnectionFlushMemoryFlags_All.
  *
  * For more detailed documentation on these properties, see the YapDatabaseConnection header file.
- * @see YapDatabaseConnection autoFlushMemoryLevel
+ * @see YapDatabaseConnection autoFlushMemoryFlags
 **/
-@property (atomic, assign, readwrite) int defaultAutoFlushMemoryLevel;
+@property (atomic, assign, readwrite) int defaultAutoFlushMemoryFlags;
 #endif
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

data/vendor/Pods/YapDatabase/YapDatabase/YapDatabase.m

@@ -35,12 +35,14 @@ NSString *const YapDatabaseObjectChangesKey      = @"objectChanges";
 NSString *const YapDatabaseMetadataChangesKey    = @"metadataChanges";
 NSString *const YapDatabaseRemovedKeysKey        = @"removedKeys";
 NSString *const YapDatabaseRemovedCollectionsKey = @"removedCollections";
+NSString *const YapDatabaseRemovedRowidsKey      = @"removedRowids";
 NSString *const YapDatabaseAllKeysRemovedKey     = @"allKeysRemoved";
 
-NSString *const YapDatabaseRegisteredExtensionsKey = @"registeredExtensions";
-NSString *const YapDatabaseRegisteredTablesKey     = @"registeredTables";
-NSString *const YapDatabaseExtensionsOrderKey      = @"extensionsOrder";
-NSString *const YapDatabaseNotificationKey         = @"notification";
+NSString *const YapDatabaseRegisteredExtensionsKey  = @"registeredExtensions";
+NSString *const YapDatabaseRegisteredTablesKey      = @"registeredTables";
+NSString *const YapDatabaseExtensionsOrderKey       = @"extensionsOrder";
+NSString *const YapDatabaseExtensionDependenciesKey = @"extensionDependencies";
+NSString *const YapDatabaseNotificationKey          = @"notification";
 
 /**
  * The database version is stored (via pragma user_version) to sqlite.
@@ -558,16 +560,16 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 }
 
 /**
- * Extracts and returns column names of our database.
+ * Extracts and returns column names from the given table in the database.
 **/
 - (NSArray *)columnNamesForTable:(NSString *)tableName using:(sqlite3 *)aDb
 {
 	if (tableName == nil) return nil;
 	
 	sqlite3_stmt *statement;
-	char *stmt = "PRAGMA table_info(?);";
+	NSString *pragma = [NSString stringWithFormat:@"PRAGMA table_info('%@');", tableName];
 	
-	int status = sqlite3_prepare_v2(aDb, stmt, (int)strlen(stmt)+1, &statement, NULL);
+	int status = sqlite3_prepare_v2(aDb, [pragma UTF8String], -1, &statement, NULL);
 	if (status != SQLITE_OK)
 	{
 		YDBLogError(@"%@: Error creating statement! %d %s", THIS_METHOD, status, sqlite3_errmsg(aDb));
@@ -576,8 +578,6 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 	
 	NSMutableArray *tableColumnNames = [NSMutableArray array];
 	
-	sqlite3_bind_text(statement, 1, [tableName UTF8String], -1, SQLITE_TRANSIENT);
-	
 	while ((status = sqlite3_step(statement)) == SQLITE_ROW)
 	{
 		const unsigned char *text = sqlite3_column_text(statement, 1);
@@ -601,6 +601,58 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 	return tableColumnNames;
 }
 
+/**
+ * Extracts and returns column names & affinity for the given table in the database.
+ * The dictionary format is:
+ *
+ * key:(NSString *)columnName -> value:(NSString *)affinity
+**/
+- (NSDictionary *)columnNamesAndAffinityForTable:(NSString *)tableName using:(sqlite3 *)aDb
+{
+	if (tableName == nil) return nil;
+	
+	sqlite3_stmt *statement;
+	NSString *pragma = [NSString stringWithFormat:@"PRAGMA table_info('%@');", tableName];
+	
+	int status = sqlite3_prepare_v2(aDb, [pragma UTF8String], -1, &statement, NULL);
+	if (status != SQLITE_OK)
+	{
+		YDBLogError(@"%@: Error creating statement! %d %s", THIS_METHOD, status, sqlite3_errmsg(aDb));
+		return nil;
+	}
+	
+	NSMutableDictionary *columns = [NSMutableDictionary dictionary];
+	
+	while ((status = sqlite3_step(statement)) == SQLITE_ROW)
+	{
+		// cid|name|type|notnull|dflt|value|pk
+		
+		const unsigned char *_name = sqlite3_column_text(statement, 1);
+		int _nameSize = sqlite3_column_bytes(statement, 1);
+		
+		const unsigned char *_type = sqlite3_column_text(statement, 2);
+		int _typeSize = sqlite3_column_bytes(statement, 2);
+		
+		NSString *name     = [[NSString alloc] initWithBytes:_name length:_nameSize encoding:NSUTF8StringEncoding];
+		NSString *affinity = [[NSString alloc] initWithBytes:_type length:_typeSize encoding:NSUTF8StringEncoding];
+		
+		if (name && affinity)
+		{
+			[columns setObject:affinity forKey:name];
+		}
+	}
+	
+	if (status != SQLITE_DONE)
+	{
+		YDBLogError(@"%@: Error executing statement! %d %s", THIS_METHOD, status, sqlite3_errmsg(aDb));
+	}
+	
+	sqlite3_finalize(statement);
+	statement = NULL;
+	
+	return columns;
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark Upgrade
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -805,7 +857,7 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 	int status = status = sqlite3_exec(db, "BEGIN TRANSACTION;", NULL, NULL, NULL);
 	if (status != SQLITE_OK)
 	{
-		YDBLogError(@"Error in '%@': %d %s", NSStringFromSelector(_cmd), status, sqlite3_errmsg(db));
+		YDBLogError(@"Error in '%@': %d %s", THIS_METHOD, status, sqlite3_errmsg(db));
 	}
 }
 
@@ -814,7 +866,7 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 	int status = status = sqlite3_exec(db, "COMMIT TRANSACTION;", NULL, NULL, NULL);
 	if (status != SQLITE_OK)
 	{
-		YDBLogError(@"Error in '%@': %d %s", NSStringFromSelector(_cmd), status, sqlite3_errmsg(db));
+		YDBLogError(@"Error in '%@': %d %s", THIS_METHOD, status, sqlite3_errmsg(db));
 	}
 }
 
@@ -828,8 +880,7 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 	status = sqlite3_prepare_v2(db, stmt, (int)strlen(stmt)+1, &statement, NULL);
 	if (status != SQLITE_OK)
 	{
-		YDBLogError(@"%@: Error creating statement: %d %s",
-		              NSStringFromSelector(_cmd), status, sqlite3_errmsg(db));
+		YDBLogError(@"%@: Error creating statement: %d %s", THIS_METHOD, status, sqlite3_errmsg(db));
 	}
 	else
 	{
@@ -844,7 +895,7 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 		status = sqlite3_step(statement);
 		if (status != SQLITE_DONE)
 		{
-			YDBLogError(@"%@: Error in statement: %d %s", NSStringFromSelector(_cmd), status, sqlite3_errmsg(db));
+			YDBLogError(@"%@: Error in statement: %d %s", THIS_METHOD, status, sqlite3_errmsg(db));
 		}
 		
 		sqlite3_finalize(statement);
@@ -863,8 +914,7 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 	status = sqlite3_prepare_v2(db, stmt, (int)strlen(stmt)+1, &statement, NULL);
 	if (status != SQLITE_OK)
 	{
-		YDBLogError(@"%@: Error creating statement: %d %s",
-					NSStringFromSelector(_cmd), status, sqlite3_errmsg(db));
+		YDBLogError(@"%@: Error creating statement: %d %s", THIS_METHOD, status, sqlite3_errmsg(db));
 	}
 	else
 	{
@@ -884,7 +934,7 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 		
 		if (status != SQLITE_DONE)
 		{
-			YDBLogError(@"%@: Error in statement: %d %s", NSStringFromSelector(_cmd), status, sqlite3_errmsg(db));
+			YDBLogError(@"%@: Error in statement: %d %s", THIS_METHOD, status, sqlite3_errmsg(db));
 		}
 		
 		sqlite3_finalize(statement);
@@ -1031,23 +1081,23 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 
 #if TARGET_OS_IPHONE
 
-- (int)defaultAutoFlushMemoryLevel
+- (YapDatabaseConnectionFlushMemoryFlags)defaultAutoFlushMemoryFlags
 {
-	__block int result = YapDatabaseConnectionFlushMemoryLevelNone;
+	__block int result = YapDatabaseConnectionFlushMemoryFlags_None;
 	
 	dispatch_sync(internalQueue, ^{
 		
-		result = defaults.autoFlushMemoryLevel;
+		result = defaults.autoFlushMemoryFlags;
 	});
 	
 	return result;
 }
 
-- (void)setDefaultAutoFlushMemoryLevel:(int)defaultAutoFlushMemoryLevel
+- (void)setDefaultAutoFlushMemoryFlags:(YapDatabaseConnectionFlushMemoryFlags)defaultAutoFlushMemoryFlags
 {
 	dispatch_sync(internalQueue, ^{
 		
-		defaults.autoFlushMemoryLevel = defaultAutoFlushMemoryLevel;
+		defaults.autoFlushMemoryFlags = defaultAutoFlushMemoryFlags;
 	});
 }
 
@@ -1340,36 +1390,9 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 		return NO;
 	}
 	
-	// Set the registeredName now.
-	// The extension will need this in order to perform the registration tasks such as creating tables, etc.
-	
-	extension.registeredName = extensionName;
-	
 	// Attempt registration
 	
 	BOOL result = [[self registrationConnection] registerExtension:extension withName:extensionName];
-	if (result)
-	{
-		// Extension registered
-		// Record dependencies (if there are any)
-		
-		NSSet *dependencies = [extension dependencies];
-		
-		if (dependencies == nil)
-			dependencies = [NSSet set];
-		
-		NSMutableDictionary *newExtensionDependencies = [extensionDependencies mutableCopy];
-		[newExtensionDependencies setObject:dependencies forKey:extensionName];
-		
-		extensionDependencies = [newExtensionDependencies copy];
-	}
-	else
-	{
-		// Registration failed
-		
-		extension.registeredName = nil;
-	}
-	
 	return result;
 }
 
@@ -1387,51 +1410,7 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 		return;
 	}
 	
-	YapDatabaseExtension *extension = [self registeredExtension:extensionName];
-	
 	[[self registrationConnection] unregisterExtension:extensionName];
-	extension.registeredName = nil;
-	
-	NSMutableDictionary *newExtensionDependencies = [extensionDependencies mutableCopy];
-	[newExtensionDependencies removeObjectForKey:extensionName];
-	
-	// Automatically unregister any extensions that were dependent upon this one.
-	
-	BOOL done;
-	do
-	{
-		__block NSString *dependentExtName = nil;
-		[newExtensionDependencies enumerateKeysAndObjectsUsingBlock:^(id key, id obj, BOOL *stop){
-
-		//	__unsafe_unretained NSString *extName = (NSString *)key;
-			__unsafe_unretained NSSet *extDependencies = (NSSet *)obj;
-		
-			if ([extDependencies containsObject:extensionName])
-			{
-				dependentExtName = (NSString *)key;
-				*stop = YES;
-			}
-		}];
-		
-		if (dependentExtName)
-		{
-			YapDatabaseExtension *dependentExt = [self registeredExtension:dependentExtName];
-			
-			[[self registrationConnection] unregisterExtension:dependentExtName];
-			dependentExt.registeredName = nil;
-			
-			[newExtensionDependencies removeObjectForKey:dependentExtName];
-			
-			done = NO;
-		}
-		else
-		{
-			done = YES;
-		}
-		
-	} while (!done);
-	
-	extensionDependencies = [newExtensionDependencies copy];
 }
 
 /**
@@ -1490,6 +1469,17 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 	return extensionsOrder;
 }
 
+/**
+ * This method is only accessible from within the snapshotQueue.
+ * Used by [YapDatabaseConnection prepare].
+**/
+- (NSDictionary *)extensionDependencies
+{
+	NSAssert(dispatch_get_specific(IsOnSnapshotQueueKey), @"Must go through snapshotQueue for atomic access.");
+	
+	return extensionDependencies;
+}
+
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 #pragma mark Pooling
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -1861,6 +1851,7 @@ NSString *const YapDatabaseNotificationKey         = @"notification";
 	{
 		registeredExtensions = newRegisteredExtensions;
 		extensionsOrder = [changeset objectForKey:YapDatabaseExtensionsOrderKey];
+		extensionDependencies = [changeset objectForKey:YapDatabaseExtensionDependenciesKey];
 	}
 	
 	// Update registeredTables, if changed.