2013-12-18 9 views
7

Ich habe einen Restaurants Tisch in meiner SQLite-DB, der die folgenden DatensätzeAndroid zum automatischen Vervollständigung mit SQLite LIKE funktioniert teilweise

| Name | Latin_Name | 
+--------+------------+ 
| Манаки | Manaki  | 
+--------+------------+ 
| Енрико | Enriko  | 
+---------------------+ 

nun wie folgt Ich mache die Suche hat:

Von meinem Fragmente:

String selection = DBHelper.COL_NAME + " LIKE ? OR " + 
        DBHelper.COL_LATIN_NAME + " LIKE ?"; 

String[] selectionArgs = {"%"+term+"%", "%"+term+"%"}; 

CursorLoader loader = new CursorLoader(getActivity(), 
           DatabaseContentProvider.REST_CONTENT_URI, 
           columns, selection, selectionArgs, null); 

Der Inhaltsanbieter query Methode:

public Cursor query(Uri uri, String[] projection, String selection, 
        String[] selectionArgs, String sortOrder) { 

    db = dbHelper.getReadableDatabase(); 
    SQLiteQueryBuilder builder = new SQLiteQueryBuilder(); 
    switch(URI_MATCHER.match(uri)){ 
     case REST_LIST: 
      builder.setTables(DBHelper.REST_TABLE); 
      break; 
     case REST_ID: 
      builder.appendWhere(DBHelper.COL_ID + " = " 
        + uri.getLastPathSegment()); 
      break; 
     default: 
      throw new IllegalArgumentException("Unsupported URI: " + uri); 
    } 
    Cursor cursor = builder.query(db, projection, selection, selectionArgs, 
      null, null, sortOrder); 


    cursor.setNotificationUri(getContext().getContentResolver(), uri); 

    return cursor; 
} 

So ziemlich Grundrecht? Jetzt kommt das Problem:

Wenn der term, die in kommt, ist en ich die unter den anderen Enriko Restaurants sehen.

Wenn ich enri passieren kann ich sehen, die Enriko nicht als Folge mehr.

Das Gleiche gilt für das Manaki Restaurant, das ich es bis mana sehen und danach (für manak Begriff für ex) Ich kann es nicht in der Ergebnisliste sehen.

Ich debugging mein ContentProvider und ich erkannte, dass der Cursor leer war, also muss das Problem auf der Datenbankebene sein, denke ich.

Bitte helfen.

UPDATE:

die @laalto Kommentare im Auge zu haben habe ich beschlossen, auf der Datenbank einig Test zu tun. In der onCreate() Methode meiner SQLiteOpenHelper habe ich nur diese zwei Datensätze in die Tabelle von Hand eingefügt und es hat funktioniert.

Nun ist das Problem, dass ich 1300 Datensätze onCreate() aus einer json Datei im Ordner assets geliefert einfügen müssen. Im Moment analysiere ich die json Datei, erstellen Sie eine Schleife dann durch und legen Sie einen Datensatz pro Objekt für alle 1300 Elemente.

Diese Art der Einfügung wird nicht mit der SQLite LIKE Methode funktionieren.

Gibt es irgendwelche Probleme mit dieser Art der Bestückung der Datenbank?

Vielleicht muss ich Dateikodierung ändern (es ist UTF-8 jetzt) ​​oder vielleicht die Sortierung der Datenbank, oder vielleicht getString() von JSONObject kann für die Datenbank optimiert werden?

+0

Wie produzieren Sie die 'Latin_Name', die in der db geht? Ich denke an die Möglichkeit, dass es dort einige Zeichen gibt, die nicht sichtbar sind, aber das "LIKE" -Match beeinflussen. – laalto

+0

Wenn ich diese Abfrage ausführen 'SELECT * FROM Restaurants wo Latin_name LIKE'% Enri% ''in einer Desktop-SQLite-App bekomme ich das gewünschte Ergebnis. – djandreski

+0

Ok - Sie könnten das SQL überprüfen, das der Builder erzeugt. z.B. Ersetzen Sie 'builder.query()' durch 'builder.buildQuery()', loggen Sie den Query String und fragen Sie nach 'db.rawQuery()'. – laalto

Antwort

2

Wenn es dringend ist, hier eine schnelle und schmutzige Lösung.

2.600 Strings (1.300 kyrillisch + 1.300 latein) sind wirklich wenige Werte im Speicher zu handhaben: Sie einfach alle Werte aus der SQLite mit

select name, latin_name from restaurants 

laden und dann können Sie Schleife das Ergebnis in Java gesetzt, während mit einem String für den passenden String suchen. enthält Methode. Denken Sie daran, dass enthält Methode ist Groß- und Kleinschreibung, so dass Sie so etwas wie dieses verwenden sollte:

string1.toLowerCase().contains(string2.toLowerCase()) 
1

SQLite Dokumentation link

The LIKE operator does a pattern matching comparison. The operand to the right of the LIKE 
operator contains the pattern and the left hand operand contains the string to 
match against the pattern. A percent symbol ("%") in the LIKE pattern matches any 
sequence of zero or more characters in the string. An underscore ("_") in the LIKE 
pattern matches any single character in the string. Any other character matches 
itself or its lower/upper case equivalent (i.e. case-insensitive matching). 
(A bug: SQLite only understands upper/lower case for ASCII characters by default. 
The LIKE operator is case sensitive by default for unicode characters that are 
beyond the ASCII range. For example, the expression 'a' LIKE 'A' is TRUE but 'æ' LIKE 'Æ' 
is FALSE.) 
Verwandte Themen