android_database_SQLiteQuery.rar_No There There

/* * 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 "Cursor" #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 "CursorWindow.h" #include "sqlite3_exception.h" namespace android { sqlite3_stmt * compile(JNIEnv* env, jobject object, sqlite3 * handle, jstring sqlString); // From android_database_CursorWindow.cpp CursorWindow * get_window_from_object(JNIEnv * env, jobject javaWindow); static jfieldID gHandleField; static jfieldID gStatementField; #define GET_STATEMENT(env, object) \ (sqlite3_stmt *)env->GetIntField(object, gStatementField) #define GET_HANDLE(env, object) \ (sqlite3 *)env->GetIntField(object, gHandleField) static int skip_rows(sqlite3_stmt *statement, int maxRows) { int retryCount = 0; for (int i = 0; i < maxRows; i++) { int err = sqlite3_step(statement); if (err == SQLITE_ROW){ // do nothing } else if (err == SQLITE_DONE) { return i; } 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 rety"); break; } // Sleep to give the thread holding the lock a chance to finish usleep(1000); retryCount++; continue; } else { return -1; } } LOGD("skip_rows row %d", maxRows); return maxRows; } static int finish_program_and_get_row_count(sqlite3_stmt *statement) { int numRows = 0; int retryCount = 0; while (true) { int err = sqlite3_step(statement); if (err == SQLITE_ROW){ numRows++; } 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 rety"); break; } // Sleep to give the thread holding the lock a chance to finish usleep(1000); retryCount++; continue; } else { // no need to throw exception break; } } sqlite3_reset(statement); LOGD("finish_program_and_get_row_count row %d", numRows); return numRows; } static jint native_fill_window(JNIEnv* env, jobject object, jobject javaWindow, jint startPos, jint offsetParam, jint maxRead, jint lastPos) { int err; sqlite3_stmt * statement = GET_STATEMENT(env, object); int numRows = lastPos; maxRead += lastPos; int numColumns; int retryCount; int boundParams; CursorWindow * window; if (statement == NULL) { LOGE("Invalid statement in fillWindow()"); jniThrowException(env, "java/lang/IllegalStateException", "Attempting to access a deactivated, closed, or empty cursor"); return 0; } // Only do the binding if there is a valid offsetParam. If no binding needs to be done // offsetParam will be set to 0, an invliad value. if(offsetParam > 0) { // Bind the offset parameter, telling the program which row to start with err = sqlite3_bind_int(statement, offsetParam, startPos); if (err != SQLITE_OK) { LOGE("Unable to bind offset position, offsetParam = %d", offsetParam); jniThrowException(env, "java/lang/IllegalArgumentException", sqlite3_errmsg(GET_HANDLE(env, object))); return 0; } LOG_WINDOW("Bound to startPos %d", startPos); } else { LOG_WINDOW("Not binding to startPos %d", startPos); } // Get the native window window = get_window_from_object(env, javaWindow); if (!window) { LOGE("Invalid CursorWindow"); jniThrowException(env, "java/lang/IllegalArgumentException", "Bad CursorWindow"); return 0; } LOG_WINDOW("Window: numRows = %d, size = %d, freeSpace = %d", window->getNumRows(), window->size(), window->freeSpace()); numColumns = sqlite3_column_count(statement); if (!window->setNumColumns(numColumns)) { LOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns); jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch"); return 0; } retryCount = 0; if (startPos > 0) { int num = skip_rows(statement, startPos); if (num < 0) { throw_sqlite3_exception(env, GET_HANDLE(env, object)); return 0; } else if (num < startPos) { LOGE("startPos %d > actual rows %d", startPos, num); return num; } } while(startPos != 0 || numRows < maxRead) { err = sqlite3_step(statement); if (err == SQLITE_ROW) { LOG_WINDOW("\nStepped statement %p to row %d", statement, startPos + numRows); retryCount = 0; // Allocate a new field directory for the row. This pointer is not reused // since it mey be possible for it to be relocated on a call to alloc() when // the field data is being allocated. { field_slot_t * fieldDir = window->allocRow(); if (!fieldDir) { LOGE("Failed allocating fieldDir at startPos %d row %d", startPos, numRows); return startPos + numRows + finish_program_and_get_row_count(statement) + 1; } } // Pack the row into the window int i; for (i = 0; i < numColumns; i++) { int type = sqlite3_column_type(statement, i); if (type == SQLITE_TEXT) { // TEXT data #if WINDOW_STORAGE_UTF8 uint8_t const * text = (uint8_t const *)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 size = sqlite3_column_bytes(statement, i) + 1; #else uint8_t const * text = (uint8_t const *)sqlite3_column_text16(statement, i); size_t size = sqlite3_column_bytes16(statement, i); #endif int offset = window->alloc(size); if (!offset) { window->freeLastRow(); LOGE("Failed allocating %u bytes for text/blob at %d,%d", size, startPos + numRows, i); return startPos + numRows + finish_program_and_get_row_count(statement) + 1; } window->copyIn(offset, text, size); // This must be updated after the call to alloc(), since that // may move the field around in the window field_slot_t * fieldSlot = window->getFieldSlot(numRows, i); fieldSlot->type = FIELD