1  /*
  2   * Copyright (c) 2016 Apple Inc. All Rights Reserved.
  3   *
  4   * @APPLE_LICENSE_HEADER_START@
  5   *
  6   * This file contains Original Code and/or Modifications of Original Code
  7   * as defined in and that are subject to the Apple Public Source License
  8   * Version 2.0 (the 'License'). You may not use this file except in
  9   * compliance with the License. Please obtain a copy of the License at
 10   * http://www.opensource.apple.com/apsl/ and read it before using this
 11   * file.
 12   *
 13   * The Original Code and all software distributed under the License are
 14   * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 15   * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 16   * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 17   * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 18   * Please see the License for the specific language governing rights and
 19   * limitations under the License.
 20   *
 21   * @APPLE_LICENSE_HEADER_END@
 22   */
 23  
 24  #import <Foundation/Foundation.h>
 25  #import "CKKSSQLDatabaseObject.h"
 26  #include "keychain/securityd/SecItemServer.h"
 27  #include "keychain/securityd/SecItemDb.h"
 28  
 29  #import "keychain/ckks/CKKS.h"
 30  #import "CKKSKeychainView.h"
 31  
 32  @interface CKKSSQLResult ()
 33  @property (nullable) NSString* stringValue;
 34  @end
 35  
 36  @implementation CKKSSQLResult
 37  - (instancetype)init:(NSString* _Nullable)value
 38  {
 39      if((self = [super init])) {
 40          _stringValue = value;
 41      }
 42      return self;
 43  }
 44  
 45  - (BOOL)asBOOL
 46  {
 47      return [self.stringValue boolValue];
 48  }
 49  
 50  - (NSInteger)asNSInteger
 51  {
 52      return [self.stringValue integerValue];
 53  }
 54  
 55  - (NSString* _Nullable)asString
 56  {
 57      return self.stringValue;
 58  }
 59  
 60  - (NSNumber* _Nullable)asNSNumberInteger
 61  {
 62      if(self.stringValue == nil) {
 63          return nil;
 64      }
 65      return [NSNumber numberWithInteger: [self.stringValue integerValue]];
 66  }
 67  
 68  - (NSDate* _Nullable)asISO8601Date
 69  {
 70      if(self.stringValue == nil) {
 71          return nil;
 72      }
 73  
 74      NSISO8601DateFormatter* dateFormat = [[NSISO8601DateFormatter alloc] init];
 75      return [dateFormat dateFromString:self.stringValue];
 76  }
 77  
 78  - (NSData* _Nullable)asBase64DecodedData
 79  {
 80      if(self.stringValue == nil) {
 81          return nil;
 82      }
 83      return [[NSData alloc] initWithBase64EncodedString:self.stringValue options:0];
 84  }
 85  @end
 86  
 87  __thread bool CKKSSQLInTransaction = false;
 88  __thread bool CKKSSQLInWriteTransaction = false;
 89  
 90  @implementation CKKSSQLDatabaseObject
 91  
 92  + (bool) saveToDatabaseTable: (NSString*) table row: (NSDictionary*) row connection: (SecDbConnectionRef) dbconn error: (NSError * __autoreleasing *) error {
 93      __block CFErrorRef cferror = NULL;
 94  
 95  #if DEBUG
 96      NSAssert(CKKSSQLInTransaction, @"Must be in a transaction to perform database writes");
 97      NSAssert(CKKSSQLInWriteTransaction, @"Must be in a write transaction to perform database writes");
 98  #endif
 99  
100      bool (^doWithConnection)(SecDbConnectionRef) = ^bool (SecDbConnectionRef dbconn) {
101          NSString * columns = [row.allKeys componentsJoinedByString:@", "];
102          NSMutableString * values = [[NSMutableString alloc] init];
103          for(NSUInteger i = 0; i < [row.allKeys count]; i++) {
104              if(i != 0) {
105                  [values appendString: @",?"];
106              } else {
107                  [values appendString: @"?"];
108              }
109          }
110  
111          NSString *sql = [[NSString alloc] initWithFormat: @"INSERT OR REPLACE into %@ (%@) VALUES (%@);", table, columns, values];
112  
113          SecDbPrepare(dbconn, (__bridge CFStringRef) sql, &cferror, ^void (sqlite3_stmt *stmt) {
114              [row.allKeys enumerateObjectsUsingBlock:^(id  _Nonnull key, NSUInteger i, BOOL * _Nonnull stop) {
115                  SecDbBindObject(stmt, (int)(i+1), (__bridge CFStringRef) row[key], &cferror);
116              }];
117  
118              SecDbStep(dbconn, stmt, &cferror, ^(bool *stop) {
119                  // don't do anything, I guess?
120              });
121          });
122  
123          return true;
124      };
125  
126      if(dbconn) {
127          doWithConnection(dbconn);
128      } else {
129          kc_with_dbt(true, &cferror, doWithConnection);
130      }
131  
132      bool ret = cferror == NULL;
133  
134      SecTranslateError(error, cferror);
135  
136      return ret;
137  }
138  
139  + (NSString*) makeWhereClause: (NSDictionary*) whereDict {
140      if(!whereDict) {
141          return @"";
142      }
143      NSMutableString * whereClause = [[NSMutableString alloc] init];
144      __block bool conjunction = false;
145      [whereDict enumerateKeysAndObjectsUsingBlock: ^(NSString* key, NSNumber* value, BOOL* stop) {
146          if(!conjunction) {
147              [whereClause appendFormat: @" WHERE "];
148          } else {
149              [whereClause appendFormat: @" AND "];
150          }
151  
152          if([value class] == [CKKSSQLWhereValue class]) {
153              CKKSSQLWhereValue* obj = (CKKSSQLWhereValue*)value;
154              [whereClause appendFormat: @"%@%@(?)", key, CKKSSQLWhereComparatorAsString(obj.sqlOp)];
155  
156          } else if([value class] == [CKKSSQLWhereColumn class]) {
157              CKKSSQLWhereColumn* obj = (CKKSSQLWhereColumn*)value;
158              [whereClause appendFormat: @"%@%@%@",
159               key,
160               CKKSSQLWhereComparatorAsString(obj.sqlOp),
161               CKKSSQLWhereColumnNameAsString(obj.columnName)];
162  
163          } else if([value isMemberOfClass:[CKKSSQLWhereIn class]]) {
164              CKKSSQLWhereIn* obj = (CKKSSQLWhereIn*)value;
165  
166              NSMutableArray* q = [NSMutableArray arrayWithCapacity:obj.values.count];
167              for(NSString* value in obj.values) {
168                  [q addObject: @"?"];
169                  (void)value;
170              }
171  
172              NSString* binds = [q componentsJoinedByString:@", "];
173  
174              [whereClause appendFormat:@"%@ IN (%@)", key, binds];
175  
176          } else {
177              [whereClause appendFormat: @"%@=(?)", key];
178          }
179  
180          conjunction = true;
181      }];
182      return whereClause;
183  }
184  
185  + (NSString*) groupByClause: (NSArray*) columns {
186      if(!columns) {
187          return @"";
188      }
189      NSMutableString * groupByClause = [[NSMutableString alloc] init];
190      __block bool conjunction = false;
191      [columns enumerateObjectsUsingBlock: ^(NSString* column, NSUInteger i, BOOL* stop) {
192          if(!conjunction) {
193              [groupByClause appendFormat: @" GROUP BY "];
194          } else {
195              [groupByClause appendFormat: @", "];
196          }
197  
198          [groupByClause appendFormat: @"%@", column];
199  
200          conjunction = true;
201      }];
202      return groupByClause;
203  }
204  
205  + (NSString*)orderByClause: (NSArray*) columns {
206      if(!columns || columns.count == 0u) {
207          return @"";
208      }
209      NSMutableString * orderByClause = [[NSMutableString alloc] init];
210      __block bool conjunction = false;
211      [columns enumerateObjectsUsingBlock: ^(NSString* column, NSUInteger i, BOOL* stop) {
212          if(!conjunction) {
213              [orderByClause appendFormat: @" ORDER BY "];
214          } else {
215              [orderByClause appendFormat: @", "];
216          }
217  
218          [orderByClause appendFormat: @"%@", column];
219  
220          conjunction = true;
221      }];
222      return orderByClause;
223  }
224  
225  + (void)bindWhereClause:(sqlite3_stmt*)stmt whereDict:(NSDictionary*)whereDict cferror:(CFErrorRef*)cferror
226  {
227      __block int whereLocation = 1;
228  
229      [whereDict.allKeys enumerateObjectsUsingBlock:^(id  _Nonnull key, NSUInteger i, BOOL * _Nonnull stop) {
230          if([whereDict[key] class] == [CKKSSQLWhereValue class]) {
231              CKKSSQLWhereValue* obj = (CKKSSQLWhereValue*)whereDict[key];
232              SecDbBindObject(stmt, whereLocation, (__bridge CFStringRef)obj.value, cferror);
233              whereLocation++;
234  
235          } else if([whereDict[key] class] == [CKKSSQLWhereColumn class]) {
236              // skip
237          } else if([whereDict[key] isMemberOfClass:[CKKSSQLWhereIn class]]) {
238              CKKSSQLWhereIn* obj = (CKKSSQLWhereIn*)whereDict[key];
239  
240              for(NSString* value in obj.values) {
241                  SecDbBindObject(stmt, whereLocation, (__bridge CFStringRef)value, cferror);
242                  whereLocation++;
243              }
244  
245          } else {
246              SecDbBindObject(stmt, whereLocation, (__bridge CFStringRef) whereDict[key], cferror);
247              whereLocation++;
248          }
249      }];
250  }
251  
252  + (bool) deleteFromTable: (NSString*) table where: (NSDictionary*) whereDict connection:(SecDbConnectionRef) dbconn error: (NSError * __autoreleasing *) error {
253      __block CFErrorRef cferror = NULL;
254  
255  #if DEBUG
256      NSAssert(CKKSSQLInTransaction, @"Must be in a transaction to perform database writes");
257      NSAssert(CKKSSQLInWriteTransaction, @"Must be in a write transaction to perform database writes");
258  #endif
259  
260      bool (^doWithConnection)(SecDbConnectionRef) = ^bool (SecDbConnectionRef dbconn) {
261          NSString* whereClause = [CKKSSQLDatabaseObject makeWhereClause: whereDict];
262  
263          NSString * sql = [[NSString alloc] initWithFormat: @"DELETE FROM %@%@;", table, whereClause];
264          SecDbPrepare(dbconn, (__bridge CFStringRef) sql, &cferror, ^void (sqlite3_stmt *stmt) {
265              [self bindWhereClause:stmt whereDict:whereDict cferror:&cferror];
266  
267              SecDbStep(dbconn, stmt, &cferror, ^(bool *stop) {
268              });
269          });
270          return true;
271      };
272  
273      if(dbconn) {
274          doWithConnection(dbconn);
275      } else {
276          kc_with_dbt(true, &cferror, doWithConnection);
277      }
278  
279      // Deletes finish in a single step, so if we didn't get an error, the delete 'happened'
280      bool status = (cferror == nil);
281  
282      if(error) {
283          *error = (NSError*) CFBridgingRelease(cferror);
284      } else {
285          CFReleaseNull(cferror);
286      }
287  
288      return status;
289  }
290  
291  + (bool)queryDatabaseTable:(NSString*)table
292                       where:(NSDictionary*)whereDict
293                     columns:(NSArray*)names
294                     groupBy:(NSArray*)groupColumns
295                     orderBy:(NSArray*)orderColumns
296                       limit:(ssize_t)limit
297                  processRow:(void (^)(NSDictionary<NSString*, CKKSSQLResult*>*)) processRow
298                       error:(NSError * __autoreleasing *) error {
299      __block CFErrorRef cferror = NULL;
300  
301      kc_with_dbt(true, &cferror, ^bool (SecDbConnectionRef dbconn) {
302          NSString * columns = [names componentsJoinedByString:@", "];
303          NSString * whereClause = [CKKSSQLDatabaseObject makeWhereClause: whereDict];
304          NSString * groupByClause = [CKKSSQLDatabaseObject groupByClause: groupColumns];
305          NSString * orderByClause = [CKKSSQLDatabaseObject orderByClause: orderColumns];
306          NSString * limitClause = (limit > 0 ? [NSString stringWithFormat:@" LIMIT %lu", limit] : @"");
307  
308          NSString * sql = [[NSString alloc] initWithFormat: @"SELECT %@ FROM %@%@%@%@%@;", columns, table, whereClause, groupByClause, orderByClause, limitClause];
309          SecDbPrepare(dbconn, (__bridge CFStringRef) sql, &cferror, ^void (sqlite3_stmt *stmt) {
310              [self bindWhereClause:stmt whereDict:whereDict cferror:&cferror];
311  
312              SecDbStep(dbconn, stmt, &cferror, ^(bool *stop) {
313                  __block NSMutableDictionary<NSString*, CKKSSQLResult*>* row = [[NSMutableDictionary alloc] init];
314  
315                  [names enumerateObjectsUsingBlock:^(id  _Nonnull name, NSUInteger i, BOOL * _Nonnull stop) {
316                      const char * col = (const char *) sqlite3_column_text(stmt, (int)i);
317                      row[name] = [[CKKSSQLResult alloc] init:col ? [NSString stringWithUTF8String:col] : nil];
318                  }];
319  
320                  processRow(row);
321              });
322          });
323          return true;
324      });
325  
326      bool ret = (cferror == NULL);
327      SecTranslateError(error, cferror);
328      return ret;
329  }
330  
331  + (NSString *)quotedString:(NSString *)string
332  {
333      char *quotedMaxField = sqlite3_mprintf("%q", [string UTF8String]);
334      if (quotedMaxField == NULL) {
335          abort();
336      }
337      NSString *rstring = [NSString stringWithUTF8String:quotedMaxField];
338      sqlite3_free(quotedMaxField);
339      return rstring;
340  }
341  
342  + (bool)queryMaxValueForField:(NSString*)maxField
343                        inTable:(NSString*)table
344                          where:(NSDictionary*)whereDict
345                        columns:(NSArray*)names
346                     processRow:(void (^)(NSDictionary<NSString*, CKKSSQLResult*>*))processRow
347  {
348      __block CFErrorRef cferror = NULL;
349  
350      kc_with_dbt(false, &cferror, ^bool(SecDbConnectionRef dbconn) {
351          NSString *quotedMaxField = [self quotedString:maxField];
352          NSString *quotedTable = [self quotedString:table];
353  
354          NSMutableArray<NSString *>* quotedNames = [NSMutableArray array];
355          for (NSString *element in names) {
356              [quotedNames addObject:[self quotedString:element]];
357          }
358  
359          NSString* columns = [[quotedNames componentsJoinedByString:@", "] stringByAppendingFormat:@", %@", quotedMaxField];
360          NSString* whereClause = [CKKSSQLDatabaseObject makeWhereClause:whereDict];
361          
362          NSString* sql = [[NSString alloc] initWithFormat:@"SELECT %@ FROM %@%@", columns, quotedTable, whereClause];
363          SecDbPrepare(dbconn, (__bridge CFStringRef)sql, &cferror, ^(sqlite3_stmt* stmt) {
364              [self bindWhereClause:stmt whereDict:whereDict cferror:&cferror];
365              
366              SecDbStep(dbconn, stmt, &cferror, ^(bool*stop) {
367                  __block NSMutableDictionary<NSString*, CKKSSQLResult*>* row = [[NSMutableDictionary alloc] init];
368                  
369                  [names enumerateObjectsUsingBlock:^(id  _Nonnull name, NSUInteger i, BOOL * _Nonnull stop) {
370                      const char * col = (const char *) sqlite3_column_text(stmt, (int)i);
371                      row[name] = [[CKKSSQLResult alloc] init:col ? [NSString stringWithUTF8String:col] : nil];
372                  }];
373                  
374                  processRow(row);
375              });
376          });
377          
378          return true;
379      });
380      
381      bool ret = (cferror == NULL);
382      return ret;
383  }
384  
385  + (BOOL)performCKKSTransaction:(CKKSDatabaseTransactionResult (^)(void))block
386  {
387      CFErrorRef cferror = NULL;
388      bool ok = kc_with_dbt(true, &cferror, ^bool (SecDbConnectionRef dbconn) {
389          CFErrorRef cferrorInternal = NULL;
390          bool ret = kc_transaction_type(dbconn, kSecDbExclusiveRemoteCKKSTransactionType, &cferrorInternal, ^bool{
391              CKKSDatabaseTransactionResult result = CKKSDatabaseTransactionRollback;
392  
393              CKKSSQLInTransaction = true;
394              CKKSSQLInWriteTransaction = true;
395              result = block();
396              CKKSSQLInWriteTransaction = false;
397              CKKSSQLInTransaction = false;
398              return result == CKKSDatabaseTransactionCommit;
399          });
400          if(cferrorInternal) {
401              ckkserror_global("ckkssql",  "error performing database transaction, major problems ahead: %@", cferrorInternal);
402          }
403          CFReleaseNull(cferrorInternal);
404          return ret;
405      });
406  
407      if(cferror) {
408          ckkserror_global("ckkssql",  "error performing database operation, major problems ahead: %@", cferror);
409      }
410      CFReleaseNull(cferror);
411      return ok;
412  }
413  
414  + (BOOL)performCKKSReadonlyTransaction:(void(^)(void))block
415  {
416      CFErrorRef cferror = NULL;
417      bool ok = kc_with_dbt(true, &cferror, ^bool (SecDbConnectionRef dbconn) {
418          CFErrorRef cferrorInternal = NULL;
419          bool ret = kc_transaction_type(dbconn, kSecDbNormalTransactionType, &cferrorInternal, ^bool{
420              CKKSSQLInTransaction = true;
421              block();
422              CKKSSQLInTransaction = false;
423              return true;
424          });
425          if(cferrorInternal) {
426              ckkserror_global("ckkssql",  "error performing database transaction, major problems ahead: %@", cferrorInternal);
427          }
428          CFReleaseNull(cferrorInternal);
429          return ret;
430      });
431  
432      if(cferror) {
433          ckkserror_global("ckkssql",  "error performing database operation, major problems ahead: %@", cferror);
434      }
435      CFReleaseNull(cferror);
436      return ok;
437  }
438  
439  #pragma mark - Instance methods
440  
441  - (bool) saveToDatabase: (NSError * __autoreleasing *) error {
442      return [self saveToDatabaseWithConnection:nil error: error];
443  }
444  
445  - (bool) saveToDatabaseWithConnection: (SecDbConnectionRef) conn error: (NSError * __autoreleasing *) error {
446      // Todo: turn this into a transaction
447  
448      NSDictionary* currentWhereClause = [self whereClauseToFindSelf];
449  
450      // First, if we were loaded from the database and the where clause has changed, delete the old record.
451      if(self.originalSelfWhereClause && ![self.originalSelfWhereClause isEqualToDictionary: currentWhereClause]) {
452          secdebug("ckkssql", "Primary key changed; removing old row at %@", self.originalSelfWhereClause);
453          if(![CKKSSQLDatabaseObject deleteFromTable:[[self class] sqlTable] where: self.originalSelfWhereClause connection:conn error: error]) {
454              return false;
455          }
456      }
457  
458      bool ok = [CKKSSQLDatabaseObject saveToDatabaseTable: [[self class] sqlTable]
459                                                       row: [self sqlValues]
460                                                connection: conn
461                                                     error: error];
462  
463      if(ok) {
464          secdebug("ckkssql", "Saved %@", self);
465      } else {
466          secdebug("ckkssql", "Couldn't save %@: %@", self, error ? *error : @"unknown");
467      }
468      return ok;
469  }
470  
471  - (bool) deleteFromDatabase: (NSError * __autoreleasing *) error {
472      bool ok = [CKKSSQLDatabaseObject deleteFromTable:[[self class] sqlTable] where: [self whereClauseToFindSelf] connection:nil error: error];
473  
474      if(ok) {
475          secdebug("ckkssql", "Deleted %@", self);
476      } else {
477          secdebug("ckkssql", "Couldn't delete %@: %@", self, error ? *error : @"unknown");
478      }
479      return ok;
480  }
481  
482  + (bool) deleteAll: (NSError * __autoreleasing *) error {
483      bool ok = [CKKSSQLDatabaseObject deleteFromTable:[self sqlTable] where: nil connection:nil error: error];
484  
485      if(ok) {
486          secdebug("ckkssql", "Deleted all %@", self);
487      } else {
488          secdebug("ckkssql", "Couldn't delete all %@: %@", self, error ? *error : @"unknown");
489      }
490      return ok;
491  }
492  
493  + (instancetype) fromDatabaseWhere: (NSDictionary*) whereDict error: (NSError * __autoreleasing *) error {
494      id ret = [self tryFromDatabaseWhere: whereDict error:error];
495  
496      if(!ret && error) {
497          *error = [NSError errorWithDomain:@"securityd"
498                                       code:errSecItemNotFound
499                                   userInfo:@{NSLocalizedDescriptionKey:
500                                                  [NSString stringWithFormat: @"%@ does not exist in database where %@", [self class], whereDict]}];
501      }
502  
503      return ret;
504  }
505  
506  + (instancetype _Nullable) tryFromDatabaseWhere: (NSDictionary*) whereDict error: (NSError * __autoreleasing *) error {
507      __block id ret = nil;
508  
509      [CKKSSQLDatabaseObject queryDatabaseTable: [self sqlTable]
510                                          where: whereDict
511                                        columns: [self sqlColumns]
512                                        groupBy: nil
513                                        orderBy:nil
514                                          limit: -1
515                                     processRow: ^(NSDictionary<NSString*, CKKSSQLResult*>* row) {
516                                     ret = [[self fromDatabaseRow: row] memoizeOriginalSelfWhereClause];
517                                 }
518                                          error: error];
519  
520      return ret;
521  }
522  
523  + (NSArray*) all: (NSError * __autoreleasing *) error {
524      return [self allWhere: nil error:error];
525  }
526  
527  + (NSArray*) allWhere: (NSDictionary*) whereDict error: (NSError * __autoreleasing *) error {
528      __block NSMutableArray* items = [[NSMutableArray alloc] init];
529  
530      [CKKSSQLDatabaseObject queryDatabaseTable: [self sqlTable]
531                                          where: whereDict
532                                        columns: [self sqlColumns]
533                                        groupBy: nil
534                                        orderBy:nil
535                                          limit: -1
536                                     processRow: ^(NSDictionary<NSString*, CKKSSQLResult*>* row) {
537                                         [items addObject: [[self fromDatabaseRow: row] memoizeOriginalSelfWhereClause]];
538                                     }
539                                          error: error];
540  
541      return items;
542  }
543  
544  + (NSArray*)fetch: (size_t)count error: (NSError * __autoreleasing *) error {
545      return [self fetch: count where:nil orderBy:nil error:error];
546  }
547  
548  + (NSArray*)fetch: (size_t)count where:(NSDictionary*)whereDict error: (NSError * __autoreleasing *) error {
549      return [self fetch: count where:whereDict orderBy:nil error:error];
550  }
551  
552  + (NSArray*)fetch:(size_t)count
553              where:(NSDictionary*)whereDict
554            orderBy:(NSArray*) orderColumns
555              error:(NSError * __autoreleasing *) error {
556      __block NSMutableArray* items = [[NSMutableArray alloc] init];
557  
558      [CKKSSQLDatabaseObject queryDatabaseTable: [self sqlTable]
559                                          where: whereDict
560                                        columns: [self sqlColumns]
561                                        groupBy:nil
562                                        orderBy:orderColumns
563                                          limit: (ssize_t) count
564                                     processRow: ^(NSDictionary<NSString*, CKKSSQLResult*>* row) {
565                                         [items addObject: [[self fromDatabaseRow: row] memoizeOriginalSelfWhereClause]];
566                                     }
567                                          error: error];
568  
569      return items;
570  }
571  
572  - (instancetype) memoizeOriginalSelfWhereClause {
573      _originalSelfWhereClause = [self whereClauseToFindSelf];
574      return self;
575  }
576  
577  #pragma mark - Subclass methods
578  
579  + (instancetype)fromDatabaseRow:(NSDictionary<NSString *, CKKSSQLResult*>*)row {
580      @throw [NSException exceptionWithName:NSInternalInconsistencyException
581                                     reason:[NSString stringWithFormat:@"A subclass must override %@", NSStringFromSelector(_cmd)]
582                                   userInfo:nil];
583  }
584  
585  + (NSString*) sqlTable {
586      @throw [NSException exceptionWithName:NSInternalInconsistencyException
587                                     reason:[NSString stringWithFormat:@"A subclass must override %@", NSStringFromSelector(_cmd)]
588                                   userInfo:nil];
589  }
590  
591  + (NSArray<NSString*>*) sqlColumns {
592      @throw [NSException exceptionWithName:NSInternalInconsistencyException
593                                     reason:[NSString stringWithFormat:@"A subclass must override %@", NSStringFromSelector(_cmd)]
594                                   userInfo:nil];
595  }
596  
597  - (NSDictionary<NSString*,NSString*>*) sqlValues {
598      @throw [NSException exceptionWithName:NSInternalInconsistencyException
599                                     reason:[NSString stringWithFormat:@"A subclass must override %@", NSStringFromSelector(_cmd)]
600                                   userInfo:nil];
601  }
602  
603  - (NSDictionary<NSString*,NSString*>*) whereClauseToFindSelf {
604      @throw [NSException exceptionWithName:NSInternalInconsistencyException
605                                     reason:[NSString stringWithFormat:@"A subclass must override %@", NSStringFromSelector(_cmd)]
606                                   userInfo:nil];
607  }
608  
609  - (instancetype)copyWithZone:(NSZone *)zone {
610      CKKSSQLDatabaseObject *dbCopy = [[[self class] allocWithZone:zone] init];
611      dbCopy->_originalSelfWhereClause = _originalSelfWhereClause;
612      return dbCopy;
613  }
614  @end
615  
616  NSString* CKKSSQLWhereComparatorAsString(CKKSSQLWhereComparator comparator)
617  {
618      switch(comparator) {
619          case CKKSSQLWhereComparatorEquals:
620              return @"=";
621          case CKKSSQLWhereComparatorNotEquals:
622              return @"<>";
623          case CKKSSQLWhereComparatorGreaterThan:
624              return @">";
625          case CKKSSQLWhereComparatorLessThan:
626              return @"<";
627      }
628  }
629  
630  NSString* CKKSSQLWhereColumnNameAsString(CKKSSQLWhereColumnName columnName)
631  {
632      switch(columnName) {
633          case CKKSSQLWhereColumnNameUUID:
634              return @"uuid";
635          case CKKSSQLWhereColumnNameParentKeyUUID:
636              return @"parentKeyUUID";
637      }
638  }
639  
640  #pragma mark - CKKSSQLWhereColumn
641  
642  @implementation CKKSSQLWhereColumn
643  - (instancetype)initWithOperation:(CKKSSQLWhereComparator)op columnName:(CKKSSQLWhereColumnName)column
644  {
645      if((self = [super init])) {
646          _sqlOp = op;
647          _columnName = column;
648      }
649      return self;
650  }
651  + (instancetype)op:(CKKSSQLWhereComparator)op column:(CKKSSQLWhereColumnName)columnName
652  {
653      return [[CKKSSQLWhereColumn alloc] initWithOperation:op columnName:columnName];
654  }
655  @end
656  
657  #pragma mark - CKKSSQLWhereObject
658  
659  @implementation CKKSSQLWhereValue
660  - (instancetype)initWithOperation:(CKKSSQLWhereComparator)op value:(NSString*)value
661  {
662      if((self = [super init])) {
663          _sqlOp = op;
664          _value = value;
665      }
666      return self;
667  }
668  + (instancetype)op:(CKKSSQLWhereComparator)op value:(NSString*)value
669  {
670      return [[CKKSSQLWhereValue alloc] initWithOperation:op value:value];
671  
672  }
673  @end
674  
675  #pragma mark - CKKSSQLWhereIn
676  
677  @implementation CKKSSQLWhereIn : NSObject
678  - (instancetype)initWithValues:(NSArray<NSString*>*)values
679  {
680      if((self = [super init])) {
681           _values = values;
682      }
683      return self;
684  }
685  @end