SQLite

    sqlite3VdbeSetVarmask(pParse->pVdbe, iCol);
    assert( pRight->op==TK_VARIABLE || pRight->op==TK_REGISTER );
  }else if( op==TK_STRING ){
    assert( !ExprHasProperty(pRight, EP_IntValue) );
     z = (u8*)pRight->u.zToken;
  }
  if( z ){
    /* Count the number of prefix bytes prior to the first wildcard,
    ** U+fffd character, or malformed utf-8. If the underlying database
    ** has a UTF16LE encoding, then only consider ASCII characters.  Note that
    ** the encoding of z[] is UTF8 - we are dealing with only UTF8 here in this
    ** code, but the database engine itself might be processing content using a
    ** different encoding. */
    cnt = 0;
    while( (c=z[cnt])!=0 && c!=wc[0] && c!=wc[1] && c!=wc[2] ){
      cnt++;
      if( c==wc[3] && z[cnt]>0 && z[cnt]<0x80 ){
        cnt++;
      }else if( c>=0x80 ){
        const u8 *z2 = z+cnt-1;
        if( sqlite3Utf8Read(&z2)==0xfffd || c==0xFF   /* bad utf-8 */
         || ENC(db)==SQLITE_UTF16LE 
        ){
          cnt--;
          break;
        }else{
          cnt = (int)(z2-z);
        }
      }
    }

      for(i=0; (c = pStr1->u.zToken[i])!=0; i++){
        pStr1->u.zToken[i] = sqlite3Toupper(c);
        pStr2->u.zToken[i] = sqlite3Tolower(c);
      }
    }

    if( !db->mallocFailed ){
      u8 *pC;       /* Last character before the first wildcard */
      pC = (u8*)&pStr2->u.zToken[sqlite3Strlen30(pStr2->u.zToken)-1];

      if( noCase ){
        /* The point is to increment the last character before the first
        ** wildcard.  But if we increment '@', that will push it into the
        ** alphabetic range where case conversions will mess up the
        ** inequality.  To avoid this, make sure to also run the full
        ** LIKE on all candidate expressions by clearing the isComplete flag
        */
        if( *pC=='A'-1 ) isComplete = 0;
        *pC = sqlite3UpperToLower[*pC];
      }

      /* Increment the value of the last utf8 character in the prefix. */
      while( *pC==0xBF && pC>(u8*)pStr2->u.zToken ){
        *pC = 0x80;
        pC--;
      }
      assert( *pC!=0xFF );        /* isLikeOrGlob() guarantees this */
      (*pC)++;
    }
    zCollSeqName = noCase ? "NOCASE" : sqlite3StrBINARY;
    pNewExpr1 = sqlite3ExprDup(db, pLeft, 0);
    pNewExpr1 = sqlite3PExpr(pParse, TK_GE,
           sqlite3ExprAddCollateString(pParse,pNewExpr1,zCollSeqName),
           pStr1);
    transferJoinMarkings(pNewExpr1, pExpr);

do_eqp_test like3-6.240 {
  SELECT * FROM t2 WHERE path LIKE 'a%' ESCAPE '\';
} {
  QUERY PLAN
  `--SEARCH t2 USING INDEX t2path2 (path>? AND path<?)
}
}

#-------------------------------------------------------------------------

ifcapable utf16 {
  reset_db
  do_execsql_test like3-7.0 {
    PRAGMA encoding = 'UTF-16be';
  
    CREATE TABLE Example(word TEXT NOT NULL);
    CREATE INDEX Example_word on Example(word);
  
    INSERT INTO Example VALUES(char(0x307F));
  }
  
  do_execsql_test like3-7.1 {
    SELECT char(0x307F)=='み';
  } {1}
  
  do_execsql_test like3-7.1 {
    SELECT * FROM Example WHERE word GLOB 'み*'
  } {み}
  
  do_execsql_test like3-7.2 {
    SELECT * FROM Example WHERE word >= char(0x307F) AND word < char(0x3080);
  } {み}
}

#-------------------------------------------------------------------------
reset_db

foreach enc {
  UTF-8
  UTF-16le 
  UTF-16be
} {
  foreach {tn expr} {
    1 "CAST (X'FF' AS TEXT)"
    2 "CAST (X'FFBF' AS TEXT)"
    3 "CAST (X'FFBFBF' AS TEXT)"
    4 "CAST (X'FFBFBFBF' AS TEXT)"

    5 "'abc' || CAST (X'FF' AS TEXT)"
    6 "'def' || CAST (X'FFBF' AS TEXT)"
    7 "'ghi' || CAST (X'FFBFBF' AS TEXT)"
    8 "'jkl' || CAST (X'FFBFBFBF' AS TEXT)"
  } {
    reset_db
    execsql "PRAGMA encoding = '$enc'"
    do_execsql_test like3-8.$tn.0 {
      CREATE TABLE t1(x);
    }
  
    do_execsql_test like3-8.$tn.1 {
      PRAGMA encoding
    } $enc
  
    do_execsql_test like3-8.$tn.1 "
      INSERT INTO t1 VALUES( $expr )
    "
  
    do_execsql_test like3-8.$tn.2 {
      SELECT typeof(x) FROM t1
    } {text}
  
    set x [db one {SELECT x || '%' FROM t1}]
  
    do_execsql_test like3-8.$tn.3 {
      SELECT rowid FROM t1 WHERE x LIKE $x
    } 1
  
    do_execsql_test like3-8.$tn.4 {
      CREATE INDEX i1 ON t1(x);
    }
  
    do_execsql_test like3-8.$tn.5 {
      SELECT rowid FROM t1 WHERE x LIKE $x
    } 1
  }
}

finish_test