├── .flowconfig
├── .gitignore
├── AIBSQLite.h
├── AIBSQLite.m
├── AIBSQLite.xcodeproj
    └── project.pbxproj
├── LICENSE.txt
├── README.md
├── package.json
└── sqlite3.ios.js


/.flowconfig:
--------------------------------------------------------------------------------
 1 | [ignore]
 2 | 
 3 | # We fork some components by platform.
 4 | .*/*.web.js
 5 | .*/*.android.js
 6 | 
 7 | # Some modules have their own node_modules with overlap
 8 | .*/node_modules/node-haste/.*
 9 | 
10 | # Ignore react-tools where there are overlaps, but don't ignore anything that
11 | # react-native relies on
12 | .*/node_modules/react-tools/src/vendor/core/ExecutionEnvironment.js
13 | .*/node_modules/react-tools/src/browser/eventPlugins/ResponderEventPlugin.js
14 | .*/node_modules/react-tools/src/browser/ui/React.js
15 | .*/node_modules/react-tools/src/core/ReactInstanceHandles.js
16 | .*/node_modules/react-tools/src/event/EventPropagators.js
17 | 
18 | # Ignore jest
19 | .*/react-native/node_modules/jest-cli/.*
20 | 
21 | # Ignore Website
22 | .*/website/.*
23 | 
24 | [include]
25 | 
26 | [libs]
27 | node_modules/react-native/Libraries/react-native/react-native-interface.js
28 | 
29 | [options]
30 | module.system=haste
31 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | # Dependency directory
2 | # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
3 | node_modules
4 | AIBSQLite.xcodeproj/xcuserdata
5 | AIBSQLite.xcodeproj/project.xcworkspace


--------------------------------------------------------------------------------
/AIBSQLite.h:
--------------------------------------------------------------------------------
 1 | //
 2 | //  AIBSQLite.h
 3 | //  activeinbox
 4 | //
 5 | //  Created by Thomas Parslow on 02/04/2015.
 6 | //
 7 | 
 8 | 
 9 | #import <RCTBridgeModule.h>
10 | 
11 | @interface AIBSQLite : NSObject <RCTBridgeModule>
12 | 
13 | - (void)openFromFilename:(NSString *)filename callback:(RCTResponseSenderBlock)callback;
14 | - (void)closeDatabase:(NSString *)databaseId callback:(RCTResponseSenderBlock)callback;
15 | - (void)prepareStatement: (NSString *)databaseId sql: (NSString *)sql andParams: (NSArray *)params callback: (RCTResponseSenderBlock)callback;
16 | - (void)stepStatement:(NSString *)databaseId statementId: (NSString *) statementId callback:(RCTResponseSenderBlock)callback;
17 | - (void)finalizeStatement:(NSString *)databaseId statementId: (NSString *) statementId callback:(RCTResponseSenderBlock)callback;
18 | 
19 | @end
20 | 


--------------------------------------------------------------------------------
/AIBSQLite.m:
--------------------------------------------------------------------------------
  1 | ;//
  2 | //  AIBSQLite.m
  3 | //  activeinbox
  4 | //
  5 | //  Created by Thomas Parslow on 02/04/2015.
  6 | //
  7 | 
  8 | #import "AIBSQLite.h"
  9 | #import "RCTLog.h"
 10 | #import "RCTUtils.h"
 11 | #import <Foundation/Foundation.h>
 12 | #import "RCTBridge.h"
 13 | #import "RCTEventDispatcher.h"
 14 | 
 15 | #import <sqlite3.h>
 16 | 
 17 | // From RCTAsyncLocalStorage, make a queue so we can serialise our interactions
 18 | static dispatch_queue_t AIBSQLiteQueue(void)
 19 | {
 20 |     static dispatch_queue_t sqliteQueue = NULL;
 21 |     static dispatch_once_t onceToken;
 22 |     dispatch_once(&onceToken, ^{
 23 |         // All JS is single threaded, so a serial queue is our only option.
 24 |         sqliteQueue = dispatch_queue_create("com.activeinboxhq.sqlite", DISPATCH_QUEUE_SERIAL);
 25 |         dispatch_set_target_queue(sqliteQueue,
 26 |                                   dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0));
 27 |     });
 28 | 
 29 |     return sqliteQueue;
 30 | }
 31 | 
 32 | // Private class to hold details of an open database
 33 | @interface Database : NSObject
 34 | @property (readonly) sqlite3 * db;
 35 | @property (readonly) NSMutableDictionary *statements;
 36 | @end
 37 | 
 38 | @implementation Database
 39 | @synthesize db = _db;
 40 | @synthesize statements = _statements;
 41 | 
 42 | - (id) initWithSqliteDb: (sqlite3 *) db
 43 | {
 44 |     self = [super init];
 45 |     if (self) {
 46 |         _db = db;
 47 |         _statements = [NSMutableDictionary dictionaryWithCapacity: 1];
 48 |     }
 49 |     return self;
 50 | }
 51 | @end
 52 | 
 53 | // Private class to hold details of an open database
 54 | @interface Statement : NSObject
 55 | @property (readonly) sqlite3_stmt * stmt;
 56 | @end
 57 | 
 58 | @implementation Statement
 59 | @synthesize stmt = _stmt;
 60 | 
 61 | - (id) initWithSqliteStmt: (sqlite3_stmt *) stmt
 62 | {
 63 |     self = [super init];
 64 |     if (self) {
 65 |         _stmt = stmt;
 66 |     }
 67 |     return self;
 68 | }
 69 | @end
 70 | 
 71 | 
 72 | 
 73 | @implementation AIBSQLite
 74 | {
 75 |     NSMutableDictionary *openDatabases;
 76 |     int nextId;
 77 | }
 78 | 
 79 | RCT_EXPORT_MODULE();
 80 | 
 81 | @synthesize bridge = _bridge;
 82 | 
 83 | - (id) init
 84 | {
 85 |     self = [super init];
 86 |     if (self) {
 87 |         openDatabases = [NSMutableDictionary dictionaryWithCapacity: 1];
 88 |         nextId = 0;
 89 |     }
 90 |     return self;
 91 | }
 92 | 
 93 | RCT_EXPORT_METHOD(openFromFilename:(NSString *)filename callback:(RCTResponseSenderBlock)callback)
 94 | {
 95 |     if (!callback) {
 96 |         RCTLogError(@"Called openFromFilename without a callback.");
 97 |         return;
 98 |     }
 99 |     dispatch_async(AIBSQLiteQueue(), ^{
100 |         // TODO: Allow creation of database in Library or tmp
101 |         // directories. Maybe also add an option to open read-only
102 |         // direct from the bundle.
103 |         NSArray *paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
104 |         NSString *documentsDirectory = [paths objectAtIndex:0];
105 |         NSString *dbPath = [documentsDirectory stringByAppendingPathComponent:filename];
106 | 
107 |         if (![[NSFileManager defaultManager] fileExistsAtPath:dbPath]) {
108 |           // If the db file doesn't exist in the documents directory
109 |           // but it does exist in the bundle then copy it over now
110 |           NSString *sourcePath = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:filename];
111 |           NSError *error;
112 |           if ([[NSFileManager defaultManager] fileExistsAtPath:sourcePath]) {
113 |             [[NSFileManager defaultManager] copyItemAtPath:sourcePath toPath:dbPath error:&error];
114 |             if (error != nil) {
115 |               callback(@[[error localizedDescription], [NSNull null]]);
116 |             }
117 |           }
118 |         }
119 | 
120 |         sqlite3 *db;
121 |         BOOL openDatabaseResult = sqlite3_open([dbPath UTF8String], &db);
122 |         if(openDatabaseResult != SQLITE_OK) {
123 |           callback(@[@"Couldn't open database", [NSNull null]]);
124 |           return;
125 |         }
126 |         NSString *databaseId = [[NSNumber numberWithInt: nextId++] stringValue];
127 |         Database *database = [[Database alloc] initWithSqliteDb:db];
128 |         [openDatabases setValue:database forKey:databaseId];
129 |         callback(@[[NSNull null], databaseId]);
130 |       });
131 | }
132 | 
133 | RCT_EXPORT_METHOD(closeDatabase:(NSString *)databaseId callback:(RCTResponseSenderBlock)callback)
134 | {
135 |     if (!callback) {
136 |         RCTLogError(@"Called openFromFilename without a callback.");
137 |         return;
138 |     }
139 |     dispatch_async(AIBSQLiteQueue(), ^{
140 |         Database *database = [openDatabases valueForKey:databaseId];
141 |         if (database == nil) {
142 |             callback(@[@"No open database found"]);
143 |             return;
144 |         }
145 |         
146 |         // Finalize any remaining statments
147 |         for (NSString* statementId in [database statements]) {
148 |             Statement *statement = [[database statements] objectForKey:statementId];
149 |             sqlite3_stmt *stmt = [statement stmt];
150 |             // We don't care about errors at this point, or at least there's nothing we can do about them
151 |             sqlite3_finalize(stmt);
152 |         }
153 |         
154 |         sqlite3 *db = [database db];
155 |         sqlite3_close(db);
156 |         
157 |         [openDatabases removeObjectForKey: databaseId];
158 |         callback(@[[NSNull null]]);
159 |     });
160 | }
161 | 
162 | RCT_EXPORT_METHOD(prepareStatement: (NSString *)databaseId sql: (NSString *)sql andParams: (NSArray *)params callback: (RCTResponseSenderBlock)callback)
163 | {
164 |     if (!callback) {
165 |         RCTLogError(@"Called prepareStatement without a callback.");
166 |     }
167 |     
168 |     dispatch_async(AIBSQLiteQueue(), ^{
169 |         Database *database = [openDatabases valueForKey:databaseId];
170 |         if (database == nil) {
171 |             callback(@[@"No open database found", [NSNull null]]);
172 |             return;
173 |         }
174 |         sqlite3 *db = [database db];
175 |         sqlite3_stmt *stmt;
176 |         
177 |         int rc = sqlite3_prepare_v2(db, [sql UTF8String], -1, &stmt, NULL);
178 |         if (rc != SQLITE_OK) {
179 |             callback(@[[NSString stringWithUTF8String:sqlite3_errmsg(db)]]);
180 |             return;
181 |         }
182 |         
183 |         for (int i=0; i < [params count]; i++){
184 |             NSObject *param = [params objectAtIndex: i];
185 |             if ([param isKindOfClass: [NSString class]]) {
186 |                 NSString *str = (NSString*) param;
187 |                 int strLength = (int) [str lengthOfBytesUsingEncoding: NSUTF8StringEncoding];
188 |                 sqlite3_bind_text(stmt, i+1, [str UTF8String], strLength, SQLITE_TRANSIENT);
189 |             } else if ([param isKindOfClass: [NSNumber class]]) {
190 |                 sqlite3_bind_double(stmt, i+1, [(NSNumber *)param doubleValue]);
191 |             } else if ([param isKindOfClass: [NSNull class]]) {
192 |                 sqlite3_bind_null(stmt, i+1);
193 |             } else {
194 |                 sqlite3_finalize(stmt);
195 |                 callback(@[@"Parameters must be either numbers or strings" ]);
196 |                 return;
197 |             }
198 |         }
199 |         
200 |         NSString *statementId = [[NSNumber numberWithInt: nextId++] stringValue];
201 |         Statement *statement = [[Statement alloc] initWithSqliteStmt: stmt];
202 |         [[database statements] setValue: statement forKey:statementId];
203 |         
204 |         callback(@[[NSNull null], statementId]);
205 |     });
206 | }
207 | 
208 | RCT_EXPORT_METHOD(stepStatement:(NSString *)databaseId statementId: (NSString *) statementId callback:(RCTResponseSenderBlock)callback)
209 | {
210 |     if (!callback) {
211 |         RCTLogError(@"Called step without a callback.");
212 |     }
213 |     
214 |     dispatch_async(AIBSQLiteQueue(), ^{
215 |         Database *database = [openDatabases valueForKey:databaseId];
216 |         if (database == nil) {
217 |             callback(@[@"No open database found", [NSNull null]]);
218 |             return;
219 |         }
220 |         Statement *statement = [[database statements] objectForKey:statementId];
221 |         if (statement == nil) {
222 |             callback(@[@"No statement found", [NSNull null]]);
223 |             return;
224 |         }
225 |         
226 |         sqlite3 *db = [database db];
227 |         sqlite3_stmt *stmt = [statement stmt];
228 |         
229 |         int rc = sqlite3_step(stmt);
230 |         if (rc == SQLITE_ROW) {
231 |             int totalColumns = sqlite3_column_count(stmt);
232 |             NSMutableDictionary *rowData = [NSMutableDictionary dictionaryWithCapacity: totalColumns];
233 |             // Go through all columns and fetch each column data.
234 |             for (int i=0; i<totalColumns; i++){
235 |                 // Convert the column data to text (characters).
236 |                 
237 |                 NSObject *value;
238 |                 NSData *data;
239 |                 switch (sqlite3_column_type(stmt, i)) {
240 |                     case SQLITE_INTEGER:
241 |                         value = [NSNumber numberWithLongLong: sqlite3_column_int64(stmt, i)];
242 |                         break;
243 |                     case SQLITE_FLOAT:
244 |                         value = [NSNumber numberWithDouble: sqlite3_column_double(stmt, i)];
245 |                         break;
246 |                     case SQLITE_NULL:
247 |                         value = [NSNull null];
248 |                         break;
249 |                     case SQLITE_BLOB:
250 |                         sqlite3_finalize(stmt);
251 |                         // TODO: How should we support blobs? Maybe base64 encode them?
252 |                         callback(@[@"BLOBs not supported", [NSNull null]]);
253 |                         return;
254 |                         break;
255 |                     case SQLITE_TEXT:
256 |                     default:
257 |                         data = [NSData dataWithBytes: sqlite3_column_blob(stmt, i) length: sqlite3_column_bytes16(stmt, i)];
258 |                         value = [[NSString alloc] initWithData:data encoding:NSUTF8StringEncoding];
259 |                         break;
260 |                 }
261 |                 char *columnName = (char *)sqlite3_column_name(stmt, i);
262 |                 // Convert the characters to string.
263 |                 [rowData setValue: value forKey: [NSString stringWithUTF8String: columnName]];
264 |             }
265 |             callback(@[[NSNull null], rowData]);
266 |         } else if (rc == SQLITE_DONE) {
267 |             sqlite3_finalize(stmt);
268 |             [[database statements] removeObjectForKey: statementId];
269 |             callback(@[[NSNull null], [NSNull null]]);
270 |         } else {
271 |             [[database statements] removeObjectForKey: statementId];
272 |             sqlite3_finalize(stmt);
273 |             callback(@[[NSString stringWithUTF8String:sqlite3_errmsg(db)], [NSNull null]]);
274 |         }
275 |     });
276 | }
277 | 
278 | RCT_EXPORT_METHOD(finalizeStatement:(NSString *)databaseId statementId: (NSString *) statementId callback:(RCTResponseSenderBlock)callback)
279 | {
280 |     if (!callback) {
281 |         RCTLogError(@"Called step without a callback.");
282 |     }
283 |     
284 |     dispatch_async(AIBSQLiteQueue(), ^{
285 |         Database *database = [openDatabases valueForKey:databaseId];
286 |         if (database == nil) {
287 |             callback(@[@"No open database found", [NSNull null]]);
288 |             return;
289 |         }
290 |         Statement *statement = [[database statements] objectForKey:statementId];
291 |         if (statement == nil) {
292 |             callback(@[@"No statement found", [NSNull null]]);
293 |             return;
294 |         }
295 |         
296 |         sqlite3 *db = [database db];
297 |         sqlite3_stmt *stmt = [statement stmt];
298 |         
299 |         [[database statements] removeObjectForKey: statementId];
300 |         
301 |         if (sqlite3_finalize(stmt) == SQLITE_OK) {
302 |             callback(@[[NSNull null]]);
303 |         } else {
304 |             callback(@[[NSString stringWithUTF8String:sqlite3_errmsg(db)]]);
305 |         }
306 |     });
307 | }
308 | 
309 | @end
310 | 


--------------------------------------------------------------------------------
/AIBSQLite.xcodeproj/project.pbxproj:
--------------------------------------------------------------------------------
  1 | // !$*UTF8*$!
  2 | {
  3 | 	archiveVersion = 1;
  4 | 	classes = {
  5 | 	};
  6 | 	objectVersion = 46;
  7 | 	objects = {
  8 | 
  9 | /* Begin PBXBuildFile section */
 10 | 		E23D7B651ACEFE6500C59171 /* libsqlite3.dylib in Frameworks */ = {isa = PBXBuildFile; fileRef = E23D7B641ACEFE6500C59171 /* libsqlite3.dylib */; };
 11 | 		E25C74971ACEFE95004F0793 /* AIBSQLite.m in Sources */ = {isa = PBXBuildFile; fileRef = E25C74961ACEFE95004F0793 /* AIBSQLite.m */; };
 12 | 		E25C74A01ACEFF33004F0793 /* AIBSQLite.h in Headers */ = {isa = PBXBuildFile; fileRef = E25C74951ACEFE95004F0793 /* AIBSQLite.h */; };
 13 | /* End PBXBuildFile section */
 14 | 
 15 | /* Begin PBXCopyFilesBuildPhase section */
 16 | 		E23D7B451ACEFE2A00C59171 /* CopyFiles */ = {
 17 | 			isa = PBXCopyFilesBuildPhase;
 18 | 			buildActionMask = 2147483647;
 19 | 			dstPath = "include/$(PRODUCT_NAME)";
 20 | 			dstSubfolderSpec = 16;
 21 | 			files = (
 22 | 			);
 23 | 			runOnlyForDeploymentPostprocessing = 0;
 24 | 		};
 25 | /* End PBXCopyFilesBuildPhase section */
 26 | 
 27 | /* Begin PBXFileReference section */
 28 | 		E23D7B471ACEFE2A00C59171 /* libAIBSQLite.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; path = libAIBSQLite.a; sourceTree = BUILT_PRODUCTS_DIR; };
 29 | 		E23D7B641ACEFE6500C59171 /* libsqlite3.dylib */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.dylib"; name = libsqlite3.dylib; path = usr/lib/libsqlite3.dylib; sourceTree = SDKROOT; };
 30 | 		E25C74951ACEFE95004F0793 /* AIBSQLite.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = AIBSQLite.h; sourceTree = SOURCE_ROOT; };
 31 | 		E25C74961ACEFE95004F0793 /* AIBSQLite.m */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.objc; path = AIBSQLite.m; sourceTree = SOURCE_ROOT; };
 32 | /* End PBXFileReference section */
 33 | 
 34 | /* Begin PBXFrameworksBuildPhase section */
 35 | 		E23D7B441ACEFE2A00C59171 /* Frameworks */ = {
 36 | 			isa = PBXFrameworksBuildPhase;
 37 | 			buildActionMask = 2147483647;
 38 | 			files = (
 39 | 				E23D7B651ACEFE6500C59171 /* libsqlite3.dylib in Frameworks */,
 40 | 			);
 41 | 			runOnlyForDeploymentPostprocessing = 0;
 42 | 		};
 43 | /* End PBXFrameworksBuildPhase section */
 44 | 
 45 | /* Begin PBXGroup section */
 46 | 		E23D7B3E1ACEFE2A00C59171 = {
 47 | 			isa = PBXGroup;
 48 | 			children = (
 49 | 				E23D7B641ACEFE6500C59171 /* libsqlite3.dylib */,
 50 | 				E23D7B491ACEFE2A00C59171 /* AIBSQLite */,
 51 | 				E23D7B481ACEFE2A00C59171 /* Products */,
 52 | 			);
 53 | 			sourceTree = "<group>";
 54 | 		};
 55 | 		E23D7B481ACEFE2A00C59171 /* Products */ = {
 56 | 			isa = PBXGroup;
 57 | 			children = (
 58 | 				E23D7B471ACEFE2A00C59171 /* libAIBSQLite.a */,
 59 | 			);
 60 | 			name = Products;
 61 | 			sourceTree = "<group>";
 62 | 		};
 63 | 		E23D7B491ACEFE2A00C59171 /* AIBSQLite */ = {
 64 | 			isa = PBXGroup;
 65 | 			children = (
 66 | 				E25C74951ACEFE95004F0793 /* AIBSQLite.h */,
 67 | 				E25C74961ACEFE95004F0793 /* AIBSQLite.m */,
 68 | 			);
 69 | 			path = AIBSQLite;
 70 | 			sourceTree = "<group>";
 71 | 		};
 72 | /* End PBXGroup section */
 73 | 
 74 | /* Begin PBXHeadersBuildPhase section */
 75 | 		E25C749F1ACEFF2C004F0793 /* Headers */ = {
 76 | 			isa = PBXHeadersBuildPhase;
 77 | 			buildActionMask = 2147483647;
 78 | 			files = (
 79 | 				E25C74A01ACEFF33004F0793 /* AIBSQLite.h in Headers */,
 80 | 			);
 81 | 			runOnlyForDeploymentPostprocessing = 0;
 82 | 		};
 83 | /* End PBXHeadersBuildPhase section */
 84 | 
 85 | /* Begin PBXNativeTarget section */
 86 | 		E23D7B461ACEFE2A00C59171 /* AIBSQLite */ = {
 87 | 			isa = PBXNativeTarget;
 88 | 			buildConfigurationList = E23D7B5B1ACEFE2A00C59171 /* Build configuration list for PBXNativeTarget "AIBSQLite" */;
 89 | 			buildPhases = (
 90 | 				E23D7B431ACEFE2A00C59171 /* Sources */,
 91 | 				E23D7B441ACEFE2A00C59171 /* Frameworks */,
 92 | 				E23D7B451ACEFE2A00C59171 /* CopyFiles */,
 93 | 				E25C749F1ACEFF2C004F0793 /* Headers */,
 94 | 			);
 95 | 			buildRules = (
 96 | 			);
 97 | 			dependencies = (
 98 | 			);
 99 | 			name = AIBSQLite;
100 | 			productName = AIBSQLite;
101 | 			productReference = E23D7B471ACEFE2A00C59171 /* libAIBSQLite.a */;
102 | 			productType = "com.apple.product-type.library.static";
103 | 		};
104 | /* End PBXNativeTarget section */
105 | 
106 | /* Begin PBXProject section */
107 | 		E23D7B3F1ACEFE2A00C59171 /* Project object */ = {
108 | 			isa = PBXProject;
109 | 			attributes = {
110 | 				LastUpgradeCheck = 0610;
111 | 				ORGANIZATIONNAME = "Active Inbox";
112 | 				TargetAttributes = {
113 | 					E23D7B461ACEFE2A00C59171 = {
114 | 						CreatedOnToolsVersion = 6.1.1;
115 | 					};
116 | 				};
117 | 			};
118 | 			buildConfigurationList = E23D7B421ACEFE2A00C59171 /* Build configuration list for PBXProject "AIBSQLite" */;
119 | 			compatibilityVersion = "Xcode 3.2";
120 | 			developmentRegion = English;
121 | 			hasScannedForEncodings = 0;
122 | 			knownRegions = (
123 | 				en,
124 | 			);
125 | 			mainGroup = E23D7B3E1ACEFE2A00C59171;
126 | 			productRefGroup = E23D7B481ACEFE2A00C59171 /* Products */;
127 | 			projectDirPath = "";
128 | 			projectRoot = "";
129 | 			targets = (
130 | 				E23D7B461ACEFE2A00C59171 /* AIBSQLite */,
131 | 			);
132 | 		};
133 | /* End PBXProject section */
134 | 
135 | /* Begin PBXSourcesBuildPhase section */
136 | 		E23D7B431ACEFE2A00C59171 /* Sources */ = {
137 | 			isa = PBXSourcesBuildPhase;
138 | 			buildActionMask = 2147483647;
139 | 			files = (
140 | 				E25C74971ACEFE95004F0793 /* AIBSQLite.m in Sources */,
141 | 			);
142 | 			runOnlyForDeploymentPostprocessing = 0;
143 | 		};
144 | /* End PBXSourcesBuildPhase section */
145 | 
146 | /* Begin XCBuildConfiguration section */
147 | 		E23D7B591ACEFE2A00C59171 /* Debug */ = {
148 | 			isa = XCBuildConfiguration;
149 | 			buildSettings = {
150 | 				ALWAYS_SEARCH_USER_PATHS = NO;
151 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
152 | 				CLANG_CXX_LIBRARY = "libc++";
153 | 				CLANG_ENABLE_MODULES = YES;
154 | 				CLANG_ENABLE_OBJC_ARC = YES;
155 | 				CLANG_WARN_BOOL_CONVERSION = YES;
156 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
157 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
158 | 				CLANG_WARN_EMPTY_BODY = YES;
159 | 				CLANG_WARN_ENUM_CONVERSION = YES;
160 | 				CLANG_WARN_INT_CONVERSION = YES;
161 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
162 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
163 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
164 | 				COPY_PHASE_STRIP = NO;
165 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
166 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
167 | 				GCC_DYNAMIC_NO_PIC = NO;
168 | 				GCC_OPTIMIZATION_LEVEL = 0;
169 | 				GCC_PREPROCESSOR_DEFINITIONS = (
170 | 					"DEBUG=1",
171 | 					"$(inherited)",
172 | 				);
173 | 				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
174 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
175 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
176 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
177 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
178 | 				GCC_WARN_UNUSED_FUNCTION = YES;
179 | 				GCC_WARN_UNUSED_VARIABLE = YES;
180 | 				IPHONEOS_DEPLOYMENT_TARGET = 8.1;
181 | 				MTL_ENABLE_DEBUG_INFO = YES;
182 | 				ONLY_ACTIVE_ARCH = YES;
183 | 				SDKROOT = iphoneos;
184 | 			};
185 | 			name = Debug;
186 | 		};
187 | 		E23D7B5A1ACEFE2A00C59171 /* Release */ = {
188 | 			isa = XCBuildConfiguration;
189 | 			buildSettings = {
190 | 				ALWAYS_SEARCH_USER_PATHS = NO;
191 | 				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
192 | 				CLANG_CXX_LIBRARY = "libc++";
193 | 				CLANG_ENABLE_MODULES = YES;
194 | 				CLANG_ENABLE_OBJC_ARC = YES;
195 | 				CLANG_WARN_BOOL_CONVERSION = YES;
196 | 				CLANG_WARN_CONSTANT_CONVERSION = YES;
197 | 				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR;
198 | 				CLANG_WARN_EMPTY_BODY = YES;
199 | 				CLANG_WARN_ENUM_CONVERSION = YES;
200 | 				CLANG_WARN_INT_CONVERSION = YES;
201 | 				CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR;
202 | 				CLANG_WARN_UNREACHABLE_CODE = YES;
203 | 				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
204 | 				COPY_PHASE_STRIP = YES;
205 | 				ENABLE_NS_ASSERTIONS = NO;
206 | 				ENABLE_STRICT_OBJC_MSGSEND = YES;
207 | 				GCC_C_LANGUAGE_STANDARD = gnu99;
208 | 				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
209 | 				GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR;
210 | 				GCC_WARN_UNDECLARED_SELECTOR = YES;
211 | 				GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE;
212 | 				GCC_WARN_UNUSED_FUNCTION = YES;
213 | 				GCC_WARN_UNUSED_VARIABLE = YES;
214 | 				IPHONEOS_DEPLOYMENT_TARGET = 8.1;
215 | 				MTL_ENABLE_DEBUG_INFO = NO;
216 | 				SDKROOT = iphoneos;
217 | 				VALIDATE_PRODUCT = YES;
218 | 			};
219 | 			name = Release;
220 | 		};
221 | 		E23D7B5C1ACEFE2A00C59171 /* Debug */ = {
222 | 			isa = XCBuildConfiguration;
223 | 			buildSettings = {
224 | 				HEADER_SEARCH_PATHS = (
225 | 					"$(inherited)",
226 | 					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
227 | 					"$(SRCROOT)/../react-native/React/**",
228 | 				);
229 | 				OTHER_LDFLAGS = "-ObjC";
230 | 				PRODUCT_NAME = "$(TARGET_NAME)";
231 | 				SKIP_INSTALL = YES;
232 | 				USER_HEADER_SEARCH_PATHS = "$(SRCROOT)/../react-native/React/**";
233 | 			};
234 | 			name = Debug;
235 | 		};
236 | 		E23D7B5D1ACEFE2A00C59171 /* Release */ = {
237 | 			isa = XCBuildConfiguration;
238 | 			buildSettings = {
239 | 				HEADER_SEARCH_PATHS = (
240 | 					"$(inherited)",
241 | 					/Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/include,
242 | 					"$(SRCROOT)/../react-native/React/**",
243 | 				);
244 | 				OTHER_LDFLAGS = "-ObjC";
245 | 				PRODUCT_NAME = "$(TARGET_NAME)";
246 | 				SKIP_INSTALL = YES;
247 | 				USER_HEADER_SEARCH_PATHS = "$(SRCROOT)/../react-native/React/**";
248 | 			};
249 | 			name = Release;
250 | 		};
251 | /* End XCBuildConfiguration section */
252 | 
253 | /* Begin XCConfigurationList section */
254 | 		E23D7B421ACEFE2A00C59171 /* Build configuration list for PBXProject "AIBSQLite" */ = {
255 | 			isa = XCConfigurationList;
256 | 			buildConfigurations = (
257 | 				E23D7B591ACEFE2A00C59171 /* Debug */,
258 | 				E23D7B5A1ACEFE2A00C59171 /* Release */,
259 | 			);
260 | 			defaultConfigurationIsVisible = 0;
261 | 			defaultConfigurationName = Release;
262 | 		};
263 | 		E23D7B5B1ACEFE2A00C59171 /* Build configuration list for PBXNativeTarget "AIBSQLite" */ = {
264 | 			isa = XCConfigurationList;
265 | 			buildConfigurations = (
266 | 				E23D7B5C1ACEFE2A00C59171 /* Debug */,
267 | 				E23D7B5D1ACEFE2A00C59171 /* Release */,
268 | 			);
269 | 			defaultConfigurationIsVisible = 0;
270 | 			defaultConfigurationName = Release;
271 | 		};
272 | /* End XCConfigurationList section */
273 | 	};
274 | 	rootObject = E23D7B3F1ACEFE2A00C59171 /* Project object */;
275 | }
276 | 


--------------------------------------------------------------------------------
/LICENSE.txt:
--------------------------------------------------------------------------------
 1 | The MIT License (MIT)
 2 | 
 3 | Copyright (c) 2014 Thomas Parslow
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in
13 | all copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
21 | THE SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # react-native-sqlite
 2 | 
 3 | NOTE: This hasn't been maintained for a while and was never very complete to start with. Check out https://github.com/andpor/react-native-sqlite-storage for a more usable library!
 4 | 
 5 | A binding for sqlite3 for React Native. Allows a database to be opened and for SQL queries to be run on it.
 6 | 
 7 | Written by Thomas Parslow
 8 | ([almostobsolete.net](http://almostobsolete.net) and
 9 | [tomparslow.co.uk](http://tomparslow.co.uk)) as part of Active Inbox
10 | ([activeinboxhq.com](http://activeinboxhq.com/)).
11 | 
12 | ## Installation
13 | 
14 | Install using npm with `npm install --save react-native-sqlite`
15 | 
16 | You then need to add the Objective C part to your XCode project. Drag
17 | `AIBSQLite.xcodeproj` from the `node_modules/react-native-sqlite` folder into your XCode project. Click on the project in XCode, goto `Build Phases` then `Link Binary With Libraries` and add `libAIBSQLite.a` and `libsqlite3.dylib`.
18 | 
19 | NOTE: Make sure you don't have the `AIBSQLite` project open seperately in XCode otherwise it won't work.
20 | 
21 | ## Usage
22 | 
23 | ```javascript
24 | var sqlite = require('react-native-sqlite');
25 | sqlite.open("filename.sqlite", function (error, database) {
26 |   if (error) {
27 |     console.log("Failed to open database:", error);
28 |     return;
29 |   }
30 |   var sql = "SELECT a, b FROM table WHERE field=? AND otherfield=?";
31 |   var params = ["somestring", 99];
32 |   database.executeSQL(sql, params, rowCallback, completeCallback);
33 |   function rowCallback(rowData) {
34 |     console.log("Got row data:", rowData);
35 |   }
36 |   function completeCallback(error) {
37 |     if (error) {
38 |       console.log("Failed to execute query:", error);
39 |       return
40 |     }
41 |     console.log("Query complete!");
42 |     database.close(function (error) {
43 |       if (error) {
44 |         console.log("Failed to close database:", error);
45 |         return
46 |       }
47 |     });
48 |   }
49 | });
50 | ```
51 | 
52 | ## Database Location
53 | 
54 | It will first look for the database filename you give in the `Documents` directory inside the app sandbox. If it doesn't find anything there it will look in the app bundle and try and copy it to the `Documents` directory. If it doesn't find the database in either place then it will create a new blank database in the `Documents` directory.
55 | 
56 | In the future it should probably be made possible to open/create databases in the `tmp` and `Libraries` directories.
57 | 
58 | ## Known Issues
59 | 
60 | - Doesn't support reading of BLOB fields right now. I'm not entirely sure what would be the best way to pass back binary data. Maybe Base64?
61 | - Database needs to be closed manually. I'm not sure how I could do
62 |   this automatically.
63 | 
64 | 
65 | ## Feedback Welcome!
66 | 
67 | Feedback, questions, suggestions and most of all Pull Requests are
68 | very welcome. This is an early version and I want to figure out the
69 | best way to continue it.
70 | 
71 | I'm also available for freelance work!
72 | 
73 | I'm [@almostobsolete](http://twitter.com/almostobsolete) on Twitter my
74 | email is [tom@almostobsolete.net](mailto:tom@almostobsolete.net) and
75 | you can find me on the web at
76 | [tomparslow.co.uk](http://tomparslow.co.uk) and
77 | [almostobsolete.net](http://almostobsolete.net)
78 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "react-native-sqlite",
 3 |   "version": "0.0.12",
 4 |   "description": "SQLite3 bindings for React Native",
 5 |   "main": "sqlite3.ios.js",
 6 |   "scripts": {
 7 |     "test": "echo \"Error: no test specified\" && exit 1"
 8 |   },
 9 |   "repository": {
10 |     "type": "git",
11 |     "url": "https://github.com/almost/react-native-sqlite.git"
12 |   },
13 |   "keywords": [
14 |     "react-component",
15 |     "reactnative",
16 |     "react-native",
17 |     "sqlite",
18 |     "sqlite3",
19 |     "ios"
20 |   ],
21 |   "author": "Thomas Parslow",
22 |   "license": "MIT",
23 |   "bugs": {
24 |     "url": "https://github.com/almost/react-native-sqlite/issues"
25 |   },
26 |   "homepage": "https://github.com/almost/react-native-sqlite",
27 |   "peerDependencies": {
28 |     "react-native": ">=0.6.0"
29 |   }
30 | }
31 | 


--------------------------------------------------------------------------------
/sqlite3.ios.js:
--------------------------------------------------------------------------------
  1 | // @flow
  2 | var NativeModules = require('react-native').NativeModules;
  3 | 
  4 | var nextId = 0;
  5 | 
  6 | function SQLite3Error(message: any) {
  7 |  this.message = message;
  8 | }
  9 | 
 10 | SQLite3Error.prototype = new Error();
 11 | 
 12 | function Database(databaseName, openCallback) {
 13 |   this._databaseId = null;
 14 |   this._databaseName = databaseName;
 15 |   // List of actions pending database connection
 16 |   this._pendingActions = [];
 17 | 
 18 |   NativeModules.AIBSQLite.openFromFilename(databaseName, (error, databaseId) => {
 19 |     if (error) {
 20 |       error = new SQLite3Error(error);
 21 |       this._failPendingActions(error);
 22 |       return openCallback(error, null);
 23 |     }
 24 |     this._databaseId = databaseId;
 25 |     this._runPendingActions();
 26 |     openCallback(null, this);
 27 |   });
 28 | }
 29 | 
 30 | Database.prototype = {
 31 | 
 32 |   getName(): string {
 33 |     return this._databaseName;
 34 |   },
 35 | 
 36 |   executeSQL (
 37 |     sql: string,
 38 |     params: Array<?(number|string)>,
 39 |     rowCallback: ((row: Object) => void),
 40 |     completeCallback: ((error: ?SQLite3Error) => void)
 41 |   ) : void {
 42 |     this._addAction(completeCallback, (callback) => {
 43 |       NativeModules.AIBSQLite.prepareStatement(this._databaseId, sql, params, (error, statementId) => {
 44 |         if (error) {
 45 |           completeCallback(new SQLite3Error(error));
 46 |           return;
 47 |         }
 48 |         var next = () => {
 49 |           NativeModules.AIBSQLite.stepStatement(this._databaseId, statementId, (error, row) => {
 50 |             if (error) {
 51 |               completeCallback(new SQLite3Error(error));
 52 |               return;
 53 |             }
 54 |             if (row === null) {
 55 |               completeCallback(null);
 56 |             } else {
 57 |               try {
 58 |                 rowCallback(row);
 59 |               } finally {
 60 |                 next();
 61 |               }
 62 |             }
 63 |           });
 64 |         };
 65 |         next();
 66 |       });
 67 |     });
 68 |   },
 69 | 
 70 |   close(callback: ?(error: ?SQLite3Error) => void) {
 71 |     NativeModules.AIBSQLite.closeDatabase(this._databaseId, (error) => {
 72 |       if (!callback) return;
 73 |       if (error) {
 74 |         callback(new SQLite3Error(error));
 75 |       } else {
 76 |         callback(null);
 77 |       }
 78 |     });
 79 |   },
 80 | 
 81 |   _addAction(callback, action) {
 82 |     if (this._databaseId) {
 83 |       action(callback);
 84 |     } else {
 85 |       this._pendingActions.push({action, callback});
 86 |     }
 87 |   },
 88 | 
 89 |   _runPendingActions () {
 90 |     this._pendingActions.forEach(
 91 |        ({action, callback}) => {
 92 |         action(callback);
 93 |       });
 94 |   },
 95 | 
 96 |   _failPendingActions (error) {
 97 |     this._pendingActions.forEach(
 98 |       ({action, callback}) => {
 99 |         callback(error);
100 |       });
101 |   }
102 | };
103 | 
104 | module.exports = {
105 |   SQLite3Error: SQLite3Error,
106 |   open (databaseName: string, callback: ?((error: ?SQLite3Error, database: ?Database) => void) ) : Database {
107 |     return new Database(databaseName, callback || ((e) => null));
108 |   }
109 | };
110 | 


--------------------------------------------------------------------------------