TDDatabase.java

/**
 * Original iOS version by  Jens Alfke
 * Ported to Android by Marty Schoch
 *
 * Copyright (c) 2012 Couchbase, Inc. All rights reserved.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
 * except in compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the
 * License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific language governing permissions
 * and limitations under the License.
 */

package com.couchbase.touchdb;

import java.io.File;
import java.io.IOException;
import java.net.URL;
import java.util.ArrayList;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Observable;
import java.util.Set;

import org.codehaus.jackson.map.ObjectMapper;

import android.content.ContentValues;
import android.database.Cursor;
import android.database.SQLException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.util.Log;

import com.couchbase.touchdb.TDDatabase.TDContentOptions;
import com.couchbase.touchdb.replicator.TDPuller;
import com.couchbase.touchdb.replicator.TDPusher;
import com.couchbase.touchdb.replicator.TDReplicator;
import com.couchbase.touchdb.support.Base64;
import com.couchbase.touchdb.support.DirUtils;

/**
 * A TouchDB database.
 */
public class TDDatabase extends Observable {

    private ObjectMapper mapper = new ObjectMapper();

    private String path;
    private String name;
    private SQLiteDatabase database;
    private boolean open = false;
    private int transactionLevel = 0;
    public static final String TAG = "TDDatabase";

    private Map<String, TDView> views;
    private Map<String, TDFilterBlock> filters;
    private Map<String, TDValidationBlock> validations;
    private List<TDReplicator> activeReplicators;
    private TDBlobStore attachments;

    /**
     * Options for what metadata to include in document bodies
     */
    public enum TDContentOptions {
        TDIncludeAttachments, TDIncludeConflicts, TDIncludeRevs, TDIncludeRevsInfo, TDIncludeLocalSeq, TDNoBody
    }

    private static final Set<String> KNOWN_SPECIAL_KEYS;

    static {
        KNOWN_SPECIAL_KEYS = new HashSet<String>();
        KNOWN_SPECIAL_KEYS.add("_id");
        KNOWN_SPECIAL_KEYS.add("_rev");
        KNOWN_SPECIAL_KEYS.add("_attachments");
        KNOWN_SPECIAL_KEYS.add("_deleted");
        KNOWN_SPECIAL_KEYS.add("_revisions");
        KNOWN_SPECIAL_KEYS.add("_revs_info");
        KNOWN_SPECIAL_KEYS.add("_conflicts");
        KNOWN_SPECIAL_KEYS.add("_deleted_conflicts");
    }

    public static final String SCHEMA = "" +
            "CREATE TABLE docs ( " +
            "        doc_id INTEGER PRIMARY KEY, " +
            "        docid TEXT UNIQUE NOT NULL); " +
            "    CREATE INDEX docs_docid ON docs(docid); " +
            "    CREATE TABLE revs ( " +
            "        sequence INTEGER PRIMARY KEY AUTOINCREMENT, " +
            "        doc_id INTEGER NOT NULL REFERENCES docs(doc_id) ON DELETE CASCADE, " +
            "        revid TEXT NOT NULL, " +
            "        parent INTEGER REFERENCES revs(sequence) ON DELETE SET NULL, " +
            "        current BOOLEAN, " +
            "        deleted BOOLEAN DEFAULT 0, " +
            "        json BLOB); " +
            "    CREATE INDEX revs_by_id ON revs(revid, doc_id); " +
            "    CREATE INDEX revs_current ON revs(doc_id, current); " +
            "    CREATE INDEX revs_parent ON revs(parent); " +
            "    CREATE TABLE localdocs ( " +
            "        docid TEXT UNIQUE NOT NULL, " +
            "        revid TEXT NOT NULL, " +
            "        json BLOB); " +
            "    CREATE INDEX localdocs_by_docid ON localdocs(docid); " +
            "    CREATE TABLE views ( " +
            "        view_id INTEGER PRIMARY KEY, " +
            "        name TEXT UNIQUE NOT NULL," +
            "        version TEXT, " +
            "        lastsequence INTEGER DEFAULT 0); " +
            "    CREATE INDEX views_by_name ON views(name); " +
            "    CREATE TABLE maps ( " +
            "        view_id INTEGER NOT NULL REFERENCES views(view_id) ON DELETE CASCADE, " +
            "        sequence INTEGER NOT NULL REFERENCES revs(sequence) ON DELETE CASCADE, " +
            "        key TEXT NOT NULL COLLATE JSON, " +
            "        value TEXT); " +
            "    CREATE INDEX maps_keys on maps(view_id, key COLLATE JSON); " +
            "    CREATE TABLE attachments ( " +
            "        sequence INTEGER NOT NULL REFERENCES revs(sequence) ON DELETE CASCADE, " +
            "        filename TEXT NOT NULL, " +
            "        key BLOB NOT NULL, " +
            "        type TEXT, " +
            "        length INTEGER NOT NULL, " +
            "        revpos INTEGER DEFAULT 0); " +
            "    CREATE INDEX attachments_by_sequence on attachments(sequence, filename); " +
            "    CREATE TABLE replicators ( " +
            "        remote TEXT NOT NULL, " +
            "        push BOOLEAN, " +
            "        last_sequence TEXT, " +
            "        UNIQUE (remote, push)); " +
            "    PRAGMA user_version = 3";             // at the end, update user_version

    /*************************************************************************************************/
    /*** TDDatabase                                                                                ***/
    /*************************************************************************************************/

    public String getAttachmentStorePath() {
        String attachmentStorePath = path;
        int lastDotPosition = attachmentStorePath.lastIndexOf('.');
        if( lastDotPosition > 0 ) {
            attachmentStorePath = attachmentStorePath.substring(0, lastDotPosition);
        }
        attachmentStorePath = attachmentStorePath + File.separator + "attachments";
        return attachmentStorePath;
    }

    public static TDDatabase createEmptyDBAtPath(String path) {
        File f = new File(path);
        f.delete();
        TDDatabase result = new TDDatabase(path);
        File af = new File(result.getAttachmentStorePath());
        //recursively delete attachments path
        DirUtils.deleteRecursive(af);
        if(!result.open()) {
            return null;
        }
        return result;
    }

    public TDDatabase(String path) {
        assert(path.startsWith("/")); //path must be absolute
        this.path = path;
        this.name = DirUtils.getDatabaseNameFromPath(path);
    }

    public String toString() {
        return this.getClass().getName() + "[" + path + "]";
    }

    public boolean exists() {
        return new File(path).exists();
    }

    public boolean initialize(String statements) {
        try {
            for (String statement : statements.split(";")) {
                database.execSQL(statement);
            }
        } catch (SQLException e) {
            close();
            return false;
        }
        return true;
    }

    public boolean open() {
        if(open) {
            return true;
        }

        try {
            database = SQLiteDatabase.openDatabase(path, null, SQLiteDatabase.CREATE_IF_NECESSARY);
            TDCollateJSON.registerCustomCollators(database);
        }
        catch(SQLiteException e) {
            Log.e(TDDatabase.TAG, "Error opening", e);
            return false;
        }

        // Stuff we need to initialize every time the database opens:
        if(!initialize("PRAGMA foreign_keys = ON;")) {
            Log.e(TDDatabase.TAG, "Error turning on foreign keys");
            return false;
        }

        // Check the user_version number we last stored in the database:
        int dbVersion = database.getVersion();

        // Incompatible version changes increment the hundreds' place:
        if(dbVersion >= 100) {
            Log.w(TDDatabase.TAG, "TDDatabase: Database version (" + dbVersion + ") is newer than I know how to work with");
            database.close();
            return false;
        }

        if(dbVersion < 1) {
            // First-time initialization:
            // (Note: Declaring revs.sequence as AUTOINCREMENT means the values will always be
            // monotonically increasing, never reused. See <http://www.sqlite.org/autoinc.html>)
            if(!initialize(SCHEMA)) {
                database.close();
                return false;
            }
            dbVersion = 3;
        }

        if (dbVersion < 2) {
            // Version 2: added attachments.revpos
            String upgradeSql = "ALTER TABLE attachments ADD COLUMN revpos INTEGER DEFAULT 0; " +
                                "PRAGMA user_version = 2";
            if(!initialize(upgradeSql)) {
                database.close();
                return false;
            }
            dbVersion = 2;
        }

        if (dbVersion < 3) {
            String upgradeSql = "CREATE TABLE localdocs ( " +
                    "docid TEXT UNIQUE NOT NULL, " +
                    "revid TEXT NOT NULL, " +
                    "json BLOB); " +
                    "CREATE INDEX localdocs_by_docid ON localdocs(docid); " +
                    "PRAGMA user_version = 3";
            if(!initialize(upgradeSql)) {
                database.close();
                return false;
            }
            dbVersion = 3;
        }

        if (dbVersion < 4) {
            String upgradeSql = "CREATE TABLE info ( " +
                    "key TEXT PRIMARY KEY, " +
                    "value TEXT); " +
                    "INSERT INTO INFO (key, value) VALUES ('privateUUID', '" + TDMisc.TDCreateUUID() + "'); " +
                    "INSERT INTO INFO (key, value) VALUES ('publicUUID',  '" + TDMisc.TDCreateUUID() + "'); " +
                    "PRAGMA user_version = 4";
            if(!initialize(upgradeSql)) {
                database.close();
                return false;
            }
        }

        try {
            attachments = new TDBlobStore(getAttachmentStorePath());
        } catch (IllegalArgumentException e) {
            Log.e(TDDatabase.TAG, "Could not initialize attachment store", e);
            database.close();
            return false;
        }

        open = true;
        return true;
    }

    public boolean close() {
        if(!open) {
            return false;
        }

        if(views != null) {
            for (TDView view : views.values()) {
                view.databaseClosing();
            }
        }
        views = null;

        if(activeReplicators != null) {
            Iterator<TDReplicator> iter = activeReplicators.iterator();
            while(iter.hasNext()) {
                TDReplicator replicator = iter.next();
                replicator.stop();
                iter.remove();
            }
        }

        if(database != null && database.isOpen()) {
            database.close();
        }
        open = false;
        transactionLevel = 0;
        return true;
    }

    public boolean deleteDatabase() {
        if(open) {
            if(!close()) {
                return false;
            }
        }
        else if(!exists()) {
            return true;
        }
        File file = new File(path);
        File attachmentsFile = new File(getAttachmentStorePath());

        boolean deleteStatus = file.delete();
        //recursively delete attachments path
        boolean deleteAttachmentStatus = DirUtils.deleteRecursive(attachmentsFile);
        return deleteStatus && deleteAttachmentStatus;
    }

    public String getPath() {
        return path;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    // Leave this package protected, so it can only be used
    // TDView uses this accessor
    SQLiteDatabase getDatabase() {
        return database;
    }

    public TDBlobStore getAttachments() {
        return attachments;
    }

    public long totalDataSize() {
        File f = new File(path);
        long size = f.length() + attachments.totalDataSize();
        return size;
    }

    /**
     * Begins a database transaction. Transactions can nest.
     * Every beginTransaction() must be balanced by a later endTransaction()
     */
    public boolean beginTransaction() {
        try {
            database.beginTransaction();
            ++transactionLevel;
            Log.v(TAG, "Begin transaction (level " + Integer.toString(transactionLevel) + ")...");
        } catch (SQLException e) {
            return false;
        }
        return true;
    }

    /**
     * Commits or aborts (rolls back) a transaction.
     *
     * @param commit If true, commits; if false, aborts and rolls back, undoing all changes made since the matching -beginTransaction call, *including* any committed nested transactions.
     */
    public boolean endTransaction(boolean commit) {
        assert(transactionLevel > 0);

        if(commit) {
            Log.v(TAG, "Committing transaction (level " + Integer.toString(transactionLevel) + ")...");
            database.setTransactionSuccessful();
            database.endTransaction();
        }
        else {
            Log.v(TAG, "CANCEL transaction (level " + Integer.toString(transactionLevel) + ")...");
            try {
                database.endTransaction();
            } catch (SQLException e) {
                return false;
            }
        }

        --transactionLevel;
        return true;
    }

    /**
     * Compacts the database storage by removing the bodies and attachments of obsolete revisions.
     */
    public TDStatus compact() {
        // Can't delete any rows because that would lose revision tree history.
        // But we can remove the JSON of non-current revisions, which is most of the space.
        try {
            Log.v(TDDatabase.TAG, "Deleting JSON of old revisions...");
            ContentValues args = new ContentValues();
            args.put("json", (String)null);
            database.update("revs", args, "current=0", null);
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error compacting", e);
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        }

        Log.v(TDDatabase.TAG, "Deleting old attachments...");
        TDStatus result = garbageCollectAttachments();

        Log.v(TDDatabase.TAG, "Vacuuming SQLite database...");
        try {
            database.execSQL("VACUUM");
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error vacuuming database", e);
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        }

        return result;
    }

    public String privateUUID() {
        String result = null;
        Cursor cursor = null;
        try {
            cursor = database.rawQuery("SELECT value FROM info WHERE key='privateUUID'", null);
            if(cursor.moveToFirst()) {
                result = cursor.getString(0);
            }
        } catch(SQLException e) {
            Log.e(TAG, "Error querying privateUUID", e);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
        return result;
    }

    public String publicUUID() {
        String result = null;
        Cursor cursor = null;
        try {
            cursor = database.rawQuery("SELECT value FROM info WHERE key='publicUUID'", null);
            if(cursor.moveToFirst()) {
                result = cursor.getString(0);
            }
        } catch(SQLException e) {
            Log.e(TAG, "Error querying privateUUID", e);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
        return result;
    }

    /** GETTING DOCUMENTS: **/

    public int getDocumentCount() {
        String sql = "SELECT COUNT(DISTINCT doc_id) FROM revs WHERE current=1 AND deleted=0";
        Cursor cursor = null;
        int result = 0;
        try {
            cursor = database.rawQuery(sql, null);
            if(cursor.moveToFirst()) {
                result = cursor.getInt(0);
            }
        } catch(SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting document count", e);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

        return result;
    }

    public long getLastSequence() {
        String sql = "SELECT MAX(sequence) FROM revs";
        Cursor cursor = null;
        long result = 0;
        try {
            cursor = database.rawQuery(sql, null);
            if(cursor.moveToFirst()) {
                result = cursor.getLong(0);
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting last sequence", e);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
        return result;
    }

    /** Splices the contents of an NSDictionary into JSON data (that already represents a dict), without parsing the JSON. */
    public  byte[] appendDictToJSON(byte[] json, Map<String,Object> dict) {
        if(dict.size() == 0) {
            return json;
        }

        byte[] extraJSON = null;
        try {
            extraJSON = mapper.writeValueAsBytes(dict);
        } catch (Exception e) {
            Log.e(TDDatabase.TAG, "Error convert extra JSON to bytes", e);
            return null;
        }

        int jsonLength = json.length;
        int extraLength = extraJSON.length;
        if(jsonLength == 2) { // Original JSON was empty
            return extraJSON;
        }
        byte[] newJson = new byte[jsonLength + extraLength - 1];
        System.arraycopy(json, 0, newJson, 0, jsonLength - 1);  // Copy json w/o trailing '}'
        newJson[jsonLength - 1] = ',';  // Add a ','
        System.arraycopy(extraJSON, 1, newJson, jsonLength, extraLength - 1);
        return newJson;
    }

    /** Inserts the _id, _rev and _attachments properties into the JSON data and stores it in rev.
    Rev must already have its revID and sequence properties set. */
    public Map<String,Object> extraPropertiesForRevision(TDRevision rev, EnumSet<TDContentOptions> contentOptions) {

        String docId = rev.getDocId();
        String revId = rev.getRevId();
        long sequenceNumber = rev.getSequence();
        assert(revId != null);
        assert(sequenceNumber > 0);

        // Get attachment metadata, and optionally the contents:
        boolean withAttachments = contentOptions.contains(TDContentOptions.TDIncludeAttachments);
        Map<String, Object> attachmentsDict = getAttachmentsDictForSequenceWithContent(sequenceNumber, withAttachments);

        // Get more optional stuff to put in the properties:
        //OPT: This probably ends up making redundant SQL queries if multiple options are enabled.
        Long localSeq = null;
        if(contentOptions.contains(TDContentOptions.TDIncludeLocalSeq)) {
            localSeq = sequenceNumber;
        }

        Map<String,Object> revHistory = null;
        if(contentOptions.contains(TDContentOptions.TDIncludeRevs)) {
            revHistory = getRevisionHistoryDict(rev);
        }

        List<Object> revsInfo = null;
        if(contentOptions.contains(TDContentOptions.TDIncludeRevsInfo)) {
            revsInfo = new ArrayList<Object>();
            List<TDRevision> revHistoryFull = getRevisionHistory(rev);
            for (TDRevision historicalRev : revHistoryFull) {
                Map<String,Object> revHistoryItem = new HashMap<String,Object>();
                String status = "available";
                if(historicalRev.isDeleted()) {
                    status = "deleted";
                }
                // TODO: Detect missing revisions, set status="missing"
                revHistoryItem.put("rev", historicalRev.getRevId());
                revHistoryItem.put("status", status);
                revsInfo.add(revHistoryItem);
            }
        }

        List<String> conflicts = null;
        if(contentOptions.contains(TDContentOptions.TDIncludeConflicts)) {
            TDRevisionList revs = getAllRevisionsOfDocumentID(docId, true);
            if(revs.size() > 1) {
                conflicts = new ArrayList<String>();
                for (TDRevision historicalRev : revs) {
                    if(!historicalRev.equals(rev)) {
                        conflicts.add(historicalRev.getRevId());
                    }
                }
            }
        }

        Map<String,Object> result = new HashMap<String,Object>();
        result.put("_id", docId);
        result.put("_rev", revId);
        if(rev.isDeleted()) {
            result.put("_deleted", true);
        }
        if(attachmentsDict != null) {
            result.put("_attachments", attachmentsDict);
        }
        if(localSeq != null) {
            result.put("_local_seq", localSeq);
        }
        if(revHistory != null) {
            result.put("_revisions", revHistory);
        }
        if(revsInfo != null) {
            result.put("_revs_info", revsInfo);
        }
        if(conflicts != null) {
            result.put("_conflicts", conflicts);
        }

        return result;
    }

    /** Inserts the _id, _rev and _attachments properties into the JSON data and stores it in rev.
    Rev must already have its revID and sequence properties set. */
    public void expandStoredJSONIntoRevisionWithAttachments(byte[] json, TDRevision rev, EnumSet<TDContentOptions> contentOptions) {
        Map<String,Object> extra = extraPropertiesForRevision(rev, contentOptions);
        if(json != null) {
            rev.setJson(appendDictToJSON(json, extra));
        }
        else {
            rev.setProperties(extra);
        }
    }

    @SuppressWarnings("unchecked")
    public Map<String, Object> documentPropertiesFromJSON(byte[] json, String docId, String revId, long sequence, EnumSet<TDContentOptions> contentOptions) {

        TDRevision rev = new TDRevision(docId, revId, false);
        rev.setSequence(sequence);
        Map<String,Object> extra = extraPropertiesForRevision(rev, contentOptions);
        if(json == null) {
            return extra;
        }

      Map<String,Object> docProperties = null;
      try {
          docProperties = mapper.readValue(json, Map.class);
          docProperties.putAll(extra);
          return docProperties;
      } catch (Exception e) {
          Log.e(TDDatabase.TAG, "Error serializing properties to JSON", e);
      }

      return docProperties;
    }

    public TDRevision getDocumentWithIDAndRev(String id, String rev, EnumSet<TDContentOptions> contentOptions) {
        TDRevision result = null;
        String sql;

        Cursor cursor = null;
        try {
            cursor = null;
            String cols = "revid, deleted, sequence";
            if(!contentOptions.contains(TDContentOptions.TDNoBody)) {
                cols += ", json";
            }
            if(rev != null) {
                sql = "SELECT " + cols + " FROM revs, docs WHERE docs.docid=? AND revs.doc_id=docs.doc_id AND revid=? LIMIT 1";
                String[] args = {id, rev};
                cursor = database.rawQuery(sql, args);
            }
            else {
                sql = "SELECT " + cols + " FROM revs, docs WHERE docs.docid=? AND revs.doc_id=docs.doc_id and current=1 and deleted=0 ORDER BY revid DESC LIMIT 1";
                String[] args = {id};
                cursor = database.rawQuery(sql, args);
            }

            if(cursor.moveToFirst()) {
                if(rev == null) {
                    rev = cursor.getString(0);
                }
                boolean deleted = (cursor.getInt(1) > 0);
                result = new TDRevision(id, rev, deleted);
                result.setSequence(cursor.getLong(2));
                if(!contentOptions.equals(EnumSet.of(TDContentOptions.TDNoBody))) {
                    byte[] json = null;
                    if(!contentOptions.contains(TDContentOptions.TDNoBody)) {
                        json = cursor.getBlob(3);
                    }
                    expandStoredJSONIntoRevisionWithAttachments(json, result, contentOptions);
                }
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting document with id and rev", e);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
        return result;
    }

    public boolean existsDocumentWithIDAndRev(String docId, String revId) {
        return getDocumentWithIDAndRev(docId, revId, EnumSet.of(TDContentOptions.TDNoBody)) != null;
    }

    public TDStatus loadRevisionBody(TDRevision rev, EnumSet<TDContentOptions> contentOptions) {
        if(rev.getBody() != null) {
            return new TDStatus(TDStatus.OK);
        }
        assert((rev.getDocId() != null) && (rev.getRevId() != null));

        Cursor cursor = null;
        TDStatus result = new TDStatus(TDStatus.NOT_FOUND);
        try {
            String sql = "SELECT sequence, json FROM revs, docs WHERE revid=? AND docs.docid=? AND revs.doc_id=docs.doc_id LIMIT 1";
            String[] args = { rev.getRevId(), rev.getDocId()};
            cursor = database.rawQuery(sql, args);
            if(cursor.moveToFirst()) {
                result.setCode(TDStatus.OK);
                rev.setSequence(cursor.getLong(0));
                expandStoredJSONIntoRevisionWithAttachments(cursor.getBlob(1), rev, contentOptions);
            }
        } catch(SQLException e) {
            Log.e(TDDatabase.TAG, "Error loading revision body", e);
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
        return result;
    }

    public long getDocNumericID(String docId) {
        Cursor cursor = null;
        String[] args = { docId };

        long result = -1;
        try {
            cursor = database.rawQuery("SELECT doc_id FROM docs WHERE docid=?", args);

            if(cursor.moveToFirst()) {
                result = cursor.getLong(0);
            }
            else {
                result = 0;
            }
        } catch (Exception e) {
            Log.e(TDDatabase.TAG, "Error getting doc numeric id", e);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

        return result;
    }

    /** HISTORY: **/

    /**
     * Returns all the known revisions (or all current/conflicting revisions) of a document.
     */
    public TDRevisionList getAllRevisionsOfDocumentID(String docId, long docNumericID, boolean onlyCurrent) {

        String sql = null;
        if(onlyCurrent) {
            sql = "SELECT sequence, revid, deleted FROM revs " +
                    "WHERE doc_id=? AND current ORDER BY sequence DESC";
        }
        else {
            sql = "SELECT sequence, revid, deleted FROM revs " +
                    "WHERE doc_id=? ORDER BY sequence DESC";
        }

        String[] args = { Long.toString(docNumericID) };
        Cursor cursor = null;

        cursor = database.rawQuery(sql, args);

        TDRevisionList result;
        try {
            cursor.moveToFirst();
            result = new TDRevisionList();
            while(!cursor.isAfterLast()) {
                TDRevision rev = new TDRevision(docId, cursor.getString(1), (cursor.getInt(2) > 0));
                rev.setSequence(cursor.getLong(0));
                result.add(rev);
                cursor.moveToNext();
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting all revisions of document", e);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

        return result;
    }

    public TDRevisionList getAllRevisionsOfDocumentID(String docId, boolean onlyCurrent) {
        long docNumericId = getDocNumericID(docId);
        if(docNumericId < 0) {
            return null;
        }
        else if(docNumericId == 0) {
            return new TDRevisionList();
        }
        else {
            return getAllRevisionsOfDocumentID(docId, docNumericId, onlyCurrent);
        }
    }

    public List<String> getConflictingRevisionIDsOfDocID(String docID) {
        long docIdNumeric = getDocNumericID(docID);
        if(docIdNumeric < 0) {
            return null;
        }

        List<String> result = new ArrayList<String>();
        Cursor cursor = null;
        try {
            String[] args = { Long.toString(docIdNumeric) };
            cursor = database.rawQuery("SELECT revid FROM revs WHERE doc_id=? AND current " +
                                           "ORDER BY revid DESC OFFSET 1", args);
            cursor.moveToFirst();
            while(!cursor.isAfterLast()) {
                result.add(cursor.getString(0));
                cursor.moveToNext();
            }

        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting all revisions of document", e);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

        return result;
    }

    public String findCommonAncestorOf(TDRevision rev, List<String> revIDs) {
        String result = null;

    	if (revIDs.size() == 0)
    		return null;
    	String docId = rev.getDocId();
    	long docNumericID = getDocNumericID(docId);
    	if (docNumericID <= 0)
    		return null;
    	String quotedRevIds = joinQuoted(revIDs);
    	String sql = "SELECT revid FROM revs " +
    			"WHERE doc_id=? and revid in (" + quotedRevIds + ") and revid <= ? " +
    			"ORDER BY revid DESC LIMIT 1";
    	String[] args = { Long.toString(docNumericID) };

    	Cursor cursor = null;
    	try {
    		cursor = database.rawQuery(sql, args);
    		cursor.moveToFirst();
            if(!cursor.isAfterLast()) {
                result = cursor.getString(0);
    		}

    	} catch (SQLException e) {
    		Log.e(TDDatabase.TAG, "Error getting all revisions of document", e);
    	} finally {
    		if(cursor != null) {
    			cursor.close();
    		}
    	}

    	return result;
    }

    /**
     * Returns an array of TDRevs in reverse chronological order, starting with the given revision.
     */
    public List<TDRevision> getRevisionHistory(TDRevision rev) {
        String docId = rev.getDocId();
        String revId = rev.getRevId();
        assert((docId != null) && (revId != null));

        long docNumericId = getDocNumericID(docId);
        if(docNumericId < 0) {
            return null;
        }
        else if(docNumericId == 0) {
            return new ArrayList<TDRevision>();
        }

        String sql = "SELECT sequence, parent, revid, deleted FROM revs " +
                    "WHERE doc_id=? ORDER BY sequence DESC";
        String[] args = { Long.toString(docNumericId) };
        Cursor cursor = null;

        List<TDRevision> result;
        try {
            cursor = database.rawQuery(sql, args);

            cursor.moveToFirst();
            long lastSequence = 0;
            result = new ArrayList<TDRevision>();
            while(!cursor.isAfterLast()) {
                long sequence = cursor.getLong(0);
                boolean matches = false;
                if(lastSequence == 0) {
                    matches = revId.equals(cursor.getString(2));
                }
                else {
                    matches = (sequence == lastSequence);
                }
                if(matches) {
                    revId = cursor.getString(2);
                    boolean deleted = (cursor.getInt(3) > 0);
                    TDRevision aRev = new TDRevision(docId, revId, deleted);
                    aRev.setSequence(cursor.getLong(0));
                    result.add(aRev);
                    lastSequence = cursor.getLong(1);
                    if(lastSequence == 0) {
                        break;
                    }
                }
                cursor.moveToNext();
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting revision history", e);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

        return result;
    }

    // Splits a revision ID into its generation number and opaque suffix string
    public static int parseRevIDNumber(String rev) {
        int result = -1;
        int dashPos = rev.indexOf("-");
        if(dashPos >= 0) {
            try {
                result = Integer.parseInt(rev.substring(0, dashPos));
            } catch (NumberFormatException e) {
                // ignore, let it return -1
            }
        }
        return result;
    }

    // Splits a revision ID into its generation number and opaque suffix string
    public static String parseRevIDSuffix(String rev) {
        String result = null;
        int dashPos = rev.indexOf("-");
        if(dashPos >= 0) {
            result = rev.substring(dashPos + 1);
        }
        return result;
    }

    public static Map<String,Object> makeRevisionHistoryDict(List<TDRevision> history) {
        if(history == null) {
            return null;
        }

        // Try to extract descending numeric prefixes:
        List<String> suffixes = new ArrayList<String>();
        int start = -1;
        int lastRevNo = -1;
        for (TDRevision rev : history) {
            int revNo = parseRevIDNumber(rev.getRevId());
            String suffix = parseRevIDSuffix(rev.getRevId());
            if(revNo > 0 && suffix.length() > 0) {
                if(start < 0) {
                    start = revNo;
                }
                else if(revNo != lastRevNo - 1) {
                    start = -1;
                    break;
                }
                lastRevNo = revNo;
                suffixes.add(suffix);
            }
            else {
                start = -1;
                break;
            }
        }

        Map<String,Object> result = new HashMap<String,Object>();
        if(start == -1) {
            // we failed to build sequence, just stuff all the revs in list
            suffixes = new ArrayList<String>();
            for (TDRevision rev : history) {
                suffixes.add(rev.getRevId());
            }
        }
        else {
            result.put("start", start);
        }
        result.put("ids", suffixes);

        return result;
    }

    /**
     * Returns the revision history as a _revisions dictionary, as returned by the REST API's ?revs=true option.
     */
    public Map<String,Object> getRevisionHistoryDict(TDRevision rev) {
        return makeRevisionHistoryDict(getRevisionHistory(rev));
    }

    public TDRevisionList changesSince(long lastSeq, TDChangesOptions options, TDFilterBlock filter) {
        // http://wiki.apache.org/couchdb/HTTP_database_API#Changes
        if(options == null) {
            options = new TDChangesOptions();
        }

        boolean includeDocs = options.isIncludeDocs() || (filter != null);
        String additionalSelectColumns =  "";
        if(includeDocs) {
            additionalSelectColumns = ", json";
        }

        String sql = "SELECT sequence, revs.doc_id, docid, revid, deleted" + additionalSelectColumns + " FROM revs, docs "
                        + "WHERE sequence > ? AND current=1 "
                        + "AND revs.doc_id = docs.doc_id "
                        + "ORDER BY revs.doc_id, revid DESC";
        String[] args = {Long.toString(lastSeq)};
        Cursor cursor = null;
        TDRevisionList changes = null;

        try {
            cursor = database.rawQuery(sql, args);
            cursor.moveToFirst();
            changes = new TDRevisionList();
            long lastDocId = 0;
            while(!cursor.isAfterLast()) {
                if(!options.isIncludeConflicts()) {
                    // Only count the first rev for a given doc (the rest will be losing conflicts):
                    long docNumericId = cursor.getLong(1);
                    if(docNumericId == lastDocId) {
                        cursor.moveToNext();
                        continue;
                    }
                    lastDocId = docNumericId;
                }

                TDRevision rev = new TDRevision(cursor.getString(2), cursor.getString(3), (cursor.getInt(4) > 0));
                rev.setSequence(cursor.getLong(0));
                if(includeDocs) {
                    expandStoredJSONIntoRevisionWithAttachments(cursor.getBlob(5), rev, options.getContentOptions());
                }
                if((filter == null) || (filter.filter(rev))) {
                    changes.add(rev);
                }
                cursor.moveToNext();
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error looking for changes", e);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

        if(options.isSortBySequence()) {
            changes.sortBySequence();
        }
        changes.limit(options.getLimit());
        return changes;
    }

    /**
     * Define or clear a named filter function.
     *
     * These aren't used directly by TDDatabase, but they're looked up by TDRouter when a _changes request has a ?filter parameter.
     */
    public void defineFilter(String filterName, TDFilterBlock filter) {
        if(filters == null) {
            filters = new HashMap<String,TDFilterBlock>();
        }
        filters.put(filterName, filter);
    }

    public TDFilterBlock getFilterNamed(String filterName) {
        TDFilterBlock result = null;
        if(filters != null) {
            result = filters.get(filterName);
        }
        return result;
    }

    /** VIEWS: **/

    public TDView registerView(TDView view) {
        if(view == null) {
            return null;
        }
        if(views == null) {
            views = new HashMap<String,TDView>();
        }
        views.put(view.getName(), view);
        return view;
    }

    public TDView getViewNamed(String name) {
        TDView view = null;
        if(views != null) {
            view = views.get(name);
        }
        if(view != null) {
            return view;
        }
        return registerView(new TDView(this, name));
    }

    public TDView getExistingViewNamed(String name) {
        TDView view = null;
        if(views != null) {
            view = views.get(name);
        }
        if(view != null) {
            return view;
        }
        view = new TDView(this, name);
        if(view.getViewId() == 0) {
            return null;
        }

        return registerView(view);
    }

    public List<TDView> getAllViews() {
        Cursor cursor = null;
        List<TDView> result = null;

        try {
            cursor = database.rawQuery("SELECT name FROM views", null);
            cursor.moveToFirst();
            result = new ArrayList<TDView>();
            while(!cursor.isAfterLast()) {
                result.add(getViewNamed(cursor.getString(0)));
                cursor.moveToNext();
            }
        } catch (Exception e) {
            Log.e(TDDatabase.TAG, "Error getting all views", e);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

        return result;
    }

    public TDStatus deleteViewNamed(String name) {
        TDStatus result = new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        try {
            String[] whereArgs = { name };
            int rowsAffected = database.delete("views", "name=?", whereArgs);
            if(rowsAffected > 0) {
                result.setCode(TDStatus.OK);
            }
            else {
                result.setCode(TDStatus.NOT_FOUND);
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error deleting view", e);
        }
        return result;
    }

    //FIX: This has a lot of code in common with -[TDView queryWithOptions:status:]. Unify the two!
    public Map<String,Object> getDocsWithIDs(List<String> docIDs, TDQueryOptions options) {
        if(options == null) {
            options = new TDQueryOptions();
        }

        long updateSeq = 0;
        if(options.isUpdateSeq()) {
            updateSeq = getLastSequence();  // TODO: needs to be atomic with the following SELECT
        }

        // Generate the SELECT statement, based on the options:
        String additionalCols = "";
        if(options.isIncludeDocs()) {
            additionalCols = ", json, sequence";
        }
        String sql = "SELECT revs.doc_id, docid, revid, deleted" + additionalCols + " FROM revs, docs WHERE";

        if(docIDs != null) {
            sql += " docid IN (" + joinQuoted(docIDs) + ")";
        } else {
            sql += " deleted=0";
        }

        sql += " AND current=1 AND docs.doc_id = revs.doc_id";

        List<String> argsList = new ArrayList<String>();
        Object minKey = options.getStartKey();
        Object maxKey = options.getEndKey();
        boolean inclusiveMin = true;
        boolean inclusiveMax = options.isInclusiveEnd();
        if(options.isDescending()) {
            minKey = maxKey;
            maxKey = options.getStartKey();
            inclusiveMin = inclusiveMax;
            inclusiveMax = true;
        }

        if(minKey != null) {
            assert(minKey instanceof String);
            if(inclusiveMin) {
                sql += " AND docid >= ?";
            } else {
                sql += " AND docid > ?";
            }
            argsList.add((String)minKey);
        }

        if(maxKey != null) {
            assert(maxKey instanceof String);
            if(inclusiveMax) {
                sql += " AND docid <= ?";
            }
            else {
                sql += " AND docid < ?";
            }
            argsList.add((String)maxKey);
        }


        String order = "ASC";
        if(options.isDescending()) {
            order = "DESC";
        }

        sql += " ORDER BY docid " + order + ", revid DESC LIMIT ? OFFSET ?";

        argsList.add(Integer.toString(options.getLimit()));
        argsList.add(Integer.toString(options.getSkip()));
        Cursor cursor = null;
        long lastDocID = 0;
        List<Map<String,Object>> rows = null;

        try {
            cursor = database.rawQuery(sql, argsList.toArray(new String[argsList.size()]));

            cursor.moveToFirst();
            rows = new ArrayList<Map<String,Object>>();
            while(!cursor.isAfterLast()) {
                long docNumericID = cursor.getLong(0);
                if(docNumericID == lastDocID) {
                    cursor.moveToNext();
                    continue;
                }
                lastDocID = docNumericID;

                String docId = cursor.getString(1);
                String revId = cursor.getString(2);
                Map<String, Object> docContents = null;
                boolean deleted = cursor.getInt(3) > 0;
                if(options.isIncludeDocs() && !deleted) {
                    byte[] json = cursor.getBlob(4);
                    long sequence = cursor.getLong(5);
                    docContents = documentPropertiesFromJSON(json, docId, revId, sequence, options.getContentOptions());
                }

                Map<String,Object> valueMap = new HashMap<String,Object>();
                valueMap.put("rev", revId);

                Map<String,Object> change = new HashMap<String, Object>();
                change.put("id", docId);
                change.put("key", docId);
                change.put("value", valueMap);
                if(docContents != null) {
                    change.put("doc", docContents);
                }
                if(deleted) {
                    change.put("deleted", true);
                }

                rows.add(change);

                cursor.moveToNext();
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting all docs", e);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

        int totalRows = cursor.getCount();  //??? Is this true, or does it ignore limit/offset?
        Map<String, Object> result = new HashMap<String, Object>();
        result.put("rows", rows);
        result.put("total_rows", totalRows);
        result.put("offset", options.getSkip());
        if(updateSeq != 0) {
            result.put("update_seq", updateSeq);
        }


        return result;
    }

    public Map<String,Object> getAllDocs(TDQueryOptions options) {
        return getDocsWithIDs(null, options);
    }

    /*************************************************************************************************/
    /*** TDDatabase+Attachments                                                                    ***/
    /*************************************************************************************************/

    public TDStatus insertAttachmentForSequenceWithNameAndType(byte[] contents, long sequence, String name, String contentType, int revpos) {
        assert(contents != null);
        assert(sequence > 0);
        assert(name != null);

        TDBlobKey key = new TDBlobKey();
        if(!attachments.storeBlob(contents, key)) {
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        }

        byte[] keyData = key.getBytes();
        try {
            ContentValues args = new ContentValues();
            args.put("sequence", sequence);
            args.put("filename", name);
            args.put("key", keyData);
            args.put("type", contentType);
            args.put("length", contents.length);
            args.put("revpos", revpos);
            database.insert("attachments", null, args);
            return new TDStatus(TDStatus.CREATED);
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error inserting attachment", e);
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        }
    }

    public TDStatus copyAttachmentNamedFromSequenceToSequence(String name, long fromSeq, long toSeq) {
        assert(name != null);
        assert(toSeq > 0);
        if(fromSeq < 0) {
            return new TDStatus(TDStatus.NOT_FOUND);
        }

        Cursor cursor = null;

        String[] args = { Long.toString(toSeq), name, Long.toString(fromSeq), name };
        try {
            database.execSQL("INSERT INTO attachments (sequence, filename, key, type, length, revpos) " +
                                      "SELECT ?, ?, key, type, length, revpos FROM attachments " +
                                        "WHERE sequence=? AND filename=?", args);
            cursor = database.rawQuery("SELECT changes()", null);
            cursor.moveToFirst();
            int rowsUpdated = cursor.getInt(0);
            if(rowsUpdated == 0) {
                // Oops. This means a glitch in our attachment-management or pull code,
                // or else a bug in the upstream server.
                Log.w(TDDatabase.TAG, "Can't find inherited attachment " + name + " from seq# " + Long.toString(fromSeq) + " to copy to " + Long.toString(toSeq));
                return new TDStatus(TDStatus.NOT_FOUND);
            }
            else {
                return new TDStatus(TDStatus.OK);
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error copying attachment", e);
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
    }

    /**
     * Returns the content and MIME type of an attachment
     */
    public TDAttachment getAttachmentForSequence(long sequence, String filename, TDStatus status) {
        assert(sequence > 0);
        assert(filename != null);


        Cursor cursor = null;

        String[] args = { Long.toString(sequence), filename };
        try {
            cursor = database.rawQuery("SELECT key, type FROM attachments WHERE sequence=? AND filename=?", args);

            if(!cursor.moveToFirst()) {
                status.setCode(TDStatus.NOT_FOUND);
                return null;
            }

            byte[] keyData = cursor.getBlob(0);
            //TODO add checks on key here? (ios version)
            TDBlobKey key = new TDBlobKey(keyData);
            byte[] contents = attachments.blobForKey(key);
            if(contents == null) {
                Log.e(TDDatabase.TAG, "Failed to load attachment");
                status.setCode(TDStatus.INTERNAL_SERVER_ERROR);
                return null;
            }
            else {
                status.setCode(TDStatus.OK);
                TDAttachment result = new TDAttachment();
                result.setData(contents);
                result.setContentType(cursor.getString(1));
                return result;
            }


        } catch (SQLException e) {
            status.setCode(TDStatus.INTERNAL_SERVER_ERROR);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }

    }

    /**
     * Constructs an "_attachments" dictionary for a revision, to be inserted in its JSON body.
     */
    public Map<String,Object> getAttachmentsDictForSequenceWithContent(long sequence, boolean withContent) {
        assert(sequence > 0);

        Cursor cursor = null;

        String args[] = { Long.toString(sequence) };
        try {
            cursor = database.rawQuery("SELECT filename, key, type, length, revpos FROM attachments WHERE sequence=?", args);

            if(!cursor.moveToFirst()) {
                return null;
            }

            Map<String, Object> result = new HashMap<String, Object>();

            while(!cursor.isAfterLast()) {

                byte[] keyData = cursor.getBlob(1);
                TDBlobKey key = new TDBlobKey(keyData);
                String digestString = "sha1-" + Base64.encodeBytes(keyData);
                String dataBase64 = null;
                if(withContent) {
                    byte[] data = attachments.blobForKey(key);
                    if(data != null) {
                        dataBase64 = Base64.encodeBytes(data);
                    }
                    else {
                        Log.w(TDDatabase.TAG, "Error loading attachment");
                    }
                }

                Map<String, Object> attachment = new HashMap<String, Object>();
                if(dataBase64 == null) {
                    attachment.put("stub", true);
                }
                else {
                    attachment.put("data", dataBase64);
                }
                attachment.put("digest", digestString);
                attachment.put("content_type", cursor.getString(2));
                attachment.put("length", cursor.getInt(3));
                attachment.put("revpos", cursor.getInt(4));

                result.put(cursor.getString(0), attachment);

                cursor.moveToNext();
            }

            return result;

        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting attachments for sequence", e);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
    }

    /**
     * Modifies a TDRevision's body by changing all attachments with revpos < minRevPos into stubs.
     *
     * @param rev
     * @param minRevPos
     */
    public void stubOutAttachmentsIn(TDRevision rev, int minRevPos)
    {
        if (minRevPos <= 1) {
            return;
        }
        Map<String, Object> properties = (Map<String,Object>)rev.getProperties();
        Map<String, Object> attachments = null;
        if(properties != null) {
            attachments = (Map<String,Object>)properties.get("_attachments");
        }
        Map<String, Object> editedProperties = null;
        Map<String, Object> editedAttachments = null;
        for (String name : attachments.keySet()) {
            Map<String,Object> attachment = (Map<String,Object>)attachments.get(name);
            int revPos = (Integer) attachment.get("revpos");
            Object stub = attachment.get("stub");
            if (revPos > 0 && revPos < minRevPos && (stub == null)) {
                // Strip this attachment's body. First make its dictionary mutable:
                if (editedProperties == null) {
                    editedProperties = new HashMap<String,Object>(properties);
                    editedAttachments = new HashMap<String,Object>(attachments);
                    editedProperties.put("_attachments", editedAttachments);
                }
                // ...then remove the 'data' and 'follows' key:
                Map<String,Object> editedAttachment = new HashMap<String,Object>(attachment);
                editedAttachment.remove("data");
                editedAttachment.remove("follows");
                editedAttachment.put("stub", true);
                editedAttachments.put(name,editedAttachment);
                Log.d(TDDatabase.TAG, "Stubbed out attachment" + rev + " " + name + ": revpos" + revPos + " " + minRevPos);
            }
        }
        if (editedProperties != null)
            rev.setProperties(editedProperties);
    }

    /**
     * Given a newly-added revision, adds the necessary attachment rows to the database and stores inline attachments into the blob store.
     */
    public TDStatus processAttachmentsForRevision(TDRevision rev, long parentSequence) {
        assert(rev != null);
        long newSequence = rev.getSequence();
        assert(newSequence > parentSequence);

        // If there are no attachments in the new rev, there's nothing to do:
        Map<String,Object> newAttachments = null;
        Map<String,Object> properties = (Map<String,Object>)rev.getProperties();
        if(properties != null) {
            newAttachments = (Map<String,Object>)properties.get("_attachments");
        }
        if(newAttachments == null || newAttachments.size() == 0 || rev.isDeleted()) {
            return new TDStatus(TDStatus.OK);
        }

        for (String name : newAttachments.keySet()) {

            TDStatus status = new TDStatus();
            Map<String,Object> newAttach = (Map<String,Object>)newAttachments.get(name);
            String newContentBase64 = (String)newAttach.get("data");
            if(newContentBase64 != null) {
                // New item contains data, so insert it. First decode the data:
                byte[] newContents;
                try {
                    newContents = Base64.decode(newContentBase64);
                } catch (IOException e) {
                    Log.e(TDDatabase.TAG, "IOExeption parsing base64", e);
                    return new TDStatus(TDStatus.BAD_REQUEST);
                }
                if(newContents == null) {
                    return new TDStatus(TDStatus.BAD_REQUEST);
                }

                // Now determine the revpos, i.e. generation # this was added in. Usually this is
                // implicit, but a rev being pulled in replication will have it set already.
                int generation = rev.getGeneration();
                assert(generation > 0);
                Object revposObj = newAttach.get("revpos");
                int revpos = generation;
                if(revposObj != null && revposObj instanceof Integer) {
                    revpos = ((Integer)revposObj).intValue();
                }

                if(revpos > generation) {
                    return new TDStatus(TDStatus.BAD_REQUEST);
                }

                // Finally insert the attachment:
                status = insertAttachmentForSequenceWithNameAndType(newContents, newSequence, name, (String)newAttach.get("content_type"), revpos);
            }
            else {
                // It's just a stub, so copy the previous revision's attachment entry:
                //? Should I enforce that the type and digest (if any) match?
                status = copyAttachmentNamedFromSequenceToSequence(name, parentSequence, newSequence);
            }
            if(!status.isSuccessful()) {
                return status;
            }
        }

        return new TDStatus(TDStatus.OK);
    }

    /**
     * Updates or deletes an attachment, creating a new document revision in the process.
     * Used by the PUT / DELETE methods called on attachment URLs.
     */
    public TDRevision updateAttachment(String filename, byte[] body, String contentType, String docID, String oldRevID, TDStatus status) {
        status.setCode(TDStatus.BAD_REQUEST);
        if(filename == null || filename.length() == 0 || (body != null && contentType == null) || (oldRevID != null && docID == null) || (body != null && docID == null)) {
            return null;
        }

        beginTransaction();
        try {
            TDRevision oldRev = new TDRevision(docID, oldRevID, false);
            if(oldRevID != null) {
                // Load existing revision if this is a replacement:
                TDStatus loadStatus = loadRevisionBody(oldRev, EnumSet.noneOf(TDContentOptions.class));
                status.setCode(loadStatus.getCode());
                if(!status.isSuccessful()) {
                    if(status.getCode() == TDStatus.NOT_FOUND && existsDocumentWithIDAndRev(docID, null)) {
                        status.setCode(TDStatus.CONFLICT);  // if some other revision exists, it's a conflict
                    }
                    return null;
                }

                Map<String,Object> attachments = (Map<String, Object>) oldRev.getProperties().get("_attachments");
                if(body == null && attachments != null && !attachments.containsKey(filename)) {
                    status.setCode(TDStatus.NOT_FOUND);
                    return null;
                }
                // Remove the _attachments stubs so putRevision: doesn't copy the rows for me
                // OPT: Would be better if I could tell loadRevisionBody: not to add it
                if(attachments != null) {
                    Map<String,Object> properties = new HashMap<String,Object>(oldRev.getProperties());
                    properties.remove("_attachments");
                    oldRev.setBody(new TDBody(properties));
                }
            } else {
                // If this creates a new doc, it needs a body:
                oldRev.setBody(new TDBody(new HashMap<String,Object>()));
            }

            // Create a new revision:
            TDRevision newRev = putRevision(oldRev, oldRevID, false, status);
            if(newRev == null) {
                return null;
            }

            if(oldRevID != null) {
                // Copy all attachment rows _except_ for the one being updated:
                String[] args = { Long.toString(newRev.getSequence()), Long.toString(oldRev.getSequence()), filename };
                database.execSQL("INSERT INTO attachments "
                        + "(sequence, filename, key, type, length, revpos) "
                        + "SELECT ?, filename, key, type, length, revpos FROM attachments "
                        + "WHERE sequence=? AND filename != ?", args);
            }

            if(body != null) {
                // If not deleting, add a new attachment entry:
                TDStatus insertStatus = insertAttachmentForSequenceWithNameAndType(body, newRev.getSequence(),
                        filename, contentType, newRev.getGeneration());
                status.setCode(insertStatus.getCode());

                if(!status.isSuccessful()) {
                    return null;
                }
            }

            status.setCode((body != null) ? TDStatus.CREATED : TDStatus.OK);
            return newRev;

        } catch(SQLException e) {
            Log.e(TAG, "Error uploading attachment", e);
            status.setCode(TDStatus.INTERNAL_SERVER_ERROR);
            return null;
        } finally {
            endTransaction(status.isSuccessful());
        }
    }

    /**
     * Deletes obsolete attachments from the database and blob store.
     */
    public TDStatus garbageCollectAttachments() {
        // First delete attachment rows for already-cleared revisions:
        // OPT: Could start after last sequence# we GC'd up to

        try {
            database.execSQL("DELETE FROM attachments WHERE sequence IN " +
                            "(SELECT sequence from revs WHERE json IS null)");
        }
        catch(SQLException e) {
            Log.e(TDDatabase.TAG, "Error deleting attachments", e);
        }

        // Now collect all remaining attachment IDs and tell the store to delete all but these:
        Cursor cursor = null;
        try {
            cursor = database.rawQuery("SELECT DISTINCT key FROM attachments", null);

            cursor.moveToFirst();
            List<TDBlobKey> allKeys = new ArrayList<TDBlobKey>();
            while(!cursor.isAfterLast()) {
                TDBlobKey key = new TDBlobKey(cursor.getBlob(0));
                allKeys.add(key);
                cursor.moveToNext();
            }

            int numDeleted = attachments.deleteBlobsExceptWithKeys(allKeys);
            if(numDeleted < 0) {
                return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
            }

            Log.v(TDDatabase.TAG, "Deleted " + numDeleted + " attachments");

            return new TDStatus(TDStatus.OK);
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error finding attachment keys in use", e);
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
    }

    /*************************************************************************************************/
    /*** TDDatabase+Insertion                                                                      ***/
    /*************************************************************************************************/

    /** DOCUMENT & REV IDS: **/

    public static boolean isValidDocumentId(String id) {
        // http://wiki.apache.org/couchdb/HTTP_Document_API#Documents
        if(id == null || id.length() == 0) {
            return false;
        }
        if(id.charAt(0) == '_') {
            return  (id.startsWith("_design/"));
        }
        return true;
        // "_local/*" is not a valid document ID. Local docs have their own API and shouldn't get here.
    }

    public static String generateDocumentId() {
        return TDMisc.TDCreateUUID();
    }

    public String generateNextRevisionID(String revisionId) {
        // Revision IDs have a generation count, a hyphen, and a UUID.
        int generation = 0;
        if(revisionId != null) {
            generation = TDRevision.generationFromRevID(revisionId);
            if(generation == 0) {
                return null;
            }
        }
        String digest = TDMisc.TDCreateUUID();  //TODO: Generate canonical digest of body
        return Integer.toString(generation + 1) + "-" + digest;
    }

    public long insertDocumentID(String docId) {
        long rowId = -1;
        try {
            ContentValues args = new ContentValues();
            args.put("docid", docId);
            rowId = database.insert("docs", null, args);
        } catch (Exception e) {
            Log.e(TDDatabase.TAG, "Error inserting document id", e);
        }
        return rowId;
    }

    public long getOrInsertDocNumericID(String docId) {
        long docNumericId = getDocNumericID(docId);
        if(docNumericId == 0) {
            docNumericId = insertDocumentID(docId);
        }
        return docNumericId;
    }

    /**
     * Parses the _revisions dict from a document into an array of revision ID strings
     */
    public static List<String> parseCouchDBRevisionHistory(Map<String,Object> docProperties) {
        Map<String,Object> revisions = (Map<String,Object>)docProperties.get("_revisions");
        if(revisions == null) {
            return null;
        }
        List<String> revIDs = (List<String>)revisions.get("ids");
        Integer start = (Integer)revisions.get("start");
        if(start != null) {
            for(int i=0; i < revIDs.size(); i++) {
                String revID = revIDs.get(i);
                revIDs.set(i, Integer.toString(start--) + "-" + revID);
            }
        }
        return revIDs;
    }

    /** INSERTION: **/

    public byte[] encodeDocumentJSON(TDRevision rev) {

        Map<String,Object> origProps = rev.getProperties();
        if(origProps == null) {
            return null;
        }

        // Don't allow any "_"-prefixed keys. Known ones we'll ignore, unknown ones are an error.
        Map<String,Object> properties = new HashMap<String,Object>(origProps.size());
        for (String key : origProps.keySet()) {
            if(key.startsWith("_")) {
                if(!KNOWN_SPECIAL_KEYS.contains(key)) {
                    Log.e(TAG, "TDDatabase: Invalid top-level key '" + key + "' in document to be inserted");
                    return null;
                }
            } else {
                properties.put(key, origProps.get(key));
            }
        }

        byte[] json = null;
        try {
            json = mapper.writeValueAsBytes(properties);
        } catch (Exception e) {
            Log.e(TDDatabase.TAG, "Error serializing " + rev + " to JSON", e);
        }
        return json;
    }

    public void notifyChange(TDRevision rev, URL source) {
        Map<String,Object> changeNotification = new HashMap<String, Object>();
        changeNotification.put("rev", rev);
        changeNotification.put("seq", rev.getSequence());
        if(source != null) {
            changeNotification.put("source", source);
        }
        setChanged();
        notifyObservers(changeNotification);
    }

    public long insertRevision(TDRevision rev, long docNumericID, long parentSequence, boolean current, byte[] data) {
        long rowId = 0;
        try {
            ContentValues args = new ContentValues();
            args.put("doc_id", docNumericID);
            args.put("revid", rev.getRevId());
            if(parentSequence != 0) {
                args.put("parent", parentSequence);
            }
            args.put("current", current);
            args.put("deleted", rev.isDeleted());
            args.put("json", data);
            rowId = database.insert("revs", null, args);
            rev.setSequence(rowId);
        } catch (Exception e) {
            Log.e(TDDatabase.TAG, "Error inserting revision", e);
        }
        return rowId;
    }

    private TDRevision putRevision(TDRevision rev, String prevRevId, TDStatus resultStatus) {
        return putRevision(rev, prevRevId, false, resultStatus);
    }

    /**
     * Stores a new (or initial) revision of a document.
     *
     * This is what's invoked by a PUT or POST. As with those, the previous revision ID must be supplied when necessary and the call will fail if it doesn't match.
     *
     * @param rev The revision to add. If the docID is null, a new UUID will be assigned. Its revID must be null. It must have a JSON body.
     * @param prevRevId The ID of the revision to replace (same as the "?rev=" parameter to a PUT), or null if this is a new document.
     * @param allowConflict If false, an error status 409 will be returned if the insertion would create a conflict, i.e. if the previous revision already has a child.
     * @param resultStatus On return, an HTTP status code indicating success or failure.
     * @return A new TDRevision with the docID, revID and sequence filled in (but no body).
     */
    @SuppressWarnings("unchecked")
    public TDRevision putRevision(TDRevision rev, String prevRevId, boolean allowConflict, TDStatus resultStatus) {
        // prevRevId is the rev ID being replaced, or nil if an insert
        String docId = rev.getDocId();
        boolean deleted = rev.isDeleted();
        if((rev == null) || ((prevRevId != null) && (docId == null)) || (deleted && (docId == null))
                || ((docId != null) && !isValidDocumentId(docId))) {
            resultStatus.setCode(TDStatus.BAD_REQUEST);
            return null;
        }

        resultStatus.setCode(TDStatus.INTERNAL_SERVER_ERROR);
        beginTransaction();
        Cursor cursor = null;
        long docNumericID = (docId != null) ? getDocNumericID(docId) : 0;
        long parentSequence = 0;
        try {
            if(prevRevId != null) {
                // Replacing: make sure given prevRevID is current & find its sequence number:
                if(docNumericID <= 0) {
                    resultStatus.setCode(TDStatus.NOT_FOUND);
                    return null;
                }

                String[] args = {Long.toString(docNumericID), prevRevId};
                String additionalWhereClause = "";
                if(!allowConflict) {
                    additionalWhereClause = "AND current=1";
                }

                cursor = database.rawQuery("SELECT sequence FROM revs WHERE doc_id=? AND revid=? " + additionalWhereClause + " LIMIT 1", args);

                if(cursor.moveToFirst()) {
                    parentSequence = cursor.getLong(0);
                }

                if(parentSequence == 0) {
                    // Not found: either a 404 or a 409, depending on whether there is any current revision
                    if(!allowConflict && existsDocumentWithIDAndRev(docId, null)) {
                        resultStatus.setCode(TDStatus.CONFLICT);
                        return null;
                    }
                    else {
                        resultStatus.setCode(TDStatus.NOT_FOUND);
                        return null;
                    }
                }

                if(validations != null && validations.size() > 0) {
                    // Fetch the previous revision and validate the new one against it:
                    TDRevision prevRev = new TDRevision(docId, prevRevId, false);
                    TDStatus status = validateRevision(rev, prevRev);
                    if(!status.isSuccessful()) {
                        resultStatus.setCode(status.getCode());
                        return null;
                    }
                }

                // Make replaced rev non-current:
                ContentValues updateContent = new ContentValues();
                updateContent.put("current", 0);
                database.update("revs", updateContent, "sequence=" + parentSequence, null);
            }
            else if(docId != null) {
                if(deleted) {
                    // Didn't specify a revision to delete: 404 or a 409, depending
                    if(existsDocumentWithIDAndRev(docId, null)) {
                        resultStatus.setCode(TDStatus.CONFLICT);
                        return null;
                    }
                    else {
                        resultStatus.setCode(TDStatus.NOT_FOUND);
                        return null;
                    }
                }

                // Inserting first revision, with docID given. First validate:
                TDStatus status = validateRevision(rev, null);
                if(!status.isSuccessful()) {
                    resultStatus.setCode(status.getCode());
                    return null;
                }

                if(docNumericID <= 0) {
                    // Doc doesn't exist at all; create it:
                    docNumericID = insertDocumentID(docId);
                    if(docNumericID <= 0) {
                        return null;
                    }
                } else {
                    // Doc exists; check whether current winning revision is deleted:
                    String[] args = { Long.toString(docNumericID) };
                    cursor = database.rawQuery("SELECT sequence, deleted FROM revs WHERE doc_id=? and current=1 ORDER BY revid DESC LIMIT 1", args);

                    if(cursor.moveToFirst()) {
                        boolean wasAlreadyDeleted = (cursor.getInt(1) > 0);
                        if(wasAlreadyDeleted) {
                            // Make the deleted revision no longer current:
                            ContentValues updateContent = new ContentValues();
                            updateContent.put("current", 0);
                            database.update("revs", updateContent, "sequence=" + cursor.getLong(0), null);
                        }
                        else if (!allowConflict) {
                            // docId already exists, current not deleted, conflict
                            resultStatus.setCode(TDStatus.CONFLICT);
                            return null;
                        }
                    }
                }
            }
            else {
                //FIXME: not currently doing any document validation here, email sent to Jens
                // Inserting first revision, with no docID given (POST): generate a unique docID:
                docId = TDDatabase.generateDocumentId();
                docNumericID = insertDocumentID(docId);
                if(docNumericID <= 0) {
                    return null;
                }
            }

            // Bump the revID and update the JSON:
            String newRevId = generateNextRevisionID(prevRevId);
            byte[] data = null;
            if(!rev.isDeleted()) {
                data = encodeDocumentJSON(rev);
                if(data == null) {
                    // bad or missing json
                    resultStatus.setCode(TDStatus.BAD_REQUEST);
                    return null;
                }
            }

            rev = rev.copyWithDocID(docId, newRevId);

            // Now insert the rev itself:
            long newSequence = insertRevision(rev, docNumericID, parentSequence, true, data);
            if(newSequence == 0) {
                return null;
            }

            // Store any attachments:
            if(attachments != null) {
                TDStatus status = processAttachmentsForRevision(rev, parentSequence);
                if(!status.isSuccessful()) {
                    resultStatus.setCode(status.getCode());
                    return null;
                }
            }

            // Success!
            if(deleted) {
                resultStatus.setCode(TDStatus.OK);
            }
            else {
                resultStatus.setCode(TDStatus.CREATED);
            }

        } catch (SQLException e1) {
            Log.e(TDDatabase.TAG, "Error putting revision", e1);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
            endTransaction(resultStatus.isSuccessful());
        }

        // Send a change notification:
        rev.setBody(null);  // body is not up to date (no current _rev, likely no _id) so avoid confusion
        notifyChange(rev, null);
        return rev;
    }

    /**
     * Inserts an already-existing revision replicated from a remote database.
     *
     * It must already have a revision ID. This may create a conflict! The revision's history must be given; ancestor revision IDs that don't already exist locally will create phantom revisions with no content.
     */
    public TDStatus forceInsert(TDRevision rev, List<String> revHistory, URL source) {

        String docId = rev.getDocId();
        String revId = rev.getRevId();
        if(!isValidDocumentId(docId) || (revId == null)) {
            return new TDStatus(TDStatus.BAD_REQUEST);
        }

        int historyCount = revHistory.size();
        if(historyCount == 0) {
            revHistory = new ArrayList<String>();
            revHistory.add(revId);
            historyCount = 1;
        } else if(!revHistory.get(0).equals(rev.getRevId())) {
            return new TDStatus(TDStatus.BAD_REQUEST);
        }

        boolean success = false;
        beginTransaction();
        try {
            // First look up all locally-known revisions of this document:
            long docNumericID = getOrInsertDocNumericID(docId);
            TDRevisionList localRevs = getAllRevisionsOfDocumentID(docId, docNumericID, false);
            if(localRevs == null) {
                return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
            }

            // Walk through the remote history in chronological order, matching each revision ID to
            // a local revision. When the list diverges, start creating blank local revisions to fill
            // in the local history:
            long sequence = 0;
            long localParentSequence = 0;
            for(int i = revHistory.size() - 1; i >= 0; --i) {
                revId = revHistory.get(i);
                TDRevision localRev = localRevs.revWithDocIdAndRevId(docId, revId);
                if(localRev != null) {
                    // This revision is known locally. Remember its sequence as the parent of the next one:
                    sequence = localRev.getSequence();
                    assert(sequence > 0);
                    localParentSequence = sequence;
                }
                else {
                    // This revision isn't known, so add it:
                    TDRevision newRev;
                    byte[] data = null;
                    boolean current = false;
                    if(i == 0) {
                        // Hey, this is the leaf revision we're inserting:
                       newRev = rev;
                       if(!rev.isDeleted()) {
                           data = encodeDocumentJSON(rev);
                           if(data == null) {
                               return new TDStatus(TDStatus.BAD_REQUEST);
                           }
                       }
                       current = true;
                    }
                    else {
                        // It's an intermediate parent, so insert a stub:
                        newRev = new TDRevision(docId, revId, false);
                    }

                    // Insert it:
                    sequence = insertRevision(newRev, docNumericID, sequence, current, data);

                    if(sequence <= 0) {
                        return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
                    }

                    if(i == 0) {
                        // Write any changed attachments for the new revision:
                        TDStatus status = processAttachmentsForRevision(rev, localParentSequence);
                        if(!status.isSuccessful()) {
                            return status;
                        }
                    }
                }
            }

            // Mark the latest local rev as no longer current:
            if(localParentSequence > 0 && localParentSequence != sequence) {
                ContentValues args = new ContentValues();
                args.put("current", 0);
                String[] whereArgs = { Long.toString(localParentSequence) };
                try {
                    database.update("revs", args, "sequence=?", whereArgs);
                } catch (SQLException e) {
                    return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
                }
            }

            success = true;
        } catch(SQLException e) {
            endTransaction(success);
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        } finally {
            endTransaction(success);
        }

        // Notify and return:
        notifyChange(rev, source);
        return new TDStatus(TDStatus.CREATED);
    }

    /** VALIDATION **/

    /**
     * Define or clear a named document validation function.
     */
    public void defineValidation(String name, TDValidationBlock validationBlock) {
        if(validations == null) {
            validations = new HashMap<String, TDValidationBlock>();
        }
        validations.put(name, validationBlock);
    }

    public TDValidationBlock getValidationNamed(String name) {
        TDValidationBlock result = null;
        if(validations != null) {
            result = validations.get(name);
        }
        return result;
    }

    public TDStatus validateRevision(TDRevision newRev, TDRevision oldRev) {
        TDStatus result = new TDStatus(TDStatus.OK);
        if(validations == null || validations.size() == 0) {
            return result;
        }
        TDValidationContextImpl context = new TDValidationContextImpl(this, oldRev);
        for (String validationName : validations.keySet()) {
            TDValidationBlock validation = getValidationNamed(validationName);
            if(!validation.validate(newRev, context)) {
                result.setCode(context.getErrorType().getCode());
                break;
            }
        }
        return result;
    }

    /*************************************************************************************************/
    /*** TDDatabase+Replication                                                                    ***/
    /*************************************************************************************************/

    //TODO implement missing replication methods

    public List<TDReplicator> getActiveReplicators() {
        return activeReplicators;
    }

    public TDReplicator getActiveReplicator(URL remote, boolean push) {
        if(activeReplicators != null) {
            for (TDReplicator replicator : activeReplicators) {
                if(replicator.getRemote().equals(remote) && replicator.isPush() == push) {
                    return replicator;
                }
            }
        }
        return null;
    }

    public TDReplicator getReplicator(URL remote, boolean push, boolean continuous) {
        TDReplicator result = getActiveReplicator(remote, push);
        if(result != null) {
            return result;
        }
        result = push ? new TDPusher(this, remote, continuous) : new TDPuller(this, remote, continuous);

        if(activeReplicators == null) {
            activeReplicators = new ArrayList<TDReplicator>();
        }
        activeReplicators.add(result);
        return result;
    }

    public void replicatorDidStop(TDReplicator replicator) {
        replicator.databaseClosing();  // get it to detach from me
        if(activeReplicators != null) {
            activeReplicators.remove(replicator);
        }
    }

    public String lastSequenceWithRemoteURL(URL url, boolean push) {
        Cursor cursor = null;
        String result = null;
        try {
            String[] args = { url.toExternalForm(), Integer.toString(push ? 1 : 0) };
            cursor = database.rawQuery("SELECT last_sequence FROM replicators WHERE remote=? AND push=?", args);
            if(cursor.moveToFirst()) {
                result = cursor.getString(0);
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting last sequence", e);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
        return result;
    }

    public boolean setLastSequence(String lastSequence, URL url, boolean push) {
        ContentValues values = new ContentValues();
        values.put("remote", url.toExternalForm());
        values.put("push", push);
        values.put("last_sequence", lastSequence);
        long newId = database.insertWithOnConflict("replicators", null, values, SQLiteDatabase.CONFLICT_REPLACE);
        return (newId == -1);
    }

    public static String quote(String string) {
        return string.replace("'", "''");
    }

    public static String joinQuoted(List<String> strings) {
        if(strings.size() == 0) {
            return "";
        }

        String result = "'";
        boolean first = true;
        for (String string : strings) {
            if(first) {
                first = false;
            }
            else {
                result = result + "','";
            }
            result = result + quote(string);
        }
        result = result + "'";

        return result;
    }

    public boolean findMissingRevisions(TDRevisionList touchRevs) {
        if(touchRevs.size() == 0) {
            return true;
        }

        String quotedDocIds = joinQuoted(touchRevs.getAllDocIds());
        String quotedRevIds = joinQuoted(touchRevs.getAllRevIds());

        String sql = "SELECT docid, revid FROM revs, docs " +
                      "WHERE docid IN (" +
                      quotedDocIds +
                      ") AND revid in (" +
                      quotedRevIds + ")" +
                      " AND revs.doc_id == docs.doc_id";

        Cursor cursor = null;
        try {
            cursor = database.rawQuery(sql, null);
            cursor.moveToFirst();
            while(!cursor.isAfterLast()) {
                TDRevision rev = touchRevs.revWithDocIdAndRevId(cursor.getString(0), cursor.getString(1));

                if(rev != null) {
                    touchRevs.remove(rev);
                }

                cursor.moveToNext();
            }
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error finding missing revisions", e);
            return false;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
        return true;
    }

    /*************************************************************************************************/
    /*** TDDatabase+LocalDocs                                                                      ***/
    /*************************************************************************************************/

    public TDRevision getLocalDocument(String docID, String revID) {
        TDRevision result = null;
        Cursor cursor = null;
        try {
            String[] args = { docID };
            cursor = database.rawQuery("SELECT revid, json FROM localdocs WHERE docid=?", args);
            if(cursor.moveToFirst()) {
                String gotRevID = cursor.getString(0);
                if(revID != null && (!revID.equals(gotRevID))) {
                    return null;
                }
                byte[] json = cursor.getBlob(1);
                Map<String,Object> properties = null;
                try {
                    properties = mapper.readValue(json, Map.class);
                    properties.put("_id", docID);
                    properties.put("_rev", gotRevID);
                    result = new TDRevision(docID, gotRevID, false);
                    result.setProperties(properties);
                } catch (Exception e) {
                    Log.w(TAG, "Error parsing local doc JSON", e);
                    return null;
                }

            }
            return result;
        } catch (SQLException e) {
            Log.e(TDDatabase.TAG, "Error getting local document", e);
            return null;
        } finally {
            if(cursor != null) {
                cursor.close();
            }
        }
    }

    public TDRevision putLocalRevision(TDRevision revision, String prevRevID, TDStatus status) {
        String docID = revision.getDocId();
        if(!docID.startsWith("_local/")) {
            status.setCode(TDStatus.BAD_REQUEST);
            return null;
        }

        if(!revision.isDeleted()) {
            // PUT:
            byte[] json = encodeDocumentJSON(revision);
            String newRevID;
            if(prevRevID != null) {
                int generation = TDRevision.generationFromRevID(prevRevID);
                if(generation == 0) {
                    status.setCode(TDStatus.BAD_REQUEST);
                    return null;
                }
                newRevID = Integer.toString(++generation) + "-local";
                ContentValues values = new ContentValues();
                values.put("revid", newRevID);
                values.put("json", json);
                String[] whereArgs = { docID, prevRevID };
                try {
                    int rowsUpdated = database.update("localdocs", values, "docid=? AND revid=?", whereArgs);
                    if(rowsUpdated == 0) {
                        status.setCode(TDStatus.CONFLICT);
                        return null;
                    }
                } catch (SQLException e) {
                    status.setCode(TDStatus.INTERNAL_SERVER_ERROR);
                    return null;
                }
            } else {
                newRevID = "1-local";
                ContentValues values = new ContentValues();
                values.put("docid", docID);
                values.put("revid", newRevID);
                values.put("json", json);
                try {
                    database.insertWithOnConflict("localdocs", null, values, SQLiteDatabase.CONFLICT_IGNORE);
                } catch (SQLException e) {
                    status.setCode(TDStatus.INTERNAL_SERVER_ERROR);
                    return null;
                }
            }
            status.setCode(TDStatus.CREATED);
            return revision.copyWithDocID(docID, newRevID);
        }
        else {
            // DELETE:
            TDStatus deleteStatus = deleteLocalDocument(docID, prevRevID);
            status.setCode(deleteStatus.getCode());
            return (status.isSuccessful()) ? revision : null;
        }
    }

    public TDStatus deleteLocalDocument(String docID, String revID) {
        if(docID == null) {
            return new TDStatus(TDStatus.BAD_REQUEST);
        }
        if(revID == null) {
            // Didn't specify a revision to delete: 404 or a 409, depending
            return (getLocalDocument(docID, null) != null) ? new TDStatus(TDStatus.CONFLICT) : new TDStatus(TDStatus.NOT_FOUND);
        }
        String[] whereArgs = { docID, revID };
        try {
            int rowsDeleted = database.delete("localdocs", "docid=? AND revid=?", whereArgs);
            if(rowsDeleted == 0) {
                return (getLocalDocument(docID, null) != null) ? new TDStatus(TDStatus.CONFLICT) : new TDStatus(TDStatus.NOT_FOUND);
            }
            return new TDStatus(TDStatus.OK);
        } catch (SQLException e) {
            return new TDStatus(TDStatus.INTERNAL_SERVER_ERROR);
        }
    }
}

class TDValidationContextImpl implements TDValidationContext {

    private TDDatabase database;
    private TDRevision currentRevision;
    private TDStatus errorType;
    private String errorMessage;

    public TDValidationContextImpl(TDDatabase database, TDRevision currentRevision) {
        this.database = database;
        this.currentRevision = currentRevision;
        this.errorType = new TDStatus(TDStatus.FORBIDDEN);
        this.errorMessage = "invalid document";
    }

    @Override
    public TDRevision getCurrentRevision() {
        if(currentRevision != null) {
            database.loadRevisionBody(currentRevision, EnumSet.noneOf(TDContentOptions.class));
        }
        return currentRevision;
    }

    @Override
    public TDStatus getErrorType() {
        return errorType;
    }

    @Override
    public void setErrorType(TDStatus status) {
        this.errorType = status;
    }

    @Override
    public String getErrorMessage() {
        return errorMessage;
    }

    @Override
    public void setErrorMessage(String message) {
        this.errorMessage = message;
    }

}