Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "AArch64: Use long for pointers"

Browse Source
This commit is contained in:
Narayan Kamath
2014-01-08 11:53:50 +00:00
committed by Gerrit Code Review
parent f5598210f0 738702d28a
commit 002ae75b82
4 changed files with 170 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
core/java/android/database/CursorWindow.java
View File

@@ -27,6 +27,7 @@ import android.os.Parcelable;
import android.os.Process; import android.os.Process;
import android.util.Log; import android.util.Log;
import android.util.SparseIntArray; import android.util.SparseIntArray;
import android.util.LongSparseArray;
/** /**
* A buffer containing multiple cursor rows. * A buffer containing multiple cursor rows.
@@ -52,40 +53,40 @@ public class CursorWindow extends SQLiteClosable implements Parcelable {
* The native CursorWindow object pointer. (FOR INTERNAL USE ONLY) * The native CursorWindow object pointer. (FOR INTERNAL USE ONLY)
* @hide * @hide
*/ */
public int mWindowPtr; public long mWindowPtr;
private int mStartPos; private int mStartPos;
private final String mName; private final String mName;
private final CloseGuard mCloseGuard = CloseGuard.get(); private final CloseGuard mCloseGuard = CloseGuard.get();
private static native int nativeCreate(String name, int cursorWindowSize); private static native long nativeCreate(String name, int cursorWindowSize);
private static native int nativeCreateFromParcel(Parcel parcel); private static native long nativeCreateFromParcel(Parcel parcel);
private static native void nativeDispose(int windowPtr); private static native void nativeDispose(long windowPtr);
private static native void nativeWriteToParcel(int windowPtr, Parcel parcel); private static native void nativeWriteToParcel(long windowPtr, Parcel parcel);
private static native void nativeClear(int windowPtr); private static native void nativeClear(long windowPtr);
private static native int nativeGetNumRows(int windowPtr); private static native int nativeGetNumRows(long windowPtr);
private static native boolean nativeSetNumColumns(int windowPtr, int columnNum); private static native boolean nativeSetNumColumns(long windowPtr, int columnNum);
private static native boolean nativeAllocRow(int windowPtr); private static native boolean nativeAllocRow(long windowPtr);
private static native void nativeFreeLastRow(int windowPtr); private static native void nativeFreeLastRow(long windowPtr);
private static native int nativeGetType(int windowPtr, int row, int column); private static native int nativeGetType(long windowPtr, int row, int column);
private static native byte[] nativeGetBlob(int windowPtr, int row, int column); private static native byte[] nativeGetBlob(long windowPtr, int row, int column);
private static native String nativeGetString(int windowPtr, int row, int column); private static native String nativeGetString(long windowPtr, int row, int column);
private static native long nativeGetLong(int windowPtr, int row, int column); private static native long nativeGetLong(long windowPtr, int row, int column);
private static native double nativeGetDouble(int windowPtr, int row, int column); private static native double nativeGetDouble(long windowPtr, int row, int column);
private static native void nativeCopyStringToBuffer(int windowPtr, int row, int column, private static native void nativeCopyStringToBuffer(long windowPtr, int row, int column,
CharArrayBuffer buffer); CharArrayBuffer buffer);
private static native boolean nativePutBlob(int windowPtr, byte[] value, int row, int column); private static native boolean nativePutBlob(long windowPtr, byte[] value, int row, int column);
private static native boolean nativePutString(int windowPtr, String value, int row, int column); private static native boolean nativePutString(long windowPtr, String value, int row, int column);
private static native boolean nativePutLong(int windowPtr, long value, int row, int column); private static native boolean nativePutLong(long windowPtr, long value, int row, int column);
private static native boolean nativePutDouble(int windowPtr, double value, int row, int column); private static native boolean nativePutDouble(long windowPtr, double value, int row, int column);
private static native boolean nativePutNull(int windowPtr, int row, int column); private static native boolean nativePutNull(long windowPtr, int row, int column);
private static native String nativeGetName(int windowPtr); private static native String nativeGetName(long windowPtr);
/** /**
* Creates a new empty cursor window and gives it a name. * Creates a new empty cursor window and gives it a name.
@@ -713,9 +714,9 @@ public class CursorWindow extends SQLiteClosable implements Parcelable {
dispose(); dispose();
} }
private static final SparseIntArray sWindowToPidMap = new SparseIntArray(); private static final LongSparseArray<Integer> sWindowToPidMap = new LongSparseArray<Integer>();
private void recordNewWindow(int pid, int window) { private void recordNewWindow(int pid, long window) {
synchronized (sWindowToPidMap) { synchronized (sWindowToPidMap) {
sWindowToPidMap.put(window, pid); sWindowToPidMap.put(window, pid);
if (Log.isLoggable(STATS_TAG, Log.VERBOSE)) { if (Log.isLoggable(STATS_TAG, Log.VERBOSE)) {
@@ -724,7 +725,7 @@ public class CursorWindow extends SQLiteClosable implements Parcelable {
} }
} }
private void recordClosingOfWindow(int window) { private void recordClosingOfWindow(long window) {
synchronized (sWindowToPidMap) { synchronized (sWindowToPidMap) {
if (sWindowToPidMap.size() == 0) { if (sWindowToPidMap.size() == 0) {
// this means we are not in the ContentProvider. // this means we are not in the ContentProvider.
@@ -771,6 +772,6 @@ public class CursorWindow extends SQLiteClosable implements Parcelable {
@Override @Override
public String toString() { public String toString() {
return getName() + " {" + Integer.toHexString(mWindowPtr) + "}"; return getName() + " {" + Long.toHexString(mWindowPtr) + "}";
} }
} }

66
core/java/android/database/sqlite/SQLiteConnection.java
View File

@@ -107,7 +107,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
private final OperationLog mRecentOperations = new OperationLog(); private final OperationLog mRecentOperations = new OperationLog();
// The native SQLiteConnection pointer. (FOR INTERNAL USE ONLY) // The native SQLiteConnection pointer. (FOR INTERNAL USE ONLY)
private int mConnectionPtr; private long mConnectionPtr;
private boolean mOnlyAllowReadOnlyOperations; private boolean mOnlyAllowReadOnlyOperations;
@@ -117,45 +117,45 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
// we can ensure that we detach the signal at the right time. // we can ensure that we detach the signal at the right time.
private int mCancellationSignalAttachCount; private int mCancellationSignalAttachCount;
private static native int nativeOpen(String path, int openFlags, String label, private static native long nativeOpen(String path, int openFlags, String label,
boolean enableTrace, boolean enableProfile); boolean enableTrace, boolean enableProfile);
private static native void nativeClose(int connectionPtr); private static native void nativeClose(long connectionPtr);
private static native void nativeRegisterCustomFunction(int connectionPtr, private static native void nativeRegisterCustomFunction(long connectionPtr,
SQLiteCustomFunction function); SQLiteCustomFunction function);
private static native void nativeRegisterLocalizedCollators(int connectionPtr, String locale); private static native void nativeRegisterLocalizedCollators(long connectionPtr, String locale);
private static native int nativePrepareStatement(int connectionPtr, String sql); private static native long nativePrepareStatement(long connectionPtr, String sql);
private static native void nativeFinalizeStatement(int connectionPtr, int statementPtr); private static native void nativeFinalizeStatement(long connectionPtr, long statementPtr);
private static native int nativeGetParameterCount(int connectionPtr, int statementPtr); private static native int nativeGetParameterCount(long connectionPtr, long statementPtr);
private static native boolean nativeIsReadOnly(int connectionPtr, int statementPtr); private static native boolean nativeIsReadOnly(long connectionPtr, long statementPtr);
private static native int nativeGetColumnCount(int connectionPtr, int statementPtr); private static native int nativeGetColumnCount(long connectionPtr, long statementPtr);
private static native String nativeGetColumnName(int connectionPtr, int statementPtr, private static native String nativeGetColumnName(long connectionPtr, long statementPtr,
int index); int index);
private static native void nativeBindNull(int connectionPtr, int statementPtr, private static native void nativeBindNull(long connectionPtr, long statementPtr,
int index); int index);
private static native void nativeBindLong(int connectionPtr, int statementPtr, private static native void nativeBindLong(long connectionPtr, long statementPtr,
int index, long value); int index, long value);
private static native void nativeBindDouble(int connectionPtr, int statementPtr, private static native void nativeBindDouble(long connectionPtr, long statementPtr,
int index, double value); int index, double value);
private static native void nativeBindString(int connectionPtr, int statementPtr, private static native void nativeBindString(long connectionPtr, long statementPtr,
int index, String value); int index, String value);
private static native void nativeBindBlob(int connectionPtr, int statementPtr, private static native void nativeBindBlob(long connectionPtr, long statementPtr,
int index, byte[] value); int index, byte[] value);
private static native void nativeResetStatementAndClearBindings( private static native void nativeResetStatementAndClearBindings(
int connectionPtr, int statementPtr); long connectionPtr, long statementPtr);
private static native void nativeExecute(int connectionPtr, int statementPtr); private static native void nativeExecute(long connectionPtr, long statementPtr);
private static native long nativeExecuteForLong(int connectionPtr, int statementPtr); private static native long nativeExecuteForLong(long connectionPtr, long statementPtr);
private static native String nativeExecuteForString(int connectionPtr, int statementPtr); private static native String nativeExecuteForString(long connectionPtr, long statementPtr);
private static native int nativeExecuteForBlobFileDescriptor( private static native int nativeExecuteForBlobFileDescriptor(
int connectionPtr, int statementPtr); long connectionPtr, long statementPtr);
private static native int nativeExecuteForChangedRowCount(int connectionPtr, int statementPtr); private static native int nativeExecuteForChangedRowCount(long connectionPtr, long statementPtr);
private static native long nativeExecuteForLastInsertedRowId( private static native long nativeExecuteForLastInsertedRowId(
int connectionPtr, int statementPtr); long connectionPtr, long statementPtr);
private static native long nativeExecuteForCursorWindow( private static native long nativeExecuteForCursorWindow(
int connectionPtr, int statementPtr, int windowPtr, long connectionPtr, long statementPtr, long windowPtr,
int startPos, int requiredPos, boolean countAllRows); int startPos, int requiredPos, boolean countAllRows);
private static native int nativeGetDbLookaside(int connectionPtr); private static native int nativeGetDbLookaside(long connectionPtr);
private static native void nativeCancel(int connectionPtr); private static native void nativeCancel(long connectionPtr);
private static native void nativeResetCancel(int connectionPtr, boolean cancelable); private static native void nativeResetCancel(long connectionPtr, boolean cancelable);
private SQLiteConnection(SQLiteConnectionPool pool, private SQLiteConnection(SQLiteConnectionPool pool,
SQLiteDatabaseConfiguration configuration, SQLiteDatabaseConfiguration configuration,
@@ -886,7 +886,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
skipCache = true; skipCache = true;
} }
final int statementPtr = nativePrepareStatement(mConnectionPtr, sql); final long statementPtr = nativePrepareStatement(mConnectionPtr, sql);
try { try {
final int numParameters = nativeGetParameterCount(mConnectionPtr, statementPtr); final int numParameters = nativeGetParameterCount(mConnectionPtr, statementPtr);
final int type = DatabaseUtils.getSqlStatementType(sql); final int type = DatabaseUtils.getSqlStatementType(sql);
@@ -987,7 +987,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
return; return;
} }
final int statementPtr = statement.mStatementPtr; final long statementPtr = statement.mStatementPtr;
for (int i = 0; i < count; i++) { for (int i = 0; i < count; i++) {
final Object arg = bindArgs[i]; final Object arg = bindArgs[i];
switch (DatabaseUtils.getTypeOfObject(arg)) { switch (DatabaseUtils.getTypeOfObject(arg)) {
@@ -1072,7 +1072,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
void dumpUnsafe(Printer printer, boolean verbose) { void dumpUnsafe(Printer printer, boolean verbose) {
printer.println("Connection #" + mConnectionId + ":"); printer.println("Connection #" + mConnectionId + ":");
if (verbose) { if (verbose) {
printer.println(" connectionPtr: 0x" + Integer.toHexString(mConnectionPtr)); printer.println(" connectionPtr: 0x" + Long.toHexString(mConnectionPtr));
} }
printer.println(" isPrimaryConnection: " + mIsPrimaryConnection); printer.println(" isPrimaryConnection: " + mIsPrimaryConnection);
printer.println(" onlyAllowReadOnlyOperations: " + mOnlyAllowReadOnlyOperations); printer.println(" onlyAllowReadOnlyOperations: " + mOnlyAllowReadOnlyOperations);
@@ -1178,7 +1178,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
return "SQLiteConnection: " + mConfiguration.path + " (" + mConnectionId + ")"; return "SQLiteConnection: " + mConfiguration.path + " (" + mConnectionId + ")";
} }
private PreparedStatement obtainPreparedStatement(String sql, int statementPtr, private PreparedStatement obtainPreparedStatement(String sql, long statementPtr,
int numParameters, int type, boolean readOnly) { int numParameters, int type, boolean readOnly) {
PreparedStatement statement = mPreparedStatementPool; PreparedStatement statement = mPreparedStatementPool;
if (statement != null) { if (statement != null) {
@@ -1225,7 +1225,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
// The native sqlite3_stmt object pointer. // The native sqlite3_stmt object pointer.
// Lifetime is managed explicitly by the connection. // Lifetime is managed explicitly by the connection.
public int mStatementPtr; public long mStatementPtr;
// The number of parameters that the prepared statement has. // The number of parameters that the prepared statement has.
public int mNumParameters; public int mNumParameters;
@@ -1271,7 +1271,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
if (statement.mInCache) { // might be false due to a race with entryRemoved if (statement.mInCache) { // might be false due to a race with entryRemoved
String sql = entry.getKey(); String sql = entry.getKey();
printer.println(" " + i + ": statementPtr=0x" printer.println(" " + i + ": statementPtr=0x"
+ Integer.toHexString(statement.mStatementPtr) + Long.toHexString(statement.mStatementPtr)
+ ", numParameters=" + statement.mNumParameters + ", numParameters=" + statement.mNumParameters
+ ", type=" + statement.mType + ", type=" + statement.mType
+ ", readOnly=" + statement.mReadOnly + ", readOnly=" + statement.mReadOnly

88
core/jni/android_database_CursorWindow.cpp
View File

@@ -58,7 +58,7 @@ static void throwUnknownTypeException(JNIEnv * env, jint type) {
jniThrowException(env, "java/lang/IllegalStateException", msg.string()); jniThrowException(env, "java/lang/IllegalStateException", msg.string());
} }
static jint nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursorWindowSize) { static jlong nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursorWindowSize) {
String8 name; String8 name;
const char* nameStr = env->GetStringUTFChars(nameObj, NULL); const char* nameStr = env->GetStringUTFChars(nameObj, NULL);
name.setTo(nameStr); name.setTo(nameStr);
@@ -73,10 +73,10 @@ static jint nativeCreate(JNIEnv* env, jclass clazz, jstring nameObj, jint cursor
} }
LOG_WINDOW("nativeInitializeEmpty: window = %p", window); LOG_WINDOW("nativeInitializeEmpty: window = %p", window);
return reinterpret_cast<jint>(window); return reinterpret_cast<jlong>(window);
} }
static jint nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) { static jlong nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj) {
Parcel* parcel = parcelForJavaObject(env, parcelObj); Parcel* parcel = parcelForJavaObject(env, parcelObj);
CursorWindow* window; CursorWindow* window;
@@ -88,10 +88,10 @@ static jint nativeCreateFromParcel(JNIEnv* env, jclass clazz, jobject parcelObj)
LOG_WINDOW("nativeInitializeFromBinder: numRows = %d, numColumns = %d, window = %p", LOG_WINDOW("nativeInitializeFromBinder: numRows = %d, numColumns = %d, window = %p",
window->getNumRows(), window->getNumColumns(), window); window->getNumRows(), window->getNumColumns(), window);
return reinterpret_cast<jint>(window); return reinterpret_cast<jlong>(window);
} }
static void nativeDispose(JNIEnv* env, jclass clazz, jint windowPtr) { static void nativeDispose(JNIEnv* env, jclass clazz, jlong windowPtr) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
if (window) { if (window) {
LOG_WINDOW("Closing window %p", window); LOG_WINDOW("Closing window %p", window);
@@ -99,12 +99,12 @@ static void nativeDispose(JNIEnv* env, jclass clazz, jint windowPtr) {
} }
} }
static jstring nativeGetName(JNIEnv* env, jclass clazz, jint windowPtr) { static jstring nativeGetName(JNIEnv* env, jclass clazz, jlong windowPtr) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
return env->NewStringUTF(window->name().string()); return env->NewStringUTF(window->name().string());
} }
static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jint windowPtr, static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jlong windowPtr,
jobject parcelObj) { jobject parcelObj) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
Parcel* parcel = parcelForJavaObject(env, parcelObj); Parcel* parcel = parcelForJavaObject(env, parcelObj);
@@ -117,7 +117,7 @@ static void nativeWriteToParcel(JNIEnv * env, jclass clazz, jint windowPtr,
} }
} }
static void nativeClear(JNIEnv * env, jclass clazz, jint windowPtr) { static void nativeClear(JNIEnv * env, jclass clazz, jlong windowPtr) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Clearing window %p", window); LOG_WINDOW("Clearing window %p", window);
status_t status = window->clear(); status_t status = window->clear();
@@ -126,30 +126,30 @@ static void nativeClear(JNIEnv * env, jclass clazz, jint windowPtr) {
} }
} }
static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jint windowPtr) { static jint nativeGetNumRows(JNIEnv* env, jclass clazz, jlong windowPtr) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
return window->getNumRows(); return window->getNumRows();
} }
static jboolean nativeSetNumColumns(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativeSetNumColumns(JNIEnv* env, jclass clazz, jlong windowPtr,
jint columnNum) { jint columnNum) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
status_t status = window->setNumColumns(columnNum); status_t status = window->setNumColumns(columnNum);
return status == OK; return status == OK;
} }
static jboolean nativeAllocRow(JNIEnv* env, jclass clazz, jint windowPtr) { static jboolean nativeAllocRow(JNIEnv* env, jclass clazz, jlong windowPtr) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
status_t status = window->allocRow(); status_t status = window->allocRow();
return status == OK; return status == OK;
} }
static void nativeFreeLastRow(JNIEnv* env, jclass clazz, jint windowPtr) { static void nativeFreeLastRow(JNIEnv* env, jclass clazz, jlong windowPtr) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
window->freeLastRow(); window->freeLastRow();
} }
static jint nativeGetType(JNIEnv* env, jclass clazz, jint windowPtr, static jint nativeGetType(JNIEnv* env, jclass clazz, jlong windowPtr,
jint row, jint column) { jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("returning column type affinity for %d,%d from %p", row, column, window); LOG_WINDOW("returning column type affinity for %d,%d from %p", row, column, window);
@@ -164,7 +164,7 @@ static jint nativeGetType(JNIEnv* env, jclass clazz, jint windowPtr,
return window->getFieldSlotType(fieldSlot); return window->getFieldSlotType(fieldSlot);
} }
static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr, static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jlong windowPtr,
jint row, jint column) { jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window); LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window);
@@ -199,7 +199,7 @@ static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jint windowPtr,
return NULL; return NULL;
} }
static jstring nativeGetString(JNIEnv* env, jclass clazz, jint windowPtr, static jstring nativeGetString(JNIEnv* env, jclass clazz, jlong windowPtr,
jint row, jint column) { jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting string for %d,%d from %p", row, column, window); LOG_WINDOW("Getting string for %d,%d from %p", row, column, window);
@@ -291,7 +291,7 @@ static void clearCharArrayBuffer(JNIEnv* env, jobject bufferObj) {
} }
} }
static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jint windowPtr, static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jlong windowPtr,
jint row, jint column, jobject bufferObj) { jint row, jint column, jobject bufferObj) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Copying string for %d,%d from %p", row, column, window); LOG_WINDOW("Copying string for %d,%d from %p", row, column, window);
@@ -330,7 +330,7 @@ static void nativeCopyStringToBuffer(JNIEnv* env, jclass clazz, jint windowPtr,
} }
} }
static jlong nativeGetLong(JNIEnv* env, jclass clazz, jint windowPtr, static jlong nativeGetLong(JNIEnv* env, jclass clazz, jlong windowPtr,
jint row, jint column) { jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting long for %d,%d from %p", row, column, window); LOG_WINDOW("Getting long for %d,%d from %p", row, column, window);
@@ -361,7 +361,7 @@ static jlong nativeGetLong(JNIEnv* env, jclass clazz, jint windowPtr,
} }
} }
static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jint windowPtr, static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jlong windowPtr,
jint row, jint column) { jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
LOG_WINDOW("Getting double for %d,%d from %p", row, column, window); LOG_WINDOW("Getting double for %d,%d from %p", row, column, window);
@@ -392,7 +392,7 @@ static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jint windowPtr,
} }
} }
static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jlong windowPtr,
jbyteArray valueObj, jint row, jint column) { jbyteArray valueObj, jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
jsize len = env->GetArrayLength(valueObj); jsize len = env->GetArrayLength(valueObj);
@@ -410,7 +410,7 @@ static jboolean nativePutBlob(JNIEnv* env, jclass clazz, jint windowPtr,
return true; return true;
} }
static jboolean nativePutString(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutString(JNIEnv* env, jclass clazz, jlong windowPtr,
jstring valueObj, jint row, jint column) { jstring valueObj, jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
@@ -432,7 +432,7 @@ static jboolean nativePutString(JNIEnv* env, jclass clazz, jint windowPtr,
return true; return true;
} }
static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutLong(JNIEnv* env, jclass clazz, jlong windowPtr,
jlong value, jint row, jint column) { jlong value, jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
status_t status = window->putLong(row, column, value); status_t status = window->putLong(row, column, value);
@@ -446,7 +446,7 @@ static jboolean nativePutLong(JNIEnv* env, jclass clazz, jint windowPtr,
return true; return true;
} }
static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jlong windowPtr,
jdouble value, jint row, jint column) { jdouble value, jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
status_t status = window->putDouble(row, column, value); status_t status = window->putDouble(row, column, value);
@@ -460,7 +460,7 @@ static jboolean nativePutDouble(JNIEnv* env, jclass clazz, jint windowPtr,
return true; return true;
} }
static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr, static jboolean nativePutNull(JNIEnv* env, jclass clazz, jlong windowPtr,
jint row, jint column) { jint row, jint column) {
CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr); CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);
status_t status = window->putNull(row, column); status_t status = window->putNull(row, column);
@@ -477,47 +477,47 @@ static jboolean nativePutNull(JNIEnv* env, jclass clazz, jint windowPtr,
static JNINativeMethod sMethods[] = static JNINativeMethod sMethods[] =
{ {
/* name, signature, funcPtr */ /* name, signature, funcPtr */
{ "nativeCreate", "(Ljava/lang/String;I)I", { "nativeCreate", "(Ljava/lang/String;I)J",
(void*)nativeCreate }, (void*)nativeCreate },
{ "nativeCreateFromParcel", "(Landroid/os/Parcel;)I", { "nativeCreateFromParcel", "(Landroid/os/Parcel;)J",
(void*)nativeCreateFromParcel }, (void*)nativeCreateFromParcel },
{ "nativeDispose", "(I)V", { "nativeDispose", "(J)V",
(void*)nativeDispose }, (void*)nativeDispose },
{ "nativeWriteToParcel", "(ILandroid/os/Parcel;)V", { "nativeWriteToParcel", "(JLandroid/os/Parcel;)V",
(void*)nativeWriteToParcel }, (void*)nativeWriteToParcel },
{ "nativeGetName", "(I)Ljava/lang/String;", { "nativeGetName", "(J)Ljava/lang/String;",
(void*)nativeGetName }, (void*)nativeGetName },
{ "nativeClear", "(I)V", { "nativeClear", "(J)V",
(void*)nativeClear }, (void*)nativeClear },
{ "nativeGetNumRows", "(I)I", { "nativeGetNumRows", "(J)I",
(void*)nativeGetNumRows }, (void*)nativeGetNumRows },
{ "nativeSetNumColumns", "(II)Z", { "nativeSetNumColumns", "(JI)Z",
(void*)nativeSetNumColumns }, (void*)nativeSetNumColumns },
{ "nativeAllocRow", "(I)Z", { "nativeAllocRow", "(J)Z",
(void*)nativeAllocRow }, (void*)nativeAllocRow },
{ "nativeFreeLastRow", "(I)V", { "nativeFreeLastRow", "(J)V",
(void*)nativeFreeLastRow }, (void*)nativeFreeLastRow },
{ "nativeGetType", "(III)I", { "nativeGetType", "(JII)I",
(void*)nativeGetType }, (void*)nativeGetType },
{ "nativeGetBlob", "(III)[B", { "nativeGetBlob", "(JII)[B",
(void*)nativeGetBlob }, (void*)nativeGetBlob },
{ "nativeGetString", "(III)Ljava/lang/String;", { "nativeGetString", "(JII)Ljava/lang/String;",
(void*)nativeGetString }, (void*)nativeGetString },
{ "nativeGetLong", "(III)J", { "nativeGetLong", "(JII)J",
(void*)nativeGetLong }, (void*)nativeGetLong },
{ "nativeGetDouble", "(III)D", { "nativeGetDouble", "(JII)D",
(void*)nativeGetDouble }, (void*)nativeGetDouble },
{ "nativeCopyStringToBuffer", "(IIILandroid/database/CharArrayBuffer;)V", { "nativeCopyStringToBuffer", "(JIILandroid/database/CharArrayBuffer;)V",
(void*)nativeCopyStringToBuffer }, (void*)nativeCopyStringToBuffer },
{ "nativePutBlob", "(I[BII)Z", { "nativePutBlob", "(J[BII)Z",
(void*)nativePutBlob }, (void*)nativePutBlob },
{ "nativePutString", "(ILjava/lang/String;II)Z", { "nativePutString", "(JLjava/lang/String;II)Z",
(void*)nativePutString }, (void*)nativePutString },
{ "nativePutLong", "(IJII)Z", { "nativePutLong", "(JJII)Z",
(void*)nativePutLong }, (void*)nativePutLong },
{ "nativePutDouble", "(IDII)Z", { "nativePutDouble", "(JDII)Z",
(void*)nativePutDouble }, (void*)nativePutDouble },
{ "nativePutNull", "(III)Z", { "nativePutNull", "(JII)Z",
(void*)nativePutNull }, (void*)nativePutNull },
}; };

132
core/jni/android_database_SQLiteConnection.cpp
View File

@@ -109,7 +109,7 @@ static int sqliteProgressHandlerCallback(void* data) {
} }
static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags, static jlong nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlags,
jstring labelStr, jboolean enableTrace, jboolean enableProfile) { jstring labelStr, jboolean enableTrace, jboolean enableProfile) {
int sqliteFlags; int sqliteFlags;
if (openFlags & SQLiteConnection::CREATE_IF_NECESSARY) { if (openFlags & SQLiteConnection::CREATE_IF_NECESSARY) {
@@ -170,10 +170,10 @@ static jint nativeOpen(JNIEnv* env, jclass clazz, jstring pathStr, jint openFlag
} }
ALOGV("Opened connection %p with label '%s'", db, label.string()); ALOGV("Opened connection %p with label '%s'", db, label.string());
return reinterpret_cast<jint>(connection); return reinterpret_cast<jlong>(connection);
} }
static void nativeClose(JNIEnv* env, jclass clazz, jint connectionPtr) { static void nativeClose(JNIEnv* env, jclass clazz, jlong connectionPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
if (connection) { if (connection) {
@@ -243,7 +243,7 @@ static void sqliteCustomFunctionDestructor(void* data) {
env->DeleteGlobalRef(functionObjGlobal); env->DeleteGlobalRef(functionObjGlobal);
} }
static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jlong connectionPtr,
jobject functionObj) { jobject functionObj) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
@@ -267,7 +267,7 @@ static void nativeRegisterCustomFunction(JNIEnv* env, jclass clazz, jint connect
} }
} }
static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jlong connectionPtr,
jstring localeStr) { jstring localeStr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
@@ -280,7 +280,7 @@ static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jint con
} }
} }
static jint nativePrepareStatement(JNIEnv* env, jclass clazz, jint connectionPtr, static jlong nativePrepareStatement(JNIEnv* env, jclass clazz, jlong connectionPtr,
jstring sqlString) { jstring sqlString) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
@@ -308,11 +308,11 @@ static jint nativePrepareStatement(JNIEnv* env, jclass clazz, jint connectionPtr
} }
ALOGV("Prepared statement %p on connection %p", statement, connection->db); ALOGV("Prepared statement %p on connection %p", statement, connection->db);
return reinterpret_cast<jint>(statement); return reinterpret_cast<jlong>(statement);
} }
static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr) { jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -323,32 +323,32 @@ static void nativeFinalizeStatement(JNIEnv* env, jclass clazz, jint connectionPt
sqlite3_finalize(statement); sqlite3_finalize(statement);
} }
static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jint connectionPtr, static jint nativeGetParameterCount(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr) { jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
return sqlite3_bind_parameter_count(statement); return sqlite3_bind_parameter_count(statement);
} }
static jboolean nativeIsReadOnly(JNIEnv* env, jclass clazz, jint connectionPtr, static jboolean nativeIsReadOnly(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr) { jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
return sqlite3_stmt_readonly(statement) != 0; return sqlite3_stmt_readonly(statement) != 0;
} }
static jint nativeGetColumnCount(JNIEnv* env, jclass clazz, jint connectionPtr, static jint nativeGetColumnCount(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr) { jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
return sqlite3_column_count(statement); return sqlite3_column_count(statement);
} }
static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jint connectionPtr, static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr, jint index) { jlong statementPtr, jint index) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -363,8 +363,8 @@ static jstring nativeGetColumnName(JNIEnv* env, jclass clazz, jint connectionPtr
return NULL; return NULL;
} }
static void nativeBindNull(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeBindNull(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr, jint index) { jlong statementPtr, jint index) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -374,8 +374,8 @@ static void nativeBindNull(JNIEnv* env, jclass clazz, jint connectionPtr,
} }
} }
static void nativeBindLong(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeBindLong(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr, jint index, jlong value) { jlong statementPtr, jint index, jlong value) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -385,8 +385,8 @@ static void nativeBindLong(JNIEnv* env, jclass clazz, jint connectionPtr,
} }
} }
static void nativeBindDouble(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeBindDouble(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr, jint index, jdouble value) { jlong statementPtr, jint index, jdouble value) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -396,8 +396,8 @@ static void nativeBindDouble(JNIEnv* env, jclass clazz, jint connectionPtr,
} }
} }
static void nativeBindString(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeBindString(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr, jint index, jstring valueString) { jlong statementPtr, jint index, jstring valueString) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -411,8 +411,8 @@ static void nativeBindString(JNIEnv* env, jclass clazz, jint connectionPtr,
} }
} }
static void nativeBindBlob(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeBindBlob(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr, jint index, jbyteArray valueArray) { jlong statementPtr, jint index, jbyteArray valueArray) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -425,8 +425,8 @@ static void nativeBindBlob(JNIEnv* env, jclass clazz, jint connectionPtr,
} }
} }
static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeResetStatementAndClearBindings(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr) { jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -450,8 +450,8 @@ static int executeNonQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_st
return err; return err;
} }
static void nativeExecute(JNIEnv* env, jclass clazz, jint connectionPtr, static void nativeExecute(JNIEnv* env, jclass clazz, jlong connectionPtr,
jint statementPtr) { jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -459,7 +459,7 @@ static void nativeExecute(JNIEnv* env, jclass clazz, jint connectionPtr,
} }
static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz, static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz,
jint connectionPtr, jint statementPtr) { jlong connectionPtr, jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -468,7 +468,7 @@ static jint nativeExecuteForChangedRowCount(JNIEnv* env, jclass clazz,
} }
static jlong nativeExecuteForLastInsertedRowId(JNIEnv* env, jclass clazz, static jlong nativeExecuteForLastInsertedRowId(JNIEnv* env, jclass clazz,
jint connectionPtr, jint statementPtr) { jlong connectionPtr, jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -486,7 +486,7 @@ static int executeOneRowQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3
} }
static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz, static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz,
jint connectionPtr, jint statementPtr) { jlong connectionPtr, jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -498,7 +498,7 @@ static jlong nativeExecuteForLong(JNIEnv* env, jclass clazz,
} }
static jstring nativeExecuteForString(JNIEnv* env, jclass clazz, static jstring nativeExecuteForString(JNIEnv* env, jclass clazz,
jint connectionPtr, jint statementPtr) { jlong connectionPtr, jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -548,7 +548,7 @@ static int createAshmemRegionWithData(JNIEnv* env, const void* data, size_t leng
} }
static jint nativeExecuteForBlobFileDescriptor(JNIEnv* env, jclass clazz, static jint nativeExecuteForBlobFileDescriptor(JNIEnv* env, jclass clazz,
jint connectionPtr, jint statementPtr) { jlong connectionPtr, jlong statementPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -665,7 +665,7 @@ static CopyRowResult copyRow(JNIEnv* env, CursorWindow* window,
} }
static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz, static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz,
jint connectionPtr, jint statementPtr, jint windowPtr, jlong connectionPtr, jlong statementPtr, jlong windowPtr,
jint startPos, jint requiredPos, jboolean countAllRows) { jint startPos, jint requiredPos, jboolean countAllRows) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr); sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);
@@ -760,7 +760,7 @@ static jlong nativeExecuteForCursorWindow(JNIEnv* env, jclass clazz,
return result; return result;
} }
static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jint connectionPtr) { static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jlong connectionPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
int cur = -1; int cur = -1;
@@ -769,12 +769,12 @@ static jint nativeGetDbLookaside(JNIEnv* env, jobject clazz, jint connectionPtr)
return cur; return cur;
} }
static void nativeCancel(JNIEnv* env, jobject clazz, jint connectionPtr) { static void nativeCancel(JNIEnv* env, jobject clazz, jlong connectionPtr) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
connection->canceled = true; connection->canceled = true;
} }
static void nativeResetCancel(JNIEnv* env, jobject clazz, jint connectionPtr, static void nativeResetCancel(JNIEnv* env, jobject clazz, jlong connectionPtr,
jboolean cancelable) { jboolean cancelable) {
SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr); SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);
connection->canceled = false; connection->canceled = false;
@@ -791,57 +791,57 @@ static void nativeResetCancel(JNIEnv* env, jobject clazz, jint connectionPtr,
static JNINativeMethod sMethods[] = static JNINativeMethod sMethods[] =
{ {
/* name, signature, funcPtr */ /* name, signature, funcPtr */
{ "nativeOpen", "(Ljava/lang/String;ILjava/lang/String;ZZ)I", { "nativeOpen", "(Ljava/lang/String;ILjava/lang/String;ZZ)J",
(void*)nativeOpen }, (void*)nativeOpen },
{ "nativeClose", "(I)V", { "nativeClose", "(J)V",
(void*)nativeClose }, (void*)nativeClose },
{ "nativeRegisterCustomFunction", "(ILandroid/database/sqlite/SQLiteCustomFunction;)V", { "nativeRegisterCustomFunction", "(JLandroid/database/sqlite/SQLiteCustomFunction;)V",
(void*)nativeRegisterCustomFunction }, (void*)nativeRegisterCustomFunction },
{ "nativeRegisterLocalizedCollators", "(ILjava/lang/String;)V", { "nativeRegisterLocalizedCollators", "(JLjava/lang/String;)V",
(void*)nativeRegisterLocalizedCollators }, (void*)nativeRegisterLocalizedCollators },
{ "nativePrepareStatement", "(ILjava/lang/String;)I", { "nativePrepareStatement", "(JLjava/lang/String;)J",
(void*)nativePrepareStatement }, (void*)nativePrepareStatement },
{ "nativeFinalizeStatement", "(II)V", { "nativeFinalizeStatement", "(JJ)V",
(void*)nativeFinalizeStatement }, (void*)nativeFinalizeStatement },
{ "nativeGetParameterCount", "(II)I", { "nativeGetParameterCount", "(JJ)I",
(void*)nativeGetParameterCount }, (void*)nativeGetParameterCount },
{ "nativeIsReadOnly", "(II)Z", { "nativeIsReadOnly", "(JJ)Z",
(void*)nativeIsReadOnly }, (void*)nativeIsReadOnly },
{ "nativeGetColumnCount", "(II)I", { "nativeGetColumnCount", "(JJ)I",
(void*)nativeGetColumnCount }, (void*)nativeGetColumnCount },
{ "nativeGetColumnName", "(III)Ljava/lang/String;", { "nativeGetColumnName", "(JJI)Ljava/lang/String;",
(void*)nativeGetColumnName }, (void*)nativeGetColumnName },
{ "nativeBindNull", "(III)V", { "nativeBindNull", "(JJI)V",
(void*)nativeBindNull }, (void*)nativeBindNull },
{ "nativeBindLong", "(IIIJ)V", { "nativeBindLong", "(JJIJ)V",
(void*)nativeBindLong }, (void*)nativeBindLong },
{ "nativeBindDouble", "(IIID)V", { "nativeBindDouble", "(JJID)V",
(void*)nativeBindDouble }, (void*)nativeBindDouble },
{ "nativeBindString", "(IIILjava/lang/String;)V", { "nativeBindString", "(JJILjava/lang/String;)V",
(void*)nativeBindString }, (void*)nativeBindString },
{ "nativeBindBlob", "(III[B)V", { "nativeBindBlob", "(JJI[B)V",
(void*)nativeBindBlob }, (void*)nativeBindBlob },
{ "nativeResetStatementAndClearBindings", "(II)V", { "nativeResetStatementAndClearBindings", "(JJ)V",
(void*)nativeResetStatementAndClearBindings }, (void*)nativeResetStatementAndClearBindings },
{ "nativeExecute", "(II)V", { "nativeExecute", "(JJ)V",
(void*)nativeExecute }, (void*)nativeExecute },
{ "nativeExecuteForLong", "(II)J", { "nativeExecuteForLong", "(JJ)J",
(void*)nativeExecuteForLong }, (void*)nativeExecuteForLong },
{ "nativeExecuteForString", "(II)Ljava/lang/String;", { "nativeExecuteForString", "(JJ)Ljava/lang/String;",
(void*)nativeExecuteForString }, (void*)nativeExecuteForString },
{ "nativeExecuteForBlobFileDescriptor", "(II)I", { "nativeExecuteForBlobFileDescriptor", "(JJ)I",
(void*)nativeExecuteForBlobFileDescriptor }, (void*)nativeExecuteForBlobFileDescriptor },
{ "nativeExecuteForChangedRowCount", "(II)I", { "nativeExecuteForChangedRowCount", "(JJ)I",
(void*)nativeExecuteForChangedRowCount }, (void*)nativeExecuteForChangedRowCount },
{ "nativeExecuteForLastInsertedRowId", "(II)J", { "nativeExecuteForLastInsertedRowId", "(JJ)J",
(void*)nativeExecuteForLastInsertedRowId }, (void*)nativeExecuteForLastInsertedRowId },
{ "nativeExecuteForCursorWindow", "(IIIIIZ)J", { "nativeExecuteForCursorWindow", "(JJJIIZ)J",
(void*)nativeExecuteForCursorWindow }, (void*)nativeExecuteForCursorWindow },
{ "nativeGetDbLookaside", "(I)I", { "nativeGetDbLookaside", "(J)I",
(void*)nativeGetDbLookaside }, (void*)nativeGetDbLookaside },
{ "nativeCancel", "(I)V", { "nativeCancel", "(J)V",
(void*)nativeCancel }, (void*)nativeCancel },
{ "nativeResetCancel", "(IZ)V", { "nativeResetCancel", "(JZ)V",
(void*)nativeResetCancel }, (void*)nativeResetCancel },
}; };