/* * Copyright (C) 2006 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.sqlite; import android.database.DatabaseUtils; import android.os.ParcelFileDescriptor; import android.os.SystemClock; import android.util.Log; import java.io.IOException; import dalvik.system.BlockGuard; /** * A pre-compiled statement against a {@link SQLiteDatabase} that can be reused. * The statement cannot return multiple rows, but 1x1 result sets are allowed. * Don't use SQLiteStatement constructor directly, please use * {@link SQLiteDatabase#compileStatement(String)} *
* SQLiteStatement is NOT internally synchronized so code using a SQLiteStatement from multiple * threads should perform its own synchronization when using the SQLiteStatement. */ @SuppressWarnings("deprecation") public class SQLiteStatement extends SQLiteProgram { private static final String TAG = "SQLiteStatement"; private static final boolean READ = true; private static final boolean WRITE = false; private SQLiteDatabase mOrigDb; private int mState; /** possible value for {@link #mState}. indicates that a transaction is started. */ private static final int TRANS_STARTED = 1; /** possible value for {@link #mState}. indicates that a lock is acquired. */ private static final int LOCK_ACQUIRED = 2; /** * Don't use SQLiteStatement constructor directly, please use * {@link SQLiteDatabase#compileStatement(String)} * @param db * @param sql */ /* package */ SQLiteStatement(SQLiteDatabase db, String sql, Object[] bindArgs) { super(db, sql, bindArgs, false /* don't compile sql statement */); } /** * Execute this SQL statement, if it is not a SELECT / INSERT / DELETE / UPDATE, for example * CREATE / DROP table, view, trigger, index etc. * * @throws android.database.SQLException If the SQL string is invalid for * some reason */ public void execute() { executeUpdateDelete(); } /** * Execute this SQL statement, if the the number of rows affected by execution of this SQL * statement is of any importance to the caller - for example, UPDATE / DELETE SQL statements. * * @return the number of rows affected by this SQL statement execution. * @throws android.database.SQLException If the SQL string is invalid for * some reason */ public int executeUpdateDelete() { try { saveSqlAsLastSqlStatement(); acquireAndLock(WRITE); int numChanges = 0; if ((mStatementType & STATEMENT_DONT_PREPARE) > 0) { // since the statement doesn't have to be prepared, // call the following native method which will not prepare // the query plan native_executeSql(mSql); } else { numChanges = native_execute(); } return numChanges; } finally { releaseAndUnlock(); } } /** * Execute this SQL statement and return the ID of the row inserted due to this call. * The SQL statement should be an INSERT for this to be a useful call. * * @return the row ID of the last row inserted, if this insert is successful. -1 otherwise. * * @throws android.database.SQLException If the SQL string is invalid for * some reason */ public long executeInsert() { try { saveSqlAsLastSqlStatement(); acquireAndLock(WRITE); return native_executeInsert(); } finally { releaseAndUnlock(); } } private void saveSqlAsLastSqlStatement() { if (((mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) == DatabaseUtils.STATEMENT_UPDATE) || (mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) == DatabaseUtils.STATEMENT_BEGIN) { mDatabase.setLastSqlStatement(mSql); } } /** * Execute a statement that returns a 1 by 1 table with a numeric value. * For example, SELECT COUNT(*) FROM table; * * @return The result of the query. * * @throws android.database.sqlite.SQLiteDoneException if the query returns zero rows */ public long simpleQueryForLong() { try { long timeStart = acquireAndLock(READ); long retValue = native_1x1_long(); mDatabase.logTimeStat(mSql, timeStart); return retValue; } catch (SQLiteDoneException e) { throw new SQLiteDoneException( "expected 1 row from this query but query returned no data. check the query: " + mSql); } finally { releaseAndUnlock(); } } /** * Execute a statement that returns a 1 by 1 table with a text value. * For example, SELECT COUNT(*) FROM table; * * @return The result of the query. * * @throws android.database.sqlite.SQLiteDoneException if the query returns zero rows */ public String simpleQueryForString() { try { long timeStart = acquireAndLock(READ); String retValue = native_1x1_string(); mDatabase.logTimeStat(mSql, timeStart); return retValue; } catch (SQLiteDoneException e) { throw new SQLiteDoneException( "expected 1 row from this query but query returned no data. check the query: " + mSql); } finally { releaseAndUnlock(); } } /** * Executes a statement that returns a 1 by 1 table with a blob value. * * @return A read-only file descriptor for a copy of the blob value, or {@code null} * if the value is null or could not be read for some reason. * * @throws android.database.sqlite.SQLiteDoneException if the query returns zero rows */ public ParcelFileDescriptor simpleQueryForBlobFileDescriptor() { try { long timeStart = acquireAndLock(READ); ParcelFileDescriptor retValue = native_1x1_blob_ashmem(); mDatabase.logTimeStat(mSql, timeStart); return retValue; } catch (IOException ex) { Log.e(TAG, "simpleQueryForBlobFileDescriptor() failed", ex); return null; } catch (SQLiteDoneException e) { throw new SQLiteDoneException( "expected 1 row from this query but query returned no data. check the query: " + mSql); } finally { releaseAndUnlock(); } } /** * Called before every method in this class before executing a SQL statement, * this method does the following: *
* This method removes the duplicate code from the other public * methods in this class. */ private long acquireAndLock(boolean rwFlag) { mState = 0; // use pooled database connection handles for SELECT SQL statements mDatabase.verifyDbIsOpen(); SQLiteDatabase db = ((mStatementType & SQLiteProgram.STATEMENT_USE_POOLED_CONN) > 0) ? mDatabase.getDbConnection(mSql) : mDatabase; // use the database connection obtained above mOrigDb = mDatabase; mDatabase = db; setNativeHandle(mDatabase.mNativeHandle); if (rwFlag == WRITE) { BlockGuard.getThreadPolicy().onWriteToDisk(); } else { BlockGuard.getThreadPolicy().onReadFromDisk(); } /* * Special case handling of SQLiteDatabase.execSQL("BEGIN transaction"). * we know it is execSQL("BEGIN transaction") from the caller IF there is no lock held. * beginTransaction() methods in SQLiteDatabase call lockForced() before * calling execSQL("BEGIN transaction"). */ if ((mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) == DatabaseUtils.STATEMENT_BEGIN) { if (!mDatabase.isDbLockedByCurrentThread()) { // transaction is NOT started by calling beginTransaction() methods in // SQLiteDatabase mDatabase.setTransactionUsingExecSqlFlag(); } } else if ((mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) == DatabaseUtils.STATEMENT_UPDATE) { // got update SQL statement. if there is NO pending transaction, start one if (!mDatabase.inTransaction()) { mDatabase.beginTransactionNonExclusive(); mState = TRANS_STARTED; } } // do I have database lock? if not, grab it. if (!mDatabase.isDbLockedByCurrentThread()) { mDatabase.lock(mSql); mState = LOCK_ACQUIRED; } acquireReference(); long startTime = SystemClock.uptimeMillis(); mDatabase.closePendingStatements(); compileAndbindAllArgs(); return startTime; } /** * this method releases locks and references acquired in {@link #acquireAndLock(boolean)} */ private void releaseAndUnlock() { releaseReference(); if (mState == TRANS_STARTED) { try { mDatabase.setTransactionSuccessful(); } finally { mDatabase.endTransaction(); } } else if (mState == LOCK_ACQUIRED) { mDatabase.unlock(); } if ((mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) == DatabaseUtils.STATEMENT_COMMIT || (mStatementType & SQLiteProgram.STATEMENT_TYPE_MASK) == DatabaseUtils.STATEMENT_ABORT) { mDatabase.resetTransactionUsingExecSqlFlag(); } clearBindings(); // release the compiled sql statement so that the caller's SQLiteStatement no longer // has a hard reference to a database object that may get deallocated at any point. release(); // restore the database connection handle to the original value mDatabase = mOrigDb; setNativeHandle(mDatabase.mNativeHandle); } private final native int native_execute(); private final native long native_executeInsert(); private final native long native_1x1_long(); private final native String native_1x1_string(); private final native ParcelFileDescriptor native_1x1_blob_ashmem() throws IOException; private final native void native_executeSql(String sql); }