Transaction de base de données Android

Question

J'ai créé la base de données. Je veux faire la Transaction. SaveCustomer() contiennent plus qu'une seule déclaration pour insérer des enregistrements d' Customer, CustomerControl, Profile,Payment tableau à l'époque.

Lorsque l'utilisateur d'appel SaveCustomer() méthode alors que les données iront à ces 4 table.alors, Comment puis-je faire la transaction? Si un tableau insérer failer alors besoin de restaurer à tout. Par exemple, lors de la 3e table insérez le disque que j'ai eu d'erreur, alors besoin de la fonction restauration des deux précédents table d'insérer des enregistrements aussi.

Voir mon code:

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

      }

De même, l'énoncé d'autres aussi.

DBAdpter code est :

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

C'est le code complet:

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

}

verrou de base de données problème dans le Désir de HTC.

Je veux la restauration si il y a des problèmes survenus lors de l'insertion du tableau de données.

Merci de m'aider

Merci.

J'ai regardé cette même question liée à :

Answer 1

Effectivement vous faire du mal. Vous devez définir le début de la transaction si vous avez plusieurs dossiers à insérer dans la base de données ou si vous avez de la restauration des données à partir d'une autre table si il y a un problème en insérant les données de la table de base de données.

Par exemple

Vous avez deux tables

1. Un
2. B

Maintenant, vous voulez insérer des données dans ces deux tableaux, mais vous devez annuler la transaction si vous receviez une erreur au moment de l'insertion de données dans les tables.

Maintenant que vous avez réussi à insérer des données dans Une table, et maintenant vous essayez d'insérer des données dans la table B. Maintenant, si vous obtenez l'erreur au moment de l'insertion de données dans la table B, alors vous devez supprimer les données pertinentes à partir d'Une table qui signifie que vous devez annuler la transaction.

Comment vous pouvez utiliser la base de données de transaction dans Android

1. Si vous voulez commencer l'opération, il est une méthode beginTransaction()
2. Si vous souhaitez valider la transaction, il existe une méthode setTransactionSuccessful() qui engage les valeurs dans la base de données
3. Si vous aviez commencé à la transaction, vous devez fermer la transaction, donc il y a une méthode endTransaction() qui mettra fin à la transaction de base de données

Maintenant, il y a deux points principaux

1. Si vous souhaitez définir transaction réussie, vous devez écrire setTransactionSuccessful() puis endTransaction() après beginTransaction()
2. Si vous souhaitez reprendre votre transaction puis vous avez besoin d' endTransaction() sans la validation de la transaction par setTransactionSuccessful().

Vous pouvez obtenir des informations détaillées à propos de la base de données SQLite transaction à partir d' ici

Dans votre cas

Vous pouvez appeler votre saveCustomer() fonction dans les blocs try et catch

   db.beginTransaction();
        try {
            saveCustomer();
            db.setTransactionSuccessful();

        }catch {
            //Error in between database transaction 
        }finally {
                db.endTransaction();

        }

Answer 2

vous devriez ajouter endTransaction dans votre finally , pas dans votre bloc try

  finally {
     myDataBase.endTransaction();
   }
 

Les modifications seront annulées si une transaction est terminée sans être marquée comme propre (en appelant setTransactionSuccessful). Sinon, ils seront commis.

Answer 3

Insérer un enregistrement à l'aide d'une transaction, c'est très rapide

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