src/com/android/calculator2/ExpressionDB.java - platform/packages/apps/ExactCalculator - Gitiles

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * 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.
  */

 // FIXME: We need to rethink the error handling here. Do we want to revert to history-less
 // operation if something goes wrong with the database?
 // TODO: This tries to ensure strong thread-safety, i.e. each call looks atomic, both to
 // other threads and other database users. Is this useful?
 // TODO: Especially if we notice serious performance issues on rotation in the history
 // view, we may need to use a CursorLoader or some other scheme to preserve the database
 // across rotations.

 package com.android.calculator2;

 import android.content.ContentValues;
 import android.content.Context;
 import android.database.Cursor;
 import android.database.sqlite.SQLiteDatabase;
 import android.database.sqlite.SQLiteException;
 import android.database.sqlite.SQLiteOpenHelper;
 import android.os.AsyncTask;
 import android.provider.BaseColumns;
 import android.util.Log;

 public class ExpressionDB {
     /* Table contents */
     public static class ExpressionEntry implements BaseColumns {
         public static final String TABLE_NAME = "expressions";
         public static final String COLUMN_NAME_EXPRESSION = "expression";
         public static final String COLUMN_NAME_FLAGS = "flags";
         // Time stamp as returned by currentTimeMillis().
         public static final String COLUMN_NAME_TIMESTAMP = "timeStamp";
     }

     /* Data to be written to or read from a row in the table */
     public static class RowData {
         private static final int DEGREE_MODE = 2;
         private static final int LONG_TIMEOUT = 1;
         public final byte[] mExpression;
         public final int mFlags;
         public long mTimeStamp;  // 0 ==> this and next field to be filled in when written.
         private static int flagsFromDegreeAndTimeout(Boolean DegreeMode, Boolean LongTimeout) {
             return (DegreeMode ? DEGREE_MODE : 0) | (LongTimeout ? LONG_TIMEOUT : 0);
         }
         private boolean degreeModeFromFlags(int flags) {
             return (flags & DEGREE_MODE) != 0;
         }
         private boolean longTimeoutFromFlags(int flags) {
             return (flags & LONG_TIMEOUT) != 0;
         }
         private static final int MILLIS_IN_15_MINS = 15 * 60 * 1000;
         private RowData(byte[] expr, int flags, long timeStamp) {
             mExpression = expr;
             mFlags = flags;
             mTimeStamp = timeStamp;
         }
         /**
          * More client-friendly constructor that hides implementation ugliness.
          * utcOffset here is uncompressed, in milliseconds.
          * A zero timestamp will cause it to be automatically filled in.
          */
         public RowData(byte[] expr, boolean degreeMode, boolean longTimeout, long timeStamp) {
             this(expr, flagsFromDegreeAndTimeout(degreeMode, longTimeout), timeStamp);
         }
         public boolean degreeMode() {
             return degreeModeFromFlags(mFlags);
         }
         public boolean longTimeout() {
             return longTimeoutFromFlags(mFlags);
         }
         /**
          * Return a ContentValues object representing the current data.
          */
         public ContentValues toContentValues() {
             ContentValues cvs = new ContentValues();
             cvs.put(ExpressionEntry.COLUMN_NAME_EXPRESSION, mExpression);
             cvs.put(ExpressionEntry.COLUMN_NAME_FLAGS, mFlags);
             if (mTimeStamp == 0) {
                 mTimeStamp = System.currentTimeMillis();
             }
             cvs.put(ExpressionEntry.COLUMN_NAME_TIMESTAMP, mTimeStamp);
             return cvs;
         }
     }

     private static final String SQL_CREATE_ENTRIES =
             "CREATE TABLE " + ExpressionEntry.TABLE_NAME + " (" +
             ExpressionEntry._ID + " INTEGER PRIMARY KEY," +
             ExpressionEntry.COLUMN_NAME_EXPRESSION + " BLOB," +
             ExpressionEntry.COLUMN_NAME_FLAGS + " INTEGER," +
             ExpressionEntry.COLUMN_NAME_TIMESTAMP + " INTEGER)";
     private static final String SQL_DROP_TABLE =
             "DROP TABLE IF EXISTS " + ExpressionEntry.TABLE_NAME;
     private static final String SQL_GET_MIN = "SELECT MIN(" + ExpressionEntry._ID +
             ") FROM " + ExpressionEntry.TABLE_NAME;
     private static final String SQL_GET_MAX = "SELECT MAX(" + ExpressionEntry._ID +
             ") FROM " + ExpressionEntry.TABLE_NAME;
     private static final String SQL_GET_ROW = "SELECT * FROM " + ExpressionEntry.TABLE_NAME +
             " WHERE " + ExpressionEntry._ID + " = ?";
     // We may eventually need an index by timestamp. We don't use it yet.
     private static final String SQL_CREATE_TIMESTAMP_INDEX =
             "CREATE INDEX timestamp_index ON " + ExpressionEntry.TABLE_NAME + "(" +
             ExpressionEntry.COLUMN_NAME_TIMESTAMP + ")";
     private static final String SQL_DROP_TIMESTAMP_INDEX = "DROP INDEX IF EXISTS timestamp_index";

     private class ExpressionDBHelper extends SQLiteOpenHelper {
         // If you change the database schema, you must increment the database version.
         public static final int DATABASE_VERSION = 1;
         public static final String DATABASE_NAME = "Expressions.db";

         public ExpressionDBHelper(Context context) {
             super(context, DATABASE_NAME, null, DATABASE_VERSION);
         }
         public void onCreate(SQLiteDatabase db) {
             db.execSQL(SQL_CREATE_ENTRIES);
             db.execSQL(SQL_CREATE_TIMESTAMP_INDEX);
         }
         public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
             // For now just throw away history on database version upgrade/downgrade.
             db.execSQL(SQL_DROP_TIMESTAMP_INDEX);
             db.execSQL(SQL_DROP_TABLE);
             onCreate(db);
         }
         public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
             onUpgrade(db, oldVersion, newVersion);
         }
     }

     private ExpressionDBHelper mExpressionDBHelper;

     private SQLiteDatabase mExpressionDB;  // Constant after initialization.

     private boolean mBadDB = false;      // Database initialization failed.

     // Never allocate new negative indicees (row ids) >= MAXIMUM_MIN_INDEX.
     public static final long MAXIMUM_MIN_INDEX = -10;

     // Minimum index value in DB.
     private long mMinIndex;
     // Maximum index value in DB.
     private long mMaxIndex;
     // mMinIndex and mMaxIndex are correct.
     private boolean mMinMaxValid;

     // mLock protects mExpressionDB and mBadDB, though we access mExpressionDB without
     // synchronization after it's known to be initialized.  Used to wait for database
     // initialization. Also protects mMinIndex, mMaxIndex, and mMinMaxValid.
     private Object mLock = new Object();

     public ExpressionDB(Context context) {
         mExpressionDBHelper = new ExpressionDBHelper(context);
         AsyncInitializer initializer = new AsyncInitializer();
         initializer.execute(mExpressionDBHelper);
     }

     private boolean getBadDB() {
         synchronized(mLock) {
             return mBadDB;
         }
     }

     private void setBadDB() {
         synchronized(mLock) {
             mBadDB = true;
         }
     }

     /**
      * Set mExpressionDB and compute minimum and maximum indices in the background.
      */
     private class AsyncInitializer extends AsyncTask<ExpressionDBHelper, Void, SQLiteDatabase> {
         @Override
         protected SQLiteDatabase doInBackground(ExpressionDBHelper... helper) {
             SQLiteDatabase result;
             try {
                 result = helper[0].getWritableDatabase();
                 // We notify here, since there are unlikely cases in which the UI thread
                 // may be blocked on us, preventing onPostExecute from running.
                 synchronized(mLock) {
                     mExpressionDB = result;
                     mLock.notifyAll();
                 }
                 long min, max;
                 try (Cursor minResult = result.rawQuery(SQL_GET_MIN, null)) {
                     if (!minResult.moveToFirst()) {
                         // Empty database.
                         min = MAXIMUM_MIN_INDEX;
                     } else {
                         min = Math.min(minResult.getLong(0), MAXIMUM_MIN_INDEX);
                     }
                 }
                 try (Cursor maxResult = result.rawQuery(SQL_GET_MAX, null)) {
                     if (!maxResult.moveToFirst()) {
                         // Empty database.
                         max = 0L;
                     } else {
                         max = Math.max(maxResult.getLong(0), 0L);
                     }
                 }
                 synchronized(mLock) {
                     mMinIndex = min;
                     mMaxIndex = max;
                     mMinMaxValid = true;
                     mLock.notifyAll();
                 }
             } catch(SQLiteException e) {
                 Log.e("Calculator", "Database initialization failed.\n", e);
                 synchronized(mLock) {
                     mBadDB = true;
                     mLock.notifyAll();
                 }
                 return null;
             }
             return result;
         }

         @Override
         protected void onPostExecute(SQLiteDatabase result) {
             if (result == null) {
                 throw new AssertionError("Failed to open history DB");
                 // TODO: Should we try to run without persistent history instead?
             } // else doInBackground already set expressionDB.
         }
         // On cancellation we do nothing;
     }

     /**
      * Wait until expression DB is ready.
      * This should usually be a no-op, since we set up the DB on creation. But there are a few
      * cases, such as restarting the calculator in history mode, when we currently can't do
      * anything but wait, possibly even in the UI thread.
      */
     private void waitForExpressionDB() {
         synchronized(mLock) {
             while (mExpressionDB == null && !mBadDB) {
                 try {
                     mLock.wait();
                 } catch(InterruptedException e) {
                     mBadDB = true;
                 }
             }
             if (mBadDB) {
                 throw new AssertionError("Failed to open history DB");
             }
         }
     }

     /**
      * Wait until the minimum key has been computed.
      */
     private void waitForMinMaxValid() {
         synchronized(mLock) {
             while (!mMinMaxValid && !mBadDB) {
                 try {
                     mLock.wait();
                 } catch(InterruptedException e) {
                     mBadDB = true;
                 }
             }
             if (mBadDB) {
                 throw new AssertionError("Failed to compute minimum key");
             }
         }
     }

     /**
      * Erase ALL database entries.
      * This is currently only safe if expressions that may refer to them are also erased.
      * Should only be called when concurrent references to the database are impossible.
      * TODO: Look at ways to more selectively clear the database.
      */
     public void eraseAll() {
         waitForExpressionDB();
         mExpressionDB.execSQL(SQL_DROP_TIMESTAMP_INDEX);
         mExpressionDB.execSQL(SQL_DROP_TABLE);
         try {
             mExpressionDB.execSQL("VACUUM");
         } catch(Exception e) {
             Log.v("Calculator", "Database VACUUM failed\n", e);
             // Should only happen with concurrent execution, which should be impossible.
         }
         mExpressionDB.execSQL(SQL_CREATE_ENTRIES);
         mExpressionDB.execSQL(SQL_CREATE_TIMESTAMP_INDEX);
         synchronized(mLock) {
             mMinIndex = MAXIMUM_MIN_INDEX;
             mMaxIndex = 0L;
         }
     }

     /**
      * Add a row with index outside existing range.
      * The returned index will be larger than any existing index unless negative_index is true.
      * In that case it will be smaller than any existing index and smaller than MAXIMUM_MIN_INDEX.
      */
     public long addRow(boolean negative_index, RowData data) {
         long result;
         long newIndex;
         waitForMinMaxValid();
         synchronized(mLock) {
             if (negative_index) {
                 newIndex = mMinIndex - 1;
                 mMinIndex = newIndex;
             } else {
                 newIndex = mMaxIndex + 1;
                 mMaxIndex = newIndex;
             }
             ContentValues cvs = data.toContentValues();
             cvs.put(ExpressionEntry._ID, newIndex);
             result = mExpressionDB.insert(ExpressionEntry.TABLE_NAME, null, cvs);
         }
         if (result != newIndex) {
             throw new AssertionError("Expected row id " + newIndex + ", got " + result);
         }
         return result;
     }

     /**
      * Retrieve the row with the given index.
      * Such a row must exist.
      */
     public RowData getRow(long index) {
         RowData result;
         waitForExpressionDB();
         String args[] = new String[] { Long.toString(index) };
         Cursor resultC = mExpressionDB.rawQuery(SQL_GET_ROW, args);
         if (!resultC.moveToFirst()) {
             throw new AssertionError("Missing Row");
         } else {
             result = new RowData(resultC.getBlob(1), resultC.getInt(2) /* flags */,
                     resultC.getLong(3) /* timestamp */);
         }
         return result;
     }

     public long getMinIndex() {
         waitForMinMaxValid();
         synchronized(mLock) {
             return mMinIndex;
         }
     }

     public long getMaxIndex() {
         waitForMinMaxValid();
         synchronized(mLock) {
             return mMaxIndex;
         }
     }

     public void close() {
         mExpressionDBHelper.close();
     }

 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* 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.
	*/

	// FIXME: We need to rethink the error handling here. Do we want to revert to history-less
	// operation if something goes wrong with the database?
	// TODO: This tries to ensure strong thread-safety, i.e. each call looks atomic, both to
	// other threads and other database users. Is this useful?
	// TODO: Especially if we notice serious performance issues on rotation in the history
	// view, we may need to use a CursorLoader or some other scheme to preserve the database
	// across rotations.

	package com.android.calculator2;

	import android.content.ContentValues;
	import android.content.Context;
	import android.database.Cursor;
	import android.database.sqlite.SQLiteDatabase;
	import android.database.sqlite.SQLiteException;
	import android.database.sqlite.SQLiteOpenHelper;
	import android.os.AsyncTask;
	import android.provider.BaseColumns;
	import android.util.Log;

	public class ExpressionDB {
	/* Table contents */
	public static class ExpressionEntry implements BaseColumns {
	public static final String TABLE_NAME = "expressions";
	public static final String COLUMN_NAME_EXPRESSION = "expression";
	public static final String COLUMN_NAME_FLAGS = "flags";
	// Time stamp as returned by currentTimeMillis().
	public static final String COLUMN_NAME_TIMESTAMP = "timeStamp";
	}

	/* Data to be written to or read from a row in the table */
	public static class RowData {
	private static final int DEGREE_MODE = 2;
	private static final int LONG_TIMEOUT = 1;
	public final byte[] mExpression;
	public final int mFlags;
	public long mTimeStamp; // 0 ==> this and next field to be filled in when written.
	private static int flagsFromDegreeAndTimeout(Boolean DegreeMode, Boolean LongTimeout) {
	return (DegreeMode ? DEGREE_MODE : 0) \| (LongTimeout ? LONG_TIMEOUT : 0);
	}
	private boolean degreeModeFromFlags(int flags) {
	return (flags & DEGREE_MODE) != 0;
	}
	private boolean longTimeoutFromFlags(int flags) {
	return (flags & LONG_TIMEOUT) != 0;
	}
	private static final int MILLIS_IN_15_MINS = 15 * 60 * 1000;
	private RowData(byte[] expr, int flags, long timeStamp) {
	mExpression = expr;
	mFlags = flags;
	mTimeStamp = timeStamp;
	}
	/**
	* More client-friendly constructor that hides implementation ugliness.
	* utcOffset here is uncompressed, in milliseconds.
	* A zero timestamp will cause it to be automatically filled in.
	*/
	public RowData(byte[] expr, boolean degreeMode, boolean longTimeout, long timeStamp) {
	this(expr, flagsFromDegreeAndTimeout(degreeMode, longTimeout), timeStamp);
	}
	public boolean degreeMode() {
	return degreeModeFromFlags(mFlags);
	}
	public boolean longTimeout() {
	return longTimeoutFromFlags(mFlags);
	}
	/**
	* Return a ContentValues object representing the current data.
	*/
	public ContentValues toContentValues() {
	ContentValues cvs = new ContentValues();
	cvs.put(ExpressionEntry.COLUMN_NAME_EXPRESSION, mExpression);
	cvs.put(ExpressionEntry.COLUMN_NAME_FLAGS, mFlags);
	if (mTimeStamp == 0) {
	mTimeStamp = System.currentTimeMillis();
	}
	cvs.put(ExpressionEntry.COLUMN_NAME_TIMESTAMP, mTimeStamp);
	return cvs;
	}
	}

	private static final String SQL_CREATE_ENTRIES =
	"CREATE TABLE " + ExpressionEntry.TABLE_NAME + " (" +
	ExpressionEntry._ID + " INTEGER PRIMARY KEY," +
	ExpressionEntry.COLUMN_NAME_EXPRESSION + " BLOB," +
	ExpressionEntry.COLUMN_NAME_FLAGS + " INTEGER," +
	ExpressionEntry.COLUMN_NAME_TIMESTAMP + " INTEGER)";
	private static final String SQL_DROP_TABLE =
	"DROP TABLE IF EXISTS " + ExpressionEntry.TABLE_NAME;
	private static final String SQL_GET_MIN = "SELECT MIN(" + ExpressionEntry._ID +
	") FROM " + ExpressionEntry.TABLE_NAME;
	private static final String SQL_GET_MAX = "SELECT MAX(" + ExpressionEntry._ID +
	") FROM " + ExpressionEntry.TABLE_NAME;
	private static final String SQL_GET_ROW = "SELECT * FROM " + ExpressionEntry.TABLE_NAME +
	" WHERE " + ExpressionEntry._ID + " = ?";
	// We may eventually need an index by timestamp. We don't use it yet.
	private static final String SQL_CREATE_TIMESTAMP_INDEX =
	"CREATE INDEX timestamp_index ON " + ExpressionEntry.TABLE_NAME + "(" +
	ExpressionEntry.COLUMN_NAME_TIMESTAMP + ")";
	private static final String SQL_DROP_TIMESTAMP_INDEX = "DROP INDEX IF EXISTS timestamp_index";

	private class ExpressionDBHelper extends SQLiteOpenHelper {
	// If you change the database schema, you must increment the database version.
	public static final int DATABASE_VERSION = 1;
	public static final String DATABASE_NAME = "Expressions.db";

	public ExpressionDBHelper(Context context) {
	super(context, DATABASE_NAME, null, DATABASE_VERSION);
	}
	public void onCreate(SQLiteDatabase db) {
	db.execSQL(SQL_CREATE_ENTRIES);
	db.execSQL(SQL_CREATE_TIMESTAMP_INDEX);
	}
	public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
	// For now just throw away history on database version upgrade/downgrade.
	db.execSQL(SQL_DROP_TIMESTAMP_INDEX);
	db.execSQL(SQL_DROP_TABLE);
	onCreate(db);
	}
	public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) {
	onUpgrade(db, oldVersion, newVersion);
	}
	}

	private ExpressionDBHelper mExpressionDBHelper;

	private SQLiteDatabase mExpressionDB; // Constant after initialization.

	private boolean mBadDB = false; // Database initialization failed.

	// Never allocate new negative indicees (row ids) >= MAXIMUM_MIN_INDEX.
	public static final long MAXIMUM_MIN_INDEX = -10;

	// Minimum index value in DB.
	private long mMinIndex;
	// Maximum index value in DB.
	private long mMaxIndex;
	// mMinIndex and mMaxIndex are correct.
	private boolean mMinMaxValid;

	// mLock protects mExpressionDB and mBadDB, though we access mExpressionDB without
	// synchronization after it's known to be initialized. Used to wait for database
	// initialization. Also protects mMinIndex, mMaxIndex, and mMinMaxValid.
	private Object mLock = new Object();

	public ExpressionDB(Context context) {
	mExpressionDBHelper = new ExpressionDBHelper(context);
	AsyncInitializer initializer = new AsyncInitializer();
	initializer.execute(mExpressionDBHelper);
	}

	private boolean getBadDB() {
	synchronized(mLock) {
	return mBadDB;
	}
	}

	private void setBadDB() {
	synchronized(mLock) {
	mBadDB = true;
	}
	}

	/**
	* Set mExpressionDB and compute minimum and maximum indices in the background.
	*/
	private class AsyncInitializer extends AsyncTask<ExpressionDBHelper, Void, SQLiteDatabase> {
	@Override
	protected SQLiteDatabase doInBackground(ExpressionDBHelper... helper) {
	SQLiteDatabase result;
	try {
	result = helper[0].getWritableDatabase();
	// We notify here, since there are unlikely cases in which the UI thread
	// may be blocked on us, preventing onPostExecute from running.
	synchronized(mLock) {
	mExpressionDB = result;
	mLock.notifyAll();
	}
	long min, max;
	try (Cursor minResult = result.rawQuery(SQL_GET_MIN, null)) {
	if (!minResult.moveToFirst()) {
	// Empty database.
	min = MAXIMUM_MIN_INDEX;
	} else {
	min = Math.min(minResult.getLong(0), MAXIMUM_MIN_INDEX);
	}
	}
	try (Cursor maxResult = result.rawQuery(SQL_GET_MAX, null)) {
	if (!maxResult.moveToFirst()) {
	// Empty database.
	max = 0L;
	} else {
	max = Math.max(maxResult.getLong(0), 0L);
	}
	}
	synchronized(mLock) {
	mMinIndex = min;
	mMaxIndex = max;
	mMinMaxValid = true;
	mLock.notifyAll();
	}
	} catch(SQLiteException e) {
	Log.e("Calculator", "Database initialization failed.\n", e);
	synchronized(mLock) {
	mBadDB = true;
	mLock.notifyAll();
	}
	return null;
	}
	return result;
	}

	@Override
	protected void onPostExecute(SQLiteDatabase result) {
	if (result == null) {
	throw new AssertionError("Failed to open history DB");
	// TODO: Should we try to run without persistent history instead?
	} // else doInBackground already set expressionDB.
	}
	// On cancellation we do nothing;
	}

	/**
	* Wait until expression DB is ready.
	* This should usually be a no-op, since we set up the DB on creation. But there are a few
	* cases, such as restarting the calculator in history mode, when we currently can't do
	* anything but wait, possibly even in the UI thread.
	*/
	private void waitForExpressionDB() {
	synchronized(mLock) {
	while (mExpressionDB == null && !mBadDB) {
	try {
	mLock.wait();
	} catch(InterruptedException e) {
	mBadDB = true;
	}
	}
	if (mBadDB) {
	throw new AssertionError("Failed to open history DB");
	}
	}
	}

	/**
	* Wait until the minimum key has been computed.
	*/
	private void waitForMinMaxValid() {
	synchronized(mLock) {
	while (!mMinMaxValid && !mBadDB) {
	try {
	mLock.wait();
	} catch(InterruptedException e) {
	mBadDB = true;
	}
	}
	if (mBadDB) {
	throw new AssertionError("Failed to compute minimum key");
	}
	}
	}

	/**
	* Erase ALL database entries.
	* This is currently only safe if expressions that may refer to them are also erased.
	* Should only be called when concurrent references to the database are impossible.
	* TODO: Look at ways to more selectively clear the database.
	*/
	public void eraseAll() {
	waitForExpressionDB();
	mExpressionDB.execSQL(SQL_DROP_TIMESTAMP_INDEX);
	mExpressionDB.execSQL(SQL_DROP_TABLE);
	try {
	mExpressionDB.execSQL("VACUUM");
	} catch(Exception e) {
	Log.v("Calculator", "Database VACUUM failed\n", e);
	// Should only happen with concurrent execution, which should be impossible.
	}
	mExpressionDB.execSQL(SQL_CREATE_ENTRIES);
	mExpressionDB.execSQL(SQL_CREATE_TIMESTAMP_INDEX);
	synchronized(mLock) {
	mMinIndex = MAXIMUM_MIN_INDEX;
	mMaxIndex = 0L;
	}
	}

	/**
	* Add a row with index outside existing range.
	* The returned index will be larger than any existing index unless negative_index is true.
	* In that case it will be smaller than any existing index and smaller than MAXIMUM_MIN_INDEX.
	*/
	public long addRow(boolean negative_index, RowData data) {
	long result;
	long newIndex;
	waitForMinMaxValid();
	synchronized(mLock) {
	if (negative_index) {
	newIndex = mMinIndex - 1;
	mMinIndex = newIndex;
	} else {
	newIndex = mMaxIndex + 1;
	mMaxIndex = newIndex;
	}
	ContentValues cvs = data.toContentValues();
	cvs.put(ExpressionEntry._ID, newIndex);
	result = mExpressionDB.insert(ExpressionEntry.TABLE_NAME, null, cvs);
	}
	if (result != newIndex) {
	throw new AssertionError("Expected row id " + newIndex + ", got " + result);
	}
	return result;
	}

	/**
	* Retrieve the row with the given index.
	* Such a row must exist.
	*/
	public RowData getRow(long index) {
	RowData result;
	waitForExpressionDB();
	String args[] = new String[] { Long.toString(index) };
	Cursor resultC = mExpressionDB.rawQuery(SQL_GET_ROW, args);
	if (!resultC.moveToFirst()) {
	throw new AssertionError("Missing Row");
	} else {
	result = new RowData(resultC.getBlob(1), resultC.getInt(2) /* flags */,
	resultC.getLong(3) /* timestamp */);
	}
	return result;
	}

	public long getMinIndex() {
	waitForMinMaxValid();
	synchronized(mLock) {
	return mMinIndex;
	}
	}

	public long getMaxIndex() {
	waitForMinMaxValid();
	synchronized(mLock) {
	return mMaxIndex;
	}
	}

	public void close() {
	mExpressionDBHelper.close();
	}

	}