Uso de pitón en androide a la interfaz a SQL

Question

Sé que usted puede utilizar Python y otros lenguajes de scripting en el androide. Pero no he visto el tiempo o no era posible utilizar Python como una interfaz para sqlite en Android. es posible? Esta es la primera aplicación para Android, donde he necesitado SQLite, y su uso de la API de Java se retarda.

Si esto no es posible, puede que alguien me punto a un buen tutorial sobre sqlite en Android? He encontrado un montón, pero todos ellos son completamente diferentes y estoy totalmente perdido en la que es la mejor manera de hacerlo.

Es simplemente difícil de imaginar cómo Google espera que utilice la base de datos SQLite. Parece que usted necesita como 10 clases diferentes sólo para consultar una base de datos.

Answer 1

En realidad sólo tiene 3 clases:

ContentProvider , tal como se encuentra aquí: http://developer.android.com/guide/topics/providers/content-providers.html

En segundo lugar usted necesita es un SQLiteOpenHelper y por último pero no menos un Cursor

Editar: Sólo se dio cuenta de que no es obvio a partir de los fragmentos de lo que es la variable db. Es la SQLiteOpenHelper o mejor mi extensión de la misma (en la que sólo he anulado onCreate, ONUPGRADE y constructor. Véase más abajo ^^

El ContentProvider es la que se comunica con la base de datos y hacer las inserciones, actualizaciones, eliminaciones. El proveedor de contenido también permitirá a otras partes de su código (incluso otras aplicaciones, si usted lo permite) para acceder a los datos almacenados en el SQLite.

A continuación, puede anular las funciones / consulta / actualización de insertar / eliminar y añadir su funcionalidad a la misma, por ejemplo, realizar diferentes acciones en función de la URI de la intención.

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

El UriMatcher se define como

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 esta manera usted puede decidir si sólo el 1 resultado será devuelta o actualizado o si todo debe ser consultado o no.

El SQLiteOpenHelper realidad llevará a cabo la inserción y también cuidar de las actualizaciones si la estructura de sus cambios de bases de datos SQLite, puede realizar allí reemplazando

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

y luego la parte más fácil de todos: Realizar una consulta:

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

Eso es básicamente todo y la forma más elegante de hacerlo por lo que yo sé.