2012-03-07 10 views
125

मेरे ऐप में दो बटन हैं, पहला बटन उपयोगकर्ता इनपुट पर रिकॉर्ड हटाने के लिए है और दूसरा बटन सभी रिकॉर्ड्स को हटाने के लिए है। लेकिन जब मैं डेटा को हटाना चाहता हूं तो यह संदेश
दिखाता है "आपका आवेदन मजबूती से बंद कर दिया गया है"।एंड्रॉइड के साथ एसक्लाइट में तालिका से सभी रिकॉर्ड कैसे हटाएं?

कृपया मेरा कोड जांचें और मुझे कुछ सुझाव दें।

public void deleteAll() 
{ 
    //SQLiteDatabase db = this.getWritableDatabase(); 
    // db.delete(TABLE_NAME,null,null); 
    //db.execSQL("delete * from"+ TABLE_NAME); 
    db.execSQL("TRUNCATE table" + TABLE_NAME); 
    db.close(); 
} 

और

public void delete(String id) 
{ 
    String[] args={id}; 
    getWritableDatabase().delete("texts", "_ID=?", args); 
} 

लेकिन यह निम्न लॉग बिल्ली त्रुटि दिखाता है।

03-07 15:57:07.143: ERROR/AndroidRuntime(287): Uncaught handler: thread main exiting due to uncaught exception 
03-07 15:57:07.153: ERROR/AndroidRuntime(287): java.lang.NullPointerException 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at com.example.MySQLiteHelper.delete(MySQLiteHelper.java:163) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at com.example.Settings$4.onClick(Settings.java:94) 
-07 15:57:07.153: ERROR/AndroidRuntime(287):  at com.android.internal.app.AlertController$ButtonHandler.handleMessage(AlertController.java:158) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at android.os.Handler.dispatchMessage(Handler.java:99) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at android.os.Looper.loop(Looper.java:123) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at android.app.ActivityThread.main(ActivityThread.java:4203) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at java.lang.reflect.Method.invokeNative(Native Method) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at java.lang.reflect.Method.invoke(Method.java:521) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:791) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:549) 
03-07 15:57:07.153: ERROR/AndroidRuntime(287):  at dalvik.system.NativeStart.main(Native Method) 
+1

से सभी डेटा getWritableDatabase की तरह लगता है() आप रिटर्न अशक्त, तो आप इस मुद्दे की जांच करनी चाहिए। – Egor

+3

आप "से" के बाद एक जगह खो रहे हैं, इस तरह तालिका नाम को "से" के साथ संयोजित किया गया है और यह आपको एक त्रुटि देता है – Th0rndike

+1

इसके अलावा आप कोशिश {try catch (exception e) {Console.WriteLine (e);} कार्यक्रम को कुचलने से बचने और त्रुटि का विश्लेषण करने के लिए। –

उत्तर

259

तुम एक अंतरिक्ष याद किया: db.execSQL("delete * from " + TABLE_NAME);

इसके अलावा भी * शामिल करने के लिए कोई जरूरत नहीं है, सही क्वेरी है:

db.execSQL("delete from "+ TABLE_NAME); 
+4

'*' शामिल करने का कोई कारण नहीं है। –

+4

कमांड हटाने के बाद वैक्यूम का उपयोग करें .. db.execSQL ("वैक्यूम"); यह सभी आवंटित रिक्त स्थान साफ़ कर देगा .. –

+5

क्वेरी सिर्फ "TABLENAME से हटाएं" है http://www.tutorialspoint.com/sqlite/sqlite_delete_query.htm, मैंने समझने से पहले 1 घंटे बिताया * गलत था! – eeadev

18

SQLite TRUNCATE कमांड का समर्थन नहीं करता है। आपको पिछली पंक्ति में जो भी प्रयास किया गया है उसका उपयोग करना चाहिए:

DELETE FROM `TABLE_NAME`; 

पीएस आप प्रत्येक क्वेरी के लिए एक नया निर्माण करने के बजाय दिए गए डेटाबेस में अपने सभी प्रश्नों के लिए डेटाबेस कनेक्शन के उसी उदाहरण का उपयोग करके अपने प्रोग्राम को अनुकूलित कर सकते हैं।

+1

असल में, मुझे लगता है कि यह 'table_name से हटा दिया गया है'; यह SQLite –

+0

@NathanWallace सटीक रूप से सही में तारांकन के साथ मेरे लिए काम नहीं करता है। धन्यवाद। मैंने जवाब अपडेट कर लिया है। :) –

33

तालिका में मौजूद सभी पंक्तियों आप उपयोग कर सकते हैं हटाने के लिए:

db.delete(TABLE_NAME, null, null); 
3

तालिका से सभी डेटा हटाने के लिए इस कोड को आज़माएं ..

String selectQuery = "DELETE FROM table_name "; 
Cursor cursor = data1.getReadableDatabase().rawQuery(selectQuery, null); 
+0

FWIW का उपयोग करना होगा, 'rawQuery()' अकेले काम नहीं करता है क्योंकि यह निष्पादित नहीं होता है एसक्यूएल मुझे लगता है कि एक तालिका को साफ़ करने के लिए – laalto

134
db.delete(TABLE_NAME, null, null); 

या, यदि आप SQLiteDatabase delete विधि के प्रलेखन से नष्ट कर दिया पंक्तियों की गिनती वापस जाने के लिए समारोह,

db.delete(TABLE_NAME, "1", null); 

हैं:

सभी पंक्तियों को हटाने के लिए और जहांक्लोज़ के रूप में एक गणना पास "1" प्राप्त करें।

17

उपयोग करने के लिए "अमल" समारोह के निम्नलिखित कोड मुझे ::: के लिए काम किया कोई ज़रूरत नहीं है

db.delete(TABLE_NAME,null,null); 
    db.close(); 
+2

बेहतर तरीका। उम्मीद है कि यह SQLite – n00b

5
SQLiteDatabase db = this.getWritableDatabase(); 
     db.execSQL("DELETE FROM tablename"); //delete all rows in a table 
db.close(); 

मेरे लिए यह काम :)

3

उपयोग Sqlit साथ समारोह को हटाना पिछले दो शून्य पैरामीटर।

db.delete(TABLE_NAME,null,null) 
1
getContentResolver().delete(DB.TableName.CONTENT_URI, null, null); 
+1

द्वारा क्वेरी को पार्स करने की आवश्यकता को हटा देगा कृपया कुछ स्पष्टीकरण जोड़ें –

3

मैं इस वर्ग का उपयोग database.I को संभालने के लिए आशा है कि यह भविष्य में किसी एक में मदद मिलेगी।

हैप्पी कोडिंग।

public class Database { 

private static class DBHelper extends SQLiteOpenHelper { 

    /** 
    * Database name 
    */ 
    private static final String DB_NAME = "db_name"; 

    /** 
    * Table Names 
    */ 
    public static final String TABLE_CART = "DB_CART"; 


    /** 
    * Cart Table Columns 
    */ 
    public static final String CART_ID_PK = "_id";// Primary key 

    public static final String CART_DISH_NAME = "dish_name"; 
    public static final String CART_DISH_ID = "menu_item_id"; 
    public static final String CART_DISH_QTY = "dish_qty"; 
    public static final String CART_DISH_PRICE = "dish_price"; 

    /** 
    * String to create reservation tabs table 
    */ 
    private final String CREATE_TABLE_CART = "CREATE TABLE IF NOT EXISTS " 
      + TABLE_CART + " (" 
      + CART_ID_PK + " INTEGER PRIMARY KEY, " 
      + CART_DISH_NAME + " TEXT , " 
      + CART_DISH_ID + " TEXT , " 
      + CART_DISH_QTY + " TEXT , " 
      + CART_DISH_PRICE + " TEXT);"; 


    public DBHelper(Context context) { 
     super(context, DB_NAME, null, 2); 

    } 

    @Override 
    public void onCreate(SQLiteDatabase db) { 
     db.execSQL(CREATE_TABLE_CART); 


    } 

    @Override 
    public void onUpgrade(SQLiteDatabase db, int arg1, int arg2) { 
     db.execSQL("DROP TABLE IF EXISTS " + CREATE_TABLE_CART); 
     onCreate(db); 
    } 

} 


    /** 
     * CART handler 
     */ 
     public static class Cart { 


    /** 
    * Check if Cart is available or not 
    * 
    * @param context 
    * @return 
    */ 
    public static boolean isCartAvailable(Context context) { 

     DBHelper dbHelper = new DBHelper(context); 
     SQLiteDatabase db = dbHelper.getReadableDatabase(); 
     boolean exists = false; 

     try { 
      String query = "SELECT * FROM " + DBHelper.TABLE_CART; 
      Cursor cursor = db.rawQuery(query, null); 
      exists = (cursor.getCount() > 0); 
      cursor.close(); 
      db.close(); 
     } catch (SQLiteException e) { 
      db.close(); 
     } 

     return exists; 
    } 


    /** 
    * Insert values in cart table 
    * 
    * @param context 
    * @param dishName 
    * @param dishPrice 
    * @param dishQty 
    * @return 
    */ 
    public static boolean insertItem(Context context, String itemId, String dishName, String dishPrice, String dishQty) { 

     DBHelper dbHelper = new DBHelper(context); 
     SQLiteDatabase db = dbHelper.getWritableDatabase(); 
     ContentValues values = new ContentValues(); 
     values.put(DBHelper.CART_DISH_ID, "" + itemId); 
     values.put(DBHelper.CART_DISH_NAME, "" + dishName); 
     values.put(DBHelper.CART_DISH_PRICE, "" + dishPrice); 
     values.put(DBHelper.CART_DISH_QTY, "" + dishQty); 

     try { 
      db.insert(DBHelper.TABLE_CART, null, values); 
      db.close(); 
      return true; 
     } catch (SQLiteException e) { 
      db.close(); 
      return false; 
     } 
    } 

    /** 
    * Check for specific record by name 
    * 
    * @param context 
    * @param dishName 
    * @return 
    */ 
    public static boolean isItemAvailable(Context context, String dishName) { 

     DBHelper dbHelper = new DBHelper(context); 
     SQLiteDatabase db = dbHelper.getReadableDatabase(); 
     boolean exists = false; 

     String query = "SELECT * FROM " + DBHelper.TABLE_CART + " WHERE " 
       + DBHelper.CART_DISH_NAME + " = '" + String.valueOf(dishName) + "'"; 


     try { 
      Cursor cursor = db.rawQuery(query, null); 

      exists = (cursor.getCount() > 0); 
      cursor.close(); 

     } catch (SQLiteException e) { 

      e.printStackTrace(); 
      db.close(); 

     } 

     return exists; 
    } 

    /** 
    * Update cart item by item name 
    * 
    * @param context 
    * @param dishName 
    * @param dishPrice 
    * @param dishQty 
    * @return 
    */ 
    public static boolean updateItem(Context context, String itemId, String dishName, String dishPrice, String dishQty) { 

     DBHelper dbHelper = new DBHelper(context); 
     SQLiteDatabase db = dbHelper.getWritableDatabase(); 
     ContentValues values = new ContentValues(); 
     values.put(DBHelper.CART_DISH_ID, itemId); 
     values.put(DBHelper.CART_DISH_NAME, dishName); 
     values.put(DBHelper.CART_DISH_PRICE, dishPrice); 
     values.put(DBHelper.CART_DISH_QTY, dishQty); 

     try { 

      String[] args = new String[]{dishName}; 
      db.update(DBHelper.TABLE_CART, values, DBHelper.CART_DISH_NAME + "=?", args); 

      db.close(); 


      return true; 
     } catch (SQLiteException e) { 
      db.close(); 

      return false; 
     } 
    } 

    /** 
    * Get cart list 
    * 
    * @param context 
    * @return 
    */ 
    public static ArrayList<CartModel> getCartList(Context context) { 

     DBHelper dbHelper = new DBHelper(context); 
     SQLiteDatabase db = dbHelper.getReadableDatabase(); 

     ArrayList<CartModel> cartList = new ArrayList<>(); 

     try { 
      String query = "SELECT * FROM " + DBHelper.TABLE_CART + ";"; 

      Cursor cursor = db.rawQuery(query, null); 


      for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { 

       cartList.add(new CartModel(
         cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_ID)), 
         cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_NAME)), 
         cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_QTY)), 
         Integer.parseInt(cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_PRICE))) 
       )); 
      } 

      db.close(); 

     } catch (SQLiteException e) { 
      db.close(); 
     } 
     return cartList; 
    } 

    /** 
    * Get total amount of cart items 
    * 
    * @param context 
    * @return 
    */ 
    public static String getTotalAmount(Context context) { 

     DBHelper dbHelper = new DBHelper(context); 
     SQLiteDatabase db = dbHelper.getReadableDatabase(); 

     double totalAmount = 0.0; 

     try { 
      String query = "SELECT * FROM " + DBHelper.TABLE_CART + ";"; 

      Cursor cursor = db.rawQuery(query, null); 


      for (cursor.moveToFirst(); !cursor.isAfterLast(); cursor.moveToNext()) { 

       totalAmount = totalAmount + Double.parseDouble(cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_PRICE))) * 
         Double.parseDouble(cursor.getString(cursor.getColumnIndex(DBHelper.CART_DISH_QTY))); 
      } 

      db.close(); 


     } catch (SQLiteException e) { 
      db.close(); 
     } 


     if (totalAmount == 0.0) 
      return ""; 
     else 
      return "" + totalAmount; 
    } 


    /** 
    * Get item quantity 
    * 
    * @param context 
    * @param dishName 
    * @return 
    */ 
    public static String getItemQty(Context context, String dishName) { 

     DBHelper dbHelper = new DBHelper(context); 
     SQLiteDatabase db = dbHelper.getReadableDatabase(); 

     Cursor cursor = null; 
     String query = "SELECT * FROM " + DBHelper.TABLE_CART + " WHERE " + DBHelper.CART_DISH_NAME + " = '" + dishName + "';"; 
     String quantity = "0"; 

     try { 
      cursor = db.rawQuery(query, null); 

      if (cursor.getCount() > 0) { 

       cursor.moveToFirst(); 
       quantity = cursor.getString(cursor 
         .getColumnIndex(DBHelper.CART_DISH_QTY)); 

       return quantity; 
      } 


     } catch (SQLiteException e) { 
      e.printStackTrace(); 
     } 

     return quantity; 
    } 


    /** 
    * Delete cart item by name 
    * 
    * @param context 
    * @param dishName 
    */ 
    public static void deleteCartItem(Context context, String dishName) { 
     DBHelper dbHelper = new DBHelper(context); 
     SQLiteDatabase db = dbHelper.getReadableDatabase(); 

     try { 

      String[] args = new String[]{dishName}; 
      db.delete(DBHelper.TABLE_CART, DBHelper.CART_DISH_NAME + "=?", args); 

      db.close(); 
     } catch (SQLiteException e) { 
      db.close(); 
      e.printStackTrace(); 
     } 

    } 


}//End of cart class 

/** 
* Delete database table 
* 
* @param context 
*/ 
public static void deleteCart(Context context) { 
    DBHelper dbHelper = new DBHelper(context); 
    SQLiteDatabase db = dbHelper.getReadableDatabase(); 

    try { 

     db.execSQL("DELETE FROM " + DBHelper.TABLE_CART); 

    } catch (SQLiteException e) { 
     e.printStackTrace(); 
    } 

} 

}

उपयोग:

if(Database.Cart.isCartAvailable(context)){ 

     Database.deleteCart(context); 

    } 
1

बस लिखें

SQLiteDatabase db = this.getWritableDatabase(); 
db.execSQL("delete from "+TableName); 
0

उपयोगी हो सकता है।

public boolean deleteAllFood() { 
      SQLiteDatabase db = dbHelper.getReadableDatabase(); 
      int affectedRows = db.delete(DBHelper.TABLE_NAME_FOOD, null, null); 
      return affectedRows > 0; 
     } 



public class DBProgram { 
    private static DBProgram INSTANCE; 
    private Context context; 
    private DBHelper dbHelper; 

    private DBProgram(Context context) { 
     // burda bu methodu kullanan activity ile eileştiriyoruz 
     this.dbHelper = new DBHelper(context); 
    } 

    public static synchronized DBProgram getInstance(Context context) { 
     if (INSTANCE == null) { 
      INSTANCE = new DBProgram(context); 
     } 
     return INSTANCE; 
    } 

    //********************************************** 
    public boolean updateById(ProgramModel program) { 
     SQLiteDatabase database = dbHelper.getWritableDatabase(); 
     ContentValues contentValues = new ContentValues(); 
     contentValues.put(DBHelper.COLUM_NAME_P, program.getProgName()); 
     contentValues.put(DBHelper.COLUM_DAY_P, program.getDay()); 
     contentValues.put(DBHelper.COLUMN_WEIGHT_P, program.getWeight()); 
     contentValues.put(DBHelper.COLUMN_SET_P, program.getSet()); 
     contentValues.put(DBHelper.COLUMN_REPETITION_P, program.getRepetition()); 
     int affectedRows = database.update(DBHelper.TABLE_NAME_PROGRAM, contentValues, "PROG_ID_P = ?", new String[]{String.valueOf(program.getId())}); 
     return affectedRows > 0; 
    } 
    //********************************************** 


    //********************************************** 
    // TODO 
    public boolean deleteProgramById(int id) { 
     SQLiteDatabase database = dbHelper.getReadableDatabase(); 
     int affectedRows = database.delete(DBHelper.TABLE_NAME_PROGRAM, DBHelper.COLUMN_ID_P + "= ?", new String[]{String.valueOf(id)}); 
     // return bize etkilenen sıra sayısınıını temsil eder 
     return affectedRows > 0; 
    } 
    //********************************************** 


    //*************************************************** 
    public boolean deleteProgramByName(String progName) { 
     SQLiteDatabase database = dbHelper.getReadableDatabase(); 
     final String whereClause = DBHelper.COLUM_NAME_P + "=?"; 
     final String whereArgs[] = {progName}; 
     int affectedRows = database.delete(DBHelper.TABLE_NAME_PROGRAM, whereClause, whereArgs); 
     return affectedRows > 0; 
    } 
    //*************************************************** 


    //************************************** get Meal 
    // TODO WEB Get All Meals 
    public List<ProgramModel> getAllProgram(String name) { 
     List<ProgramModel> foodList = new ArrayList<>(); 
     ProgramModel food; 
     SQLiteDatabase database = dbHelper.getReadableDatabase(); 
     final String kolonlar[] = {DBHelper.COLUMN_ID_P, 
       DBHelper.COLUM_NAME_P, 
       DBHelper.COLUM_DAY_P, 
       DBHelper.COLUMN_WEIGHT_P, 
       DBHelper.COLUMN_SET_P, 
       DBHelper.COLUMN_REPETITION_P}; 

     final String whereClause = DBHelper.COLUM_DAY_P + "=?"; 
     final String whereArgs[] = {name}; 
     Cursor cursor = database.query(DBHelper.TABLE_NAME_PROGRAM, kolonlar, whereClause, whereArgs, null, null, null); 
     while (cursor.moveToNext()) { 

      food = new ProgramModel(); 
      food.setId(cursor.getInt(cursor.getColumnIndex(DBHelper.COLUMN_ID_P))); 
      food.setProgName(cursor.getString(cursor.getColumnIndex(DBHelper.COLUM_NAME_P))); 
      food.setDay(cursor.getString(cursor.getColumnIndex(DBHelper.COLUM_DAY_P))); 
      food.setWeight(cursor.getInt(cursor.getColumnIndex(DBHelper.COLUMN_WEIGHT_P))); 
      food.setSet(cursor.getInt(cursor.getColumnIndex(DBHelper.COLUMN_SET_P))); 
      food.setRepetition(cursor.getInt(cursor.getColumnIndex(DBHelper.COLUMN_REPETITION_P))); 
      foodList.add(food); 
     } 
     database.close(); 
     cursor.close(); 
     return foodList; 
    } 
    //************************************** 


    //**************************************insert FOOD 
    //TODO LOCAL insert Foods 
    public boolean insertProgram(ProgramModel favorite) { 
     boolean result = false; 
     ContentValues contentValues = new ContentValues(); 
     contentValues.put(DBHelper.COLUM_NAME_P, favorite.getProgName()); 
     contentValues.put(DBHelper.COLUM_DAY_P, favorite.getDay()); 
     contentValues.put(DBHelper.COLUMN_WEIGHT_P, favorite.getWeight()); 
     contentValues.put(DBHelper.COLUMN_SET_P, favorite.getSet()); 
     contentValues.put(DBHelper.COLUMN_REPETITION_P, favorite.getRepetition()); 
     SQLiteDatabase database = dbHelper.getWritableDatabase(); 
     long id = database.insert(DBHelper.TABLE_NAME_PROGRAM, null, contentValues); 
     if (id != 1) { 
      result = true; 
     } 
     database.close(); 

     return result; 
    } 
    //*************************************************** 

    // ******************************* SQLITE HELPER CLASS ****************** 
    private class DBHelper extends SQLiteOpenHelper { 
     private final Context context; 
     private static final String DATABASE_NAME = "PROGRAM_INFO"; 
     private static final String TABLE_NAME_PROGRAM = "PROGRAM"; 
     private static final int DATABASE_VERSION = 2; 

     // FOOD 
     private static final String COLUMN_ID_P = "PROG_ID_P"; 
     private static final String COLUM_NAME_P = "PROG_NAME_P"; 
     private static final String COLUM_DAY_P = "PROG_DAY_P"; 
     private static final String COLUMN_WEIGHT_P = "PROG_WEIGHT_P"; 
     private static final String COLUMN_SET_P = "PROG_SET_P"; 
     private static final String COLUMN_REPETITION_P = "PROG_REPETITION_P"; 

     private final String CREATE_TABLE_PROGRAM = "CREATE TABLE " + TABLE_NAME_PROGRAM + 
       " (" + COLUMN_ID_P + " INTEGER PRIMARY KEY AUTOINCREMENT, " 
       + COLUM_NAME_P + " TEXT, " 
       + COLUM_DAY_P + " TEXT, " 
       + COLUMN_WEIGHT_P + " INTEGER, " 
       + COLUMN_SET_P + " INTEGER, " 
       + COLUMN_REPETITION_P + " INTEGER)"; 

     private static final String DROP_TABLE_PROGRAM = "DROP TABLE IF EXIST " + TABLE_NAME_PROGRAM; 

     public DBHelper(Context context) { 
      super(context, DATABASE_NAME, null, DATABASE_VERSION); 
      this.context = context; 
     } 

     @Override 
     public void onCreate(SQLiteDatabase db) { 
      db.execSQL(CREATE_TABLE_PROGRAM); 

      Util.showMessage(context, "Database Created"); 
     } 

     @Override 
     public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 
      db.execSQL(DROP_TABLE_PROGRAM); 
      Util.showMessage(context, "Database Upgrated"); 
      onCreate(db); 
     } 

     @Override 
     public void onDowngrade(SQLiteDatabase db, int oldVersion, int newVersion) { 
      super.onDowngrade(db, oldVersion, newVersion); 
     } 
    } 


} 
0

इस metod दोष लगाना डेटाबेस

public void deleteAll() 
{ 
    SQLiteDatabase db = this.getWritableDatabase(); 
    db.execSQL("delete from "+ TABLE_NAME); 
    db.close(); 
} 
संबंधित मुद्दे