Veritabanı oluşturdum. İşlem yapmak istiyorum. SaveCustomer() Customer, CustomerControl, Profile,Payment tabloya kayıt eklemek, birden fazla deyim içerir.

Kullanıcı SaveCustomer() yöntem çağrısı ardından verileri bu 4 tablo gidecek.Nasıl işlem yapabilirim? Bir tablo eklemek failer sonra geri alma her şey için gerekiyorsa. 3. tabloya kayıt eklediğinizde örneğin hata var, önceki iki tablo Ekle kayıtları da geri almak için gerekir.

Bakın benim kod:

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

      }

Aynı şekilde diğer deyim de var.

DBAdpter kodu :

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

Bu tam kodu

     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 lock problem in HTC Desire.

Eğer orada herhangi bir sorunları tablo verileri eklediğinizde oluştu geri istiyorum.

Bana yardım edin lütfen

Teşekkürler.

Bu aynı konuyla ilgili soru baktım :

Aslında yanlış yapıyorsun. Eğer veritabanına eklemek veya birden çok kayıt varsa işlem başlar ayarlamak gerekir eğer başka bir tablodan veri geri almak için eğer varsa veritabanı tablo ekleme veri bir sorun var.

Örneğin

İki tablo var

1. Bir
2. B

Şimdi bu iki tabloya veri eklemek istiyorum ama eğer tablolarda veri ekleme sırasında herhangi bir hata alırsınız eğer hareketi geri alma.

Şimdi başarıyla insert veri tablo ve şimdi eklemeye veri tablosu B. Şimdi alırsan hata zaman veri ekleme tablo B sonra silmek için ilgili verileri Tablo Bir anlamı var geri alma hareketi.

Nasıl Android veritabanı işlem kullanabilirsiniz

1. Eğer işlem başlatmak istiyorsanız bir yöntemdir beginTransaction()
2. Eğer hareketi tamamlamak istiyorsan bir yöntemdir veritabanı değerlerini kaydetme setTransactionSuccessful()
3. Eğer işlem başlatmak olsaydı veritabanı işlem sona erecek bir yöntem endTransaction() Bu işlem kapatmak gerekir

Şimdi iki ana nokta var

1. Eğer işlem başarılı ayarlamak istiyorsanız beginTransaction() sonra setTransactionSuccessful() endTransaction() yazmak gerekir
2. Eğer hareket sonra geri almak isterseniz 17 ** setTransactionSuccessful() tarafından işlem yapılıyor olmadan.

here SQLite veritabanı işlem hakkında detaylı bilgi alabilirsiniz

Senin durumunda

Deneyin saveCustomer() işlev çağrısı ve engeller yakalamak

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