如何从Android中删除sqlite中表的所有记录？

Question

我的应用有两个按钮，第一个按钮用于删除用户输入的记录，第二个按钮用于删除所有记录。但是，当我想删除数据时，它会显示消息
“你的申请已被强行停止”。

请检查我的代码并给我一些建议。

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

但它显示以下Log cat错误。

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)

Answer 1

你遗漏了一个空格：db.execSQL("delete * from " + TABLE_NAME);

此外，甚至不需要包含*，正确的查询是：

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

Answer 2

db.delete(TABLE_NAME, null, null);

或者，如果您希望函数返回已删除行的计数，

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

来自SQLiteDatabase delete方法的文档：

  

删除所有行并获取计数传递“1”作为whereClause。

Answer 3

要删除表格中的所有行，您可以使用：

db.delete(TABLE_NAME, null, null);

Answer 4

SQLite不支持TRUNCATE命令。您应该使用您在上一行中尝试过的内容：

DELETE FROM `TABLE_NAME`;

P.S。您可以通过对给定数据库的所有查询使用相同的数据库连接实例来优化程序，而不是为每个查询创建新的查询。

Answer 5

没有必要使用“执行”功能。以下代码适用于我:::

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

Answer 6

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

这项工作对我来说：）

Answer 7

尝试使用此代码删除表中的所有数据。

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

Answer 8

我使用这个类来处理数据库。我希望将来可以帮助它。

快乐的编码。

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

   }

Answer 9

刚写

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

或

db.delete(tablename,null,null);

Answer 10

使用带有最后两个空参数的Sqlit删除函数。

db.delete(TABLE_NAME,null,null)

Answer 11

//Delete all records of table
db.execSQL("DELETE FROM " + TABLE_NAME);

//Reset the auto_increment primary key if you needed
db.execSQL("UPDATE SQLITE_SEQUENCE SET SEQ=0 WHERE NAME=" + TABLE_NAME);

//For go back free space by shrinking sqlite file
db.execSQL("VACUUM");

Answer 12

    getContentResolver().delete(DB.TableName.CONTENT_URI, null, null);

Answer 13

这对我有用。区别在于execSQL和rawQuery。 rawQuery最常用于搜索大小写，而execSQL最常用于apply操作。

   // truncate the table
    ArrayList<HashMap<String, String>> getDatabaseName1(String sr) {
        SQLiteDatabase sqLiteDatabase=this.getWritableDatabase();
        sqLiteDatabase.execSQL("delete from Hotel");
        sqLiteDatabase.close();
        return null;
    }

Answer 14

可以有用。

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


}

Answer 15

这个metod减去了数据库中的所有数据

 public void deleteAll()
{
    SQLiteDatabase db = this.getWritableDatabase();
    db.execSQL("delete from "+ TABLE_NAME);
    db.close();
}

Answer 16

我有一个对Unity有用的功能（与数据库SQLite结合使用）。

代码C＃：

public void DeleteAllObj() {
    connectionString = "URI=file:"+Application.dataPath+"/TerrainTools/db/object.sqlite";
    using (IDbConnection dbConnection = new SqliteConnection(connectionString)) {
        dbConnection.Open();
        using(IDbCommand dbCmd =dbConnection.CreateCommand()) {
            dbCmd.CommandText = "DELETE FROM 'ObjectMap'";
            using (IDataReader reader = dbCmd.ExecuteReader()) {
                dbConnection.Close();
                reader.Close();
                return;
            }
        }
    }
}

Answer 17

这是删除的简单方法：

public void deleteItem(Item item) {
SQLiteDatabase db = getWritableDatabase();
String whereClause = "id=?";
String whereArgs[] = {item.id.toString()};
db.delete("Items", whereClause, whereArgs);
}

此处whereClause是可选的，传递null将删除表中的所有行。如果传递了whereClause，则delete函数将返回受影响的行数，否则将返回0。

  

重要说明：如果要删除所有行并要求对已删除的行进行计数，则还要将1传递为whereClause。

Answer 18

您可以使用两种不同的方法删除或在sqlite android中进行任何查询

第一种方法是

public void deleteItem(Student item) {
 SQLiteDatabase db = getWritableDatabase();
 String whereClause = "id=?";
 String whereArgs[] = {item.id.toString()};
 db.delete("Items", whereClause, whereArgs);
}

第二种方法

public void deleteAll()
{
  SQLiteDatabase db = this.getWritableDatabase();
  db.execSQL("delete from "+ TABLE_NAME);
  db.close();
}

针对您的用例使用任何方法

Answer 19

在VStudio中使用SQLite_NET_PCL v1.6.292-许多文档和注释似乎已经过时了（我认为）。

要删除所有记录

public Task<int> DeleteAllEntry()
    {
        return DataBasePath.DeleteAllAsync<tableName>();
    }