core/jni/android_database_SQLiteQuery.cpp - platform/frameworks/base - Git at Google

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

 static jint nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
         jint statementPtr, jint windowPtr, jint startPos, jint offsetParam) {
     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
         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 to startPos %d", startPos);
     } else {
         LOG_WINDOW("Not binding 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;
     const bool countAllRows = (startPos == 0); // when startPos is 0, we count all rows
     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;
             }

             // 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 = window->allocRow();
             if (status) {
                 LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
                         startPos, addedRows, status);
                 windowFull = true;
                 continue;
             }

             // Pack the row into the window.
             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);
                         windowFull = true;
                         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);
                         windowFull = true;
                         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);
                         windowFull = true;
                         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);
                         windowFull = true;
                         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);
                         windowFull = true;
                         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");
                     gotException = true;
                     break;
                 }
             }

             // Update the final row tally.
             if (windowFull || gotException) {
                 window->freeLastRow();
             } else {
                 addedRows += 1;
             }
         } 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);
     }
     return countAllRows ? totalRows : 0;
 }

 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", "(IIIII)I",
             (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 {

	static jint nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
	jint statementPtr, jint windowPtr, jint startPos, jint offsetParam) {
	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
	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 to startPos %d", startPos);
	} else {
	LOG_WINDOW("Not binding 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;
	const bool countAllRows = (startPos == 0); // when startPos is 0, we count all rows
	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;
	}

	// 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 = window->allocRow();
	if (status) {
	LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
	startPos, addedRows, status);
	windowFull = true;
	continue;
	}

	// Pack the row into the window.
	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);
	windowFull = true;
	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);
	windowFull = true;
	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);
	windowFull = true;
	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);
	windowFull = true;
	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);
	windowFull = true;
	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");
	gotException = true;
	break;
	}
	}

	// Update the final row tally.
	if (windowFull \|\| gotException) {
	window->freeLastRow();
	} else {
	addedRows += 1;
	}
	} 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);
	}
	return countAllRows ? totalRows : 0;
	}

	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", "(IIIII)I",
	(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