protected void saveBookAuthorInfo(long bookId, long index, Author author) {
    if (myGetAuthorIdStatement == null) {
      myGetAuthorIdStatement =
          myDatabase.compileStatement(
              "SELECT author_id FROM Authors WHERE name = ? AND sort_key = ?");
      myInsertAuthorStatement =
          myDatabase.compileStatement("INSERT OR IGNORE INTO Authors (name,sort_key) VALUES (?,?)");
      myInsertBookAuthorStatement =
          myDatabase.compileStatement(
              "INSERT OR REPLACE INTO BookAuthor (book_id,author_id,author_index) VALUES (?,?,?)");
    }

    long authorId;
    try {
      myGetAuthorIdStatement.bindString(1, author.DisplayName);
      myGetAuthorIdStatement.bindString(2, author.SortKey);
      authorId = myGetAuthorIdStatement.simpleQueryForLong();
    } catch (SQLException e) {
      myInsertAuthorStatement.bindString(1, author.DisplayName);
      myInsertAuthorStatement.bindString(2, author.SortKey);
      authorId = myInsertAuthorStatement.executeInsert();
    }
    myInsertBookAuthorStatement.bindLong(1, bookId);
    myInsertBookAuthorStatement.bindLong(2, authorId);
    myInsertBookAuthorStatement.bindLong(3, index);
    myInsertBookAuthorStatement.execute();
  }
    @Override
    public void onCreate(SQLiteDatabase db) {
      db.beginTransaction();
      try {
        SQLiteStatement stmt;
        db.execSQL("create table capitals (prefecture text primary key, capital text not null);");
        stmt = db.compileStatement("insert into capitals values (?, ?);");

        for (String[] capital : CAPITALS) {
          stmt.bindString(1, capital[0]);
          stmt.bindString(2, capital[1]);
          stmt.executeInsert();
        }

        db.execSQL(
            "create table local_dishes (prefecture text not null, local_dish text not null);");
        stmt = db.compileStatement("insert into local_dishes values (?, ?);");

        for (String[] localDish : LOCAL_DISHES) {
          stmt.bindString(1, localDish[0]);
          stmt.bindString(2, localDish[1]);
          stmt.executeInsert();
        }
        db.setTransactionSuccessful();
      } finally {
        db.endTransaction();
      }
    }
  protected void saveBookSeriesInfo(long bookId, SeriesInfo seriesInfo) {
    if (myGetSeriesIdStatement == null) {
      myGetSeriesIdStatement =
          myDatabase.compileStatement("SELECT series_id FROM Series WHERE name = ?");
      myInsertSeriesStatement =
          myDatabase.compileStatement("INSERT OR IGNORE INTO Series (name) VALUES (?)");
      myInsertBookSeriesStatement =
          myDatabase.compileStatement(
              "INSERT OR REPLACE INTO BookSeries (book_id,series_id,book_index) VALUES (?,?,?)");
      myDeleteBookSeriesStatement =
          myDatabase.compileStatement("DELETE FROM BookSeries WHERE book_id = ?");
    }

    if (seriesInfo == null) {
      myDeleteBookSeriesStatement.bindLong(1, bookId);
      myDeleteBookSeriesStatement.execute();
    } else {
      long seriesId;
      try {
        myGetSeriesIdStatement.bindString(1, seriesInfo.Name);
        seriesId = myGetSeriesIdStatement.simpleQueryForLong();
      } catch (SQLException e) {
        myInsertSeriesStatement.bindString(1, seriesInfo.Name);
        seriesId = myInsertSeriesStatement.executeInsert();
      }
      myInsertBookSeriesStatement.bindLong(1, bookId);
      myInsertBookSeriesStatement.bindLong(2, seriesId);
      SQLiteUtil.bindString(
          myInsertBookSeriesStatement,
          3,
          seriesInfo.Index != null ? seriesInfo.Index.toString() : null);
      myInsertBookSeriesStatement.execute();
    }
  }
Beispiel #4
0
  @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
  public TileCache(Context context, String cacheDirectory, String dbName) {
    if (dbg) log.debug("open cache {}, {}", cacheDirectory, dbName);

    dbHelper = new SQLiteHelper(context, dbName);

    if (Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.JELLY_BEAN)
      dbHelper.setWriteAheadLoggingEnabled(true);

    mDatabase = dbHelper.getWritableDatabase();

    mStmtGetTile =
        mDatabase.compileStatement(
            "" + "SELECT " + COLUMN_DATA + " FROM " + TABLE_NAME + " WHERE x=? AND y=? AND z = ?");

    mStmtPutTile =
        mDatabase.compileStatement(
            ""
                + "INSERT INTO "
                + TABLE_NAME
                + " (x, y, z, time, last_access, data)"
                + " VALUES(?,?,?,?,?,?)");

    // mStmtUpdateTile = mDatabase.compileStatement("" +
    //        "UPDATE " + TABLE_NAME +
    //        "  SET last_access=?" +
    //        "  WHERE x=? AND y=? AND z=?");

    mCacheBuffers = new ArrayList<ByteArrayOutputStream>();
  }
 public boolean deleteAll() {
   boolean flag = false;
   String deleteHeadSql = "DELETE FROM ProductGroupHead";
   String deleteDetailSql = "DELETE FROM ProductGroupDetail";
   SQLiteDatabase db = AssetsDatabaseManager.getManager().getDatabase();
   try {
     // 开启事务
     db.beginTransaction();
     SQLiteStatement detail_stat = db.compileStatement(deleteDetailSql);
     detail_stat.executeUpdateDelete();
     SQLiteStatement head_stat = db.compileStatement(deleteHeadSql);
     head_stat.executeUpdateDelete();
     // 数据插入成功,设置事物成功标志
     db.setTransactionSuccessful();
     // 保存数据
     db.endTransaction();
     flag = true;
   } catch (SQLException e) {
     // 结束事物,在这里没有设置成功标志,结束后不保存
     ZillionLog.e(this.getClass().getName(), e.getMessage(), e);
     db.endTransaction();
     e.printStackTrace();
   }
   return flag;
 }
  private void importContactMethods() {
    SQLiteStatement emailInsert = mTargetDb.compileStatement(EmailInsert.INSERT_SQL);
    SQLiteStatement imInsert = mTargetDb.compileStatement(ImInsert.INSERT_SQL);
    SQLiteStatement postalInsert = mTargetDb.compileStatement(PostalInsert.INSERT_SQL);
    Cursor c =
        mSourceDb.query(
            ContactMethodsQuery.TABLE, ContactMethodsQuery.COLUMNS, null, null, null, null, null);
    try {
      while (c.moveToNext()) {
        int kind = c.getInt(ContactMethodsQuery.KIND);
        switch (kind) {
          case android.provider.Contacts.KIND_EMAIL:
            insertEmail(c, emailInsert);
            break;

          case android.provider.Contacts.KIND_IM:
            insertIm(c, imInsert);
            break;

          case android.provider.Contacts.KIND_POSTAL:
            insertPostal(c, postalInsert);
            break;
        }
      }
    } finally {
      c.close();
    }
  }
 private long getTagId(Tag tag) {
   if (myGetTagIdStatement == null) {
     myGetTagIdStatement =
         myDatabase.compileStatement("SELECT tag_id FROM Tags WHERE parent_id = ? AND name = ?");
     myCreateTagIdStatement =
         myDatabase.compileStatement("INSERT OR IGNORE INTO Tags (parent_id,name) VALUES (?,?)");
   }
   {
     final Long id = myIdByTag.get(tag);
     if (id != null) {
       return id;
     }
   }
   if (tag.Parent != null) {
     myGetTagIdStatement.bindLong(1, getTagId(tag.Parent));
   } else {
     myGetTagIdStatement.bindNull(1);
   }
   myGetTagIdStatement.bindString(2, tag.Name);
   long id;
   try {
     id = myGetTagIdStatement.simpleQueryForLong();
   } catch (SQLException e) {
     if (tag.Parent != null) {
       myCreateTagIdStatement.bindLong(1, getTagId(tag.Parent));
     } else {
       myCreateTagIdStatement.bindNull(1);
     }
     myCreateTagIdStatement.bindString(2, tag.Name);
     id = myCreateTagIdStatement.executeInsert();
   }
   myIdByTag.put(tag, id);
   myTagById.put(id, tag);
   return id;
 }
 private int update(String statement, Object[] args, FieldType[] argFieldTypes, String label)
     throws SQLException {
   SQLiteStatement stmt = null;
   try {
     stmt = db.compileStatement(statement);
     bindArgs(stmt, args, argFieldTypes);
     stmt.execute();
   } catch (android.database.SQLException e) {
     throw SqlExceptionUtil.create("updating database failed: " + statement, e);
   } finally {
     closeQuietly(stmt);
     stmt = null;
   }
   int result;
   try {
     stmt = db.compileStatement("SELECT CHANGES()");
     result = (int) stmt.simpleQueryForLong();
   } catch (android.database.SQLException e) {
     // ignore the exception and just return 1
     result = 1;
   } finally {
     closeQuietly(stmt);
   }
   logger.trace("{} statement is compiled and executed, changed {}: {}", label, result, statement);
   return result;
 }
 // opens the database
 public POIDataHelper open() {
   db = helper.getWritableDatabase();
   this.insertMapStmt = db.compileStatement(INSERT_MAP);
   this.insertGroupStmt = db.compileStatement(INSERT_GROUP);
   this.insertPOIStmt = db.compileStatement(INSERT_POI);
   this.updatePOIStmt = db.compileStatement(UPDATE_POI);
   this.updatePOISelectedStmt = db.compileStatement(UPDATE_POI_SELECTED);
   return this;
 }
  /**
   * 批量增加产品组合主表记录数据
   *
   * @param list
   */
  public boolean batchAddProductGroupHead(List<ProductGroupHeadData> list) {
    boolean flag = false;
    String headSql =
        "insert into ProductGroupHead(PG1_ID,PG1_M02_ID,PG1_CU1_ID,PG1_CODE,PG1_Name,PG1_CreateUser,PG1_CreateTime,PG1_ModifyUser,PG1_ModifyTime,PG1_RowVersion)"
            + "values(?,?,?,?,?,?,?,?,?,?)";
    String detailSql =
        "insert into ProductGroupDetail(PG2_ID,PG2_M02_ID,PG2_PG1_ID,PG2_PD1_ID,PG2_GroupQty,PG2_CreateUser,PG2_CreateTime,PG2_ModifyUser,PG2_ModifyTime,PG2_RowVersion)"
            + "values(?,?,?,?,?,?,?,?,?,?)";
    SQLiteDatabase db = AssetsDatabaseManager.getManager().getDatabase();
    try {
      // 开启事务
      db.beginTransaction();
      for (ProductGroupHeadData productGroupHead : list) {
        SQLiteStatement stat = db.compileStatement(headSql);
        stat.bindString(1, productGroupHead.getPg1Id());
        stat.bindString(2, productGroupHead.getPg1M02Id());
        stat.bindString(3, productGroupHead.getPg1Cu1Id());
        stat.bindString(4, productGroupHead.getPg1Code());
        stat.bindString(5, productGroupHead.getPg1Name());
        stat.bindString(6, productGroupHead.getPg1CreateUser());
        stat.bindString(7, productGroupHead.getPg1CreateTime());
        stat.bindString(8, productGroupHead.getPg1ModifyUser());
        stat.bindString(9, productGroupHead.getPg1ModifyTime());
        stat.bindString(10, productGroupHead.getPg1RowVersion());
        stat.executeInsert();

        List<ProductGroupDetailData> children = productGroupHead.getChildren();
        if (children != null) {
          for (ProductGroupDetailData productGroupDetail : children) {
            SQLiteStatement detail_stat = db.compileStatement(detailSql);
            detail_stat.bindString(1, productGroupDetail.getPg2Id());
            detail_stat.bindString(2, productGroupDetail.getPg2M02Id());
            detail_stat.bindString(3, productGroupDetail.getPg2Pg1Id());
            detail_stat.bindString(4, productGroupDetail.getPg2Pd1Id());
            detail_stat.bindLong(5, productGroupDetail.getPg2GroupQty());
            detail_stat.bindString(6, productGroupDetail.getPg2CreateUser());
            detail_stat.bindString(7, productGroupDetail.getPg2CreateTime());
            detail_stat.bindString(8, productGroupDetail.getPg2ModifyUser());
            detail_stat.bindString(9, productGroupDetail.getPg2ModifyTime());
            detail_stat.bindString(10, productGroupDetail.getPg2RowVersion());
            detail_stat.executeInsert();
          }
        }
      }
      // 数据插入成功,设置事物成功标志
      db.setTransactionSuccessful();
      // 保存数据
      db.endTransaction();
      flag = true;
    } catch (SQLException e) {
      // 结束事物,在这里没有设置成功标志,结束后不保存
      ZillionLog.e(this.getClass().getName(), e.getMessage(), e);
      db.endTransaction();
      e.printStackTrace();
    }
    return flag;
  }
 private void importPhotos() {
   SQLiteStatement insert = mTargetDb.compileStatement(PhotoInsert.INSERT_SQL);
   SQLiteStatement photoIdUpdate = mTargetDb.compileStatement(PhotoIdUpdate.UPDATE_SQL);
   Cursor c =
       mSourceDb.query(PhotosQuery.TABLE, PhotosQuery.COLUMNS, null, null, null, null, null);
   try {
     while (c.moveToNext()) {
       insertPhoto(c, insert, photoIdUpdate);
     }
   } finally {
     c.close();
   }
 }
 private void importPhones() {
   SQLiteStatement phoneInsert = mTargetDb.compileStatement(PhoneInsert.INSERT_SQL);
   SQLiteStatement phoneLookupInsert = mTargetDb.compileStatement(PhoneLookupInsert.INSERT_SQL);
   SQLiteStatement hasPhoneUpdate = mTargetDb.compileStatement(HasPhoneNumberUpdate.UPDATE_SQL);
   Cursor c =
       mSourceDb.query(PhonesQuery.TABLE, PhonesQuery.COLUMNS, null, null, null, null, null);
   try {
     while (c.moveToNext()) {
       insertPhone(c, phoneInsert, phoneLookupInsert, hasPhoneUpdate);
     }
   } finally {
     c.close();
   }
 }
  @Override
  public void changeStoredSamplesType(
      int timestampFrom, int timestampTo, byte kind, SampleProvider provider) {
    try (SQLiteDatabase db = this.getReadableDatabase()) {
      String sql =
          "UPDATE "
              + TABLE_GBACTIVITYSAMPLES
              + " SET "
              + KEY_TYPE
              + "= ? WHERE "
              + KEY_PROVIDER
              + " = ? AND "
              + KEY_TIMESTAMP
              + " >= ? AND "
              + KEY_TIMESTAMP
              + " < ? ;"; // do not use BETWEEN because the range is inclusive in that case!

      SQLiteStatement statement = db.compileStatement(sql);
      statement.bindLong(1, kind);
      statement.bindLong(2, provider.getID());
      statement.bindLong(3, timestampFrom);
      statement.bindLong(4, timestampTo);
      statement.execute();
    }
  }
  @Override
  public void addGBActivitySamples(ActivitySample[] activitySamples) {
    try (SQLiteDatabase db = this.getWritableDatabase()) {

      String sql =
          "INSERT INTO "
              + TABLE_GBACTIVITYSAMPLES
              + " ("
              + KEY_TIMESTAMP
              + ","
              + KEY_PROVIDER
              + ","
              + KEY_INTENSITY
              + ","
              + KEY_STEPS
              + ","
              + KEY_TYPE
              + ")"
              + " VALUES (?,?,?,?,?);";
      SQLiteStatement statement = db.compileStatement(sql);
      db.beginTransaction();

      for (ActivitySample activitySample : activitySamples) {
        statement.clearBindings();
        statement.bindLong(1, activitySample.getTimestamp());
        statement.bindLong(2, activitySample.getProvider().getID());
        statement.bindLong(3, activitySample.getRawIntensity());
        statement.bindLong(4, activitySample.getSteps());
        statement.bindLong(5, activitySample.getRawKind());
        statement.execute();
      }
      db.setTransactionSuccessful();
      db.endTransaction();
    }
  }
  @MediumTest
  public void testSimpleQuery() throws Exception {
    mDatabase.execSQL("CREATE TABLE test (num INTEGER NOT NULL, str TEXT NOT NULL);");
    mDatabase.execSQL("INSERT INTO test VALUES (1234, 'hello');");
    SQLiteStatement statement1 = mDatabase.compileStatement("SELECT num FROM test WHERE str = ?");
    SQLiteStatement statement2 = mDatabase.compileStatement("SELECT str FROM test WHERE num = ?");

    try {
      statement1.bindString(1, "hello");
      long value = statement1.simpleQueryForLong();
      assertEquals(1234, value);

      statement1.bindString(1, "world");
      statement1.simpleQueryForLong();
      fail("shouldn't get here");
    } catch (SQLiteDoneException e) {
      // expected
    }

    try {
      statement2.bindLong(1, 1234);
      String value = statement1.simpleQueryForString();
      assertEquals("hello", value);

      statement2.bindLong(1, 5678);
      statement1.simpleQueryForString();
      fail("shouldn't get here");
    } catch (SQLiteDoneException e) {
      // expected
    }

    statement1.close();
    statement2.close();
  }
  private void createVarnaStations(SQLiteDatabase db, String tableName, InputStream openRawResource)
      throws JsonParseException, JsonMappingException, IOException {
    final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    final BusStopVarnaTraffic[] all =
        OBJECT_MAPPER.readValue(openRawResource, BusStopVarnaTraffic[].class);
    final String FORMAT_SQL_INSERT =
        "INSERT INTO %s (%s, %s, %s, %s, %s) VALUES (?, ?, ?, ?, '%s')";

    final SQLiteStatement insertStatement =
        db.compileStatement(
            String.format(
                FORMAT_SQL_INSERT,
                tableName,
                Station.CODE,
                Station.LAT,
                Station.LON,
                Station.LABEL,
                Station.PROVIDER,
                FavoritiesService.PROVIDER_VARNATRAFFIC));

    for (BusStopVarnaTraffic busStopVarnaTraffic : all) {
      insertStatement.bindLong(1, busStopVarnaTraffic.getId());
      insertStatement.bindDouble(2, busStopVarnaTraffic.getPosition().getLat());
      insertStatement.bindDouble(3, busStopVarnaTraffic.getPosition().getLon());
      insertStatement.bindString(4, busStopVarnaTraffic.getText());
      insertStatement.executeInsert();
    }
  }
 public int insert(
     String statement, Object[] args, FieldType[] argFieldTypes, GeneratedKeyHolder keyHolder)
     throws SQLException {
   SQLiteStatement stmt = null;
   try {
     stmt = db.compileStatement(statement);
     bindArgs(stmt, args, argFieldTypes);
     long rowId = stmt.executeInsert();
     if (keyHolder != null) {
       keyHolder.addKey(rowId);
     }
     /*
      * I've decided to not do the CHANGES() statement here like we do down below in UPDATE because we know that
      * it worked (since it didn't throw) so we know that 1 is right.
      */
     int result = 1;
     logger.trace(
         "{}: insert statement is compiled and executed, changed {}: {}", this, result, statement);
     return result;
   } catch (android.database.SQLException e) {
     throw SqlExceptionUtil.create("inserting to database failed: " + statement, e);
   } finally {
     closeQuietly(stmt);
   }
 }
Beispiel #18
0
 private void importCities(InputStream in) {
   CityJsonParser parser = createParser();
   insertStatement =
       db.compileStatement(
           "INSERT INTO "
               + CityContract.Cities.TABLE
               + " ("
               + CityContract.Cities.CITY_ID
               + ", "
               + CityContract.Cities.NAME
               + ", "
               + CityContract.Cities.COUNTRY
               + ", "
               + CityContract.Cities.LATITUDE
               + ", "
               + CityContract.Cities.LONGITUDE
               + ") VALUES"
               + "(?, ?, ?, ?, ?)");
   db.beginTransaction();
   try {
     parser.parseCities(in, this);
   } catch (Exception e) {
     Log.e(LOG_TAG, "Failed to parse cities: " + e, e);
   } finally {
     db.endTransaction();
     insertStatement.close();
   }
 }
  public long isTagPostExists(int post_id) {
    SQLiteDatabase database = null;
    long count = 0;
    try {
      String sql =
          "SELECT COUNT(*) FROM "
              + DbAdapter.TAG_POSTS_TABLE_NAME
              + " where "
              + DbAdapter.TP_ID
              + "="
              + post_id;

      dbHelper = new DbAdapter(context);
      database = dbHelper.getReadableDatabase();
      SQLiteStatement statement = database.compileStatement(sql);
      count = statement.simpleQueryForLong();
    } catch (Exception e) {
      e.printStackTrace();
    } finally {
      try {
        database.close();
      } catch (Exception e) {
      }
    }
    return count;
  }
 /*package*/ SQLiteStatement createInsertStatement(SQLiteDatabase database) {
   return database.compileStatement(
       "INSERT INTO "
           + TABLE_NAME
           + " ("
           + ADDRESS
           + ", "
           + PERSON
           + ", "
           + DATE_SENT
           + ", "
           + DATE_RECEIVED
           + ", "
           + PROTOCOL
           + ", "
           + READ
           + ", "
           + STATUS
           + ", "
           + TYPE
           + ", "
           + REPLY_PATH_PRESENT
           + ", "
           + SUBJECT
           + ", "
           + BODY
           + ", "
           + SERVICE_CENTER
           + ", "
           + THREAD_ID
           + ") "
           + " VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)");
 }
  private void updateTables4() {
    final FileInfoSet fileInfos = new FileInfoSet();
    final Cursor cursor = myDatabase.rawQuery("SELECT file_name FROM Books", null);
    while (cursor.moveToNext()) {
      fileInfos.check(ZLFile.createFileByPath(cursor.getString(0)).getPhysicalFile(), false);
    }
    cursor.close();
    fileInfos.save();

    myDatabase.execSQL(
        "CREATE TABLE RecentBooks("
            + "book_index INTEGER PRIMARY KEY,"
            + "book_id INTEGER REFERENCES Books(book_id))");
    final ArrayList<Long> ids = new ArrayList<Long>();

    final SQLiteStatement statement =
        myDatabase.compileStatement("SELECT book_id FROM Books WHERE file_name = ?");

    for (int i = 0; i < 20; ++i) {
      final ZLStringOption option = new ZLStringOption("LastOpenedBooks", "Book" + i, "");
      final String fileName = option.getValue();
      option.setValue("");
      try {
        statement.bindString(1, fileName);
        final long bookId = statement.simpleQueryForLong();
        if (bookId != -1) {
          ids.add(bookId);
        }
      } catch (SQLException e) {
      }
    }
    saveRecentBookIds(ids);
  }
 public void insertFiles(File[] files) {
   SQLiteDatabase database = dbHelper.getWritableDatabase();
   SQLiteStatement statement =
       database.compileStatement(
           "INSERT INTO "
               + TABLE_NAME
               + " ("
               + COL_FILENAME
               + ", "
               + COL_FILESIZE
               + ", "
               + COL_TIMESTAMP
               + ") VALUES (?, ?, ?)");
   database.beginTransaction();
   try {
     for (File file : files) {
       statement.bindString(1, file.getName());
       statement.bindLong(2, file.length());
       statement.bindLong(3, file.lastModified());
       statement.executeInsert();
     }
     database.setTransactionSuccessful();
   } finally {
     database.endTransaction();
   }
 }
Beispiel #23
0
 /**
  * Adds or updates room.
  *
  * @param account
  * @param room
  * @param nickname
  * @param password
  * @param join
  */
 void write(String account, String room, String nickname, String password, boolean join) {
   synchronized (writeLock) {
     if (writeStatement == null) {
       SQLiteDatabase db = databaseManager.getWritableDatabase();
       writeStatement =
           db.compileStatement(
               "INSERT OR REPLACE INTO "
                   + NAME
                   + " ("
                   + Fields.ACCOUNT
                   + ", "
                   + Fields.ROOM
                   + ", "
                   + Fields.NICKNAME
                   + ", "
                   + Fields.PASSWORD
                   + ", "
                   + Fields.NEED_JOIN
                   + ") VALUES (?, ?, ?, ?, ?);");
     }
     writeStatement.bindString(1, account);
     writeStatement.bindString(2, room);
     writeStatement.bindString(3, nickname);
     writeStatement.bindString(4, password);
     writeStatement.bindLong(5, join ? 1 : 0);
     writeStatement.execute();
   }
 }
  @MediumTest
  public void testStatementMultipleBindings() throws Exception {
    mDatabase.execSQL("CREATE TABLE test (num INTEGER, str TEXT);");
    SQLiteStatement statement =
        mDatabase.compileStatement("INSERT INTO test (num, str) VALUES (?, ?)");

    for (long i = 0; i < 10; i++) {
      statement.bindLong(1, i);
      statement.bindString(2, Long.toHexString(i));
      statement.execute();
    }
    statement.close();

    Cursor c = mDatabase.query("test", null, null, null, null, null, "ROWID");
    int numCol = c.getColumnIndexOrThrow("num");
    int strCol = c.getColumnIndexOrThrow("str");
    assertTrue(c.moveToFirst());
    for (long i = 0; i < 10; i++) {
      long num = c.getLong(numCol);
      String str = c.getString(strCol);
      assertEquals(i, num);
      assertEquals(Long.toHexString(i), str);
      c.moveToNext();
    }
    c.close();
  }
    @Override
    public void onCreate(SQLiteDatabase database) {
      database.execSQL(
          "create table if not exists urlpermission("
              + " id integer primary key autoincrement,"
              + " service_name text,"
              + " url text,"
              + " rule text);");

      SQLiteStatement statement =
          database.compileStatement(
              "insert into urlpermission(service_name, url, rule) values(?,?,?)");
      int index = 1;
      statement.bindString(index++, "service1");
      statement.bindString(index++, "http://www.baidu.com/1");
      statement.bindString(index++, "YES");

      statement.execute();

      index = 1;
      statement.bindString(index++, "service2");
      statement.bindString(index++, "http://www.baidu.com/2");
      statement.bindString(index++, "NO");
      statement.execute();

      statement.close();
    }
  @MediumTest
  public void testStatementConstraint() throws Exception {
    mDatabase.execSQL("CREATE TABLE test (num INTEGER NOT NULL);");
    SQLiteStatement statement = mDatabase.compileStatement("INSERT INTO test (num) VALUES (?)");

    // Try to insert NULL, which violates the constraint
    try {
      statement.clearBindings();
      statement.execute();
      fail("expected exception not thrown");
    } catch (SQLiteConstraintException e) {
      // expected
    }

    // Make sure the statement can still be used
    statement.bindLong(1, 1);
    statement.execute();
    statement.close();

    Cursor c = mDatabase.query("test", null, null, null, null, null, null);
    int numCol = c.getColumnIndexOrThrow("num");
    c.moveToFirst();
    long num = c.getLong(numCol);
    assertEquals(1, num);
    c.close();
  }
 public void addTerms(ArrayList<Terms> termList, User usr) {
   System.out.println("Terms StartUp : " + System.currentTimeMillis());
   if (!isTermsAvailableForCompany(usr.getCompanyId())) {
     deleteTerms();
     SQLiteDatabase db = this.getWritableDatabase();
     try {
       db.beginTransaction();
       SQLiteStatement statement = db.compileStatement(this.TERMS_QUERY);
       for (Terms terms : termList) {
         statement.bindString(1, terms.description);
         statement.bindLong(2, terms.languageId);
         statement.bindString(3, terms.term);
         statement.bindString(4, usr.getCompanyId());
         statement.execute();
         statement.clearBindings();
       }
       db.setTransactionSuccessful();
     } catch (Exception e) {
       // TODO: handle exception
     } finally {
       db.endTransaction();
       db.close();
     }
   }
   System.out.println("Terms End : " + System.currentTimeMillis());
 }
 private void updateTables18() {
   myDatabase.execSQL("ALTER TABLE BookSeries RENAME TO BookSeries_Obsolete");
   myDatabase.execSQL(
       "CREATE TABLE BookSeries("
           + "series_id INTEGER NOT NULL REFERENCES Series(series_id),"
           + "book_id INTEGER NOT NULL UNIQUE REFERENCES Books(book_id),"
           + "book_index TEXT)");
   final SQLiteStatement insert =
       myDatabase.compileStatement(
           "INSERT INTO BookSeries (series_id,book_id,book_index) VALUES (?,?,?)");
   final Cursor cursor =
       myDatabase.rawQuery("SELECT series_id,book_id,book_index FROM BookSeries_Obsolete", null);
   while (cursor.moveToNext()) {
     insert.bindLong(1, cursor.getLong(0));
     insert.bindLong(2, cursor.getLong(1));
     final float index = cursor.getFloat(2);
     final String stringIndex;
     if (index == 0.0f) {
       stringIndex = null;
     } else {
       if (Math.abs(index - Math.round(index)) < 0.01) {
         stringIndex = String.valueOf(Math.round(index));
       } else {
         stringIndex = String.format("%.1f", index);
       }
     }
     final BigDecimal bdIndex = SeriesInfo.createIndex(stringIndex);
     SQLiteUtil.bindString(insert, 3, bdIndex != null ? bdIndex.toString() : null);
     insert.executeInsert();
   }
   cursor.close();
   myDatabase.execSQL("DROP TABLE BookSeries_Obsolete");
 }
  // @Large
  @Suppress
  public void testLoadingThreadDelayRegisterData() throws Exception {
    mDatabase.execSQL("CREATE TABLE test (_id INTEGER PRIMARY KEY, data INT);");

    final int count = 505;
    String sql = "INSERT INTO test (data) VALUES (?);";
    SQLiteStatement s = mDatabase.compileStatement(sql);
    for (int i = 0; i < count; i++) {
      s.bindLong(1, i);
      s.execute();
    }

    int maxRead = 500;
    int initialRead = 5;
    SQLiteCursor c =
        (SQLiteCursor) mDatabase.rawQuery("select * from test;", null, initialRead, maxRead);

    TestObserver observer = new TestObserver(count, c);
    c.getCount();
    c.registerDataSetObserver(observer);
    if (!observer.quit) {
      Looper.loop();
    }
    c.close();
  }
  public void hapusBukmakByAri(int ari, int jenis) {
    SQLiteDatabase db = helper.getWritableDatabase();
    db.beginTransaction();
    try {
      long _id;

      SQLiteStatement stmt =
          db.compileStatement(
              "select _id from "
                  + Db.TABEL_Bukmak2
                  + " where "
                  + Db.Bukmak2.jenis
                  + "=? and "
                  + Db.Bukmak2.ari
                  + "=?"); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$ //$NON-NLS-4$
      try {
        stmt.bindLong(1, jenis);
        stmt.bindLong(2, ari);
        _id = stmt.simpleQueryForLong();
      } finally {
        stmt.close();
      }

      String[] params = {String.valueOf(_id)};
      db.delete(Db.TABEL_Bukmak2_Label, Db.Bukmak2_Label.bukmak2_id + "=?", params); // $NON-NLS-1$
      db.delete(Db.TABEL_Bukmak2, "_id=?", params); // $NON-NLS-1$
      db.setTransactionSuccessful();
    } finally {
      db.endTransaction();
    }
  }