change rawExecSQL to allow execution of SELECT operations

Author: sjlombardo

sqlcipher/src/androidTest/java/net/zetetic/database/sqlcipher_cts/ImportUnencryptedDatabaseTest.java

@@ -21,13 +21,12 @@ public void shouldImportUnencryptedPlaintextDatabase(){
     try {
       database.close();
       unencryptedDatabasePath = extractAssetToDatabaseDirectory("unencrypted.db");
-      database = SQLiteDatabase.openDatabase(unencryptedDatabasePath.getAbsolutePath(), null, SQLiteDatabase.OPEN_READWRITE);
+      database = SQLiteDatabase.openDatabase(unencryptedDatabasePath.getAbsolutePath(), null, SQLiteDatabase.OPEN_READWRITE | SQLiteDatabase.CREATE_IF_NECESSARY);
       database.execSQL("ATTACH DATABASE ? as encrypted KEY ?;",
           new Object[]{encryptedDatabasePath.getAbsolutePath(), "foo"});
-      database.execSQL("SELECT sqlcipher_export('encrypted');");
+      database.rawExecSQL("SELECT sqlcipher_export('encrypted');");
       database.execSQL("DETACH DATABASE encrypted;");
       database.close();
-
       database = SQLiteDatabase.openDatabase(encryptedDatabasePath.getAbsolutePath(), "foo",
           null, SQLiteDatabase.OPEN_READWRITE, null);
       Cursor cursor = database.rawQuery("select * from t1", new String[]{});
@@ -37,15 +36,13 @@ public void shouldImportUnencryptedPlaintextDatabase(){
         cursor.close();
       }
       database.close();
-      assertThat(a, is("one for the money"));
-      assertThat(b, is("two for the show"));
-
     } catch (Exception ex){
-
+      throw ex;
     } finally {
+      assertThat(a, is("one for the money"));
+      assertThat(b, is("two for the show"));
       delete(unencryptedDatabasePath);
       delete(encryptedDatabasePath);
     }
   }
-
 }

sqlcipher/src/androidTest/java/net/zetetic/database/sqlcipher_cts/SQLCipherDatabaseTest.java

@@ -401,8 +401,8 @@ public void shouldPerformRollbackToSavepoint(){
     assertThat(count, is(1L));
   }
 
-  @Test(expected = SQLiteException.class)
-  public void shouldThrowExceptionWithSelectStatementUsingRawExecSQL(){
+  @Test
+  public void shouldNotThrowExceptionWithSelectStatementUsingRawExecSQL(){
     database.rawExecSQL("SELECT count(*) FROM sqlite_schema;");
   }
 

sqlcipher/src/main/java/net/zetetic/database/sqlcipher/SQLiteConnection.java

@@ -152,6 +152,7 @@ private static native void nativeResetStatementAndClearBindings(
     private static native String nativeExecuteForString(long connectionPtr, long statementPtr);
     private static native int nativeExecuteForBlobFileDescriptor(
             long connectionPtr, long statementPtr);
+    private static native void nativeExecuteRaw(long connectionPtr, long statementPtr);
     private static native int nativeExecuteForChangedRowCount(long connectionPtr, long statementPtr);
     private static native long nativeExecuteForLastInsertedRowId(
             long connectionPtr, long statementPtr);
@@ -737,6 +738,53 @@ public ParcelFileDescriptor executeForBlobFileDescriptor(String sql, Object[] bi
         }
     }
 
+    /**
+     * Executes a statement that returns a count of the number of rows
+     * that were changed.  Use for UPDATE or DELETE SQL statements.
+     *
+     * @param sql The SQL statement to execute.
+     * @param bindArgs The arguments to bind, or null if none.
+     * @param cancellationSignal A signal to cancel the operation in progress, or null if none.
+     * @return The number of rows that were changed.
+     *
+     * @throws SQLiteException if an error occurs, such as a syntax error
+     * or invalid number of bind arguments.
+     * @throws OperationCanceledException if the operation was canceled.
+     */
+    public void executeRaw(String sql, Object[] bindArgs,
+                                         CancellationSignal cancellationSignal) {
+        if (sql == null) {
+            throw new IllegalArgumentException("sql must not be null.");
+        }
+
+        final int cookie = mRecentOperations.beginOperation("executeRaw",
+                sql, bindArgs);
+        try {
+            final PreparedStatement statement = acquirePreparedStatement(sql);
+            try {
+                throwIfStatementForbidden(statement);
+                bindArguments(statement, bindArgs);
+                applyBlockGuardPolicy(statement);
+                attachCancellationSignal(cancellationSignal);
+                try {
+                    nativeExecuteRaw(
+                            mConnectionPtr, statement.mStatementPtr);
+                } finally {
+                    detachCancellationSignal(cancellationSignal);
+                }
+            } finally {
+                releasePreparedStatement(statement);
+            }
+        } catch (RuntimeException ex) {
+            mRecentOperations.failOperation(cookie, ex);
+            throw ex;
+        } finally {
+            if (mRecentOperations.endOperationDeferLog(cookie)) {
+                mRecentOperations.logOperation(cookie, "");
+            }
+        }
+    }
+
     /**
      * Executes a statement that returns a count of the number of rows
      * that were changed.  Use for UPDATE or DELETE SQL statements.

sqlcipher/src/main/java/net/zetetic/database/sqlcipher/SQLiteDatabase.java

@@ -1957,16 +1957,15 @@ public void execSQL(String sql, Object[] bindArgs) throws SQLException {
      * @param bindArgs The arguments to bind.
      * @return The number of rows that were changed.
      */
-    public int rawExecSQL(String sql, Object...bindArgs) throws SQLException {
+    public void rawExecSQL(String sql, Object...bindArgs) throws SQLException {
         acquireReference();
         try {
             SQLiteStatement statement = new SQLiteStatement(this, sql, bindArgs);
             try {
-                return statement.executeUpdateDeleteRaw();
+                statement.executeRaw();
             } finally {
                 statement.close();
             }
-
         } finally {
             releaseReference();
         }

sqlcipher/src/main/java/net/zetetic/database/sqlcipher/SQLiteSession.java

@@ -778,15 +778,15 @@ public int executeForChangedRowCount(String sql, Object[] bindArgs, int connecti
      * or invalid number of bind arguments.
      * @throws OperationCanceledException if the operation was canceled.
      */
-    public int executeForChangedRowCountRaw(String sql, Object[] bindArgs, int connectionFlags,
+    public void executeRaw(String sql, Object[] bindArgs, int connectionFlags,
                                          CancellationSignal cancellationSignal) {
         if (sql == null) {
             throw new IllegalArgumentException("sql must not be null.");
         }
 
         acquireConnection(sql, connectionFlags, cancellationSignal); // might throw
         try {
-            return mConnection.executeForChangedRowCount(sql, bindArgs,
+            mConnection.executeRaw(sql, bindArgs,
                 cancellationSignal); // might throw
         } finally {
             releaseConnection(); // might throw

sqlcipher/src/main/java/net/zetetic/database/sqlcipher/SQLiteStatement.java

@@ -38,6 +38,25 @@ public final class SQLiteStatement extends SQLiteProgram implements SupportSQLit
         super(db, sql, bindArgs, null);
     }
 
+    /**
+     * 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 executeRaw() {
+        acquireReference();
+        try {
+            getSession().executeRaw(getSql(), getBindArgs(), getConnectionFlags(), null);
+        } catch (SQLiteDatabaseCorruptException ex) {
+            onCorruption();
+            throw ex;
+        } finally {
+            releaseReference();
+        }
+    }
+
     /**
      * Execute this SQL statement, if it is not a SELECT / INSERT / DELETE / UPDATE, for example
      * CREATE / DROP table, view, trigger, index etc.

sqlcipher/src/main/jni/sqlcipher/android_database_SQLiteConnection.cpp

@@ -497,6 +497,22 @@ static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jlon
     }
 }
 
+static int executeNonQueryRaw(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement) {
+    int err;
+    do {
+      err = sqlite3_step(statement);
+    } while(err == SQLITE_ROW);
+    return err;
+}
+
+static void nativeExecuteRaw(JNIEnv* env, jclass clazz, jlong connectionPtr,
+                              jlong statementPtr) {
+    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
+    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
+
+    executeNonQueryRaw(env, connection, statement);
+}
+
 static int executeNonQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement) {
     int err = sqlite3_step(statement);
     if (err == SQLITE_ROW) {
@@ -905,6 +921,8 @@ static JNINativeMethod sMethods[] =
             (void*)nativeBindBlob },
     { "nativeResetStatementAndClearBindings", "(JJ)V",
             (void*)nativeResetStatementAndClearBindings },
+    { "nativeExecuteRaw", "(JJ)V",
+            (void*)nativeExecuteRaw },
     { "nativeExecute", "(JJ)V",
             (void*)nativeExecute },
     { "nativeExecuteForLong", "(JJ)J",