KDB + - Kurzanleitung

Dies ist eine völlige Herausforderung kdb+von kx-Systemen, die sich in erster Linie an diejenigen richten, die unabhängig voneinander lernen. kdb + wurde 2003 eingeführt und ist die neue Generation der kdb-Datenbank, mit der Daten erfasst, analysiert, verglichen und gespeichert werden können.

Ein kdb + System enthält die folgenden zwei Komponenten:

• KDB+ - die Datenbank (k Datenbank plus)

• Q - die Programmiersprache für die Arbeit mit kdb +

Beide kdb+ und q sind geschrieben in k programming language (gleich wie q aber weniger lesbar).

Hintergrund

Kdb + / q entstand als obskure akademische Sprache, hat aber im Laufe der Jahre die Benutzerfreundlichkeit schrittweise verbessert.

• APL (1964, Eine Programmiersprache)

• A+ (1988, modifizierte APL von Arthur Whitney)

• K (1993, knackige Version von A +, entwickelt von A. Whitney)

• Kdb (1998, speicherinterne spaltenbasierte Datenbank)

• Kdb+/q (2003, q Sprache - besser lesbare Version von k)

Warum und wo KDB + verwendet werden soll

Warum? - Wenn Sie eine einzige Lösung für Echtzeitdaten mit Analyse benötigen, sollten Sie kdb + in Betracht ziehen. Kdb + speichert die Datenbank als normale native Dateien, sodass keine besonderen Anforderungen an die Hardware und die Speicherarchitektur gestellt werden. Es sei darauf hingewiesen, dass es sich bei der Datenbank nur um eine Reihe von Dateien handelt, sodass Ihre Verwaltungsarbeit nicht schwierig wird.

Wo kann man KDB + verwenden??- Es ist einfach zu zählen, welche Investmentbanken NICHT kdb + verwenden, da die meisten von ihnen derzeit kdb + verwenden oder planen, von herkömmlichen Datenbanken auf kdb + umzusteigen. Da das Datenvolumen von Tag zu Tag zunimmt, benötigen wir ein System, das große Datenmengen verarbeiten kann. KDB + erfüllt diese Anforderung. KDB + speichert nicht nur eine enorme Datenmenge, sondern analysiert sie auch in Echtzeit.

Anfangen

Lassen Sie uns nun vor diesem Hintergrund erläutern, wie Sie eine Umgebung für KDB + einrichten. Wir beginnen mit dem Herunterladen und Installieren von KDB +.

KDB + herunterladen und installieren

Sie können die kostenlose 32-Bit-Version von KDB + mit allen Funktionen der 64-Bit-Version von herunterladen http://kx.com/software-download.php

Stimmen Sie der Lizenzvereinbarung zu und wählen Sie das Betriebssystem aus (verfügbar für alle gängigen Betriebssysteme). Für das Windows-Betriebssystem ist die neueste Version 3.2. Laden Sie die neueste Version herunter. Sobald Sie es entpacken, erhalten Sie den Ordnernamen“windows” und innerhalb des Windows-Ordners erhalten Sie einen anderen Ordner “q”. Kopieren Sie das gesamteq Ordner auf Ihrem Laufwerk c: /.

Öffnen Sie das Run-Terminal und geben Sie den Speicherort ein qMappe; es wird wie "c: /q/w32/q.exe" sein. Sobald Sie die Eingabetaste drücken, erhalten Sie eine neue Konsole wie folgt:

In der ersten Zeile sehen Sie die Versionsnummer 3.2 und das Veröffentlichungsdatum 2015.03.05

Verzeichnislayout

Die Testversion / kostenlose Version wird in der Regel in Verzeichnissen installiert.

For linux/Mac −

~/q       / main q directory (under the user’s home)
~/q/l32   / location of linux 32-bit executable
~/q/m32   / Location of mac 32-bit executable

For Windows −

c:/q          / Main q directory
c:/q/w32/     / Location of windows 32-bit executable

Example Files −

Sobald Sie kdb + heruntergeladen haben, sieht die Verzeichnisstruktur auf der Windows-Plattform wie folgt aus:

In der obigen Verzeichnisstruktur trade.q und sp.q sind die Beispieldateien, die wir als Referenzpunkt verwenden können.

Kdb + ist eine leistungsstarke Datenbank mit hohem Datenvolumen, die von Anfang an für die Verarbeitung enormer Datenmengen entwickelt wurde. Es ist vollständig 64-Bit und verfügt über eine integrierte Multi-Core-Verarbeitung und Multithreading. Dieselbe Architektur wird für Echtzeit- und historische Daten verwendet. Die Datenbank enthält eine eigene leistungsstarke Abfragesprache.q, So können Analysen direkt auf den Daten ausgeführt werden.

kdb+tick ist eine Architektur, die das Erfassen, Verarbeiten und Abfragen von Echtzeit- und historischen Daten ermöglicht.

Kdb + / tick Architektur

Die folgende Abbildung gibt einen allgemeinen Überblick über eine typische Kdb + / Tick-Architektur, gefolgt von einer kurzen Erläuterung der verschiedenen Komponenten und des Datenflusses.

• Das Data Feeds sind Zeitreihendaten, die meist von Daten-Feed-Anbietern wie Reuters, Bloomberg oder direkt von Börsen bereitgestellt werden.

• Um die relevanten Daten zu erhalten, werden die Daten aus dem Datenfeed von der analysiert feed handler.

• Sobald die Daten vom Feed-Handler analysiert wurden, werden sie an die gesendet ticker-plant.

• Um Daten nach einem Fehler wiederherzustellen, aktualisiert / speichert die Ticker-Anlage zuerst die neuen Daten in der Protokolldatei und aktualisiert dann ihre eigenen Tabellen.

• Nach dem Aktualisieren der internen Tabellen und der Protokolldateien werden die Pünktlichkeitsschleifendaten kontinuierlich an die Echtzeitdatenbank und alle verketteten Abonnenten gesendet / veröffentlicht, die Daten angefordert haben.

• Am Ende eines Geschäftstages wird die Protokolldatei gelöscht, eine neue erstellt und die Echtzeitdatenbank in der historischen Datenbank gespeichert. Sobald alle Daten in der historischen Datenbank gespeichert sind, löscht die Echtzeitdatenbank ihre Tabellen.

Komponenten der Kdb + Tick-Architektur

Daten-Feeds

Daten-Feeds können beliebige Markt- oder andere Zeitreihendaten sein. Betrachten Sie Daten-Feeds als Roheingabe für den Feed-Handler. Feeds können direkt vom Austausch (Live-Streaming-Daten), von Nachrichten- / Datenanbietern wie Thomson-Reuters, Bloomberg oder anderen externen Agenturen stammen.

Feed Handler

Ein Feed-Handler konvertiert den Datenstrom in ein Format, das zum Schreiben in kdb + geeignet ist. Es ist mit dem Daten-Feed verbunden und ruft die Daten aus dem Feed-spezifischen Format ab und konvertiert sie in eine Kdb + -Nachricht, die im Ticker-Plant-Prozess veröffentlicht wird. Im Allgemeinen wird ein Feed-Handler verwendet, um die folgenden Vorgänge auszuführen:

• Erfassen Sie Daten nach einer Reihe von Regeln.
• Übersetzen (/ bereichern) Sie diese Daten von einem Format in ein anderes.
• Fangen Sie die neuesten Werte ab.

Ticker Pflanze

Ticker Plant ist der wichtigste Bestandteil der KDB + -Architektur. Es ist die Tickeranlage, mit der die Echtzeitdatenbank oder direkte Abonnenten (Clients) verbunden sind, um auf die Finanzdaten zuzugreifen. Es arbeitet inpublish and subscribeMechanismus. Sobald Sie ein Abonnement (Lizenz) erhalten haben, wird eine Tick-Veröffentlichung (routinemäßig) vom Verlag (Ticker-Anlage) definiert. Es führt die folgenden Operationen aus:

• Empfängt die Daten vom Feed-Handler.

• Unmittelbar nachdem die Tickeranlage die Daten erhalten hat, speichert sie eine Kopie als Protokolldatei und aktualisiert sie, sobald die Tickeranlage eine Aktualisierung erhält, so dass wir im Falle eines Fehlers keinen Datenverlust haben sollten.

• Die Kunden (Echtzeit-Abonnenten) können die Ticker-Anlage direkt abonnieren.

• Am Ende eines jeden Geschäftstages, dh sobald die Echtzeitdatenbank die letzte Nachricht empfangen hat, werden alle heutigen Daten in der historischen Datenbank gespeichert und an alle Abonnenten weitergeleitet, die die heutigen Daten abonniert haben. Dann werden alle Tabellen zurückgesetzt. Die Protokolldatei wird auch gelöscht, sobald die Daten in der historischen Datenbank oder einem anderen direkt mit der Echtzeitdatenbank (rtdb) verknüpften Abonnenten gespeichert sind.

• Infolgedessen sind die Ticker-Anlage, die Echtzeitdatenbank und die historische Datenbank rund um die Uhr in Betrieb.

Da es sich bei der Ticker-Pflanze um eine Kdb + -Anwendung handelt, können ihre Tabellen mit abgefragt werden qwie jede andere Kdb + Datenbank. Alle Ticker-Plant-Clients sollten nur als Abonnenten Zugriff auf die Datenbank haben.

Echtzeitdatenbank

Eine Echtzeitdatenbank (rdb) speichert die heutigen Daten. Es ist direkt mit der Tickeranlage verbunden. Normalerweise wird es während der Marktzeiten (eines Tages) gespeichert und am Ende des Tages in die historische Datenbank (hdb) geschrieben. Da die Daten (Rdb-Daten) im Speicher gespeichert sind, ist die Verarbeitung extrem schnell.

Da kdb + eine RAM-Größe empfiehlt, die viermal oder mehr der erwarteten Datengröße pro Tag entspricht, ist die auf rdb ausgeführte Abfrage sehr schnell und bietet eine überlegene Leistung. Da eine Echtzeitdatenbank nur die heutigen Daten enthält, ist die Datumsspalte (Parameter) nicht erforderlich.

Zum Beispiel können wir rdb-Abfragen haben wie:

select from trade where sym = `ibm

OR

select from trade where sym = `ibm, price > 100

Historische Datenbank

Wenn wir die Schätzungen eines Unternehmens berechnen müssen, müssen wir seine historischen Daten verfügbar haben. Eine historische Datenbank (hdb) enthält Daten von Transaktionen, die in der Vergangenheit durchgeführt wurden. Jeder neue Tagesdatensatz wird am Ende des Tages zur Festplatte hinzugefügt. Große Tabellen in der HDB werden entweder gespreizt gespeichert (jede Spalte wird in einer eigenen Datei gespeichert) oder sie werden partitioniert nach zeitlichen Daten gespeichert. Einige sehr große Datenbanken können auch mithilfe von weiter partitioniert werdenpar.txt (Datei).

Diese Speicherstrategien (gespreizt, partitioniert usw.) sind effizient beim Suchen oder Zugreifen auf die Daten aus einer großen Tabelle.

Eine historische Datenbank kann auch für interne und externe Berichtszwecke verwendet werden, dh für Analysen. Angenommen, wir möchten die Handelsgeschäfte von IBM für einen bestimmten Tag aus dem Handelsnamen (oder einem beliebigen Namen) abrufen. Wir müssen eine Abfrage wie folgt schreiben:

thisday: 2014.10.12

select from trade where date = thisday, sym =`ibm

Note - Wir werden alle diese Fragen schreiben, sobald wir einen Überblick über die q Sprache.

Kdb + wird mit seiner integrierten Programmiersprache geliefert, die als bekannt ist q. Es enthält eine Obermenge von Standard-SQL, die für die Zeitreihenanalyse erweitert wurde und viele Vorteile gegenüber der Standardversion bietet. Jeder, der mit SQL vertraut ist, kann lernenq in wenigen Tagen und in der Lage sein, schnell ihre eigenen Ad-hoc-Anfragen zu schreiben.

Starten der "q" -Umgebung

Um kdb + zu verwenden, müssen Sie das starten qSession. Es gibt drei Möglichkeiten, um a zu startenq Sitzung -

• Geben Sie einfach "c: /q/w32/q.exe" in Ihr Laufterminal ein.

• Starten Sie das MS-DOS-Befehlsterminal und geben Sie ein q.

• Kopiere das q.exe Datei auf "C: \ Windows \ System32" und geben Sie auf dem Run-Terminal einfach "q" ein.

Hier gehen wir davon aus, dass Sie auf einer Windows-Plattform arbeiten.

Datentypen

Die folgende Tabelle enthält eine Liste der unterstützten Datentypen -

Name	Beispiel	Verkohlen	Art	Größe
Boolescher Wert	1b	b	1	1
Byte	0xff	x	4	1
kurz	23h	h	5	2
int	23i	ich	6	4
lange	23j	j	7	8
echt	2.3e	e	8	4
schweben	2.3f	f	9	8
verkohlen	"ein"	c	10	1
varchar	`ab	s	11	* *
Monat	2003.03m	m	13	4
Datum	2015.03.17T18: 01: 40.134	z	15	8
Minute	08:31	u	17	4
zweite	08:31:53	v	18	4
Zeit	18: 03: 18.521	t	19	4
Aufzählung	`u $` b, wobei u: `a`b	* *	20	4

Atom- und Listenbildung

Atome sind einzelne Entitäten, z. B. eine einzelne Zahl, ein Zeichen oder ein Symbol. In der obigen Tabelle (verschiedener Datentypen) sind alle unterstützten Datentypen Atome. Eine Liste ist eine Folge von Atomen oder anderen Typen, einschließlich Listen.

Wenn Sie ein Atom eines beliebigen Typs an die monadische Funktion (dh eine Funktion mit einem Argument) übergeben, wird ein negativer Wert zurückgegeben, d. H. –nWährend das Übergeben einer einfachen Liste dieser Atome an die Typfunktion einen positiven Wert zurückgibt n.

Beispiel 1 - Atom- und Listenbildung

/ Note that the comments begin with a slash “ / ” and cause the parser
/ to ignore everything up to the end of the line.

x: `mohan              / `mohan is a symbol, assigned to a variable x
type x                 / let’s check the type of x
-11h                   / -ve sign, because it’s single element.

y: (`abc;`bca;`cab)    / list of three symbols, y is the variable name.

type y
11h                    / +ve sign, as it contain list of atoms (symbol).

y1: (`abc`bca`cab)     / another way of writing y, please note NO semicolon

y2: (`$”symbols may have interior blanks”)   / string to symbol conversion
y[0]                   / return `abc
y 0                    / same as y[0], also returns `abc
y 0 2                  / returns `abc`cab, same as does y[0 2]

z: (`abc; 10 20 30; (`a`b); 9.9 8.8 7.7)      / List of different types,
z 2 0                  / returns (`a`b; `abc),
z[2;0]                 / return `a. first element of z[2]

x: “Hello World!”      / list of character, a string
x 4 0                  / returns “oH” i.e. 4th and 0th(first)
element

Es ist häufig erforderlich, den Datentyp einiger Daten von einem Typ in einen anderen zu ändern. Die Standard-Casting-Funktion ist das "$"dyadic operator.

Drei Ansätze werden verwendet, um von einem Typ in einen anderen umzuwandeln (mit Ausnahme von Zeichenfolgen) -

• Geben Sie den gewünschten Datentyp anhand des Symbolnamens an
• Geben Sie den gewünschten Datentyp anhand seines Zeichens an
• Geben Sie den gewünschten Datentyp anhand des Kurzwerts an.

Ganzzahlen in Floats umwandeln

Im folgenden Beispiel für das Umwandeln von Ganzzahlen in Floats sind alle drei verschiedenen Arten des Umwerfens gleichwertig:

q)a:9 18 27

q)$[`float;a]     / Specify desired data type by its symbol name, 1st way
9 18 27f

q)$["f";a]        / Specify desired data type by its character, 2nd way
9 18 27f

q)$[9h;a]         / Specify desired data type by its short value, 3rd way
9 18 27f

Überprüfen Sie, ob alle drei Operationen gleich sind.

q)($[`float;a]~$["f";a]) and ($[`float;a] ~ $[9h;a])
1b

Zeichenfolgen in Symbole umwandeln

Das Umwandeln von Zeichenfolgen in Symbole und umgekehrt funktioniert etwas anders. Lassen Sie es uns anhand eines Beispiels überprüfen -

q)b: ("Hello";"World";"HelloWorld")    / define a list of strings

q)b
"Hello"
"World"
"HelloWorld"

q)c: `$b                               / this is how to cast strings to symbols

q)c                                    / Now c is a list of symbols
`Hello`World`HelloWorld

Der Versuch, Zeichenfolgen mit den Schlüsselwörtern `symbol oder 11h in Symbole umzuwandeln, schlägt mit dem Typfehler fehl -

q)b
"Hello"
"World"
"HelloWorld"

q)`symbol$b
'type

q)11h$b
'type

Strings in Nicht-Symbole umwandeln

Das Umwandeln von Zeichenfolgen in einen anderen Datentyp als das Symbol erfolgt wie folgt:

q)b:900               / b contain single atomic integer

q)c:string b          / convert this integer atom to string “900”

q)c
"900"

q)`int $ c            / converting string to integer will return the
                      / ASCII equivalent of the character “9”, “0” and
                      / “0” to produce the list of integer 57, 48 and
                      / 48.
57 48 48i

q)6h $ c / Same as above 57 48 48i q)"i" $ c             / Same a above
57 48 48i

q)"I" $ c
900i

Um also eine ganze Zeichenfolge (die Liste der Zeichen) in ein einzelnes Atom des Datentyps umzuwandeln x erfordert, dass wir den Großbuchstaben angeben, der den Datentyp darstellt x als erstes Argument an die $Operator. Wenn Sie den Datentyp von angebenx Auf andere Weise wird die Besetzung auf jedes Zeichen der Zeichenfolge angewendet.

Das q Sprache hat viele verschiedene Möglichkeiten, zeitliche Daten wie Zeiten und Daten darzustellen und zu bearbeiten.

Datum

Ein Datum in kdb + wird intern als ganzzahlige Anzahl von Tagen seit unserem Referenzdatum 01Jan2000 gespeichert. Ein Datum nach diesem Datum wird intern als positive Zahl gespeichert, und ein Datum davor wird als negative Zahl bezeichnet.

Standardmäßig wird ein Datum im Format "JJJY.MM.TT" geschrieben.

q)x:2015.01.22      / This is how we write 22nd Jan 2015

q)`int$x / Number of days since 2000.01.01 5500i q)`year$x           / Extracting year from the date
2015i

q)x.year            / Another way of extracting year
2015i

q)`mm$x / Extracting month from the date 1i q)x.mm / Another way of extracting month 1i q)`dd$x             / Extracting day from the date
22i

q)x.dd              / Another way of extracting day
22i

Arithmetic and logical operations kann direkt an Terminen durchgeführt werden.

q)x+1        / Add one day
2015.01.23

q)x-7        / Subtract 7 days
2015.01.15

Der 1. Januar 2000 fiel auf einen Samstag. Daher würde jeder Samstag in der Geschichte oder in der Zukunft, wenn er durch 7 geteilt wird, einen Rest von 0 ergeben, Sonntag ergibt 1, Montag ergibt 2.

Day               mod 7
           Saturday              0
           Sunday                1
           Monday                2
           Tuesday               3
           Wednesday             4
           Thursday              5
           Friday                6

Mal

Eine Zeit wird intern als ganzzahlige Anzahl von Millisekunden seit dem Mitternachtsstrich gespeichert. Eine Zeit wird im Format HH: MM: SS.MSS geschrieben

q)tt1: 03:30:00.000     / tt1 store the time 03:30 AM

q)tt1
03:30:00.000

q)`int$tt1 / Number of milliseconds in 3.5 hours 12600000i q)`hh$tt1               / Extract the hour component from time
3i

q)tt1.hh
3i

q)`mm$tt1 / Extract the minute component from time 30i q)tt1.mm 30i q)`ss$tt1               / Extract the second component from time
0i

q)tt1.ss
0i

Wie bei Datumsangaben kann die Arithmetik direkt zu bestimmten Zeiten ausgeführt werden.

Datetimes

Eine Datums- / Uhrzeitangabe ist die Kombination aus Datum und Uhrzeit, die wie im ISO-Standardformat durch 'T' getrennt sind. Ein Datum / Uhrzeit-Wert speichert die Anzahl der gebrochenen Tage ab Mitternacht des 1. Januar 2000.

q)dt:2012.12.20T04:54:59:000      / 04:54.59 AM on 20thDec2012

q)type dt
-15h

q)dt
2012.12.20T04:54:59.000
9
q)`float$dt
4737.205

Die zugrunde liegende Anzahl von Bruchteilen von Tagen kann durch Gießen zum Schweben erhalten werden.

Listen sind die Grundbausteine ​​von q languageDaher ist ein gründliches Verständnis der Listen sehr wichtig. Eine Liste ist einfach eine geordnete Sammlung von Atomen (atomaren Elementen) und anderen Listen (Gruppe von einem oder mehreren Atomen).

Arten von Listen

EIN general listschließt seine Elemente in übereinstimmende Klammern ein und trennt sie durch Semikolons. Zum Beispiel -

(9;8;7)   or   ("a"; "b"; "c")   or   (-10.0; 3.1415e; `abcd; "r")

Wenn eine Liste Atome des gleichen Typs enthält, wird sie als a bezeichnet uniform list. Sonst ist es bekannt alsgeneral list (gemischter Typ).

Anzahl

Wir können die Anzahl der Elemente in einer Liste durch ihre Anzahl erhalten.

q)l1:(-10.0;3.1415e;`abcd;"r")    / Assigning variable name to general list

q)count l1                        / Calculating number of items in the list l1
4

Beispiele für einfache Listen

q)h:(1h;2h;255h)                    / Simple Integer List

q)h
1 2 255h

q)f:(123.4567;9876.543;98.7)        / Simple Floating Point List

q)f
123.4567 9876.543 98.7

q)b:(0b;1b;0b;1b;1b)                / Simple Binary Lists

q)b
01011b

q)symbols:(`Life;`Is;`Beautiful)    / Simple Symbols List

q)symbols
`Life`Is`Beautiful

q)chars:("h";"e";"l";"l";"o";" ";"w";"o";"r";"l";"d") 
                                    / Simple char lists and Strings.
q)chars
"hello world"

**Note − A simple list of char is called a string.

Eine Liste enthält Atome oder Listen. To create a single item listverwenden wir -

q)singleton:enlist 42

q)singleton
,42

To distinguish between an atom and the equivalent singleton, untersuchen Sie das Zeichen ihres Typs.

q)signum type 42
-1i

q)signum type enlist 42
1i

Eine Liste wird von links nach rechts nach der Position ihrer Elemente sortiert. Der Versatz eines Elements vom Anfang der Liste wird als its bezeichnetindex. Somit hat das erste Element einen Index 0, das zweite Element (falls vorhanden) einen Index 1 usw. Eine Liste der Zählungenn hat Indexdomäne von 0 zu n–1.

Indexnotation

Eine Liste gegeben L, das Element am Index i wird von zugegriffen L[i]. Das Abrufen eines Elements anhand seines Index wird aufgerufenitem indexing. Zum Beispiel,

q)L:(99;98.7e;`b;`abc;"z")

q)L[0]
99

q)L[1]
98.7e

q)L[4]
"z

Indizierte Zuordnung

Elemente in einer Liste können auch über die Elementindizierung zugewiesen werden. So,

q)L1:9 8 7

q)L1[2]:66      / Indexed assignment into a simple list
                / enforces strict type matching.
                
q)L1
9 8 66

Listen aus Variablen

q)l1:(9;8;40;200)

q)l2:(1 4 3; `abc`xyz)

q)l:(l1;l2)               / combining the two list l1 and l2

q)l
9 8 40 200
(1 4 3;`abc`xyz)

Listen beitreten

Die häufigste Operation bei zwei Listen besteht darin, sie zu einer größeren Liste zusammenzufügen. Genauer gesagt hängt der Join-Operator (,) seinen rechten Operanden an das Ende des linken Operanden an und gibt das Ergebnis zurück. In beiden Argumenten wird ein Atom akzeptiert.

q)1,2 3 4
1 2 3 4

q)1 2 3, 4.4 5.6     / If the arguments are not of uniform type,
                     / the result is a general list.
1
2
3
4.4
5.6

Nisten

Die Datenkomplexität wird durch die Verwendung von Listen als Listenelemente erstellt.

Tiefe

Die Anzahl der Verschachtelungsebenen für eine Liste wird als Tiefe bezeichnet. Atome haben eine Tiefe von 0 und einfache Listen haben eine Tiefe von 1.

q)l1:(9;8;(99;88))

q)count l1
3

Hier ist eine Liste von Tiefe 3 mit zwei Elementen -

q)l5
9
(90;180;900 1800 2700 3600)

q)count l5
2

q)count l5[1]
3

Indizierung in der Tiefe

Es ist möglich, direkt in die Elemente einer verschachtelten Liste zu indizieren.

Repeated Item Indexing

Durch das Abrufen eines Elements über einen einzelnen Index wird immer ein oberstes Element aus einer verschachtelten Liste abgerufen.

q)L:(1;(100;200;(300;400;500;600)))

q)L[0]
1

q)L[1]
100
200
300 400 500 600

Da das Ergebnis L[1] Ist selbst eine Liste, können wir ihre Elemente mit einem einzigen Index abrufen.

q)L[1][2]
300 400 500 600

Wir können die einzelne Indizierung noch einmal wiederholen, um ein Element aus der innersten verschachtelten Liste abzurufen.

q)L[1][2][0]
300

Sie können dies lesen als,

Holen Sie sich das Element bei Index 1 von L und rufen Sie von dort das Element bei Index 2 und von dort das Element bei Index 0 ab.

Notation for Indexing at Depth

Es gibt eine alternative Notation für die wiederholte Indizierung in die Bestandteile einer verschachtelten Liste. Der letzte Abruf kann auch geschrieben werden als:

q)L[1;2;0]
300

Die Zuordnung über den Index funktioniert auch in der Tiefe.

q)L[1;2;1]:900

q)L
1
(100;200;300 900 500 600)

Elided Indizes

Eliding Indices for a General List

q)L:((1 2 3; 4 5 6 7); (`a`b`c;`d`e`f`g;`0`1`2);("good";"morning"))

q)L
(1 2 3;4 5 6 7)
(`a`b`c;`d`e`f`g;`0`1`2)
("good";"morning")

q)L[;1;]
4 5 6 7
`d`e`f`g
"morning"

q)L[;;2]
3 6
`c`f`2
"or"

Interpret L[;1;] as,

Rufen Sie alle Elemente an der zweiten Position jeder Liste auf der obersten Ebene ab.

Interpret L[;;2] as,

Rufen Sie die Elemente an dritter Stelle für jede Liste auf der zweiten Ebene ab.

Wörterbücher sind eine Erweiterung von Listen, die die Grundlage für die Erstellung von Tabellen bilden. In mathematischen Begriffen erstellt das Wörterbuch die

"Domain → Range"

oder im Allgemeinen (kurz) erstellt

"Schlüssel → Wert"

Beziehung zwischen Elementen.

Ein Wörterbuch ist eine geordnete Sammlung von Schlüssel-Wert-Paaren, die in etwa einer Hash-Tabelle entspricht. Ein Wörterbuch ist eine Zuordnung, die durch eine explizite E / A-Zuordnung zwischen einer Domänenliste und einer Bereichsliste über Positionskorrespondenz definiert wird. Bei der Erstellung eines Wörterbuchs wird das Grundelement "xkey" (!) Verwendet.

ListOfDomain ! ListOfRange

Das einfachste Wörterbuch ordnet eine einfache Liste einer einfachen Liste zu.

Eingabe (I)	Ausgang (O)
`Name	`John
`Alter	36
`Sex	"M"
Gewicht	60.3

q)d:`Name`Age`Sex`Weight!(`John;36;"M";60.3)   / Create a dictionary d

q)d

Name   | `John
Age    | 36
Sex    | "M"
Weight | 60.3

q)count d             / To get the number of rows in a dictionary.
4

q)key d               / The function key returns the domain
`Name`Age`Sex`Weight

q)value d             / The function value returns the range.

`John
36

"M"
60.3

q)cols d             / The function cols also returns the domain.
`Name`Age`Sex`Weight

Nachsehen

Das Finden des Wörterbuchausgabewerts, der einem Eingabewert entspricht, wird aufgerufen looking up die Eingabe.

q)d[`Name]       / Accessing the value of domain `Name
`John

q)d[`Name`Sex]   / extended item-wise to a simple list of keys
`John
"M"

Nachschlagen mit Verb @

q)d1:`one`two`three!9 18 27

q)d1[`two]
18

q)d1@`two
18

Operationen an Wörterbüchern

Ändern und Upsert

Wie bei Listen können die Elemente eines Wörterbuchs über eine indizierte Zuordnung geändert werden.

d:`Name`Age`Sex`Weight! (`John;36;"M";60.3)
                                  / A dictionary d
                                  
q)d[`Age]:35                      / Assigning new value to key Age

q)d 
                              / New value assigned to key Age in d
Name   | `John
Age    | 35
Sex    | "M"
Weight | 60.3

Wörterbücher können über die Indexzuordnung erweitert werden.

q)d[`Height]:"182 Ft"

q)d

Name   | `John
Age    | 35
Sex    | "M"
Weight | 60.3
Height | "182 Ft"

Reverse Lookup mit Find (?)

Der Operator find (?) Wird verwendet, um eine umgekehrte Suche durchzuführen, indem ein Bereich von Elementen seinem Domänenelement zugeordnet wird.

q)d2:`x`y`z!99 88 77

q)d2?77
`z

Falls die Elemente einer Liste nicht eindeutig sind, wird die find Gibt die erste Elementzuordnung aus der Domänenliste zurück.

Einträge entfernen

Um einen Eintrag aus einem Wörterbuch zu entfernen, klicken Sie auf delete ( _ ) functionwird eingesetzt. Der linke Operand von (_) ist das Wörterbuch und der rechte Operand ist ein Schlüsselwert.

q)d2:`x`y`z!99 88 77

q)d2 _`z

x| 99
y| 88

Links von _ ist ein Leerzeichen erforderlich, wenn der erste Operand eine Variable ist.

q)`x`y _ d2           / Deleting multiple entries

z| 77

Spaltenwörterbücher

Spaltenwörterbücher sind die Grundlagen für die Erstellung von Tabellen. Betrachten Sie das folgende Beispiel -

q)scores: `name`id!(`John`Jenny`Jonathan;9 18 27)
                              / Dictionary scores
                              
q)scores[`name]               / The values for the name column are
`John`Jenny`Jonathan

q)scores.name                 / Retrieving the values for a column in a
                              / column dictionary using dot notation.
`John`Jenny`Jonathan

q)scores[`name][1]            / Values in row 1 of the name column
`Jenny

q)scores[`id][2]              / Values in row 2 of the id column is
27

Ein Wörterbuch umblättern

Der Nettoeffekt beim Umblättern eines Spaltenwörterbuchs besteht einfach darin, die Reihenfolge der Indizes umzukehren. Dies entspricht logischerweise der Transponierung der Zeilen und Spalten.

Blättern Sie in einem Spaltenwörterbuch

Die Transponierung eines Wörterbuchs wird durch Anwenden des unären Flip-Operators erhalten. Schauen Sie sich das folgende Beispiel an -

q)scores

name  | John Jenny Jonathan
id    | 9   18   27

q)flip scores

  name     id
---------------
  John     9
  Jenny    18
 Jonathan  27

Flip eines gespiegelten Spaltenwörterbuchs

Wenn Sie ein Wörterbuch zweimal transponieren, erhalten Sie das Originalwörterbuch.

q)scores ~ flip flip scores
1b

Tabellen sind das Herzstück von kdb +. Eine Tabelle ist eine Sammlung benannter Spalten, die als Wörterbuch implementiert sind.q tables sind spaltenorientiert.

Tabellen erstellen

Tabellen werden mit der folgenden Syntax erstellt:

q)trade:([]time:();sym:();price:();size:())

q)trade
time sym price size
-------------------

Im obigen Beispiel haben wir nicht den Typ jeder Spalte angegeben. Dies wird durch das erste Einfügen in die Tabelle festgelegt.

Auf andere Weise können wir den Spaltentyp bei der Initialisierung angeben -

q)trade:([]time:`time$();sym:`$();price:`float$();size:`int$())

Oder wir können auch nicht leere Tabellen definieren -

q)trade:([]sym:(`a`b);price:(1 2))

q)trade

 sym   price
-------------
  a      1
  b      2

Wenn sich in den eckigen Klammern keine Spalten befinden, wie in den obigen Beispielen, lautet die Tabelle unkeyed.

So erstellen Sie eine keyed tablefügen wir die Spalte (n) für den Schlüssel in die eckigen Klammern ein.

q)trade:([sym:`$()]time:`time$();price:`float$();size:`int$())

q)trade

 sym   | time price size
-----  | ---------------

Sie können die Spaltentypen auch definieren, indem Sie die Werte als Nulllisten verschiedener Typen festlegen.

q)trade:([]time:0#0Nt;sym:0#`;price:0#0n;size:0#0N)

Abrufen von Tabelleninformationen

Lassen Sie uns eine Handelstabelle erstellen -

trade: ([]sym:`ibm`msft`apple`samsung;mcap:2000 4000 9000 6000;ex:`nasdaq`nasdaq`DAX`Dow)

q)cols trade                         / column names of a table
`sym`mcap`ex

q)trade.sym                          / Retrieves the value of column sym
`ibm`msft`apple`samsung

q)show meta trade                    / Get the meta data of a table trade.

  c   | t f a
----- | -----
 Sym  | s
 Mcap | j
 ex   | s

Primärschlüssel und Schlüsseltabellen

Schlüsseltabelle

Eine Schlüsseltabelle ist ein Wörterbuch, das jede Zeile in einer Tabelle mit eindeutigen Schlüsseln einer entsprechenden Zeile in einer Wertetabelle zuordnet. Nehmen wir ein Beispiel -

val:flip `name`id!(`John`Jenny`Jonathan;9 18 27)
                          / a flip dictionary create table val
id:flip (enlist `eid)!enlist 99 198 297
                          / flip dictionary, having single column eid

Erstellen Sie nun eine einfache Schlüsseltabelle mit eid als Schlüssel.

q)valid: id ! val

q)valid                 / table name valid, having key as eid

  eid |  name      id
---   | ---------------
  99  |  John      9
  198 |  Jenny     18
  297 |  Jonathan  27

Fremde Schlüssel

EIN foreign key definiert eine Zuordnung von den Zeilen der Tabelle, in der sie definiert ist, zu den Zeilen der Tabelle mit den entsprechenden primary key.

Fremdschlüssel bieten referential integrity. Mit anderen Worten, ein Versuch, einen Fremdschlüsselwert einzufügen, der nicht im Primärschlüssel enthalten ist, schlägt fehl.

Betrachten Sie die folgenden Beispiele. Im ersten Beispiel definieren wir einen Fremdschlüssel explizit bei der Initialisierung. Im zweiten Beispiel verwenden wir die Fremdschlüsseljagd, bei der keine vorherige Beziehung zwischen den beiden Tabellen vorausgesetzt wird.

Example 1 − Define foreign key on initialization

q)sector:([sym:`SAMSUNG`HSBC`JPMC`APPLE]ex:`N`CME`DAQ`N;MC:1000 2000 3000 4000)

q)tab:([]sym:`sector$`HSBC`APPLE`APPLE`APPLE`HSBC`JPMC;price:6?9f)

q)show meta tab

  c    | t f a
------ | ----------
 sym   | s sector
 price | f

q)show select from tab where sym.ex=`N

  sym     price
----------------
 APPLE   4.65382
 APPLE   4.643817
 APPLE   3.659978

Example 2 − no pre-defined relationship between tables

sector: ([symb:`IBM`MSFT`HSBC]ex:`N`CME`N;MC:1000 2000 3000)
tab:([]sym:`IBM`MSFT`MSFT`HSBC`HSBC;price:5?9f)

Um die Fremdschlüsseljagd zu verwenden, müssen wir eine Tabelle erstellen, um den Sektor einzugeben.

q)show update mc:(sector([]symb:sym))[`MC] from tab

  sym     price      mc
--------------------------
  IBM   7.065297    1000
  MSFT  4.812387    2000
  MSFT  6.400545    2000
  HSBC  3.704373    3000
  HSBC  4.438651    3000

Allgemeine Notation für einen vordefinierten Fremdschlüssel -

Wählen Sie ab aus c, wobei a der Fremdschlüssel (sym) ist, b a ist

Feld in der Primärschlüsseltabelle (ind), c ist das

Fremdschlüsseltabelle (Handel)

Tabellen bearbeiten

Let’s create one trade table and check the result of different table expression −

q)trade:([]sym:5?`ibm`msft`hsbc`samsung;price:5?(303.00*3+1);size:5?(900*5);time:5?(.z.T-365))

q)trade

  sym        price   size   time
-----------------------------------------
 msft      743.8592  3162  02:32:17.036
 msft      641.7307  2917  01:44:56.936
 hsbc      838.2311  1492  00:25:23.210
 samsung   278.3498  1983  00:29:38.945
 ibm       838.6471  4006  07:24:26.842

Let us now take a look at the statements that are used to manipulate tables using q language.

Select

The syntax to use a Select statement is as follows −

select [columns] [by columns] from table [where clause]

Let us now take an example to demonstrate how to use Select statement −

q)/ select expression example

q)select sym,price,size by time from trade where size > 2000

    time      |  sym    price     size
------------- | -----------------------
 01:44:56.936 |  msft   641.7307  2917
 02:32:17.036 |  msft   743.8592  3162
 07:24:26.842 |  ibm    838.6471  4006

Insert

The syntax to use an Insert statement is as follows −

`tablename insert (values)
Insert[`tablename; values]

Let us now take an example to demonstrate how to use Insert statement −

q)/ Insert expression example

q)`trade insert (`hsbc`apple;302.0 730.40;3020 3012;09:30:17.00409:15:00.000)
5 6

q)trade

   sym    price     size    time
------------------------------------------
  msft    743.8592  3162   02:32:17.036
  msft    641.7307  2917   01:44:56.936
  hsbc    838.2311  1492   00:25:23.210
 samsung  278.3498  1983   00:29:38.945
  ibm     838.6471  4006   07:24:26.842
  hsbc    302       3020   09:30:17.004
  apple   730.4     3012   09:15:00.000

q)/Insert another value

q)insert[`trade;(`samsung;302.0; 3333;10:30:00.000]
']

q)insert[`trade;(`samsung;302.0; 3333;10:30:00.000)]
,7

q)trade

   sym     price   size     time
----------------------------------------
  msft   743.8592  3162  02:32:17.036
  msft   641.7307  2917  01:44:56.936
  hsbc   838.2311  1492  00:25:23.210
 samsung 278.3498  1983  00:29:38.945
  ibm    838.6471  4006  07:24:26.842
  hsbc   302       3020  09:30:17.004
  apple  730.4     3012  09:15:00.000
 samsung 302       3333  10:30:00.000

Delete

The syntax to use a Delete statement is as follows −

delete columns from table
delete from table where clause

Let us now take an example to demonstrate how to use Delete statement −

q)/Delete expression example

q)delete price from trade

   sym   size       time
-------------------------------
  msft   3162   02:32:17.036
  msft   2917   01:44:56.936
  hsbc   1492   00:25:23.210
 samsung 1983   00:29:38.945
  ibm    4006   07:24:26.842
  hsbc   3020   09:30:17.004
  apple  3012   09:15:00.000
 samsung 3333   10:30:00.000

q)delete from trade where price > 3000

   sym     price     size       time
-------------------------------------------
  msft    743.8592   3162    02:32:17.036
  msft    641.7307   2917    01:44:56.936
  hsbc    838.2311   1492    00:25:23.210
 samsung  278.3498   1983    00:29:38.945
  ibm     838.6471   4006    07:24:26.842
  hsbc    302        3020    09:30:17.004
  apple   730.4      3012    09:15:00.000
 samsung  302        3333    10:30:00.000

q)delete from trade where price > 500

  sym     price     size     time
-----------------------------------------
 samsung  278.3498  1983  00:29:38.945
  hsbc    302       3020  09:30:17.004
 samsung  302       3333  10:30:00.000

Update

The syntax to use an Update statement is as follows −

update column: newValue from table where ….

Use the following syntax to update the format/datatype of a column using the cast function −

update column:newValue from `table where …

Let us now take an example to demonstrate how to use Update statement −

q)/Update expression example

q)update size:9000 from trade where price > 600

  sym     price      size     time
------------------------------------------
  msft    743.8592   9000   02:32:17.036
  msft    641.7307   9000   01:44:56.936
  hsbc    838.2311   9000   00:25:23.210
 samsung  278.3498   1983   00:29:38.945
  ibm     838.6471   9000   07:24:26.842
  hsbc    302        3020   09:30:17.004
  apple   730.4      9000   09:15:00.000
 samsung  302        3333   10:30:00.000

q)/Update the datatype of a column using the cast function

q)meta trade

   c  |  t f a
----- | --------
  sym |  s
 price|  f
 size |  j
 time |  t

q)update size:`float$size from trade sym price size time ------------------------------------------ msft 743.8592 3162 02:32:17.036 msft 641.7307 2917 01:44:56.936 hsbc 838.2311 1492 00:25:23.210 samsung 278.3498 1983 00:29:38.945 ibm 838.6471 4006 07:24:26.842 hsbc 302 3020 09:30:17.004 apple 730.4 3012 09:15:00.000 samsung 302 3333 10:30:00.000 q)/ Above statement will not update the size column datatype permanently q)meta trade c | t f a ------ | -------- sym | s price | f size | j time | t q)/to make changes in the trade table permanently, we have do q)update size:`float$size from `trade
`trade

q)meta trade

   c   |  t f a
------ | --------
  sym  |   s
 price |   f
 size  |   f
 time  |   t

Kdb+ has nouns, verbs, and adverbs. All data objects and functions are nouns. Verbs enhance the readability by reducing the number of square brackets and parentheses in expressions. Adverbs modify dyadic (2 arguments) functions and verbs to produce new, related verbs. The functions produced by adverbs are called derived functions or derived verbs.

Each

The adverb each, denoted by ( ` ), modifies dyadic functions and verbs to apply to the items of lists instead of the lists themselves. Take a look at the following example −

q)1, (2 3 5)       / Join
1 2 3 5

q)1, '( 2 3 4)     / Join each
1 2
1 3
1 4

There is a form of Each for monadic functions that uses the keyword “each”. For example,

q)reverse ( 1 2 3; "abc")           /Reverse
a b c
1 2 3

q)each [reverse] (1 2 3; "abc")     /Reverse-Each
3 2 1
c b a

q)'[reverse] ( 1 2 3; "abc")
3 2 1
c b a

Each-Left and Each-Right

There are two variants of Each for dyadic functions called Each-Left (\:) and Each-Right (/:). The following example explains how to use them.

q)x: 9 18 27 36

q)y:10 20 30 40

q)x,y            / join
9 18 27 36 10 20 30 40

q)x,'y           / each

9   10
18  20
27  30
36  40

q)x: 9 18 27 36

q)y:10 20 30 40

q)x,y            / join
9 18 27 36 10 20 30 40

q)x,'y           / each, will return a list of pairs

9   10
18  20
27  30
36  40

q)x, \:y         / each left, returns a list of each element
                 / from x with all of y
					  
9   10  20  30  40
18  10  20  30  40
27  10  20  30  40
36  10  20  30  40

q)x,/:y          / each right, returns a list of all the x with
                 / each element of y
					  
9  18  27  36  10
9  18  27  36  20
9  18  27  36  30
9  18  27  36  40

q)1 _x           / drop the first element
18 27 36

q)-2_y           / drop the last two element
10 20

q)               / Combine each left and each right to be a
                 / cross-product (cartesian product)
                 
q)x,/:\:y

9   10  9   20  9   30  9   40
18  10  18  20  18  30  18  40
27  10  27  20  27  30  27  40
36  10  36  20  36  30  36  40

In q language, we have different kinds of joins based on the input tables supplied and the kind of joined tables we desire. A join combines data from two tables. Besides foreign key chasing, there are four other ways to join tables −

• Simple join
• Asof join
• Left join
• Union join

Here, in this chapter, we will discuss each of these joins in detail.

Simple Join

Simple join is the most basic type of join, performed with a comma ‘,’. In this case, the two tables have to be type conformant, i.e., both the tables have the same number of columns in the same order, and same key.

table1,:table2 / table1 is assigned the value of table2

We can use comma-each join for tables with same length to join sideways. One of the tables can be keyed here,

Table1, `Table2

Asof Join (aj)

It is the most powerful join which is used to get the value of a field in one table asof the time in another table. Generally it is used to get the prevailing bid and ask at the time of each trade.

General format

aj[joinColumns;tbl1;tbl2]

For example,

aj[`sym`time;trade;quote]

Example

q)tab1:([]a:(1 2 3 4);b:(2 3 4 5);d:(6 7 8 9))

q)tab2:([]a:(2 3 4);b:(3 4 5); c:( 4 5 6))

q)show aj[`a`b;tab1;tab2]

 a  b  d  c
-------------
 1  2  6
 2  3  7  4
 3  4  8  5
 4  5  9  6

Left Join(lj)

It’s a special case of aj where the second argument is a keyed table and the first argument contains the columns of the right argument’s key.

General format

table1 lj Keyed-table

Example

q)/Left join- syntax table1 lj table2 or lj[table1;table2]

q)tab1:([]a:(1 2 3 4);b:(2 3 4 5);d:(6 7 8 9))

q)tab2:([a:(2 3 4);b:(3 4 5)]; c:( 4 5 6))

q)show lj[tab1;tab2]

 a  b  d  c
-------------
 1  2  6
 2  3  7  4
 3  4  8  5
 4  5  9  6

Union Join (uj)

It allows to create a union of two tables with distinct schemas. It is basically an extension to the simple join ( , )

q)tab1:([]a:(1 2 3 4);b:(2 3 4 5);d:(6 7 8 9))

q)tab2:([]a:(2 3 4);b:(3 4 5); c:( 4 5 6))

q)show uj[tab1;tab2]

 a  b  d  c
------------
 1  2  6
 2  3  7
 3  4  8
 4  5  9
 2  3     4
 3  4     5
 4  5     6

If you are using uj on keyed tables, then the primary keys must match.

Types of Functions

Functions can be classified in a number of ways. Here we have classified them based on the number and type of argument they take and the result type. Functions can be,

• Atomic − Where the arguments are atomic and produce atomic results

• Aggregate − atom from list

• Uniform (list from list) − Extended the concept of atom as they apply to lists. The count of the argument list equals the count of the result list.

• Other − if the function is not from the above category.

Binary operations in mathematics are called dyadic functions in q; for example, “+”. Similarly unary operations are called monadic functions; for example, “abs” or “floor”.

Frequently Used Functions

There are quite a few functions used frequently in q programming. Here, in this section, we will see the usage of some popular functions −

abs

q) abs -9.9 / Absolute value, Negates -ve number & leaves non -ve number
9.9

all

q) all 4 5 0 -4 / Logical AND (numeric min), returns the minimum value
0b

Max (&), Min (|), and Not (!)

q) /And, Or, and Logical Negation

q) 1b & 1b        / And (Max)
1b

q) 1b|0b              / Or (Min)
1b

q) not 1b             /Logical Negate (Not)
0b

asc

q)asc 1 3 5 7 -2 0 4    / Order list ascending, sorted list
                        / in ascending order i
s returned
`s#-2 0 1 3 4 5 7

q)/attr - gives the attributes of data, which describe how it's sorted.
`s denotes fully sorted, `u denotes unique and `p and `g are used to 
refer to lists with repetition, with `p standing for parted and `g for grouped

avg

q)avg 3 4 5 6 7           / Return average of a list of numeric values
5f

q)/Create on trade table

q)trade:([]time:3?(.z.Z-200);sym:3?(`ibm`msft`apple);price:3?99.0;size:3?100)

by

q)/ by - Groups rows in a table at given sym

q)select sum price by sym from trade    / find total price for each sym

  sym  |   price
------ | --------
 apple | 140.2165
  ibm  | 16.11385

cols

q)cols trade / Lists columns of a table
`time`sym`price`size

Anzahl

q)count (til 9) / Count list, count the elements in a list and
                / return a single int value 9

Hafen

q)\p 9999 / assign port number

q)/csv - This command allows queries in a browser to be exported to
   excel by prefixing the query, such as http://localhost:9999/.csv?select from trade where sym =`ibm

Schnitt

q)/ cut - Allows a table or list to be cut at a certain point

q)(1 3 5) cut "abcdefghijkl"
                            / the argument is split at 1st, 3rd and 5th letter.
"bc"
"de"
"fghijkl"

q)5 cut "abcdefghijkl"      / cut the right arg. Into 5 letters part
                            / until its end.
"abcde"
"fghij"
"kl"

Löschen

q)/delete - Delete rows/columns from a table

q)delete price from trade

          time              sym   size
---------------------------------------
  2009.06.18T06:04:42.919  apple   36
  2009.11.14T12:42:34.653   ibm    12
  2009.12.27T17:02:11.518  apple   97

Deutlich

q)/distinct - Returns the distinct element of a list

q)distinct 1 2 3 2 3 4 5 2 1 3            / generate unique set of number
1 2 3 4 5

gewinnen

q)/enlist - Creates one-item list.

q)enlist 37
,37

q)type 37           / -ve type value
-7h

q)type enlist 37    / +ve type value
7h

Fülle (^)

q)/fill - used with nulls. There are three functions for processing null values.

The dyadic function named fill replaces null values in the right argument with the atomic left argument.

q)100 ^ 3 4 0N 0N -5
3 4 100 100 -5

q)`Hello^`jack`herry``john`
`jack`herry`Hello`john`Hello

Füllt

q)/fills - fills in nulls with the previous not null value.

q)fills 1 0N 2 0N 0N 2 3 0N -5 0N
1 1 2 2 2 2 3 3 -5 -5

Zuerst

q)/first - returns the first atom of a list

q)first 1 3 34 5 3
1

Flip

q)/flip - Monadic primitive that applies to lists and associations. It interchange the top two levels of its argument.

q)trade

       time                   sym      price   size
------------------------------------------------------
  2009.06.18T06:04:42.919    apple   72.05742   36
  2009.11.14T12:42:34.653    ibm     16.11385   12
  2009.12.27T17:02:11.518    apple   68.15909   97

q)flip trade

time | 2009.06.18T06:04:42.919 2009.11.14T12:42:34.653
2009.12.27T17:02:11.518

sym   |  apple         ibm         apple
price | 72.05742     16.11385    68.15909
size  | 36 12 97

iasc

q)/iasc - Index ascending, return the indices of the ascended sorted list relative to the input list.

q)iasc 5 4 0 3 4 9

2 3 1 4 0 5

Idesc

q)/idesc - Index desceding, return the descended sorted list relative to the input list

q)idesc 0 1 3 4

3 2 1 0

im

q)/in - In a list, dyadic function used to query list (on the right-handside) about their contents.

q)(2 4) in 1 2 3

10b

einfügen

q)/insert - Insert statement, upload new data into a table.

q)insert[`trade;((.z.Z);`samsung;48.35;99)],3

q)trade

      time                  sym       price     size
------------------------------------------------------
 2009.06.18T06:04:42.919   apple    72.05742     36
 2009.11.14T12:42:34.653    ibm     16.11385     12
 2009.12.27T17:02:11.518   apple    68.15909     97
 2015.04.06T10:03:36.738   samsung  48.35        99

Schlüssel

q)/key - three different functions i.e. generate +ve integer number, gives content of a directory or key of a table/dictionary.

q)key 9

0 1 2 3 4 5 6 7 8

q)key `:c:
`$RECYCLE.BIN`Config.Msi`Documents and Settings`Drivers`Geojit`hiberfil.sys`I..

niedriger

q)/lower - Convert to lower case and floor

q)lower ("JoHn";`HERRY`SYM)
"john"
`herry`sym

Max und Min (dh | und &)

q)/Max and Min / a|b and a&b

q)9|7
9

q)9&5
5

Null

q)/null - return 1b if the atom is a null else 0b from the argument list

q)null 1 3 3 0N
0001b

Pfirsich

q)/peach - Parallel each, allows process across slaves

q)foo peach list1       / function foo applied across the slaves named in list1

'list1

q)foo:{x+27}

q)list1:(0 1 2 3 4)

q)foo peach list1       / function foo applied across the slaves named in list1
27 28 29 30 31

Zurück

q)/prev - returns the previous element i.e. pushes list forwards

q)prev 0 1 3 4 5 7

0N 0 1 3 4 5

Zufällig( ?)

q)/random - syntax - n?list, gives random sequences of ints and floats

q)9?5
0 0 4 0 3 2 2 0 1

q)3?9.9
0.2426823 1.674133 3.901671

Schleifen

q)/raze - Flattn a list of lists, removes a layer of indexing from a list of lists. for instance:

q)raze (( 12 3 4; 30 0);("hello";7 8); 1 3 4)

12 3 4
30 0
"hello"
7 8
1
3
4

read0

q)/read0 - Read in a text file

q)read0 `:c:/q/README.txt    / gives the contents of *.txt file

read1

q)/read1 - Read in a q data file

q)read1 `:c:/q/t1

0xff016200630b000500000073796d0074696d6500707269636…

umkehren

q)/reverse - Reverse a list

q)reverse 2 30 29 1 3 4

4 3 1 29 30 2

q)reverse "HelloWorld"

"dlroWolleH"

einstellen

q)/set - set value of a variable

q)`x set 9
`x

q)x
9

q)`:c:/q/test12 set trade

`:c:/q/test12

q)get `:c:/q/test12

       time                   sym      price     size
---------------------------------------------------------
  2009.06.18T06:04:42.919    apple    72.05742    36
  2009.11.14T12:42:34.653     ibm     16.11385    12
  2009.12.27T17:02:11.518    apple    68.15909    97
  2015.04.06T10:03:36.738    samsung  48.35       99
  2015.04.06T10:03:47.540    samsung  48.35       99
  2015.04.06T10:04:44.844    samsung  48.35       99

ssr

q)/ssr - String search and replace, syntax - ssr["string";searchstring;replaced-with]

q)ssr["HelloWorld";"o";"O"]

"HellOWOrld"

Zeichenfolge

q)/string - converts to string, converts all types to a string format.

q)string (1 2 3; `abc;"XYZ";0b)

(,"1";,"2";,"3")
"abc"

(,"X";,"Y";,"Z")
,"0"

SV

q)/sv - Scalar from vector, performs different tasks dependent on its arguments.

It evaluates the base representation of numbers, which allows us to calculate the number of seconds in a month or convert a length from feet and inches to centimeters.

q)24 60 60 sv 11 30 49

41449   / number of seconds elapsed in a day at 11:30:49

System

q)/system - allows a system command to be sent,

q)system "dir *.py"

" Volume in drive C is New Volume"
" Volume Serial Number is 8CD2-05B2"
""

" Directory of C:\\Users\\myaccount-raj"
""

"09/14/2014    06:32 PM     22 hello1.py"
"                1 File(s)    22 bytes"

Tabellen

q)/tables - list all tables

q)tables `

`s#`tab1`tab2`trade

Til

q)/til - Enumerate

q)til 5

0 1 2 3 4

trimmen

q)/trim - Eliminate string spaces

q)trim " John "

"John"

vs.

q)/vs - Vector from scaler , produces a vector quantity from a scaler quantity

q)"|" vs "20150204|msft|20.45"

"20150204"
"msft"
"20.45"

xasc

q)/xasc - Order table ascending, allows a table (right-hand argument) to be sorted such that (left-hand argument) is in ascending order

q)`price xasc trade

          time                 sym      price      size
----------------------------------------------------------
   2009.11.14T12:42:34.653     ibm     16.11385     12
   2015.04.06T10:03:36.738   samsung   48.35        99
   2015.04.06T10:03:47.540   samsung   48.35        99
   2015.04.06T10:04:44.844   samsung   48.35        99
   2009.12.27T17:02:11.518    apple    68.15909     97
   2009.06.18T06:04:42.919    apple    72.05742     36

xcol

q)/xcol - Renames columns of a table

q)`timeNew`symNew xcol trade

        timeNew                 symNew    price      size
-------------------------------------------------------------
   2009.06.18T06:04:42.919      apple    72.05742     36
   2009.11.14T12:42:34.653       ibm     16.11385     12
   2009.12.27T17:02:11.518      apple    68.15909     97
   2015.04.06T10:03:36.738     samsung   48.35        99
   2015.04.06T10:03:47.540     samsung   48.35        99
   2015.04.06T10:04:44.844     samsung   48.35        99

xcols

q)/xcols - Reorders the columns of a table,

q)`size`price xcols trade

  size    price           time                   sym
-----------------------------------------------------------
   36   72.05742   2009.06.18T06:04:42.919      apple 
   12   16.11385   2009.11.14T12:42:34.653       ibm
   97   68.15909   2009.12.27T17:02:11.518      apple
   99   48.35      2015.04.06T10:03:36.738     samsung 
   99   48.35      2015.04.06T10:03:47.540     samsung
   99   48.35      2015.04.06T10:04:44.844     samsung

xdesc

q)/xdesc - Order table descending, allows tables to be sorted such that the left-hand argument is in descending order.

q)`price xdesc trade

        time                   sym       price      size
-----------------------------------------------------------
   2009.06.18T06:04:42.919    apple    72.05742      36
   2009.12.27T17:02:11.518    apple    68.15909      97
   2015.04.06T10:03:36.738   samsung   48.35         99
   2015.04.06T10:03:47.540   samsung   48.35         99
   2015.04.06T10:04:44.844   samsung   48.35         99
   2009.11.14T12:42:34.653     ibm     16.11385      12

xgroup

q)/xgroup - Creates nested table

q)`x xgroup ([]x:9 18 9 18 27 9 9;y:10 20 10 20 30 40)
'length

q)`x xgroup ([]x:9 18 9 18 27 9 9;y:10 20 10 20 30 40 10)

  x  |    y
---- | -----------
  9  | 10 10 40 10
  18 | 20 20
  27 | ,30

xkey

q)/xkey - Set key on table

q)`sym xkey trade

    sym   |      time                    price     size
--------- | -----------------------------------------------
   apple  | 2009.06.18T06:04:42.919    72.05742     36
    ibm   | 2009.11.14T12:42:34.653    16.11385     12
   apple  | 2009.12.27T17:02:11.518    68.15909     97
  samsung | 2015.04.06T10:03:36.738    48.35        99
  samsung | 2015.04.06T10:03:47.540    48.35        99
  samsung | 2015.04.06T10:04:44.844    48.35        99

Systembefehle

Systembefehle steuern die qUmgebung. Sie haben die folgende Form -

\cmd [p]       where p may be optional

Einige der gängigen Systembefehle wurden unten erläutert -

\ a [Namespace] - Listet Tabellen im angegebenen Namespace auf

q)/Tables in default namespace

q)\a
,`trade

q)\a .o         / table in .o namespace.
,`TI

\ b - Abhängigkeiten anzeigen

q)/ views/dependencies

q)a:: x+y      / global assingment

q)b:: x+1

q)\b
`s#`a`b

\ B - Ausstehende Ansichten / Abhängigkeiten

q)/ Pending views/dependencies

q)a::x+1     / a depends on x

q)\B         / the dependency is pending
' / the dependency is pending

q)\B
`s#`a`b

q)\b
`s#`a`b

q)b
29

q)a
29

q)\B
`symbol$()

\ cd - Verzeichnis wechseln

q)/change directory, \cd [name]

q)\cd
"C:\\Users\\myaccount-raj"

q)\cd ../new-account

q)\cd
"C:\\Users\\new-account"

\ d - Legt den aktuellen Namespace fest

q)/ sets current namespace \d [namespace]

q)\d             /default namespace
'

q)\d .o          /change to .o

q.o)\d
`.o

q.o)\d .         / return to default

q)key `          /lists namespaces other than .z
`q`Q`h`j`o

q)\d .john       /change to non-existent namespace

q.john)\d
`.john

q.john)\d .

q)\d
`.

\ l - Datei oder Verzeichnis aus der Datenbank laden

q)/ Load file or directory, \l

q)\l test2.q / loading test2.q which is stored in current path.

   ric      |     date      ex      openP    closeP    MCap
----------- | -------------------------------------------------
 JPMORGAN   | 2008.05.23  SENSEX  18.30185  17.16319  17876
   HSBC     | 2002.05.21  NIFTY   2.696749  16.58846  26559
 JPMORGAN   | 2006.09.07  NIFTY   14.15219  20.05624  14557
   HSBC     | 2010.10.11  SENSEX  7.394497  25.45859  29366
 JPMORGAN   | 2007.10.02  SENSEX  1.558085  25.61478  20390
 
   ric     |    date       ex      openP     closeP    MCap
---------- | ------------------------------------------------
  INFOSYS  | 2003.10.30    DOW    21.2342   7.565652   2375
 RELIANCE  | 2004.08.12    DOW    12.34132  17.68381   4201
   SBIN    | 2008.02.14    DOW    1.830857  9.006485   15465
  INFOSYS  | 2009.06.11  HENSENG  19.47664  12.05208   11143
   SBIN    | 2010.07.05    DOW    18.55637  10.54082   15873

\ p - Portnummer

q)/ assign port number, \p

q)\p
5001i

q)\p 8888

q)\p
8888i

\\ - Beenden Sie die q-Konsole

\\ - exit
Exit form q.

Das qDie Programmiersprache verfügt über eine Reihe von umfangreichen und leistungsstarken integrierten Funktionen. Es gibt folgende Arten von integrierten Funktionen:

• String function - Nimmt eine Zeichenfolge als Eingabe und gibt eine Zeichenfolge zurück.

• Aggregate function - Nimmt eine Liste als Eingabe und gibt ein Atom zurück.

• Uniform function - Nimmt eine Liste und gibt eine Liste mit der gleichen Anzahl zurück.

• Mathematical function - Nimmt ein numerisches Argument und gibt ein numerisches Argument zurück.

• Miscellaneous function - Alle Funktionen außer den oben genannten.

String-Funktionen

Like - Pattern Matching

q)/like is a dyadic, performs pattern matching, return 1b on success else 0b

q)"John" like "J??n"
1b

q)"John My Name" like "J*"
1b

ltrim - Entfernt führende Leerzeichen

q)/ ltrim - monadic ltrim takes string argument, removes leading blanks

q)ltrim " Rick "
"Rick "

rtrim - Entfernt nachgestellte Leerzeichen

q)/rtrim - takes string argument, returns the result of removing trailing blanks

q)rtrim " Rick "
" Rick"

ss - String-Suche

q)/ss - string search, perform pattern matching, same as "like" but return the indices of the matches of the pattern in source.

q)"Life is beautiful" ss "i"
1 5 13

trimmen - Entfernt führende und nachfolgende Leerzeichen

q)/trim - takes string argument, returns the result of removing leading & trailing blanks

q)trim " John "
"John"

Mathematische Funktionen

acos - invers von cos

q)/acos - inverse of cos, for input between -1 and 1, return float between 0 and pi

q)acos 1
0f

q)acos -1
3.141593

q)acos 0
1.570796

gibt Korrelation

q)/cor - the dyadic takes two numeric lists of same count, returns a correlation between the items of the two arguments

q)27 18 18 9 0 cor 27 36 45 54 63
-0.9707253

Kreuz - kartesisches Produkt

q)/cross - takes atoms or lists as arguments and returns their Cartesian product

q)9 18 cross `x`y`z

9 `x
9 `y
9 `z

18 `x
18 `y
18 `z

var - Varianz

q)/var - monadic, takes a scaler or numeric list and returns a float equal to the mathematical variance of the items

q)var 45
0f

q)var 9 18 27 36
101.25

wavg

q)/wavg - dyadic, takes two numeric lists of the same count and returns the average of the second argument weighted by the first argument.

q)1 2 3 4 wavg 200 300 400 500
400f

Aggregierte Funktionen

alles - & Betrieb

q)/all - monadic, takes a scaler or list of numeric type and returns the result of & applied across the items.

q)all 0b
0b

q)all 9 18 27 36
1b

q)all 10 20 30
1b

Beliebig - | Betrieb

q)/any - monadic, takes scaler or list of numeric type and the return the result of | applied across the items

q)any 20 30 40 50
1b

q)any 20012.02.12 2013.03.11
'20012.02.12

prd - arithmetisches Produkt

q)/prd - monadic, takes scaler, list, dictionary or table of numeric type and returns the arithmetic product.

q)prd `x`y`z! 10 20 30
6000

q)prd ((1 2; 3 4);(10 20; 30 40))

10 40
90 160

Summe - arithmetische Summe

q)/sum - monadic, takes a scaler, list,dictionary or table of numeric type and returns the arithmetic sum.

q)sum 2 3 4 5 6
20

q)sum (1 2; 4 5)
5 7

Einheitliche Funktionen

Deltas - Unterschied zum vorherigen Artikel.

q)/deltas -takes a scalar, list, dictionary or table and returns the difference of each item from its predecessor.

q)deltas 2 3 5 7 9
2 1 2 2 2

q)deltas `x`y`z!9 18 27

x | 9
y | 9
z | 9

füllt - füllt den Nullwert

q)/fills - takes scalar, list, dictionary or table of numeric type and returns a c copy of the source in which non-null items are propagated forward to fill nulls

q)fills 1 0N 2 0N 4
1 1 2 2 4

q)fills `a`b`c`d! 10 0N 30 0N

a | 10
b | 10
c | 30
d | 30

maxs - kumulatives Maximum

q)/maxs - takes scalar, list, dictionary or table and returns the cumulative maximum of the source items.

q)maxs 1 2 4 3 9 13 2
1 2 4 4 9 13 13

q)maxs `a`b`c`d!9 18 0 36

a | 9
b | 18
c | 18
d | 36

Verschiedene Funktionen

Count - Gibt die Nummer des Elements zurück

q)/count - returns the number of entities in its argument.

q)count 10 30 30
3

q)count (til 9)
9

q)count ([]a:9 18 27;b:1.1 2.2 3.3)
3

Distinct - Gibt verschiedene Entitäten zurück

q)/distinct - monadic, returns the distinct entities in its argument

q)distinct 1 2 3 4 2 3 4 5 6 9
1 2 3 4 5 6 9

Außer - Element im zweiten Argument nicht vorhanden.

q)/except - takes a simple list (target) as its first argument and returns a list containing the items of target that are not in its second argument

q)1 2 3 4 3 1 except 1
2 3 4 3

fill - fülle null mit dem ersten Argument

q)/fill (^) - takes an atom as its first argument and a list(target) as its second argument and return a list obtained by substituting the first argument for every occurrence of null in target

q)42^ 9 18 0N 27 0N 36
9 18 42 27 42 36

q)";"^"Life is Beautiful"
"Life;is;Beautiful"

Abfragen in qsind kürzer und einfacher und erweitern die Fähigkeiten von SQL. Der Hauptabfrageausdruck ist der 'Auswahlausdruck', der in seiner einfachsten Form Untertabellen extrahiert, aber auch neue Spalten erstellen kann.

Die allgemeine Form von a Select expression ist wie folgt -

Select columns by columns from table where conditions

**Note − by & where Phrasen sind optional, nur der 'from-Ausdruck' ist obligatorisch.

Im Allgemeinen lautet die Syntax -

select [a] [by b] from t [where c]
update [a] [by b] from t [where c]

Die Syntax von q Ausdrücke sehen SQL ziemlich ähnlich, aber qAusdrücke sind einfach und mächtig. Ein äquivalenter SQL-Ausdruck für das oben Gesagteq Ausdruck wäre wie folgt -

select [b] [a] from t [where c] [group by b order by b]
update t set [a] [where c]

Alle Klauseln werden für die Spalten und daher ausgeführt qkann die Bestellung nutzen. Da SQL-Abfragen nicht auf der Reihenfolge basieren, können sie diesen Vorteil nicht nutzen.

qrelationale Abfragen sind im Allgemeinen viel kleiner als die entsprechenden SQL-Abfragen. Geordnete und funktionale Abfragen erledigen Dinge, die in SQL schwierig sind.

In einer historischen Datenbank ist die Reihenfolge der whereKlausel ist sehr wichtig, da sie die Leistung der Abfrage beeinflusst. Daspartition Die Variable (Datum / Monat / Tag) steht immer an erster Stelle, gefolgt von der sortierten und indizierten Spalte (im Allgemeinen der Sym-Spalte).

Zum Beispiel,

select from table where date in d, sym in s

ist viel schneller als,

select from table where sym in s, date in d

Grundlegende Abfragen

Schreiben wir ein Abfrageskript in den Editor (wie unten), speichern (als * .q) und laden es dann.

sym:asc`AIG`CITI`CSCO`IBM`MSFT;
ex:"NASDAQ"
dst:`$":c:/q/test/data/"; /database destination @[dst;`sym;:;sym]; n:1000000; trade:([]sym:n?`sym;time:10:30:00.0+til n;price:n?3.3e;size:n?9;ex:n?ex); quote:([]sym:n?`sym;time:10:30:00.0+til n;bid:n?3.3e;ask:n?3.3e;bsize:n?9;asize:n?9;ex:n?ex); {@[;`sym;`p#]`sym xasc x}each`trade`quote; d:2014.08.07 2014.08.08 2014.08.09 2014.08.10 2014.08.11; /Date vector can also be changed by the user dt:{[d;t].[dst;(`$string d;t;`);:;value t]};
d dt/:\:`trade`quote;

Note: Once you run this query, two folders .i.e. "test" and "data" will be created under "c:/q/", and date partition data can be seen inside data folder.

Abfragen mit Einschränkungen

* Denotes HDB query

Select all IBM trades

select from trade where sym in `IBM

*Select all IBM trades on a certain day

thisday: 2014.08.11
select from trade where date=thisday,sym=`IBM

Select all IBM trades with a price > 100

select from trade where sym=`IBM, price > 100.0

Select all IBM trades with a price less than or equal to 100

select from trade where sym=`IBM,not price > 100.0

*Select all IBM trades between 10.30 and 10.40, in the morning, on a certain date

thisday: 2014.08.11
select from trade where
date = thisday, sym = `IBM, time > 10:30:00.000,time < 10:40:00.000

Select all IBM trades in ascending order of price

`price xasc select from trade where sym =`IBM

*Select all IBM trades in descending order of price in a certain time frame

`price xdesc select from trade where date within 2014.08.07 2014.08.11, sym =`IBM

Composite sort − sort ascending order by sym and then sort the result in descending order of price

`sym xasc `price xdesc select from trade where date = 2014.08.07,size = 5

Select all IBM or MSFT trades

select from trade where sym in `IBM`MSFT

*Calculate count of all symbols in ascending order within a certain time frame

`numsym xasc select numsym: count i by sym from trade where date within 2014.08.07 2014.08.11

*Calculate count of all symbols in descending order within a certain time frame

`numsym xdesc select numsym: count i by sym from trade where date within 2014.08.07 2014.08.11

* What is the maximum price of IBM stock within a certain time frame, and when does this first happen?

select time,ask from quote where date within 2014.08.07 2014.08.11,
sym =`IBM, ask = exec first ask from select max ask from quote where
sym =`IBM

Select the last price for each sym in hourly buckets

select last price by hour:time.hh, sym from trade

Abfragen mit Aggregationen

* Calculate vwap (Volume Weighted Average Price) of all symbols

select vwap:size wavg price by sym from trade

* Count the number of records (in millions) for a certain month

(select trade:1e-6*count i by date.dd from trade where date.month=2014.08m) + select quote:1e-6*count i by date.dd from quote where date.month=2014.08m

* HLOC – Daily High, Low, Open and Close for CSCO in a certain month

select high:max price,low:min price,open:first price,close:last price by date.dd from trade where date.month=2014.08m,sym =`CSCO

* Daily Vwap for CSCO in a certain month

select vwap:size wavg price by date.dd from trade where date.month = 2014.08m ,sym = `CSCO

* Calculate the hourly mean, variance and standard deviation of the price for AIG

select mean:avg price, variance:var price, stdDev:dev price by date, hour:time.hh from trade where sym = `AIG

Select the price range in hourly buckets

select range:max[price] – min price by date,sym,hour:time.hh from trade

* Daily Spread (average bid-ask) for CSCO in a certain month

select spread:avg bid-ask by date.dd from quote where date.month = 2014.08m, sym = `CSCO

* Daily Traded Values for all syms in a certain month

select dtv:sum size by date,sym from trade where date.month = 2014.08m

Extract a 5 minute vwap for CSCO

select size wavg price by 5 xbar time.minute from trade where sym = `CSCO

* Extract 10 minute bars for CSCO

select high:max price,low:min price,close:last price by date, 10 xbar time.minute from trade where sym = `CSCO

* Find the times when the price exceeds 100 basis points (100e-4) over the last price for CSCO for a certain day

select time from trade where date = 2014.08.11,sym = `CSCO,price > 1.01*last price

* Full Day Price and Volume for MSFT in 1 Minute Intervals for the last date in the database

select last price,last size by time.minute from trade where date = last date, sym = `MSFT

Mit KDB + kann ein Prozess über Interprozesskommunikation mit einem anderen Prozess kommunizieren. Kdb + -Prozesse können eine Verbindung zu jedem anderen kdb + auf demselben Computer, demselben Netzwerk oder sogar remote herstellen. Wir müssen nur den Port angeben, und dann können die Clients mit diesem Port kommunizieren. Irgendeinq Prozess kann mit jedem anderen kommunizieren q Prozess, solange es im Netzwerk zugänglich ist und auf Verbindungen wartet.

• Ein Serverprozess wartet auf Verbindungen und verarbeitet alle Anforderungen

• Ein Client-Prozess initiiert die Verbindung und sendet auszuführende Befehle

Client und Server können sich auf demselben Computer oder auf verschiedenen Computern befinden. Ein Prozess kann sowohl ein Client als auch ein Server sein.

Eine Kommunikation kann sein,

• Synchronous (Warten Sie, bis ein Ergebnis zurückgegeben wird.)

• Asynchronous (kein Warten und kein Ergebnis zurückgegeben)

Server initialisieren

EIN q Der Server wird initialisiert, indem der Port angegeben wird, der abgehört werden soll.

q –p 5001 / command line
\p 5001   / session command

Kommunikationsgriff

Ein Kommunikationshandle ist ein Symbol, das mit „:“ beginnt und die Form - hat.

`:[server]:port-number

Beispiel

`::5001              / server and client on same machine
`:jack:5001          / server on machine jack
`:192.168.0.156      / server on specific IP address
`:www.myfx.com:5001  / server at www.myfx.com

Um die Verbindung zu starten, verwenden wir die Funktion "hopen", die ein ganzzahliges Verbindungshandle zurückgibt. Dieses Handle wird für alle nachfolgenden Clientanforderungen verwendet. Zum Beispiel -

q)h:hopen `::5001

q)h"til 5"
0 1 2 3 4

q)hclose h

Synchrone und asynchrone Nachrichten

Sobald wir ein Handle haben, können wir eine Nachricht entweder synchron oder asynchron senden.

Synchronous Message- Sobald eine Nachricht gesendet wurde, wartet sie weiter und gibt das Ergebnis zurück. Sein Format ist wie folgt -

handle “message”

Asynchronous Message- Beginnen Sie nach dem Senden einer Nachricht sofort mit der Verarbeitung der nächsten Anweisung, ohne warten zu müssen und ein Ergebnis zurückzugeben. Sein Format ist wie folgt -

neg[handle] “message”

Nachrichten, die eine Antwort erfordern, z. B. Funktionsaufrufe oder Select-Anweisungen, verwenden normalerweise die synchrone Form. Nachrichten, die keine Ausgabe zurückgeben müssen, z. B. das Einfügen von Aktualisierungen in eine Tabelle, sind asynchron.

Wenn ein q Prozess verbindet sich mit einem anderen qProzess über prozessübergreifende Kommunikation, wird von Nachrichtenhandlern verarbeitet. Diese Nachrichtenhandler haben ein Standardverhalten. Beispielsweise gibt der Handler bei synchroner Nachrichtenbehandlung den Wert der Abfrage zurück. Der synchrone Handler ist in diesem Fall.z.pg, die wir je nach Anforderung überschreiben könnten.

Kdb + -Prozesse verfügen über mehrere vordefinierte Nachrichtenhandler. Nachrichtenhandler sind wichtig für die Konfiguration der Datenbank. Einige der Verwendungen umfassen -

• Logging - Protokollieren Sie eingehende Nachrichten (hilfreich bei schwerwiegenden Fehlern),

• Security- Zulassen / Verbieten des Zugriffs auf die Datenbank, bestimmte Funktionsaufrufe usw. basierend auf Benutzername / IP-Adresse. Es hilft dabei, nur autorisierten Abonnenten Zugriff zu gewähren.

• Handle connections/disconnections von anderen Prozessen.

Vordefinierte Nachrichtenhandler

Einige der vordefinierten Nachrichtenhandler werden unten erläutert.

.z.pg

Es ist ein synchroner Nachrichtenhandler (Process Get). Diese Funktion wird automatisch aufgerufen, wenn eine Synchronisierungsnachricht auf einer kdb + -Instanz empfangen wird.

Parameter ist der auszuführende String- / Funktionsaufruf, dh die übergebene Nachricht. Standardmäßig ist es wie folgt definiert:

.z.pg: {value x}                / simply execute the message 
                                received but we can overwrite it to
give any customized result.
.z.pg : {handle::.z.w;value x}  / this will store the remote handle
.z.pg : {show .z.w;value x}     / this will show the remote handle

.z.ps

Es ist ein asynchroner Nachrichtenhandler (Prozesssatz). Dies ist der entsprechende Handler für asynchrone Nachrichten. Parameter ist der auszuführende String / Funktionsaufruf. Standardmäßig ist es definiert als:

.z.pg : {value x}        / Can be overriden for a customized action.

Im Folgenden finden Sie den benutzerdefinierten Nachrichtenhandler für asynchrone Nachrichten, bei dem wir die geschützte Ausführung verwendet haben.

.z.pg: {@[value; x; errhandler x]}

Hier errhandler ist eine Funktion, die im Falle eines unerwarteten Fehlers verwendet wird.

.z.po []

Es ist ein Handler für offene Verbindungen (Prozess offen). Es wird ausgeführt, wenn ein Remote-Prozess eine Verbindung herstellt. Um das Handle zu sehen, wenn eine Verbindung zu einem Prozess geöffnet wird, können Sie die .z.po wie folgt definieren:

.z.po : {Show “Connection opened by” , string h: .z.h}

.z.pc []

Es ist ein Handler für enge Verbindungen (Prozessabschluss). Es wird aufgerufen, wenn eine Verbindung geschlossen wird. Wir können unseren eigenen Close-Handler erstellen, der das globale Verbindungshandle auf 0 zurücksetzen und einen Befehl ausgeben kann, mit dem der Timer alle 3 Sekunden (3000 Millisekunden) ausgelöst (ausgeführt) wird.

.z.pc : { h::0; value “\\t 3000”}

Der Timer-Handler (.z.ts) versucht, die Verbindung erneut zu öffnen. Bei Erfolg wird der Timer ausgeschaltet.

.z.ts : { h:: hopen `::5001; if [h>0; value “\\t 0”] }

.z.pi []

PI steht für Process Input. Es wird für jede Art von Eingabe aufgerufen. Es kann zur Verarbeitung von Konsoleneingaben oder Remote-Client-Eingaben verwendet werden. Mit .z.pi [] kann die Konsoleneingabe überprüft oder die Standardanzeige ersetzt werden. Darüber hinaus kann es für jede Art von Protokollierungsvorgängen verwendet werden.

q).z.pi
'.z.pi

q).z.pi:{">", .Q.s value x}

q)5+4
>9

q)30+42
>72

q)30*2
>60

q)\x .z.pi
>q)

q)5+4
9

.z.pw

Es ist ein Validierungsverbindungshandler (Benutzerauthentifizierung). Es wird ein zusätzlicher Rückruf hinzugefügt, wenn eine Verbindung zu einer kdb + -Sitzung geöffnet wird. Es wird nach den –u / -U-Überprüfungen und vor der .z.po (Port offen) aufgerufen.

.z.pw : {[user_id;passwd] 1b}

Eingänge sind userid (Symbol) und password (Text).

Auf Listen, Wörterbücher oder Spalten einer Tabelle können Attribute angewendet werden. Attribute legen der Liste bestimmte Eigenschaften auf. Einige Attribute verschwinden möglicherweise bei Änderungen.

Arten von Attributen

Sortiert (`s #)

`s # bedeutet, dass die Liste in aufsteigender Reihenfolge sortiert ist. Wenn eine Liste explizit nach asc (oder xasc) sortiert ist, wird für die Liste automatisch das sortierte Attribut festgelegt.

q)L1: asc 40 30 20 50 9 4

q)L1
`s#4 9 20 30 40 50

Für eine Liste, von der bekannt ist, dass sie sortiert ist, kann das Attribut auch explizit festgelegt werden. Q prüft, ob die Liste sortiert ist, und wenn nicht, an s-fail Fehler wird ausgelöst.

q)L2:30 40 24 30 2

q)`s#L2
's-fail

Das sortierte Attribut geht bei einem unsortierten Anhängen verloren.

Getrennt (`p #)

`p # bedeutet, dass die Liste geteilt ist und identische Elemente zusammenhängend gespeichert werden.

Der Bereich ist ein int oder temporal type mit einem zugrunde liegenden int-Wert, wie z. B. Jahre, Monate, Tage usw. Sie können auch über ein Symbol partitionieren, sofern es aufgelistet ist.

Durch Anwenden des Attributs parted wird ein Indexwörterbuch erstellt, das jeden eindeutigen Ausgabewert der Position seines ersten Auftretens zuordnet. Wenn eine Liste getrennt wird, ist die Suche viel schneller, da die lineare Suche durch die Suche nach Hashtabellen ersetzt wird.

q)L:`p# 99 88 77 1 2 3

q)L
`p#99 88 77 1 2 3

q)L,:3

q)L
99 88 77 1 2 3 3

Note −

• Das parted-Attribut wird unter einer Operation in der Liste nicht beibehalten, selbst wenn die Operation die Partitionierung beibehält.

• Das geteilte Attribut sollte berücksichtigt werden, wenn die Anzahl der Entitäten eine Milliarde erreicht und die meisten Partitionen eine beträchtliche Größe haben, dh es gibt signifikante Wiederholungen.

Gruppiert (`g #)

`g # bedeutet, dass die Liste gruppiert ist. Es wird ein internes Wörterbuch erstellt und verwaltet, das jedes einzelne Element jedem seiner Indizes zuordnet, was erheblichen Speicherplatz erfordert. Für eine Liste der LängeL enthält u einzigartige Gegenstände der Größe s, Das wird sein (L × 4) + (u × s) Bytes.

Die Gruppierung kann auf eine Liste angewendet werden, wenn keine anderen Annahmen über ihre Struktur getroffen werden können.

Das Attribut kann auf alle typisierten Listen angewendet werden. Es wird beim Anhängen beibehalten, geht jedoch beim Löschen verloren.

q)L: `g# 1 2 3 4 5 4 2 3 1 4 5 6

q)L
`g#1 2 3 4 5 4 2 3 1 4 5 6

q)L,:9

q)L
`g#1 2 3 4 5 4 2 3 1 4 5 6 9

q)L _:2

q)L
1 2 4 5 4 2 3 1 4 5 6 9

Einzigartig (`#u)

Das Anwenden des eindeutigen Attributs (`u #) auf eine Liste zeigt an, dass die Elemente der Liste unterschiedlich sind. Zu wissen, dass die Elemente einer Liste einzigartig sind, beschleunigt sich dramatischdistinct und erlaubt q einige Vergleiche frühzeitig durchzuführen.

Wenn eine Liste als eindeutig gekennzeichnet ist, wird für jedes Element in der Liste eine interne Hash-Zuordnung erstellt. Operationen in der Liste müssen die Eindeutigkeit bewahren, sonst geht das Attribut verloren.

q)LU:`u#`MSFT`SAMSUNG`APPLE

q)LU
`u#`MSFT`SAMSUNG`APPLE

q)LU,:`IBM                        /Uniqueness preserved

q)LU
`u#`MSFT`SAMSUNG`APPLE`IBM

q)LU,:`SAMSUNG                    / Attribute lost

q)LU
`MSFT`SAMSUNG`APPLE`IBM`SAMSUNG

Note −

• `u # bleibt bei Verkettungen erhalten, die die Einzigartigkeit bewahren. Es geht bei Löschungen und nicht eindeutigen Verkettungen verloren.

• Die Suche in U-Listen erfolgt über eine Hash-Funktion.

Attribute entfernen

Attribute können durch Anwenden von `# entfernt werden.

Attribute anwenden

Drei Formate zum Anwenden von Attributen sind:

• L: `s# 14 2 3 3 9/ Während der Listenerstellung angeben

• @[ `.; `L ; `s#]/ Funktional anwenden, dh auf die Variablenliste L.

  / im Standard-Namespace (dh `.) gelten

  / das # Attribut des sortierten `s

• Update `s#time from `tab

  / Aktualisieren Sie die Tabelle (Registerkarte), um die anzuwenden

  / Attribut.

Wenden wir die obigen drei verschiedenen Formate mit Beispielen an.

q)/ set the attribute during creation

q)L:`s# 3 4 9 10 23 84 90

q)/apply the attribute to existing list data

q)L1: 9 18 27 36 42 54

q)@[`.;`L1;`s#]
`.

q)L1                 / check
`s#9 18 27 36 42 54

q)@[`.;`L1;`#]       / clear attribute
`.

q)L1
9 18 27 36 42 54

q)/update a table to apply the attribute

q)t: ([] sym:`ibm`msft`samsung; mcap:9000 18000 27000)

q)t:([]time:09:00 09:30 10:00t;sym:`ibm`msft`samsung; mcap:9000 18000 27000)

q)t

    time         sym    mcap
---------------------------------
  09:00:00.000   ibm    9000
  09:30:00.000   msft   18000
  10:00:00.000  samsung 27000

q)update `s#time from `t
`t

q)meta t               / check it was applied

    c  | t f a
------ | -----
  time | t s
  sym  | s
  mcap | j
  
Above we can see that the attribute column in meta table results shows the time column is sorted (`s#).

Funktionale (dynamische) Abfragen ermöglichen die Angabe von Spaltennamen als Symbole für typische q-sql-Spalten zum Auswählen / Ausführen / Löschen. Es ist sehr praktisch, wenn wir Spaltennamen dynamisch angeben möchten.

Die funktionalen Formen sind -

?[t;c;b;a]    / for select
![t;c;b;a]    / for update

wo

• t ist ein Tisch;

• a ist ein Wörterbuch der Aggregate;

• bder Nebensatz; und

• c ist eine Liste von Einschränkungen.

Hinweis -

• Alle q Entitäten in a, b, und c muss durch den Namen referenziert werden, dh als Symbole, die die Entitätsnamen enthalten.

• Die syntaktischen Formen von Auswahl und Aktualisierung werden von der in ihre entsprechenden Funktionsformen analysiert q Dolmetscher, so dass es keinen Leistungsunterschied zwischen den beiden Formen gibt.

Funktionsauswahl

Der folgende Codeblock zeigt die Verwendung functional select - -

q)t:([]n:`ibm`msft`samsung`apple;p:40 38 45 54)

q)t

    n       p
-------------------
   ibm     40
   msft    38
 samsung   45
  apple    54

q)select m:max p,s:sum p by name:n from t where p>36, n in `ibm`msft`apple

  name |   m   s
------ | ---------
 apple |  54  54
 ibm   |  40  40
 msft  |  38  38

Beispiel 1

Beginnen wir mit dem einfachsten Fall, der funktionalen Version von “select from t” wird aussehen wie -

q)?[t;();0b;()]     / select from t

    n      p
-----------------
   ibm    40
   msft   38
 samsung  45
  apple   54

Beispiel 2

Im folgenden Beispiel verwenden wir die Enlist-Funktion, um Singletons zu erstellen, um sicherzustellen, dass die entsprechenden Entitäten Listen sind.

q)wherecon: enlist (>;`p;40)

q)?[`t;wherecon;0b;()] / select from t where p > 40

    n      p
----------------
 samsung  45
  apple   54

Beispiel 3

q)groupby: enlist[`p] ! enlist `p

q)selcols: enlist [`n]!enlist `n

q)?[ `t;(); groupby;selcols]        / select n by p from t

   p  |    n
----- | -------
  38  |  msft
  40  |  ibm
  45  | samsung
  54  | apple

Functional Exec

Die funktionale Form von exec ist eine vereinfachte Form von select.

q)?[t;();();`n]                / exec n from t (functional form of exec)
`ibm`msft`samsung`apple

q)?[t;();`n;`p]                / exec p by n from t (functional exec)

apple   | 54
ibm     | 40
msft    | 38
samsung | 45

Funktionsaktualisierung

Die funktionale Form der Aktualisierung ist völlig analog zu der von select. Im folgenden Beispiel werden mit enlist Singletons erstellt, um sicherzustellen, dass Eingabeentitäten Listen sind.

q)c:enlist (>;`p;0)

q)b: (enlist `n)!enlist `n

q)a: (enlist `p) ! enlist (max;`p)

q)![t;c;b;a]

   n      p
-------------
  ibm    40
  msft   38
 samsung 45
 apple   54

Funktionelles Löschen

Das funktionale Löschen ist eine vereinfachte Form der funktionalen Aktualisierung. Die Syntax lautet wie folgt:

![t;c;0b;a]        / t is a table, c is a list of where constraints, a is a
                   / list of column names

Nehmen wir nun ein Beispiel, um zu zeigen, wie funktionales Löschen funktioniert -

q)![t; enlist (=;`p; 40); 0b;`symbol$()]
                                          / delete from t where p = 40
   n       p
---------------
  msft    38
 samsung  45
  apple   54

In diesem Kapitel lernen wir, wie man Wörterbücher und dann Tabellen bearbeitet. Beginnen wir mit Wörterbüchern -

q)d:`u`v`x`y`z! 9 18 27 36 45                  / Creating a dictionary d

q)/ key of this dictionary (d) is given by

q)key d
`u`v`x`y`z

q)/and the value by

q)value d
9 18 27 36 45

q)/a specific value

q)d`x
27

q)d[`x]
27

q)/values can be manipulated by using the arithmetic operator +-*% as,

q)45 + d[`x`y]
72 81

Wenn man die Wörterbuchwerte ändern muss, kann die Änderungsformulierung sein -

q)@[`d;`z;*;9]
`d

q)d

u | 9
v | 18
x | 27
y | 36

q)/Example, table tab

q)tab:([]sym:`;time:0#0nt;price:0n;size:0N)

q)n:10;sym:`IBM`SAMSUNG`APPLE`MSFT

q)insert[`tab;(n?sym;("t"$.z.Z);n?100.0;n?100)]
0 1 2 3 4 5 6 7 8 9

q)`time xasc `tab
`tab

q)/ to get particular column from table tab

q)tab[`size]
12 10 1 90 73 90 43 90 84 63

q)tab[`size]+9
21 19 10 99 82 99 52 99 93 72

z | 405

q)/Example table tab

q)tab:([]sym:`;time:0#0nt;price:0n;size:0N)

q)n:10;sym:`IBM`SAMSUNG`APPLE`MSFT

q)insert[`tab;(n?sym;("t"$.z.Z);n?100.0;n?100)] 0 1 2 3 4 5 6 7 8 9 q)`time xasc `tab `tab q)/ to get particular column from table tab q)tab[`size] 12 10 1 90 73 90 43 90 84 63 q)tab[`size]+9 21 19 10 99 82 99 52 99 93 72 q)/Example table tab q)tab:([]sym:`;time:0#0nt;price:0n;size:0N) q)n:10;sym:`IBM`SAMSUNG`APPLE`MSFT q)insert[`tab;(n?sym;("t"$.z.Z);n?100.0;n?100)]
0 1 2 3 4 5 6 7 8 9

q)`time xasc `tab
`tab

q)/ to get particular column from table tab

q)tab[`size]
12 10 1 90 73 90 43 90 84 63

q)tab[`size]+9
21 19 10 99 82 99 52 99 93 72

q)/We can also use the @ amend too

q)@[tab;`price;-;2]

   sym      time           price     size
--------------------------------------------
  APPLE   11:16:39.779   6.388858     12
  MSFT    11:16:39.779   17.59907     10
  IBM     11:16:39.779   35.5638      1
 SAMSUNG  11:16:39.779   59.37452     90
  APPLE   11:16:39.779   50.94808     73
 SAMSUNG  11:16:39.779   67.16099     90
  APPLE   11:16:39.779   20.96615     43
 SAMSUNG  11:16:39.779   67.19531     90
  IBM     11:16:39.779   45.07883     84
  IBM     11:16:39.779   61.46716     63

q)/if the table is keyed

q)tab1:`sym xkey tab[0 1 2 3 4]

q)tab1

   sym    |   time          price     size
--------- | ----------------------------------
  APPLE   | 11:16:39.779   8.388858    12
  MSFT    | 11:16:39.779   19.59907    10
  IBM     | 11:16:39.779   37.5638     1
 SAMSUNG  | 11:16:39.779   61.37452    90
  APPLE   | 11:16:39.779   52.94808    73

q)/To work on specific column, try this

q){tab1[x]`size} each sym
1 90 12 10

q)(0!tab1)`size
12 10 1 90 73

q)/once we got unkeyed table, manipulation is easy

q)2+ (0!tab1)`size
14 12 3 92 75

Daten auf Ihrer Festplatte (auch als historische Datenbank bezeichnet) können in drei verschiedenen Formaten gespeichert werden: Flat Files, Splayed Tables und Partitioned Tables. Hier erfahren Sie, wie Sie diese drei Formate zum Speichern von Daten verwenden.

Flatfile

Flache Dateien werden vollständig in den Speicher geladen, weshalb ihre Größe (Speicherbedarf) gering sein sollte. Tabellen werden vollständig in einer Datei auf der Festplatte gespeichert (daher spielt die Größe eine Rolle).

Die Funktionen zum Bearbeiten dieser Tabellen sind set/get - -

`:path_to_file/filename set tablename

Nehmen wir ein Beispiel, um zu demonstrieren, wie es funktioniert -

q)tables `.
`s#`t`tab`tab1 

q)`:c:/q/w32/tab1_test set tab1
`:c:/q/w32/tab1_test

In einer Windows-Umgebung werden Flatfiles am Speicherort gespeichert. C:\q\w32

Holen Sie sich die Flatfile von Ihrer Festplatte (historische Datenbank) und verwenden Sie die get Befehl wie folgt -

q)tab2: get `:c:/q/w32/tab1_test

q)tab2

   sym    |   time           price   size
--------- | -------------------------------
  APPLE   | 11:16:39.779   8.388858   12
  MSFT    | 11:16:39.779   19.59907   10
  IBM     | 11:16:39.779   37.5638    1
 SAMSUNG  | 11:16:39.779   61.37452   90
  APPLE   | 11:16:39.779   52.94808   73

Eine neue Tabelle wird erstellt tab2 mit seinem Inhalt gespeichert in tab1_test Datei.

Gespielte Tische

Wenn eine Tabelle zu viele Spalten enthält, speichern wir solche Tabellen im gespreizten Format, dh wir speichern sie auf der Festplatte in einem Verzeichnis. Innerhalb des Verzeichnisses wird jede Spalte in einer separaten Datei unter demselben Namen wie der Spaltenname gespeichert. Jede Spalte wird als Liste des entsprechenden Typs in einer kdb + -Binärdatei gespeichert.

Das Speichern einer Tabelle im gespreizten Format ist sehr nützlich, wenn nur wenige Spalten aus den vielen Spalten häufig aufgerufen werden müssen. Ein gespreiztes Tabellenverzeichnis enthält.d Binärdatei, die die Reihenfolge der Spalten enthält.

Ähnlich wie bei einer Flatfile kann eine Tabelle mithilfe der Datei als gespreizt gespeichert werden setBefehl. Um eine Tabelle als gespreizt zu speichern, sollte der Dateipfad mit einem Spiel enden -

`:path_to_filename/filename/ set tablename

Zum Lesen einer gespreizten Tabelle können wir die verwenden get Funktion -

tablename: get `:path_to_file/filename

Note - Damit eine Tabelle als gespreizt gespeichert werden kann, muss sie nicht verschlüsselt und aufgelistet sein.

In der Windows-Umgebung wird Ihre Dateistruktur wie folgt angezeigt:

Partitionierte Tabellen

Partitionierte Tabellen bieten eine effiziente Möglichkeit, große Tabellen mit erheblichen Datenmengen zu verwalten. Partitionierte Tabellen sind gespreizte Tabellen, die auf mehrere Partitionen (Verzeichnisse) verteilt sind.

Innerhalb jeder Partition verfügt eine Tabelle über ein eigenes Verzeichnis mit der Struktur einer gespreizten Tabelle. Die Tabellen können nach Tag / Monat / Jahr aufgeteilt werden, um einen optimierten Zugriff auf den Inhalt zu ermöglichen.

Verwenden Sie den folgenden Codeblock, um den Inhalt einer partitionierten Tabelle abzurufen:

q)get `:c:/q/data/2000.01.13              // “get” command used, sample folder

quote| +`sym`time`bid`ask`bsize`asize`ex!(`p#`sym!0 0 0 0 0 0 0 0 0 0 0
0 0 0….

trade| +`sym`time`price`size`ex!(`p#`sym!0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 ….

Lassen Sie uns versuchen, den Inhalt einer Handelstabelle zu erhalten -

q)get `:c:/q/data/2000.01.13/trade

   sym    time            price     size    ex
--------------------------------------------------
    0   09:30:00.496    0.4092016    7      T
    0   09:30:00.501    1.428629     4      N
    0   09:30:00.707    0.5647834    6      T
    0   09:30:00.781    1.590509     5      T
    0   09:30:00.848    2.242627     3      A
    0   09:30:00.860    2.277041     8      T
    0   09:30:00.931    0.8044885    8      A
    0   09:30:01.197    1.344031     2      A
    0   09:30:01.337    1.875        3      A
    0   09:30:01.399    2.187723     7      A

Note - Der partitionierte Modus eignet sich für Tabellen mit Millionen von Datensätzen pro Tag (dh Zeitreihendaten).

Sym-Datei

Die sym-Datei ist eine kdb + -Binärdatei, die die Liste der Symbole aus allen gespreizten und partitionierten Tabellen enthält. Es kann gelesen werden mit,

get `:sym

par.txt-Datei (optional)

Dies ist eine Konfigurationsdatei, die verwendet wird, wenn Partitionen auf mehrere Verzeichnisse / Festplatten verteilt sind und die Pfade zu den Festplattenpartitionen enthalten.

.Q.en

.Q.enist eine dyadische Funktion, die beim Aufteilen einer Tabelle hilft, indem eine Symbolspalte aufgelistet wird. Dies ist besonders nützlich, wenn es sich um historische Datenbanken handelt (gespreizt, Partitionstabellen usw.). - -

.Q.en[`:directory;table]

wo directory ist das Ausgangsverzeichnis der historischen Datenbank, in der sym file befindet sich und table ist die aufzuzählende Tabelle.

Eine manuelle Aufzählung von Tabellen ist nicht erforderlich, um sie als gespreizte Tabellen zu speichern, da dies durch -

.Q.en[`:directory_where_symbol_file_stored]table_name

.Q.dpft

Das .Q.dpftFunktion hilft beim Erstellen partitionierter und segmentierter Tabellen. Es ist eine fortgeschrittene Form von.Q.en, da es nicht nur die Tabelle aufteilt, sondern auch eine Partitionstabelle erstellt.

Es werden vier Argumente verwendet .Q.dpft - -

• symbolisches Dateihandle der Datenbank, in der eine Partition erstellt werden soll,

• q Datenwert, mit dem wir die Tabelle partitionieren werden,

• Name des Feldes, mit dem das partierte Attribut (`p #) angewendet werden soll (normalerweise` sym), und

• der Tabellenname.

Nehmen wir ein Beispiel, um zu sehen, wie es funktioniert -

q)tab:([]sym:5?`msft`hsbc`samsung`ibm;time:5?(09:30:30);price:5?30.25)

q).Q.dpft[`:c:/q/;2014.08.24;`sym;`tab]
`tab

q)delete tab from `
'type

q)delete tab from `/
'type

q)delete tab from .
'type

q)delete tab from `.
`.

q)tab
'tab

Wir haben die Tabelle gelöscht tabaus dem Gedächtnis. Laden wir es jetzt aus der Datenbank

q)\l c:/q/2014.08.24/

q)\a
,`tab

q)tab

   sym      time      price
-------------------------------
  hsbc    07:38:13   15.64201
  hsbc    07:21:05   5.387037
  msft    06:16:58   11.88076
  msft    08:09:26   12.30159
 samsung  04:57:56   15.60838

.Q.chk

.Q.chk ist eine monadische Funktion, deren einzelner Parameter das symbolische Dateihandle des Stammverzeichnisses ist. Wo immer erforderlich, werden leere Tabellen in einer Partition erstellt, indem die einzelnen Partitionsunterverzeichnisse im Stammverzeichnis untersucht werden.

.Q.chk `:directory

wo directory ist das Ausgangsverzeichnis der historischen Datenbank.