Wie lösche ich alle Datensätze aus der Tabelle in SQLite mit Android?

Meine App verfügt über zwei Schaltflächen. Die erste Schaltfläche dient zum Löschen von Datensätzen bei Benutzereingaben und die zweite Schaltfläche zum Löschen aller Datensätze. Wenn ich jedoch Daten löschen möchte, wird die Meldung
"Ihre Anwendung wurde gewaltsam gestoppt" angezeigt.

Bitte überprüfen Sie meinen Code und geben Sie mir einen Vorschlag.

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

und

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

Es wird jedoch der folgende Log cat-Fehler angezeigt.

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)

Sie haben ein Leerzeichen verpasst: db.execSQL("delete * from " + TABLE_NAME);

Es muss auch nicht einmal eingeschlossen werden *. Die richtige Abfrage lautet:

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

db.delete(TABLE_NAME, null, null);

oder, wenn die Funktion die Anzahl der gelöschten Zeilen zurückgeben soll ,

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

Aus der Dokumentation von SQLiteDatabase Löschmethode:

Um alle Zeilen zu entfernen und eine Zählung zu erhalten, übergeben Sie "1" als whereClause.

So löschen Sie alle Zeilen in der Tabelle:

db.delete(TABLE_NAME, null, null);

SQLite unterstützt den TRUNCATEBefehl nicht. Sie sollten das verwenden, was Sie in der vorherigen Zeile versucht haben:

DELETE FROM `TABLE_NAME`;

PS Sie können Ihr Programm optimieren, indem Sie für alle Ihre Abfragen zur angegebenen Datenbank dieselbe Instanz der Datenbankverbindung verwenden, anstatt für jede Abfrage eine neue zu erstellen.

Die Funktion "Ausführen" muss nicht verwendet werden. Der folgende Code hat bei mir funktioniert :::

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

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

diese Arbeit für mich :)

Versuchen Sie diesen Code, um alle Daten aus einer Tabelle zu löschen.

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

Verwenden Sie die Sqlit-Löschfunktion mit den letzten beiden Nullparametern.

db.delete(TABLE_NAME,null,null)

Einfach schreiben

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

oder

db.delete(tablename,null,null);

Ich benutze diese Klasse, um mit Datenbanken umzugehen. Ich hoffe, sie wird in Zukunft jemandem helfen.

Viel Spaß beim Codieren.

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

}

}}

Verwendung:

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

       Database.deleteCart(context);

   }

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

Das funktioniert bei mir. Der Unterschied liegt hier bei execSQL und rawQuery. Die rawQuery wird am häufigsten in Suchfällen verwendet und execSQL wird hauptsächlich in Anwendungsoperationen verwendet.

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

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

Kann nützlich sein.

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


}

Diese Methode löscht alle Daten aus der Datenbank

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

Ich habe eine Funktion, die für mich in Unity funktioniert (in Verbindung mit der Datenbank SQLite).

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

Hier ist eine einfache Möglichkeit zum Löschen:

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

Hier whereClauseist optional, wenn Sie null übergeben, werden alle Zeilen in der Tabelle gelöscht. Die Löschfunktion gibt die Anzahl der betroffenen Zeilen zurück, wenn sie whereClauseübergeben wird. Andernfalls wird 0 zurückgegeben.

Wichtiger Hinweis: Wenn Sie alle Zeilen entfernen möchten und auch die Anzahl der gelöschten Zeilen benötigen, übergeben Sie 1 als whereClause.

Sie können zwei verschiedene Methoden verwenden, um oder jede Abfrage in SQLite Android zu löschen

erste Methode ist

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

zweite Methode

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

Verwenden Sie eine beliebige Methode für Ihren Anwendungsfall

Verwenden von SQLite_NET_PCL v1.6.292 in VStudio - viele der Dokumente und Kommentare scheinen veraltet zu sein (glaube ich).

Alle Datensätze löschen

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