【问题标题】:How to delete all records from table in sqlite with Android?如何使用Android从sqlite中的表中删除所有记录?
【发布时间】:2012-03-24 21:04:47
【问题描述】:

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

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

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)

【问题讨论】:

  • 好像 getWritableDatabase() 返回 null,你应该调查这个问题。
  • 你在“from”后面缺少一个空格,这样表名就会与“from”连接起来,它会给你一个错误
  • 也可以尝试使用try{} catch(Exception e){Console.WriteLine(e);}来避免crash程序并分析错误。

标签: android sqlite


【解决方案1】:

你错过了一个空格:db.execSQL("delete * from " + TABLE_NAME);

另外,甚至不需要包含*,正确的查询是:

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

【讨论】:

【解决方案2】:
db.delete(TABLE_NAME, null, null);

或者,如果您希望函数返回已删除行数

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

来自 SQLiteDatabase delete 方法的文档:

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

【讨论】:

【解决方案3】:

要删除表中的所有行,您可以使用:

db.delete(TABLE_NAME, null, null);

【讨论】:

    【解决方案4】:

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

    DELETE FROM `TABLE_NAME`;
    

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

    【讨论】:

      【解决方案5】:

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

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

      【讨论】:

        【解决方案6】:
        SQLiteDatabase db = this.getWritableDatabase();
                db.execSQL("DELETE FROM tablename"); //delete all rows in a table
        db.close();
        

        这对我有用:)

        【讨论】:

          【解决方案7】:

          尝试使用此代码从表中删除所有数据..

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

          【讨论】:

          • FWIW,rawQuery() 单独不起作用,因为它不执行 SQL。
          • rawQuerry() 为我工作。但是这段代码有一个错误:getReadableDatabase()。您只能对只读数据库进行查询。如果要执行删除,正确的方法是使用 getWritableDatabase()。
          【解决方案8】:

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

          db.delete(TABLE_NAME,null,null)
          

          【讨论】:

            【解决方案9】:

            随便写

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

            db.delete(tablename,null,null);
            

            【讨论】:

              【解决方案10】:

              我使用这个类来处理数据库。我希望它对将来的一些人有所帮助。

              愉快的编码。

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

              【讨论】:

                【解决方案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");
                

                【讨论】:

                  【解决方案12】:

                  这对我有用。不同之处在于 execSQL 和 rawQuery。 rawQuery 最常用于搜索 case,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;
                      }
                  

                  【讨论】:

                    【解决方案13】:

                    您可以使用两种不同的方法来删除或在 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();
                    }
                    

                    为您的用例使用任何方法

                    【讨论】:

                      【解决方案14】:
                          getContentResolver().delete(DB.TableName.CONTENT_URI, null, null);
                      

                      【讨论】:

                      • 请添加一些解释
                      【解决方案15】:

                      可能有用。

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

                      【讨论】:

                        【解决方案16】:

                        这个方法从数据库中删除所有数据

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

                        【讨论】:

                          【解决方案17】:

                          我有一个适用于 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;
                                      }
                                  }
                              }
                          }
                          

                          【讨论】:

                            【解决方案18】:

                            以下是简单的删除方法:

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

                            这里whereClause是可选的,传递null将删除表中的所有行。如果whereClause传递,删除函数将返回受影响的行数,否则将返回0。

                            重要提示:如果您想删除所有行并要求删除行的计数,则将 1 作为whereClause 传递。

                            【讨论】:

                              【解决方案19】:

                              在 VStudio 中使用 SQLite_NET_PCL v1.6.292 - 那里的许多文档和 cmets 似乎都过时了(我认为)。

                              删除所有记录

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

                              【讨论】:

                                猜你喜欢
                                • 2012-01-29
                                • 1970-01-01
                                • 1970-01-01
                                • 2020-04-06
                                • 2015-09-11
                                • 2013-07-22
                                • 1970-01-01
                                • 1970-01-01
                                • 1970-01-01
                                相关资源
                                最近更新 更多