Simple Cursor Adapter and Listview

I have a Listview that should show all entries from database in my main activity. I'm using a Simple Cursor Adapter, but when I run as android application, it crashes. The application is stopped and finished. Something wrong is happenning.

My Main Activity

public class BancoDictionary extends ListActivity  {

public static final String PREFS_NAME = "MyPrefsFile1";


ListView mListView;




@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);

setContentView(R.layout.main);


mListView = (ListView) findViewById(R.id.list);





Cursor cursor = getContentResolver().query(DictionaryProvider.CONTENT_URI, new String[] {DictionaryDatabase.KEY_WORD, DictionaryDatabase.KEY_DEFINITION}, null, null, null);
startManagingCursor(cursor);

// THE DESIRED COLUMNS TO BE BOUND
String[] columns = new String[] { DictionaryDatabase.KEY_WORD, DictionaryDatabase.KEY_DEFINITION };
// THE XML DEFINED VIEWS WHICH THE DATA WILL BE BOUND TO
int[] to = new int[] { R.id.word, R.id.definition };

// CREATE THE ADAPTER USING THE CURSOR POINTING TO THE DESIRED DATA AS WELL AS THE LAYOUT INFORMATION
SimpleCursorAdapter mAdapter = new SimpleCursorAdapter(this, R.layout.list_item, cursor, columns, to);

// SET THIS ADAPTER AS YOUR LISTACTIVITY'S ADAPTER



mListView.setAdapter(mAdapter);
mListView.setOnItemClickListener(new OnItemClickListener() {

@Override
public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
Intent wordIntent = new Intent(getApplicationContext(), WordActivity.class);
Uri data = Uri.withAppendedPath(DictionaryProvider.CONTENT_URI,
                            String.valueOf(id));


wordIntent.setData(data);
wordIntent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
wordIntent.addFlags(Intent.FLAG_ACTIVITY_NO_ANIMATION);
startActivity(wordIntent);

}


});

}

}

DictionaryDatabase

public class DictionaryDatabase {
private static final String TAG = "DictionaryDatabase";

public static final String KEY_WORD = SearchManager.SUGGEST_COLUMN_TEXT_1;
public static final String KEY_DEFINITION = SearchManager.SUGGEST_COLUMN_TEXT_2;

private static final String DATABASE_NAME = "dictionary";
private static final String FTS_VIRTUAL_TABLE = "FTSdictionary";
private static final int DATABASE_VERSION = 2;

private final DictionaryOpenHelper mDatabaseOpenHelper;
private static final HashMap<String,String> mColumnMap = buildColumnMap();

public DictionaryDatabase(Context context) {
    mDatabaseOpenHelper = new DictionaryOpenHelper(context);
}

private static HashMap<String,String> buildColumnMap() {
    HashMap<String,String> map = new HashMap<String,String>();
    map.put(KEY_WORD, KEY_WORD);
    map.put(KEY_DEFINITION, KEY_DEFINITION);
    map.put(BaseColumns._ID, "rowid AS " +
            BaseColumns._ID);
    map.put(SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID, "rowid AS " +
            SearchManager.SUGGEST_COLUMN_INTENT_DATA_ID);
    map.put(SearchManager.SUGGEST_COLUMN_SHORTCUT_ID, "rowid AS " +
            SearchManager.SUGGEST_COLUMN_SHORTCUT_ID);
    return map;
}




public Cursor getWord(String rowId, String[] columns) {
    String selection = "rowid = ?";
    String[] selectionArgs = new String[] {rowId};

    return query(selection, selectionArgs, columns);

}

public Cursor getWordMatches(String query, String[] columns) {
    String selection = KEY_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);
    builder.setProjectionMap(mColumnMap);

    Cursor cursor = builder.query(mDatabaseOpenHelper.getReadableDatabase(),
            columns, selection, selectionArgs, null, null, KEY_WORD + " COLLATE NOCASE ASC");

    if (cursor == null) {
        return null;
    } else if (!cursor.moveToFirst()) {
        cursor.close();
        return null;
    }
    return cursor;
}

private static class DictionaryOpenHelper extends SQLiteOpenHelper {

    private final Context mHelperContext;
    private SQLiteDatabase mDatabase;

    private static final String FTS_TABLE_CREATE =
                "CREATE VIRTUAL TABLE " + FTS_VIRTUAL_TABLE +
                " USING fts3 (" +
                KEY_WORD + ", " +
                KEY_DEFINITION + ");";



    DictionaryOpenHelper(Context context) {
        super(context, DATABASE_NAME, null, DATABASE_VERSION);
        mHelperContext = context;
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        mDatabase = db;
        mDatabase.execSQL(FTS_TABLE_CREATE);
        loadDictionary();
    }



    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 {
        Log.d(TAG, "Loading words...");
        final Resources URL = mHelperContext.getResources();
        InputStream input = new URL("http://ift.tt/1RpRCSu").openStream();


        BufferedReader reader = new BufferedReader(new InputStreamReader(input));
        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();
        }
        Log.d(TAG, "DONE loading words.");
    }


    public long addWord(String word, String definition) {
        ContentValues initialValues = new ContentValues();
        initialValues.put(KEY_WORD, word);
        initialValues.put(KEY_DEFINITION, definition);

        return mDatabase.insert(FTS_VIRTUAL_TABLE, null, initialValues);
    }

    @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);
    }
}

public long insertData(WordDefinition wordDefinition) {
    SQLiteDatabase database=mDatabaseOpenHelper.getWritableDatabase();
    ContentValues values=new ContentValues();

    values.put(KEY_WORD, wordDefinition.word);
    values.put(KEY_DEFINITION, wordDefinition.definition);

    return database.insert(FTS_VIRTUAL_TABLE, null, values);        

}

   public long updateData(WordDefinition wordDefinition) {
    SQLiteDatabase database=mDatabaseOpenHelper.getWritableDatabase();
    ContentValues values=new ContentValues();

    values.put(KEY_WORD, wordDefinition.word);
    values.put(KEY_DEFINITION, wordDefinition.definition);

    return database.update(FTS_VIRTUAL_TABLE, values, KEY_WORD+" =?", new String[]{wordDefinition.word});   

}

public void deleteData(WordDefinition wordDefinition) {
    SQLiteDatabase database=mDatabaseOpenHelper.getWritableDatabase();
    String queryString="DELETE FROM "+FTS_VIRTUAL_TABLE+" WHERE "+KEY_WORD+" = '"+wordDefinition.word+"'";

    database.execSQL(queryString);
}


public ArrayList<WordDefinition> getAllWords() {
ArrayList<WordDefinition> arrayList=new ArrayList<WordDefinition>();
SQLiteDatabase database=mDatabaseOpenHelper.getReadableDatabase();

String selectAllQueryString="SELECT * FROM "+FTS_VIRTUAL_TABLE;
Cursor cursor=database.rawQuery(selectAllQueryString, null);

if (cursor.moveToFirst()) {
    do {            
        WordDefinition wordDefinition=new WordDefinition(cursor.getString(cursor.getColumnIndex(KEY_WORD)), cursor.getString(cursor.getColumnIndex(KEY_DEFINITION)));
        arrayList.add(wordDefinition);              
    } while (cursor.moveToNext());          
}   
return arrayList;
}

public WordDefinition getWordDefinition(String word) {
SQLiteDatabase database=mDatabaseOpenHelper.getReadableDatabase();
WordDefinition wordDefinition=null;

String selectQueryString="SELECT * FROM "+FTS_VIRTUAL_TABLE+ " WHERE "+KEY_WORD+" = '"+word+ "'";
Cursor cursor=database.rawQuery(selectQueryString, null);

if (cursor.moveToFirst()) {
    wordDefinition=new WordDefinition(cursor.getString(cursor.getColumnIndex(KEY_WORD)), cursor.getString(cursor.getColumnIndex(KEY_DEFINITION)));

}   

return wordDefinition;

}

public WordDefinition getWordDefinition(long id) {
SQLiteDatabase database=mDatabaseOpenHelper.getReadableDatabase();
WordDefinition wordDefinition=null;

String selectQueryString="SELECT * FROM "+FTS_VIRTUAL_TABLE+ " WHERE "+BaseColumns._ID+" = '"+id+ "'";
Cursor cursor=database.rawQuery(selectQueryString, null);

if (cursor.moveToFirst()) {
    wordDefinition=new WordDefinition(cursor.getString(cursor.getColumnIndex(KEY_WORD)), cursor.getString(cursor.getColumnIndex(KEY_DEFINITION)));

}   

return wordDefinition;

   }


 public void initializeDatabaseFortheFirstTime(ArrayList<WordDefinition> wordDefinitions) {
SQLiteDatabase database=mDatabaseOpenHelper.getWritableDatabase();
database.execSQL("BEGIN");

ContentValues contentValues=new ContentValues();

for (WordDefinition wordDefinition : wordDefinitions) {
    contentValues.put(KEY_WORD, wordDefinition.word);
    contentValues.put(KEY_DEFINITION, wordDefinition.definition);           
    database.insert(FTS_VIRTUAL_TABLE, null, contentValues);
}
database.execSQL("COMMIT");

}

  }