Utilizzando pitone in Android per l'interfaccia a SQL

Question

So che è possibile utilizzare Python e altri linguaggi di scripting in Android. Ma non ho visto il tempo o non è stato possibile utilizzare Python come interfaccia per SQLite in Android. È possibile? Questa è la prima applicazione Android in cui ho bisogno di SQLite, e utilizzando l'API java è ritardato.

Se questo non è possibile, qualcuno mi può puntare a un buon tutorial su SQLite in Android? Ho trovato un gruppo, ma tutti sono completamente diverso e io sono totalmente perso sul quale è il modo migliore per farlo.

E 'solo difficile immagine come Google si aspetta di utilizzare il database SQLite. Sembra che tu abbia bisogno come 10 diverse classi solo per interrogare un database.

Answer 1

In realtà è sufficiente 3 classi:

Un ContentProvider , come si trova qui: http://developer.android.com/guide/topics/providers/content-providers.html

In secondo luogo è necessario è un SQLiteOpenHelper e, ultimo ma non almeno un Cursore

Edit: appena notato che non è evidente dai frammenti quanto la variabile db è. E 'lo SQLiteOpenHelper o meglio la mia estensione di esso (dove ho sovrascritto solo l'onCreate, ONUPGRADE e costruttore. Vedi sotto ^^

Il ContentProvider è quella che sarà in comunicazione con il database e fare le inserimenti, aggiornamenti, eliminazioni. Il fornitore di contenuti consentirà anche altre parti del codice (anche altre applicazioni, se lo consentono) per accedere ai dati memorizzati nel SQLite.

Si può quindi ignorare le funzioni / interrogazione / aggiornamento inserimento / cancellazione e aggiungere la funzionalità ad esso, ad esempio eseguire azioni diverse a seconda del URI dell'intento.

public int delete(Uri uri, String whereClause, String[] whereArgs) {
    int count = 0;

    switch(URI_MATCHER.match(uri)){
    case ITEMS:
        // uri = content://com.yourname.yourapp.Items/item
        // delete all rows
        count = db.delete(TABLE_ITEMS, whereClause, whereArgs);
        break;
    case ITEMS_ID:
        // uri = content://com.yourname.yourapp.Items/item/2
        // delete the row with the id 2
        String segment = uri.getPathSegments().get(1);
        count = db.delete(TABLE_ITEMS, 
                Item.KEY_ITEM_ID +"="+segment
                +(!TextUtils.isEmpty(whereClause)?" AND ("+whereClause+")":""),
                whereArgs);
        break;
    default:
        throw new IllegalArgumentException("Unknown Uri: "+uri);
    }

    return count;
}

L'UriMatcher è definito come

private static final int ITEMS = 1;
private static final int ITEMS_ID = 2;
private static final String AUTHORITY_ITEMS ="com.yourname.yourapp.Items";
private static final UriMatcher URI_MATCHER;

static {
    URI_MATCHER = new UriMatcher(UriMatcher.NO_MATCH);
    URI_MATCHER.addURI(AUTHORITY_ITEMS, "item", ITEMS);
    URI_MATCHER.addURI(AUTHORITY_ITEMS, "item/#", ITEMS_ID);
}

In questo modo si può decidere se solo 1 risultato deve essere restituito o aggiornato o se tutto deve essere interrogato o no.

Lo SQLiteOpenHelper sarà effettivamente eseguire l'inserimento e anche prendersi cura di aggiornamenti se la struttura delle modifiche del database SQLite, è possibile eseguire lì ridefinendo

class ItemDatabaseHelper extends SQLiteOpenHelper {
    public ItemDatabaseHelper(Context context){
        super(context, "myDatabase.db", null, ITEMDATABASE_VERSION);
    }

    @Override
    public void onCreate(SQLiteDatabase db) {
        // TODO Auto-generated method stub
        String createItemsTable = "create table " + TABLE_ITEMS + " (" +
            ...
        ");";

        // Begin Transaction
        db.beginTransaction();
        try{
            // Create Items table
            db.execSQL(createItemsTable);

            // Transaction was successful
            db.setTransactionSuccessful();
        } catch(Exception ex) {
            Log.e(this.getClass().getName(), ex.getMessage(), ex);
        } finally {
            // End transaction
            db.endTransaction();
        }
    }

    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        String dropItemsTable = "DROP TABLE IF EXISTS " + TABLE_ITEMS;

        // Begin transaction
        db.beginTransaction();

        try {
            if(oldVersion<2){
                // Upgrade from version 1 to version 2: DROP the whole table
                db.execSQL(dropItemsTable);
                onCreate(db);
                Log.i(this.getClass().toString(),"Successfully upgraded to Version 2");
            }
            if(oldVersion<3) {
                // minor change, perform an ALTER query
                db.execSQL("ALTER ...");
            }

            db.setTransactionSuccessful();
        } catch(Exception ex){
            Log.e(this.getClass().getName(), ex.getMessage(), ex);
        } finally {
            // Ends transaction
            // If there was an error, the database won't be altered
            db.endTransaction();
        }
    }
}

e quindi la parte più facile di tutto: Eseguire una query:

String[] rows = new String[] {"_ID", "_name", "_email" };
Uri uri = Uri.parse("content://com.yourname.yourapp.Items/item/2";

// Alternatively you can also use getContentResolver().insert/update/query/delete methods
Cursor c = managedQuery(uri, rows, "someRow=1", null, null); 

Questo è fondamentalmente tutto e il modo più elegante per farlo per quanto ne so.