• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2011 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 #define LOG_TAG "SQLiteConnection"
18 
19 #include <jni.h>
20 #include <JNIHelp.h>
21 #include <android_runtime/AndroidRuntime.h>
22 #include <android_runtime/Log.h>
23 
24 #include <utils/Log.h>
25 #include <utils/String8.h>
26 #include <utils/String16.h>
27 #include <cutils/ashmem.h>
28 #include <sys/mman.h>
29 
30 #include <string.h>
31 #include <unistd.h>
32 
33 #include <androidfw/CursorWindow.h>
34 
35 #include <sqlite3.h>
36 #include <sqlite3_android.h>
37 
38 #include "android_database_SQLiteCommon.h"
39 
40 // Set to 1 to use UTF16 storage for localized indexes.
41 #define UTF16_STORAGE 0
42 
43 namespace android {
44 
45 /* Busy timeout in milliseconds.
46  * If another connection (possibly in another process) has the database locked for
47  * longer than this amount of time then SQLite will generate a SQLITE_BUSY error.
48  * The SQLITE_BUSY error is then raised as a SQLiteDatabaseLockedException.
49  *
50  * In ordinary usage, busy timeouts are quite rare.  Most databases only ever
51  * have a single open connection at a time unless they are using WAL.  When using
52  * WAL, a timeout could occur if one connection is busy performing an auto-checkpoint
53  * operation.  The busy timeout needs to be long enough to tolerate slow I/O write
54  * operations but not so long as to cause the application to hang indefinitely if
55  * there is a problem acquiring a database lock.
56  */
57 static const int BUSY_TIMEOUT_MS = 2500;
58 
59 static struct {
60     jfieldID name;
61     jfieldID numArgs;
62     jmethodID dispatchCallback;
63 } gSQLiteCustomFunctionClassInfo;
64 
65 static struct {
66     jclass clazz;
67 } gStringClassInfo;
68 
69 struct SQLiteConnection {
70     // Open flags.
71     // Must be kept in sync with the constants defined in SQLiteDatabase.java.
72     enum {
73         OPEN_READWRITE          = 0x00000000,
74         OPEN_READONLY           = 0x00000001,
75         OPEN_READ_MASK          = 0x00000001,
76         NO_LOCALIZED_COLLATORS  = 0x00000010,
77         CREATE_IF_NECESSARY     = 0x10000000,
78     };
79 
80     sqlite3* const db;
81     const int openFlags;
82     const String8 path;
83     const String8 label;
84 
85     volatile bool canceled;
86 
SQLiteConnectionandroid::SQLiteConnection87     SQLiteConnection(sqlite3* db, int openFlags, const String8& path, const String8& label) :
88         db(db), openFlags(openFlags), path(path), label(label), canceled(false) { }
89 };
90 
91 // Called each time a statement begins execution, when tracing is enabled.
sqliteTraceCallback(void * data,const char * sql)92 static void sqliteTraceCallback(void *data, const char *sql) {
93     SQLiteConnection* connection = static_cast<SQLiteConnection*>(data);
94     ALOG(LOG_VERBOSE, SQLITE_TRACE_TAG, "%s: \"%s\"\n",
95             connection->label.string(), sql);
96 }
97 
98 // Called each time a statement finishes execution, when profiling is enabled.
sqliteProfileCallback(void * data,const char * sql,sqlite3_uint64 tm)99 static void sqliteProfileCallback(void *data, const char *sql, sqlite3_uint64 tm) {
100     SQLiteConnection* connection = static_cast<SQLiteConnection*>(data);
101     ALOG(LOG_VERBOSE, SQLITE_PROFILE_TAG, "%s: \"%s\" took %0.3f ms\n",
102             connection->label.string(), sql, tm * 0.000001f);
103 }
104 
105 // Called after each SQLite VM instruction when cancelation is enabled.
sqliteProgressHandlerCallback(void * data)106 static int sqliteProgressHandlerCallback(void* data) {
107     SQLiteConnection* connection = static_cast<SQLiteConnection*>(data);
108     return connection->canceled;
109 }
110 
111 
nativeOpen(JNIEnv * env,jclass clazz,jstring pathStr,jint openFlags,jstring labelStr,jboolean enableTrace,jboolean enableProfile)112 static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags,
113         jstring labelStr, jboolean enableTrace, jboolean enableProfile) {
114     int sqliteFlags;
115     if (openFlags & SQLiteConnection::CREATE_IF_NECESSARY) {
116         sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
117     } else if (openFlags & SQLiteConnection::OPEN_READONLY) {
118         sqliteFlags = SQLITE_OPEN_READONLY;
119     } else {
120         sqliteFlags = SQLITE_OPEN_READWRITE;
121     }
122 
123     const char* pathChars = env->GetStringUTFChars(pathStr, NULL);
124     String8 path(pathChars);
125     env->ReleaseStringUTFChars(pathStr, pathChars);
126 
127     const char* labelChars = env->GetStringUTFChars(labelStr, NULL);
128     String8 label(labelChars);
129     env->ReleaseStringUTFChars(labelStr, labelChars);
130 
131     sqlite3* db;
132     int err = sqlite3_open_v2(path.string(), &db, sqliteFlags, NULL);
133     if (err != SQLITE_OK) {
134         throw_sqlite3_exception_errcode(env, err, "Could not open database");
135         return 0;
136     }
137 
138     // Check that the database is really read/write when that is what we asked for.
139     if ((sqliteFlags & SQLITE_OPEN_READWRITE) && sqlite3_db_readonly(db, NULL)) {
140         throw_sqlite3_exception(env, db, "Could not open the database in read/write mode.");
141         sqlite3_close(db);
142         return 0;
143     }
144 
145     // Set the default busy handler to retry automatically before returning SQLITE_BUSY.
146     err = sqlite3_busy_timeout(db, BUSY_TIMEOUT_MS);
147     if (err != SQLITE_OK) {
148         throw_sqlite3_exception(env, db, "Could not set busy timeout");
149         sqlite3_close(db);
150         return 0;
151     }
152 
153     // Register custom Android functions.
154     err = register_android_functions(db, UTF16_STORAGE);
155     if (err) {
156         throw_sqlite3_exception(env, db, "Could not register Android SQL functions.");
157         sqlite3_close(db);
158         return 0;
159     }
160 
161     // Create wrapper object.
162     SQLiteConnection* connection = new SQLiteConnection(db, openFlags, path, label);
163 
164     // Enable tracing and profiling if requested.
165     if (enableTrace) {
166         sqlite3_trace(db, &sqliteTraceCallback, connection);
167     }
168     if (enableProfile) {
169         sqlite3_profile(db, &sqliteProfileCallback, connection);
170     }
171 
172     ALOGV("Opened connection %p with label '%s'", db, label.string());
173     return reinterpret_cast<jint>(connection);
174 }
175 
nativeClose(JNIEnv * env,jclass clazz,jint connectionPtr)176 static void nativeClose(JNIEnv* env, jclass clazz, jint connectionPtr) {
177     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
178 
179     if (connection) {
180         ALOGV("Closing connection %p", connection->db);
181         int err = sqlite3_close(connection->db);
182         if (err != SQLITE_OK) {
183             // This can happen if sub-objects aren't closed first.  Make sure the caller knows.
184             ALOGE("sqlite3_close(%p) failed: %d", connection->db, err);
185             throw_sqlite3_exception(env, connection->db, "Count not close db.");
186             return;
187         }
188 
189         delete connection;
190     }
191 }
192 
193 // Called each time a custom function is evaluated.
sqliteCustomFunctionCallback(sqlite3_context * context,int argc,sqlite3_value ** argv)194 static void sqliteCustomFunctionCallback(sqlite3_context *context,
195         int argc, sqlite3_value **argv) {
196     JNIEnv* env = AndroidRuntime::getJNIEnv();
197 
198     // Get the callback function object.
199     // Create a new local reference to it in case the callback tries to do something
200     // dumb like unregister the function (thereby destroying the global ref) while it is running.
201     jobject functionObjGlobal = reinterpret_cast<jobject>(sqlite3_user_data(context));
202     jobject functionObj = env->NewLocalRef(functionObjGlobal);
203 
204     jobjectArray argsArray = env->NewObjectArray(argc, gStringClassInfo.clazz, NULL);
205     if (argsArray) {
206         for (int i = 0; i < argc; i++) {
207             const jchar* arg = static_cast<const jchar*>(sqlite3_value_text16(argv[i]));
208             if (!arg) {
209                 ALOGW("NULL argument in custom_function_callback.  This should not happen.");
210             } else {
211                 size_t argLen = sqlite3_value_bytes16(argv[i]) / sizeof(jchar);
212                 jstring argStr = env->NewString(arg, argLen);
213                 if (!argStr) {
214                     goto error; // out of memory error
215                 }
216                 env->SetObjectArrayElement(argsArray, i, argStr);
217                 env->DeleteLocalRef(argStr);
218             }
219         }
220 
221         // TODO: Support functions that return values.
222         env->CallVoidMethod(functionObj,
223                 gSQLiteCustomFunctionClassInfo.dispatchCallback, argsArray);
224 
225 error:
226         env->DeleteLocalRef(argsArray);
227     }
228 
229     env->DeleteLocalRef(functionObj);
230 
231     if (env->ExceptionCheck()) {
232         ALOGE("An exception was thrown by custom SQLite function.");
233         LOGE_EX(env);
234         env->ExceptionClear();
235     }
236 }
237 
238 // Called when a custom function is destroyed.
sqliteCustomFunctionDestructor(void * data)239 static void sqliteCustomFunctionDestructor(void* data) {
240     jobject functionObjGlobal = reinterpret_cast<jobject>(data);
241 
242     JNIEnv* env = AndroidRuntime::getJNIEnv();
243     env->DeleteGlobalRef(functionObjGlobal);
244 }
245 
nativeRegisterCustomFunction(JNIEnv * env,jclass clazz,jint connectionPtr,jobject functionObj)246 static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jint connectionPtr,
247         jobject functionObj) {
248     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
249 
250     jstring nameStr = jstring(env->GetObjectField(
251             functionObj, gSQLiteCustomFunctionClassInfo.name));
252     jint numArgs = env->GetIntField(functionObj, gSQLiteCustomFunctionClassInfo.numArgs);
253 
254     jobject functionObjGlobal = env->NewGlobalRef(functionObj);
255 
256     const char* name = env->GetStringUTFChars(nameStr, NULL);
257     int err = sqlite3_create_function_v2(connection->db, name, numArgs, SQLITE_UTF16,
258             reinterpret_cast<void*>(functionObjGlobal),
259             &sqliteCustomFunctionCallback, NULL, NULL, &sqliteCustomFunctionDestructor);
260     env->ReleaseStringUTFChars(nameStr, name);
261 
262     if (err != SQLITE_OK) {
263         ALOGE("sqlite3_create_function returned %d", err);
264         env->DeleteGlobalRef(functionObjGlobal);
265         throw_sqlite3_exception(env, connection->db);
266         return;
267     }
268 }
269 
nativeRegisterLocalizedCollators(JNIEnv * env,jclass clazz,jint connectionPtr,jstring localeStr)270 static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jint connectionPtr,
271         jstring localeStr) {
272     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
273 
274     const char* locale = env->GetStringUTFChars(localeStr, NULL);
275     int err = register_localized_collators(connection->db, locale, UTF16_STORAGE);
276     env->ReleaseStringUTFChars(localeStr, locale);
277 
278     if (err != SQLITE_OK) {
279         throw_sqlite3_exception(env, connection->db);
280     }
281 }
282 
nativePrepareStatement(JNIEnv * env,jclass clazz,jint connectionPtr,jstring sqlString)283 static jint nativePrepareStatement(JNIEnv* env, jclass clazz, jint connectionPtr,
284         jstring sqlString) {
285     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
286 
287     jsize sqlLength = env->GetStringLength(sqlString);
288     const jchar* sql = env->GetStringCritical(sqlString, NULL);
289     sqlite3_stmt* statement;
290     int err = sqlite3_prepare16_v2(connection->db,
291             sql, sqlLength * sizeof(jchar), &statement, NULL);
292     env->ReleaseStringCritical(sqlString, sql);
293 
294     if (err != SQLITE_OK) {
295         // Error messages like 'near ")": syntax error' are not
296         // always helpful enough, so construct an error string that
297         // includes the query itself.
298         const char *query = env->GetStringUTFChars(sqlString, NULL);
299         char *message = (char*) malloc(strlen(query) + 50);
300         if (message) {
301             strcpy(message, ", while compiling: "); // less than 50 chars
302             strcat(message, query);
303         }
304         env->ReleaseStringUTFChars(sqlString, query);
305         throw_sqlite3_exception(env, connection->db, message);
306         free(message);
307         return 0;
308     }
309 
310     ALOGV("Prepared statement %p on connection %p", statement, connection->db);
311     return reinterpret_cast<jint>(statement);
312 }
313 
nativeFinalizeStatement(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)314 static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jint connectionPtr,
315         jint statementPtr) {
316     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
317     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
318 
319     // We ignore the result of sqlite3_finalize because it is really telling us about
320     // whether any errors occurred while executing the statement.  The statement itself
321     // is always finalized regardless.
322     ALOGV("Finalized statement %p on connection %p", statement, connection->db);
323     sqlite3_finalize(statement);
324 }
325 
nativeGetParameterCount(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)326 static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jint connectionPtr,
327         jint statementPtr) {
328     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
329     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
330 
331     return sqlite3_bind_parameter_count(statement);
332 }
333 
nativeIsReadOnly(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)334 static jboolean nativeIsReadOnly(JNIEnv* env, jclass clazz, jint connectionPtr,
335         jint statementPtr) {
336     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
337     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
338 
339     return sqlite3_stmt_readonly(statement) != 0;
340 }
341 
nativeGetColumnCount(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)342 static jint nativeGetColumnCount(JNIEnv* env, jclass clazz, jint connectionPtr,
343         jint statementPtr) {
344     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
345     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
346 
347     return sqlite3_column_count(statement);
348 }
349 
nativeGetColumnName(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr,jint index)350 static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jint connectionPtr,
351         jint statementPtr, jint index) {
352     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
353     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
354 
355     const jchar* name = static_cast<const jchar*>(sqlite3_column_name16(statement, index));
356     if (name) {
357         size_t length = 0;
358         while (name[length]) {
359             length += 1;
360         }
361         return env->NewString(name, length);
362     }
363     return NULL;
364 }
365 
nativeBindNull(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr,jint index)366 static void nativeBindNull(JNIEnv* env, jclass clazz, jint connectionPtr,
367         jint statementPtr, jint index) {
368     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
369     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
370 
371     int err = sqlite3_bind_null(statement, index);
372     if (err != SQLITE_OK) {
373         throw_sqlite3_exception(env, connection->db, NULL);
374     }
375 }
376 
nativeBindLong(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr,jint index,jlong value)377 static void nativeBindLong(JNIEnv* env, jclass clazz, jint connectionPtr,
378         jint statementPtr, jint index, jlong value) {
379     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
380     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
381 
382     int err = sqlite3_bind_int64(statement, index, value);
383     if (err != SQLITE_OK) {
384         throw_sqlite3_exception(env, connection->db, NULL);
385     }
386 }
387 
nativeBindDouble(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr,jint index,jdouble value)388 static void nativeBindDouble(JNIEnv* env, jclass clazz, jint connectionPtr,
389         jint statementPtr, jint index, jdouble value) {
390     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
391     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
392 
393     int err = sqlite3_bind_double(statement, index, value);
394     if (err != SQLITE_OK) {
395         throw_sqlite3_exception(env, connection->db, NULL);
396     }
397 }
398 
nativeBindString(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr,jint index,jstring valueString)399 static void nativeBindString(JNIEnv* env, jclass clazz, jint connectionPtr,
400         jint statementPtr, jint index, jstring valueString) {
401     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
402     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
403 
404     jsize valueLength = env->GetStringLength(valueString);
405     const jchar* value = env->GetStringCritical(valueString, NULL);
406     int err = sqlite3_bind_text16(statement, index, value, valueLength * sizeof(jchar),
407             SQLITE_TRANSIENT);
408     env->ReleaseStringCritical(valueString, value);
409     if (err != SQLITE_OK) {
410         throw_sqlite3_exception(env, connection->db, NULL);
411     }
412 }
413 
nativeBindBlob(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr,jint index,jbyteArray valueArray)414 static void nativeBindBlob(JNIEnv* env, jclass clazz, jint connectionPtr,
415         jint statementPtr, jint index, jbyteArray valueArray) {
416     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
417     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
418 
419     jsize valueLength = env->GetArrayLength(valueArray);
420     jbyte* value = static_cast<jbyte*>(env->GetPrimitiveArrayCritical(valueArray, NULL));
421     int err = sqlite3_bind_blob(statement, index, value, valueLength, SQLITE_TRANSIENT);
422     env->ReleasePrimitiveArrayCritical(valueArray, value, JNI_ABORT);
423     if (err != SQLITE_OK) {
424         throw_sqlite3_exception(env, connection->db, NULL);
425     }
426 }
427 
nativeResetStatementAndClearBindings(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)428 static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jint connectionPtr,
429         jint statementPtr) {
430     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
431     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
432 
433     int err = sqlite3_reset(statement);
434     if (err == SQLITE_OK) {
435         err = sqlite3_clear_bindings(statement);
436     }
437     if (err != SQLITE_OK) {
438         throw_sqlite3_exception(env, connection->db, NULL);
439     }
440 }
441 
executeNonQuery(JNIEnv * env,SQLiteConnection * connection,sqlite3_stmt * statement)442 static int executeNonQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement) {
443     int err = sqlite3_step(statement);
444     if (err == SQLITE_ROW) {
445         throw_sqlite3_exception(env,
446                 "Queries can be performed using SQLiteDatabase query or rawQuery methods only.");
447     } else if (err != SQLITE_DONE) {
448         throw_sqlite3_exception(env, connection->db);
449     }
450     return err;
451 }
452 
nativeExecute(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)453 static void nativeExecute(JNIEnv* env, jclass clazz, jint connectionPtr,
454         jint statementPtr) {
455     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
456     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
457 
458     executeNonQuery(env, connection, statement);
459 }
460 
nativeExecuteForChangedRowCount(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)461 static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz,
462         jint connectionPtr, jint statementPtr) {
463     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
464     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
465 
466     int err = executeNonQuery(env, connection, statement);
467     return err == SQLITE_DONE ? sqlite3_changes(connection->db) : -1;
468 }
469 
nativeExecuteForLastInsertedRowId(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)470 static jlong nativeExecuteForLastInsertedRowId(JNIEnv* env, jclass clazz,
471         jint connectionPtr, jint statementPtr) {
472     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
473     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
474 
475     int err = executeNonQuery(env, connection, statement);
476     return err == SQLITE_DONE && sqlite3_changes(connection->db) > 0
477             ? sqlite3_last_insert_rowid(connection->db) : -1;
478 }
479 
executeOneRowQuery(JNIEnv * env,SQLiteConnection * connection,sqlite3_stmt * statement)480 static int executeOneRowQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement) {
481     int err = sqlite3_step(statement);
482     if (err != SQLITE_ROW) {
483         throw_sqlite3_exception(env, connection->db);
484     }
485     return err;
486 }
487 
nativeExecuteForLong(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)488 static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz,
489         jint connectionPtr, jint statementPtr) {
490     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
491     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
492 
493     int err = executeOneRowQuery(env, connection, statement);
494     if (err == SQLITE_ROW && sqlite3_column_count(statement) >= 1) {
495         return sqlite3_column_int64(statement, 0);
496     }
497     return -1;
498 }
499 
nativeExecuteForString(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)500 static jstring nativeExecuteForString(JNIEnv* env, jclass clazz,
501         jint connectionPtr, jint statementPtr) {
502     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
503     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
504 
505     int err = executeOneRowQuery(env, connection, statement);
506     if (err == SQLITE_ROW && sqlite3_column_count(statement) >= 1) {
507         const jchar* text = static_cast<const jchar*>(sqlite3_column_text16(statement, 0));
508         if (text) {
509             size_t length = sqlite3_column_bytes16(statement, 0) / sizeof(jchar);
510             return env->NewString(text, length);
511         }
512     }
513     return NULL;
514 }
515 
createAshmemRegionWithData(JNIEnv * env,const void * data,size_t length)516 static int createAshmemRegionWithData(JNIEnv* env, const void* data, size_t length) {
517     int error = 0;
518     int fd = ashmem_create_region(NULL, length);
519     if (fd < 0) {
520         error = errno;
521         ALOGE("ashmem_create_region failed: %s", strerror(error));
522     } else {
523         if (length > 0) {
524             void* ptr = mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
525             if (ptr == MAP_FAILED) {
526                 error = errno;
527                 ALOGE("mmap failed: %s", strerror(error));
528             } else {
529                 memcpy(ptr, data, length);
530                 munmap(ptr, length);
531             }
532         }
533 
534         if (!error) {
535             if (ashmem_set_prot_region(fd, PROT_READ) < 0) {
536                 error = errno;
537                 ALOGE("ashmem_set_prot_region failed: %s", strerror(errno));
538             } else {
539                 return fd;
540             }
541         }
542 
543         close(fd);
544     }
545 
546     jniThrowIOException(env, error);
547     return -1;
548 }
549 
nativeExecuteForBlobFileDescriptor(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr)550 static jint nativeExecuteForBlobFileDescriptor(JNIEnv* env, jclass clazz,
551         jint connectionPtr, jint statementPtr) {
552     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
553     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
554 
555     int err = executeOneRowQuery(env, connection, statement);
556     if (err == SQLITE_ROW && sqlite3_column_count(statement) >= 1) {
557         const void* blob = sqlite3_column_blob(statement, 0);
558         if (blob) {
559             int length = sqlite3_column_bytes(statement, 0);
560             if (length >= 0) {
561                 return createAshmemRegionWithData(env, blob, length);
562             }
563         }
564     }
565     return -1;
566 }
567 
568 enum CopyRowResult {
569     CPR_OK,
570     CPR_FULL,
571     CPR_ERROR,
572 };
573 
copyRow(JNIEnv * env,CursorWindow * window,sqlite3_stmt * statement,int numColumns,int startPos,int addedRows)574 static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window,
575         sqlite3_stmt* statement, int numColumns, int startPos, int addedRows) {
576     // Allocate a new field directory for the row.
577     status_t status = window->allocRow();
578     if (status) {
579         LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
580                 startPos, addedRows, status);
581         return CPR_FULL;
582     }
583 
584     // Pack the row into the window.
585     CopyRowResult result = CPR_OK;
586     for (int i = 0; i < numColumns; i++) {
587         int type = sqlite3_column_type(statement, i);
588         if (type == SQLITE_TEXT) {
589             // TEXT data
590             const char* text = reinterpret_cast<const char*>(
591                     sqlite3_column_text(statement, i));
592             // SQLite does not include the NULL terminator in size, but does
593             // ensure all strings are NULL terminated, so increase size by
594             // one to make sure we store the terminator.
595             size_t sizeIncludingNull = sqlite3_column_bytes(statement, i) + 1;
596             status = window->putString(addedRows, i, text, sizeIncludingNull);
597             if (status) {
598                 LOG_WINDOW("Failed allocating %u bytes for text at %d,%d, error=%d",
599                         sizeIncludingNull, startPos + addedRows, i, status);
600                 result = CPR_FULL;
601                 break;
602             }
603             LOG_WINDOW("%d,%d is TEXT with %u bytes",
604                     startPos + addedRows, i, sizeIncludingNull);
605         } else if (type == SQLITE_INTEGER) {
606             // INTEGER data
607             int64_t value = sqlite3_column_int64(statement, i);
608             status = window->putLong(addedRows, i, value);
609             if (status) {
610                 LOG_WINDOW("Failed allocating space for a long in column %d, error=%d",
611                         i, status);
612                 result = CPR_FULL;
613                 break;
614             }
615             LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + addedRows, i, value);
616         } else if (type == SQLITE_FLOAT) {
617             // FLOAT data
618             double value = sqlite3_column_double(statement, i);
619             status = window->putDouble(addedRows, i, value);
620             if (status) {
621                 LOG_WINDOW("Failed allocating space for a double in column %d, error=%d",
622                         i, status);
623                 result = CPR_FULL;
624                 break;
625             }
626             LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value);
627         } else if (type == SQLITE_BLOB) {
628             // BLOB data
629             const void* blob = sqlite3_column_blob(statement, i);
630             size_t size = sqlite3_column_bytes(statement, i);
631             status = window->putBlob(addedRows, i, blob, size);
632             if (status) {
633                 LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d, error=%d",
634                         size, startPos + addedRows, i, status);
635                 result = CPR_FULL;
636                 break;
637             }
638             LOG_WINDOW("%d,%d is Blob with %u bytes",
639                     startPos + addedRows, i, size);
640         } else if (type == SQLITE_NULL) {
641             // NULL field
642             status = window->putNull(addedRows, i);
643             if (status) {
644                 LOG_WINDOW("Failed allocating space for a null in column %d, error=%d",
645                         i, status);
646                 result = CPR_FULL;
647                 break;
648             }
649 
650             LOG_WINDOW("%d,%d is NULL", startPos + addedRows, i);
651         } else {
652             // Unknown data
653             ALOGE("Unknown column type when filling database window");
654             throw_sqlite3_exception(env, "Unknown column type when filling window");
655             result = CPR_ERROR;
656             break;
657         }
658     }
659 
660     // Free the last row if if was not successfully copied.
661     if (result != CPR_OK) {
662         window->freeLastRow();
663     }
664     return result;
665 }
666 
nativeExecuteForCursorWindow(JNIEnv * env,jclass clazz,jint connectionPtr,jint statementPtr,jint windowPtr,jint startPos,jint requiredPos,jboolean countAllRows)667 static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz,
668         jint connectionPtr, jint statementPtr, jint windowPtr,
669         jint startPos, jint requiredPos, jboolean countAllRows) {
670     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
671     sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
672     CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
673 
674     status_t status = window->clear();
675     if (status) {
676         String8 msg;
677         msg.appendFormat("Failed to clear the cursor window, status=%d", status);
678         throw_sqlite3_exception(env, connection->db, msg.string());
679         return 0;
680     }
681 
682     int numColumns = sqlite3_column_count(statement);
683     status = window->setNumColumns(numColumns);
684     if (status) {
685         String8 msg;
686         msg.appendFormat("Failed to set the cursor window column count to %d, status=%d",
687                 numColumns, status);
688         throw_sqlite3_exception(env, connection->db, msg.string());
689         return 0;
690     }
691 
692     int retryCount = 0;
693     int totalRows = 0;
694     int addedRows = 0;
695     bool windowFull = false;
696     bool gotException = false;
697     while (!gotException && (!windowFull || countAllRows)) {
698         int err = sqlite3_step(statement);
699         if (err == SQLITE_ROW) {
700             LOG_WINDOW("Stepped statement %p to row %d", statement, totalRows);
701             retryCount = 0;
702             totalRows += 1;
703 
704             // Skip the row if the window is full or we haven't reached the start position yet.
705             if (startPos >= totalRows || windowFull) {
706                 continue;
707             }
708 
709             CopyRowResult cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
710             if (cpr == CPR_FULL && addedRows && startPos + addedRows <= requiredPos) {
711                 // We filled the window before we got to the one row that we really wanted.
712                 // Clear the window and start filling it again from here.
713                 // TODO: Would be nicer if we could progressively replace earlier rows.
714                 window->clear();
715                 window->setNumColumns(numColumns);
716                 startPos += addedRows;
717                 addedRows = 0;
718                 cpr = copyRow(env, window, statement, numColumns, startPos, addedRows);
719             }
720 
721             if (cpr == CPR_OK) {
722                 addedRows += 1;
723             } else if (cpr == CPR_FULL) {
724                 windowFull = true;
725             } else {
726                 gotException = true;
727             }
728         } else if (err == SQLITE_DONE) {
729             // All rows processed, bail
730             LOG_WINDOW("Processed all rows");
731             break;
732         } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) {
733             // The table is locked, retry
734             LOG_WINDOW("Database locked, retrying");
735             if (retryCount > 50) {
736                 ALOGE("Bailing on database busy retry");
737                 throw_sqlite3_exception(env, connection->db, "retrycount exceeded");
738                 gotException = true;
739             } else {
740                 // Sleep to give the thread holding the lock a chance to finish
741                 usleep(1000);
742                 retryCount++;
743             }
744         } else {
745             throw_sqlite3_exception(env, connection->db);
746             gotException = true;
747         }
748     }
749 
750     LOG_WINDOW("Resetting statement %p after fetching %d rows and adding %d rows"
751             "to the window in %d bytes",
752             statement, totalRows, addedRows, window->size() - window->freeSpace());
753     sqlite3_reset(statement);
754 
755     // Report the total number of rows on request.
756     if (startPos > totalRows) {
757         ALOGE("startPos %d > actual rows %d", startPos, totalRows);
758     }
759     jlong result = jlong(startPos) << 32 | jlong(totalRows);
760     return result;
761 }
762 
nativeGetDbLookaside(JNIEnv * env,jobject clazz,jint connectionPtr)763 static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jint connectionPtr) {
764     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
765 
766     int cur = -1;
767     int unused;
768     sqlite3_db_status(connection->db, SQLITE_DBSTATUS_LOOKASIDE_USED, &cur, &unused, 0);
769     return cur;
770 }
771 
nativeCancel(JNIEnv * env,jobject clazz,jint connectionPtr)772 static void nativeCancel(JNIEnv* env, jobject clazz, jint connectionPtr) {
773     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
774     connection->canceled = true;
775 }
776 
nativeResetCancel(JNIEnv * env,jobject clazz,jint connectionPtr,jboolean cancelable)777 static void nativeResetCancel(JNIEnv* env, jobject clazz, jint connectionPtr,
778         jboolean cancelable) {
779     SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
780     connection->canceled = false;
781 
782     if (cancelable) {
783         sqlite3_progress_handler(connection->db, 4, sqliteProgressHandlerCallback,
784                 connection);
785     } else {
786         sqlite3_progress_handler(connection->db, 0, NULL, NULL);
787     }
788 }
789 
790 
791 static JNINativeMethod sMethods[] =
792 {
793     /* name, signature, funcPtr */
794     { "nativeOpen", "(Ljava/lang/String;ILjava/lang/String;ZZ)I",
795             (void*)nativeOpen },
796     { "nativeClose", "(I)V",
797             (void*)nativeClose },
798     { "nativeRegisterCustomFunction", "(ILandroid/database/sqlite/SQLiteCustomFunction;)V",
799             (void*)nativeRegisterCustomFunction },
800     { "nativeRegisterLocalizedCollators", "(ILjava/lang/String;)V",
801             (void*)nativeRegisterLocalizedCollators },
802     { "nativePrepareStatement", "(ILjava/lang/String;)I",
803             (void*)nativePrepareStatement },
804     { "nativeFinalizeStatement", "(II)V",
805             (void*)nativeFinalizeStatement },
806     { "nativeGetParameterCount", "(II)I",
807             (void*)nativeGetParameterCount },
808     { "nativeIsReadOnly", "(II)Z",
809             (void*)nativeIsReadOnly },
810     { "nativeGetColumnCount", "(II)I",
811             (void*)nativeGetColumnCount },
812     { "nativeGetColumnName", "(III)Ljava/lang/String;",
813             (void*)nativeGetColumnName },
814     { "nativeBindNull", "(III)V",
815             (void*)nativeBindNull },
816     { "nativeBindLong", "(IIIJ)V",
817             (void*)nativeBindLong },
818     { "nativeBindDouble", "(IIID)V",
819             (void*)nativeBindDouble },
820     { "nativeBindString", "(IIILjava/lang/String;)V",
821             (void*)nativeBindString },
822     { "nativeBindBlob", "(III[B)V",
823             (void*)nativeBindBlob },
824     { "nativeResetStatementAndClearBindings", "(II)V",
825             (void*)nativeResetStatementAndClearBindings },
826     { "nativeExecute", "(II)V",
827             (void*)nativeExecute },
828     { "nativeExecuteForLong", "(II)J",
829             (void*)nativeExecuteForLong },
830     { "nativeExecuteForString", "(II)Ljava/lang/String;",
831             (void*)nativeExecuteForString },
832     { "nativeExecuteForBlobFileDescriptor", "(II)I",
833             (void*)nativeExecuteForBlobFileDescriptor },
834     { "nativeExecuteForChangedRowCount", "(II)I",
835             (void*)nativeExecuteForChangedRowCount },
836     { "nativeExecuteForLastInsertedRowId", "(II)J",
837             (void*)nativeExecuteForLastInsertedRowId },
838     { "nativeExecuteForCursorWindow", "(IIIIIZ)J",
839             (void*)nativeExecuteForCursorWindow },
840     { "nativeGetDbLookaside", "(I)I",
841             (void*)nativeGetDbLookaside },
842     { "nativeCancel", "(I)V",
843             (void*)nativeCancel },
844     { "nativeResetCancel", "(IZ)V",
845             (void*)nativeResetCancel },
846 };
847 
848 #define FIND_CLASS(var, className) \
849         var = env->FindClass(className); \
850         LOG_FATAL_IF(! var, "Unable to find class " className);
851 
852 #define GET_METHOD_ID(var, clazz, methodName, fieldDescriptor) \
853         var = env->GetMethodID(clazz, methodName, fieldDescriptor); \
854         LOG_FATAL_IF(! var, "Unable to find method" methodName);
855 
856 #define GET_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
857         var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
858         LOG_FATAL_IF(! var, "Unable to find field " fieldName);
859 
register_android_database_SQLiteConnection(JNIEnv * env)860 int register_android_database_SQLiteConnection(JNIEnv *env)
861 {
862     jclass clazz;
863     FIND_CLASS(clazz, "android/database/sqlite/SQLiteCustomFunction");
864 
865     GET_FIELD_ID(gSQLiteCustomFunctionClassInfo.name, clazz,
866             "name", "Ljava/lang/String;");
867     GET_FIELD_ID(gSQLiteCustomFunctionClassInfo.numArgs, clazz,
868             "numArgs", "I");
869     GET_METHOD_ID(gSQLiteCustomFunctionClassInfo.dispatchCallback,
870             clazz, "dispatchCallback", "([Ljava/lang/String;)V");
871 
872     FIND_CLASS(clazz, "java/lang/String");
873     gStringClassInfo.clazz = jclass(env->NewGlobalRef(clazz));
874 
875     return AndroidRuntime::registerNativeMethods(env, "android/database/sqlite/SQLiteConnection",
876             sMethods, NELEM(sMethods));
877 }
878 
879 } // namespace android
880