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列。有幾種方法可以解決這個問題。首先，你可以改寫東西只使用一列，並將負值視爲費用和正值作爲收入。

或者，您可以執行兩個查詢。第一個選擇你的收入，第二個選擇你的開支。然後你會從收入中扣除費用來獲得餘額。