Android数据库使用货币/余额

Question

我正在开发一个管理用户开支和收入的应用程序，我已经达到了一个点，我很困难，觉得我需要一些帮助，我想要做的是保存有记录的总用户余额，并且能够根据用户的操作对其进行计算，如果他的余额是100美元并且他增加了50美元的开支，则所存储的余额将被更新为总共50美元等。

我不知道什么是正确的方法来做到这一点或如何编写数据库函数来做“平衡”变量的数学，这是我的数据库类迄今，我真的很感激任何示例或提示。

现在所有我有是基本的“添加，更新，删除，获取”功能...

public class TransactionsDatabase { 

private static final String DATABASE_NAME = "transactions_db"; 
private static final String DATABASE_TABLE = "transactions_table"; 
private static final int DATABASE_VERSION = 1; 

private static final String TRANSACTION_ID = "_id"; 
private static final String TRANSACTION_AMOUNT = "amount"; 
private static final String TRANSACTION_DESCRIPTION = "description"; 
private static final String TRANSACTION_DATE = "date"; 
private static final String TRANSACTION_CATEGORY = "category"; 
private static final String TRANSACTION_CURRENCY = "currency_type"; 
private static final String TRANSACTION_EXPENSE_OR_INCOME = "expenseOrIncome"; 
private static int BALANCE; // this is how I have tried to use the balance so far... 

private static final String CREATE_DATABASE = "create table transactions_table (_id integer primary key autoincrement, " 
+ "amount integer not null, date text not null, category text not null, currency_type text not null, description text not null, expenseOrIncome text not null);"; 

private static final String TAG = "TransactionsDatabase"; 
private DatabaseHelper DbHelper; 
private SQLiteDatabase SqlDatabase; 
private final Context ctx; 

private static class DatabaseHelper extends SQLiteOpenHelper { 

    public DatabaseHelper(Context context) { 

     super(context, DATABASE_NAME, null, DATABASE_VERSION); 
    } 

    @Override 
    public void onCreate(SQLiteDatabase db) { 

     db.execSQL(CREATE_DATABASE); 
    } 

    @Override 
    public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) { 

     Log.w(TAG, "Upgrading database from version " + oldVersion + " to " 
       + newVersion + ", which will erase old data"); 
     db.execSQL("DROP TABLE IF EXISTS expenses_table"); 
     onCreate(db); 
    }  
} 

TransactionsDatabase (Context c) { 
    this.ctx = c; 
} 

public TransactionsDatabase open() throws SQLException { 

    DbHelper = new DatabaseHelper(ctx); 
    SqlDatabase = DbHelper.getWritableDatabase(); 
    return this; 

} 

public void close() { 

    DbHelper.close(); 
} 

public long createExpenseOrIncome (int amount, String description, String date, String category, String currency_type, String expenseOrIncome) { 

    ContentValues values = new ContentValues(); 
    values.put(TRANSACTION_AMOUNT, amount); 
    values.put(TRANSACTION_DESCRIPTION, description); 
    values.put(TRANSACTION_DATE, date); 
    values.put(TRANSACTION_CATEGORY, category); 
    values.put(TRANSACTION_CURRENCY, currency_type); 
    values.put(TRANSACTION_EXPENSE_OR_INCOME, expenseOrIncome); 

    // Returns the row ID of newly inserted row, or -1 if an error occurred. 
    return SqlDatabase.insert(DATABASE_TABLE, null, values); 
} 

public boolean deleteExpenseOrIncome(long rowId) { 

    // Returns true if deleted, false otherwise. 
    return SqlDatabase.delete(DATABASE_TABLE, TRANSACTION_ID + "=" + rowId, null) > 0; 

} 

public Cursor fetchAllExpensesAndIncomes() { 

    // Returns a cursor over the list of all expenses/incomes. 

    return SqlDatabase.query(DATABASE_TABLE, new String[] { TRANSACTION_ID, 
      TRANSACTION_AMOUNT, TRANSACTION_DESCRIPTION, TRANSACTION_DATE, TRANSACTION_CATEGORY, TRANSACTION_CURRENCY, TRANSACTION_EXPENSE_OR_INCOME }, null, null, null, null, 
      null); 
} 

public Cursor fetchSpecificExpenseOrIncome(long rowId) throws SQLException { 

     Cursor mCursor = SqlDatabase.query(true, DATABASE_TABLE, new String[] { 
       TRANSACTION_AMOUNT, TRANSACTION_DESCRIPTION, 
       TRANSACTION_DATE, TRANSACTION_CATEGORY, TRANSACTION_CURRENCY, TRANSACTION_EXPENSE_OR_INCOME }, 
       TRANSACTION_ID + "=" + rowId, null, null, null, null, null); 

     if (mCursor != null) { 
      mCursor.moveToFirst(); 
     } 
      return mCursor; 
    } 

public boolean updateExpenseOrIncome(long rowId, int amount, String description, String date, String category, String currency_type, String expenseOrIncome) { 

    // returns true if the expense/income was successfully updated, false otherwise. 

    ContentValues values = new ContentValues(); 
    values.put(TRANSACTION_AMOUNT, amount); 
    values.put(TRANSACTION_DESCRIPTION, description); 
    values.put(TRANSACTION_DATE, date); 
    values.put(TRANSACTION_CATEGORY, category); 
    values.put(TRANSACTION_CURRENCY, currency_type); 
    values.put(TRANSACTION_EXPENSE_OR_INCOME, expenseOrIncome); 

    return SqlDatabase.update(DATABASE_TABLE, values, TRANSACTION_ID + "=" + rowId, null) > 0; 

} 

public boolean deleteAllExpensesOrIncomes() { 

    // true if any number of rows were deleted, false otherwise. 

    return SqlDatabase.delete(DATABASE_TABLE, null, null) > 0; 
} 

public boolean deleteSpecificExpenseOrIncome(long rowId) { 

    // true if a row is deleted, false otherwise. 

    return SqlDatabase.delete(DATABASE_TABLE, TRANSACTION_ID + "=" + rowId, null) > 0; 
} 

}

Answer 1

由于这仅仅是一个单用户的Android应用程序，我会跳过缓存计算值的位（因为SQLite查找不是很费时）。但是，如果您认为需要额外的性能，则应该考虑让第二张表缓存在重新运行计算时更新的计算值。

那么现在，就到你的真正问题：

比方说，你想写一个基本功能，我们将根据您的交易总量平衡和一些基本的价值。它看起来有点像这样：

public int getBalance(int baseValue) { 
    String[] cols = new String[] { 
     "SUM(" + TRANSACTION_AMOUNT + ")" 
    }; 
    try { 
     Cursor data = SqlDatabase.query(DATABASE_TABLE, cols, null, null, null, null, null); 
     return data.getInt(data.getColumnIndexOrThrow(cols[0])) + baseValue; 
    } catch(IllegalArgumentException e) { 
     Log.e("MyApp", "Couldn't get balance", e); 
     return 0; 
    } 
} 

的SUM(..) SQL函数返回列的值的总和。

当然，这段代码不会马上工作，因为一方面，你有一个单独的expenseOrIncome列。有几种方法可以解决这个问题。首先，你可以改写东西只使用一列，并将负值视为费用和正值作为收入。

或者，您可以执行两个查询。第一个选择你的收入，第二个选择你的开支。然后你会从收入中扣除费用来获得余额。