Saving an ALAsset to SQLite3 database - retrieve error

Question 1

There are a couple of issues with your code sample:

The image retrieval is happening asynchronously, so when you try to update the image, you want to make sure the cell is still visible (and not reused for another NSIndexPath).

In this case, the retrieval from the ALAssetsLibrary will probably be so fast that this isn't critical, but it's a good pattern to familiarize yourself with, because if you're ever retrieving images over the Internet, this issue becomes increasingly important.
Because cells are being reused, if you don't find the image immediately and have to update it asynchronously, make sure you reset the UIImageView before initiating the asynchronous process. Otherwise, you'll see a "flickering" of replacing old images with new ones.
You are using UITableViewCell for your cell. The problem with that is that it will layout the cell based upon the size of the image present by the time cellForRowAtIndexPath finishes.

There are two easy solutions to this. First, you could initialize the cell's imageView to be a placeholder image of the correct size. (I usually have an image called placeholder.png that is all white or all transparent that I add to my project, which is what I used below.) This will ensure that cell will be laid out properly, so that when you asynchronously set the image later, the cell will be laid out properly already.

Second, you could alternatively use a custom cell whose layout is fixed in advance, bypassing this annoyance with the standard UITableViewCell, whose layout is contingent upon the initial image used.
I'd suggest using a NSCache to hold the thumbnails images. That will save you from having to constantly re-retrieve the thumbnail images as you get them from your ALAssetsLibrary as you scroll back and forth. Unfortunately, iOS 7 broke some of the wonderful NSCache memory-pressure logic, so I'd suggest a cache that will respond to memory pressure and purge itself if necessary.

Anyway, putting that all together, you get something like:

@interface ViewController ()

@property (nonatomic, strong) NSMutableArray *assetGroups;
@property (nonatomic, strong) ALAssetsLibrary *library;
@property (nonatomic, strong) ThumbnailCache *imageCache;

@end

@implementation ViewController

- (void)viewDidLoad
{
    [super viewDidLoad];

    self.imageCache = [[ThumbnailCache alloc] init];

    self.assetGroups = [NSMutableArray array];

    self.library = [[ALAssetsLibrary alloc] init];
    [self.library enumerateGroupsWithTypes:ALAssetsGroupAll usingBlock:^(ALAssetsGroup *group, BOOL *stop) {
        if (!group) {
            [self.tableView reloadData];
            return;
        }

        CustomAssetGroup *assetGroup = [[CustomAssetGroup alloc] init];
        assetGroup.name = [group valueForProperty:ALAssetsGroupPropertyName];
        assetGroup.assetURLs = [NSMutableArray array];

        [group enumerateAssetsUsingBlock:^(ALAsset *result, NSUInteger index, BOOL *stop) {
            if (result) {
                [assetGroup.assetURLs addObject:[result valueForProperty:ALAssetPropertyAssetURL]];
            }
        }];

        [self.assetGroups addObject:assetGroup];
    } failureBlock:^(NSError *error) {
        NSLog(@"%s: enumerateGroupsWithTypes error: %@", __PRETTY_FUNCTION__, error);
    }];
}

#pragma mark - UITableViewDataSource

- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
    return self.assetGroups.count;
}

- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
    CustomAssetGroup *group = self.assetGroups[section];
    return [group.assetURLs count];
}

- (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section
{
    CustomAssetGroup *group = self.assetGroups[section];
    return group.name;
}

- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
    static NSString *cellIdentifier = @"Cell";
    UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:cellIdentifier];

    // note, these following three lines are unnecessary if you use cell prototype in Interface Builder

    if (!cell) {
        cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:cellIdentifier];
    }

    CustomAssetGroup *group = self.assetGroups[indexPath.section];
    NSURL *url = group.assetURLs[indexPath.row];
    NSString *key = [url absoluteString];
    UIImage *image = [self.imageCache objectForKey:key];

    if (image) {
        cell.imageView.image = image;
    } else {
        UIImage *placeholderImage = [UIImage imageNamed:@"placeholder.png"];
        cell.imageView.image = placeholderImage;  // initialize this to a placeholder image of the right size

        [self.library assetForURL:url resultBlock:^(ALAsset *asset) {
            UIImage *image = [UIImage imageWithCGImage:asset.thumbnail];   // note, use thumbnail, not fullResolutionImage or anything like that

            [self.imageCache setObject:image forKey:key];

            // see if the cell is still visible, and if so, update it
            // note, do _not_ use `cell` when updating the cell image, but rather `updateCell` as shown below

            UITableViewCell *updateCell = (id)[tableView cellForRowAtIndexPath:indexPath]; // not to be confused with similarly named table view controller method ... this one checks to see if cell is still visible
            if (updateCell) {
                [UIView transitionWithView:updateCell.imageView duration:0.1 options:UIViewAnimationOptionTransitionCrossDissolve animations:^{
                    updateCell.imageView.image = image;
                    updateCell.textLabel.text = asset.defaultRepresentation.filename;
                } completion:nil];
            }
        } failureBlock:^(NSError *error) {
            NSLog(@"%s: assetForURL error: %@", __PRETTY_FUNCTION__, error);
        }];
    }

    return cell;
}
@end

The above uses the following classes:

/** Thumbnail cache
 *
 * This cache optimizes retrieval of old thumbnails. This purges itself 
 * upon memory pressure and sets a default countLimit.
 */
@interface ThumbnailCache : NSCache

// nothing needed here

@end

@implementation ThumbnailCache

/** Initialize cell
 *
 * Add observer for UIApplicationDidReceiveMemoryWarningNotification, so it purges itself under memory pressure
 */
- (instancetype)init
{
    self = [super init];
    if (self) {
        [[NSNotificationCenter defaultCenter] addObserver:self selector:@selector(removeAllObjects) name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
        self.countLimit = 50;
    };
    return self;
}

/** Dealloc
 *
 * Remove observer before removing cache
 */
- (void)dealloc
{
    [[NSNotificationCenter defaultCenter] removeObserver:self name:UIApplicationDidReceiveMemoryWarningNotification object:nil];
}

@end

and

/** Custom AssetGroup object
 *
 * This is my model object for keeping track of the name of the group and list of asset URLs.
 */
@interface CustomAssetGroup : NSObject

@property (nonatomic, copy)   NSString       *name;
@property (nonatomic, strong) NSMutableArray *assetURLs;

@end

@implementation CustomAssetGroup

// nothing needed here

@end

Question 2

You have to explore all the code base related to the save and retrieve functionality.

However, here are some good tips.

Save the ALAsset Url instead of saving the entire ALAsset as a string.
Retrieve the ALAsset Url from the database and convert it to NSUrlString.
Use ALAsset Library to load the image or thumbnail back.

Hope this will help you.