Android example source code file (NewDatabasePerformanceTests.java)

This example Android source code file (NewDatabasePerformanceTests.java) is included in the DevDaily.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Android by Example" ^TM.

Java - Android tags/keywords

android, columns, content, contentvalues, create, database, insert, integer, into, io, override, performancebase, random, size, string, table, test, util, values, varchar

The NewDatabasePerformanceTests.java Android example source code

/*
 * Copyright (C) 2007 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.
 */

package android.database;

import android.content.ContentValues;
import android.database.sqlite.SQLiteDatabase;
import android.test.PerformanceTestCase;

import junit.framework.Assert;
import junit.framework.TestCase;

import java.io.File;
import java.util.Random;

/**
 * Database Performance Tests
 * 
 */

public class NewDatabasePerformanceTests {

  // Edit this to change the test run times.  The original is 100.
  final static int kMultiplier = 1;
  
  public static class PerformanceBase extends TestCase
          implements PerformanceTestCase {
    protected static final int CURRENT_DATABASE_VERSION = 42;
    protected SQLiteDatabase mDatabase;
    protected File mDatabaseFile;

    public void setUp() {
      mDatabaseFile = new File("/sdcard", "perf_database_test.db");
      if (mDatabaseFile.exists()) {
        mDatabaseFile.delete();
      }
      mDatabase =
        SQLiteDatabase.openOrCreateDatabase(mDatabaseFile.getPath(),
            null);
      assertTrue(mDatabase != null);
      mDatabase.setVersion(CURRENT_DATABASE_VERSION);
    }

    public void tearDown() {
      mDatabase.close();
      mDatabaseFile.delete();
    }

    public boolean isPerformanceOnly() {
      return true;
    }

    // These tests can only be run once.
    public int startPerformance(Intermediates intermediates) {
      return 0;
    }

    public String numberName(int number) {
      String result = "";

      if (number >= 1000) {
        result += numberName((number / 1000)) + " thousand";
        number = (number % 1000);

        if (number > 0) result += " ";
      }

      if (number >= 100) {
        result += ONES[(number / 100)] + " hundred";
        number = (number % 100);

        if (number > 0) result += " ";
      }

      if (number >= 20) {
        result += TENS[(number / 10)];
        number = (number % 10);

        if (number > 0) result += " ";
      }

      if (number > 0) {
        result += ONES[number];
      }

      return result;
    }
  }

  /**
   * Test 1000 inserts.
   */

  public static class Insert1000 extends PerformanceBase {
    private static final int SIZE = 10 * kMultiplier;

    private String[] statements = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        statements[i] =
          "INSERT INTO t1 VALUES(" + i + "," + r + ",'"
          + numberName(r) + "')";
      }

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.execSQL(statements[i]);
      }
    }
  }

  /**
   * Test 1000 inserts into an indexed table.
   */

  public static class InsertIndexed1000 extends PerformanceBase {
    private static final int SIZE = 10 * kMultiplier;

    private String[] statements = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        statements[i] =
          "INSERT INTO t1 VALUES(" + i + "," + r + ",'"
          + numberName(r) + "')";
      }

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i1c ON t1(c)");
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.execSQL(statements[i]);
      }
    }
  }

  /**
   * 100 SELECTs without an index
   */

  public static class Select100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"count(*)", "avg(b)"};

    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] = "b >= " + lower + " AND b < " + upper;
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase
        .query("t1", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   * 100 SELECTs on a string comparison
   */

  public static class SelectStringComparison100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"count(*)", "avg(b)"};

    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        where[i] = "c LIKE '" + numberName(i) + "'";
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase
        .query("t1", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   * 100 SELECTs with an index
   */

  public static class SelectIndex100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"count(*)", "avg(b)"};

    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i1b ON t1(b)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] = "b >= " + lower + " AND b < " + upper;
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase
        .query("t1", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   *  INNER JOIN without an index
   */

  public static class InnerJoin100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"t1.a"};

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase
      .execSQL("CREATE TABLE t2(a INTEGER, b INTEGER, c VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t2 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }
    }

    public void testRun() {
      mDatabase.query("t1 INNER JOIN t2 ON t1.b = t2.b", COLUMNS, null,
          null, null, null, null);
    }
  }

  /**
   *  INNER JOIN without an index on one side
   */

  public static class InnerJoinOneSide100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"t1.a"};

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase
      .execSQL("CREATE TABLE t2(a INTEGER, b INTEGER, c VARCHAR(100))");

      mDatabase.execSQL("CREATE INDEX i1b ON t1(b)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t2 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }
    }

    public void testRun() {
      mDatabase.query("t1 INNER JOIN t2 ON t1.b = t2.b", COLUMNS, null,
          null, null, null, null);
    }
  }

  /**
   *  INNER JOIN without an index on one side
   */

  public static class InnerJoinNoIndex100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"t1.a"};

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase
      .execSQL("CREATE TABLE t2(a INTEGER, b INTEGER, c VARCHAR(100))");

      mDatabase.execSQL("CREATE INDEX i1b ON t1(b)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t2 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }
    }

    public void testRun() {
      mDatabase.query("t1 INNER JOIN t2 ON t1.c = t2.c", COLUMNS, null,
          null, null, null, null);
    }
  }

  /**
   *  100 SELECTs with subqueries. Subquery is using an index
   */

  public static class SelectSubQIndex100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"t1.a"};

    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase
      .execSQL("CREATE TABLE t2(a INTEGER, b INTEGER, c VARCHAR(100))");

      mDatabase.execSQL("CREATE INDEX i2b ON t2(b)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t2 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] =
          "t1.b IN (SELECT t2.b FROM t2 WHERE t2.b >= " + lower
          + " AND t2.b < " + upper + ")";
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase
        .query("t1", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   *  100 SELECTs on string comparison with Index
   */

  public static class SelectIndexStringComparison100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"count(*)", "avg(b)"};

    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i3c ON t1(c)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        where[i] = "c LIKE '" + numberName(i) + "'";
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase
        .query("t1", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   *  100 SELECTs on integer 
   */

  public static class SelectInteger100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"b"};

    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t1", COLUMNS, null, null, null, null, null);
      }
    }
  }

  /**
   *  100 SELECTs on String
   */

  public static class SelectString100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"c"};

    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t1", COLUMNS, null, null, null, null, null);
      }
    }
  }

  /**
   *  100 SELECTs on integer with index
   */

  public static class SelectIntegerIndex100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"b"};

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i1b on t1(b)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t1", COLUMNS, null, null, null, null, null);
      }
    }
  }

  /**
   *  100 SELECTs on String with index
   */

  public static class SelectIndexString100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"c"};      

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i1c ON t1(c)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t1", COLUMNS, null, null, null, null, null);
      }
    }
  }

  /**
   *  100 SELECTs on String with starts with
   */

  public static class SelectStringStartsWith100 extends PerformanceBase {
    private static final int SIZE = 1 * kMultiplier;
    private static final String[] COLUMNS = {"c"};
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i1c ON t1(c)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        where[i] = "c LIKE '" + numberName(r).substring(0, 1) + "*'";

      }

    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase
        .query("t1", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   *  1000 Deletes on an indexed table
   */

  public static class DeleteIndexed1000 extends PerformanceBase {
    private static final int SIZE = 10 * kMultiplier;
    private static final String[] COLUMNS = {"c"};

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i3c ON t1(c)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.delete("t1", null, null);
      }
    }
  }

  /**
   *  1000 Deletes
   */

  public static class Delete1000 extends PerformanceBase {
    private static final int SIZE = 10 * kMultiplier;
    private static final String[] COLUMNS = {"c"};       

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.delete("t1", null, null);
      }
    }
  }

  /**
   *  1000 DELETE's without an index with where clause 
   */

  public static class DeleteWhere1000 extends PerformanceBase {
    private static final int SIZE = 10 * kMultiplier;
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] = "b >= " + lower + " AND b < " + upper;
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.delete("t1", where[i], null);
      }
    }
  }

  /**
   *  1000 DELETE's with an index with where clause 
   */

  public static class DeleteIndexWhere1000 extends PerformanceBase {
    private static final int SIZE = 10 * kMultiplier;
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i1b ON t1(b)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] = "b >= " + lower + " AND b < " + upper;
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.delete("t1", where[i], null);
      }
    }
  }

  /**
   *  1000 update's with an index with where clause 
   */

  public static class UpdateIndexWhere1000 extends PerformanceBase {
    private static final int SIZE = 10 * kMultiplier;
    private String[] where = new String[SIZE];
    ContentValues[] mValues = new ContentValues[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i1b ON t1(b)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {

        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] = "b >= " + lower + " AND b < " + upper;
        ContentValues b = new ContentValues(1);
        b.put("b", upper);
        mValues[i] = b;

      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.update("t1", mValues[i], where[i], null);
      }
    }
  }

  /**
   *  1000 update's without an index with where clause 
   */

  public static class UpdateWhere1000 extends PerformanceBase {
    private static final int SIZE = 10 * kMultiplier;       
    private String[] where = new String[SIZE];
    ContentValues[] mValues = new ContentValues[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER, b INTEGER, c VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t1 VALUES(" + i + "," + r + ",'"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {

        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] = "b >= " + lower + " AND b < " + upper;
        ContentValues b = new ContentValues(1);
        b.put("b", upper);
        mValues[i] = b;
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.update("t1", mValues[i], where[i], null);
      }
    }
  }

  /**
   *  10000 inserts for an integer 
   */

  public static class InsertInteger10000 extends PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    ContentValues[] mValues = new ContentValues[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        ContentValues b = new ContentValues(1);
        b.put("a", r);
        mValues[i] = b;
      }
    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.insert("t1", null, mValues[i]);
      }
    }
  }

  /**
   *  10000 inserts for an integer -indexed table
   */

  public static class InsertIntegerIndex10000 extends PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    ContentValues[] mValues = new ContentValues[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a INTEGER)");
      mDatabase.execSQL("CREATE INDEX i1a ON t1(a)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        ContentValues b = new ContentValues(1);
        b.put("a", r);
        mValues[i] = b;
      }
    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.insert("t1", null, mValues[i]);
      }
    }
  }

  /**
   *  10000 inserts for a String 
   */

  public static class InsertString10000 extends PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    ContentValues[] mValues = new ContentValues[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        ContentValues b = new ContentValues(1);
        b.put("a", numberName(r));
        mValues[i] = b;
      }
    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.insert("t1", null, mValues[i]);
      }
    }
  }

  /**
   *  10000 inserts for a String - indexed table 
   */

  public static class InsertStringIndexed10000 extends PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;       
    ContentValues[] mValues = new ContentValues[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t1(a VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i1a ON t1(a)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        ContentValues b = new ContentValues(1);
        b.put("a", numberName(r));
        mValues[i] = b; 
      }
    }

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.insert("t1", null, mValues[i]);
      }
    }
  }


  /**
   *  10000 selects for a String -starts with
   */

  public static class SelectStringStartsWith10000 extends PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    private static final String[] COLUMNS = {"t3.a"};
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t3(a VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t3 VALUES('"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        where[i] = "a LIKE '" + numberName(r).substring(0, 1) + "*'";

      }
    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t3", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   *  10000 selects for a String - indexed table -starts with
   */

  public static class SelectStringIndexedStartsWith10000 extends
  PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    private static final String[] COLUMNS = {"t3.a"};
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t3(a VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i3a ON t3(a)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t3 VALUES('"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        where[i] = "a LIKE '" + numberName(r).substring(0, 1) + "*'";

      }                              
    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t3", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   *  10000 selects for an integer -
   */

  public static class SelectInteger10000 extends PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    private static final String[] COLUMNS = {"t4.a"};
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t4(a INTEGER)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t4 VALUES(" + r + ")");
        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] = "a >= " + lower + " AND a < " + upper;
      }
    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t4", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   *  10000 selects for an integer -indexed table
   */

  public static class SelectIntegerIndexed10000 extends PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    private static final String[] COLUMNS = {"t4.a"};
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t4(a INTEGER)");
      mDatabase.execSQL("CREATE INDEX i4a ON t4(a)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t4 VALUES(" + r + ")");

        int lower = i * 100;
        int upper = (i + 10) * 100;
        where[i] = "a >= " + lower + " AND a < " + upper;
      }

    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t4", COLUMNS, where[i], null, null, null, null);
      }
    }
  }


  /**
   *  10000 selects for a String - contains 'e'
   */

  public static class SelectStringContains10000 extends PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    private static final String[] COLUMNS = {"t3.a"};
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t3(a VARCHAR(100))");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t3 VALUES('"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        where[i] = "a LIKE '*e*'";

      }                              
    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t3", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  /**
   *  10000 selects for a String - contains 'e'-indexed table
   */

  public static class SelectStringIndexedContains10000 extends
  PerformanceBase {
    private static final int SIZE = 100 * kMultiplier;
    private static final String[] COLUMNS = {"t3.a"};
    private String[] where = new String[SIZE];

    @Override
    public void setUp() {
      super.setUp();
      Random random = new Random(42);

      mDatabase
      .execSQL("CREATE TABLE t3(a VARCHAR(100))");
      mDatabase.execSQL("CREATE INDEX i3a ON t3(a)");

      for (int i = 0; i < SIZE; i++) {
        int r = random.nextInt(100000);
        mDatabase.execSQL("INSERT INTO t3 VALUES('"
            + numberName(r) + "')");
      }

      for (int i = 0; i < SIZE; i++) {
        where[i] = "a LIKE '*e*'";

      }                              
    }        

    public void testRun() {
      for (int i = 0; i < SIZE; i++) {
        mDatabase.query("t3", COLUMNS, where[i], null, null, null, null);
      }
    }
  }

  public static final String[] ONES =
  {"zero", "one", "two", "three", "four", "five", "six", "seven",
    "eight", "nine", "ten", "eleven", "twelve", "thirteen",
    "fourteen", "fifteen", "sixteen", "seventeen", "eighteen",
  "nineteen"};

  public static final String[] TENS =
  {"", "ten", "twenty", "thirty", "forty", "fifty", "sixty",
    "seventy", "eighty", "ninety"};
}