En utilisant python dans Android à l'interface sql

Question

Je sais que vous pouvez utiliser Python et d'autres langages de script dans Android. Mais je ne l'ai pas vu le temps ou pas, il était possible d'utiliser python comme une interface pour SQLite dans Android. Est-ce possible? Ceci est la première application android où j'ai besoin SQLite, et utilise est retardée de la java api.

Si cela est impossible, quelqu'un peut me pointer vers un bon tutoriel sur SQLite Android? Je l'ai trouvé un groupe, mais chacun d'entre eux sont tout à fait différents et je suis totalement perdu sur ce qui est la meilleure façon de le faire.

Il est juste difficile d'imaginer comment Google vous attend à utiliser la base de données SQLite. Il semble que vous avez besoin comme 10 classes différentes juste pour interroger une base de données.

Answer 1

En fait, vous avez juste besoin de 3 classes:

ContentProvider , que l'on trouve ici: http://developer.android.com/guide/topics/providers/content-providers.html

Deuxièmement, vous avez besoin est un SQLiteOpenHelper et last but not moins un curseur

Edit: juste remarqué qu'il est pas évident à partir des extraits de ce que la variable est db. Il est le SQLiteOpenHelper ou mieux mon extension de celui-ci (où je ne l'ai surchargé l'onCreate, onUpgrade et constructeur. Voir ci-dessous ^^

Le ContentProvider est celui qui sera en communication avec la base de données et faire les insertions, les mises à jour, suppressions. Le fournisseur de contenu permettra également à d'autres parties de votre code (même d'autres applications, si vous le permettez) d'accéder aux données stockées dans la sqlite.

Vous pouvez remplacer l'insertion / suppression / fonctions de requête / mise à jour et ajoutez votre fonctionnalité, par exemple effectuer différentes actions en fonction de l'URI de l'intention.

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

Le UriMatcher est défini comme étant

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

De cette façon, vous pouvez décider si seulement 1 résultat doit être retourné ou mis à jour ou si tout doit être interrogé ou non.

Le SQLiteOpenHelper sera effectivement réaliser l'insert et aussi prendre soin des mises à niveau si la structure de vos modifications de la base de données SQLite, vous pouvez effectuer là en remplaçant

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

et la partie de plus facile tous: Effectuez une requête:

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

C'est essentiellement tout et la façon la plus élégante de le faire autant que je sache.