2014-04-19 6 views
5

मेरे पास डेटाबेस हैंडलर है। मुझे टेबल में पंक्तियों को गिनने की जरूरत है। ऐप इस त्रुटि से दुर्घटनाग्रस्त: android attempt to reopen an already-closed object sqlitedatabase
मैं बस गतिविधि में इस कोड का उपयोग:पहले से बंद ऑब्जेक्ट को दोबारा खोलने का प्रयास sqlitedatabase

db.getContactsCount(); 

लेकिन ऐप्लिकेशन क्रैश। फर्टहेमोर मैं टेबल को रीसेट करना चाहता हूं (टेबल पंक्तियां हटाएं)। मैं नीचे दी गई विधि कहा:

public void deleteTable() { 
     SQLiteDatabase db = this.getWritableDatabase(); 
     db.delete("contacts", null, null); 
    } 

यह अच्छा काम करता है, लेकिन मैं उपयोग नहीं कर सकते यह एक:

public class DatabaseHandler extends SQLiteOpenHelper { 

// All Static variables 
// Database Version 
private static final int DATABASE_VERSION = 1; 

// Database Name 
private static final String DATABASE_NAME = "contactsManager"; 

// Contacts table name 
private static final String TABLE_CONTACTS = "contacts"; 

// Contacts Table Columns names 
private static final String KEY_ID = "id"; 
private static final String KEY_NAME = "name"; 
private static final String KEY_PH_NO = "phone_number"; 

public DatabaseHandler(Context context) { 
    super(context, DATABASE_NAME, null, DATABASE_VERSION); 
} 

// Creating Tables 
@Override 
public void onCreate(SQLiteDatabase db) { 
    String CREATE_CONTACTS_TABLE = "CREATE TABLE " + TABLE_CONTACTS + "(" 
      + KEY_ID + " INTEGER PRIMARY KEY," + KEY_NAME + " TEXT," 
      + KEY_PH_NO + " TEXT" + ")"; 
    db.execSQL(CREATE_CONTACTS_TABLE); 
} 

// Upgrading database 
@Override 
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 
    // Drop older table if existed 
    db.execSQL("DROP TABLE IF EXISTS " + TABLE_CONTACTS); 

    // Create tables again 
    onCreate(db); 
} 

/** 
* All CRUD(Create, Read, Update, Delete) Operations 
*/ 

// Adding new contact 
void addContact(Contact contact) { 
    SQLiteDatabase db = this.getWritableDatabase(); 

    ContentValues values = new ContentValues(); 
    values.put(KEY_NAME, contact.getName()); // Contact Name 
    values.put(KEY_PH_NO, contact.getPhoneNumber()); // Contact Phone 

    // Inserting Row 
    db.insert(TABLE_CONTACTS, null, values); 
    db.close(); // Closing database connection 
} 

// Getting single contact 
Contact getContact(int id) { 
    SQLiteDatabase db = this.getReadableDatabase(); 

    Cursor cursor = db.query(TABLE_CONTACTS, new String[] { KEY_ID, 
      KEY_NAME, KEY_PH_NO }, KEY_ID + "=?", 
      new String[] { String.valueOf(id) }, null, null, null, null); 
    if (cursor != null) 
     cursor.moveToFirst(); 

    Contact contact = new Contact(Integer.parseInt(cursor.getString(0)), 
      cursor.getString(1), cursor.getString(2)); 
    // return contact 
    return contact; 
} 

// Getting All Contacts 
public List<Contact> getAllContacts() { 
    List<Contact> contactList = new ArrayList<Contact>(); 
    // Select All Query 
    String selectQuery = "SELECT * FROM " + TABLE_CONTACTS; 

    SQLiteDatabase db = this.getWritableDatabase(); 
    Cursor cursor = db.rawQuery(selectQuery, null); 

    // looping through all rows and adding to list 
    if (cursor.moveToFirst()) { 
     do { 
      Contact contact = new Contact(); 
      contact.setID(Integer.parseInt(cursor.getString(0))); 
      contact.setName(cursor.getString(1)); 
      contact.setPhoneNumber(cursor.getString(2)); 
      // Adding contact to list 
      contactList.add(contact); 
     } while (cursor.moveToNext()); 
    } 

    // return contact list 
    return contactList; 
} 

// Updating single contact 
public int updateContact(Contact contact) { 
    SQLiteDatabase db = this.getWritableDatabase(); 

    ContentValues values = new ContentValues(); 
    values.put(KEY_NAME, contact.getName()); 
    values.put(KEY_PH_NO, contact.getPhoneNumber()); 

    // updating row 
    return db.update(TABLE_CONTACTS, values, KEY_ID + " = ?", 
      new String[] { String.valueOf(contact.getID()) }); 
} 

// Deleting single contact 
public void deleteContact(Contact contact) { 
    SQLiteDatabase db = this.getWritableDatabase(); 
    db.delete(TABLE_CONTACTS, KEY_ID + " = ?", 
      new String[] { String.valueOf(contact.getID()) }); 
    db.close(); 
} 


// Getting contacts Count 
public int getContactsCount() { 
    String countQuery = "SELECT * FROM " + TABLE_CONTACTS; 
    SQLiteDatabase db = this.getReadableDatabase(); 
    Cursor cursor = db.rawQuery(countQuery, null); 
    cursor.close(); 

    // return count 
    return cursor.getCount(); 
} 

public void Upgrade (SQLiteDatabase db, int oldVersion, int newVersion) { 
    String CREATE_CONTACTS_TABLE = "CREATE TABLE " + TABLE_CONTACTS + "(" 
      + KEY_ID + " INTEGER PRIMARY KEY," + KEY_NAME + " TEXT," 
      + KEY_PH_NO + " TEXT" + ")"; 
    db.execSQL(CREATE_CONTACTS_TABLE); 
} 

// Deleting single contact 
    public void deleteTable() { 
     SQLiteDatabase db = this.getWritableDatabase(); 
     db.delete("contacts", null, null); 
    } 
} 
+0

का उपयोग करके सभी ऑपरेशन करने के बाद बंद करें, बस myDb.open() नामक लाइन का उपयोग करके इसे खोलें। फिर अपना काम करो। – itsrajesh4uguys

+0

होला। 'myDb.open()' डेटाबेस को अपग्रेड करेगा? तालिका पंक्तियों को हटाने, ...? –

उत्तर

13

की वजह से इसे होता है:

@Override 
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 
    // Drop older table if existed 
    db.execSQL("DROP TABLE IF EXISTS " + TABLE_CONTACTS); 

    // Create tables again 
    onCreate(db); 
} 

यह databasehandler है:

db.close();

तरीकों में:

void addContact(Contact contact)

public void deleteContact(Contact contact)

आप जब तक आप वास्तव में अब और इसके साथ काम करने के लिए इरादा नहीं है अंतर्निहित डेटाबेस के लिए कनेक्शन बंद नहीं करना चाहिए। जब आप अपना काम पूरा कर लेंगे, तो SQLiteOpenHelper:close का उपयोग करें।

इसके अलावा, getReadableDatabase() करने के लिए कॉल और एक समय का एक ही डेटाबेस ऑब्जेक्ट प्रदान getWriteableDatabase() 99%, और वे नहीं reinitialize डेटाबेस कनेक्शन आपके द्वारा मैन्युअल रूप से बंद कर दिया करते

इन विधि नामों से मूर्ख मत बनो।

1

मुझे डेटाबेस बंद करने से पहले int count = cursor.getCount(); परिभाषित करना चाहिए था। ऐसा लगता है कि डेटाबेस बंद करने के बाद return cursor.getCount(); एक बेकार प्रयास है।
हटाने और हटाने के तरीकों को हटाने के अंत में db.close(); को हटाने के लिए आवश्यक था।
हैंडलर में बजाय इस कोड को जोड़ने के बजाय बहुत मदद की:

public void closeDB() { 
    SQLiteDatabase db = this.getReadableDatabase(); 
    if (db != null && db.isOpen()) 
     db.close(); 
} 

डेटाबेस उपयोग के अंत में गतिविधि के अंदर close समारोह से छेड़छाड़ बेहतर था। @ ड्रू के लिए धन्यवाद।
मैं अब भी हैंडलर के अंदर onUpgrade के उपयोग को समझ नहीं सकता ???

0

ऑन अपग्रेड तब होता है जब आपने अपने डेटाबेस में परिवर्तन किए हैं (यानी टेबल जोड़ना) तो अब आपके डेटाबेस का एक नया संस्करण है। आपका:

private static final int DATABASE_VERSION = 1; 

अब क्योंकि डेटाबेस संस्करण अब अधिक नए संस्करण OnUpgrade() विधि कहा जाता है और डेटाबेस को अद्यतन करता है

private static final int DATABASE_VERSION = 2; 

1

यह मूल रूप से कर्सर का bcoz होता है।बंद करे(); जब आप कर्सर ऑब्जेक्ट को बंद कर देते हैं तो इससे पहले कि आप इसकी गिनती वापस कर रहे हों।

6

मैं आपको सुझाव देना चाहता हूं कि, डेटाबेस डेटाबेस को पूरा करने से पहले डेटाबेस ऑब्जेक्ट को बंद न करें।

SQLiteDatabase db; 
db = this.getWritableDatabase(); 

or 

db = this.getReadableDatabase(); 

दोनों विधि से ऊपर हमें डेटाबेस वस्तु सहायक वर्ग का उपयोग करने और का उपयोग कर इस वस्तु हम डेटाबेस पर विभिन्न कार्यों कर सकते हैं दे। लेकिन आपके परिदृश्य में, मुझे लगता है कि आपने पूर्ण डेटाबेस ऑपरेशन से पहले डेटाबेस ऑब्जेक्ट बंद कर दिया है।

db.close(); 
संबंधित मुद्दे