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 "SqliteCursor.cpp"
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 "binder/CursorWindow.h"
33#include "sqlite3_exception.h"
34
35
36namespace android {
37
38static jint nativeFillWindow(JNIEnv* env, jclass clazz, jint databasePtr,
39        jint statementPtr, jint windowPtr, jint startPos, jint offsetParam) {
40    sqlite3* database = reinterpret_cast<sqlite3*>(databasePtr);
41    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
42    CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
43
44    // Only do the binding if there is a valid offsetParam. If no binding needs to be done
45    // offsetParam will be set to 0, an invalid value.
46    if (offsetParam > 0) {
47        // Bind the offset parameter, telling the program which row to start with
48        int err = sqlite3_bind_int(statement, offsetParam, startPos);
49        if (err != SQLITE_OK) {
50            LOGE("Unable to bind offset position, offsetParam = %d", offsetParam);
51            throw_sqlite3_exception(env, database);
52            return 0;
53        }
54        LOG_WINDOW("Bound to startPos %d", startPos);
55    } else {
56        LOG_WINDOW("Not binding to startPos %d", startPos);
57    }
58
59    // We assume numRows is initially 0.
60    LOG_WINDOW("Window: numRows = %d, size = %d, freeSpace = %d",
61            window->getNumRows(), window->size(), window->freeSpace());
62
63    int numColumns = sqlite3_column_count(statement);
64    status_t status = window->setNumColumns(numColumns);
65    if (status) {
66        LOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns);
67        jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch");
68        return 0;
69    }
70
71    int retryCount = 0;
72    int totalRows = 0;
73    int addedRows = 0;
74    bool windowFull = false;
75    bool gotException = false;
76    const bool countAllRows = (startPos == 0); // when startPos is 0, we count all rows
77    while (!gotException && (!windowFull || countAllRows)) {
78        int err = sqlite3_step(statement);
79        if (err == SQLITE_ROW) {
80            LOG_WINDOW("Stepped statement %p to row %d", statement, totalRows);
81            retryCount = 0;
82            totalRows += 1;
83
84            // Skip the row if the window is full or we haven't reached the start position yet.
85            if (startPos >= totalRows || windowFull) {
86                continue;
87            }
88
89            // Allocate a new field directory for the row. This pointer is not reused
90            // since it may be possible for it to be relocated on a call to alloc() when
91            // the field data is being allocated.
92            status = window->allocRow();
93            if (status) {
94                LOG_WINDOW("Failed allocating fieldDir at startPos %d row %d, error=%d",
95                        startPos, addedRows, status);
96                windowFull = true;
97                continue;
98            }
99
100            // Pack the row into the window.
101            for (int i = 0; i < numColumns; i++) {
102                int type = sqlite3_column_type(statement, i);
103                if (type == SQLITE_TEXT) {
104                    // TEXT data
105                    const char* text = reinterpret_cast<const char*>(
106                            sqlite3_column_text(statement, i));
107                    // SQLite does not include the NULL terminator in size, but does
108                    // ensure all strings are NULL terminated, so increase size by
109                    // one to make sure we store the terminator.
110                    size_t sizeIncludingNull = sqlite3_column_bytes(statement, i) + 1;
111                    status = window->putString(addedRows, i, text, sizeIncludingNull);
112                    if (status) {
113                        LOG_WINDOW("Failed allocating %u bytes for text at %d,%d, error=%d",
114                                sizeIncludingNull, startPos + addedRows, i, status);
115                        windowFull = true;
116                        break;
117                    }
118                    LOG_WINDOW("%d,%d is TEXT with %u bytes",
119                            startPos + addedRows, i, sizeIncludingNull);
120                } else if (type == SQLITE_INTEGER) {
121                    // INTEGER data
122                    int64_t value = sqlite3_column_int64(statement, i);
123                    status = window->putLong(addedRows, i, value);
124                    if (status) {
125                        LOG_WINDOW("Failed allocating space for a long in column %d, error=%d",
126                                i, status);
127                        windowFull = true;
128                        break;
129                    }
130                    LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + addedRows, i, value);
131                } else if (type == SQLITE_FLOAT) {
132                    // FLOAT data
133                    double value = sqlite3_column_double(statement, i);
134                    status = window->putDouble(addedRows, i, value);
135                    if (status) {
136                        LOG_WINDOW("Failed allocating space for a double in column %d, error=%d",
137                                i, status);
138                        windowFull = true;
139                        break;
140                    }
141                    LOG_WINDOW("%d,%d is FLOAT %lf", startPos + addedRows, i, value);
142                } else if (type == SQLITE_BLOB) {
143                    // BLOB data
144                    const void* blob = sqlite3_column_blob(statement, i);
145                    size_t size = sqlite3_column_bytes(statement, i);
146                    status = window->putBlob(addedRows, i, blob, size);
147                    if (status) {
148                        LOG_WINDOW("Failed allocating %u bytes for blob at %d,%d, error=%d",
149                                size, startPos + addedRows, i, status);
150                        windowFull = true;
151                        break;
152                    }
153                    LOG_WINDOW("%d,%d is Blob with %u bytes",
154                            startPos + addedRows, i, size);
155                } else if (type == SQLITE_NULL) {
156                    // NULL field
157                    status = window->putNull(addedRows, i);
158                    if (status) {
159                        LOG_WINDOW("Failed allocating space for a null in column %d, error=%d",
160                                i, status);
161                        windowFull = true;
162                        break;
163                    }
164
165                    LOG_WINDOW("%d,%d is NULL", startPos + addedRows, i);
166                } else {
167                    // Unknown data
168                    LOGE("Unknown column type when filling database window");
169                    throw_sqlite3_exception(env, "Unknown column type when filling window");
170                    gotException = true;
171                    break;
172                }
173            }
174
175            // Update the final row tally.
176            if (windowFull || gotException) {
177                window->freeLastRow();
178            } else {
179                addedRows += 1;
180            }
181        } else if (err == SQLITE_DONE) {
182            // All rows processed, bail
183            LOG_WINDOW("Processed all rows");
184            break;
185        } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) {
186            // The table is locked, retry
187            LOG_WINDOW("Database locked, retrying");
188            if (retryCount > 50) {
189                LOGE("Bailing on database busy retry");
190                throw_sqlite3_exception(env, database, "retrycount exceeded");
191                gotException = true;
192            } else {
193                // Sleep to give the thread holding the lock a chance to finish
194                usleep(1000);
195                retryCount++;
196            }
197        } else {
198            throw_sqlite3_exception(env, database);
199            gotException = true;
200        }
201    }
202
203    LOG_WINDOW("Resetting statement %p after fetching %d rows and adding %d rows"
204            "to the window in %d bytes",
205            statement, totalRows, addedRows, window->size() - window->freeSpace());
206    sqlite3_reset(statement);
207
208    // Report the total number of rows on request.
209    if (startPos > totalRows) {
210        LOGE("startPos %d > actual rows %d", startPos, totalRows);
211    }
212    return countAllRows ? totalRows : 0;
213}
214
215static jint nativeColumnCount(JNIEnv* env, jclass clazz, jint statementPtr) {
216    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
217    return sqlite3_column_count(statement);
218}
219
220static jstring nativeColumnName(JNIEnv* env, jclass clazz, jint statementPtr,
221        jint columnIndex) {
222    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
223    const char* name = sqlite3_column_name(statement, columnIndex);
224    return env->NewStringUTF(name);
225}
226
227
228static JNINativeMethod sMethods[] =
229{
230     /* name, signature, funcPtr */
231    { "nativeFillWindow", "(IIIII)I",
232            (void*)nativeFillWindow },
233    { "nativeColumnCount", "(I)I",
234            (void*)nativeColumnCount},
235    { "nativeColumnName", "(II)Ljava/lang/String;",
236            (void*)nativeColumnName},
237};
238
239int register_android_database_SQLiteQuery(JNIEnv * env)
240{
241    return AndroidRuntime::registerNativeMethods(env,
242        "android/database/sqlite/SQLiteQuery", sMethods, NELEM(sMethods));
243}
244
245} // namespace android
246