1/* 2 * Copyright (C) 2006 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#undef LOG_TAG 18#define LOG_TAG "Cursor" 19 20#include <jni.h> 21#include <JNIHelp.h> 22#include <android_runtime/AndroidRuntime.h> 23 24#include <sqlite3.h> 25 26#include <utils/Log.h> 27 28#include <stdio.h> 29#include <string.h> 30#include <unistd.h> 31 32#include "CursorWindow.h" 33#include "sqlite3_exception.h" 34 35 36namespace android { 37 38sqlite3_stmt * compile(JNIEnv* env, jobject object, 39 sqlite3 * handle, jstring sqlString); 40 41// From android_database_CursorWindow.cpp 42CursorWindow * get_window_from_object(JNIEnv * env, jobject javaWindow); 43 44static jfieldID gHandleField; 45static jfieldID gStatementField; 46 47 48#define GET_STATEMENT(env, object) \ 49 (sqlite3_stmt *)env->GetIntField(object, gStatementField) 50#define GET_HANDLE(env, object) \ 51 (sqlite3 *)env->GetIntField(object, gHandleField) 52 53static int skip_rows(sqlite3_stmt *statement, int maxRows) { 54 int retryCount = 0; 55 for (int i = 0; i < maxRows; i++) { 56 int err = sqlite3_step(statement); 57 if (err == SQLITE_ROW){ 58 // do nothing 59 } else if (err == SQLITE_DONE) { 60 return i; 61 } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) { 62 // The table is locked, retry 63 LOG_WINDOW("Database locked, retrying"); 64 if (retryCount > 50) { 65 LOGE("Bailing on database busy rety"); 66 break; 67 } 68 // Sleep to give the thread holding the lock a chance to finish 69 usleep(1000); 70 retryCount++; 71 continue; 72 } else { 73 return -1; 74 } 75 } 76 LOGD("skip_rows row %d", maxRows); 77 return maxRows; 78} 79 80static int finish_program_and_get_row_count(sqlite3_stmt *statement) { 81 int numRows = 0; 82 int retryCount = 0; 83 while (true) { 84 int err = sqlite3_step(statement); 85 if (err == SQLITE_ROW){ 86 numRows++; 87 } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) { 88 // The table is locked, retry 89 LOG_WINDOW("Database locked, retrying"); 90 if (retryCount > 50) { 91 LOGE("Bailing on database busy rety"); 92 break; 93 } 94 // Sleep to give the thread holding the lock a chance to finish 95 usleep(1000); 96 retryCount++; 97 continue; 98 } else { 99 // no need to throw exception 100 break; 101 } 102 } 103 sqlite3_reset(statement); 104 LOGD("finish_program_and_get_row_count row %d", numRows); 105 return numRows; 106} 107 108static jint native_fill_window(JNIEnv* env, jobject object, jobject javaWindow, 109 jint startPos, jint offsetParam, jint maxRead, jint lastPos) 110{ 111 int err; 112 sqlite3_stmt * statement = GET_STATEMENT(env, object); 113 int numRows = lastPos; 114 maxRead += lastPos; 115 int numColumns; 116 int retryCount; 117 int boundParams; 118 CursorWindow * window; 119 120 if (statement == NULL) { 121 LOGE("Invalid statement in fillWindow()"); 122 jniThrowException(env, "java/lang/IllegalStateException", 123 "Attempting to access a deactivated, closed, or empty cursor"); 124 return 0; 125 } 126 127 // Only do the binding if there is a valid offsetParam. If no binding needs to be done 128 // offsetParam will be set to 0, an invliad value. 129 if(offsetParam > 0) { 130 // Bind the offset parameter, telling the program which row to start with 131 err = sqlite3_bind_int(statement, offsetParam, startPos); 132 if (err != SQLITE_OK) { 133 LOGE("Unable to bind offset position, offsetParam = %d", offsetParam); 134 jniThrowException(env, "java/lang/IllegalArgumentException", 135 sqlite3_errmsg(GET_HANDLE(env, object))); 136 return 0; 137 } 138 LOG_WINDOW("Bound to startPos %d", startPos); 139 } else { 140 LOG_WINDOW("Not binding to startPos %d", startPos); 141 } 142 143 // Get the native window 144 window = get_window_from_object(env, javaWindow); 145 if (!window) { 146 LOGE("Invalid CursorWindow"); 147 jniThrowException(env, "java/lang/IllegalArgumentException", 148 "Bad CursorWindow"); 149 return 0; 150 } 151 LOG_WINDOW("Window: numRows = %d, size = %d, freeSpace = %d", window->getNumRows(), window->size(), window->freeSpace()); 152 153 numColumns = sqlite3_column_count(statement); 154 if (!window->setNumColumns(numColumns)) { 155 LOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns); 156 jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch"); 157 return 0; 158 } 159 160 retryCount = 0; 161 if (startPos > 0) { 162 int num = skip_rows(statement, startPos); 163 if (num < 0) { 164 throw_sqlite3_exception(env, GET_HANDLE(env, object)); 165 return 0; 166 } else if (num < startPos) { 167 LOGE("startPos %d > actual rows %d", startPos, num); 168 return num; 169 } 170 } 171 172 while(startPos != 0 || numRows < maxRead) { 173 err = sqlite3_step(statement); 174 if (err == SQLITE_ROW) { 175 LOG_WINDOW("\nStepped statement %p to row %d", statement, startPos + numRows); 176 retryCount = 0; 177 178 // Allocate a new field directory for the row. This pointer is not reused 179 // since it mey be possible for it to be relocated on a call to alloc() when 180 // the field data is being allocated. 181 { 182 field_slot_t * fieldDir = window->allocRow(); 183 if (!fieldDir) { 184 LOGE("Failed allocating fieldDir at startPos %d row %d", startPos, numRows); 185 return startPos + numRows + finish_program_and_get_row_count(statement) + 1; 186 } 187 } 188 189 // Pack the row into the window 190 int i; 191 for (i = 0; i < numColumns; i++) { 192 int type = sqlite3_column_type(statement, i); 193 if (type == SQLITE_TEXT) { 194 // TEXT data 195#if WINDOW_STORAGE_UTF8 196 uint8_t const * text = (uint8_t const *)sqlite3_column_text(statement, i); 197 // SQLite does not include the NULL terminator in size, but does 198 // ensure all strings are NULL terminated, so increase size by 199 // one to make sure we store the terminator. 200 size_t size = sqlite3_column_bytes(statement, i) + 1; 201#else 202 uint8_t const * text = (uint8_t const *)sqlite3_column_text16(statement, i); 203 size_t size = sqlite3_column_bytes16(statement, i); 204#endif 205 int offset = window->alloc(size); 206 if (!offset) { 207 window->freeLastRow(); 208 LOGE("Failed allocating %u bytes for text/blob at %d,%d", size, 209 startPos + numRows, i); 210 return startPos + numRows + finish_program_and_get_row_count(statement) + 1; 211 } 212 213 window->copyIn(offset, text, size); 214 215 // This must be updated after the call to alloc(), since that 216 // may move the field around in the window 217 field_slot_t * fieldSlot = window->getFieldSlot(numRows, i); 218 fieldSlot->type = FIELD_TYPE_STRING; 219 fieldSlot->data.buffer.offset = offset; 220 fieldSlot->data.buffer.size = size; 221 222 LOG_WINDOW("%d,%d is TEXT with %u bytes", startPos + numRows, i, size); 223 } else if (type == SQLITE_INTEGER) { 224 // INTEGER data 225 int64_t value = sqlite3_column_int64(statement, i); 226 if (!window->putLong(numRows, i, value)) { 227 window->freeLastRow(); 228 LOGE("Failed allocating space for a long in column %d", i); 229 return startPos + numRows + finish_program_and_get_row_count(statement) + 1; 230 } 231 LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + numRows, i, value); 232 } else if (type == SQLITE_FLOAT) { 233 // FLOAT data 234 double value = sqlite3_column_double(statement, i); 235 if (!window->putDouble(numRows, i, value)) { 236 window->freeLastRow(); 237 LOGE("Failed allocating space for a double in column %d", i); 238 return startPos + numRows + finish_program_and_get_row_count(statement) + 1; 239 } 240 LOG_WINDOW("%d,%d is FLOAT %lf", startPos + numRows, i, value); 241 } else if (type == SQLITE_BLOB) { 242 // BLOB data 243 uint8_t const * blob = (uint8_t const *)sqlite3_column_blob(statement, i); 244 size_t size = sqlite3_column_bytes16(statement, i); 245 int offset = window->alloc(size); 246 if (!offset) { 247 window->freeLastRow(); 248 LOGE("Failed allocating %u bytes for blob at %d,%d", size, 249 startPos + numRows, i); 250 return startPos + numRows + finish_program_and_get_row_count(statement) + 1; 251 } 252 253 window->copyIn(offset, blob, size); 254 255 // This must be updated after the call to alloc(), since that 256 // may move the field around in the window 257 field_slot_t * fieldSlot = window->getFieldSlot(numRows, i); 258 fieldSlot->type = FIELD_TYPE_BLOB; 259 fieldSlot->data.buffer.offset = offset; 260 fieldSlot->data.buffer.size = size; 261 262 LOG_WINDOW("%d,%d is Blob with %u bytes @ %d", startPos + numRows, i, size, offset); 263 } else if (type == SQLITE_NULL) { 264 // NULL field 265 window->putNull(numRows, i); 266 267 LOG_WINDOW("%d,%d is NULL", startPos + numRows, i); 268 } else { 269 // Unknown data 270 LOGE("Unknown column type when filling database window"); 271 throw_sqlite3_exception(env, "Unknown column type when filling window"); 272 break; 273 } 274 } 275 276 if (i < numColumns) { 277 // Not all the fields fit in the window 278 // Unknown data error happened 279 break; 280 } 281 282 // Mark the row as complete in the window 283 numRows++; 284 } else if (err == SQLITE_DONE) { 285 // All rows processed, bail 286 LOG_WINDOW("Processed all rows"); 287 break; 288 } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) { 289 // The table is locked, retry 290 LOG_WINDOW("Database locked, retrying"); 291 if (retryCount > 50) { 292 LOGE("Bailing on database busy rety"); 293 break; 294 } 295 296 // Sleep to give the thread holding the lock a chance to finish 297 usleep(1000); 298 299 retryCount++; 300 continue; 301 } else { 302 throw_sqlite3_exception(env, GET_HANDLE(env, object)); 303 break; 304 } 305 } 306 307 LOG_WINDOW("Resetting statement %p after fetching %d rows in %d bytes\n\n\n\n", statement, 308 numRows, window->size() - window->freeSpace()); 309// LOGI("Filled window with %d rows in %d bytes", numRows, window->size() - window->freeSpace()); 310 if (err == SQLITE_ROW) { 311 return -1; 312 } else { 313 sqlite3_reset(statement); 314 return startPos + numRows; 315 } 316} 317 318static jint native_column_count(JNIEnv* env, jobject object) 319{ 320 sqlite3_stmt * statement = GET_STATEMENT(env, object); 321 322 return sqlite3_column_count(statement); 323} 324 325static jstring native_column_name(JNIEnv* env, jobject object, jint columnIndex) 326{ 327 sqlite3_stmt * statement = GET_STATEMENT(env, object); 328 char const * name; 329 330 name = sqlite3_column_name(statement, columnIndex); 331 332 return env->NewStringUTF(name); 333} 334 335 336static JNINativeMethod sMethods[] = 337{ 338 /* name, signature, funcPtr */ 339 {"native_fill_window", "(Landroid/database/CursorWindow;IIII)I", (void *)native_fill_window}, 340 {"native_column_count", "()I", (void*)native_column_count}, 341 {"native_column_name", "(I)Ljava/lang/String;", (void *)native_column_name}, 342}; 343 344int register_android_database_SQLiteQuery(JNIEnv * env) 345{ 346 jclass clazz; 347 348 clazz = env->FindClass("android/database/sqlite/SQLiteQuery"); 349 if (clazz == NULL) { 350 LOGE("Can't find android/database/sqlite/SQLiteQuery"); 351 return -1; 352 } 353 354 gHandleField = env->GetFieldID(clazz, "nHandle", "I"); 355 gStatementField = env->GetFieldID(clazz, "nStatement", "I"); 356 357 if (gHandleField == NULL || gStatementField == NULL) { 358 LOGE("Error locating fields"); 359 return -1; 360 } 361 362 return AndroidRuntime::registerNativeMethods(env, 363 "android/database/sqlite/SQLiteQuery", sMethods, NELEM(sMethods)); 364} 365 366} // namespace android 367