core/jni/android_database_SQLiteQuery.cpp - platform/frameworks/base - Gitiles

 /*
  * 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.
  */

 #undef LOG_TAG
 #define LOG_TAG "SqliteCursor.cpp"

 #include <jni.h>
 #include <JNIHelp.h>
 #include <android_runtime/AndroidRuntime.h>

 #include <sqlite3.h>

 #include <utils/Log.h>

 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>

 #include "binder/CursorWindow.h"
 #include "sqlite3_exception.h"


 namespace android {

 enum CopyRowResult {
     CPR_OK,
     CPR_FULL,
     CPR_ERROR,
 };

 static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window,
         sqlite3_stmt* statement, int numColumns, int startPos, int addedRows) {
     // Allocate a new field directory for the row. This pointer is not reused
     // since it may be possible for it to be relocated on a call to alloc() when
     // the field data is being allocated.
     status_t status = window->allocRow();
     if (status) {
         LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
                 startPos, addedRows, status);
         return CPR_FULL;
     }

     // Pack the row into the window.
     CopyRowResult result = CPR_OK;
     for (int i = 0; i < numColumns; i++) {
         int type = sqlite3_column_type(statement, i);
         if (type == SQLITE_TEXT) {
             // TEXT data
             const char* text = reinterpret_cast<const char*>(
                     sqlite3_column_text(statement, i));
             // SQLite does not include the NULL terminator in size, but does
             // ensure all strings are NULL terminated, so increase size by
             // one to make sure we store the terminator.
             size_t sizeIncludingNull = sqlite3_column_bytes(statement, i) + 1;
             status = window->putString(addedRows, i, text, sizeIncludingNull);
             if (status) {
                 LOG_WINDOW("Failed allocating %u bytes for text at %d,%d, error=%d",
                         sizeIncludingNull, startPos + addedRows, i, status);
                 result = CPR_FULL;
                 break;
             }
             LOG_WINDOW("%d,%d is TEXT with %u bytes",
                     startPos + addedRows, i, sizeIncludingNull);
         } else if (type == SQLITE_INTEGER) {
             // INTEGER data
             int64_t value = sqlite3_column_int64(statement, i);
             status = window->putLong(addedRows, i, value);
             if (status) {
                 LOG_WINDOW("Failed allocating space for a long in column %d, error=%d",
                         i, status);
                 result = CPR_FULL;
                 break;
             }
             LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + addedRows, i, value);
         } else if (type == SQLITE_FLOAT) {
             // FLOAT data
             double value = sqlite3_column_double(statement, i);
             status = window->putDouble(addedRows, i, value);
             if (status) {
                 LOG_WINDOW("Failed allocating space for a double in column %d, error=%d",
                         i, status);
                 result = CPR_FULL;
                 break;
             }
             LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value);
         } else if (type == SQLITE_BLOB) {
             // BLOB data
             const void* blob = sqlite3_column_blob(statement, i);
             size_t size = sqlite3_column_bytes(statement, i);
             status = window->putBlob(addedRows, i, blob, size);
             if (status) {
                 LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d, error=%d",
                         size, startPos + addedRows, i, status);
                 result = CPR_FULL;
                 break;
             }
             LOG_WINDOW("%d,%d is Blob with %u bytes",
                     startPos + addedRows, i, size);
         } else if (type == SQLITE_NULL) {
             // NULL field
             status = window->putNull(addedRows, i);
             if (status) {
                 LOG_WINDOW("Failed allocating space for a null in column %d, error=%d",
                         i, status);
                 result = CPR_FULL;
                 break;
             }

             LOG_WINDOW("%d,%d is NULL", startPos + addedRows, i);
         } else {
             // Unknown data
             LOGE("Unknown column type when filling database window");
             throw_sqlite3_exception(env, "Unknown column type when filling window");
             result = CPR_ERROR;
             break;
         }
     }

     // Free the last row if if was not successfully copied.
     if (result != CPR_OK) {
         window->freeLastRow();
     }
     return result;
 }

 static jlong nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
         jint statementPtr, jint windowPtr, jint offsetParam,
         jint startPos, jint requiredPos, jboolean countAllRows) {
     sqlite3* database = reinterpret_cast<sqlite3*>(databasePtr);
     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
     CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);

     // Only do the binding if there is a valid offsetParam. If no binding needs to be done
     // offsetParam will be set to 0, an invalid value.
     if (offsetParam > 0) {
         // Bind the offset parameter, telling the program which row to start with
         // If an offset parameter is used, we cannot simply clear the window if it
         // turns out that the requiredPos won't fit because the result set may
         // depend on startPos, so we set startPos to requiredPos.
         startPos = requiredPos;
         int err = sqlite3_bind_int(statement, offsetParam, startPos);
         if (err != SQLITE_OK) {
             LOGE("Unable to bind offset position, offsetParam = %d", offsetParam);
             throw_sqlite3_exception(env, database);
             return 0;
         }
         LOG_WINDOW("Bound offset position to startPos %d", startPos);
     }

     // We assume numRows is initially 0.
     LOG_WINDOW("Window: numRows = %d, size = %d, freeSpace = %d",
             window->getNumRows(), window->size(), window->freeSpace());

     int numColumns = sqlite3_column_count(statement);
     status_t status = window->setNumColumns(numColumns);
     if (status) {
         LOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns);
         jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch");
         return 0;
     }

     int retryCount = 0;
     int totalRows = 0;
     int addedRows = 0;
     bool windowFull = false;
     bool gotException = false;
     while (!gotException && (!windowFull || countAllRows)) {
         int err = sqlite3_step(statement);
         if (err == SQLITE_ROW) {
             LOG_WINDOW("Stepped statement %p to row %d", statement, totalRows);
             retryCount = 0;
             totalRows += 1;

             // Skip the row if the window is full or we haven't reached the start position yet.
             if (startPos >= totalRows || windowFull) {
                 continue;
             }

             CopyRowResult cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
             if (cpr == CPR_FULL && addedRows && startPos + addedRows < requiredPos) {
                 // We filled the window before we got to the one row that we really wanted.
                 // Clear the window and start filling it again from here.
                 // TODO: Would be nicer if we could progressively replace earlier rows.
                 window->clear();
                 window->setNumColumns(numColumns);
                 startPos += addedRows;
                 addedRows = 0;
                 cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
             }

             if (cpr == CPR_OK) {
                 addedRows += 1;
             } else if (cpr == CPR_FULL) {
                 windowFull = true;
             } else {
                 gotException = true;
             }
         } else if (err == SQLITE_DONE) {
             // All rows processed, bail
             LOG_WINDOW("Processed all rows");
             break;
         } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) {
             // The table is locked, retry
             LOG_WINDOW("Database locked, retrying");
             if (retryCount > 50) {
                 LOGE("Bailing on database busy retry");
                 throw_sqlite3_exception(env, database, "retrycount exceeded");
                 gotException = true;
             } else {
                 // Sleep to give the thread holding the lock a chance to finish
                 usleep(1000);
                 retryCount++;
             }
         } else {
             throw_sqlite3_exception(env, database);
             gotException = true;
         }
     }

     LOG_WINDOW("Resetting statement %p after fetching %d rows and adding %d rows"
             "to the window in %d bytes",
             statement, totalRows, addedRows, window->size() - window->freeSpace());
     sqlite3_reset(statement);

     // Report the total number of rows on request.
     if (startPos > totalRows) {
         LOGE("startPos %d > actual rows %d", startPos, totalRows);
     }
     jlong result = jlong(startPos) << 32 | jlong(totalRows);
     return result;
 }

 static jint nativeColumnCount(JNIEnv* env, jclass clazz, jint statementPtr) {
     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
     return sqlite3_column_count(statement);
 }

 static jstring nativeColumnName(JNIEnv* env, jclass clazz, jint statementPtr,
         jint columnIndex) {
     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
     const char* name = sqlite3_column_name(statement, columnIndex);
     return env->NewStringUTF(name);
 }


 static JNINativeMethod sMethods[] =
 {
      /* name, signature, funcPtr */
     { "nativeFillWindow", "(IIIIIIZ)J",
             (void*)nativeFillWindow },
     { "nativeColumnCount", "(I)I",
             (void*)nativeColumnCount},
     { "nativeColumnName", "(II)Ljava/lang/String;",
             (void*)nativeColumnName},
 };

 int register_android_database_SQLiteQuery(JNIEnv * env)
 {
     return AndroidRuntime::registerNativeMethods(env,
         "android/database/sqlite/SQLiteQuery", sMethods, NELEM(sMethods));
 }

 } // namespace android
	/*
	* 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.
	*/

	#undef LOG_TAG
	#define LOG_TAG "SqliteCursor.cpp"

	#include <jni.h>
	#include <JNIHelp.h>
	#include <android_runtime/AndroidRuntime.h>

	#include <sqlite3.h>

	#include <utils/Log.h>

	#include <stdio.h>
	#include <string.h>
	#include <unistd.h>

	#include "binder/CursorWindow.h"
	#include "sqlite3_exception.h"


	namespace android {

	enum CopyRowResult {
	CPR_OK,
	CPR_FULL,
	CPR_ERROR,
	};

	static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window,
	sqlite3_stmt* statement, int numColumns, int startPos, int addedRows) {
	// Allocate a new field directory for the row. This pointer is not reused
	// since it may be possible for it to be relocated on a call to alloc() when
	// the field data is being allocated.
	status_t status = window->allocRow();
	if (status) {
	LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
	startPos, addedRows, status);
	return CPR_FULL;
	}

	// Pack the row into the window.
	CopyRowResult result = CPR_OK;
	for (int i = 0; i < numColumns; i++) {
	int type = sqlite3_column_type(statement, i);
	if (type == SQLITE_TEXT) {
	// TEXT data
	const char* text = reinterpret_cast<const char*>(
	sqlite3_column_text(statement, i));
	// SQLite does not include the NULL terminator in size, but does
	// ensure all strings are NULL terminated, so increase size by
	// one to make sure we store the terminator.
	size_t sizeIncludingNull = sqlite3_column_bytes(statement, i) + 1;
	status = window->putString(addedRows, i, text, sizeIncludingNull);
	if (status) {
	LOG_WINDOW("Failed allocating %u bytes for text at %d,%d, error=%d",
	sizeIncludingNull, startPos + addedRows, i, status);
	result = CPR_FULL;
	break;
	}
	LOG_WINDOW("%d,%d is TEXT with %u bytes",
	startPos + addedRows, i, sizeIncludingNull);
	} else if (type == SQLITE_INTEGER) {
	// INTEGER data
	int64_t value = sqlite3_column_int64(statement, i);
	status = window->putLong(addedRows, i, value);
	if (status) {
	LOG_WINDOW("Failed allocating space for a long in column %d, error=%d",
	i, status);
	result = CPR_FULL;
	break;
	}
	LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + addedRows, i, value);
	} else if (type == SQLITE_FLOAT) {
	// FLOAT data
	double value = sqlite3_column_double(statement, i);
	status = window->putDouble(addedRows, i, value);
	if (status) {
	LOG_WINDOW("Failed allocating space for a double in column %d, error=%d",
	i, status);
	result = CPR_FULL;
	break;
	}
	LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value);
	} else if (type == SQLITE_BLOB) {
	// BLOB data
	const void* blob = sqlite3_column_blob(statement, i);
	size_t size = sqlite3_column_bytes(statement, i);
	status = window->putBlob(addedRows, i, blob, size);
	if (status) {
	LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d, error=%d",
	size, startPos + addedRows, i, status);
	result = CPR_FULL;
	break;
	}
	LOG_WINDOW("%d,%d is Blob with %u bytes",
	startPos + addedRows, i, size);
	} else if (type == SQLITE_NULL) {
	// NULL field
	status = window->putNull(addedRows, i);
	if (status) {
	LOG_WINDOW("Failed allocating space for a null in column %d, error=%d",
	i, status);
	result = CPR_FULL;
	break;
	}

	LOG_WINDOW("%d,%d is NULL", startPos + addedRows, i);
	} else {
	// Unknown data
	LOGE("Unknown column type when filling database window");
	throw_sqlite3_exception(env, "Unknown column type when filling window");
	result = CPR_ERROR;
	break;
	}
	}

	// Free the last row if if was not successfully copied.
	if (result != CPR_OK) {
	window->freeLastRow();
	}
	return result;
	}

	static jlong nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
	jint statementPtr, jint windowPtr, jint offsetParam,
	jint startPos, jint requiredPos, jboolean countAllRows) {
	sqlite3* database = reinterpret_cast<sqlite3*>(databasePtr);
	sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
	CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);

	// Only do the binding if there is a valid offsetParam. If no binding needs to be done
	// offsetParam will be set to 0, an invalid value.
	if (offsetParam > 0) {
	// Bind the offset parameter, telling the program which row to start with
	// If an offset parameter is used, we cannot simply clear the window if it
	// turns out that the requiredPos won't fit because the result set may
	// depend on startPos, so we set startPos to requiredPos.
	startPos = requiredPos;
	int err = sqlite3_bind_int(statement, offsetParam, startPos);
	if (err != SQLITE_OK) {
	LOGE("Unable to bind offset position, offsetParam = %d", offsetParam);
	throw_sqlite3_exception(env, database);
	return 0;
	}
	LOG_WINDOW("Bound offset position to startPos %d", startPos);
	}

	// We assume numRows is initially 0.
	LOG_WINDOW("Window: numRows = %d, size = %d, freeSpace = %d",
	window->getNumRows(), window->size(), window->freeSpace());

	int numColumns = sqlite3_column_count(statement);
	status_t status = window->setNumColumns(numColumns);
	if (status) {
	LOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns);
	jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch");
	return 0;
	}

	int retryCount = 0;
	int totalRows = 0;
	int addedRows = 0;
	bool windowFull = false;
	bool gotException = false;
	while (!gotException && (!windowFull \|\| countAllRows)) {
	int err = sqlite3_step(statement);
	if (err == SQLITE_ROW) {
	LOG_WINDOW("Stepped statement %p to row %d", statement, totalRows);
	retryCount = 0;
	totalRows += 1;

	// Skip the row if the window is full or we haven't reached the start position yet.
	if (startPos >= totalRows \|\| windowFull) {
	continue;
	}

	CopyRowResult cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
	if (cpr == CPR_FULL && addedRows && startPos + addedRows < requiredPos) {
	// We filled the window before we got to the one row that we really wanted.
	// Clear the window and start filling it again from here.
	// TODO: Would be nicer if we could progressively replace earlier rows.
	window->clear();
	window->setNumColumns(numColumns);
	startPos += addedRows;
	addedRows = 0;
	cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
	}

	if (cpr == CPR_OK) {
	addedRows += 1;
	} else if (cpr == CPR_FULL) {
	windowFull = true;
	} else {
	gotException = true;
	}
	} else if (err == SQLITE_DONE) {
	// All rows processed, bail
	LOG_WINDOW("Processed all rows");
	break;
	} else if (err == SQLITE_LOCKED \|\| err == SQLITE_BUSY) {
	// The table is locked, retry
	LOG_WINDOW("Database locked, retrying");
	if (retryCount > 50) {
	LOGE("Bailing on database busy retry");
	throw_sqlite3_exception(env, database, "retrycount exceeded");
	gotException = true;
	} else {
	// Sleep to give the thread holding the lock a chance to finish
	usleep(1000);
	retryCount++;
	}
	} else {
	throw_sqlite3_exception(env, database);
	gotException = true;
	}
	}

	LOG_WINDOW("Resetting statement %p after fetching %d rows and adding %d rows"
	"to the window in %d bytes",
	statement, totalRows, addedRows, window->size() - window->freeSpace());
	sqlite3_reset(statement);

	// Report the total number of rows on request.
	if (startPos > totalRows) {
	LOGE("startPos %d > actual rows %d", startPos, totalRows);
	}
	jlong result = jlong(startPos) << 32 \| jlong(totalRows);
	return result;
	}

	static jint nativeColumnCount(JNIEnv* env, jclass clazz, jint statementPtr) {
	sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
	return sqlite3_column_count(statement);
	}

	static jstring nativeColumnName(JNIEnv* env, jclass clazz, jint statementPtr,
	jint columnIndex) {
	sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
	const char* name = sqlite3_column_name(statement, columnIndex);
	return env->NewStringUTF(name);
	}


	static JNINativeMethod sMethods[] =
	{
	/* name, signature, funcPtr */
	{ "nativeFillWindow", "(IIIIIIZ)J",
	(void*)nativeFillWindow },
	{ "nativeColumnCount", "(I)I",
	(void*)nativeColumnCount},
	{ "nativeColumnName", "(II)Ljava/lang/String;",
	(void*)nativeColumnName},
	};

	int register_android_database_SQLiteQuery(JNIEnv * env)
	{
	return AndroidRuntime::registerNativeMethods(env,
	"android/database/sqlite/SQLiteQuery", sMethods, NELEM(sMethods));
	}

	} // namespace android