Usando Python no Android para interface com SQL

Question

Eu sei que você pode usar o Python e outras linguagens de script no Android. Mas não vi o tempo ou não, foi possível usar o Python como uma interface para SQLite no Android. Isso é possível? Este é o primeiro aplicativo Android em que eu precisava do SQLite, e o uso da API Java é retardado.

Se isso não for possível, alguém pode me indicar um bom tutorial sobre o SQLite no Android? Eu encontrei um monte, mas todos eles são totalmente diferentes e estou totalmente perdido, qual é a melhor maneira de fazê -lo.

É difícil imaginar como o Google espera que você use o banco de dados SQLite. Parece que você precisa de 10 classes diferentes apenas para consultar um banco de dados.

Answer 1

Na verdade, você só precisa de 3 aulas:

UMA Provedor de conteúdo, como encontrado aqui: http://developer.android.com/guide/topics/providers/content-providers.html

Segundo que você precisa é um Sqliteopenhelper e por último, mas não menos importante, um Cursor

Editar: acabei de notar que não é óbvio dos trechos o que o db variável é. É o sqliteopenhelper ou melhor minha extensão (onde eu apenas substituí o OnCreate, OnUpgrade e o construtor. Veja abaixo ^^

O ContentProvider é o que se comunicará com o banco de dados e fará as inserções, atualizações, excluirá. O provedor de conteúdo também permitirá que outras partes do seu código (mesmo outros aplicativos, se você permitirem) acesse os dados armazenados no sqlite.

Em seguida, você pode substituir as funções Inserir/Excluir/consultar/atualizar e adicionar sua funcionalidade, por exemplo, execute ações diferentes, dependendo do URI da intenção.

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

O urinatcher é definido 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);
}

Dessa forma, você pode decidir se apenas 1 resultado será devolvido ou atualizado ou se tudo deve ser consultado ou não.

O sqliteopenhelper realmente executará a inserção e também cuidará das atualizações se a estrutura das suas alterações no banco de dados SQLite, você poderá executá -lo lá, substituindo

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 então a parte mais fácil de todos: execute uma 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); 

Isso é basicamente tudo e a maneira mais elegante de fazê -lo até onde eu sei.