Android Transazione Di Database

Ho creato un database. Voglio fare la Transazione. SaveCustomer() contiene più di un’istruzione per inserire record in Customer, CustomerControl, Profile, Payment tabella a quel tempo.

Quando un utente chiama SaveCustomer() metodo, quindi, che i dati andranno a queste 4 tabelle.allora, Come posso fare l’operazione? Se una tabella inserti impossibile quindi necessario ripristinare il tutto. Per esempio, quando il 3 tabella inserisce il record ho ottenuto un errore, quindi necessario riportare due precedenti tabella inserire record anche.

Vedere il mio codice:

public void saveCustomer(){
    DBAdapter dbAdapter = DBAdapter.getDBAdapterInstance(RetailerOrderKeyActivity.this);
    dbAdapter.openDataBase();
    ContentValues initialValues = new ContentValues();
    initialValues.put("CustomerName",customer.getName());
    initialValues.put("Address",customer.getAddress());
    initialValues.put("CustomerPID",strPID);
    initialValues.put("Date",strDateOnly);
    long n = dbAdapter.insertRecordsInDB("Customer", null, initialValues);

}

Pure di altri dichiarazione anche lì.

DBAdpter codice :

public long insertRecordsInDB(String tableName, String nullColumnHack,ContentValues initialValues) {
    long n =-1;
    try {
        myDataBase.beginTransaction();
        n = myDataBase.insert(tableName, nullColumnHack, initialValues);

        myDataBase.endTransaction();
        myDataBase.setTransactionSuccessful();
    } catch (Exception e) {
        // how to do the rollback 
        e.printStackTrace();
    }

    return n;
}

Questo è il codice completo:

public class DBAdapter extends SQLiteOpenHelper {

    private static String DB_PATH = "/data/data/com.my.controller/databases/";
    private static final String DB_NAME = "customer";
    private SQLiteDatabase myDataBase;
    private final Context myContext;
    private static DBAdapter mDBConnection;


    private DBAdapter(Context context) {
        super(context, DB_NAME, null, 1);
        this.myContext = context;
        DB_PATH = "/data/data/"
                + context.getApplicationContext().getPackageName()
                + "/databases/";
        // The Android's default system path of your application database is
        //"/data/data/mypackagename/databases/"
    }


    public static synchronized DBAdapter getDBAdapterInstance(Context context) {
        if (mDBConnection == null) {
            mDBConnection = new DBAdapter(context);
        }
        return mDBConnection;
    }


    public void createDataBase() throws IOException {
        boolean dbExist = checkDataBase();
        if (dbExist) {
            //do nothing - database already exist
        } else {
            //By calling following method 
            //1) an empty database will be created into the default system path of your application 
            //2) than we overwrite that database with our database.
            this.getReadableDatabase();
            try {
                copyDataBase();
            } catch (IOException e) {
                throw new Error("Error copying database");
            }
        }
    }


    private boolean checkDataBase() {
        SQLiteDatabase checkDB = null;

        try {
            String myPath = DB_PATH + DB_NAME;
            checkDB = SQLiteDatabase.openDatabase(myPath, null,SQLiteDatabase.OPEN_READONLY);

        } catch (SQLiteException e) {
            //database does't exist yet.
        }
        if (checkDB != null) {
            checkDB.close();
        }
        return checkDB != null ? true : false;
    }


    private void copyDataBase() throws IOException {
        InputStream myInput = myContext.getAssets().open(DB_NAME);
        String outFileName = DB_PATH + DB_NAME;
        OutputStream myOutput = new FileOutputStream(outFileName);  
    byte[] buffer = new byte[1024];
        int length;
        while ((length = myInput.read(buffer)) > 0) {
            myOutput.write(buffer, 0, length);
        }
            // Close the streams
        myOutput.flush();
        myOutput.close();
        myInput.close();
    }

    /**
     * Open the database
     * @throws SQLException
     */
    public void openDataBase() throws SQLException {
        String myPath = DB_PATH + DB_NAME;
        myDataBase = SQLiteDatabase.openDatabase(myPath, null, SQLiteDatabase.OPEN_READWRITE);      
    }


    @Override
    public synchronized void close() {
        if (myDataBase != null)
            myDataBase.close();
        super.close();
    }

    /**
     * Call on creating data base for example for creating tables at run time
     */
    @Override
    public void onCreate(SQLiteDatabase db) {
    }


    @Override
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
        db.execSQL("ALTER TABLE WMPalmUploadControl ADD Testing int");

    }

    public void upgradeDb(){
        onUpgrade(myDataBase, 1, 2);
    }

    public Cursor selectRecordsFromDB(String tableName, String[] tableColumns,
            String whereClase, String whereArgs[], String groupBy,
            String having, String orderBy) {
        return myDataBase.query(tableName, tableColumns, whereClase, whereArgs,
                groupBy, having, orderBy);
    }


    public ArrayList<ArrayList<String>> selectRecordsFromDBList(String tableName, String[] tableColumns,
            String whereClase, String whereArgs[], String groupBy,
            String having, String orderBy) {        

        ArrayList<ArrayList<String>> retList = new ArrayList<ArrayList<String>>();
          ArrayList<String> list = new ArrayList<String>();
          Cursor cursor = myDataBase.query(tableName, tableColumns, whereClase, whereArgs,
                    groupBy, having, orderBy);        
          if (cursor.moveToFirst()) {
             do {
                 list = new ArrayList<String>();
                 for(int i=0; i<cursor.getColumnCount(); i++){                   
                     list.add( cursor.getString(i) );
                 }   
                 retList.add(list);
             } while (cursor.moveToNext());
          }
          if (cursor != null && !cursor.isClosed()) {
             cursor.close();
          }
          return retList;

    }   


    public long insertRecordsInDB(String tableName, String nullColumnHack,ContentValues initialValues) {
        long n =-1;
        try {
            myDataBase.beginTransaction();
            n = myDataBase.insert(tableName, nullColumnHack, initialValues);

            myDataBase.endTransaction();
            myDataBase.setTransactionSuccessful();
        } catch (Exception e) {
            // how to do the rollback 
            e.printStackTrace();
        }

        return n;
    }


    public boolean updateRecordInDB(String tableName,
            ContentValues initialValues, String whereClause, String whereArgs[]) {
        return myDataBase.update(tableName, initialValues, whereClause,
                whereArgs) > 0;             
    }

    public int updateRecordsInDB(String tableName,
            ContentValues initialValues, String whereClause, String whereArgs[]) {
        return myDataBase.update(tableName, initialValues, whereClause, whereArgs);     
    }


    public int deleteRecordInDB(String tableName, String whereClause,
            String[] whereArgs) {
        return myDataBase.delete(tableName, whereClause, whereArgs);
    }


    public Cursor selectRecordsFromDB(String query, String[] selectionArgs) {
        return myDataBase.rawQuery(query, selectionArgs);       
    }


    public ArrayList<ArrayList<String>> selectRecordsFromDBList(String query, String[] selectionArgs) {       
          ArrayList<ArrayList<String>> retList = new ArrayList<ArrayList<String>>();
          ArrayList<String> list = new ArrayList<String>();
          Cursor cursor = myDataBase.rawQuery(query, selectionArgs);            
          if (cursor.moveToFirst()) {
             do {
                 list = new ArrayList<String>();
                 for(int i=0; i<cursor.getColumnCount(); i++){                   
                     list.add( cursor.getString(i) );
                 }   
                 retList.add(list);
             } while (cursor.moveToNext());
          }
          if (cursor != null && !cursor.isClosed()) {
             cursor.close();
          }
          return retList;
       }

}

database il problema di blocco nel HTC Desire.

Voglio rollback se ci sono problemi durante la fase di inserimento dei dati della tabella.

Si prega di aiutare me

Grazie.

Ho guardato questa stessa domanda correlata :

InformationsquelleAutor Kartheepan | 2011-11-16



3 Replies
  1. 275

    In realtà stai facendo male.
    È necessario impostare iniziare la transazione se si dispone di più di un record da inserire nel database o
    se si dispone di ripristino di dati da un’altra tabella, se c’è un problema nell’inserimento dei dati in una tabella di database.

    Per esempio

    Vi sono due tabelle

    1. Un
    2. B

    Ora si desidera inserire i dati in queste due tabelle, ma si dovrà rollback della transazione, se si ottiene un errore al momento dell’inserimento dei dati nelle tabelle.

    Ora è stato l’inserimento di dati in Una tabella e ora si sta tentando di inserire i dati nella tabella B. Ora, se ti da errore al momento dell’inserimento dei dati nella tabella B, quindi devi eliminare i dati da Una tabella che significa che è necessario eseguire il rollback della transazione.

    Come è possibile utilizzare il database delle transazioni in Android

    1. Se si desidera avviare l’operazione c’è un metodo beginTransaction()
    2. Se si desidera eseguire il commit della transazione c’è un metodo setTransactionSuccessful() che impegnerà i valori nel database
    3. Se hai avuto inizio l’operazione è necessario chiudere la transazione in modo che ci sia un metodo endTransaction() che terminerà il database delle transazioni

    Ora ci sono due punti principali

    1. Se si desidera impostare una transazione di successo è necessario scrivere setTransactionSuccessful() e poi endTransaction() dopo beginTransaction()
    2. Se si desidera rollback della transazione, allora avete bisogno di endTransaction() senza il commit della transazione da setTransactionSuccessful().

    È possibile ottenere informazioni dettagliate circa il database SQLite transazione da qui

    Nel tuo caso

    È possibile chiamare il vostro saveCustomer() funzione in blocchi try e catch

    db.beginTransaction();
    try {
        saveCustomer();
        db.setTransactionSuccessful();
    } catch {
        //Error in between database transaction 
    } finally {
        db.endTransaction();
    }
    • Grazie per queste informazioni. La sua più utile per me!!!. Grazie ancora
    • Si dovrebbe aggiungere endTransaction nel infine, non nel blocco try.
    • hai ragione, infine, è il posto migliore per chiudere la transazione di database. grazie per renderlo migliore.
    • upvoting duro come posso su questa risposta, grazie
    • +1 Molto utile. grazie.
    • +1 Una bella e semplice spiegazione.
    • A1 risposta grazie.

  2. 25

    si dovrebbe aggiungere endTransaction nel finally, non nel blocco try

     finally {
         myDataBase.endTransaction();
       }

    Le modifiche sarà annullata in caso di qualsiasi transazione è conclusa senza
    essere contrassegnati come pulire (chiamando setTransactionSuccessful).
    In caso contrario, sarà impegnata.

    • Grazie per le informazioni. Nel mio ‘SaveCustomer()` sto andando a chiamare’ lungo n = dbAdapter.insertRecordsInDB (il”Cliente”, null, initialValues); ” nel 4 tempo con diversi record. Sarà rollback tutto, se c’è qualche errore si verifica anche in mezzo alla tavola.Ho 4 tabella.Bisogno di aggiungere record in 4 tabella con i record diversi.?
  3. 15

    Inserisci Record Usando la Transazione, Questo è molto veloce

    String sql = "INSERT INTO table (col1, col2) VALUES (?, ?)";
    db.beginTransaction();
    
    SQLiteStatement stmt = db.compileStatement(sql);
    for (int i = 0; i < values.size(); i++) {
        stmt.bindString(1, values.get(i).col1);
        stmt.bindString(2, values.get(i).col2);
        stmt.execute();
        stmt.clearBindings();
    }
    
    db.setTransactionSuccessful();
    db.endTransaction();

Lascia un commento