自学教程：C++ throw_sqlite3_exception函数代码示例

static jbyteArray nativeGetBlob(JNIEnv* env, jclass clazz, jlong windowPtr,        jint row, jint column) {    CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);    LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window);    CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);    if (!fieldSlot) {        throwExceptionWithRowCol(env, row, column);        return NULL;    }    int32_t type = window->getFieldSlotType(fieldSlot);    if (type == CursorWindow::FIELD_TYPE_BLOB || type == CursorWindow::FIELD_TYPE_STRING) {        size_t size;        const void* value = window->getFieldSlotValueBlob(fieldSlot, &size);        jbyteArray byteArray = env->NewByteArray(size);        if (!byteArray) {            env->ExceptionClear();            throw_sqlite3_exception(env, "Native could not create new byte[]");            return NULL;        }        env->SetByteArrayRegion(byteArray, 0, size, static_cast<const jbyte*>(value));        return byteArray;    } else if (type == CursorWindow::FIELD_TYPE_INTEGER) {        throw_sqlite3_exception(env, "INTEGER data in nativeGetBlob ");    } else if (type == CursorWindow::FIELD_TYPE_FLOAT) {        throw_sqlite3_exception(env, "FLOAT data in nativeGetBlob ");    } else if (type == CursorWindow::FIELD_TYPE_NULL) {        // do nothing    } else {        throwUnknownTypeException(env, type);    }    return NULL;}

void Java_com_jim_multipos_utils_database_AbstractSQLite_tableinfo(JNIEnv *env, jobject object, int dbHandle, jstring tableName) {    sqlite3 *db = (sqlite3 *) dbHandle;    sqlite3_stmt *handle;    char const *tn = env->GetStringUTFChars(tableName, 0);    char test[100] = "CREATE TABLE IF NOT EXISTS foo (id INTEGER, name TEXT, test TEXT);";    int rc = sqlite3_exec(db, test, NULL, 0, 0);    if (rc != SQLITE_OK) {        throw_sqlite3_exception(env, db, rc);        return;    }    else        __android_log_write(ANDROID_LOG_DEBUG, "com.jim.multipos", "table created");    std::string temp =  "PRAGMA table_info(foo)";    char query[100];    strcpy(query, temp.c_str());    rc = sqlite3_prepare_v2(db, query, sizeof(query), &handle, NULL);    if (rc != SQLITE_OK) {        throw_sqlite3_exception(env, db, rc);        return;    }    while (sqlite3_step(handle) == SQLITE_ROW) {        __android_log_write(ANDROID_LOG_DEBUG, "com.jim.multipos", std::to_string(sqlite3_column_count(handle)).c_str());        const char *str = (const char *) sqlite3_column_text(handle, 0);        __android_log_write(ANDROID_LOG_DEBUG, "com.jim.multipos", str);    }    sqlite3_finalize(handle);    if (tn != 0) {        env->ReleaseStringUTFChars(tableName, tn);    }}

static jbyteArray getBlob_native(JNIEnv* env, jobject object, jint row, jint column){    int32_t err;    CursorWindow * window = GET_WINDOW(env, object);LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window);    field_slot_t field;    err = window->read_field_slot(row, column, &field);    if (err != 0) {        throwExceptionWithRowCol(env, row, column);        return NULL;    }    uint8_t type = field.type;    if (type == FIELD_TYPE_BLOB || type == FIELD_TYPE_STRING) {        jbyteArray byteArray = env->NewByteArray(field.data.buffer.size);        LOG_ASSERT(byteArray, "Native could not create new byte[]");        env->SetByteArrayRegion(byteArray, 0, field.data.buffer.size,            (const jbyte*)window->offsetToPtr(field.data.buffer.offset));        return byteArray;    } else if (type == FIELD_TYPE_INTEGER) {        throw_sqlite3_exception(env, "INTEGER data in getBlob_native ");    } else if (type == FIELD_TYPE_FLOAT) {        throw_sqlite3_exception(env, "FLOAT data in getBlob_native ");    } else if (type == FIELD_TYPE_NULL) {        // do nothing    } else {        throwUnknowTypeException(env, type);    }    return NULL;}

/* throw a SQLiteException for a given error code */void throw_sqlite3_exception_errcode(JNIEnv* env, int errcode, const char* message) {    if (errcode == SQLITE_DONE) {        throw_sqlite3_exception(env, errcode, NULL, message);    } else {        char temp[21];        sprintf(temp, "error code %d", errcode);        throw_sqlite3_exception(env, errcode, temp, message);    }}

static int executeNonQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement) {    int err = sqlite3_step(statement);    if (err == SQLITE_ROW) {        throw_sqlite3_exception(env,                "Queries can be performed using SQLiteDatabase query or rawQuery methods only.");    } else if (err != SQLITE_DONE) {        throw_sqlite3_exception(env, connection->db);    }    return err;}

/* throw a SQLiteException with a message appropriate for the error in handle   concatenated with the given message */void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle, const char* message) {    if (handle) {        throw_sqlite3_exception(env, sqlite3_errcode(handle),                                sqlite3_errmsg(handle), message);    } else {        // we use SQLITE_OK so that a generic SQLiteException is thrown;        // any code not specified in the switch statement below would do.        throw_sqlite3_exception(env, SQLITE_OK, "unknown error", message);    }}

/** Class:     com_sabo_sqlite_SQLiteDatabase_SQLiteQuery* Method:    nativeQuery* Signature: (J)[Ljava/lang/String;*/JNIEXPORT jobjectArray JNICALL Java_com_sabo_sqlite_SQLiteDatabase_00024SQLiteQuery_nativeQuery(JNIEnv *env, jobject clazz, jlong statementPtr) {	sqlite3_stmt *pStmt;	jobjectArray objArray;	int nCol;	int i;	int rc;	int nLen;	jchar *zVal;	jclass clazzString;	jstring val;	assert(statementPtr != 0);	pStmt = (sqlite3_stmt *)statementPtr;	nCol = sqlite3_column_count(pStmt);	assert(nCol > 0);	clazzString = env->FindClass("java/lang/String");	assert(clazzString != NULL);	/**	  Ignore to check clazzString.	*/	if (nCol <= 0) throw_sqlite3_exception(env, "[SQLite]: nCol is less than 1.");	objArray = env->NewObjectArray(nCol, clazzString, NULL);	if (objArray == NULL) throw_sqlite3_exception(env, "[SQLite]: Allocate objArray failed (No enough memory)");	rc = sqlite3_step(pStmt);		if (rc == SQLITE_ROW) {		for (i = 0; i < nCol; ++i) {			zVal = (jchar *)sqlite3_column_text16(pStmt, i);			nLen = 0;			if (zVal) {				nLen = sqlite3_column_bytes16(pStmt, i);				assert(nLen > 0);			}			if (nLen > 0) {				val = env->NewString(zVal, nLen/sizeof(jchar));				assert(val != NULL);				if (val == NULL) throw_sqlite3_exception(env, "[SQLite]: NewString failed...");			}			else {				val = NULL;			}			env->SetObjectArrayElement(objArray, i, val);		}	}	else {		if (rc == SQLITE_OK || rc == SQLITE_DONE) {			return NULL;		}		throw_sqlite3_exception(env, "[SQLITE]: Fail to run sqltie3_step.");	}	return objArray;}

/* throw a SQLiteException with a message appropriate for the error in handle   concatenated with the given message */void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle, const char* message) {    if (handle) {        // get the error code and message from the SQLite connection        // the error message may contain more information than the error code        // because it is based on the extended error code rather than the simplified        // error code that SQLite normally returns.        throw_sqlite3_exception(env, sqlite3_extended_errcode(handle),                sqlite3_errmsg(handle), message);    } else {        // we use SQLITE_OK so that a generic SQLiteException is thrown;        // any code not specified in the switch statement below would do.        throw_sqlite3_exception(env, SQLITE_OK, "unknown error", message);    }}

/* public native void native_execSQL(String sql); */static void native_execSQL(JNIEnv* env, jobject object, jstring sqlString){    int err;    int stepErr;    sqlite3_stmt * statement = NULL;    sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);    jchar const * sql = env->GetStringChars(sqlString, NULL);    jsize sqlLen = env->GetStringLength(sqlString);    if (sql == NULL || sqlLen == 0) {        jniThrowException(env, "java/lang/IllegalArgumentException", "You must supply an SQL string");        return;    }    err = sqlite3_prepare16_v2(handle, sql, sqlLen * 2, &statement, NULL);    env->ReleaseStringChars(sqlString, sql);    if (err != SQLITE_OK) {        char const * sql8 = env->GetStringUTFChars(sqlString, NULL);        LOGE("Failure %d (%s) on %p when preparing '%s'./n", err, sqlite3_errmsg(handle), handle, sql8);        throw_sqlite3_exception(env, handle, sql8);        env->ReleaseStringUTFChars(sqlString, sql8);        return;    }    stepErr = sqlite3_step(statement);    err = sqlite3_finalize(statement);    if (stepErr != SQLITE_DONE) {        if (stepErr == SQLITE_ROW) {            throw_sqlite3_exception(env, "Queries cannot be performed using execSQL(), use query() instead.");        } else {            char const * sql8 = env->GetStringUTFChars(sqlString, NULL);            LOGE("Failure %d (%s) on %p when executing '%s'/n", err, sqlite3_errmsg(handle), handle, sql8);            throw_sqlite3_exception(env, handle, sql8);            env->ReleaseStringUTFChars(sqlString, sql8);        }    } else#ifndef DB_LOG_STATEMENTS    IF_LOGV()#endif    {        char const * sql8 = env->GetStringUTFChars(sqlString, NULL);        LOGV("Success on %p when executing '%s'/n", handle, sql8);        env->ReleaseStringUTFChars(sqlString, sql8);    }}

//close dbvoid Java_com_jim_multipos_utils_database_AbstractSQLite_closedb(JNIEnv *env, jobject object, int sqliteHandle) {    sqlite3 *handle = (sqlite3 *)sqliteHandle;    int err = sqlite3_close(handle);    if (SQLITE_OK != err) {        throw_sqlite3_exception(env, handle, err);    }}

static jdouble nativeGetDouble(JNIEnv* env, jclass clazz, jlong windowPtr,        jint row, jint column) {    CursorWindow* window = reinterpret_cast<CursorWindow*>(windowPtr);    LOG_WINDOW("Getting double for %d,%d from %p", row, column, window);    CursorWindow::FieldSlot* fieldSlot = window->getFieldSlot(row, column);    if (!fieldSlot) {        throwExceptionWithRowCol(env, row, column);        return 0.0;    }    int32_t type = window->getFieldSlotType(fieldSlot);    if (type == CursorWindow::FIELD_TYPE_FLOAT) {        return window->getFieldSlotValueDouble(fieldSlot);    } else if (type == CursorWindow::FIELD_TYPE_STRING) {        size_t sizeIncludingNull;        const char* value = window->getFieldSlotValueString(fieldSlot, &sizeIncludingNull);        return sizeIncludingNull > 1 ? strtod(value, NULL) : 0.0;    } else if (type == CursorWindow::FIELD_TYPE_INTEGER) {        return jdouble(window->getFieldSlotValueLong(fieldSlot));    } else if (type == CursorWindow::FIELD_TYPE_NULL) {        return 0.0;    } else if (type == CursorWindow::FIELD_TYPE_BLOB) {        throw_sqlite3_exception(env, "Unable to convert BLOB to double");        return 0.0;    } else {        throwUnknownTypeException(env, type);        return 0.0;    }}

void Java_com_jmv_frre_moduloestudiante_SQLite_SQLiteDatabase_closedb(JNIEnv *env, jobject object, int sqliteHandle) {	sqlite3 *handle = (sqlite3 *)sqliteHandle;	int err = sqlite3_close(handle);	if (SQLITE_OK != err) {		throw_sqlite3_exception(env, handle, err);	}}

void Java_com_jim_multipos_utils_database_SQLitePreparedStatement_reset(JNIEnv *env, jobject object, int statementHandle) {    sqlite3_stmt *handle = (sqlite3_stmt *) statementHandle;    int errcode = sqlite3_reset(handle);    if (SQLITE_OK != errcode) {        throw_sqlite3_exception(env, sqlite3_db_handle(handle), errcode);    }}

static void native_finalize(JNIEnv* env, jobject object){    char buf[66];    strcpy(buf, "com_sqlcrypt_database_SQLiteProgram->native_finalize() not implemented");    throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);    return;}

/* public native void close(); */static void dbclose(JNIEnv* env, jobject object){    sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);    if (handle != NULL) {        // release the memory associated with the traceFuncArg in enableSqlTracing function        void *traceFuncArg = sqlite3_trace(handle, &sqlTrace, NULL);        if (traceFuncArg != NULL) {            free(traceFuncArg);        }        // release the memory associated with the traceFuncArg in enableSqlProfiling function        traceFuncArg = sqlite3_profile(handle, &sqlProfile, NULL);        if (traceFuncArg != NULL) {            free(traceFuncArg);        }        LOGV("Closing database: handle=%p/n", handle);        int result = sqlite3_close(handle);        if (result == SQLITE_OK) {            LOGV("Closed %p/n", handle);            env->SetIntField(object, offset_db_handle, 0);        } else {            // This can happen if sub-objects aren't closed first.  Make sure the caller knows.            throw_sqlite3_exception(env, handle);            LOGE("sqlite3_close(%p) failed: %d/n", handle, result);        }    }}

static void native_compile(JNIEnv* env, jobject object, jstring sqlString){    char buf[65];    strcpy(buf, "android_database_SQLiteProgram->native_compile() not implemented");    throw_sqlite3_exception(env, GET_HANDLE(env, object), buf);    return;}

void Java_ir_persianfox_SQLite_SQLiteDatabase_closedb(JNIEnv *env, jobject object, int sqliteHandle) {	sqlite3 *handle = (sqlite3 *)sqliteHandle;	int err = sqlite3_close(handle);	if (SQLITE_OK != err) {		throw_sqlite3_exception(env, handle, err);	}}

static jlong nativePrepareStatement(JNIEnv* env, jclass clazz, jlong connectionPtr,        jstring sqlString) {    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);    jsize sqlLength = env->GetStringLength(sqlString);    const jchar* sql = env->GetStringCritical(sqlString, NULL);    sqlite3_stmt* statement;    int err = sqlite3_prepare16_v2(connection->db,            sql, sqlLength * sizeof(jchar), &statement, NULL);    env->ReleaseStringCritical(sqlString, sql);    if (err != SQLITE_OK) {        // Error messages like 'near ")": syntax error' are not        // always helpful enough, so construct an error string that        // includes the query itself.        const char *query = env->GetStringUTFChars(sqlString, NULL);        char *message = (char*) malloc(strlen(query) + 50);        if (message) {            strcpy(message, ", while compiling: "); // less than 50 chars            strcat(message, query);        }        env->ReleaseStringUTFChars(sqlString, query);        throw_sqlite3_exception(env, connection->db, message);        free(message);        return 0;    }    ALOGV("Prepared statement %p on connection %p", statement, connection->db);    return reinterpret_cast<jlong>(statement);}

static int executeOneRowQuery(JNIEnv* env, SQLiteConnection* connection, sqlite3_stmt* statement) {    int err = sqlite3_step(statement);    if (err != SQLITE_ROW) {        throw_sqlite3_exception(env, connection->db);    }    return err;}

//bind longvoid Java_com_jim_multipos_utils_database_SQLitePreparedStatement_bindLong(JNIEnv *env, jobject object, int statementHandle, int index, long long value) {    sqlite3_stmt *handle = (sqlite3_stmt *) statementHandle;    int errcode = sqlite3_bind_int64(handle, index, value);    if (SQLITE_OK != errcode) {        throw_sqlite3_exception(env, sqlite3_db_handle(handle), errcode);    }}

void native_key_char(JNIEnv* env, jobject object, jcharArray jKey){  char *keyUtf8        = 0;  int lenUtf8          = 0;  jchar* keyUtf16      = 0;  jsize lenUtf16       = 0;  UErrorCode status    = U_ZERO_ERROR;  UConverter *encoding = 0;  sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle);  keyUtf16 = env->GetCharArrayElements(jKey, 0);  lenUtf16 = env->GetArrayLength(jKey);  // no key, bailing out.  if ( lenUtf16 == 0 ) goto done;  encoding = ucnv_open("UTF-8", &status);  if( U_FAILURE(status) ) {    throw_sqlite3_exception(env, "native_key_char: opening encoding converter failed");    goto done;  }  lenUtf8 = ucnv_fromUChars(encoding, NULL, 0, keyUtf16, lenUtf16, &status);  status = (status == U_BUFFER_OVERFLOW_ERROR) ? U_ZERO_ERROR : status;  if( U_FAILURE(status) ) {    throw_sqlite3_exception(env, "native_key_char: utf8 length unknown");    goto done;  }  keyUtf8 = (char*) malloc(lenUtf8 * sizeof(char));  ucnv_fromUChars(encoding, keyUtf8, lenUtf8, keyUtf16, lenUtf16, &status);  if( U_FAILURE(status) ) {    throw_sqlite3_exception(env, "native_key_char: utf8 conversion failed");    goto done;  }  if ( sqlite3_key(handle, keyUtf8, lenUtf8) != SQLITE_OK ) {    throw_sqlite3_exception(env, handle);  }done:  env->ReleaseCharArrayElements(jKey, keyUtf16, 0);  if(encoding != 0) ucnv_close(encoding);  if(keyUtf8 != 0)  free(keyUtf8);}

static jstring getString_native(JNIEnv* env, jobject object, jint row, jint column){    int32_t err;    CursorWindow * window = GET_WINDOW(env, object);LOG_WINDOW("Getting string for %d,%d from %p", row, column, window);    field_slot_t field;    err = window->read_field_slot(row, column, &field);    if (err != 0) {        throwExceptionWithRowCol(env, row, column);        return NULL;    }    uint8_t type = field.type;    if (type == FIELD_TYPE_STRING) {        uint32_t size = field.data.buffer.size;        if (size > 0) {#if WINDOW_STORAGE_UTF8            // Pass size - 1 since the UTF8 is null terminated and we don't want a null terminator on the UTF16 string            String16 utf16((char const *)window->offsetToPtr(field.data.buffer.offset), size - 1);            return env->NewString((jchar const *)utf16.string(), utf16.size());#else            return env->NewString((jchar const *)window->offsetToPtr(field.data.buffer.offset), size / 2);#endif        } else {            return env->NewStringUTF("");        }    } else if (type == FIELD_TYPE_INTEGER) {        int64_t value;        if (window->getLong(row, column, &value)) {            char buf[32];            snprintf(buf, sizeof(buf), "%lld", value);            return env->NewStringUTF(buf);        }        return NULL;    } else if (type == FIELD_TYPE_FLOAT) {        double value;        if (window->getDouble(row, column, &value)) {            char buf[32];            //selete the print way by code to impove the precision            if (((value > 0.0001) && (value < 1000000)) || ((value < -0.0001) && (value > -1000000)))                snprintf(buf, sizeof(buf), "%lf", value);            else                snprintf(buf, sizeof(buf), "%e", value);            return env->NewStringUTF(buf);        }        return NULL;    } else if (type == FIELD_TYPE_NULL) {        return NULL;    } else if (type == FIELD_TYPE_BLOB) {        throw_sqlite3_exception(env, "Unable to convert BLOB to string");        return NULL;    } else {        throwUnknowTypeException(env, type);        return NULL;    }}

//binding none primitive typesvoid Java_com_jim_multipos_utils_database_SQLitePreparedStatement_bindByteBuffer(JNIEnv *env, jobject object, int statementHandle, int index, jobject value, int length) {    sqlite3_stmt *handle = (sqlite3_stmt *) statementHandle;    void *buf = env->GetDirectBufferAddress(value);    int errcode = sqlite3_bind_blob(handle, index, buf, length, SQLITE_STATIC);    if (SQLITE_OK != errcode) {        throw_sqlite3_exception(env, sqlite3_db_handle(handle), errcode);    }}

ECode CursorWindow::NativeGetBlob(    /* [in] */ Int32 row,    /* [in] */ Int32 column,    /* [out] */ ArrayOf<Byte>** blob){    ECode ec = NOERROR;    int32_t err;    NativeCursorWindow * window = mNativeWindow;    // LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window);    field_slot_t field;    err = window->read_field_slot(row, column, &field);    if (err != 0) {        *blob = NULL;        // throwExceptionWithRowCol(env, row, column);        return E_ILLEGAL_STATE_EXCEPTION;    }    uint8_t type = field.type;    if (type == FIELD_TYPE_BLOB || type == FIELD_TYPE_STRING) {        ArrayOf<Byte>* byteArray = ArrayOf<Byte>::Alloc(field.data.buffer.size);        // LOG_ASSERT(byteArray, "Native could not create new byte[]");        memcpy(byteArray->GetPayload(), window->offsetToPtr(field.data.buffer.offset),                field.data.buffer.size);        *blob = byteArray;        return NOERROR;    }    else if (type == FIELD_TYPE_INTEGER) {        ec = throw_sqlite3_exception(NULL);    }    else if (type == FIELD_TYPE_FLOAT) {        ec = throw_sqlite3_exception(NULL);    }    else if (type == FIELD_TYPE_NULL) {        // do nothing    }    else {        // throwUnknowTypeException(env, type);        ec = E_ILLEGAL_STATE_EXCEPTION;    }    *blob = NULL;    return ec;}

 void native_rawExecSQL(JNIEnv* env, jobject object, jstring sql) {   sqlite3 * handle = (sqlite3 *)env->GetLongField(object, offset_db_handle);   char const * sqlCommand = env->GetStringUTFChars(sql, NULL);   int status = sqlite3_exec(handle, sqlCommand, NULL, NULL, NULL);   env->ReleaseStringUTFChars(sql, sqlCommand);   if(status != SQLITE_OK){     throw_sqlite3_exception(env, handle);   } }

static void nativeBindDouble(JNIEnv* env, jclass clazz, jlong connectionPtr,        jlong statementPtr, jint index, jdouble value) {    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);    sqlite3_stmt* statement = reinterpret_cast<sqlite3_stmt*>(statementPtr);    int err = sqlite3_bind_double(statement, index, value);    if (err != SQLITE_OK) {        throw_sqlite3_exception(env, connection->db, NULL);    }}

static void native_clear_bindings(JNIEnv* env, jobject object){    int err;    sqlite3_stmt * statement = GET_STATEMENT(env, object);    err = sqlite3_clear_bindings(statement);    if (err != SQLITE_OK) {        throw_sqlite3_exception(env, GET_HANDLE(env, object));        return;    }}

 int native_status(JNIEnv* env, jobject object, jint operation, jboolean reset) {   int value;   int highWater;   sqlite3 * handle = (sqlite3 *)env->GetLongField(object, offset_db_handle);   int status = sqlite3_status(operation, &value, &highWater, reset);   if(status != SQLITE_OK){     throw_sqlite3_exception(env, handle);   }   return value; }

//binding stringvoid Java_com_jim_multipos_utils_database_SQLitePreparedStatement_bindString(JNIEnv *env, jobject object, int statementHandle, int index, jstring value) {    sqlite3_stmt *handle = (sqlite3_stmt *) statementHandle;    char const *valueStr = env->GetStringUTFChars(value, 0);    int errcode = sqlite3_bind_text(handle, index, valueStr, -1, SQLITE_TRANSIENT);    if (SQLITE_OK != errcode) {        throw_sqlite3_exception(env, sqlite3_db_handle(handle), errcode);    }    if (valueStr != 0) {        env->ReleaseStringUTFChars(value, valueStr);    }}

static void nativeRegisterLocalizedCollators(JNIEnv* env, jclass clazz, jlong connectionPtr,        jstring localeStr) {    SQLiteConnection* connection = reinterpret_cast<SQLiteConnection*>(connectionPtr);    const char* locale = env->GetStringUTFChars(localeStr, NULL);    int err = register_localized_collators(connection->db, locale, UTF16_STORAGE);    env->ReleaseStringUTFChars(localeStr, locale);    if (err != SQLITE_OK) {        throw_sqlite3_exception(env, connection->db);    }}