Esistono molti modi per archiviare i dati, ad esempio in un database online, in un database SQLite locale o persino in un file di testo. Spetta a te decidere qual è la soluzione migliore per la tua applicazione. Questa lezione spiega come creare una tabella virtuale SQLite in grado di fornire una solida ricerca nell'intero testo. La tabella viene completata con i dati di un file di testo contenente una coppia di parole e definizioni su ogni riga del file.
Crea la tabella virtuale
Una tabella virtuale si comporta in modo simile a una tabella SQLite, ma legge e scrive in un oggetto in memoria tramite callback, anziché in un file di database. Per creare una tabella virtuale, crea una classe per la tabella:
Kotlin
class DatabaseTable(context: Context) {
private val databaseOpenHelper = DatabaseOpenHelper(context)
}
Java
public class DatabaseTable {
private final DatabaseOpenHelper databaseOpenHelper;
public DatabaseTable(Context context) {
databaseOpenHelper = new DatabaseOpenHelper(context);
}
}
Crea un corso interno in DatabaseTable che estenda SQLiteOpenHelper. La classe SQLiteOpenHelper definisce i metodi astratti di cui devi eseguire l'override in modo che sia possibile creare ed eseguire l'upgrade della tabella di database quando necessario. Ad esempio, ecco del codice che dichiara una tabella di database che conterrà parole per un'app di dizionario:
Kotlin
private const val TAG = "DictionaryDatabase"
// The columns we'll include in the dictionary table
const val COL_WORD = "WORD"
const val COL_DEFINITION = "DEFINITION"
private const val DATABASE_NAME = "DICTIONARY"
private const val FTS_VIRTUAL_TABLE = "FTS"
private const val DATABASE_VERSION = 1
private const val FTS_TABLE_CREATE =
"CREATE VIRTUAL TABLE $FTS_VIRTUAL_TABLE USING fts3 ($COL_WORD, $COL_DEFINITION)"
class DatabaseTable(context: Context) {
private val databaseOpenHelper: DatabaseOpenHelper
init {
databaseOpenHelper = DatabaseOpenHelper(context)
}
private class DatabaseOpenHelper internal constructor(private val helperContext: Context) :
SQLiteOpenHelper(helperContext, DATABASE_NAME, null, DATABASE_VERSION) {
private lateinit var mDatabase: SQLiteDatabase
override fun onCreate(db: SQLiteDatabase) {
mDatabase = db
mDatabase.execSQL(FTS_TABLE_CREATE)
}
override fun onUpgrade(db: SQLiteDatabase, oldVersion: Int, newVersion: Int) {
Log.w(
TAG,
"Upgrading database from version $oldVersion to $newVersion , which will " +
"destroy all old data"
)
db.execSQL("DROP TABLE IF EXISTS $FTS_VIRTUAL_TABLE")
onCreate(db)
}
}
}
Java
public class DatabaseTable {
private static final String TAG = "DictionaryDatabase";
// The columns we'll include in the dictionary table
public static final String COL_WORD = "WORD";
public static final String COL_DEFINITION = "DEFINITION";
private static final String DATABASE_NAME = "DICTIONARY";
private static final String FTS_VIRTUAL_TABLE = "FTS";
private static final int DATABASE_VERSION = 1;
private final DatabaseOpenHelper databaseOpenHelper;
public DatabaseTable(Context context) {
databaseOpenHelper = new DatabaseOpenHelper(context);
}
private static class DatabaseOpenHelper extends SQLiteOpenHelper {
private final Context helperContext;
private SQLiteDatabase mDatabase;
private static final String FTS_TABLE_CREATE =
"CREATE VIRTUAL TABLE " + FTS_VIRTUAL_TABLE +
" USING fts3 (" +
COL_WORD + ", " +
COL_DEFINITION + ")";
DatabaseOpenHelper(Context context) {
super(context, DATABASE_NAME, null, DATABASE_VERSION);
helperContext = context;
}
@Override
public void onCreate(SQLiteDatabase db) {
mDatabase = db;
mDatabase.execSQL(FTS_TABLE_CREATE);
}
@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
Log.w(TAG, "Upgrading database from version " + oldVersion + " to "
+ newVersion + ", which will destroy all old data");
db.execSQL("DROP TABLE IF EXISTS " + FTS_VIRTUAL_TABLE);
onCreate(db);
}
}
}
Completa la tabella virtuale
La tabella ora necessita di dati da archiviare. Il codice seguente mostra come leggere un file di testo
(che si trova in res/raw/definitions.txt) contenente parole e le relative definizioni, come
analizzare il file e come inserire ogni riga di quel file come riga nella tabella virtuale. Tutto questo viene fatto in un altro thread per evitare il blocco dell'interfaccia utente. Aggiungi il seguente codice alla tua
classe interna DatabaseOpenHelper.
Suggerimento: ti consigliamo anche di impostare un callback per notificare alla tua attività di UI il completamento di questo thread.
Kotlin
private fun loadDictionary() {
Thread(Runnable {
try {
loadWords()
} catch (e: IOException) {
throw RuntimeException(e)
}
}).start()
}
@Throws(IOException::class)
private fun loadWords() {
val inputStream = helperContext.resources.openRawResource(R.raw.definitions)
BufferedReader(InputStreamReader(inputStream)).use { reader ->
var line: String? = reader.readLine()
while (line != null) {
val strings: List<String> = line.split("-").map { it.trim() }
if (strings.size < 2) continue
val id = addWord(strings[0], strings[1])
if (id < 0) {
Log.e(TAG, "unable to add word: ${strings[0]}")
}
line = reader.readLine()
}
}
}
fun addWord(word: String, definition: String): Long {
val initialValues = ContentValues().apply {
put(COL_WORD, word)
put(COL_DEFINITION, definition)
}
return database.insert(FTS_VIRTUAL_TABLE, null, initialValues)
}
Java
private void loadDictionary() {
new Thread(new Runnable() {
public void run() {
try {
loadWords();
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}).start();
}
private void loadWords() throws IOException {
final Resources resources = helperContext.getResources();
InputStream inputStream = resources.openRawResource(R.raw.definitions);
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));
try {
String line;
while ((line = reader.readLine()) != null) {
String[] strings = TextUtils.split(line, "-");
if (strings.length < 2) continue;
long id = addWord(strings[0].trim(), strings[1].trim());
if (id < 0) {
Log.e(TAG, "unable to add word: " + strings[0].trim());
}
}
} finally {
reader.close();
}
}
public long addWord(String word, String definition) {
ContentValues initialValues = new ContentValues();
initialValues.put(COL_WORD, word);
initialValues.put(COL_DEFINITION, definition);
return database.insert(FTS_VIRTUAL_TABLE, null, initialValues);
}
Chiama il metodo loadDictionary() dove appropriato per completare la tabella. Un buon posto sarebbe nel metodo onCreate() della classe DatabaseOpenHelper, subito dopo aver creato la tabella:
Kotlin
override fun onCreate(db: SQLiteDatabase) {
database = db
database.execSQL(FTS_TABLE_CREATE)
loadDictionary()
}
Java
@Override
public void onCreate(SQLiteDatabase db) {
database = db;
database.execSQL(FTS_TABLE_CREATE);
loadDictionary();
}
Cerca la query
Una volta creata e completata la tabella virtuale, utilizza la query fornita da SearchView per cercare i dati. Aggiungi i seguenti metodi alla
classe DatabaseTable per creare un'istruzione SQL che cerchi la query:
Kotlin
fun getWordMatches(query: String, columns: Array<String>?): Cursor? {
val selection = "$COL_WORD MATCH ?"
val selectionArgs = arrayOf("$query*")
return query(selection, selectionArgs, columns)
}
private fun query(
selection: String,
selectionArgs: Array<String>,
columns: Array<String>?
): Cursor? {
val cursor: Cursor? = SQLiteQueryBuilder().run {
tables = FTS_VIRTUAL_TABLE
query(databaseOpenHelper.readableDatabase,
columns, selection, selectionArgs, null, null, null)
}
return cursor?.run {
if (!moveToFirst()) {
close()
null
} else {
this
}
} ?: null
}
Java
public Cursor getWordMatches(String query, String[] columns) {
String selection = COL_WORD + " MATCH ?";
String[] selectionArgs = new String[] {query+"*"};
return query(selection, selectionArgs, columns);
}
private Cursor query(String selection, String[] selectionArgs, String[] columns) {
SQLiteQueryBuilder builder = new SQLiteQueryBuilder();
builder.setTables(FTS_VIRTUAL_TABLE);
Cursor cursor = builder.query(databaseOpenHelper.getReadableDatabase(),
columns, selection, selectionArgs, null, null, null);
if (cursor == null) {
return null;
} else if (!cursor.moveToFirst()) {
cursor.close();
return null;
}
return cursor;
}
Cerca una query chiamando il numero getWordMatches(). Eventuali risultati corrispondenti vengono restituiti
in un Cursor che puoi eseguire iterazione o utilizzare per creare un ListView.
Questo esempio chiama getWordMatches() nel metodo handleIntent() dell'attività
disponibile per la ricerca. Ricorda che l'attività disponibile per la ricerca riceve la query all'interno dell'intent ACTION_SEARCH come extra, a causa del filtro per intent creato in precedenza:
Kotlin
private val db = DatabaseTable(this)
...
private fun handleIntent(intent: Intent) {
if (Intent.ACTION_SEARCH == intent.action) {
val query = intent.getStringExtra(SearchManager.QUERY)
val c = db.getWordMatches(query, null)
// process Cursor and display results
}
}
Java
DatabaseTable db = new DatabaseTable(this);
...
private void handleIntent(Intent intent) {
if (Intent.ACTION_SEARCH.equals(intent.getAction())) {
String query = intent.getStringExtra(SearchManager.QUERY);
Cursor c = db.getWordMatches(query, null);
// process Cursor and display results
}
}