Annotation of embedaddon/sqlite3/ext/icu/icu.c, revision 1.1
1.1 ! misho 1: /*
! 2: ** 2007 May 6
! 3: **
! 4: ** The author disclaims copyright to this source code. In place of
! 5: ** a legal notice, here is a blessing:
! 6: **
! 7: ** May you do good and not evil.
! 8: ** May you find forgiveness for yourself and forgive others.
! 9: ** May you share freely, never taking more than you give.
! 10: **
! 11: *************************************************************************
! 12: ** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $
! 13: **
! 14: ** This file implements an integration between the ICU library
! 15: ** ("International Components for Unicode", an open-source library
! 16: ** for handling unicode data) and SQLite. The integration uses
! 17: ** ICU to provide the following to SQLite:
! 18: **
! 19: ** * An implementation of the SQL regexp() function (and hence REGEXP
! 20: ** operator) using the ICU uregex_XX() APIs.
! 21: **
! 22: ** * Implementations of the SQL scalar upper() and lower() functions
! 23: ** for case mapping.
! 24: **
! 25: ** * Integration of ICU and SQLite collation seqences.
! 26: **
! 27: ** * An implementation of the LIKE operator that uses ICU to
! 28: ** provide case-independent matching.
! 29: */
! 30:
! 31: #if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU)
! 32:
! 33: /* Include ICU headers */
! 34: #include <unicode/utypes.h>
! 35: #include <unicode/uregex.h>
! 36: #include <unicode/ustring.h>
! 37: #include <unicode/ucol.h>
! 38:
! 39: #include <assert.h>
! 40:
! 41: #ifndef SQLITE_CORE
! 42: #include "sqlite3ext.h"
! 43: SQLITE_EXTENSION_INIT1
! 44: #else
! 45: #include "sqlite3.h"
! 46: #endif
! 47:
! 48: /*
! 49: ** Maximum length (in bytes) of the pattern in a LIKE or GLOB
! 50: ** operator.
! 51: */
! 52: #ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH
! 53: # define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000
! 54: #endif
! 55:
! 56: /*
! 57: ** Version of sqlite3_free() that is always a function, never a macro.
! 58: */
! 59: static void xFree(void *p){
! 60: sqlite3_free(p);
! 61: }
! 62:
! 63: /*
! 64: ** Compare two UTF-8 strings for equality where the first string is
! 65: ** a "LIKE" expression. Return true (1) if they are the same and
! 66: ** false (0) if they are different.
! 67: */
! 68: static int icuLikeCompare(
! 69: const uint8_t *zPattern, /* LIKE pattern */
! 70: const uint8_t *zString, /* The UTF-8 string to compare against */
! 71: const UChar32 uEsc /* The escape character */
! 72: ){
! 73: static const int MATCH_ONE = (UChar32)'_';
! 74: static const int MATCH_ALL = (UChar32)'%';
! 75:
! 76: int iPattern = 0; /* Current byte index in zPattern */
! 77: int iString = 0; /* Current byte index in zString */
! 78:
! 79: int prevEscape = 0; /* True if the previous character was uEsc */
! 80:
! 81: while( zPattern[iPattern]!=0 ){
! 82:
! 83: /* Read (and consume) the next character from the input pattern. */
! 84: UChar32 uPattern;
! 85: U8_NEXT_UNSAFE(zPattern, iPattern, uPattern);
! 86: assert(uPattern!=0);
! 87:
! 88: /* There are now 4 possibilities:
! 89: **
! 90: ** 1. uPattern is an unescaped match-all character "%",
! 91: ** 2. uPattern is an unescaped match-one character "_",
! 92: ** 3. uPattern is an unescaped escape character, or
! 93: ** 4. uPattern is to be handled as an ordinary character
! 94: */
! 95: if( !prevEscape && uPattern==MATCH_ALL ){
! 96: /* Case 1. */
! 97: uint8_t c;
! 98:
! 99: /* Skip any MATCH_ALL or MATCH_ONE characters that follow a
! 100: ** MATCH_ALL. For each MATCH_ONE, skip one character in the
! 101: ** test string.
! 102: */
! 103: while( (c=zPattern[iPattern]) == MATCH_ALL || c == MATCH_ONE ){
! 104: if( c==MATCH_ONE ){
! 105: if( zString[iString]==0 ) return 0;
! 106: U8_FWD_1_UNSAFE(zString, iString);
! 107: }
! 108: iPattern++;
! 109: }
! 110:
! 111: if( zPattern[iPattern]==0 ) return 1;
! 112:
! 113: while( zString[iString] ){
! 114: if( icuLikeCompare(&zPattern[iPattern], &zString[iString], uEsc) ){
! 115: return 1;
! 116: }
! 117: U8_FWD_1_UNSAFE(zString, iString);
! 118: }
! 119: return 0;
! 120:
! 121: }else if( !prevEscape && uPattern==MATCH_ONE ){
! 122: /* Case 2. */
! 123: if( zString[iString]==0 ) return 0;
! 124: U8_FWD_1_UNSAFE(zString, iString);
! 125:
! 126: }else if( !prevEscape && uPattern==uEsc){
! 127: /* Case 3. */
! 128: prevEscape = 1;
! 129:
! 130: }else{
! 131: /* Case 4. */
! 132: UChar32 uString;
! 133: U8_NEXT_UNSAFE(zString, iString, uString);
! 134: uString = u_foldCase(uString, U_FOLD_CASE_DEFAULT);
! 135: uPattern = u_foldCase(uPattern, U_FOLD_CASE_DEFAULT);
! 136: if( uString!=uPattern ){
! 137: return 0;
! 138: }
! 139: prevEscape = 0;
! 140: }
! 141: }
! 142:
! 143: return zString[iString]==0;
! 144: }
! 145:
! 146: /*
! 147: ** Implementation of the like() SQL function. This function implements
! 148: ** the build-in LIKE operator. The first argument to the function is the
! 149: ** pattern and the second argument is the string. So, the SQL statements:
! 150: **
! 151: ** A LIKE B
! 152: **
! 153: ** is implemented as like(B, A). If there is an escape character E,
! 154: **
! 155: ** A LIKE B ESCAPE E
! 156: **
! 157: ** is mapped to like(B, A, E).
! 158: */
! 159: static void icuLikeFunc(
! 160: sqlite3_context *context,
! 161: int argc,
! 162: sqlite3_value **argv
! 163: ){
! 164: const unsigned char *zA = sqlite3_value_text(argv[0]);
! 165: const unsigned char *zB = sqlite3_value_text(argv[1]);
! 166: UChar32 uEsc = 0;
! 167:
! 168: /* Limit the length of the LIKE or GLOB pattern to avoid problems
! 169: ** of deep recursion and N*N behavior in patternCompare().
! 170: */
! 171: if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){
! 172: sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);
! 173: return;
! 174: }
! 175:
! 176:
! 177: if( argc==3 ){
! 178: /* The escape character string must consist of a single UTF-8 character.
! 179: ** Otherwise, return an error.
! 180: */
! 181: int nE= sqlite3_value_bytes(argv[2]);
! 182: const unsigned char *zE = sqlite3_value_text(argv[2]);
! 183: int i = 0;
! 184: if( zE==0 ) return;
! 185: U8_NEXT(zE, i, nE, uEsc);
! 186: if( i!=nE){
! 187: sqlite3_result_error(context,
! 188: "ESCAPE expression must be a single character", -1);
! 189: return;
! 190: }
! 191: }
! 192:
! 193: if( zA && zB ){
! 194: sqlite3_result_int(context, icuLikeCompare(zA, zB, uEsc));
! 195: }
! 196: }
! 197:
! 198: /*
! 199: ** This function is called when an ICU function called from within
! 200: ** the implementation of an SQL scalar function returns an error.
! 201: **
! 202: ** The scalar function context passed as the first argument is
! 203: ** loaded with an error message based on the following two args.
! 204: */
! 205: static void icuFunctionError(
! 206: sqlite3_context *pCtx, /* SQLite scalar function context */
! 207: const char *zName, /* Name of ICU function that failed */
! 208: UErrorCode e /* Error code returned by ICU function */
! 209: ){
! 210: char zBuf[128];
! 211: sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));
! 212: zBuf[127] = '\0';
! 213: sqlite3_result_error(pCtx, zBuf, -1);
! 214: }
! 215:
! 216: /*
! 217: ** Function to delete compiled regexp objects. Registered as
! 218: ** a destructor function with sqlite3_set_auxdata().
! 219: */
! 220: static void icuRegexpDelete(void *p){
! 221: URegularExpression *pExpr = (URegularExpression *)p;
! 222: uregex_close(pExpr);
! 223: }
! 224:
! 225: /*
! 226: ** Implementation of SQLite REGEXP operator. This scalar function takes
! 227: ** two arguments. The first is a regular expression pattern to compile
! 228: ** the second is a string to match against that pattern. If either
! 229: ** argument is an SQL NULL, then NULL Is returned. Otherwise, the result
! 230: ** is 1 if the string matches the pattern, or 0 otherwise.
! 231: **
! 232: ** SQLite maps the regexp() function to the regexp() operator such
! 233: ** that the following two are equivalent:
! 234: **
! 235: ** zString REGEXP zPattern
! 236: ** regexp(zPattern, zString)
! 237: **
! 238: ** Uses the following ICU regexp APIs:
! 239: **
! 240: ** uregex_open()
! 241: ** uregex_matches()
! 242: ** uregex_close()
! 243: */
! 244: static void icuRegexpFunc(sqlite3_context *p, int nArg, sqlite3_value **apArg){
! 245: UErrorCode status = U_ZERO_ERROR;
! 246: URegularExpression *pExpr;
! 247: UBool res;
! 248: const UChar *zString = sqlite3_value_text16(apArg[1]);
! 249:
! 250: (void)nArg; /* Unused parameter */
! 251:
! 252: /* If the left hand side of the regexp operator is NULL,
! 253: ** then the result is also NULL.
! 254: */
! 255: if( !zString ){
! 256: return;
! 257: }
! 258:
! 259: pExpr = sqlite3_get_auxdata(p, 0);
! 260: if( !pExpr ){
! 261: const UChar *zPattern = sqlite3_value_text16(apArg[0]);
! 262: if( !zPattern ){
! 263: return;
! 264: }
! 265: pExpr = uregex_open(zPattern, -1, 0, 0, &status);
! 266:
! 267: if( U_SUCCESS(status) ){
! 268: sqlite3_set_auxdata(p, 0, pExpr, icuRegexpDelete);
! 269: }else{
! 270: assert(!pExpr);
! 271: icuFunctionError(p, "uregex_open", status);
! 272: return;
! 273: }
! 274: }
! 275:
! 276: /* Configure the text that the regular expression operates on. */
! 277: uregex_setText(pExpr, zString, -1, &status);
! 278: if( !U_SUCCESS(status) ){
! 279: icuFunctionError(p, "uregex_setText", status);
! 280: return;
! 281: }
! 282:
! 283: /* Attempt the match */
! 284: res = uregex_matches(pExpr, 0, &status);
! 285: if( !U_SUCCESS(status) ){
! 286: icuFunctionError(p, "uregex_matches", status);
! 287: return;
! 288: }
! 289:
! 290: /* Set the text that the regular expression operates on to a NULL
! 291: ** pointer. This is not really necessary, but it is tidier than
! 292: ** leaving the regular expression object configured with an invalid
! 293: ** pointer after this function returns.
! 294: */
! 295: uregex_setText(pExpr, 0, 0, &status);
! 296:
! 297: /* Return 1 or 0. */
! 298: sqlite3_result_int(p, res ? 1 : 0);
! 299: }
! 300:
! 301: /*
! 302: ** Implementations of scalar functions for case mapping - upper() and
! 303: ** lower(). Function upper() converts its input to upper-case (ABC).
! 304: ** Function lower() converts to lower-case (abc).
! 305: **
! 306: ** ICU provides two types of case mapping, "general" case mapping and
! 307: ** "language specific". Refer to ICU documentation for the differences
! 308: ** between the two.
! 309: **
! 310: ** To utilise "general" case mapping, the upper() or lower() scalar
! 311: ** functions are invoked with one argument:
! 312: **
! 313: ** upper('ABC') -> 'abc'
! 314: ** lower('abc') -> 'ABC'
! 315: **
! 316: ** To access ICU "language specific" case mapping, upper() or lower()
! 317: ** should be invoked with two arguments. The second argument is the name
! 318: ** of the locale to use. Passing an empty string ("") or SQL NULL value
! 319: ** as the second argument is the same as invoking the 1 argument version
! 320: ** of upper() or lower().
! 321: **
! 322: ** lower('I', 'en_us') -> 'i'
! 323: ** lower('I', 'tr_tr') -> 'ı' (small dotless i)
! 324: **
! 325: ** http://www.icu-project.org/userguide/posix.html#case_mappings
! 326: */
! 327: static void icuCaseFunc16(sqlite3_context *p, int nArg, sqlite3_value **apArg){
! 328: const UChar *zInput;
! 329: UChar *zOutput;
! 330: int nInput;
! 331: int nOutput;
! 332:
! 333: UErrorCode status = U_ZERO_ERROR;
! 334: const char *zLocale = 0;
! 335:
! 336: assert(nArg==1 || nArg==2);
! 337: if( nArg==2 ){
! 338: zLocale = (const char *)sqlite3_value_text(apArg[1]);
! 339: }
! 340:
! 341: zInput = sqlite3_value_text16(apArg[0]);
! 342: if( !zInput ){
! 343: return;
! 344: }
! 345: nInput = sqlite3_value_bytes16(apArg[0]);
! 346:
! 347: nOutput = nInput * 2 + 2;
! 348: zOutput = sqlite3_malloc(nOutput);
! 349: if( !zOutput ){
! 350: return;
! 351: }
! 352:
! 353: if( sqlite3_user_data(p) ){
! 354: u_strToUpper(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status);
! 355: }else{
! 356: u_strToLower(zOutput, nOutput/2, zInput, nInput/2, zLocale, &status);
! 357: }
! 358:
! 359: if( !U_SUCCESS(status) ){
! 360: icuFunctionError(p, "u_strToLower()/u_strToUpper", status);
! 361: return;
! 362: }
! 363:
! 364: sqlite3_result_text16(p, zOutput, -1, xFree);
! 365: }
! 366:
! 367: /*
! 368: ** Collation sequence destructor function. The pCtx argument points to
! 369: ** a UCollator structure previously allocated using ucol_open().
! 370: */
! 371: static void icuCollationDel(void *pCtx){
! 372: UCollator *p = (UCollator *)pCtx;
! 373: ucol_close(p);
! 374: }
! 375:
! 376: /*
! 377: ** Collation sequence comparison function. The pCtx argument points to
! 378: ** a UCollator structure previously allocated using ucol_open().
! 379: */
! 380: static int icuCollationColl(
! 381: void *pCtx,
! 382: int nLeft,
! 383: const void *zLeft,
! 384: int nRight,
! 385: const void *zRight
! 386: ){
! 387: UCollationResult res;
! 388: UCollator *p = (UCollator *)pCtx;
! 389: res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2);
! 390: switch( res ){
! 391: case UCOL_LESS: return -1;
! 392: case UCOL_GREATER: return +1;
! 393: case UCOL_EQUAL: return 0;
! 394: }
! 395: assert(!"Unexpected return value from ucol_strcoll()");
! 396: return 0;
! 397: }
! 398:
! 399: /*
! 400: ** Implementation of the scalar function icu_load_collation().
! 401: **
! 402: ** This scalar function is used to add ICU collation based collation
! 403: ** types to an SQLite database connection. It is intended to be called
! 404: ** as follows:
! 405: **
! 406: ** SELECT icu_load_collation(<locale>, <collation-name>);
! 407: **
! 408: ** Where <locale> is a string containing an ICU locale identifier (i.e.
! 409: ** "en_AU", "tr_TR" etc.) and <collation-name> is the name of the
! 410: ** collation sequence to create.
! 411: */
! 412: static void icuLoadCollation(
! 413: sqlite3_context *p,
! 414: int nArg,
! 415: sqlite3_value **apArg
! 416: ){
! 417: sqlite3 *db = (sqlite3 *)sqlite3_user_data(p);
! 418: UErrorCode status = U_ZERO_ERROR;
! 419: const char *zLocale; /* Locale identifier - (eg. "jp_JP") */
! 420: const char *zName; /* SQL Collation sequence name (eg. "japanese") */
! 421: UCollator *pUCollator; /* ICU library collation object */
! 422: int rc; /* Return code from sqlite3_create_collation_x() */
! 423:
! 424: assert(nArg==2);
! 425: zLocale = (const char *)sqlite3_value_text(apArg[0]);
! 426: zName = (const char *)sqlite3_value_text(apArg[1]);
! 427:
! 428: if( !zLocale || !zName ){
! 429: return;
! 430: }
! 431:
! 432: pUCollator = ucol_open(zLocale, &status);
! 433: if( !U_SUCCESS(status) ){
! 434: icuFunctionError(p, "ucol_open", status);
! 435: return;
! 436: }
! 437: assert(p);
! 438:
! 439: rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator,
! 440: icuCollationColl, icuCollationDel
! 441: );
! 442: if( rc!=SQLITE_OK ){
! 443: ucol_close(pUCollator);
! 444: sqlite3_result_error(p, "Error registering collation function", -1);
! 445: }
! 446: }
! 447:
! 448: /*
! 449: ** Register the ICU extension functions with database db.
! 450: */
! 451: int sqlite3IcuInit(sqlite3 *db){
! 452: struct IcuScalar {
! 453: const char *zName; /* Function name */
! 454: int nArg; /* Number of arguments */
! 455: int enc; /* Optimal text encoding */
! 456: void *pContext; /* sqlite3_user_data() context */
! 457: void (*xFunc)(sqlite3_context*,int,sqlite3_value**);
! 458: } scalars[] = {
! 459: {"regexp", 2, SQLITE_ANY, 0, icuRegexpFunc},
! 460:
! 461: {"lower", 1, SQLITE_UTF16, 0, icuCaseFunc16},
! 462: {"lower", 2, SQLITE_UTF16, 0, icuCaseFunc16},
! 463: {"upper", 1, SQLITE_UTF16, (void*)1, icuCaseFunc16},
! 464: {"upper", 2, SQLITE_UTF16, (void*)1, icuCaseFunc16},
! 465:
! 466: {"lower", 1, SQLITE_UTF8, 0, icuCaseFunc16},
! 467: {"lower", 2, SQLITE_UTF8, 0, icuCaseFunc16},
! 468: {"upper", 1, SQLITE_UTF8, (void*)1, icuCaseFunc16},
! 469: {"upper", 2, SQLITE_UTF8, (void*)1, icuCaseFunc16},
! 470:
! 471: {"like", 2, SQLITE_UTF8, 0, icuLikeFunc},
! 472: {"like", 3, SQLITE_UTF8, 0, icuLikeFunc},
! 473:
! 474: {"icu_load_collation", 2, SQLITE_UTF8, (void*)db, icuLoadCollation},
! 475: };
! 476:
! 477: int rc = SQLITE_OK;
! 478: int i;
! 479:
! 480: for(i=0; rc==SQLITE_OK && i<(int)(sizeof(scalars)/sizeof(scalars[0])); i++){
! 481: struct IcuScalar *p = &scalars[i];
! 482: rc = sqlite3_create_function(
! 483: db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0
! 484: );
! 485: }
! 486:
! 487: return rc;
! 488: }
! 489:
! 490: #if !SQLITE_CORE
! 491: int sqlite3_extension_init(
! 492: sqlite3 *db,
! 493: char **pzErrMsg,
! 494: const sqlite3_api_routines *pApi
! 495: ){
! 496: SQLITE_EXTENSION_INIT2(pApi)
! 497: return sqlite3IcuInit(db);
! 498: }
! 499: #endif
! 500:
! 501: #endif
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to icu.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sqlite3 / ext / icu