progress-4gl
TEMP-TABELLE
Suche…
Einführung
Die TEMP-TABLE ist eine sehr leistungsfähige Funktion von Progress ABL. Es ist eine temporäre In-Memory-Tabelle (meistens zumindest), die zum Schreiben komplexer Logik verwendet werden kann. Es kann als Eingabe- / Ausgabeparameter für Prozeduren, Funktionen und andere Programme verwendet werden. Eine oder mehrere temporäre Tabellen können die Grundlage eines DATASET (häufig als ProDataset bezeichnet).
Fast alles, was mit einer nativen Progress-Datenbanktabelle gemacht werden kann, kann mit einer temporären Tabelle durchgeführt werden.
Definieren einer einfachen Temp-Tabelle
Dies ist die Definition einer TEMP-TABLE Namen ttTempTable mit drei Feldern. NO-UNDO zeigt an, dass keine Undo-Behandlung erforderlich ist (dies ist normalerweise das, was Sie tun möchten, wenn Sie nicht wirklich das Gegenteil benötigen).
DEFINE TEMP-TABLE ttTempTable NO-UNDO
FIELD field1 AS INTEGER
FIELD field2 AS CHARACTER
FIELD field3 AS LOGICAL.
Eine temporäre Tabelle mit einem Index
Temporäre Tabellen können (und sollten) mit Indizes erstellt werden, wenn Sie Abfragen gegen sie ausführen möchten.
Diese Tabelle hat einen Index (Index1), der ein Feld (Feld1) enthält. Dieser Index ist primär und eindeutig (dh, nicht zwei Datensätze können den gleichen Inhalt von Feld1 haben).
DEFINE TEMP-TABLE ttTempTable NO-UNDO
FIELD field1 AS INTEGER
FIELD field2 AS CHARACTER
FIELD field3 AS LOGICAL
INDEX index1 IS PRIMARY UNIQUE field1 .
Weitere Indizes - Indizes ...
Sie können mehrere Indizes für jede Temp-Tabelle definieren. Wenn Sie sie brauchen, definieren Sie sie. Grundsätzlich hilft ein Index, der Ihrer Suchanfrage und / oder Sortierreihenfolge entspricht, die Leistung!
DEFINE TEMP-TABLE ttWithIndex NO-UNDO
FIELD field1 AS INTEGER
FIELD field2 AS CHARACTER
FIELD field3 AS LOGICAL
INDEX field1 field1.
DEFINE TEMP-TABLE ttWithoutIndex NO-UNDO
FIELD field1 AS INTEGER
FIELD field2 AS CHARACTER
FIELD field3 AS LOGICAL.
DEFINE VARIABLE i AS INTEGER NO-UNDO.
DEFINE VARIABLE iWithCreate AS INTEGER NO-UNDO.
DEFINE VARIABLE iWithFind AS INTEGER NO-UNDO.
DEFINE VARIABLE iWithoutCreate AS INTEGER NO-UNDO.
DEFINE VARIABLE iWithoutFind AS INTEGER NO-UNDO.
ETIME(TRUE).
DO i = 1 TO 1000:
CREATE ttWithIndex.
ttWithIndex.field1 = i.
END.
iWithCreate = ETIME.
ETIME(TRUE).
DO i = 1 TO 1000:
CREATE ttWithoutIndex.
ttWithoutIndex.field1 = i.
END.
iWithoutCreate = ETIME.
RELEASE ttWithIndex.
RELEASE ttWithoutIndex.
ETIME(TRUE).
DO i = 1 TO 1000:
FIND FIRST ttWithIndex WHERE ttWithIndex.field1 = i NO-ERROR.
END.
iWithFind = ETIME.
ETIME(TRUE).
DO i = 1 TO 1000:
FIND FIRST ttWithoutIndex WHERE ttWithoutIndex.field1 = i NO-ERROR.
END.
iWithoutFind = ETIME.
MESSAGE
"With index took" iWithFind "ms to find and" iWithCreate "ms to create" SKIP
"Without index took" iWithoutFind "ms to find and" iWithoutCreate "ms to create"
VIEW-AS ALERT-BOX.
Die Suche mit dem Index war etwa 70 Mal schneller als bei keinem Index! Dies ist natürlich nur ein Durchlauf, also kein wissenschaftlicher Beweis, aber Ihr Index-Setup wird Auswirkungen haben.
Temp-Tabellen eingeben und ausgeben
Es ist sehr einfach, temporäre Tabellen in Programme, Prozeduren und Funktionen zu übergeben.
Dies kann praktisch sein, wenn Sie möchten, dass eine Prozedur eine größere Anzahl von Daten verarbeitet, als Sie leicht in einer Zeichenfolge oder ähnlichem speichern können. Sie können temp-Tabellen übergeben INPUT , OUTPUT und INPUT-OUTPUT - Daten.
Eine Temp-Tabelle eingeben und eine andere ausgeben:
DEFINE TEMP-TABLE ttRequest NO-UNDO
FIELD fieldA AS CHARACTER
FIELD fieldB AS CHARACTER.
/* Define a temp-table with the same fields and indices */
DEFINE TEMP-TABLE ttResponse NO-UNDO LIKE ttRequest.
/* A procedure that simply swap the values of fieldA and fieldB */
PROCEDURE swapFields:
DEFINE INPUT PARAMETER TABLE FOR ttRequest.
DEFINE OUTPUT PARAMETER TABLE FOR ttResponse.
FOR EACH ttRequest:
CREATE ttResponse.
ASSIGN
ttResponse.fieldA = ttRequest.fieldB
ttResponse.fieldB = ttRequest.fieldA.
END.
END PROCEDURE.
CREATE ttRequest.
ASSIGN ttRequest.fieldA = "A"
ttRequest.fieldB = "B".
CREATE ttRequest.
ASSIGN ttRequest.fieldA = "B"
ttRequest.fieldB = "C".
CREATE ttRequest.
ASSIGN ttRequest.fieldA = "C"
ttRequest.fieldB = "D".
/* Call the procedure */
RUN swapFields ( INPUT TABLE ttRequest
, OUTPUT TABLE ttResponse).
FOR EACH ttResponse:
DISPLAY ttResponse.
END.
Ergebnis:
fieldA--------fieldB--------
B A
C B
D C
Eingabe-Ausgabe einer Temp-Tabelle:
DEFINE TEMP-TABLE ttCalculate NO-UNDO
FIELD num1 AS INTEGER
FIELD num2 AS INTEGER
FIELD response AS DECIMAL.
PROCEDURE pythagoras:
DEFINE INPUT-OUTPUT PARAMETER TABLE FOR ttCalculate.
FOR EACH ttCalculate:
ttCalculate.response = SQRT( EXP(num1, 2) + EXP(num2, 2)).
END.
END PROCEDURE.
CREATE ttCalculate.
ASSIGN ttCalculate.num1 = 3
ttCalculate.num2 = 4.
CREATE ttCalculate.
ASSIGN ttCalculate.num1 = 6
ttCalculate.num2 = 8.
CREATE ttCalculate.
ASSIGN ttCalculate.num1 = 12
ttCalculate.num2 = 16.
/* Call the procedure */
RUN pythagoras ( INPUT-OUTPUT TABLE ttCalculate ).
FOR EACH ttCalculate:
DISPLAY ttCalculate.
END.
Ergebnis:
----------num1-- ----------num2-- -------response-
3 4 5.00
6 8 10.00
12 16 20.00
Übergabe an Funktionen
DEFINE TEMP-TABLE ttNumbers NO-UNDO
FIELD num1 AS INTEGER
FIELD num2 AS INTEGER
INDEX index1 num1 num2.
DEFINE VARIABLE iNum AS INTEGER NO-UNDO.
/* Forward declare the function */
FUNCTION hasAPair RETURNS LOGICAL (INPUT TABLE ttNumbers) FORWARD.
DO iNum = 1 TO 100:
CREATE ttNumbers.
ASSIGN ttNumbers.num1 = RANDOM(1,100)
ttNumbers.num2 = RANDOM(1,100).
END.
MESSAGE hasAPair(INPUT TABLE ttNumbers) VIEW-AS ALERT-BOX.
/* Function to check if two records has the same value in num1 and num2 */
FUNCTION hasAPair RETURNS LOGICAL (INPUT TABLE ttNumbers):
FIND FIRST ttNumbers WHERE ttNumbers.num1 = ttNumbers.num2 NO-ERROR.
IF AVAILABLE ttNumbers THEN
RETURN TRUE.
ELSE
RETURN FALSE.
END FUNCTION.
Weitergabe an Programmdateien
Sie übergeben temporäre Tabellen an und von anderen .p-Programmen auf dieselbe Weise, wie Sie sie an andere Prozeduren übergeben. Der einzige Unterschied besteht darin, dass sowohl das aufrufende als auch das aufgerufene Programm dieselbe Temp-Table-Deklaration haben müssen. Eine einfache Möglichkeit besteht darin, das Temp-Table-Programm in einer dritten Datei zu speichern - einem Include, das in beiden Programmen verwendet wird.
Include-Datei mit der Definition der temporären Tabelle: / * ttFile.i * / DEFINE TEMP-TABLE ttFile NO-UNDO FIELD fName AS CHARACTER FORMAT "x (20)" FELD isADirectory AS LOGICAL.
Programm prüft alle Dateien in einer temporären Tabelle. Sind das Verzeichnisse?
/* checkFiles.p */
{ttFile.i}
DEFINE INPUT-OUTPUT PARAMETER TABLE FOR ttFile.
FOR EACH ttFile:
FILE-INFO:FILE-NAME = ttFile.fName.
IF FILE-INFO:FILE-TYPE BEGINS "D" THEN
ttFile.isADirectory = TRUE.
END.
Hauptprogramm:
{ttFile.i}
CREATE ttFile.
ASSIGN ttFile.fname = "c:\temp\".
CREATE ttFile.
ASSIGN ttFile.fname = "c:\Windows\".
CREATE ttFile.
ASSIGN ttFile.fname = "c:\Windoose\".
RUN checkFiles.p(INPUT-OUTPUT TABLE ttFile).
FOR EACH ttFile:
DISPLAY ttFile.
END.
Ergebnis:
fName----------------- isADirector
c:\temp\ yes
c:\Windows\ yes
c:\Windoose\ no