Not executing any queries SQLite - ios

Question

So I created an NSObject that connects to an SQLite Database and everything was working perfectly. In my code, if the query is executable, the code goes through a series of conditions and executes the query. Then, for no reason and I hadn't done anything, the executable queries stopped working. I tried deleting the db file and copying it back again (I made sure to check all the checkboxes), but all that happened was that the project.pbxproj suddenly appeared in all my files and Xcode still couldn't execute my executable queries. I put the project.pbxproj back in the project file and kept deleting/recopying the db file from/in the project without luck.
Here is my code, I know it is perfectly fine because I changed nothing in it and it was working:
-(void)runQuery:(const char *)query isQueryExecutable:(BOOL)queryExecutable{
// Create a sqlite object.
sqlite3 *sqlite3Database;
// Set the database file path.
NSString *databasePath = [self.documentsDirectory stringByAppendingPathComponent:self.databaseFilename];
// Initialize the results array.
if (self.arrResults != nil) {
[self.arrResults removeAllObjects];
self.arrResults = nil;
}
self.arrResults = [[NSMutableArray alloc] init];
// Initialize the column names array.
if (self.arrColumnNames != nil) {
[self.arrColumnNames removeAllObjects];
self.arrColumnNames = nil;
}
self.arrColumnNames = [[NSMutableArray alloc] init];
// Open the database.
BOOL openDatabaseResult = sqlite3_open([databasePath UTF8String], &sqlite3Database);
if(openDatabaseResult == SQLITE_OK) {
// Declare a sqlite3_stmt object in which will be stored the query after having been compiled into a SQLite statement.
sqlite3_stmt *compiledStatement;
// Load all data from database to memory.
BOOL prepareStatementResult = sqlite3_prepare_v2(sqlite3Database, query, -1, &compiledStatement, NULL);
if(prepareStatementResult == SQLITE_OK) {
// Check if the query is non-executable.
if (!queryExecutable){
// In this case data must be loaded from the database.
// Declare an array to keep the data for each fetched row.
NSMutableArray *arrDataRow;
// Loop through the results and add them to the results array row by row.
while(sqlite3_step(compiledStatement) == SQLITE_ROW) {
// Initialize the mutable array that will contain the data of a fetched row.
arrDataRow = [[NSMutableArray alloc] init];
// Get the total number of columns.
int totalColumns = sqlite3_column_count(compiledStatement);
// Go through all columns and fetch each column data.
for (int i=0; i<totalColumns; i++){
// Convert the column data to text (characters).
char *dbDataAsChars = (char *)sqlite3_column_text(compiledStatement, i);
// If there are contents in the currenct column (field) then add them to the current row array.
if (dbDataAsChars != NULL) {
// Convert the characters to string.
[arrDataRow addObject:[NSString stringWithUTF8String:dbDataAsChars]];
}
// Keep the current column name.
if (self.arrColumnNames.count != totalColumns) {
dbDataAsChars = (char *)sqlite3_column_name(compiledStatement, i);
[self.arrColumnNames addObject:[NSString stringWithUTF8String:dbDataAsChars]];
}
}
// Store each fetched data row in the results array, but first check if there is actually data.
if (arrDataRow.count > 0) {
[self.arrResults addObject:arrDataRow];
}
}
}
else {
// This is the case of an executable query (insert, update, ...).
// Execute the query.
BOOL executeQueryResults = sqlite3_step(compiledStatement);
if (executeQueryResults == SQLITE_DONE) {
// Keep the affected rows.
self.affectedRows = sqlite3_changes(sqlite3Database);
// Keep the last inserted row ID.
self.lastInsertedRowID = sqlite3_last_insert_rowid(sqlite3Database);
}else if(executeQueryResults == SQLITE_BUSY){
NSLog(#"busy");
}else if(executeQueryResults == SQLITE_ERROR){
NSLog(#"error in exec");
}else if(executeQueryResults == SQLITE_MISUSE){
NSLog(#"misuse");
}else if(executeQueryResults == SQLITE_ROW){
NSLog(#"row");
}
else {
// If could not execute the query show the error message on the debugger.
NSLog(#"DB Error: %s", sqlite3_errmsg(sqlite3Database));
}
}
}
else {
// In the database cannot be opened then show the error message on the debugger.
NSLog(#"%s", sqlite3_errmsg(sqlite3Database));
}
// Release the compiled statement from memory.
sqlite3_finalize(compiledStatement);
}
// Close the database.
sqlite3_close(sqlite3Database);
}
I created all the conditions to check what kind of problem there was, turns out executeQueryResults is equal to SQLITE_ERROR, and the error is: unkown error.
Also, I tried logging the arrays and they are either empty or equal to null even when the database is not empty to start with.
Also, I am getting an error (ONLY IN THIS PROJECT) at all lines comparing executeQueryResults to SQLITE_DONE/BUSY/ERROR etc saying : semantic issue: Comparison of constant 101 with expression of type 'BOOL' (aka 'bool') is always false.
In other projects with exactly the same code, this error does not appear.

Answer 1

The problem is that you are holding the return values from your SQLite calls in boolean variables. You should change those variables to be int, the same type as the sqlite3_xxx() function calls return.
The clue was the error message you provided in your revised question:
Comparison of constant 101 with expression of type 'BOOL' (aka 'bool') is always false.
When you build for a 64-bit target, BOOL is defined as a bool type. And the bool type will take any non-zero value and change it to 1. For non-64 bit targets, though, BOOL is defined as signed char (which doesn't do this mapping of non-zero values to 1), which is why your code works when compiled against some targets, but not others.
Thus, when sqlite_step is returning a successful SQLITE_DONE (a non-zero value), for a 64-bit target, the BOOL is represented as bool, and the meaningful return code is getting replaced with 1 (which equates to SQLITE_ERROR). And the subsequent call to sqlite3_errmsg is getting confused, because no SQLite error has actually occurred.
If you replace those BOOL references with int (which you should do anyway), the code should work fine.