ماژول SQLiteHelper

سلام. من توی آموزش های استاد (قسمت SQLite) یه کلاس نسبتاً متفاوتی از کلاس استاد نوشتم اما وقتی وارد پروژه ام کردم ایرادهای زیادی به وجود اومد.

مثلاً وقتی ابتدای یک اکتیویتی بهش می گفتی اطلاعات داخل جدول رو بریز توی یه آرایه از فلان جنس، عمل می کرد اما بعد از اون دیگه هربار صداش بزنی همون اطلاعات رو میده.

یا یه باگ دیگه اش هم اینه که وقتی می خواد دیلیت کنه با خطا مواجه می شه و درست حذفش نمی کنه.

من سورس رو براتون می ذارم اگه کسی می تونه لطفا کمک کنه.

import android.database.Cursor;
import android.database.sqlite.SQLiteConstraintException;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteException;
import android.text.TextUtils;
import android.util.Log;

import java.util.ArrayList;


public class DBHelper {
  public static class Column {
    public static final String TYPE_BOOLEAN = "BOOLEAN";
    public static final String TYPE_BYTE = "BYTE";
    public static final String TYPE_INTEGER = "INTEGER";
    public static final String TYPE_REAL = "REAL";
    public static final String TYPE_VARCHAR = "VARCHAR";
    public static final String TYPE_TEXT = "TEXT";
    public static final String TYPE_TIME = "TIME";
    public static final String TYPE_DATE = "DATE";
    public static final String TYPE_DATETIME = "DATETIME";

    public String name;
    public String type;
    public boolean isUnique;

    public Column(String name, String type, boolean isUnique) {
      this.name = name;
      this.type = type;
      this.isUnique = isUnique;
    }

    public Column(String name, String type) {
      this.name = name;
      this.type = type;
    }

    public Column() {
    }
  }

  public static class KeyValuePair {
    public String key;
    public Object value;

    public KeyValuePair(String key, Object value) {
      this.key = key;
      this.value = value;
    }

    public KeyValuePair() {
    }

    public static Object getValueFrom(String key, KeyValuePair[] keyValuePairs) {
      for (KeyValuePair keyValuePair : keyValuePairs) {
        if (key.equals(keyValuePair.key)) {
          return keyValuePair.value;
        }
      }

      return null;
    }

    public static String getKeyFrom(Object value, KeyValuePair[] keyValuePairs) {
      for (KeyValuePair keyValuePair : keyValuePairs) {
        if (value.equals(keyValuePair.value)) {
          return keyValuePair.key;
        }
      }

      return null;
    }

    public static String[] getKeysFrom(KeyValuePair[] keyValuePairs) {
      String[] keys = new String[keyValuePairs.length];
      for (int i = 0; i < keyValuePairs.length; i++) {
        keys[i] = keyValuePairs[i].key;
      }
      return keys;
    }

    public static Object[] getValuesFrom(KeyValuePair[] keyValuePairs) {
      Object[] values = new Object[keyValuePairs.length];
      for (int i = 0; i < keyValuePairs.length; i++) {
        values[i] = keyValuePairs[i].value;
      }
      return values;
    }
  }

  private SQLiteDatabase db;

  public DBHelper(SQLiteDatabase db) {
    this.db = db;
  }

  private void logWarning(Exception e) {
    Log.w("LOG", "Warning: " + e.getMessage());
  }

  private String joinValues(Object[] values) {
    ArrayList<String> valuesAsStr = new ArrayList<>();
    for (Object value : values) {
      valuesAsStr.add("'" + value.toString() + "'");
    }
    return TextUtils.join(", ", valuesAsStr);
  }

  public boolean createTable(String table, Column... columns) {
    try {
      String query =
        "CREATE TABLE '" + table + "' (" +
          "'" + table + "_id' INTEGER PRIMARY KEY AUTOINCREMENT  NOT NULL";
      for (Column colum : columns) {
        query += ", '" + colum.name + "' " + colum.type.toUpperCase() + (colum.isUnique ? " UNIQUE" : "");
      }
      query += ")";
      db.execSQL(query);
      return true;
    } catch (SQLiteException e) {
      logWarning(e);
      return false;
    }
  }

  public ArrayList<KeyValuePair[]> select(String sql) {
    try {
      ArrayList<KeyValuePair[]> rows = new ArrayList<>();
      Cursor cursor = db.rawQuery(sql, null);
      int columnCount = cursor.getColumnCount();
      while (cursor.moveToNext()) {
        KeyValuePair[] keyValuePairs = new KeyValuePair[columnCount];
        for (int i = 0; i < columnCount; i++) {
          int type = cursor.getType(i);
          keyValuePairs[i] = new KeyValuePair();
          keyValuePairs[i].key = cursor.getColumnName(i);
          switch (type) {
            case Cursor.FIELD_TYPE_INTEGER: {
              keyValuePairs[i].value = cursor.getInt(i);
              break;
            }
            case Cursor.FIELD_TYPE_FLOAT: {
              keyValuePairs[i].value = cursor.getFloat(i);
              break;
            }
            case Cursor.FIELD_TYPE_STRING: {
              keyValuePairs[i].value = cursor.getString(i);
              break;
            }
            case Cursor.FIELD_TYPE_BLOB: {
              keyValuePairs[i].value = cursor.getBlob(i);
              break;
            }
          }
        }
        rows.add(keyValuePairs);
      }
      cursor.close();
      return rows;
    } catch (SQLiteException e) {
      logWarning(e);
      return null;
    }
  }

  public ArrayList<Object> createObjectsFrom(String sql, Class structure, String[] dbColumnNames, String[] structureFieldNames) {
    if (dbColumnNames != null && structureFieldNames != null) {
      if (dbColumnNames.length != structureFieldNames.length) {
        return null;
      }
    }

    ArrayList<Object> outArray = new ArrayList<>();
    ArrayList<KeyValuePair[]> rows = select(sql);
    for (KeyValuePair[] keyValuePairs : rows) {
      Object instance = null;
      try {
        instance = structure.newInstance();
      } catch (InstantiationException e) {
        logWarning(e);
      } catch (IllegalAccessException e) {
        logWarning(e);
      }
      for (KeyValuePair keyValuePair : keyValuePairs) {
        try {
          String fieldName = keyValuePair.key;
          if (dbColumnNames != null && structureFieldNames != null) {
            if (StaticArrayHelper.contains(fieldName, dbColumnNames)) {
              fieldName = structureFieldNames[StaticArrayHelper.indexOf(fieldName, dbColumnNames)];
            }
          }
          if (keyValuePair.value.equals("true") || keyValuePair.value.equals("false")) {
            keyValuePair.value = Boolean.parseBoolean("" + keyValuePair.value);
          }
          structure.getField(fieldName).set(instance, keyValuePair.value);
        } catch (IllegalAccessException e) {
          logWarning(e);
        } catch (NoSuchFieldException e) {
          logWarning(e);
        }
      }

      outArray.add(instance);
    }

    return outArray;
  }

  public int insert(String table, KeyValuePair... keyValuePairs) {
    String columnsStr = joinValues(KeyValuePair.getKeysFrom(keyValuePairs));
    String valuesStr = joinValues(KeyValuePair.getValuesFrom(keyValuePairs));

    try {
      db.execSQL("INSERT INTO " + table + "(" + columnsStr + ") VALUES (" + valuesStr + ")");
      return getLastId();
    } catch (SQLiteConstraintException e) {
      logWarning(e);
      return -1;
    }
  }

  public int getLastId() {
    Cursor cursor = db.rawQuery("SELECT last_insert_rowid() AS lastId", null);
    cursor.moveToFirst();
    int lastId = cursor.getInt(cursor.getColumnIndex("lastId"));
    cursor.close();
    return lastId;
  }

  public void update(String table, String where, KeyValuePair... keyValuePairs) {
    try {
      String[] updates = new String[keyValuePairs.length];
      for (int i = 0; i < keyValuePairs.length; i++) {
        updates[i] = keyValuePairs[i].key + "=" + "'" + keyValuePairs[i].value.toString() + "'";
      }

      String query = "UPDATE " + table + " SET " + TextUtils.join(", ", updates);
      if (where != null) {
        query += " WHERE " + where;
      }
      db.execSQL(query);
    } catch (SQLiteException e) {
      logWarning(e);
    }
  }

  public void delete(String table, String where) {
    try {
      String query = "DELETE FROM " + table;
      if (where != null) {
        query += " WHERE " + where;
      }
      db.execSQL(query);
    } catch (SQLiteException e) {
      logWarning(e);
    }
  }

  public void truncate(String table) {
    delete(table, null);
  }
}