Berechnete Kennzahlen

Um eine berechnete Kennzahl zu generieren, wählen Sie im Kennzahlen-Editor den Aggregationstyp: Berechnung oder detaillierte Berechnung.

Es gibt zwei Arten von berechneten Kennzahlen: anhand anderer Kennzahlen (Berechnung) und anhand der Stammdaten (detaillierte Berechnung):

  • Berechnete Kennzahlen, die auf anderen Kennzahlen basieren, werden nach der Berechnung der Standardkennzahlen berechnet. In der Berechnungsfunktion einer solchen Kennzahl sind Dimensionswerte und Werte von zuvor berechneten Kennzahlen verfügbar. Um alle Zellen zu berechnen, einschließlich der "leeren" Zellen (die keine entsprechenden Zeilen im Ursprungssatz haben), muss das Kontrollkästchen "Alle Zellen berechnen" aktiviert werden.

  • Die Berechnung der berechneten Kennzahlen aus den Stammdaten erfolgt zur gleichen Zeit wie die Berechnung der Standardkennzahlen. Die Feldwerte des aktuellen Ursprungssatzes und die Dimensionswerte stehen dabei in der Berechnungsfunktion zur Verfügung. Das Kontrollkästchen "Alle Zellen berechnen" ist für diese Art von Kennzahlen nicht verfügbar.

Nachdem Sie den Aggregationstyp ausgewählt haben, müssen Sie eine Berechnungsfunktion schreiben oder sie aus der Liste der vorhandenen auswählen. Erstellen Sie eine Vorlage oder öffnen Sie die Bearbeitung der ausgewählten Funktion durch Doppelklick in das Feld "Funktion". Dies öffnet den Formeleditor.

Neben der Funktion für die Kennzahl müssen Sie im Feld "Reihenfolge" die Priorität ihrer Berechnung festlegen.

Das Schreiben und Ändern der Berechnungsfunktion erfolgt im Formeleditor.

Der Formeleditor ist ein Dialog, der aus drei Teilen besteht:

  1. Symbolleiste;
  2. Editor mit Syntax-Highlighting;
  3. Baum der Variablen, Funktionen und Klassen, die beim Schreiben von Berechnungsfunktionen zur Verfügung stehen.

Die Symbolleiste enthält Befehle zum Überprüfen der Formel, zum Speichern, zum Abbrechen der Bearbeitung sowie zum Auswählen einer Programmiersprache.

Der Texteditor dient zum Bearbeiten der Funktionstexte. Der Funktionstext ist ein Programm in der gewählten Sprache und wird zum Zeitpunkt der Berechnung mit FastScript interpretiert. Der Funktionskörper muss einen Wert zurückgeben, indem er der "Result" Variablen einen Wert zuweist. Beim Schreiben von Formeln stehen je nach Art der Kennzahl Dimensionen, Kennzahlen und Quelldatenfelder zur Verfügung.

Die folgenden Variablen sind im Skript verfügbar, um auf die Kreuztabellenelemente zuzugreifen:

  • Liste der Dimensionen: TDimensions;
  • Liste der Kennzahlen: TMeasures;
  • Liste der SliceFields: TfcxSliceFields;
  • CustomObject-Servicevariable: TfcxCustomObject. Diese Variable wird verwendet, um alle benutzerdefinierten Informationen zu speichern, die einer Kennzahlzelle zugeordnet sind. So kann ihr beispielsweise ein Zeiger auf ein in der Berechnungsfunktion erstelltes Objekt zur späteren Verwendung zugewiesen werde. Jeder Zelle (Schnittpunkt von Dimensionskoordinaten) wird eine eigene Variable zugeordnet. Sie können eine CustomObject-Variable nur bei der Berechnung von Kennzahlen anhand des Ursprungdatensatzes verwenden. Wird der CustomObject-Variablen ein Zeiger auf das erstellte Objekt oder einen in der Berechnungsfunktion allokierten Speicherbereich zugewiesen, muss der Speicherplatz in der Funktion freigegeben werden. Zu diesem Zweck wird der Funktion der Parameter Final: boolean übergeben. Ist der Parameter Final = True, wird die Funktion aufgerufen, um die abschließenden Operationen durchzuführen, einschließlich der Freigabe des Speicherplatzes.

Beim Schreiben der berechneten Kennzahl verfügbare Klassen: // Kennzahlensatz-Klasse

TMeasures = class
published
  property Items[AIndex: Integer]: TMeasure;
  property ItemByCaption[AIndex: String]: TMeasure;
  property ItemByName[AIndex: String]: TMeasure;
  property Count: Integer;
  property RecordCount: integer;
  property DetailValue[ARecordIndex: Integer; AFieldName: String]: Variant;
  property XLevel: integer;
  property YLevel: integer;
end;

// Dimensionssatz-Klasse

TDimensions = class
published
  property Items[AIndex: Integer]: TDimension;
  property ItemByCaption[AIndex: String]: TDimension;
  property ItemByName[AIndex: String]: TDimension;
  property XAxisItems[AIndex: Integer]: TDimension;
  property YAxisItems[AIndex: Integer]: TDimension;
  property IsTotalByCol: boolean
  property IsTotalByRow: boolean
  property XLevel: integer;
  property YLevel: integer;
  property XAxisLevelsCount: integer;
  property YAxisLevelsCount: integer;
end;

// Feldsatz-Klasse

TfcxSliceFields = class
published
    property Items[Index: Integer]: TfcxSliceField;
    property ItemByCaption[AIndex: String]: TfcxSliceField;
    property ItemByName[AIndex: String]: TfcxSliceField;
    property Count;
end;

// Kennzahl-Klasse

TMeasure = class
published
  property Caption: String;
  property CurrentValue: Variant;
  property CurrentCaption: String;
  property FieldName: String;
  property ColOffsetValue[Offset: integer]: Variant;
  property RowOffsetValue[Offset: integer]: Variant;
  property ColOffsetValueWithDimValue[ADimValue: Variant]: Variant;
  property RowOffsetValueWithDimValue[ADimValue: Variant]: Variant;
  property TotalValueForDims[ADimNames: String]: Variant;
  property ColRowOffsetValue[ColOffset, RowOffset: integer]: Variant;
  property ColRowOffsetValueWLevel[ColOffset, RowOffset, ColLevelOffset, RowLevelOffset: integer]: Variant
end;

// Dimension-Klasse

TDimension = class
published
  property FieldName: String;
  property Caption: String;
  property CurrentValue: Variant;
  property CurrentCaption: String;
  property SubGroup: TDimension;
end;

// Feld-Klasse

TfcxSliceField = class(TPersistent)
published
  property FieldName: String;
  property Caption: String;
  property CurrentValue: Variant;
  property CurrentCaption: String;
  property FilterCount: Integer;
  property IsFiltered: Boolean;
end;

// Serviceobjekt

TfcxCustomObject = class(TPersistent)
published
  property Value: Pointer;
  property ValueIsNil: Boolean;
end;

Im Folgenden finden Sie eine detaillierte Beschreibung der Eigenschaften und Methoden der aufgeführten Klassen:

TMeasure

  • Caption – Kopfzeile der Kennzahl;
  • FieldName – Name des Kennzahlfeldes;
  • CurrentValue – aktueller Wert;
  • CurrentCaption – Kopfzeile des aktuellen Wertes;
  • ColOffsetValue[Offset: integer] – Kennzahlenwert der Spaltenelemente, die um Offset vom aktuellen Wert versetzt sind;
  • RowOffsetValue[Offset: integer] - Kennzahlenwert der Zeilenelemente, die um Offset vom aktuellen Wert versetzt sind;
  • ColOffsetValueWithDimValue[ADimValue: Variant] - Kennzahlwert, der dem ADimValue-Wert der aktuellen Dimension in der Spaltenachse entspricht;
  • RowOffsetValueWithDimValue[ADimValue: Variant] - Kennzahlwert, der dem ADimValue-Wert der aktuellen Dimension in der Zeilenachse entspricht;
  • TotalValueForDims[ADimNames: String] - der Gesamtwert für die angegebenen Dimensionen;
  • ColRowOffsetValue[ColOffset, RowOffset: integer] – Kennzahlwert der Spaltenelemente, die um ColOffset vom aktuellen Wert versetzt sind, der Zeilenelemente, die um RowOffset versetzt sind;
  • ColRowOffsetValueWLevel[ColOffset, RowOffset, ColLevelOffset, RowLevelOffset: integer] - Kennzahlwert der Spaltenelemente, die um ColOffset versetzt ist, und der Zeilenelemente, die um RowOffset vom Wert auf der angegebenen Ebene versetzt sind;

TDimension

  • Caption – Kopfzeile der Dimension;
  • FieldName – Name des Dimensionsfeldes;
  • CurrentValue - aktueller Wert;
  • CurrentCaption - Kopfzeile des aktuellen Wertes;
  • SubGroup - Dimensionsuntergruppe;

TfcxSliceField

  • Caption - Feldkopfzeile;
  • FieldName - Feldname;
  • CurrentValue - aktueller Wert (nur im Skript für den Filter verfügbar);
  • CurrentCaption - aktueller Wert (nur im Skript für den Filter verfügbar);
  • FilterCount - Anzahl der gefilterten Werte;
  • IsFiltered - ob die Werte dieses Feldes gefiltert werden;

TMeasures

  • Items[AIndex: Integer] – Kennzahlen-Array, auf die per Index zugegriffen wird;
  • ItemByCaption[AIndex: String] - Kennzahlen-Array, auf die über die Kopfzeile zugegriffen wird;
  • ItemByName[AIndex: String] - Kennzahlen-Array, auf die über den Namen zugegriffen wird (Standardeigenschaft);
  • Count – Anzahl der Kennzahlen;
  • RecordCount - Anzahl der Detailzeilen;
  • DetailValue[ARecordIndex: Integer; AFieldName: String] - Feldwert in der Detailzeile;
  • XLevel - Ebene auf der X-Achse, zu der die aktuelle Zelle gehört;
  • YLevel - Ebene auf der Y-Achse, zu der die aktuelle Zelle gehört;

TDimensions

  • Items[AIndex: Integer] – Array von Dimensionen, auf die über den Index zugegriffen wird;
  • ItemByCaption[AIndex: String] - Array von Dimensionen, auf die über die Kopfzeile zugegriffen wird;
  • ItemByName[AIndex: String] - Array von Dimensionen, auf die über den Namen zugegriffen wird (Standardeigenschaft);
  • Count – Anzahl der Dimensionen;
  • XAxisItems[AIndex: Integer] – Dimension auf der X-Achse;
  • YAxisItems[AIndex: Integer] - Dimension auf der Y-Achse;
  • IsTotalByCol - Gesamtzelle auf der X-Achse;
  • IsTotalByRow - Gesamtzelle auf der Y-Achse;
  • XAxisLevelsCount – Anzahl der Dimensionen auf der X-Achse;
  • YAxisLevelsCount - Anzahl der Dimensionen auf der Y-Achse;
  • XLevel - Ebene auf der X-Achse, zu der die aktuelle Zelle gehört;
  • YLevel - Ebene auf der Y-Achse, zu der die aktuelle Zelle gehört;

TfcxSliceFields

  • Items[Index: Integer] – Array von Feldern, auf die über den Index zugegriffen wird;
  • ItemByCaption[AIndex: String] - Array von Feldern, auf die über die Kopfzeile zugegriffen wird;
  • ItemByName[AIndex: String] - Array von Feldern, auf die über den Namen zugegriffen wird (Standardeigenschaft);
  • Count – Anzahl der Felder;

TfcxCustomObject

  • Value - Zeiger auf ein Benutzerobjekt oder einen Speicherbereich;
  • ValueIsNil - Eigenschaft, um die Leerstellen zu überprüfen. Wird verwendet, um vor der Erstellung von Primärobjekten oder der Speicherzuweisung zu prüfen.

Hier ist ein Beispiel dafür, wie eine Kennzahl anhand anderer Kennzahlen berechnet werden kann:

```Code Example Sum = Price * Amount + WorkPrice (Summe = Preis * Menge + Arbeitskosten)


|1.|procedure func\_3(var Result: Variant);|Funktionskopfzeile|
| ----- | ----- | ----- |
|2.|var  wp: Variant;|Bestimmung einer zusätzlichen wp-Variable|
|3.|begin||
|4.|`   wp := Measures['Work price'].CurrentValue;`|Zuweisung des aktuellen Kennzahlwertes mit dem Namen "Work price" an die wp-Variable|
||`   if VarType(wp) <= 1 then wp := 0;`|Wenn es keinen wp-Wert gibt (gleich Null oder Empty), wird angenommen, dass der Wert wp = 0 ist (wir verwenden diesen Trick, um zu vermeiden, dass der Wert Null oder Empty addiert wird)|
||`   Result :=``      Measures['Price'].CurrentValue*``      Measures['Amount'].CurrentValue+``      wp;`|Berechnung des Ergebnisses als aktueller Wert der "Price"-Kennzahl multipliziert mit dem aktuellen Wert der "Amount"-Kennzahl plus den Wert der wp-Variablen|
|5.|end;||

![](../../imgs/fastscript_3.png)

Die Funktion zur Kennzahlenberechnung anhand anderer Kennzahlen wird für jede Zelle (Schnittpunkt der Dimensionen) einmal aufgerufen. Ist der Parameter „Alle Zellen berechnen“ nicht aktiviert, wird die Funktion für leere Zellen nicht aufgerufen.

Die Funktion zur Kennzahlenberechnung anhand der Stammdaten wird für jede Zelle so oft aufgerufen, wie die Zellkoordinaten im Ursprungsdatensatz vorkommen. Zwei Parameter werden an die Funktion übergeben: Result und Final. 

Result ist ein aktueller Wert der Kennzahl.

Final ist ein Zeichen des letzten Aufrufs (bei normalem Aufruf = Fasle).

Nach dem abgeschlossenen Durchlauf durch den ganzen Ursprungsdatensatz wird für jede nicht leere Zelle ein zusätzlicher (letzter) Funktionsaufruf durchgeführt. In diesem Fall wird Final = True an die Funktion übergeben. Der letzte Aufruf dient dazu, weitere Berechnungen durchzuführen und den in der Funktion zugewiesenen Speicher freizugeben.

Im Folgenden finden Sie zwei Beispiele für Funktionen:

Die AmountScriptOnGetValue Funktion berechnet die Summe der Felder "Menge". Bitte beachten Sie, dass die Addition erfolgt, wenn Final = False ist.

Die AveragePriceOnGetValue Funktion berechnet den Durchschnittspreis der Produkte. Dazu werden die Werte in den Feldern "Menge" und "Preis" im letzten Aufruf addiert und der Durchschnitt wird direkt im letzten Aufruf berechnet. Bitte beachten Sie, dass die CustomObject-Service-Variable verwendet wird, um die Summe des Felds „Menge“ zu speichern. Da keine Speicherzuweisung und keine Objekterstellung stattgefunden haben, besteht keine Notwendigkeit, Speicher freizugeben.

![](../../imgs/fastscript_4.png)