/*

** 2007 May 6

**

** The author disclaims copyright to this source code.  In place of

** a legal notice, here is a blessing:

**

**    May you do good and not evil.

**    May you find forgiveness for yourself and forgive others.

**    May you share freely, never taking more than you give.

**

*************************************************************************

** $Id: icu.c,v 1.7 2007/12/13 21:54:11 drh Exp $

**

** This file implements an integration between the ICU library 

** ("International Components for Unicode", an open-source library 

** for handling unicode data) and SQLite. The integration uses 

** ICU to provide the following to SQLite:

**

**   * An implementation of the SQL regexp() function (and hence REGEXP

**     operator) using the ICU uregex_XX() APIs.

**

**   * Implementations of the SQL scalar upper() and lower() functions

**     for case mapping.

**

**   * Integration of ICU and SQLite collation seqences.

**

**   * An implementation of the LIKE operator that uses ICU to 

**     provide case-independent matching.

*/

#if !defined(SQLITE_CORE) || defined(SQLITE_ENABLE_ICU)

/* Include ICU headers */

#include <unicode/utypes.h>

#include <unicode/uregex.h>

#include <unicode/ustring.h>

#include <unicode/ucol.h>

#include <assert.h>

#ifndef SQLITE_CORE

  #include "sqlite3ext.h"

  SQLITE_EXTENSION_INIT1

#else

  #include "sqlite3.h"

#endif

/*

** Maximum length (in bytes) of the pattern in a LIKE or GLOB

** operator.

*/

#ifndef SQLITE_MAX_LIKE_PATTERN_LENGTH

# define SQLITE_MAX_LIKE_PATTERN_LENGTH 50000

#endif

/*

** Version of sqlite3_free() that is always a function, never a macro.

*/

static void xFree(void *p){

  sqlite3_free(p);

}

/*

** Compare two UTF-8 strings for equality where the first string is

** a "LIKE" expression. Return true (1) if they are the same and 

** false (0) if they are different.

*/

static int icuLikeCompare(

  const uint8_t *zPattern,   /* LIKE pattern */

  const uint8_t *zString,    /* The UTF-8 string to compare against */

  const UChar32 uEsc         /* The escape character */

){

  static const int MATCH_ONE = (UChar32)'_';

  static const int MATCH_ALL = (UChar32)'%';

  int iPattern = 0;       /* Current byte index in zPattern */

  int iString = 0;        /* Current byte index in zString */

  int prevEscape = 0;     /* True if the previous character was uEsc */

  while( zPattern[iPattern]!=0 ){

    /* Read (and consume) the next character from the input pattern. */

    UChar32 uPattern;

    U8_NEXT_UNSAFE(zPattern, iPattern, uPattern);

    assert(uPattern!=0);

    /* There are now 4 possibilities:

    **

    **     1. uPattern is an unescaped match-all character "%",

    **     2. uPattern is an unescaped match-one character "_",

    **     3. uPattern is an unescaped escape character, or

    **     4. uPattern is to be handled as an ordinary character

    */

    if( !prevEscape && uPattern==MATCH_ALL ){

      /* Case 1. */

      uint8_t c;

      /* Skip any MATCH_ALL or MATCH_ONE characters that follow a

      ** MATCH_ALL. For each MATCH_ONE, skip one character in the 

      ** test string.

      */

      while( (c=zPattern[iPattern]) == MATCH_ALL || c == MATCH_ONE ){

        if( c==MATCH_ONE ){

          if( zString[iString]==0 ) return 0;

          U8_FWD_1_UNSAFE(zString, iString);

        }

        iPattern++;

      }

      if( zPattern[iPattern]==0 ) return 1;

      while( zString[iString] ){

        if( icuLikeCompare(&zPattern[iPattern], &zString[iString], uEsc) ){

          return 1;

        }

        U8_FWD_1_UNSAFE(zString, iString);

      }

      return 0;

    }else if( !prevEscape && uPattern==MATCH_ONE ){

      /* Case 2. */

      if( zString[iString]==0 ) return 0;

      U8_FWD_1_UNSAFE(zString, iString);

    }else if( !prevEscape && uPattern==uEsc){

      /* Case 3. */

      prevEscape = 1;

    }else{

      /* Case 4. */

      UChar32 uString;

      U8_NEXT_UNSAFE(zString, iString, uString);

      uString = u_foldCase(uString, U_FOLD_CASE_DEFAULT);

      uPattern = u_foldCase(uPattern, U_FOLD_CASE_DEFAULT);

      if( uString!=uPattern ){

        return 0;

      }

      prevEscape = 0;

    }

  }

  return zString[iString]==0;

}

/*

** Implementation of the like() SQL function.  This function implements

** the build-in LIKE operator.  The first argument to the function is the

** pattern and the second argument is the string.  So, the SQL statements:

**

**       A LIKE B

**

** is implemented as like(B, A). If there is an escape character E, 

**

**       A LIKE B ESCAPE E

**

** is mapped to like(B, A, E).

*/

static void icuLikeFunc(

  sqlite3_context *context, 

  int argc, 

  sqlite3_value **argv

){

  const unsigned char *zA = sqlite3_value_text(argv[0]);

  const unsigned char *zB = sqlite3_value_text(argv[1]);

  UChar32 uEsc = 0;

  /* Limit the length of the LIKE or GLOB pattern to avoid problems

  ** of deep recursion and N*N behavior in patternCompare().

  */

  if( sqlite3_value_bytes(argv[0])>SQLITE_MAX_LIKE_PATTERN_LENGTH ){

    sqlite3_result_error(context, "LIKE or GLOB pattern too complex", -1);

    return;

  }

  if( argc==3 ){

    /* The escape character string must consist of a single UTF-8 character.

    ** Otherwise, return an error.

    */

    int nE= sqlite3_value_bytes(argv[2]);

    const unsigned char *zE = sqlite3_value_text(argv[2]);

    int i = 0;

    if( zE==0 ) return;

    U8_NEXT(zE, i, nE, uEsc);

    if( i!=nE){

      sqlite3_result_error(context, 

          "ESCAPE expression must be a single character", -1);

      return;

    }

  }

  if( zA && zB ){

    sqlite3_result_int(context, icuLikeCompare(zA, zB, uEsc));

  }

}

/*

** This function is called when an ICU function called from within

** the implementation of an SQL scalar function returns an error.

**

** The scalar function context passed as the first argument is 

** loaded with an error message based on the following two args.

*/

static void icuFunctionError(

  sqlite3_context *pCtx,       /* SQLite scalar function context */

  const char *zName,           /* Name of ICU function that failed */

  UErrorCode e                 /* Error code returned by ICU function */

){

  char zBuf[128];

  sqlite3_snprintf(128, zBuf, "ICU error: %s(): %s", zName, u_errorName(e));

  zBuf[127] = '\0';

  sqlite3_result_error(pCtx, zBuf, -1);

}

/*

** Function to delete compiled regexp objects. Registered as

** a destructor function with sqlite3_set_auxdata().

*/

static void icuRegexpDelete(void *p){

  URegularExpression *pExpr = (URegularExpression *)p;

  uregex_close(pExpr);

}

/*

** 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]);

  /* 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);

}

/*

** 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);

}

/*

** Collation sequence destructor function. The pCtx argument points to

** a UCollator structure previously allocated using ucol_open().

*/

static void icuCollationDel(void *pCtx){

  UCollator *p = (UCollator *)pCtx;

  ucol_close(p);

}

/*

** Collation sequence comparison function. The pCtx argument points to

** a UCollator structure previously allocated using ucol_open().

*/

static int icuCollationColl(

  void *pCtx,

  int nLeft,

  const void *zLeft,

  int nRight,

  const void *zRight

){

  UCollationResult res;

  UCollator *p = (UCollator *)pCtx;

  res = ucol_strcoll(p, (UChar *)zLeft, nLeft/2, (UChar *)zRight, nRight/2);

  switch( res ){

    case UCOL_LESS:    return -1;

    case UCOL_GREATER: return +1;

    case UCOL_EQUAL:   return 0;

  }

  assert(!"Unexpected return value from ucol_strcoll()");

  return 0;

}

/*

** Implementation of the scalar function icu_load_collation().

**

** This scalar function is used to add ICU collation based collation 

** types to an SQLite database connection. It is intended to be called

** as follows:

**

**     SELECT icu_load_collation(<locale>, <collation-name>);

**

** Where <locale> is a string containing an ICU locale identifier (i.e.

** "en_AU", "tr_TR" etc.) and <collation-name> is the name of the

** collation sequence to create.

*/

static void icuLoadCollation(

  sqlite3_context *p, 

  int nArg, 

  sqlite3_value **apArg

){

  sqlite3 *db = (sqlite3 *)sqlite3_user_data(p);

  UErrorCode status = U_ZERO_ERROR;

  const char *zLocale;      /* Locale identifier - (eg. "jp_JP") */

  const char *zName;        /* SQL Collation sequence name (eg. "japanese") */

  UCollator *pUCollator;    /* ICU library collation object */

  int rc;                   /* Return code from sqlite3_create_collation_x() */

  assert(nArg==2);

  zLocale = (const char *)sqlite3_value_text(apArg[0]);

  zName = (const char *)sqlite3_value_text(apArg[1]);

  if( !zLocale || !zName ){

    return;

  }

  pUCollator = ucol_open(zLocale, &status);

  if( !U_SUCCESS(status) ){

    icuFunctionError(p, "ucol_open", status);

    return;

  }

  assert(p);

  rc = sqlite3_create_collation_v2(db, zName, SQLITE_UTF16, (void *)pUCollator, 

      icuCollationColl, icuCollationDel

  );

  if( rc!=SQLITE_OK ){

    ucol_close(pUCollator);

    sqlite3_result_error(p, "Error registering collation function", -1);

  }

}

/*

** Register the ICU extension functions with database db.

*/

int sqlite3IcuInit(sqlite3 *db){

  struct IcuScalar {

    const char *zName;                        /* Function name */

    int nArg;                                 /* Number of arguments */

    int enc;                                  /* Optimal text encoding */

    void *pContext;                           /* sqlite3_user_data() context */

    void (*xFunc)(sqlite3_context*,int,sqlite3_value**);

  } scalars[] = {

    {"regexp",-1, SQLITE_ANY,          0, icuRegexpFunc},

    {"lower",  1, SQLITE_UTF16,        0, icuCaseFunc16},

    {"lower",  2, SQLITE_UTF16,        0, icuCaseFunc16},

    {"upper",  1, SQLITE_UTF16, (void*)1, icuCaseFunc16},

    {"upper",  2, SQLITE_UTF16, (void*)1, icuCaseFunc16},

    {"lower",  1, SQLITE_UTF8,         0, icuCaseFunc16},

    {"lower",  2, SQLITE_UTF8,         0, icuCaseFunc16},

    {"upper",  1, SQLITE_UTF8,  (void*)1, icuCaseFunc16},

    {"upper",  2, SQLITE_UTF8,  (void*)1, icuCaseFunc16},

    {"like",   2, SQLITE_UTF8,         0, icuLikeFunc},

    {"like",   3, SQLITE_UTF8,         0, icuLikeFunc},

    {"icu_load_collation",  2, SQLITE_UTF8, (void*)db, icuLoadCollation},

  };

  int rc = SQLITE_OK;

  int i;

  for(i=0; rc==SQLITE_OK && i<(sizeof(scalars)/sizeof(struct IcuScalar)); i++){

    struct IcuScalar *p = &scalars[i];

    rc = sqlite3_create_function(

        db, p->zName, p->nArg, p->enc, p->pContext, p->xFunc, 0, 0

    );

  }

  return rc;

}

#if !SQLITE_CORE

int sqlite3_extension_init(

  sqlite3 *db, 

  char **pzErrMsg,

  const sqlite3_api_routines *pApi

){

  SQLITE_EXTENSION_INIT2(pApi)

  return sqlite3IcuInit(db);

}

#endif

#endif