Android Veritabanı İşlemi

84

Bir veritabanı oluşturdum. İşlemi yapmak istiyorum. o anda tabloya SaveCustomer()kayıt eklemek için birden fazla ifade içerir Customer, CustomerControl, Profile, Payment.

Bir kullanıcı SaveCustomer()metodu çağırdığında o veri bu 4 tabloya gidecek. Yani işlemi nasıl yapabilirim? Bir tablo eki başarısız olursa, her şeyi geri almanız gerekir. Örneğin, 3. tablo hata aldığım kaydı eklediğinde, önceki iki tablonun ekleme kayıtlarını da geri almam gerekiyor.

Koduma bakın:

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 başka bir açıklama da 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 kod:

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

}

HTC Desire'da veritabanı kilidi sorunu .

Tablo verilerini eklerken herhangi bir sorun olursa geri almak istiyorum.

Lütfen bana yardım et

Teşekkürler.

Aynı soruya baktım:

android  sqlite  transactions 
— Kartheepan
kaynak

Yanıtlar:

279

Aslında yanlış yapıyorsun. Veritabanına eklemek için birden fazla kaydınız varsa veya veritabanı tablosundan birine veri eklemede bir sorun varsa diğer tablodan verileri geri almanız gerekiyorsa, işlemi başlat ayarlamanız gerekir.

Örneğin

İki masanız var

  1. Bir
  2. B

Şimdi bu iki tabloya veri eklemek istiyorsunuz, ancak tablolara veri girerken herhangi bir hata alırsanız işlemi geri almanız gerekecek.

Şimdi tablo A'ya başarıyla veri eklediniz ve şimdi B tablosuna veri eklemeye çalışıyorsunuz. Şimdi B tablosuna veri eklerken hata alırsanız, A tablosundaki ilgili verileri silmeniz gerekir, bu da sizin işlemi geri almak zorunda.

Android'de veritabanı işlemini nasıl kullanabilirsiniz?

  1. İşlemi başlatmak istiyorsanız bir yöntem var beginTransaction()
  2. İşlemi gerçekleştirmek istiyorsanız setTransactionSuccessful(), veri tabanındaki değerleri kaydedecek bir yöntem vardır.
  3. İşlemi başlattıysanız, işlemi kapatmanız gerekir, böylece endTransaction()veritabanı işleminizi sona erdirecek bir yöntem vardır.

Şimdi iki ana nokta var

  1. Set işlem istiyorsanız başarılı yazmanız gereken setTransactionSuccessful()sonra ve endTransaction()sonrabeginTransaction()
  2. Eğer hareketi geri almak istiyorsanız, o zaman gerek endTransaction()tarafından işlem yapılıyor olmadan setTransactionSuccessful().

Sen gelen SQLite veritabanı işlem hakkında detaylı bilgi alabilirsiniz burada

Senin durumunda

saveCustomer()Try and catch bloklarında fonksiyonunuzu çağırabilirsiniz

db.beginTransaction();
try {
    saveCustomer();
    db.setTransactionSuccessful();
} catch {
    //Error in between database transaction 
} finally {
    db.endTransaction();
}
— Dharmendra
kaynak
11
endTransactionDeneme bloğunuza değil, sonunda eklemelisiniz .
— VansFannel
6
@VansFannel nihayet haklısın, veritabanı işlemini kapatmak için en iyi yer. daha iyi hale getirdiğin için teşekkürler.
— Dharmendra
25

Eklemek gerekir endTransactionGözlerinde farklı finallydeğil try bloğundaki,

 finally {
     myDataBase.endTransaction();
   }

Herhangi bir işlem temiz olarak işaretlenmeden sonlandırılırsa (setTransactionSuccessful çağrılarak) değişiklikler geri alınır. Aksi takdirde taahhüt edilirler.

— Labeeb Panampullan
kaynak
1
Bilgi için teşekkürler. 'SaveCustomer ()' da 'long n = dbAdapter.insertRecordsInDB ("Müşteri", null, initialValues); 4 seferde farklı kayıtlarla. Ortadaki tabloda bile herhangi bir hata olursa her şeyi geri alır mı? 4 tablom var. 4 tabloya farklı kayıtlarla kayıt eklemem gerekiyor.
— Kartheepan
17

İşlemi Kullanarak Kayıt Ekleyin, Bu çok hızlı

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();
— Piyush
kaynak
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.