367 lines
14 KiB
C++
367 lines
14 KiB
C++
|
/*
|
||
|
|
* 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_TYPE_STRING;
|
||
|
|
fieldSlot->data.buffer.offset = offset;
|
||
|
|
fieldSlot->data.buffer.size = size;
|
||
|
|
|
||
|
|
LOG_WINDOW("%d,%d is TEXT with %u bytes", startPos + numRows, i, size);
|
||
|
|
} else if (type == SQLITE_INTEGER) {
|
||
|
|
// INTEGER data
|
||
|
|
int64_t value = sqlite3_column_int64(statement, i);
|
||
|
|
if (!window->putLong(numRows, i, value)) {
|
||
|
|
window->freeLastRow();
|
||
|
|
LOGE("Failed allocating space for a long in column %d", i);
|
||
|
|
return startPos + numRows + finish_program_and_get_row_count(statement) + 1;
|
||
|
|
}
|
||
|
|
LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + numRows, i, value);
|
||
|
|
} else if (type == SQLITE_FLOAT) {
|
||
|
|
// FLOAT data
|
||
|
|
double value = sqlite3_column_double(statement, i);
|
||
|
|
if (!window->putDouble(numRows, i, value)) {
|
||
|
|
window->freeLastRow();
|
||
|
|
LOGE("Failed allocating space for a double in column %d", i);
|
||
|
|
return startPos + numRows + finish_program_and_get_row_count(statement) + 1;
|
||
|
|
}
|
||
|
|
LOG_WINDOW("%d,%d is FLOAT %lf", startPos + numRows, i, value);
|
||
|
|
} else if (type == SQLITE_BLOB) {
|
||
|
|
// BLOB data
|
||
|
|
uint8_t const * blob = (uint8_t const *)sqlite3_column_blob(statement, i);
|
||
|
|
size_t size = sqlite3_column_bytes16(statement, i);
|
||
|
|
int offset = window->alloc(size);
|
||
|
|
if (!offset) {
|
||
|
|
window->freeLastRow();
|
||
|
|
LOGE("Failed allocating %u bytes for blob at %d,%d", size,
|
||
|
|
startPos + numRows, i);
|
||
|
|
return startPos + numRows + finish_program_and_get_row_count(statement) + 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
window->copyIn(offset, blob, 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_TYPE_BLOB;
|
||
|
|
fieldSlot->data.buffer.offset = offset;
|
||
|
|
fieldSlot->data.buffer.size = size;
|
||
|
|
|
||
|
|
LOG_WINDOW("%d,%d is Blob with %u bytes @ %d", startPos + numRows, i, size, offset);
|
||
|
|
} else if (type == SQLITE_NULL) {
|
||
|
|
// NULL field
|
||
|
|
window->putNull(numRows, i);
|
||
|
|
|
||
|
|
LOG_WINDOW("%d,%d is NULL", startPos + numRows, i);
|
||
|
|
} else {
|
||
|
|
// Unknown data
|
||
|
|
LOGE("Unknown column type when filling database window");
|
||
|
|
throw_sqlite3_exception(env, "Unknown column type when filling window");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
if (i < numColumns) {
|
||
|
|
// Not all the fields fit in the window
|
||
|
|
// Unknown data error happened
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Mark the row as complete in the window
|
||
|
|
numRows++;
|
||
|
|
} 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 rety");
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Sleep to give the thread holding the lock a chance to finish
|
||
|
|
usleep(1000);
|
||
|
|
|
||
|
|
retryCount++;
|
||
|
|
continue;
|
||
|
|
} else {
|
||
|
|
throw_sqlite3_exception(env, GET_HANDLE(env, object));
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
LOG_WINDOW("Resetting statement %p after fetching %d rows in %d bytes\n\n\n\n", statement,
|
||
|
|
numRows, window->size() - window->freeSpace());
|
||
|
|
// LOGI("Filled window with %d rows in %d bytes", numRows, window->size() - window->freeSpace());
|
||
|
|
if (err == SQLITE_ROW) {
|
||
|
|
return -1;
|
||
|
|
} else {
|
||
|
|
sqlite3_reset(statement);
|
||
|
|
return startPos + numRows;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
static jint native_column_count(JNIEnv* env, jobject object)
|
||
|
|
{
|
||
|
|
sqlite3_stmt * statement = GET_STATEMENT(env, object);
|
||
|
|
|
||
|
|
return sqlite3_column_count(statement);
|
||
|
|
}
|
||
|
|
|
||
|
|
static jstring native_column_name(JNIEnv* env, jobject object, jint columnIndex)
|
||
|
|
{
|
||
|
|
sqlite3_stmt * statement = GET_STATEMENT(env, object);
|
||
|
|
char const * name;
|
||
|
|
|
||
|
|
name = sqlite3_column_name(statement, columnIndex);
|
||
|
|
|
||
|
|
return env->NewStringUTF(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
static JNINativeMethod sMethods[] =
|
||
|
|
{
|
||
|
|
/* name, signature, funcPtr */
|
||
|
|
{"native_fill_window", "(Landroid/database/CursorWindow;IIII)I", (void *)native_fill_window},
|
||
|
|
{"native_column_count", "()I", (void*)native_column_count},
|
||
|
|
{"native_column_name", "(I)Ljava/lang/String;", (void *)native_column_name},
|
||
|
|
};
|
||
|
|
|
||
|
|
int register_android_database_SQLiteQuery(JNIEnv * env)
|
||
|
|
{
|
||
|
|
jclass clazz;
|
||
|
|
|
||
|
|
clazz = env->FindClass("android/database/sqlite/SQLiteQuery");
|
||
|
|
if (clazz == NULL) {
|
||
|
|
LOGE("Can't find android/database/sqlite/SQLiteQuery");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
gHandleField = env->GetFieldID(clazz, "nHandle", "I");
|
||
|
|
gStatementField = env->GetFieldID(clazz, "nStatement", "I");
|
||
|
|
|
||
|
|
if (gHandleField == NULL || gStatementField == NULL) {
|
||
|
|
LOGE("Error locating fields");
|
||
|
|
return -1;
|
||
|
|
}
|
||
|
|
|
||
|
|
return AndroidRuntime::registerNativeMethods(env,
|
||
|
|
"android/database/sqlite/SQLiteQuery", sMethods, NELEM(sMethods));
|
||
|
|
}
|
||
|
|
|
||
|
|
} // namespace android
|