Case sensitive and insensitive like in SQLite

sqlite like or
sqlite case insensitive like
sqlite like with parameter
how to make sqlite database case insensitive
python sqlite like
like query in sqlite android
sqlite escape
sqlite not like

In SQLite it is possible to change the case sensitive behaviour of 'LIKE' by using the commands:

PRAGMA case_sensitive_like=ON;
PRAGMA case_sensitive_like=OFF;

However in my situation I would like to execute a query, part of which is case sensitive and part of which isn't. For example:

SELECT * FROM mytable
WHERE caseSensitiveField like 'test%'
AND caseInsensitiveField like 'g2%'

Is this possible?

You can use the UPPER keyword on your case insensitive field then upper-case your like statement. e.g.

SELECT * FROM mytable 
WHERE caseSensitiveField like 'test%' 
AND UPPER(caseInsensitiveField) like 'G2%'

Case sensitive and insensitive like in SQLite, dose , Dose , etc does not seem a great idea even if permitted, unless as an exploratory exercise. SQLite. Finally get to SQLite. To my surprise this nice tiny DB gave me the most headaches in this area. SQLite has collations but there’re only few built-in ones and all of them have no Unicode support. At first it could look like we can use title LIKE 'term' COLLATE NOCASE. As NOCASE is a collation for case-insensitive comparing. But it doesn’t support Unicode only ASCII.

Use plain comparisons, which are case sensitive by default (unless you have declared the column COLLATE NOCASE):

FROM mytable 
WHERE caseSensitiveField >= 'test'
  AND caseSensitiveField <  'tesu'
  AND caseInsensitiveField LIKE 'g2%'

This works only if the original LIKE is searching for a prefix, but allows using an index.

SQLite Query Language: expression, Obviously it is transformed to a SQL-query with LIKE operator. But will the search be case-sensitive or insensitive? Well, it depends on DBMS which is being  Case-sensitivity, performance and LIKE. Hello, I need help with the following question: Is there a way to make SQLite queries case-insensitive? For example my query is: SELECT

I know this is an old question, but if you are coding in Java and have this problem this might be helpful. You can register a function that handles the like checking. I got the tip form this post:

The solution i dependent on sqlite jdbc:

In my case I only needed to see if a certain string existed as part of another string (like '%mystring%'), so I created a Contains function, but it should be possible to extend this to do a more sql-like check using regex or something.

To use the function in SQL to see if MyCol contains "searchstring" you would do:

select * from mytable where Contains(MyCol, 'searchstring')

Here is my Contains function:

public class Contains extends Function {

    protected void xFunc() throws SQLException {
        if (args() != 2) {
            throw new SQLException("Contains(t1,t2): Invalid argument count. Requires 2, but found " + args());
        String testValue = value_text(0).toLowerCase();
        String isLike = value_text(1).toLowerCase();

        if (testValue.contains(isLike)) {
        } else {

To use this function you must first register it. When you are done with using it you can optionally destroy it. Here is how:

public static void registerContainsFunc(Connection con) throws SQLException   {
    Function.create(con, Contains.class.getSimpleName(), new Contains());
public static void destroyContainsFunc(Connection con) throws SQLException {
    Function.destroy(con, Contains.class.getSimpleName());

Is the LIKE operator case-sensitive with MSSQL Server?, By default in SQLite LIKE is case-insensitive for ASCII symbols, but is case-​sensitive for Unicode symbols. In other databases LIKE is  EF Core with SQLite, Code First, case insensitive Contains for one column, sensitive for other. I have EF Core 1.1.0 preview with SQLite database and code-first approach. IQueryable<T> query = dbSet; query = query.Where(i => i.A.Contains(pattern)); the matching is case sensitive.

To perform case sensitive queries on a column created with COLLATE NOCASE, use COLLATE BINARY:

select * from myTable where name like 'Test%' COLLATE BINARY;

Case insensitive SQL SELECT query examples, SQLite LIKE operator checks whether a specific character string matches a itself or its lower/upper case equivalent (i.e. case-insensitive matching). The LIKE operator is case sensitive by default for Unicode characters that  I see the COLLATE NOCASE append in the sql query very long time ago (may be not COLLATE NOCASE,but something else , all I remember is my query is case insensitive), but recently I use Sqlite again , and it is case sensitive , and I can not compare an "Email" filed with x.Email == myvariable

How to make column names case-sensitive of Sqlite3 in Python , The IS and IS NOT operators work like = and != except when one or both of the matches itself or its lower/upper case equivalent (i.e. case-insensitive matching). The LIKE operator is case sensitive by default for unicode characters that are  Re: SQLite Select with case insensitive « Reply #2 on: March 02, 2018, 07:50:41 pm » I tried adding COLLATE NOCASE - and had some success. but I have a very complicated select statement, more than 1000 characters long, that is built at run time, and I guess I don't know where to place the COLLATE NOCASE statement.

Case-insensitive LIKE in SQLite, I thought SQLite selects would be case insensitive but they don't seem to be. '​SELECT *, TOTAL(CASE WHEN Scoring Like "I%" and ((North  Case Sensitivity Important point to be noted is that SQLite is case insensitive, but there are some commands, which are case sensitive like GLOB and glob have different meaning in SQLite statements.

SQLite and case sensitivity · Issue #367 · ponyorm/pony · GitHub, Case insensitive LIKE (and ORDER) in SQLite, above ASCII [SOLVED by LacaK] utf8 case-sensitive compare callback function. Case insensitive SQL SELECT query FAQ: How do I issue SQL SELECT queries while ignoring case (ignoring whether a string is uppercase or lowercase)?. Background. When I first started writing SQL queries I was using Postgresql, and used some of their custom regular expression capabilities to perform case-insensitive queries.

  • @AlexanderMalakhov Works for Italian and German characters as well. Just make sure that the db and the data you imported in it are all in UTF-8 encoding, and it works.
  • @rbedger Note, you don't need the Upper function, since Like is case-insensitive by default.
  • @FrankN.Stein it's doable, but not out-of-the-box. From official FAQ: The default configuration of SQLite only supports case-insensitive comparisons of ASCII characters.
  • I did it so: Since I planned to use UTF-8 characters, I saved my tables as UTF-8 CSV files. Then generated my tables from the CSV files in SQLiteManager (FireFox plugin). Then changed something in the DB configuration (don't remember what and if it's really needed). Then added my indexes to the WHERE and the JOIN fields. And that was all.
  • By editing out the "UPPER()", you end up with the same code as what the OP posted in the question. If you want to change your answer completely do so, or if you want to delete your answer then say so; but the edit you made makes no sense.
  • Found a bug in my code. If the column you are using the Contains function on has null values allowed, you should check the value_text(n) for null before applying th toLowerCase function.