summaryrefslogtreecommitdiffstats
path: root/Classes
diff options
context:
space:
mode:
Diffstat (limited to 'Classes')
-rw-r--r--Classes/AcidCowFeedburnerParser.m4
-rw-r--r--Classes/FMDatabase.h118
-rw-r--r--Classes/FMDatabase.m815
-rw-r--r--Classes/FMDatabaseAdditions.h31
-rw-r--r--Classes/FMDatabaseAdditions.m114
-rw-r--r--Classes/FMResultSet.h93
-rw-r--r--Classes/FMResultSet.m405
-rw-r--r--Classes/PicCastAppDelegate.h2
-rw-r--r--Classes/PicCastAppDelegate.m45
-rw-r--r--Classes/SectionDictionary.h23
-rw-r--r--Classes/SectionDictionary.m64
-rw-r--r--Classes/Topic.h8
-rw-r--r--Classes/Topic.m58
-rw-r--r--Classes/TopicsViewController.h7
-rw-r--r--Classes/TopicsViewController.m96
-rw-r--r--Classes/fmdb_Prefix.pch7
16 files changed, 1873 insertions, 17 deletions
diff --git a/Classes/AcidCowFeedburnerParser.m b/Classes/AcidCowFeedburnerParser.m
index 46d7ec5..118aa43 100644
--- a/Classes/AcidCowFeedburnerParser.m
+++ b/Classes/AcidCowFeedburnerParser.m
@@ -15,12 +15,12 @@
- (void)downloadAndParse:(NSURL *)url {
- NSLog(@"downloadAndParse");
self.downloadAndParsePool = [[NSAutoreleasePool alloc] init];
done = NO;
self.parseFormatter = [[[NSDateFormatter alloc] init] autorelease];
[parseFormatter setDateStyle:NSDateFormatterLongStyle];
[parseFormatter setTimeStyle:NSDateFormatterNoStyle];
+ [parseFormatter setDateFormat:@"EEE, d MMM yyyy HH:mm:ss Z"];
// necessary because iTunes RSS feed is not localized, so if the device region has been set to other than US
// the date formatter must be set to US locale in order to parse the dates
[parseFormatter setLocale:[[[NSLocale alloc] initWithLocaleIdentifier:@"US"] autorelease]];
@@ -169,7 +169,7 @@ static NSString *kName_Guid = @"guid";
} else if ([elementName isEqualToString:kName_Guid]) {
currentTopic.guid = currentString;
} else if ([elementName isEqualToString:kName_Creator]) {
- currentTopic.creator = currentString;
+ //currentTopic.creator = currentString;
} else if ([elementName isEqualToString:kName_Description]) {
NSRegularExpression* regex = [NSRegularExpression regularExpressionWithPattern:@"http\\S+(jpg|png|gif|jpeg)"
options:NSRegularExpressionCaseInsensitive
diff --git a/Classes/FMDatabase.h b/Classes/FMDatabase.h
new file mode 100644
index 0000000..f125d61
--- /dev/null
+++ b/Classes/FMDatabase.h
@@ -0,0 +1,118 @@
+#import <Foundation/Foundation.h>
+#import "sqlite3.h"
+#import "FMResultSet.h"
+
+@interface FMDatabase : NSObject
+{
+ sqlite3* db;
+ NSString* databasePath;
+ BOOL logsErrors;
+ BOOL crashOnErrors;
+ BOOL inUse;
+ BOOL inTransaction;
+ BOOL traceExecution;
+ BOOL checkedOut;
+ int busyRetryTimeout;
+ BOOL shouldCacheStatements;
+ NSMutableDictionary *cachedStatements;
+ NSMutableSet *openResultSets;
+}
+
+
++ (id)databaseWithPath:(NSString*)inPath;
+- (id)initWithPath:(NSString*)inPath;
+
+- (BOOL)open;
+#if SQLITE_VERSION_NUMBER >= 3005000
+- (BOOL)openWithFlags:(int)flags;
+#endif
+- (BOOL)close;
+- (BOOL)goodConnection;
+- (void)clearCachedStatements;
+- (void)closeOpenResultSets;
+
+// encryption methods. You need to have purchased the sqlite encryption extensions for these to work.
+- (BOOL)setKey:(NSString*)key;
+- (BOOL)rekey:(NSString*)key;
+
+
+- (NSString *)databasePath;
+
+- (NSString*)lastErrorMessage;
+
+- (int)lastErrorCode;
+- (BOOL)hadError;
+- (sqlite_int64)lastInsertRowId;
+
+- (sqlite3*)sqliteHandle;
+
+- (BOOL)update:(NSString*)sql error:(NSError**)outErr bind:(id)bindArgs, ...;
+- (BOOL)executeUpdate:(NSString*)sql, ...;
+- (BOOL)executeUpdate:(NSString*)sql withArgumentsInArray:(NSArray *)arguments;
+- (BOOL)executeUpdate:(NSString*)sql error:(NSError**)outErr withArgumentsInArray:(NSArray*)arrayArgs orVAList:(va_list)args; // you shouldn't ever need to call this. use the previous two instead.
+
+- (FMResultSet *)executeQuery:(NSString*)sql, ...;
+- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments;
+- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orVAList:(va_list)args; // you shouldn't ever need to call this. use the previous two instead.
+
+- (BOOL)rollback;
+- (BOOL)commit;
+- (BOOL)beginTransaction;
+- (BOOL)beginDeferredTransaction;
+
+- (BOOL)logsErrors;
+- (void)setLogsErrors:(BOOL)flag;
+
+- (BOOL)crashOnErrors;
+- (void)setCrashOnErrors:(BOOL)flag;
+
+- (BOOL)inUse;
+- (void)setInUse:(BOOL)value;
+
+- (BOOL)inTransaction;
+- (void)setInTransaction:(BOOL)flag;
+
+- (BOOL)traceExecution;
+- (void)setTraceExecution:(BOOL)flag;
+
+- (BOOL)checkedOut;
+- (void)setCheckedOut:(BOOL)flag;
+
+- (int)busyRetryTimeout;
+- (void)setBusyRetryTimeout:(int)newBusyRetryTimeout;
+
+- (BOOL)shouldCacheStatements;
+- (void)setShouldCacheStatements:(BOOL)value;
+
+- (NSMutableDictionary *)cachedStatements;
+- (void)setCachedStatements:(NSMutableDictionary *)value;
+
+
++ (NSString*)sqliteLibVersion;
+
+- (int)changes;
+
+@end
+
+@interface FMStatement : NSObject {
+ sqlite3_stmt *statement;
+ NSString *query;
+ long useCount;
+}
+
+
+- (void)close;
+- (void)reset;
+
+- (sqlite3_stmt *)statement;
+- (void)setStatement:(sqlite3_stmt *)value;
+
+- (NSString *)query;
+- (void)setQuery:(NSString *)value;
+
+- (long)useCount;
+- (void)setUseCount:(long)value;
+
+
+@end
+
diff --git a/Classes/FMDatabase.m b/Classes/FMDatabase.m
new file mode 100644
index 0000000..46d963b
--- /dev/null
+++ b/Classes/FMDatabase.m
@@ -0,0 +1,815 @@
+#import "FMDatabase.h"
+#import "unistd.h"
+
+@implementation FMDatabase
+
++ (id)databaseWithPath:(NSString*)aPath {
+ return [[[self alloc] initWithPath:aPath] autorelease];
+}
+
+- (id)initWithPath:(NSString*)aPath {
+ self = [super init];
+
+ if (self) {
+ databasePath = [aPath copy];
+ openResultSets = [[NSMutableSet alloc] init];
+ db = 0x00;
+ logsErrors = 0x00;
+ crashOnErrors = 0x00;
+ busyRetryTimeout = 0x00;
+ }
+
+ return self;
+}
+
+- (void)finalize {
+ [self close];
+ [super finalize];
+}
+
+- (void)dealloc {
+ [self close];
+
+ [openResultSets release];
+ [cachedStatements release];
+ [databasePath release];
+
+ [super dealloc];
+}
+
++ (NSString*)sqliteLibVersion {
+ return [NSString stringWithFormat:@"%s", sqlite3_libversion()];
+}
+
+- (NSString *)databasePath {
+ return databasePath;
+}
+
+- (sqlite3*)sqliteHandle {
+ return db;
+}
+
+- (BOOL)open {
+ if (db) {
+ return YES;
+ }
+
+ int err = sqlite3_open((databasePath ? [databasePath fileSystemRepresentation] : ":memory:"), &db );
+ if(err != SQLITE_OK) {
+ NSLog(@"error opening!: %d", err);
+ return NO;
+ }
+
+ return YES;
+}
+
+#if SQLITE_VERSION_NUMBER >= 3005000
+- (BOOL)openWithFlags:(int)flags {
+ int err = sqlite3_open_v2((databasePath ? [databasePath fileSystemRepresentation] : ":memory:"), &db, flags, NULL /* Name of VFS module to use */);
+ if(err != SQLITE_OK) {
+ NSLog(@"error opening!: %d", err);
+ return NO;
+ }
+ return YES;
+}
+#endif
+
+
+- (BOOL)close {
+
+ [self clearCachedStatements];
+ [self closeOpenResultSets];
+
+ if (!db) {
+ return YES;
+ }
+
+ int rc;
+ BOOL retry;
+ int numberOfRetries = 0;
+ do {
+ retry = NO;
+ rc = sqlite3_close(db);
+ if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) {
+ retry = YES;
+ usleep(20);
+ if (busyRetryTimeout && (numberOfRetries++ > busyRetryTimeout)) {
+ NSLog(@"%s:%d", __FUNCTION__, __LINE__);
+ NSLog(@"Database busy, unable to close");
+ return NO;
+ }
+ }
+ else if (SQLITE_OK != rc) {
+ NSLog(@"error closing!: %d", rc);
+ }
+ }
+ while (retry);
+
+ db = nil;
+ return YES;
+}
+
+- (void)clearCachedStatements {
+
+ NSEnumerator *e = [cachedStatements objectEnumerator];
+ FMStatement *cachedStmt;
+
+ while ((cachedStmt = [e nextObject])) {
+ [cachedStmt close];
+ }
+
+ [cachedStatements removeAllObjects];
+}
+
+- (void)closeOpenResultSets {
+ //Copy the set so we don't get mutation errors
+ NSSet *resultSets = [[openResultSets copy] autorelease];
+
+ NSEnumerator *e = [resultSets objectEnumerator];
+ NSValue *returnedResultSet = nil;
+
+ while((returnedResultSet = [e nextObject])) {
+ FMResultSet *rs = (FMResultSet *)[returnedResultSet pointerValue];
+ if ([rs respondsToSelector:@selector(close)]) {
+ [rs close];
+ }
+ }
+}
+
+- (void)resultSetDidClose:(FMResultSet *)resultSet {
+ NSValue *setValue = [NSValue valueWithNonretainedObject:resultSet];
+ [openResultSets removeObject:setValue];
+}
+
+- (FMStatement*)cachedStatementForQuery:(NSString*)query {
+ return [cachedStatements objectForKey:query];
+}
+
+- (void)setCachedStatement:(FMStatement*)statement forQuery:(NSString*)query {
+ //NSLog(@"setting query: %@", query);
+ query = [query copy]; // in case we got handed in a mutable string...
+ [statement setQuery:query];
+ [cachedStatements setObject:statement forKey:query];
+ [query release];
+}
+
+
+- (BOOL)rekey:(NSString*)key {
+#ifdef SQLITE_HAS_CODEC
+ if (!key) {
+ return NO;
+ }
+
+ int rc = sqlite3_rekey(db, [key UTF8String], strlen([key UTF8String]));
+
+ if (rc != SQLITE_OK) {
+ NSLog(@"error on rekey: %d", rc);
+ NSLog(@"%@", [self lastErrorMessage]);
+ }
+
+ return (rc == SQLITE_OK);
+#else
+ return NO;
+#endif
+}
+
+- (BOOL)setKey:(NSString*)key {
+#ifdef SQLITE_HAS_CODEC
+ if (!key) {
+ return NO;
+ }
+
+ int rc = sqlite3_key(db, [key UTF8String], strlen([key UTF8String]));
+
+ return (rc == SQLITE_OK);
+#else
+ return NO;
+#endif
+}
+
+- (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)compainAboutInUse {
+ NSLog(@"The FMDatabase %@ is currently in use.", self);
+
+#ifndef NS_BLOCK_ASSERTIONS
+ if (crashOnErrors) {
+ NSAssert1(false, @"The FMDatabase %@ is currently in use.", self);
+ }
+#endif
+}
+
+- (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);
+}
+
+- (sqlite_int64)lastInsertRowId {
+
+ if (inUse) {
+ [self compainAboutInUse];
+ return NO;
+ }
+ [self setInUse:YES];
+
+ sqlite_int64 ret = sqlite3_last_insert_rowid(db);
+
+ [self setInUse:NO];
+
+ return ret;
+}
+
+- (int)changes {
+ if (inUse) {
+ [self compainAboutInUse];
+ return 0;
+ }
+
+ [self setInUse:YES];
+ int ret = sqlite3_changes(db);
+ [self setInUse:NO];
+
+ return ret;
+}
+
+- (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]]) {
+ sqlite3_bind_blob(pStmt, idx, [obj bytes], (int)[obj length], SQLITE_STATIC);
+ }
+ else if ([obj isKindOfClass:[NSDate class]]) {
+ sqlite3_bind_double(pStmt, idx, [obj timeIntervalSince1970]);
+ }
+ else if ([obj isKindOfClass:[NSNumber class]]) {
+
+ if (strcmp([obj objCType], @encode(BOOL)) == 0) {
+ sqlite3_bind_int(pStmt, idx, ([obj boolValue] ? 1 : 0));
+ }
+ else if (strcmp([obj objCType], @encode(int)) == 0) {
+ sqlite3_bind_int64(pStmt, idx, [obj longValue]);
+ }
+ else if (strcmp([obj objCType], @encode(long)) == 0) {
+ sqlite3_bind_int64(pStmt, idx, [obj longValue]);
+ }
+ else if (strcmp([obj objCType], @encode(long long)) == 0) {
+ sqlite3_bind_int64(pStmt, idx, [obj longLongValue]);
+ }
+ 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 {
+ sqlite3_bind_text(pStmt, idx, [[obj description] UTF8String], -1, SQLITE_STATIC);
+ }
+ }
+ else {
+ sqlite3_bind_text(pStmt, idx, [[obj description] UTF8String], -1, SQLITE_STATIC);
+ }
+}
+
+- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray*)arrayArgs orVAList:(va_list)args {
+
+ if (inUse) {
+ [self compainAboutInUse];
+ return nil;
+ }
+
+ [self setInUse:YES];
+
+ FMResultSet *rs = nil;
+
+ int rc = 0x00;;
+ sqlite3_stmt *pStmt = 0x00;;
+ FMStatement *statement = 0x00;
+
+ if (traceExecution && sql) {
+ NSLog(@"%@ executeQuery: %@", self, sql);
+ }
+
+ if (shouldCacheStatements) {
+ statement = [self cachedStatementForQuery:sql];
+ pStmt = statement ? [statement statement] : 0x00;
+ }
+
+ int numberOfRetries = 0;
+ BOOL retry = NO;
+
+ if (!pStmt) {
+ do {
+ retry = NO;
+ rc = sqlite3_prepare_v2(db, [sql UTF8String], -1, &pStmt, 0);
+
+ if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) {
+ retry = YES;
+ usleep(20);
+
+ if (busyRetryTimeout && (numberOfRetries++ > busyRetryTimeout)) {
+ NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]);
+ NSLog(@"Database busy");
+ sqlite3_finalize(pStmt);
+ [self setInUse:NO];
+ return nil;
+ }
+ }
+ else if (SQLITE_OK != rc) {
+
+
+ if (logsErrors) {
+ NSLog(@"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]);
+ NSLog(@"DB Query: %@", sql);
+#ifndef NS_BLOCK_ASSERTIONS
+ if (crashOnErrors) {
+ NSAssert2(false, @"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]);
+ }
+#endif
+ }
+
+ sqlite3_finalize(pStmt);
+
+ [self setInUse:NO];
+ return nil;
+ }
+ }
+ while (retry);
+ }
+
+ id obj;
+ int idx = 0;
+ int queryCount = sqlite3_bind_parameter_count(pStmt); // pointed out by Dominic Yu (thanks!)
+
+ while (idx < queryCount) {
+
+ if (arrayArgs) {
+ obj = [arrayArgs objectAtIndex:idx];
+ }
+ else {
+ obj = va_arg(args, id);
+ }
+
+ if (traceExecution) {
+ 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);
+ [self setInUse:NO];
+ return nil;
+ }
+
+ [statement retain]; // to balance the release below
+
+ if (!statement) {
+ statement = [[FMStatement alloc] init];
+ [statement setStatement:pStmt];
+
+ if (shouldCacheStatements) {
+ [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.useCount = statement.useCount + 1;
+
+ [statement release];
+
+ [self setInUse:NO];
+
+ return rs;
+}
+
+- (FMResultSet *)executeQuery:(NSString*)sql, ... {
+ va_list args;
+ va_start(args, sql);
+
+ id result = [self executeQuery:sql withArgumentsInArray:nil orVAList:args];
+
+ va_end(args);
+ return result;
+}
+
+- (FMResultSet *)executeQuery:(NSString *)sql withArgumentsInArray:(NSArray *)arguments {
+ return [self executeQuery:sql withArgumentsInArray:arguments orVAList:nil];
+}
+
+- (BOOL)executeUpdate:(NSString*)sql error:(NSError**)outErr withArgumentsInArray:(NSArray*)arrayArgs orVAList:(va_list)args {
+
+ if (inUse) {
+ [self compainAboutInUse];
+ return NO;
+ }
+
+ [self setInUse: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;
+ }
+
+ int numberOfRetries = 0;
+ BOOL retry = NO;
+
+ if (!pStmt) {
+
+ do {
+ retry = NO;
+ rc = sqlite3_prepare_v2(db, [sql UTF8String], -1, &pStmt, 0);
+ if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) {
+ retry = YES;
+ usleep(20);
+
+ if (busyRetryTimeout && (numberOfRetries++ > busyRetryTimeout)) {
+ NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]);
+ NSLog(@"Database busy");
+ sqlite3_finalize(pStmt);
+ [self setInUse:NO];
+ return NO;
+ }
+ }
+ else if (SQLITE_OK != rc) {
+
+
+ if (logsErrors) {
+ NSLog(@"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]);
+ NSLog(@"DB Query: %@", sql);
+#ifndef NS_BLOCK_ASSERTIONS
+ if (crashOnErrors) {
+ NSAssert2(false, @"DB Error: %d \"%@\"", [self lastErrorCode], [self lastErrorMessage]);
+ }
+#endif
+ }
+
+ sqlite3_finalize(pStmt);
+ [self setInUse:NO];
+
+ if (outErr) {
+ *outErr = [NSError errorWithDomain:[NSString stringWithUTF8String:sqlite3_errmsg(db)] code:rc userInfo:nil];
+ }
+
+ return NO;
+ }
+ }
+ while (retry);
+ }
+
+
+ id obj;
+ int idx = 0;
+ int queryCount = sqlite3_bind_parameter_count(pStmt);
+
+ while (idx < queryCount) {
+
+ if (arrayArgs) {
+ obj = [arrayArgs objectAtIndex:idx];
+ }
+ else {
+ obj = va_arg(args, id);
+ }
+
+
+ if (traceExecution) {
+ 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 (%@) (executeUpdate)", sql);
+ sqlite3_finalize(pStmt);
+ [self setInUse: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.
+ */
+ numberOfRetries = 0;
+ do {
+ rc = sqlite3_step(pStmt);
+ retry = NO;
+
+ if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) {
+ // this will happen if the db is locked, like if we are doing an update or insert.
+ // in that case, retry the step... and maybe wait just 10 milliseconds.
+ retry = YES;
+ if (SQLITE_LOCKED == rc) {
+ rc = sqlite3_reset(pStmt);
+ if (rc != SQLITE_LOCKED) {
+ NSLog(@"Unexpected result from sqlite3_reset (%d) eu", rc);
+ }
+ }
+ usleep(20);
+
+ if (busyRetryTimeout && (numberOfRetries++ > busyRetryTimeout)) {
+ NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [self databasePath]);
+ NSLog(@"Database busy");
+ retry = NO;
+ }
+ }
+ else if (SQLITE_DONE == rc || SQLITE_ROW == rc) {
+ // all is well, let's return.
+ }
+ else if (SQLITE_ERROR == rc) {
+ NSLog(@"Error calling sqlite3_step (%d: %s) SQLITE_ERROR", rc, sqlite3_errmsg(db));
+ NSLog(@"DB Query: %@", sql);
+ }
+ else if (SQLITE_MISUSE == rc) {
+ // uh oh.
+ NSLog(@"Error calling sqlite3_step (%d: %s) SQLITE_MISUSE", rc, sqlite3_errmsg(db));
+ NSLog(@"DB Query: %@", sql);
+ }
+ else {
+ // wtf?
+ NSLog(@"Unknown error calling sqlite3_step (%d: %s) eu", rc, sqlite3_errmsg(db));
+ NSLog(@"DB Query: %@", sql);
+ }
+
+ } while (retry);
+
+ assert( rc!=SQLITE_ROW );
+
+
+ if (shouldCacheStatements && !cachedStmt) {
+ cachedStmt = [[FMStatement alloc] init];
+
+ [cachedStmt setStatement:pStmt];
+
+ [self setCachedStatement:cachedStmt forQuery:sql];
+
+ [cachedStmt release];
+ }
+
+ if (cachedStmt) {
+ cachedStmt.useCount = cachedStmt.useCount + 1;
+ rc = sqlite3_reset(pStmt);
+ }
+ else {
+ /* Finalize the virtual machine. This releases all memory and other
+ ** resources allocated by the sqlite3_prepare() call above.
+ */
+ rc = sqlite3_finalize(pStmt);
+ }
+
+ [self setInUse:NO];
+
+ return (rc == SQLITE_OK);
+}
+
+
+- (BOOL)executeUpdate:(NSString*)sql, ... {
+ va_list args;
+ va_start(args, sql);
+
+ BOOL result = [self executeUpdate:sql error:nil withArgumentsInArray:nil orVAList:args];
+
+ va_end(args);
+ return result;
+}
+
+
+
+- (BOOL)executeUpdate:(NSString*)sql withArgumentsInArray:(NSArray *)arguments {
+ return [self executeUpdate:sql error:nil withArgumentsInArray:arguments orVAList:nil];
+}
+
+- (BOOL)update:(NSString*)sql error:(NSError**)outErr bind:(id)bindArgs, ... {
+ va_list args;
+ va_start(args, bindArgs);
+
+ BOOL result = [self executeUpdate:sql error:outErr withArgumentsInArray:nil orVAList:args];
+
+ va_end(args);
+ return result;
+}
+
+- (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)logsErrors {
+ return logsErrors;
+}
+- (void)setLogsErrors:(BOOL)flag {
+ logsErrors = flag;
+}
+
+- (BOOL)crashOnErrors {
+ return crashOnErrors;
+}
+- (void)setCrashOnErrors:(BOOL)flag {
+ crashOnErrors = flag;
+}
+
+- (BOOL)inUse {
+ return inUse || inTransaction;
+}
+
+- (void)setInUse:(BOOL)b {
+ inUse = b;
+}
+
+- (BOOL)inTransaction {
+ return inTransaction;
+}
+- (void)setInTransaction:(BOOL)flag {
+ inTransaction = flag;
+}
+
+- (BOOL)traceExecution {
+ return traceExecution;
+}
+- (void)setTraceExecution:(BOOL)flag {
+ traceExecution = flag;
+}
+
+- (BOOL)checkedOut {
+ return checkedOut;
+}
+- (void)setCheckedOut:(BOOL)flag {
+ checkedOut = flag;
+}
+
+
+- (int)busyRetryTimeout {
+ return busyRetryTimeout;
+}
+- (void)setBusyRetryTimeout:(int)newBusyRetryTimeout {
+ busyRetryTimeout = newBusyRetryTimeout;
+}
+
+
+- (BOOL)shouldCacheStatements {
+ return shouldCacheStatements;
+}
+
+- (void)setShouldCacheStatements:(BOOL)value {
+
+ shouldCacheStatements = value;
+
+ if (shouldCacheStatements && !cachedStatements) {
+ [self setCachedStatements:[NSMutableDictionary dictionary]];
+ }
+
+ if (!shouldCacheStatements) {
+ [self setCachedStatements:nil];
+ }
+}
+
+- (NSMutableDictionary *)cachedStatements {
+ return cachedStatements;
+}
+
+- (void)setCachedStatements:(NSMutableDictionary *)value {
+ if (cachedStatements != value) {
+ [cachedStatements release];
+ cachedStatements = [value retain];
+ }
+}
+
+
+@end
+
+
+
+@implementation FMStatement
+
+- (void)finalize {
+ [self close];
+ [super finalize];
+}
+
+- (void)dealloc {
+ [self close];
+ [query release];
+ [super dealloc];
+}
+
+
+- (void)close {
+ if (statement) {
+ sqlite3_finalize(statement);
+ statement = 0x00;
+ }
+}
+
+- (void)reset {
+ if (statement) {
+ sqlite3_reset(statement);
+ }
+}
+
+- (sqlite3_stmt *)statement {
+ return statement;
+}
+
+- (void)setStatement:(sqlite3_stmt *)value {
+ statement = value;
+}
+
+- (NSString *)query {
+ return query;
+}
+
+- (void)setQuery:(NSString *)value {
+ if (query != value) {
+ [query release];
+ query = [value retain];
+ }
+}
+
+- (long)useCount {
+ return useCount;
+}
+
+- (void)setUseCount:(long)value {
+ if (useCount != value) {
+ useCount = value;
+ }
+}
+
+- (NSString*)description {
+ return [NSString stringWithFormat:@"%@ %d hit(s) for query %@", [super description], useCount, query];
+}
+
+
+@end
+
diff --git a/Classes/FMDatabaseAdditions.h b/Classes/FMDatabaseAdditions.h
new file mode 100644
index 0000000..3846268
--- /dev/null
+++ b/Classes/FMDatabaseAdditions.h
@@ -0,0 +1,31 @@
+//
+// FMDatabaseAdditions.h
+// fmkit
+//
+// Created by August Mueller on 10/30/05.
+// Copyright 2005 Flying Meat Inc.. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+@interface FMDatabase (FMDatabaseAdditions)
+
+
+- (int)intForQuery:(NSString*)objs, ...;
+- (long)longForQuery:(NSString*)objs, ...;
+- (BOOL)boolForQuery:(NSString*)objs, ...;
+- (double)doubleForQuery:(NSString*)objs, ...;
+- (NSString*)stringForQuery:(NSString*)objs, ...;
+- (NSData*)dataForQuery:(NSString*)objs, ...;
+- (NSDate*)dateForQuery:(NSString*)objs, ...;
+
+// Notice that there's no dataNoCopyForQuery:.
+// That would be a bad idea, because we close out the result set, and then what
+// happens to the data that we just didn't copy? Who knows, not I.
+
+
+- (BOOL)tableExists:(NSString*)tableName;
+- (FMResultSet*)getSchema;
+- (FMResultSet*)getTableSchema:(NSString*)tableName;
+- (BOOL)columnExists:(NSString*)tableName columnName:(NSString*)columnName;
+
+@end
diff --git a/Classes/FMDatabaseAdditions.m b/Classes/FMDatabaseAdditions.m
new file mode 100644
index 0000000..3ac45cb
--- /dev/null
+++ b/Classes/FMDatabaseAdditions.m
@@ -0,0 +1,114 @@
+//
+// FMDatabaseAdditions.m
+// fmkit
+//
+// Created by August Mueller on 10/30/05.
+// Copyright 2005 Flying Meat Inc.. All rights reserved.
+//
+
+#import "FMDatabase.h"
+#import "FMDatabaseAdditions.h"
+
+@implementation FMDatabase (FMDatabaseAdditions)
+
+#define RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(type, sel) \
+va_list args; \
+va_start(args, query); \
+FMResultSet *resultSet = [self executeQuery:query withArgumentsInArray:0x00 orVAList:args]; \
+va_end(args); \
+if (![resultSet next]) { return (type)0; } \
+type ret = [resultSet sel:0]; \
+[resultSet close]; \
+[resultSet setParentDB:nil]; \
+return ret;
+
+
+- (NSString*)stringForQuery:(NSString*)query, ... {
+ RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSString *, stringForColumnIndex);
+}
+
+- (int)intForQuery:(NSString*)query, ... {
+ RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(int, intForColumnIndex);
+}
+
+- (long)longForQuery:(NSString*)query, ... {
+ RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(long, longForColumnIndex);
+}
+
+- (BOOL)boolForQuery:(NSString*)query, ... {
+ RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(BOOL, boolForColumnIndex);
+}
+
+- (double)doubleForQuery:(NSString*)query, ... {
+ RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(double, doubleForColumnIndex);
+}
+
+- (NSData*)dataForQuery:(NSString*)query, ... {
+ RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSData *, dataForColumnIndex);
+}
+
+- (NSDate*)dateForQuery:(NSString*)query, ... {
+ RETURN_RESULT_FOR_QUERY_WITH_SELECTOR(NSDate *, dateForColumnIndex);
+}
+
+
+//check if table exist in database (patch from OZLB)
+- (BOOL)tableExists:(NSString*)tableName {
+
+ BOOL returnBool;
+ //lower case table name
+ tableName = [tableName lowercaseString];
+ //search in sqlite_master table if table exists
+ FMResultSet *rs = [self executeQuery:@"select [sql] from sqlite_master where [type] = 'table' and lower(name) = ?", tableName];
+ //if at least one next exists, table exists
+ returnBool = [rs next];
+ //close and free object
+ [rs close];
+
+ return returnBool;
+}
+
+//get table with list of tables: result colums: type[STRING], name[STRING],tbl_name[STRING],rootpage[INTEGER],sql[STRING]
+//check if table exist in database (patch from OZLB)
+- (FMResultSet*)getSchema {
+
+ //result colums: type[STRING], name[STRING],tbl_name[STRING],rootpage[INTEGER],sql[STRING]
+ FMResultSet *rs = [self executeQuery:@"SELECT type, name, tbl_name, rootpage, sql FROM (SELECT * FROM sqlite_master UNION ALL SELECT * FROM sqlite_temp_master) WHERE type != 'meta' AND name NOT LIKE 'sqlite_%' ORDER BY tbl_name, type DESC, name"];
+
+ return rs;
+}
+
+//get table schema: result colums: cid[INTEGER], name,type [STRING], notnull[INTEGER], dflt_value[],pk[INTEGER]
+- (FMResultSet*)getTableSchema:(NSString*)tableName {
+
+ //result colums: cid[INTEGER], name,type [STRING], notnull[INTEGER], dflt_value[],pk[INTEGER]
+ FMResultSet *rs = [self executeQuery:[NSString stringWithFormat: @"PRAGMA table_info(%@)", tableName]];
+
+ return rs;
+}
+
+
+//check if column exist in table
+- (BOOL)columnExists:(NSString*)tableName columnName:(NSString*)columnName {
+
+ BOOL returnBool = NO;
+ //lower case table name
+ tableName = [tableName lowercaseString];
+ //lower case column name
+ columnName = [columnName lowercaseString];
+ //get table schema
+ FMResultSet *rs = [self getTableSchema: tableName];
+ //check if column is present in table schema
+ while ([rs next]) {
+ if ([[[rs stringForColumn:@"name"] lowercaseString] isEqualToString: columnName]) {
+ returnBool = YES;
+ break;
+ }
+ }
+ //close and free object
+ [rs close];
+
+ return returnBool;
+}
+
+@end
diff --git a/Classes/FMResultSet.h b/Classes/FMResultSet.h
new file mode 100644
index 0000000..306676e
--- /dev/null
+++ b/Classes/FMResultSet.h
@@ -0,0 +1,93 @@
+#import <Foundation/Foundation.h>
+#import "sqlite3.h"
+
+#ifndef __has_feature // Optional.
+#define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#endif
+
+#ifndef NS_RETURNS_NOT_RETAINED
+#if __has_feature(attribute_ns_returns_not_retained)
+#define NS_RETURNS_NOT_RETAINED __attribute__((ns_returns_not_retained))
+#else
+#define NS_RETURNS_NOT_RETAINED
+#endif
+#endif
+
+@class FMDatabase;
+@class FMStatement;
+
+@interface FMResultSet : NSObject {
+ FMDatabase *parentDB;
+ FMStatement *statement;
+
+ NSString *query;
+ NSMutableDictionary *columnNameToIndexMap;
+ BOOL columnNamesSetup;
+}
+
+
++ (id)resultSetWithStatement:(FMStatement *)statement usingParentDatabase:(FMDatabase*)aDB;
+
+- (void)close;
+
+- (NSString *)query;
+- (void)setQuery:(NSString *)value;
+
+- (FMStatement *)statement;
+- (void)setStatement:(FMStatement *)value;
+
+- (void)setParentDB:(FMDatabase *)newDb;
+
+- (BOOL)next;
+- (BOOL)hasAnotherRow;
+
+- (int)columnIndexForName:(NSString*)columnName;
+- (NSString*)columnNameForIndex:(int)columnIdx;
+
+- (int)intForColumn:(NSString*)columnName;
+- (int)intForColumnIndex:(int)columnIdx;
+
+- (long)longForColumn:(NSString*)columnName;
+- (long)longForColumnIndex:(int)columnIdx;
+
+- (long long int)longLongIntForColumn:(NSString*)columnName;
+- (long long int)longLongIntForColumnIndex:(int)columnIdx;
+
+- (BOOL)boolForColumn:(NSString*)columnName;
+- (BOOL)boolForColumnIndex:(int)columnIdx;
+
+- (double)doubleForColumn:(NSString*)columnName;
+- (double)doubleForColumnIndex:(int)columnIdx;
+
+- (NSString*)stringForColumn:(NSString*)columnName;
+- (NSString*)stringForColumnIndex:(int)columnIdx;
+
+- (NSDate*)dateForColumn:(NSString*)columnName;
+- (NSDate*)dateForColumnIndex:(int)columnIdx;
+
+- (NSData*)dataForColumn:(NSString*)columnName;
+- (NSData*)dataForColumnIndex:(int)columnIdx;
+
+- (const unsigned char *)UTF8StringForColumnIndex:(int)columnIdx;
+- (const unsigned char *)UTF8StringForColumnName:(NSString*)columnName;
+
+// returns one of NSNumber, NSString, NSData, or NSNull
+- (id)objectForColumnIndex:(int)columnIdx;
+- (id)objectForColumnName:(NSString*)columnName;
+
+/*
+If you are going to use this data after you iterate over the next row, or after you close the
+result set, make sure to make a copy of the data first (or just use dataForColumn:/dataForColumnIndex:)
+If you don't, you're going to be in a world of hurt when you try and use the data.
+*/
+- (NSData*)dataNoCopyForColumn:(NSString*)columnName NS_RETURNS_NOT_RETAINED;
+- (NSData*)dataNoCopyForColumnIndex:(int)columnIdx NS_RETURNS_NOT_RETAINED;
+
+
+- (BOOL)columnIndexIsNull:(int)columnIdx;
+- (BOOL)columnIsNull:(NSString*)columnName;
+
+- (void)kvcMagic:(id)object;
+- (NSDictionary *)resultDict;
+
+@end
diff --git a/Classes/FMResultSet.m b/Classes/FMResultSet.m
new file mode 100644
index 0000000..027257e
--- /dev/null
+++ b/Classes/FMResultSet.m
@@ -0,0 +1,405 @@
+#import "FMResultSet.h"
+#import "FMDatabase.h"
+#import "unistd.h"
+
+@interface FMDatabase ()
+- (void)resultSetDidClose:(FMResultSet *)resultSet;
+@end
+
+
+@interface FMResultSet (Private)
+- (NSMutableDictionary *)columnNameToIndexMap;
+- (void)setColumnNameToIndexMap:(NSMutableDictionary *)value;
+@end
+
+@implementation FMResultSet
+
++ (id)resultSetWithStatement:(FMStatement *)statement usingParentDatabase:(FMDatabase*)aDB {
+
+ FMResultSet *rs = [[FMResultSet alloc] init];
+
+ [rs setStatement:statement];
+ [rs setParentDB:aDB];
+
+ return [rs autorelease];
+}
+
+- (void)finalize {
+ [self close];
+ [super finalize];
+}
+
+- (void)dealloc {
+ [self close];
+
+ [query release];
+ query = nil;
+
+ [columnNameToIndexMap release];
+ columnNameToIndexMap = nil;
+
+ [super dealloc];
+}
+
+- (void)close {
+ [statement reset];
+ [statement release];
+ statement = nil;
+
+ // we don't need this anymore... (i think)
+ //[parentDB setInUse:NO];
+ [parentDB resultSetDidClose:self];
+ parentDB = nil;
+}
+
+- (void)setupColumnNames {
+
+ if (!columnNameToIndexMap) {
+ [self setColumnNameToIndexMap:[NSMutableDictionary dictionary]];
+ }
+
+ int columnCount = sqlite3_column_count(statement.statement);
+
+ int columnIdx = 0;
+ for (columnIdx = 0; columnIdx < columnCount; columnIdx++) {
+ [columnNameToIndexMap setObject:[NSNumber numberWithInt:columnIdx]
+ forKey:[[NSString stringWithUTF8String:sqlite3_column_name(statement.statement, columnIdx)] lowercaseString]];
+ }
+ columnNamesSetup = YES;
+}
+
+- (void)kvcMagic:(id)object {
+
+ int columnCount = sqlite3_column_count(statement.statement);
+
+ int columnIdx = 0;
+ for (columnIdx = 0; columnIdx < columnCount; columnIdx++) {
+
+ const char *c = (const char *)sqlite3_column_text(statement.statement, columnIdx);
+
+ // check for a null row
+ if (c) {
+ NSString *s = [NSString stringWithUTF8String:c];
+
+ [object setValue:s forKey:[NSString stringWithUTF8String:sqlite3_column_name(statement.statement, columnIdx)]];
+ }
+ }
+}
+
+- (NSDictionary *)resultDict {
+
+ int num_cols = sqlite3_data_count(statement.statement);
+
+ if (num_cols > 0) {
+ NSMutableDictionary *dict = [NSMutableDictionary dictionaryWithCapacity:num_cols];
+
+ if (!columnNamesSetup) {
+ [self setupColumnNames];
+ }
+
+ NSEnumerator *columnNames = [columnNameToIndexMap keyEnumerator];
+ NSString *columnName = nil;
+ while ((columnName = [columnNames nextObject])) {
+ id objectValue = [self objectForColumnName:columnName];
+ [dict setObject:objectValue forKey:columnName];
+ }
+
+ return [[dict copy] autorelease];
+ }
+ else {
+ NSLog(@"Warning: There seem to be no columns in this set.");
+ }
+
+ return nil;
+}
+
+- (BOOL)next {
+
+ int rc;
+ BOOL retry;
+ int numberOfRetries = 0;
+ do {
+ retry = NO;
+
+ rc = sqlite3_step(statement.statement);
+
+ if (SQLITE_BUSY == rc || SQLITE_LOCKED == rc) {
+ // this will happen if the db is locked, like if we are doing an update or insert.
+ // in that case, retry the step... and maybe wait just 10 milliseconds.
+ retry = YES;
+ if (SQLITE_LOCKED == rc) {
+ rc = sqlite3_reset(statement.statement);
+ if (rc != SQLITE_LOCKED) {
+ NSLog(@"Unexpected result from sqlite3_reset (%d) rs", rc);
+ }
+ }
+ usleep(20);
+
+ if ([parentDB busyRetryTimeout] && (numberOfRetries++ > [parentDB busyRetryTimeout])) {
+
+ NSLog(@"%s:%d Database busy (%@)", __FUNCTION__, __LINE__, [parentDB databasePath]);
+ NSLog(@"Database busy");
+ break;
+ }
+ }
+ else if (SQLITE_DONE == rc || SQLITE_ROW == rc) {
+ // all is well, let's return.
+ }
+ else if (SQLITE_ERROR == rc) {
+ NSLog(@"Error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([parentDB sqliteHandle]));
+ break;
+ }
+ else if (SQLITE_MISUSE == rc) {
+ // uh oh.
+ NSLog(@"Error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([parentDB sqliteHandle]));
+ break;
+ }
+ else {
+ // wtf?
+ NSLog(@"Unknown error calling sqlite3_step (%d: %s) rs", rc, sqlite3_errmsg([parentDB sqliteHandle]));
+ break;
+ }
+
+ } while (retry);
+
+
+ if (rc != SQLITE_ROW) {
+ [self close];
+ }
+
+ return (rc == SQLITE_ROW);
+}
+
+- (BOOL)hasAnotherRow {
+ return sqlite3_errcode([parentDB sqliteHandle]) == SQLITE_ROW;
+}
+
+- (int)columnIndexForName:(NSString*)columnName {
+
+ if (!columnNamesSetup) {
+ [self setupColumnNames];
+ }
+
+ columnName = [columnName lowercaseString];
+
+ NSNumber *n = [columnNameToIndexMap objectForKey:columnName];
+
+ if (n) {
+ return [n intValue];
+ }
+
+ NSLog(@"Warning: I could not find the column named '%@'.", columnName);
+
+ return -1;
+}
+
+
+
+- (int)intForColumn:(NSString*)columnName {
+ return [self intForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (int)intForColumnIndex:(int)columnIdx {
+ return sqlite3_column_int(statement.statement, columnIdx);
+}
+
+- (long)longForColumn:(NSString*)columnName {
+ return [self longForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (long)longForColumnIndex:(int)columnIdx {
+ return (long)sqlite3_column_int64(statement.statement, columnIdx);
+}
+
+- (long long int)longLongIntForColumn:(NSString*)columnName {
+ return [self longLongIntForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (long long int)longLongIntForColumnIndex:(int)columnIdx {
+ return sqlite3_column_int64(statement.statement, columnIdx);
+}
+
+- (BOOL)boolForColumn:(NSString*)columnName {
+ return [self boolForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (BOOL)boolForColumnIndex:(int)columnIdx {
+ return ([self intForColumnIndex:columnIdx] != 0);
+}
+
+- (double)doubleForColumn:(NSString*)columnName {
+ return [self doubleForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (double)doubleForColumnIndex:(int)columnIdx {
+ return sqlite3_column_double(statement.statement, columnIdx);
+}
+
+- (NSString*)stringForColumnIndex:(int)columnIdx {
+
+ if (sqlite3_column_type(statement.statement, columnIdx) == SQLITE_NULL || (columnIdx < 0)) {
+ return nil;
+ }
+
+ const char *c = (const char *)sqlite3_column_text(statement.statement, columnIdx);
+
+ if (!c) {
+ // null row.
+ return nil;
+ }
+
+ return [NSString stringWithUTF8String:c];
+}
+
+- (NSString*)stringForColumn:(NSString*)columnName {
+ return [self stringForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (NSDate*)dateForColumn:(NSString*)columnName {
+ return [self dateForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (NSDate*)dateForColumnIndex:(int)columnIdx {
+
+ if (sqlite3_column_type(statement.statement, columnIdx) == SQLITE_NULL || (columnIdx < 0)) {
+ return nil;
+ }
+
+ return [NSDate dateWithTimeIntervalSince1970:[self doubleForColumnIndex:columnIdx]];
+}
+
+
+- (NSData*)dataForColumn:(NSString*)columnName {
+ return [self dataForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (NSData*)dataForColumnIndex:(int)columnIdx {
+
+ if (sqlite3_column_type(statement.statement, columnIdx) == SQLITE_NULL || (columnIdx < 0)) {
+ return nil;
+ }
+
+ int dataSize = sqlite3_column_bytes(statement.statement, columnIdx);
+
+ NSMutableData *data = [NSMutableData dataWithLength:dataSize];
+
+ memcpy([data mutableBytes], sqlite3_column_blob(statement.statement, columnIdx), dataSize);
+
+ return data;
+}
+
+
+- (NSData*)dataNoCopyForColumn:(NSString*)columnName {
+ return [self dataNoCopyForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (NSData*)dataNoCopyForColumnIndex:(int)columnIdx {
+
+ if (sqlite3_column_type(statement.statement, columnIdx) == SQLITE_NULL || (columnIdx < 0)) {
+ return nil;
+ }
+
+ int dataSize = sqlite3_column_bytes(statement.statement, columnIdx);
+
+ NSData *data = [NSData dataWithBytesNoCopy:(void *)sqlite3_column_blob(statement.statement, columnIdx) length:dataSize freeWhenDone:NO];
+
+ return data;
+}
+
+
+- (BOOL)columnIndexIsNull:(int)columnIdx {
+ return sqlite3_column_type(statement.statement, columnIdx) == SQLITE_NULL;
+}
+
+- (BOOL)columnIsNull:(NSString*)columnName {
+ return [self columnIndexIsNull:[self columnIndexForName:columnName]];
+}
+
+- (const unsigned char *)UTF8StringForColumnIndex:(int)columnIdx {
+
+ if (sqlite3_column_type(statement.statement, columnIdx) == SQLITE_NULL || (columnIdx < 0)) {
+ return nil;
+ }
+
+ return sqlite3_column_text(statement.statement, columnIdx);
+}
+
+- (const unsigned char *)UTF8StringForColumnName:(NSString*)columnName {
+ return [self UTF8StringForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+- (id)objectForColumnIndex:(int)columnIdx {
+ int columnType = sqlite3_column_type(statement.statement, columnIdx);
+
+ id returnValue = nil;
+
+ if (columnType == SQLITE_INTEGER) {
+ returnValue = [NSNumber numberWithLongLong:[self longLongIntForColumnIndex:columnIdx]];
+ }
+ else if (columnType == SQLITE_FLOAT) {
+ returnValue = [NSNumber numberWithDouble:[self doubleForColumnIndex:columnIdx]];
+ }
+ else if (columnType == SQLITE_BLOB) {
+ returnValue = [self dataForColumnIndex:columnIdx];
+ }
+ else {
+ //default to a string for everything else
+ returnValue = [self stringForColumnIndex:columnIdx];
+ }
+
+ if (returnValue == nil) {
+ returnValue = [NSNull null];
+ }
+
+ return returnValue;
+}
+
+- (id)objectForColumnName:(NSString*)columnName {
+ return [self objectForColumnIndex:[self columnIndexForName:columnName]];
+}
+
+
+// returns autoreleased NSString containing the name of the column in the result set
+- (NSString*)columnNameForIndex:(int)columnIdx {
+ return [NSString stringWithUTF8String: sqlite3_column_name(statement.statement, columnIdx)];
+}
+
+- (void)setParentDB:(FMDatabase *)newDb {
+ parentDB = newDb;
+}
+
+
+- (NSString *)query {
+ return query;
+}
+
+- (void)setQuery:(NSString *)value {
+ [value retain];
+ [query release];
+ query = value;
+}
+
+- (NSMutableDictionary *)columnNameToIndexMap {
+ return columnNameToIndexMap;
+}
+
+- (void)setColumnNameToIndexMap:(NSMutableDictionary *)value {
+ [value retain];
+ [columnNameToIndexMap release];
+ columnNameToIndexMap = value;
+}
+
+- (FMStatement *)statement {
+ return statement;
+}
+
+- (void)setStatement:(FMStatement *)value {
+ if (statement != value) {
+ [statement release];
+ statement = [value retain];
+ }
+}
+
+
+
+@end
diff --git a/Classes/PicCastAppDelegate.h b/Classes/PicCastAppDelegate.h
index a0efe4d..1085903 100644
--- a/Classes/PicCastAppDelegate.h
+++ b/Classes/PicCastAppDelegate.h
@@ -18,4 +18,6 @@
@property (nonatomic, retain) IBOutlet UITabBarController *tabBarController;
@property (nonatomic, retain) IBOutlet UINavigationController *navigationController;
++ (NSString *) getDatabasePath;
+
@end
diff --git a/Classes/PicCastAppDelegate.m b/Classes/PicCastAppDelegate.m
index ab242ec..f44c6eb 100644
--- a/Classes/PicCastAppDelegate.m
+++ b/Classes/PicCastAppDelegate.m
@@ -32,6 +32,16 @@
@synthesize navigationController;
+//- (void)initialize {
+// [[NSUserDefaults standardUserDefaults]
+// registerDefaults:[NSDictionary dictionaryWithObjectsAndKeys:
+// NULL, @"facebookToken",
+// NULL, @"facebookExpirationDate",
+// NULL, @"twitterToken",
+// [NSNumber numberWithBool:NO], @"haveSearched",
+// nil]];
+//}
+
#pragma mark -
#pragma mark Application lifecycle
@@ -110,6 +120,41 @@
*/
}
+#pragma mark -
+#pragma mark CustomSheeyit
+
+//+ (void) prompt:(NSString *)title withMessage:(NSString *)message andButtonTitle:(NSString *)buttonTitle withDelegate:(id)delegate {
+// UIAlertView *prompt = [UIAlertView alloc];
+// prompt = [prompt initWithTitle:title message:message delegate:delegate cancelButtonTitle:buttonTitle otherButtonTitles:nil];
+// [prompt show];
+// [prompt release];
+//}
+//
+//+ (void) prompt:(NSString *)title withMessage:(NSString *)message andButtonTitle:(NSString *)buttonTitle {
+// [self prompt:title withMessage:message andButtonTitle:buttonTitle withDelegate:self];
+//}
+//
+//- (BOOL)application:(UIApplication *)application handleOpenURL:(NSURL *)url {
+// return [facebook handleOpenURL:url];
+//}
+
++ (NSString *) getDatabasePath {
+ NSString *databaseName = @"PicCastSqlTable.db";
+
+ NSArray *documentPaths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+ NSString *documentsDir = [documentPaths objectAtIndex:0];
+ NSString *databasePath = [documentsDir stringByAppendingPathComponent:databaseName];
+
+ NSFileManager *fileManager = [NSFileManager defaultManager];
+
+ if(![fileManager fileExistsAtPath:databasePath]) {
+ NSString *databasePathFromApp = [[[NSBundle mainBundle] resourcePath] stringByAppendingPathComponent:databaseName];
+ [fileManager copyItemAtPath:databasePathFromApp toPath:databasePath error:nil];
+ }
+
+ return databasePath;
+}
+
#pragma mark -
#pragma mark UITabBarControllerDelegate methods
diff --git a/Classes/SectionDictionary.h b/Classes/SectionDictionary.h
new file mode 100644
index 0000000..f227e44
--- /dev/null
+++ b/Classes/SectionDictionary.h
@@ -0,0 +1,23 @@
+//
+// SectionDictionary.h
+// PicCast
+//
+// Created by Matthew Handler on 4/23/11.
+// Copyright 2011 Earl Industries. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+
+@interface SectionDictionary : NSObject {
+ NSInteger index;
+ NSMutableDictionary *indexMap;
+ NSMutableDictionary *theRealDictionary;
+}
+
+- (void) appendObject:(id)anObject forKey:(id)aKey;
+- (void) setObject:(id)anObject forKey:(id)aKey;
+- (id) objectForIndex:(NSInteger)i;
+- (NSString *) keyForIndex:(NSInteger)i;
+
+@end
diff --git a/Classes/SectionDictionary.m b/Classes/SectionDictionary.m
new file mode 100644
index 0000000..8845b2b
--- /dev/null
+++ b/Classes/SectionDictionary.m
@@ -0,0 +1,64 @@
+//
+// SectionDictionary.m
+// PicCast
+//
+// Created by Matthew Handler on 4/23/11.
+// Copyright 2011 Earl Industries. All rights reserved.
+//
+
+#import "SectionDictionary.h"
+
+
+@implementation SectionDictionary
+
+//@synthesize index;
+
+- (SectionDictionary *) init {
+ index = 0;
+ indexMap = [[[NSMutableDictionary alloc] init] retain];
+ theRealDictionary = [[[NSMutableDictionary alloc] init] retain];
+ [super init];
+
+ return self;
+}
+
+- (id)forwardingTargetForSelector:(SEL)aSelector
+{
+ return theRealDictionary;
+}
+
+- (void) setObject:(id)anObject forKey:(id)aKey {
+ [indexMap setObject:aKey forKey:[NSString stringWithFormat:@"%d", index]];
+ index++;
+ [theRealDictionary setObject:anObject forKey:aKey];
+}
+
+// lets you push objects into sections without worry about storage
+- (void) appendObject:(id)anObject forKey:(id)aKey {
+ NSMutableArray *store = [theRealDictionary objectForKey:aKey];
+ if (store == nil) {
+ NSMutableArray *store = [[[NSMutableArray alloc] init] autorelease];
+ [store addObject:anObject];
+ [theRealDictionary setObject:store forKey:aKey];
+ }
+ else [store addObject:anObject];
+
+ NSLog(@"number of rows: %d", [[theRealDictionary objectForKey:aKey] count]);
+}
+
+- (id) objectForIndex:(NSInteger)i {
+ return [theRealDictionary objectForKey:[indexMap objectForKey:[NSString stringWithFormat:@"%d", i]]];
+}
+
+- (NSString *) keyForIndex:(NSInteger)i {
+ return [indexMap objectForKey:[NSString stringWithFormat:@"%d", i]];
+}
+
+- (void) dealloc {
+ [theRealDictionary release];
+ [indexMap release];
+ [super dealloc];
+}
+
+
+@end
diff --git a/Classes/Topic.h b/Classes/Topic.h
index 2ae6520..26f8c29 100644
--- a/Classes/Topic.h
+++ b/Classes/Topic.h
@@ -5,14 +5,13 @@
// Created by Matthew Handler on 4/16/11.
// Copyright 2011 Earl Industries. All rights reserved.
//
-
+#import "FMResultSet.h"
#import <UIKit/UIKit.h>
@interface Topic : NSObject {
NSString *title;
- NSString *creator;
NSString *description;
NSDate *releaseDate;
NSString *category;
@@ -25,10 +24,13 @@
@property (nonatomic, copy) NSNumber *picCount;
@property (nonatomic, copy) NSString *title;
@property (nonatomic, copy) NSString *guid;
-@property (nonatomic, copy) NSString *creator;
@property (nonatomic, copy) NSString *description;
@property (nonatomic, copy) NSDate *releaseDate;
@property (nonatomic, copy) NSString *category;
@property (nonatomic, copy) NSString *iconUrl;
++ (Topic *) initFromDatabaseRow:(FMResultSet *)result;
++ (NSString *) dateToString:(NSDate *)date;
++ (NSDate *) stringToDate:(NSString *)string;
+
@end
diff --git a/Classes/Topic.m b/Classes/Topic.m
index 712519b..65ea506 100644
--- a/Classes/Topic.m
+++ b/Classes/Topic.m
@@ -7,17 +7,69 @@
//
#import "Topic.h"
-
+#import "FMDatabase.h"
+#import "FMResultSet.h"
@implementation Topic
-@synthesize title, guid, creator, iconUrl, description, releaseDate, category, picCount;
+@synthesize guid, title, iconUrl, description, releaseDate, category, picCount;
+
++ (Topic *) initFromDatabaseRow:(FMResultSet *)result {
+ NSDateFormatter *dateFormatter = [[[NSDateFormatter alloc] init] autorelease];
+ [dateFormatter setDateStyle:NSDateFormatterLongStyle];
+ [dateFormatter setTimeStyle:NSDateFormatterNoStyle];
+ [dateFormatter setLocale:[[[NSLocale alloc] initWithLocaleIdentifier:@"US"] autorelease]];
+
+ Topic *topic = [[[Topic alloc] init] autorelease];
+
+ topic.guid = [result stringForColumn:@"link"];
+ topic.title = [result stringForColumn:@"title"];
+ topic.iconUrl = [result stringForColumn:@"iconUrl"];
+ topic.description = [result stringForColumn:@"description"];
+ topic.releaseDate = [Topic stringToDate:[result stringForColumn:@"releaseDate"]];
+ topic.category = [result stringForColumn:@"category"];
+ topic.picCount = [result intForColumn:@"picCount"];
+
+ return topic;
+}
+
++ (NSString *) dateToString:(NSDate *)date {
+ NSDateFormatter *dateFormatter = [[[NSDateFormatter alloc] init] autorelease];
+ [dateFormatter setDateStyle:NSDateFormatterLongStyle];
+ [dateFormatter setTimeStyle:NSDateFormatterNoStyle];
+ [dateFormatter setLocale:[[[NSLocale alloc] initWithLocaleIdentifier:@"US"] autorelease]];
+
+ return [dateFormatter stringFromDate:date];
+}
+
++ (NSDate *) stringToDate:(NSString *)string {
+ NSDateFormatter *dateFormatter = [[[NSDateFormatter alloc] init] autorelease];
+ [dateFormatter setDateStyle:NSDateFormatterLongStyle];
+ [dateFormatter setTimeStyle:NSDateFormatterNoStyle];
+ [dateFormatter setLocale:[[[NSLocale alloc] initWithLocaleIdentifier:@"US"] autorelease]];
+
+ return [dateFormatter dateFromString:string];
+}
+
+- (void)serializeToDatabase:(FMDatabase *)db {
+ //NSLog(@"title: %@", title);
+ [db executeUpdate:@"INSERT INTO picCasts \
+ (foreignId, link, title, description, releaseDate, category, iconUrl, picCount) \
+ VALUES \
+ (?, ?, ?, ?, ?, ?, ?, ?)",
+ 12, guid, title, description, [Topic dateToString:releaseDate], category, picCount];
+ //NSLog(@"insert id:%d error: %@", [db lastInsertRowId], [db lastErrorMessage]);
+
+ // [NSString stringWithFormat:@"number %d", i],
+ // [NSNumber numberWithInt:i],
+ // [NSDate date],
+ // [NSNumber numberWithFloat:2.2f]];
+}
- (void)dealloc {
[picCount release];
[guid release];
[title release];
- [creator release];
[description release];
[releaseDate release];
[category release];
diff --git a/Classes/TopicsViewController.h b/Classes/TopicsViewController.h
index fac4e7d..c6de22f 100644
--- a/Classes/TopicsViewController.h
+++ b/Classes/TopicsViewController.h
@@ -12,14 +12,17 @@
//#import "PicDumpViewController.h"
#import "SourcesEditViewController.h"
#import "PhotoViewController.h"
+#import "FMDatabase.h"
+#import "SectionDictionary.h"
@interface TopicsViewController : UIViewController <XMLParserDelegate, SourcesEditViewControllerDelegate, UITableViewDataSource>{
UINavigationController *topicsNavigationController;
- NSMutableArray *topics;
-// PicDumpViewController *picDumpViewController;
+ NSMutableArray *topics; // topics loaded from the web
+ SectionDictionary *tableDictionary; // structure to sync with table
PhotoViewController *photoViewController;
XMLParser *parser;
HJObjManager* objMan;
+ FMDatabase* db;
}
- (IBAction)showSources:(id)sender;
diff --git a/Classes/TopicsViewController.m b/Classes/TopicsViewController.m
index 8bd4531..2548bf3 100644
--- a/Classes/TopicsViewController.m
+++ b/Classes/TopicsViewController.m
@@ -16,6 +16,9 @@
#import "HJObjManager.h"
#import "HJManagedImageV.h"
#import "SourcesEditViewController.h"
+#import "SectionDictionary.h"
+#import "FMDatabase.h"
+#import "FMResultSet.h"
@implementation TopicsViewController
@@ -46,9 +49,87 @@
fileCache.fileAgeLimit = 60*60*24*7; //1 week
[fileCache trimCacheUsingBackgroundThread];
+ tableDictionary = [[[SectionDictionary alloc] init] retain];
+
+ NSString *path = [[NSBundle mainBundle] pathForResource:@"SampleDB" ofType:@"sqlite"];
+ FMDatabase *db = [[FMDatabase alloc] initWithPath:path];
+ [db open];
+
+ [self getTopicsFromDb];
+
[self startParsing];
}
+- (void) getTopicsFromDb {
+ // grab topics
+ FMResultSet *fResult= [db executeQuery:@"SELECT * FROM picCasts"]; //order by date, limite _max
+
+ // put into sections
+ while([fResult next])
+ {
+ [self addTopicToSectionDictionary:[Topic initFromDatabaseRow:fResult]];
+
+ }
+ [fResult close];
+
+ // put into data structure
+}
+
+- (void) addTopicToSectionDictionary:(Topic *)topic {
+ NSLog(@"days apart: %d", [self daysApart:topic.releaseDate]);
+ switch ((int)[self daysApart:topic.releaseDate]) {
+ case 0:
+ [tableDictionary appendObject:topic forKey:@"Today"];
+ break;
+ case 1:
+ [tableDictionary appendObject:topic forKey:@"Yesterday"];
+ break;
+ default:
+ [tableDictionary appendObject:topic forKey:[Topic dateToString:topic.releaseDate]];
+ break;
+ }
+}
+
+//- (void) addTopic:(FMResultSet *)result forKey:(NSString *)key {
+// NSMutableArray *store = [tableDictionary objectForKey:key];
+// if (store == nil) {
+// NSMutableArray *store = [[[NSMutableArray alloc] init] autorelease];
+// [tableDictionary setObject:store forKey:key];
+// }
+// [store addObject:result];
+//}
+
+- (NSTimeInterval) daysApart:(NSDate *)date {
+ //NSLog(@"datestring: %@", [Topic dateToString:date]);
+ NSDate *today = [NSDate date];
+
+// NSDateFormatter *dateFormatter = [[[NSDateFormatter alloc] init] autorelease];
+// [dateFormatter setDateFormat:@"yyyy-MM-dd"];
+// NSDate *published = [dateFormatter dateFromString:string];
+
+ return [today timeIntervalSinceDate:date];
+}
+
+// called after parsing is finished
+- (void) updateTopicsFromWeb:(NSArray *)parsedTopics {
+ // add topics to sql
+ [db beginTransaction];
+ for (Topic *topic in parsedTopics) {
+ // if topic is already in database
+ FMResultSet *rs = [db executeQuery:@"SELECT id FROM picCasts WHERE foreignId = ?", 10];
+ if (![rs hasAnotherRow]) {
+ [topic serializeToDatabase:db];
+ // add topics to structure
+ [self addTopicToSectionDictionary:topic];
+ }
+ }
+ [db commit];
+// NSLog(@"%@", [db lastErrorMessage]);
+// NSLog(@"%d", [db lastInsertRowId]);
+ // tell table to animate things being added
+ [self.tableView reloadData];
+}
+
- (void) sourcesEditViewControllerDidFinish:(SourcesEditViewController *)controller {
[self dismissModalViewControllerAnimated:YES];
@@ -118,7 +199,8 @@
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
// Return the number of sections.
- return 2;
+ NSLog(@"number of sections: %d", [tableDictionary count]);
+ return [tableDictionary count];
}
#pragma mark -
@@ -138,14 +220,13 @@
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
// Return the number of rows in the section.
- return [topics count];
+ NSLog(@"number of rows in section %d: %d", section, [[tableDictionary objectForIndex:section] count]);
+ return [[tableDictionary objectForIndex:section] count];
}
- (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section {
- if (section == 0)
- return @"Today";
- else
- return @"Yesterday";
+ NSLog(@"row title: %@", [tableDictionary keyForIndex:section]);
+ return [tableDictionary keyForIndex:section]; //how do you convert a key to index from mutabledictionary
}
- (void)setSelected:(BOOL)selected animated:(BOOL)animated {
@@ -258,7 +339,7 @@
}
- (void)parser:(XMLParser *)parser didParseTopics:(NSArray *)parsedTopics {
- [topics addObjectsFromArray:parsedTopics];
+ [self updateTopicsFromWeb:parsedTopics];
// Three scroll view properties are checked to keep the user interface smooth during parse. When new objects are delivered
// by the parser, the table view is reloaded to display them. If the table is reloaded while
@@ -291,6 +372,7 @@
}
- (void)dealloc {
+ [tableDictionary release];
[objMan release];
[topics release];
//[detailController release];
diff --git a/Classes/fmdb_Prefix.pch b/Classes/fmdb_Prefix.pch
new file mode 100644
index 0000000..b8c83c3
--- /dev/null
+++ b/Classes/fmdb_Prefix.pch
@@ -0,0 +1,7 @@
+//
+// Prefix header for all source files of the 'fmdb' target in the 'fmdb' project.
+//
+
+#ifdef __OBJC__
+ #import <Foundation/Foundation.h>
+#endif
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-21 14:07:46 +0000