öffnen/schließen Datenbank Muster für einzelne vs. mehrere Insertion ruft

Question

Zum Beispiel diese Funktion betrachten

public void insertRow(CoolObject coolObject) { 
    ContentValues values = new ContentValues(); 
    values.put("some field name", coolObject.getSomeValue()); 
    //and so on and so on 

    mDatabase.open(); 
    mDatabase.insertWithOnConflict("CoolTable", 
     null, 
     values, 
     SQLiteDatabase.CONFLICT_IGNORE); 
    mDatabase.close(); 
} 

ich die Datenbank öffnen, führen Sie einen SQL-Befehl von einer Art, die Datenbank, dann wieder auf die Datenbank schließen.

Betrachten wir nun diese:

public void insertRows(List<CoolObject> coolObjectList) { 
    mDatabase.beginTransaction(); 
    try { 
     for (CoolObject coolObject : coolObjectList) { 
      insertRow(coolObject); 
     } 
     mDatabase.setTransactionSuccessful(); 
    } 
    finally { 
     mDatabase.endTransaction(); 
    } 
} 

In diesem Fall habe ich eine Schleife ausführen, die insertRow() wiederholt aufruft, sondern im Rahmen einer einzigen Datenbanktransaktion.

Meine Frage:

Ist es ein Problem, dass ich offen und in der Nähe nennen, wie ich tun? Es kann für einen einzelnen Anruf sinnvoll sein, aber ich sorge mich, dass, wenn ich die Einfügerei immer und immer wieder rufe, das Öffnen und Schließen viel ist.

Und wenn die Datenbank bis zum Ende der Zeilenoperation geschlossen ist, muss ich sie wieder öffnen, auch für die Dinge wie mDatabase.beginTransaction(); oder mDatabase.setTransactionSuccessful(); oder mDatabase.endTransaction();?

Ich kann auch nicht nur die offene nehmen und in der Nähe der insertRow() aus entweder und fügen Sie es zu Beginn und am Ende der insertRows() Methode entweder, weil dann ist es, na ja, nicht in insertRow() so jetzt, wenn ich anrufen will, dass Funktion für sich selbst Ich bin nicht mehr öffnen/schließen.

Was ist der akzeptierte Weg, um diese Fehler zu umgehen?

Answer 1

Ist es ein Problem, das ich offen und nah wie ich es nenne? Es kann für einen einzelnen Anruf sinnvoll sein, aber ich sorge mich, dass, wenn ich die Einfügerei immer und immer wieder rufe, das Öffnen und Schließen viel ist.

Je nach Datenbank, werden Sie einen neuen Prozess öffnen oder jedes Mal Faden, der nicht nicht wirklich effizient, zu der Tatsache, dass es nicht richtig schließen kann ...

kombinierte Einsätze Versuchen, Es wird dazu beitragen, Ressourcen niedrig zu halten.

Wenn Sie eine Gelegenheit haben und immer noch den ersten Weg gehen wollen, implementieren Sie einen Verbindungspool, der Verbindungen geöffnet hält.

Answer 2

public void insertRow(CoolObject coolObject) { 
    ContentValues values = new ContentValues(); 
    values.put("some field name", coolObject.getSomeValue()); 
    //and so on and so on 

    mDatabase.open(); 
    try { 
     // Do whatever you want to do with your connection 
     mDatabase.insertWithOnConflict("CoolTable", 
      null, 
      values, 
      SQLiteDatabase.CONFLICT_IGNORE); 
    }catch(Exception err) { 
     // handle error 
    }finally { 
     mDatabase.close();   
    } 
} 

Meiner Meinung nach sollte der obige Code Sie die meisten Fälle behandeln lassen. In der obigen Methode, wenn der mDatabase.open() Fehler werfen würde, wäre es ein Problem. Um diesen Fall zu behandeln, könnten Sie den connection als Ressourcenparameter an Ihre try-Methode übergeben.