Ist es in Ordnung, einen Wert beizubehalten, der in einer Tabelle aktualisiert wird?

Wir entwickeln eine Plattform für Prepaid-Karten, die im Wesentlichen Daten zu Karten und deren Guthaben, Zahlungen usw. enthält.

Bisher hatten wir eine Karteneinheit, die eine Sammlung von Kontoeinheiten enthält, und jedes Konto verfügt über einen Betrag, der bei jeder Ein- / Auszahlung aktualisiert wird.

Es gibt jetzt eine Debatte im Team; Jemand hat uns gesagt, dass dies gegen die 12 Regeln von Codd verstößt und die Aktualisierung des Wertes bei jeder Zahlung problematisch ist.

Ist das wirklich ein Problem?

Wenn ja, wie können wir das beheben?

Ja, das ist nicht normalisiert, aber gelegentlich gewinnen nicht normalisierte Designs aus Leistungsgründen.

Aus Sicherheitsgründen würde ich es jedoch wahrscheinlich ein wenig anders angehen. (Haftungsausschluss: Ich habe zurzeit noch nie im Finanzsektor gearbeitet. Ich werfe das hier nur raus.)

Haben Sie eine Tabelle für die Guthaben auf den Karten gebucht. In diesem Fall wird für jedes Konto eine Zeile eingefügt, in der der Saldo zum Ende jedes Zeitraums (Tag, Woche, Monat oder was auch immer angemessen ist) angegeben ist. Indizieren Sie diese Tabelle nach Kontonummer und Datum.

Verwenden Sie eine andere Tabelle, um ausstehende Transaktionen zu speichern, die im laufenden Betrieb eingefügt werden. Führen Sie am Ende jedes Zeitraums eine Routine aus, die die nicht gebuchten Transaktionen zum letzten Schlusssaldo des Kontos hinzufügt, um den neuen Saldo zu berechnen. Markieren Sie die ausstehenden Transaktionen entweder als gebucht oder überprüfen Sie anhand der Daten, was noch aussteht.

Auf diese Weise haben Sie die Möglichkeit, bei Bedarf einen Kartensaldo zu berechnen, ohne den gesamten Kontoverlauf aufsummieren zu müssen, und indem Sie die Saldo-Neuberechnung in eine spezielle Buchungsroutine einfügen, können Sie sicherstellen, dass die Transaktionssicherheit dieser Neuberechnung auf beschränkt ist eine einzelne Stelle (und auch die Sicherheit in der Saldotabelle einschränken, sodass nur die Buchungsroutine darauf schreiben kann).

Bewahren Sie dann nur so viele historische Daten auf, wie aufgrund von Audits, Kundendienst und Leistungsanforderungen erforderlich sind.

Auf der anderen Seite gibt es ein Problem, auf das wir bei Buchhaltungssoftware häufig stoßen. Umschrieben:

Muss ich wirklich zehn Jahre Daten sammeln, um herauszufinden, wie viel Geld sich auf dem Girokonto befindet?

Die Antwort ist natürlich nein, das tust du nicht. Hier gibt es einige Ansätze. Einer speichert den berechneten Wert. Ich empfehle diesen Ansatz nicht, da Softwarefehler, die zu falschen Werten führen, sehr schwer aufzuspüren sind und ich diesen Ansatz vermeiden würde.

Ein besserer Weg, dies zu tun, ist das, was ich als Log-Snapshot-Aggregat-Ansatz bezeichne. In diesem Ansatz sind unsere Zahlungen und Verwendungen Beilagen und wir aktualisieren diese Werte niemals. In regelmäßigen Abständen aggregieren wir die Daten über einen bestimmten Zeitraum und fügen einen berechneten Schnappschussdatensatz ein, der die Daten zum Zeitpunkt der Gültigkeitsdauer des Schnappschusses darstellt (in der Regel einen Zeitraum, bevor dieser gültig war ).

Dies verstößt nicht gegen die Regeln von Codd, da die Snapshots im Laufe der Zeit möglicherweise weniger als perfekt von den eingegebenen Zahlungs- / Nutzungsdaten abhängen. Wenn wir über funktionierende Snapshots verfügen, können wir entscheiden, 10 Jahre alte Daten zu löschen, ohne unsere Fähigkeit zu beeinträchtigen, aktuelle Salden nach Bedarf zu berechnen.

Aus Leistungsgründen müssen wir in den meisten Fällen das aktuelle Guthaben speichern, da es sonst möglicherweise unerschwinglich langsam wird, es im laufenden Betrieb zu berechnen.

Wir speichern vorberechnete laufende Summen in unserem System. Um sicherzustellen, dass die Zahlen immer korrekt sind, verwenden wir Einschränkungen. Die folgende Lösung wurde aus meinem Blog kopiert. Es beschreibt ein Inventar, das im Wesentlichen das gleiche Problem ist:

Das Berechnen von laufenden Summen ist notorisch langsam, egal ob Sie sie mit einem Cursor oder mit einer Dreiecksverknüpfung ausführen. Es ist sehr verlockend zu denormalisieren, laufende Summen in einer Spalte zu speichern, besonders wenn Sie diese häufig auswählen. Beim Denormalisieren müssen Sie jedoch wie gewohnt die Integrität Ihrer denormalisierten Daten gewährleisten. Glücklicherweise können Sie die Integrität von laufenden Summen mit Einschränkungen garantieren. Solange alle Ihre Einschränkungen vertrauenswürdig sind, sind alle laufenden Summen korrekt. Auch auf diese Weise können Sie auf einfache Weise sicherstellen, dass der aktuelle Kontostand (laufende Summen) niemals negativ ist - die Durchsetzung durch andere Methoden kann auch sehr langsam sein. Das folgende Skript demonstriert die Technik.

CREATE TABLE Data.Inventory(InventoryID INT NOT NULL IDENTITY,
  ItemID INT NOT NULL,
  ChangeDate DATETIME NOT NULL,
  ChangeQty INT NOT NULL,
  TotalQty INT NOT NULL,
  PreviousChangeDate DATETIME NULL,
  PreviousTotalQty INT NULL,
  CONSTRAINT PK_Inventory PRIMARY KEY(ItemID, ChangeDate),
  CONSTRAINT UNQ_Inventory UNIQUE(ItemID, ChangeDate, TotalQty),
  CONSTRAINT UNQ_Inventory_Previous_Columns UNIQUE(ItemID, PreviousChangeDate, PreviousTotalQty),
  CONSTRAINT FK_Inventory_Self FOREIGN KEY(ItemID, PreviousChangeDate, PreviousTotalQty)
    REFERENCES Data.Inventory(ItemID, ChangeDate, TotalQty),
  CONSTRAINT CHK_Inventory_Valid_TotalQty CHECK(TotalQty >= 0 AND (TotalQty = COALESCE(PreviousTotalQty, 0) + ChangeQty)),
  CONSTRAINT CHK_Inventory_Valid_Dates_Sequence CHECK(PreviousChangeDate < ChangeDate),
  CONSTRAINT CHK_Inventory_Valid_Previous_Columns CHECK((PreviousChangeDate IS NULL AND PreviousTotalQty IS NULL)
            OR (PreviousChangeDate IS NOT NULL AND PreviousTotalQty IS NOT NULL))
);
GO
-- beginning of inventory for item 1
INSERT INTO Data.Inventory(ItemID,
  ChangeDate,
  ChangeQty,
  TotalQty,
  PreviousChangeDate,
  PreviousTotalQty)
VALUES(1, '20090101', 10, 10, NULL, NULL);
-- cannot begin the inventory for the second time for the same item 1
INSERT INTO Data.Inventory(ItemID,
  ChangeDate,
  ChangeQty,
  TotalQty,
  PreviousChangeDate,
  PreviousTotalQty)
VALUES(1, '20090102', 10, 10, NULL, NULL);

Msg 2627, Level 14, State 1, Line 10
Violation of UNIQUE KEY constraint 'UNQ_Inventory_Previous_Columns'. Cannot insert duplicate key in object 'Data.Inventory'.
The statement has been terminated.

-- add more
DECLARE @ChangeQty INT;
SET @ChangeQty = 5;
INSERT INTO Data.Inventory(ItemID,
  ChangeDate,
  ChangeQty,
  TotalQty,
  PreviousChangeDate,
  PreviousTotalQty)
SELECT TOP 1 ItemID, '20090103', @ChangeQty, TotalQty + @ChangeQty, ChangeDate, TotalQty
  FROM Data.Inventory
  WHERE ItemID = 1
  ORDER BY ChangeDate DESC;

SET @ChangeQty = 3;
INSERT INTO Data.Inventory(ItemID,
  ChangeDate,
  ChangeQty,
  TotalQty,
  PreviousChangeDate,
  PreviousTotalQty)
SELECT TOP 1 ItemID, '20090104', @ChangeQty, TotalQty + @ChangeQty, ChangeDate, TotalQty
  FROM Data.Inventory
  WHERE ItemID = 1
  ORDER BY ChangeDate DESC;

SET @ChangeQty = -4;
INSERT INTO Data.Inventory(ItemID,
  ChangeDate,
  ChangeQty,
  TotalQty,
  PreviousChangeDate,
  PreviousTotalQty)
SELECT TOP 1 ItemID, '20090105', @ChangeQty, TotalQty + @ChangeQty, ChangeDate, TotalQty
  FROM Data.Inventory
  WHERE ItemID = 1
  ORDER BY ChangeDate DESC;

-- try to violate chronological order

SET @ChangeQty = 5;
INSERT INTO Data.Inventory(ItemID,
  ChangeDate,
  ChangeQty,
  TotalQty,
  PreviousChangeDate,
  PreviousTotalQty)
SELECT TOP 1 ItemID, '20081231', @ChangeQty, TotalQty + @ChangeQty, ChangeDate, TotalQty
  FROM Data.Inventory
  WHERE ItemID = 1
  ORDER BY ChangeDate DESC;

Msg 547, Level 16, State 0, Line 4
The INSERT statement conflicted with the CHECK constraint "CHK_Inventory_Valid_Dates_Sequence". The conflict occurred in database "Test", table "Data.Inventory".
The statement has been terminated.


SELECT ChangeDate,
  ChangeQty,
  TotalQty,
  PreviousChangeDate,
  PreviousTotalQty
FROM Data.Inventory ORDER BY ChangeDate;

ChangeDate              ChangeQty   TotalQty    PreviousChangeDate      PreviousTotalQty
----------------------- ----------- ----------- ----------------------- -----
2009-01-01 00:00:00.000 10          10          NULL                    NULL
2009-01-03 00:00:00.000 5           15          2009-01-01 00:00:00.000 10
2009-01-04 00:00:00.000 3           18          2009-01-03 00:00:00.000 15
2009-01-05 00:00:00.000 -4          14          2009-01-04 00:00:00.000 18


-- try to change a single row, all updates must fail
UPDATE Data.Inventory SET ChangeQty = ChangeQty + 2 WHERE InventoryID = 3;
UPDATE Data.Inventory SET TotalQty = TotalQty + 2 WHERE InventoryID = 3;
-- try to delete not the last row, all deletes must fail
DELETE FROM Data.Inventory WHERE InventoryID = 1;
DELETE FROM Data.Inventory WHERE InventoryID = 3;

-- the right way to update

DECLARE @IncreaseQty INT;
SET @IncreaseQty = 2;
UPDATE Data.Inventory SET ChangeQty = ChangeQty + CASE WHEN ItemID = 1 AND ChangeDate = '20090103' THEN @IncreaseQty ELSE 0 END,
  TotalQty = TotalQty + @IncreaseQty,
  PreviousTotalQty = PreviousTotalQty + CASE WHEN ItemID = 1 AND ChangeDate = '20090103' THEN 0 ELSE @IncreaseQty END
WHERE ItemID = 1 AND ChangeDate >= '20090103';

SELECT ChangeDate,
  ChangeQty,
  TotalQty,
  PreviousChangeDate,
  PreviousTotalQty
FROM Data.Inventory ORDER BY ChangeDate;

ChangeDate              ChangeQty   TotalQty    PreviousChangeDate      PreviousTotalQty
----------------------- ----------- ----------- ----------------------- ----------------
2009-01-01 00:00:00.000 10          10          NULL                    NULL
2009-01-03 00:00:00.000 7           17          2009-01-01 00:00:00.000 10
2009-01-04 00:00:00.000 3           20          2009-01-03 00:00:00.000 17
2009-01-05 00:00:00.000 -4          16          2009-01-04 00:00:00.000 20

Das ist eine sehr gute Frage.

Angenommen, Sie haben eine Transaktionstabelle, in der jede Lastschrift / Gutschrift gespeichert ist, dann ist an Ihrem Entwurf nichts falsch. Tatsächlich habe ich mit Prepaid-Telekommunikationssystemen gearbeitet, die genau so funktioniert haben.

Das wichtigste, was Sie tun müssen, ist sicherzustellen, dass Sie einen SELECT ... FOR UPDATETeil der Balance machen, während SieINSERT die Lastschrift / Gutschrift ausführen. Dies garantiert den korrekten Saldo, wenn etwas schief geht (da die gesamte Transaktion zurückgesetzt wird).

Wie bereits erwähnt, benötigen Sie eine Momentaufnahme der Salden zu bestimmten Zeitpunkten, um zu überprüfen, ob alle Transaktionen in einem bestimmten Zeitraum die korrekte Summe der Start- / Endsalden für den Zeitraum ergeben. Schreiben Sie dazu einen Stapeljob, der am Ende des Zeitraums (Monat / Woche / Tag) um Mitternacht ausgeführt wird.

Der Saldo ist ein berechneter Betrag, der auf bestimmten Geschäftsregeln basiert. Sie möchten den Saldo also nicht behalten, sondern ihn aus den Transaktionen auf der Karte und daher auf dem Konto berechnen.

Sie möchten alle Transaktionen auf der Karte für die Prüfung und Berichterstellung nachverfolgen und später sogar Daten aus verschiedenen Systemen.

Fazit: Berechnen Sie alle Werte, die nach Bedarf berechnet werden müssen