Use 8 MB CursorWindow by default, adjustable with static methods on SQLiteCursor class

Author: developernotes

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

@@ -2,11 +2,14 @@
 
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.core.Is.is;
+import static org.hamcrest.core.IsNull.notNullValue;
 import static org.hamcrest.core.IsNull.nullValue;
+import static org.junit.Assert.fail;
 
 import android.content.ContentValues;
 import android.database.Cursor;
 
+import net.zetetic.database.sqlcipher.SQLiteCursor;
 import net.zetetic.database.sqlcipher.SQLiteDatabase;
 import net.zetetic.database.sqlcipher.SQLiteDatabaseConfiguration;
 import net.zetetic.database.sqlcipher.SQLiteDatabaseCorruptException;
@@ -18,6 +21,7 @@
 
 import java.io.File;
 import java.nio.charset.StandardCharsets;
+import java.util.Arrays;
 
 public class SQLCipherDatabaseTest extends AndroidSQLCipherTestCase {
 
@@ -451,4 +455,54 @@ public void shouldReportErrorAfterDatabaseCloseWhenCheckingTransactionState(){
     database.close();
     database.inTransaction();
   }
+
+  @Test
+  public void shouldRetrieveLargeSingleRowResultFromCursor(){
+    try {
+      int id = 1;
+      byte[] queriedData = null;
+      int size = 256;
+      SQLiteCursor.setCursorWindowSize(size);
+      byte[] data = generateRandomBytes(size);
+      database.execSQL("create table t1(a,b);");
+      database.execSQL("insert into t1(a,b) values(?,?);", new Object[]{id, data});
+      Cursor cursor = database.rawQuery("select b from t1 where a = ?;", new Object[]{id});
+      if(cursor != null && cursor.moveToFirst()){
+        queriedData = cursor.getBlob(0);
+        cursor.close();
+      }
+      assertThat(Arrays.equals(queriedData, data), is(true));
+    } finally {
+      SQLiteCursor.resetCursorWindowSize();
+    }
+  }
+
+  @Test
+  public void shouldAllowCursorWindowToResize(){
+    try {
+      Cursor cursor;
+      int id = 1, extra = 100, size = 256;
+      byte[] tooLargeQueriedData = null;
+      SQLiteCursor.setCursorWindowSize(size);
+      byte[] tooLargeData = generateRandomBytes(size + extra);
+      database.execSQL("create table t1(a,b);");
+      database.execSQL("insert into t1(a,b) values(?,?);", new Object[]{id, tooLargeData});
+      try {
+        cursor = database.rawQuery("select b from t1 where a = ?;", new Object[]{id});
+        if(cursor != null && cursor.moveToFirst()) {
+          fail("CursorWindow should be too small to fill query results");
+        }
+      } catch (Exception ex){
+        SQLiteCursor.setCursorWindowSize(size + extra);
+        cursor = database.rawQuery("select b from t1 where a = ?;", new Object[]{id});
+        if(cursor != null && cursor.moveToFirst()) {
+          tooLargeQueriedData = cursor.getBlob(0);
+          cursor.close();
+        }
+      }
+      assertThat(Arrays.equals(tooLargeQueriedData, tooLargeData), is(true));
+    } finally {
+      SQLiteCursor.resetCursorWindowSize();
+    }
+  }
 }

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

@@ -20,13 +20,15 @@
 
 package net.zetetic.database.sqlcipher;
 
+import android.annotation.SuppressLint;
 import android.database.AbstractWindowedCursor;
 import android.database.CursorWindow;
 import net.zetetic.database.DatabaseUtils;
 
-import android.os.StrictMode;
+import android.os.Build;
 import android.util.Log;
 
+import java.lang.reflect.Field;
 import java.util.HashMap;
 import java.util.Map;
 
@@ -40,6 +42,10 @@
 public class SQLiteCursor extends AbstractWindowedCursor {
     static final String TAG = "SQLiteCursor";
     static final int NO_COUNT = -1;
+    private static final int CURSOR_WINDOW_EXTRA = 512;
+    private static boolean CURSOR_WINDOW_NEEDS_RECREATED = false;
+    private static final int DEFAULT_CURSOR_WINDOW_SIZE = (int)(8 * Math.pow(1024, 2));
+    public static int PREFERRED_CURSOR_WINDOW_SIZE = DEFAULT_CURSOR_WINDOW_SIZE;
 
     /** The name of the table to edit */
     private final String mEditTable;
@@ -131,21 +137,52 @@ public int getCount() {
         return mCount;
     }
 
+    public static void setCursorWindowSize(int size) {
+        PREFERRED_CURSOR_WINDOW_SIZE = size;
+        CURSOR_WINDOW_NEEDS_RECREATED = true;
+    }
+
+    public static void resetCursorWindowSize() {
+        PREFERRED_CURSOR_WINDOW_SIZE = DEFAULT_CURSOR_WINDOW_SIZE;
+        CURSOR_WINDOW_NEEDS_RECREATED = true;
+    }
+
     /* 
     ** The AbstractWindowClass contains protected methods clearOrCreateWindow() and
     ** closeWindow(), which are used by the android.database.sqlite.* version of this
     ** class. But, since they are marked with "@hide", the following replacement 
     ** versions are required.
     */
-    private void awc_clearOrCreateWindow(String name){
-      CursorWindow win = getWindow();
-      if( win==null ){
-        win = new CursorWindow(name);
-        setWindow(win);
-      }else{
-        win.clear();
+    private void awc_clearOrCreateWindow(String name) {
+        int cursorWindowAllocationSize = PREFERRED_CURSOR_WINDOW_SIZE + CURSOR_WINDOW_EXTRA;
+        if (CURSOR_WINDOW_NEEDS_RECREATED) {
+            awc_closeWindow();
+            CURSOR_WINDOW_NEEDS_RECREATED = false;
+        }
+        CursorWindow win = getWindow();
+        if ( win==null ) {
+            if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+                win = new CursorWindow(name, cursorWindowAllocationSize);
+            } else {
+                try {
+                    @SuppressLint("DiscouragedPrivateApi")
+                    Field field = CursorWindow.class.getDeclaredField("sCursorWindowSize");
+                    if (field != null) {
+                        field.setAccessible(true);
+                        field.set(null, cursorWindowAllocationSize);
+                        Log.i(TAG, String.format("Set CursorWindow allocation size to %s", cursorWindowAllocationSize));
+                    }
+                } catch (Exception ex) {
+                    Log.e(TAG, "Failed to override CursorWindow allocation size", ex);
+                }
+                win = new CursorWindow(name);
+            }
+            setWindow(win);
+        }else{
+            win.clear();
       }
     }
+
     private void awc_closeWindow(){
       setWindow(null);
     }

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

@@ -24,7 +24,6 @@
 #include <JNIHelp.h>
 #include "ALog-priv.h"
 
-
 #include <sys/mman.h>
 #include <string.h>
 #include <unistd.h>
@@ -755,7 +754,7 @@ static jlong nativeExecuteForCursorWindow(
   int nRow;
   jboolean bOk;
   int iStart;                     /* First row copied to CursorWindow */
-
+  int rc_step;
   /* Locate all required CursorWindow methods. */
   cls = pEnv->FindClass("android/database/CursorWindow");
   for(i=0; i<(sizeof(aMethod)/sizeof(struct CWMethod)); i++){
@@ -775,7 +774,7 @@ static jlong nativeExecuteForCursorWindow(
 
   nRow = 0;
   iStart = startPos;
-  while( sqlite3_step(pStmt)==SQLITE_ROW ){
+  while( (rc_step = sqlite3_step(pStmt))==SQLITE_ROW ){
     /* Only copy in rows that occur at or after row index iStart. */
     if( nRow>=iStart && bOk ){
       bOk = copyRowToWindow(pEnv, win, (nRow - iStart), pStmt, aMethod);
@@ -811,6 +810,22 @@ static jlong nativeExecuteForCursorWindow(
     return 0;
   }
 
+  if( bOk==0 && countAllRows==0 && nRow <= iRowRequired ) {
+    char *msg = sqlite3_mprintf("Row too big to fit into CursorWindow requiredPos=%d, totalRows=%d",
+                                    iRowRequired, nRow);
+    throw_sqlite3_exception(pEnv, pConnection->db, msg);
+    sqlite3_free(msg);
+    return 0;
+  }
+
+  if ( rc_step != SQLITE_DONE && rc_step != SQLITE_ROW ) {
+    char *msg = sqlite3_mprintf("Unexpected result code=%d while stepping through result",
+                                 rc_step);
+    throw_sqlite3_exception(pEnv, pConnection->db, msg);
+    sqlite3_free(msg);
+    return 0;
+  }
+
   jlong lRet = jlong(iStart) << 32 | jlong(nRow);
   return lRet;
 }