/* ** Return UTF-16 encoded English language explanation of the most recent ** error. */ const void *sqlite3_errmsg16(sqlite3 *db){ /* Because all the characters in the string are in the unicode ** range 0x00-0xFF, if we pad the big-endian string with a ** zero byte, we can obtain the little-endian string with ** &big_endian[1]. */ static const char outOfMemBe[] = { 0, 'o', 0, 'u', 0, 't', 0, ' ', 0, 'o', 0, 'f', 0, ' ', 0, 'm', 0, 'e', 0, 'm', 0, 'o', 0, 'r', 0, 'y', 0, 0, 0 }; static const char misuseBe [] = { 0, 'l', 0, 'i', 0, 'b', 0, 'r', 0, 'a', 0, 'r', 0, 'y', 0, ' ', 0, 'r', 0, 'o', 0, 'u', 0, 't', 0, 'i', 0, 'n', 0, 'e', 0, ' ', 0, 'c', 0, 'a', 0, 'l', 0, 'l', 0, 'e', 0, 'd', 0, ' ', 0, 'o', 0, 'u', 0, 't', 0, ' ', 0, 'o', 0, 'f', 0, ' ', 0, 's', 0, 'e', 0, 'q', 0, 'u', 0, 'e', 0, 'n', 0, 'c', 0, 'e', 0, 0, 0 }; const void *z; if( sqlite3_malloc_failed ){ return (void *)(&outOfMemBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]); } if( sqlite3SafetyCheck(db) || db->errCode==SQLITE_MISUSE ){ return (void *)(&misuseBe[SQLITE_UTF16NATIVE==SQLITE_UTF16LE?1:0]); } z = sqlite3_value_text16(db->pErr); if( z==0 ){ sqlite3ValueSetStr(db->pErr, -1, sqlite3ErrStr(db->errCode), SQLITE_UTF8, SQLITE_STATIC); z = sqlite3_value_text16(db->pErr); } return z; }
/* ** Implementation of SQLite REGEXP operator. This scalar function takes ** two arguments. The first is a regular expression pattern to compile ** the second is a string to match against that pattern. If either ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result ** is 1 if the string matches the pattern, or 0 otherwise. ** ** SQLite maps the regexp() function to the regexp() operator such ** that the following two are equivalent: ** ** zString REGEXP zPattern ** regexp(zPattern, zString) ** ** Uses the following ICU regexp APIs: ** ** uregex_open() ** uregex_matches() ** uregex_close() */ static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){ UErrorCode status = U_ZERO_ERROR; URegularExpression *pExpr; UBool res; const UChar *zString = sqlite3_value_text16(apArg[1]); (void)nArg; /* Unused parameter */ /* If the left hand side of the regexp operator is NULL, ** then the result is also NULL. */ if( !zString ){ return; } pExpr = sqlite3_get_auxdata(p, 0); if( !pExpr ){ const UChar *zPattern = sqlite3_value_text16(apArg[0]); if( !zPattern ){ return; } pExpr = uregex_open(zPattern, -1, 0, 0, &status); if( U_SUCCESS(status) ){ sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete); }else{ assert(!pExpr); icuFunctionError(p, "uregex_open", status); return; } } /* Configure the text that the regular expression operates on. */ uregex_setText(pExpr, zString, -1, &status); if( !U_SUCCESS(status) ){ icuFunctionError(p, "uregex_setText", status); return; } /* Attempt the match */ res = uregex_matches(pExpr, 0, &status); if( !U_SUCCESS(status) ){ icuFunctionError(p, "uregex_matches", status); return; } /* Set the text that the regular expression operates on to a NULL ** pointer. This is not really necessary, but it is tidier than ** leaving the regular expression object configured with an invalid ** pointer after this function returns. */ uregex_setText(pExpr, 0, 0, &status); /* Return 1 or 0. */ sqlite3_result_int(p, res ? 1 : 0); }
/* ** This function takes two arguments. It performance UTF-8/16 type ** conversions on the first argument then returns a copy of the second ** argument. ** ** This function is used in cases such as the following: ** ** SELECT test_isolation(x,x) FROM t1; ** ** We want to verify that the type conversions that occur on the ** first argument do not invalidate the second argument. */ static void test_isolation( sqlite3_context *pCtx, int nArg, sqlite3_value **argv ){ #ifndef SQLITE_OMIT_UTF16 sqlite3_value_text16(argv[0]); sqlite3_value_text(argv[0]); sqlite3_value_text16(argv[0]); sqlite3_value_text(argv[0]); #endif sqlite3_result_value(pCtx, argv[1]); }
SQLValue SQLiteStatement::getColumnValue(int col) { ASSERT(col >= 0); if (!m_statement) if (prepareAndStep() != SQLITE_ROW) return SQLValue(); if (columnCount() <= col) return SQLValue(); // SQLite is typed per value. optional column types are // "(mostly) ignored" sqlite3_value* value = sqlite3_column_value(m_statement, col); switch (sqlite3_value_type(value)) { case SQLITE_INTEGER: // SQLValue and JS don't represent integers, so use FLOAT -case case SQLITE_FLOAT: return SQLValue(sqlite3_value_double(value)); case SQLITE_BLOB: // SQLValue and JS don't represent blobs, so use TEXT -case case SQLITE_TEXT: { const UChar* string = reinterpret_cast<const UChar*>(sqlite3_value_text16(value)); unsigned length = WTF::lengthOfNullTerminatedString(string); return SQLValue(StringImpl::create8BitIfPossible(string, length)); } case SQLITE_NULL: return SQLValue(); default: break; } ASSERT_NOT_REACHED(); return SQLValue(); }
/* ** Implementations of scalar functions for case mapping - upper() and ** lower(). Function upper() converts its input to upper-case (ABC). ** Function lower() converts to lower-case (abc). ** ** ICU provides two types of case mapping, "general" case mapping and ** "language specific". Refer to ICU documentation for the differences ** between the two. ** ** To utilise "general" case mapping, the upper() or lower() scalar ** functions are invoked with one argument: ** ** upper('ABC') -> 'abc' ** lower('abc') -> 'ABC' ** ** To access ICU "language specific" case mapping, upper() or lower() ** should be invoked with two arguments. The second argument is the name ** of the locale to use. Passing an empty string ("") or SQL NULL value ** as the second argument is the same as invoking the 1 argument version ** of upper() or lower(). ** ** lower('I', 'en_us') -> 'i' ** lower('I', 'tr_tr') -> '\u131' (small dotless i) ** ** http://www.icu-project.org/userguide/posix.html#case_mappings */ static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){ const UChar *zInput; /* Pointer to input string */ UChar *zOutput = 0; /* Pointer to output buffer */ int nInput; /* Size of utf-16 input string in bytes */ int nOut; /* Size of output buffer in bytes */ int cnt; int bToUpper; /* True for toupper(), false for tolower() */ UErrorCode status; const char *zLocale = 0; assert(nArg==1 || nArg==2); bToUpper = (sqlite3_user_data(p)!=0); if( nArg==2 ){ zLocale = (const char *)sqlite3_value_text(apArg[1]); } zInput = sqlite3_value_text16(apArg[0]); if( !zInput ){ return; } nOut = nInput = sqlite3_value_bytes16(apArg[0]); if( nOut==0 ){ sqlite3_result_text16(p, "", 0, SQLITE_STATIC); return; } for(cnt=0; cnt<2; cnt++){ UChar *zNew = sqlite3_realloc(zOutput, nOut); if( zNew==0 ){ sqlite3_free(zOutput); sqlite3_result_error_nomem(p); return; } zOutput = zNew; status = U_ZERO_ERROR; if( bToUpper ){ nOut = 2*u_strToUpper(zOutput,nOut/2,zInput,nInput/2,zLocale,&status); }else{ nOut = 2*u_strToLower(zOutput,nOut/2,zInput,nInput/2,zLocale,&status); } if( U_SUCCESS(status) ){ sqlite3_result_text16(p, zOutput, nOut, xFree); }else if( status==U_BUFFER_OVERFLOW_ERROR ){ assert( cnt==0 ); continue; }else{ icuFunctionError(p, bToUpper ? "u_strToUpper" : "u_strToLower", status); } return; } assert( 0 ); /* Unreachable */ }
ikptr ik_sqlite3_value_text16 (ikptr s_value, ikpcb * pcb) { #ifdef HAVE_SQLITE3_VALUE_TEXT16 sqlite3_value * value = IK_SQLITE_VALUE(s_value); const void * data; int bytes; bytes = sqlite3_value_bytes16(value); data = sqlite3_value_text16(value); return ika_bytevector_from_memory_block(pcb, data, bytes); #else feature_failure(__func__); #endif }
static void getUnicodeResult(const RtlFieldInfo *field, sqlite3_value *val, size32_t &chars, UChar * &result) { assertex(val); if (isNull(val)) { NullFieldProcessor p(field); rtlUnicodeToUnicodeX(chars, result, p.resultChars, p.unicodeResult); return; } if (sqlite3_value_type(val) != SQLITE_TEXT) typeError("string", field); const UChar *text = (const UChar *) sqlite3_value_text16(val); int bytes = sqlite3_value_bytes16(val); unsigned numchars = bytes / sizeof(UChar); rtlUnicodeToUnicodeX(chars, result, numchars, text); }
/* ** UTF-16 implementation of the substr() */ void sqlite3utf16Substr( sqlite3_context *context, int argc, sqlite3_value **argv ){ int y, z; unsigned char const *zStr; unsigned char const *zStrEnd; unsigned char const *zStart; unsigned char const *zEnd; int i; zStr = (unsigned char const *)sqlite3_value_text16(argv[0]); zStrEnd = &zStr[sqlite3_value_bytes16(argv[0])]; y = sqlite3_value_int(argv[1]); z = sqlite3_value_int(argv[2]); if( y>0 ){ y = y-1; zStart = zStr; if( SQLITE_UTF16BE==SQLITE_UTF16NATIVE ){ for(i=0; i<y && zStart<zStrEnd; i++) SKIP_UTF16BE(zStart); }else{ for(i=0; i<y && zStart<zStrEnd; i++) SKIP_UTF16LE(zStart); } }else{ zStart = zStrEnd; if( SQLITE_UTF16BE==SQLITE_UTF16NATIVE ){ for(i=y; i<0 && zStart>zStr; i++) RSKIP_UTF16BE(zStart); }else{ for(i=y; i<0 && zStart>zStr; i++) RSKIP_UTF16LE(zStart); } for(; i<0; i++) z -= 1; } zEnd = zStart; if( SQLITE_UTF16BE==SQLITE_UTF16NATIVE ){ for(i=0; i<z && zEnd<zStrEnd; i++) SKIP_UTF16BE(zEnd); }else{ for(i=0; i<z && zEnd<zStrEnd; i++) SKIP_UTF16LE(zEnd); } sqlite3_result_text16(context, zStart, zEnd-zStart, SQLITE_TRANSIENT); }
// Called each time a custom function is evaluated. static void sqliteCustomFunctionCallback(sqlite3_context *context, int argc, sqlite3_value **argv) { JNIEnv* env = AndroidRuntime::getJNIEnv(); // Get the callback function object. // Create a new local reference to it in case the callback tries to do something // dumb like unregister the function (thereby destroying the global ref) while it is running. jobject functionObjGlobal = reinterpret_cast<jobject>(sqlite3_user_data(context)); jobject functionObj = env->NewLocalRef(functionObjGlobal); jobjectArray argsArray = env->NewObjectArray(argc, gStringClassInfo.clazz, NULL); if (argsArray) { for (int i = 0; i < argc; i++) { const jchar* arg = static_cast<const jchar*>(sqlite3_value_text16(argv[i])); if (!arg) { ALOGW("NULL argument in custom_function_callback. This should not happen."); } else { size_t argLen = sqlite3_value_bytes16(argv[i]) / sizeof(jchar); jstring argStr = env->NewString(arg, argLen); if (!argStr) { goto error; // out of memory error } env->SetObjectArrayElement(argsArray, i, argStr); env->DeleteLocalRef(argStr); } } // TODO: Support functions that return values. env->CallVoidMethod(functionObj, gSQLiteCustomFunctionClassInfo.dispatchCallback, argsArray); error: env->DeleteLocalRef(argsArray); } env->DeleteLocalRef(functionObj); if (env->ExceptionCheck()) { ALOGE("An exception was thrown by custom SQLite function."); LOGE_EX(env); env->ExceptionClear(); } }
/* ** Implementations of scalar functions for case mapping - upper() and ** lower(). Function upper() converts its input to upper-case (ABC). ** Function lower() converts to lower-case (abc). ** ** ICU provides two types of case mapping, "general" case mapping and ** "language specific". Refer to ICU documentation for the differences ** between the two. ** ** To utilise "general" case mapping, the upper() or lower() scalar ** functions are invoked with one argument: ** ** upper('ABC') -> 'abc' ** lower('abc') -> 'ABC' ** ** To access ICU "language specific" case mapping, upper() or lower() ** should be invoked with two arguments. The second argument is the name ** of the locale to use. Passing an empty string ("") or SQL NULL value ** as the second argument is the same as invoking the 1 argument version ** of upper() or lower(). ** ** lower('I', 'en_us') -> 'i' ** lower('I', 'tr_tr') -> 'ı' (small dotless i) ** ** http://www.icu-project.org/userguide/posix.html#case_mappings */ static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){ const UChar *zInput; UChar *zOutput; int nInput; int nOutput; UErrorCode status = U_ZERO_ERROR; const char *zLocale = 0; assert(nArg==1 || nArg==2); if( nArg==2 ){ zLocale = (const char *)sqlite3_value_text(apArg[1]); } zInput = sqlite3_value_text16(apArg[0]); if( !zInput ){ return; } nInput = sqlite3_value_bytes16(apArg[0]); nOutput = nInput * 2 + 2; zOutput = sqlite3_malloc(nOutput); if( !zOutput ){ return; } if( sqlite3_user_data(p) ){ u_strToUpper(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status); }else{ u_strToLower(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status); } if( !U_SUCCESS(status) ){ icuFunctionError(p, "u_strToLower()/u_strToUpper", status); return; } sqlite3_result_text16(p, zOutput, -1, xFree); }
static void test_destructor16( sqlite3_context *pCtx, int nArg, sqlite3_value **argv ){ char *zVal; int len; test_destructor_count_var++; assert( nArg==1 ); if( sqlite3_value_type(argv[0])==SQLITE_NULL ) return; len = sqlite3_value_bytes16(argv[0]); zVal = testContextMalloc(pCtx, len+3); if( !zVal ){ return; } zVal[len+1] = 0; zVal[len+2] = 0; zVal++; memcpy(zVal, sqlite3_value_text16(argv[0]), len); sqlite3_result_text16(pCtx, zVal, -1, destructor); }
const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){ const void *val = sqlite3_value_text16( columnMem(pStmt,i) ); columnMallocFailure(pStmt); return val; }
/** * This function is invoked as: * * _TOKENIZE('<token_table>', <data_row_id>, <data>, <delimiter>, * <use_token_index>, <data_tag>) * * If <use_token_index> is omitted, it is treated as 0. * If <data_tag> is omitted, it is treated as NULL. * * It will split <data> on each instance of <delimiter> and insert each token * into <token_table>. The following columns in <token_table> are used: * token TEXT, source INTEGER, token_index INTEGER, tag (any type) * The token_index column is not required if <use_token_index> is 0. * The tag column is not required if <data_tag> is NULL. * * One row is inserted for each token in <data>. * In each inserted row, 'source' is <data_row_id>. * In the first inserted row, 'token' is the hex collation key of * the entire <data> string, and 'token_index' is 0. * In each row I (where 1 <= I < N, and N is the number of tokens in <data>) * 'token' will be set to the hex collation key of the I:th token (0-based). * If <use_token_index> != 0, 'token_index' is set to I. * If <data_tag> is not NULL, 'tag' is set to <data_tag>. * * In other words, there will be one row for the entire string, * and one row for each token except the first one. * * The function returns the number of tokens generated. */ static void tokenize(sqlite3_context * context, int argc, sqlite3_value ** argv) { //ALOGD("enter tokenize"); int err; int useTokenIndex = 0; int useDataTag = 0; if (!(argc >= 4 || argc <= 6)) { ALOGE("Tokenize requires 4 to 6 arguments"); sqlite3_result_null(context); return; } if (argc > 4) { useTokenIndex = sqlite3_value_int(argv[4]); } if (argc > 5) { useDataTag = (sqlite3_value_type(argv[5]) != SQLITE_NULL); } sqlite3 * handle = sqlite3_context_db_handle(context); UCollator* collator = (UCollator*)sqlite3_user_data(context); char const * tokenTable = (char const *)sqlite3_value_text(argv[0]); if (tokenTable == NULL) { ALOGE("tokenTable null"); sqlite3_result_null(context); return; } // Get or create the prepared statement for the insertions sqlite3_stmt * statement = (sqlite3_stmt *)sqlite3_get_auxdata(context, 0); if (!statement) { char const * tokenIndexCol = useTokenIndex ? ", token_index" : ""; char const * tokenIndexParam = useTokenIndex ? ", ?" : ""; char const * dataTagCol = useDataTag ? ", tag" : ""; char const * dataTagParam = useDataTag ? ", ?" : ""; char * sql = sqlite3_mprintf("INSERT INTO %s (token, source%s%s) VALUES (?, ?%s%s);", tokenTable, tokenIndexCol, dataTagCol, tokenIndexParam, dataTagParam); err = sqlite3_prepare_v2(handle, sql, -1, &statement, NULL); sqlite3_free(sql); if (err) { ALOGE("prepare failed"); sqlite3_result_null(context); return; } // This binds the statement to the table it was compiled against, which is argv[0]. // If this function is ever called with a different table the finalizer will be called // and sqlite3_get_auxdata() will return null above, forcing a recompile for the new table. sqlite3_set_auxdata(context, 0, statement, tokenize_auxdata_delete); } else { // Reset the cached statement so that binding the row ID will work properly sqlite3_reset(statement); } // Bind the row ID of the source row int64_t rowID = sqlite3_value_int64(argv[1]); err = sqlite3_bind_int64(statement, 2, rowID); if (err != SQLITE_OK) { ALOGE("bind failed"); sqlite3_result_null(context); return; } // Bind <data_tag> to the tag column if (useDataTag) { int dataTagParamIndex = useTokenIndex ? 4 : 3; err = sqlite3_bind_value(statement, dataTagParamIndex, argv[5]); if (err != SQLITE_OK) { ALOGE("bind failed"); sqlite3_result_null(context); return; } } // Get the raw bytes for the string to tokenize // the string will be modified by following code // however, sqlite did not reuse the string, so it is safe to not dup it UChar * origData = (UChar *)sqlite3_value_text16(argv[2]); if (origData == NULL) { sqlite3_result_null(context); return; } // Get the raw bytes for the delimiter const UChar * delim = (const UChar *)sqlite3_value_text16(argv[3]); if (delim == NULL) { ALOGE("can't get delimiter"); sqlite3_result_null(context); return; } UChar * token = NULL; UChar *state; int numTokens = 0; do { if (numTokens == 0) { token = origData; } // Reset the program so we can use it to perform the insert sqlite3_reset(statement); UErrorCode status = U_ZERO_ERROR; char keybuf[1024]; uint32_t result = ucol_getSortKey(collator, token, -1, (uint8_t*)keybuf, sizeof(keybuf)-1); if (result > sizeof(keybuf)) { // TODO allocate memory for this super big string ALOGE("ucol_getSortKey needs bigger buffer %d", result); break; } uint32_t keysize = result-1; uint32_t base16Size = keysize*2; char *base16buf = (char*)malloc(base16Size); base16Encode(base16buf, keybuf, keysize); err = sqlite3_bind_text(statement, 1, base16buf, base16Size, SQLITE_STATIC); if (err != SQLITE_OK) { ALOGE(" sqlite3_bind_text16 error %d", err); free(base16buf); break; } if (useTokenIndex) { err = sqlite3_bind_int(statement, 3, numTokens); if (err != SQLITE_OK) { ALOGE(" sqlite3_bind_int error %d", err); free(base16buf); break; } } err = sqlite3_step(statement); free(base16buf); if (err != SQLITE_DONE) { ALOGE(" sqlite3_step error %d", err); break; } numTokens++; if (numTokens == 1) { // first call u_strtok_r(origData, delim, &state); } } while ((token = u_strtok_r(NULL, delim, &state)) != NULL); sqlite3_result_int(context, numTokens); }
__declspec(dllexport) const void * WINAPI sqlite3_value_text16_interop(sqlite3_value *val, int *plen) { const void *pval = sqlite3_value_text16(val); *plen = (pval != 0) ? wcslen((wchar_t *)pval) * sizeof(wchar_t) : 0; return pval; }
const void *sqlite3_column_text16(sqlite3_stmt *pStmt, int i){ return sqlite3_value_text16( columnMem(pStmt,i) ); }
static void mmenc_func(sqlite3_context *db, int argc, sqlite3_value **argv) { mm_cipher_context_t *ctx; const UChar *src; int32_t src_len; char buf[1024]; char *dst = buf; int32_t dst_len; UErrorCode status = U_ZERO_ERROR; int arg_type; // only accept 1 argument. if (argc != 1) goto error_misuse; // encoding BLOB data type is not supported. arg_type = sqlite3_value_type(argv[0]); if (arg_type == SQLITE_BLOB) goto error_misuse; // for data types other than TEXT, just return them. if (arg_type != SQLITE_TEXT) { sqlite3_result_value(db, argv[0]); return; } ctx = (mm_cipher_context_t *) sqlite3_user_data(db); src_len = sqlite3_value_bytes16(argv[0]) / 2; src = (const UChar *) sqlite3_value_text16(argv[0]); // transform input string to BOCU-1 encoding. // try stack buffer first, if it doesn't fit, malloc a new buffer. dst_len = ucnv_fromUChars(ctx->cnv, dst, sizeof(buf), src, src_len, &status); if (status == U_BUFFER_OVERFLOW_ERROR) { status = U_ZERO_ERROR; dst = (char *) sqlite3_malloc(dst_len); dst_len = ucnv_fromUChars(ctx->cnv, dst, dst_len, src, src_len, &status); } if (U_FAILURE(status) && status != U_STRING_NOT_TERMINATED_WARNING) { sqlite3_mm_set_last_error( "Failed transforming text to internal encoding."); goto error_error; } // encrypt transformed BOCU-1 string. do_rc4(ctx, dst, dst_len); // return sqlite3_result_blob(db, dst, dst_len, SQLITE_TRANSIENT); if (dst != buf) sqlite3_free(dst); return; error_error: if (dst != buf) sqlite3_free(dst); sqlite3_result_error_code(db, SQLITE_ERROR); return; error_misuse: if (dst != buf) sqlite3_free(dst); sqlite3_result_error_code(db, SQLITE_MISUSE); return; }