1) Download NanoStore
2) Open the NanoStore.xcodeproj file
3) Select Universal > My Mac 64-bit or 32-bit from the Scheme popup
4) Build (Command-B)

1) Drag the Distribution directory to the Project Navigator panel
2) Include #import "NanoStore.h" in your code

#import "NanoStore.h"

@implementation MyDemoAppDelegate

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions
{
    // Override point for customization after application launch.
    // Instantiate a NanoStore and open it
    
    NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFMemoryStoreType path:nil error:nil];
    ...

If you want to add a dependency between your project and NanoStore so that it gets automatically rebuilt when
you update NanoStore, do the following (we'll assume your app is called "MyDemoApp"):

1) Select the MyDemoApp project in the Project Navigator
2) Select the MyDemoApp target
3) Expand the Target Dependencies box
4) Click "+" and add NanoStore

(*) The data type NSData is allowed, but it will be excluded from the indexing process.

If the document store is opened by another application that doesn't implement the object that was stored, NanoStore
will instantiate a NSFNanoObject instead, thus allowing the app to retrieve the data seamlessly. If the object is then
updated by this application, the original class name will be honored.

App A stores an object of class Car.
App B retrieves the object, but since it doesn't know anything about the class Car, NanoStore returns a NSFNanoObject.
App B updates the object, with additional information. NanoStore saves it as a Car, not as a NSFNanoObject.
App A retrieves the updated object as a Car object, in exactly the same format as it was originally stored.

Create the transient backing store in RAM. Its contents are lost when the process exits. Fastest, uses more RAM (*).

Create a transient temporary backing store on disk. Its contents are lost when the process exits. Slower, uses less
RAM than NSFMemoryStoreType.

Create a persistent backing store on disk. Slower, uses less RAM than NSFMemoryStoreType (*).

Until the limit set by NSFNanoEngine's - (NSUInteger)cacheSize has been reached, memory usage would be the same for
in-memory and on-disk stores. When the size of the store grows beyond - (NSUInteger)cacheSize in-memory stores start to
consume more memory than on-disk ones, because it has nowhere to push pages out of the cache.

Typically, most developers may want to create and open the document store. To do that, use the following method:

+ (NSFNanoStore *)createAndOpenStoreWithType:(NSFNanoStoreType)aType path:(NSString *)aPath error:(out NSError **)outError

// Instantiate an in-memory document store and open it. The path parameter is unused.
NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFMemoryStoreType path:nil error:nil];

// Instantiate a temporary document store and open it. The path parameter is unused.
NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFTemporaryStoreType path:nil error:nil];

// Instantiate a file-based document store and open it. The path parameter must be specified.
NSString *thePath = @"~/Desktop/myDatabase.database";
NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFPersistentStoreType path:thePath error:nil];

In the case of file-based document stores, the file gets created automatically if it doesn't exist and then opened. If
it already exists, it gets opened and made available for use right away. There are instances where you may want to
fine-tune the engine. Tuning the engine has to be performed before the document store is opened. Another method is
available in NSFNanoStore for this purpose:

+ (NSFNanoStore *)createStoreWithType:(NSFNanoStoreType)theType path:(NSString *)thePath.

// Instantiate a file-based document store but don't open it right away. The path parameter must be specified.
NSString *thePath = @"~/Desktop/myDatabase.database";
NSFNanoStore *nanoStore = [NSFNanoStore createStoreWithType:NSFPersistentStoreType path:thePath error:nil];

// Obtain the engine
NSFNanoEngine *nanoStoreEngine = [nanoStore nanoStoreEngine];

// Set the synchronous mode setting
[nanoStoreEngine setSynchronousMode:SynchronousModeOff];
[nanoStoreEngine setEncodingType:NSFEncodingUTF16];

// Open the document store
[nanoStore openWithError:nil];

Check the section Performance Tips below for important information about how to get the most out of NanoStore.

// Instantiate a NanoStore and open it
NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFMemoryStoreType path:nil error:nil];

// Generate an empty NanoObject
NSFNanoObject *object = [NSFNanoObject nanoObject];

// Add some data
[object setObject:@"Doe" forKey:@"kLastName"];
[object setObject:@"John" forKey:@"kFirstName"];
[object setObject:[NSArray arrayWithObjects:@"[email protected]", @"[email protected]", nil] forKey:@"kEmails"];

// Add it to the document store
[nanoStore addObject:object error:nil];

// Close the document store
[nanoStore closeWithError:nil];

+ (NSFNanoObject*)nanoObjectWithDictionary:(NSDictionary *)theDictionary

- (NSString *)nanoObjectKey

If an attempt is made to add or remove an object without a valid key, an exception of type NSFNanoObjectBehaviorException
will be raised. To update an object, simply modify the object and add it to the document store. NanoStore will replace
the existing object with the one being added.

// Instantiate and open a NanoStore
NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFMemoryStoreType path:nil error:nil];

// Assuming the dictionary exists, instantiate a NanoObject
NSDictionary *info = ...;
NSFNanoObject *object = [NSFNanoObject nanoObjectWithDictionary:info];

// Add the NanoObject to the document store
[nanoStore addObject:object error:nil];

// Update the NanoObject with new data
[object setObject:@"foo" forKey:@"SomeKey"];

// Update the NanoObject in the document store
[nanoStore addObject:object error:nil];

- (BOOL)removeObject:(id <NSFNanoObjectProtocol>)theObject error:(out NSError **)outError
- (BOOL)removeObjectsWithKeysInArray:(NSArray *)theKeys error:(out NSError **)outError
- (BOOL)removeObjectsInArray:(NSArray *)theObjects error:(out NSError **)outError

// Instantiate and open a NanoStore
NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFMemoryStoreType path:nil error:nil];

// Assuming the dictionary exists, instantiate a NanoObject
NSDictionary *info = ...;
NSFNanoObject *object = [NSFNanoObject nanoObjectWithDictionary:info];

// Add the NanoObject to the document store
[nanoStore addObject:object error:nil];

// Remove the object
[nanoStore removeObject:object error:nil];

// ... or you could pass the key instead
[nanoStore removeObjectsWithKeysInArray:[NSArray arrayWithObject:[object nanoObjectKey]] error:nil];

1) Instantiate a search object
2) Configure the search via its accessors
3) Obtain the results specifying whether objects or keys should be returned (*)

(*) If introspecting the data is needed, request objects. You should request keys if you need to feed the result to
another method, such as the following method in NSFNanoStore:

-(BOOL)removeObjectsWithKeysInArray:(NSArray *)theKeys error:(out NSError **)outError

NSFNanoSearch *search = [NSFNanoSearch searchWithStore:nanoStore];

search.attribute = @"LastName";
search.match = NSFEqualTo;
search.value = @"Doe";

// Returns a dictionary with the UUID of the object (key) and the NanoObject (value).
NSDictionary *searchResults = [search searchObjectsWithReturnType:NSFReturnObjects error:nil];

NSFNanoSearch *search = [NSFNanoSearch searchWithStore:nanoStore];

search.attribute = @"LastName";
search.match = NSFEqualTo;
search.value = @"Doe";

// Returns an array of matching UUIDs
NSArray *matchingKeys = [search searchObjectsWithReturnType:NSFReturnKeys error:nil];

// Remove the NanoObjects matching the selected UUIDs
NSError *outError = nil;
if (YES == [nanoStore removeObjectsWithKeysInArray:matchingKeys error:&outError]) {
   NSLog(@"The matching objects have been removed.");
} else {
   NSLog(@"An error has occurred while removing the matching objects. Reason: %@", [outError localizedDescription]);
}

NSFNanoSearch *search = [NSFNanoSearch searchWithStore:nanoStore];

search.attribute = @"LastName";
search.match = NSFEqualTo;
search.value = @"Doe";

float averageSalary = [[search aggregateOperation:NSFAverage onAttribute:@"Salary"]floatValue];

1) Preparing your classes for sorting
2) Setup a search operation and set its sort descriptors

- (id)rootObject
{
    return self;
}

@interface NSFNanoBag : NSObject <NSFNanoObjectProtocol, NSCopying>
{
    NSFNanoStore     *store;
    NSString         *name;
    NSString         *key;
    BOOL             hasUnsavedChanges;
}

@interface Person : NSFNanoObject
{
    NSString        *firstName;
    NSString        *lastName;
    NSString        *email;
}

// Assume NanoStore has been opened elsewhere
NSFNanoStore *nanoStore = ...;

// Prepare the search
NSFNanoSearch *search = [NSFNanoSearch searchWithStore:nanoStore];
search.attribute = @"firstName";
search.match = NSFEqualTo;
search.value = @"John";
 
// Prepare and set the sort descriptor
NSFNanoSortDescriptor *sortByLastName = [[NSFNanoSortDescriptor alloc]initWithAttribute:@"lastName" ascending:YES];
search.sort = [NSArray arrayWithObject:sortByLastName];

// Perform the search
NSArray *searchResults = [search searchObjectsWithReturnType:NSFReturnObjects error:nil];

// Cleanup
[sortByLastName release];

SELECT column FROM table LIMIT 10

SELECT column FROM table LIMIT 10 OFFSET 10

NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFMemoryStoreType path:nil error:nil];

// Assume we have added objects to the store

NSFNanoSearch *search = [NSFNanoSearch searchWithStore:nanoStore];
search.value = @"Barcelona";
search.match = NSFEqualTo;
search.limit = 5;
search.offset = 3;

NSDictionary *searchResults = [search searchObjectsWithReturnType:NSFReturnObjects error:nil];

// Assuming the query matches some results, NanoStore should have retrieved
// the first 5 records right after the 3rd one from the result set.

// Instantiate and open a NanoStore
NSFNanoStore *nanoStore = [NSFNanoStore createAndOpenStoreWithType:NSFMemoryStoreType path:nil error:nil];

// Increase the save interval
[nanoStore setSaveInterval:1000];

// Do a bunch of inserts and/or edits

// Don't forget that some objects could be lingering in memory. Force a save.
[nanoStore saveStoreAndReturnError:nil];

If you set the saveInterval value to anything other one, keep in mind that some objects may still be left unsaved after
being added or modified. To make sure they're saved properly, call:

- (BOOL)saveStoreAndReturnError:(out NSError **)outError .

Choosing a good saveInterval value is more art than science. While testing NanoStore using a medium-sized dictionary
(iTunes MP3 dictionary) setting saveInterval to 1000 resulted in the best performance. You may want to test with
different numbers and fine-tune it for your data set.

Setting saveInterval to a large number could result in decreased performance because SQLite's would have to spend more
time reading the journal file and writing the changes to the store.