KDB +の概要

これは、kxシステムの kdb + に対する完全な手引きであり、主に独立して学習する人を対象としています。 2003年に導入されたkdb +は、データをキャプチャ、分析、比較、および保存するために設計された新世代のkdbデータベースです。

kdb +システムには、次の2つのコンポーネントが含まれています-

KDB + -データベース（kデータベースプラス）

Q -kdb +を操作するためのプログラミング言語

*kdb +* と *q* は両方とも* kプログラミング言語*で記述されています（ *q* と同じですが、読みにくくなっています）。

バックグラウンド

Kdb +/qは、あいまいなアカデミック言語として生まれましたが、長年にわたって、使いやすさが徐々に向上しています。

APL （1964、プログラミング言語）
A + （1988年、アーサーホイットニーによる修正APL）
K （1993、A +の鮮明なバージョン、Aが開発）ホイットニー）
Kdb （1998、インメモリ列ベースのデータベース）
Kdb +/q （2003、q言語– kのより読みやすいバージョン）

KDB +を使用する理由と場所

Why? -分析機能を備えたリアルタイムデータに単一のソリューションが必要な場合は、kdb +を検討する必要があります。 Kdb +はデータベースを通常のネイティブファイルとして保存するため、ハードウェアおよびストレージアーキテクチャに関する特別なニーズはありません。データベースは単なるファイルのセットであるため、管理作業は難しくありません。

KDB +の使用場所？-ほとんどの投資銀行が現在使用している、または従来のデータベースからkdb +に切り替える予定があるため、kdb +を使用していない投資銀行を簡単に数えます。データの量は日々増加しているため、大量のデータを処理できるシステムが必要です。 KDB +はこの要件を満たしています。 KDB +は膨大な量のデータを保存するだけでなく、リアルタイムで分析します。

入門

ここまでの背景を踏まえて、KDB +の環境を設定する方法を説明し、学習しましょう。 KDB +をダウンロードしてインストールする方法から始めます。

KDB +のダウンロードとインストール

64ビットバージョンのすべての機能を備えた無料の32ビットバージョンのKDB +をhttp://kx.com/software-download.phpから入手できます。

ライセンス契約に同意し、オペレーティングシステムを選択します（すべての主要なオペレーティングシステムで使用可能）。 Windowsオペレーティングシステムの場合、最新バージョンは3.2です。最新バージョンをダウンロードしてください。解凍すると、フォルダー名*「windows」が表示され、windowsフォルダー内に別のフォルダー「q」が表示されます。 *q フォルダ全体をc：/ドライブにコピーします。

Runターミナルを開き、 q フォルダーを保存する場所を入力します。「c：/q/w32/q.exe」のようになります。 Enterキーを押すと、次のように新しいコンソールが表示されます-

KDB +コンソール

最初の行には、バージョン番号3.2とリリース日2015.03.05が表示されます。

ディレクトリレイアウト

試用版/無料版は通常、ディレクトリにインストールされますが、

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

Windowsの場合-*

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

サンプルファイル-

kdb +をダウンロードすると、Windowsプラットフォームのディレクトリ構造は次のように表示されます-

KDB +サンプルファイル

上記のディレクトリ構造で、 trade.q および sp.q は、参照ポイントとして使用できるサンプルファイルです。

KDB +アーキテクチャ

Kdb +は、膨大な量のデータを処理するために最初から設計された高性能で大容量のデータベースです。完全に64ビットであり、組み込みのマルチコア処理とマルチスレッドを備えています。同じアーキテクチャがリアルタイムデータと履歴データに使用されます。データベースには独自の強力なクエリ言語* q、*が組み込まれているため、データに対して直接分析を実行できます。

*kdb + tick* は、リアルタイムデータと履歴データのキャプチャ、処理、およびクエリを可能にするアーキテクチャです。

Kdb +/tickアーキテクチャ

次の図は、一般的なKdb +/tickアーキテクチャの一般的な概要を示した後、さまざまなコンポーネントとデータのフローの簡単な説明を示しています。

KDB +アーキテクチャ

*データフィード*は、ほとんどがロイター、ブルームバーグなどのデータフィードプロバイダーによって、または取引所から直接提供される時系列データです。
関連データを取得するために、データフィードのデータは feed handler によって解析されます。
フィードハンドラによってデータが解析されると、 ticker-plant に送られます。
障害からデータを回復するために、ティッカープラントは最初に新しいデータをログファイルに更新/保存してから、独自のテーブルを更新します。
内部テーブルとログファイルを更新した後、オンタイムループデータは、リアルタイムデータベースと、データを要求したすべてのチェーンサブスクライバーに継続的に送信/公開されます。
営業日の終わりに、ログファイルが削除され、新しいログファイルが作成され、リアルタイムデータベースが履歴データベースに保存されます。すべてのデータが履歴データベースに保存されると、リアルタイムデータベースはそのテーブルを削除します。

Kdb + Tickアーキテクチャのコンポーネント

データフィード

データフィードには、任意の市場またはその他の時系列データを使用できます。フィードハンドラーへの生の入力としてデータフィードを検討します。フィードは、取引所（ライブストリーミングデータ）、トムソンロイター、ブルームバーグ、またはその他の外部機関などのニュース/データプロバイダーから直接取得できます。

フィードハンドラー

フィードハンドラーは、データストリームをkdb +への書き込みに適した形式に変換します。データフィードに接続されており、フィード固有の形式からデータを取得して、ティッカープラントプロセスに公開されるKdb +メッセージに変換します。一般的に、フィードハンドラは、次の操作を実行するために使用されます-

一連のルールに従ってデータをキャプチャします。
そのデータをある形式から別の形式に変換（/enrich）します。 *最新の値をキャッチします。

ティッカープラント

Ticker Plantは、KDB +アーキテクチャの最も重要なコンポーネントです。これは、リアルタイムデータベースまたは直接サブスクライバー（クライアント）が金融データにアクセスするために接続されるティッカープラントです。* publishおよびsubscribe *メカニズムで動作します。サブスクリプション（ライセンス）を取得すると、パブリッシャー（ティッカープラント）から（定期的に）ティックパブリケーションが定義されます。それは次の操作を実行します-

フィードハンドラからデータを受け取ります。
ティッカープラントはデータを受信するとすぐに、コピーをログファイルとして保存し、ティッカープラントが更新を取得したら更新します。これにより、障害が発生した場合にデータが失われることはありません。
クライアント（リアルタイムサブスクライバー）は、ティッカープラントに直接サブスクライブできます。
各営業日の終わりに、つまり、リアルタイムデータベースが最後のメッセージを受信すると、今日のすべてのデータを履歴データベースに保存し、今日のデータを購読しているすべてのサブスクライバーに同じデータをプッシュします。次に、すべてのテーブルをリセットします。ログファイルは、履歴データベースまたはリアルタイムデータベース（rtdb）に直接リンクされている他のサブスクライバにデータが保存されると削除されます。
その結果、ティッカープラント、リアルタイムデータベース、および履歴データベースは年中無休で稼働しています。

ticker-plantはKdb +アプリケーションであるため、他のKdb +データベースと同様に、 q を使用してテーブルをクエリできます。すべてのティッカープラントクライアントは、サブスクライバーとしてのみデータベースにアクセスできます。

リアルタイムデータベース

リアルタイムデータベース（rdb）は、今日のデータを保存します。ティッカープラントに直接接続されています。通常、市場の時間（1日）にメモリに保存され、1日の終わりに履歴データベース（hdb）に書き込まれます。データ（rdbデータ）はメモリに保存されるため、処理は非常に高速です。

kdb +では、1日あたりの予想データサイズの4倍以上のRAMサイズを推奨しているため、rdbで実行されるクエリは非常に高速で、優れたパフォーマンスを提供します。リアルタイムデータベースには今日のデータのみが含まれるため、日付列（パラメーター）は不要です。

たとえば、次のようなrdbクエリを使用できます。

select from trade where sym = `ibm

OR

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

歴史的データベース

会社の推定値を計算する必要がある場合、その履歴データを利用できるようにする必要があります。履歴データベース（hdb）は、過去に行われたトランザクションのデータを保持します。新しい日の各レコードは、1日の終わりにhdbに追加されます。 hdbの大きなテーブルは、表示されるように保存されるか（各列が独自のファイルに保存される）、一時データによってパーティション分割されて保存されます。また、いくつかの非常に大きなデータベースは、 par.txt （ファイル）を使用してさらにパーティション化できます。

これらのストレージ戦略（スプレイ、パーティション分割など）は、大きなテーブルからデータを検索またはアクセスする際に効率的です。

履歴データベースは、内部および外部のレポート目的、つまり分析にも使用できます。たとえば、特定の日のIBMの企業取引を取引（または任意の）テーブル名から取得したい場合、次のようにクエリを記述する必要があります-

thisday: 2014.10.12

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

注- q 言語の概要がわかったら、このようなクエリをすべて作成します。

Qプログラミング言語

Kdb +には、 q として知られる組み込みプログラミング言語が付属しています。時系列分析用に拡張された標準SQLのスーパーセットが組み込まれており、標準バージョンよりも多くの利点があります。 SQLに精通している人なら、数日のうちに q を学び、自分のアドホッククエリをすばやく書くことができます。

「q」環境の開始

kdb +の使用を開始するには、 q セッションを開始する必要があります。 q セッションを開始するには3つの方法があります-

実行端末で「c：/q/w32/q.exe」と入力するだけです。
MS-DOSコマンドターミナルを起動し、 q と入力します。
q.exe ファイルを「C：\ Windows \ System32」にコピーし、実行端末で「q」と入力します。

ここでは、Windowsプラットフォームで作業していると想定しています。

データ型

次の表は、サポートされているデータ型のリストを提供します-

Name	Example	Char	Type	Size
boolean	1b	b	1	1
byte	0xff	x	4	1
short	23h	h	5	2
int	23i	i	6	4
long	23j	j	7	8
real	2.3e	e	8	4
float	2.3f	f	9	8
char	“a”	c	10	1
varchar	`ab	s	11	*
month	2003.03m	m	13	4
date	2015.03.17T18:01:40.134	z	15	8
minute	08:31	u	17	4
second	08:31:53	v	18	4
time	18:03:18.521	t	19	4
enum	`u$`b, where u:`a`b	*	20	4

原子とリストの形成

原子は、単一のエンティティ、たとえば、単一の数字、文字、または記号です。（異なるデータ型の）上記の表では、サポートされているすべてのデータ型はアトムです。リストは、一連のアトムまたはリストを含む他のタイプです。

任意の型のアトムをモナドに渡す（つまり、単一引数関数）型関数は負の値、つまり –n を返しますが、これらのアトムの単純なリストを型関数に渡すと正の値 n を返します。

例1 –アトムとリストの形成

/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

Q言語-型キャスト

多くの場合、一部のデータのデータ型をある型から別の型に変更する必要があります。標準のキャスト関数は「$」* 2項演算子*です。

1つのタイプから別のタイプにキャストするために3つのアプローチが使用されます（文字列を除く）-

シンボル名で目的のデータ型を指定します
文字で目的のデータ型を指定します
短い値で目的のデータ型を指定します。

整数から浮動小数点数へのキャスト

整数を浮動小数点数にキャストする次の例では、3つの異なるキャスト方法はすべて同等です-

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

3つの操作すべてが同等であるかどうかを確認し、

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

文字列をシンボルにキャスト

文字列をシンボルにキャストしたり、文字列をシンボルにキャストしたりする方法は少し異なります。例で確認しましょう-

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

キー付き単語 `symbolまたは11hを使用して文字列を記号にキャストしようとすると、型エラーで失敗します-

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

q)`symbol$b
'type

q)11h$b
'type

文字列を非シンボルにキャストする

文字列をシンボル以外のデータ型にキャストするには、次のようにします-

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

したがって、文字列全体（文字のリスト）をデータ型 x の単一アトムにキャストするには、データ型 x を表す大文字を $ 演算子の最初の引数として指定する必要があります。他の方法で x のデータ型を指定すると、文字列の各文字にキャストが適用されます。

Q言語-時間データ

*q* 言語には、時刻や日付などの時間データを表現および操作するさまざまな方法があります。

Date

基準日は01Jan2000なので、kdb +の日付は整数の日数として内部的に保存されます。この日付の後の日付は内部的に正の数として保存され、それより前の日付は負の数として参照されます。

デフォルトでは、日付は「YYYY.MM.DD」の形式で書き込まれます

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

算術および論理演算*は、日付に直接実行できます。

q)x+1       /Add one day
2015.01.23

q)x-7       /Subtract 7 days
2015.01.15

2000年1月1日は土曜日に落ちました。したがって、履歴全体または将来の土曜日を7で割ると、残りは0、日曜日は1、月曜日は2になります。

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

タイムズ

時間は、午前0時のストロークからのミリ秒の整数として内部的に保存されます。時間はHH：MM：SS.MSSの形式で記述されます

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

日付の場合のように、算術は時間に直接実行できます。

日時

日時は、ISO標準形式のように「T」で区切られた日付と時刻の組み合わせです。日時値には、2000年1月1日午前0時からの小数日数が格納されます。

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

基になる端数の日数は、フロートにキャストすることで取得できます。

Q言語-リスト

リストは* q言語*の基本的な構成要素であるため、リストを完全に理解することは非常に重要です。リストは、単純に原子（原子要素）と他のリスト（1つ以上の原子のグループ）の順序付けられたコレクションです。

リストの種類

一般リスト*は、一致する括弧内にその項目を囲み、それらをセミコロンで区切ります。たとえば-

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

リストが同じタイプのアトムで構成されている場合、均一リスト*として知られています。それ以外の場合、*一般リスト（混合型）として知られています。

カウント

リスト内のアイテムの数は、そのカウントから取得できます。

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

単純なリストの例

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"

- - 注-文字の単純なリストは文字列と呼ばれます。 *

リストには、アトムまたはリストが含まれます。* 単一のアイテムリスト*を作成するには、次を使用します-

q)singleton:enlist 42

q)singleton
,42

アトムと同等のシングルトンを区別するには、そのタイプの符号を調べます。

q)signum type 42
-1i

q)signum type enlist 42
1i

Q言語-インデックス作成

リストは、そのアイテムの位置によって左から右に並べられます。リストの先頭からのアイテムのオフセットは、インデックス*と呼ばれます。したがって、最初のアイテムにはインデックス0があり、2番目のアイテム（ある場合）にはインデックス1があります。カウント *n のリストには、 0 から n–1 までのインデックスドメインがあります。

インデックス表記

リスト L を指定すると、インデックス i のアイテムは L [i] によってアクセスされます。インデックスでアイテムを取得することを*アイテムインデックス作成*と呼びます。例えば、

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

q)L[0]
99

q)L[1]
98.7e

q)L[4]
"z

インデックス付き割り当て

リスト内のアイテムは、アイテムのインデックス作成によって割り当てることもできます。したがって、

q)L1:9 8 7

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

q)L1
9 8 66

変数からのリスト

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)

参加リスト

2つのリストで最も一般的な操作は、それらを結合してより大きなリストを作成することです。より正確には、結合演算子（、）は、右のオペランドを左のオペランドの最後に追加し、結果を返します。いずれかの引数でアトムを受け入れます。

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

ネスティング

データの複雑さは、リストをリストのアイテムとして使用して構築されます。

深さ

リストのネストのレベル数は、その深さと呼ばれます。原子の深さは0で、単純リストの深さは1です。

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

q)count l1
3

これは2つの項目を持つ深さ3のリストです-

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

q)count l5
2

q)count l5[1]
3

深さでのインデックス作成

ネストされたリストのアイテムに直接インデックスを付けることができます。

繰り返しアイテムのインデックス作成

単一のインデックスを介してアイテムを取得すると、常にネストされたリストから最上位のアイテムが取得されます。

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

q)L[0]
1

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

結果 L [1] はそれ自体がリストであるため、単一のインデックスを使用してその要素を取得できます。

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

単一のインデックス作成をもう一度繰り返して、最も内側のネストされたリストからアイテムを取得できます。

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

これを読むことができます、

_Lからインデックス1のアイテムを取得し、インデックス2のアイテムを取得し、インデックス0のアイテムを取得します。

深さでのインデックスの表記

ネストされたリストの構成要素に繰り返しインデックスを付けるための代替表記法があります。最後の取得は、次のように書くこともできます。

q)L[1;2;0]
300

インデックスを介した割り当ても詳細に機能します。

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

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

除外インデックス

一般リストの指標の除外

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"

L [; 1;]を次のように解釈*

最上位の各リストの2番目の位置にあるすべてのアイテムを取得します。

L [;; 2]を次のように解釈*

2番目のレベルの各リストの3番目の位置にあるアイテムを取得します。

Q言語-辞書

辞書は、テーブルを作成するための基盤を提供するリストの拡張です。数学用語では、辞書は

「ドメイン→範囲」

または一般的に（短い）作成

「キー→値」

要素間の関係。

辞書は、ハッシュテーブルとほぼ同等のキーと値のペアの順序付きコレクションです。ディクショナリは、位置対応を介したドメインリストと範囲リスト間の明示的なI/Oアソシエーションによって定義されるマッピングです。辞書の作成には「xkey」プリミティブを使用します（！）

                  ListOfDomain ! ListOfRange

最も基本的な辞書は、単純なリストを単純なリストにマップします。

Input (I)	Output (O)
`Name	`John
`Age	36
`Sex	“M”
Weight	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

見上げる

入力値に対応するディクショナリ出力値を見つけることは、入力を「調べる」と呼ばれます。

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"

動詞での検索@

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

q)d1[`two]
18

q)d1@`two
18

辞書の操作

修正とアップサート

リストと同様に、ディクショナリのアイテムはインデックス付き割り当てを介して変更できます。

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

辞書は、インデックスの割り当てによって拡張できます。

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

q)d

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

検索を使用した逆引き（？）

検索（？）演算子は、要素の範囲をそのドメイン要素にマッピングすることにより、逆ルックアップを実行するために使用されます。

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

q)d2?77
`z

リストの要素が一意でない場合、 find はドメインリストから最初の項目マッピングを返します。

エントリの削除

辞書からエントリを削除するには、* delete（）関数*を使用します。（）の左側のオペランドは辞書であり、右側のオペランドはキー値です。

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

q)d2 _`z

x| 99
y| 88

最初のオペランドが変数の場合、_の左側に空白が必要です。

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

z| 77

列辞書

列辞書は、テーブル作成の基本です。次の例を考慮してください-

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

辞書の反転

列ディクショナリを反転することの最終的な効果は、単にインデックスの順序を逆にすることです。これは、行と列の転置と論理的に同等です。

列辞書の反転

辞書の転置は、単項反転演算子を適用することにより取得されます。次の例を見てください-

q)scores

name  | John Jenny Jonathan
id    | 9   18   27

q)flip scores

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

反転した列辞書の反転

辞書を2回転置すると、元の辞書が取得され、

q)scores ~ flip flip scores
1b

Q言語-テーブル

テーブルはkdb +の中核です。テーブルは、辞書として実装された名前付き列のコレクションです。 * qテーブル*は列指向です。

テーブルを作成する

テーブルは、次の構文を使用して作成されます-

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

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

上記の例では、各列のタイプを指定していません。これは、テーブルへの最初の挿入によって設定されます。

別の方法では、初期化時に列タイプを指定できます-

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

または、空でないテーブルを定義することもできます-

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

q)trade

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

上記の例のように角括弧内に列がない場合、テーブルは unkeyed です。

キー付きテーブル*を作成するには、角かっこにキーの列を挿入します。

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

q)trade

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

また、値をさまざまなタイプのヌルリストに設定することにより、列のタイプを定義することができます-

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

テーブル情報の取得

貿易テーブルを作成しましょう-

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

主キーとキー付きテーブル

キー付きテーブル

キー付きテーブルは、一意のキーのテーブルの各行を値のテーブルの対応する行にマップする辞書です。例を見てみましょう-

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

ここで、キーとしてeidを含む単純なキー付きテーブルを作成し、

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

ForeignKeys

外部キー*は、それが定義されているテーブルの行から、対応する*プライマリキー*を持つテーブルの行へのマッピングを定義します。

外部キーは*参照整合性*を提供します。つまり、主キーにない外部キー値を挿入しようとすると失敗します。

次の例を検討してください。最初の例では、初期化時に外部キーを明示的に定義します。 2番目の例では、2つのテーブル間の以前の関係を想定しない外部キー追跡を使用します。

例1-初期化時に外部キーを定義する

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

例2-テーブル間に定義済みの関係なし

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

外部キー追跡を使用するには、セクターにキー入力するためのテーブルを作成する必要があります。

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

事前定義された外部キーの一般的な表記法-

cからa.bを選択します。aは外部キー（記号）、bはa_です。

主キーテーブル（ind）のフィールド、cはthe

外部キーテーブル（取引）

テーブルの操作

1つの取引テーブルを作成し、異なるテーブル式の結果を確認しましょう-

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

ここで、 q 言語を使用してテーブルを操作するために使用されるステートメントを見てみましょう。

選択する

*Select* ステートメントを使用する構文は次のとおりです-

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

Selectステートメントの使用方法を示すために例を見てみましょう-

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

インサート

挿入*ステートメントを使用する構文は次のとおりです-

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

ここで、Insertステートメントの使用方法を示す例を示します-

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 columns from table
delete from table where clause

Deleteステートメントの使用方法を示すために例を見てみましょう-

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 column: newValue from table where ….

次の構文を使用して、キャスト関数を使用して列の形式/データ型を更新します-

update column:newValue from `table where …

ここで、 Update ステートメントの使用方法を示す例を示します-

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

Q言語-動詞と副詞

Kdb +には名詞、動詞、副詞があります。すべてのデータオブジェクトと関数は*名詞*です。 *動詞*は、式の角括弧と括弧の数を減らすことにより、読みやすくします。 *副詞*ダイアディック（2つの引数）関数と動詞を変更して、新しい関連する動詞を生成します。副詞によって生成される関数は、*派生関数*または*派生動詞*と呼ばれます。

Each

（ `）で示される副詞 each は、ダイアディック関数と動詞を変更して、リスト自体ではなくリストの項目に適用します。次の例を見てください-

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

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

キーワード「each」を使用するモナド関数用の Each の形式があります。例えば、

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* （\ :)および *Each-Right* （/:)と呼ばれるダイアディック関数用のEachの2つのバリアントがあります。 次の例は、それらの使用方法を説明しています。

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

Q言語-結合

*q* 言語では、提供される入力テーブルと必要な結合テーブルの種類に基づいて、さまざまな種類の結合があります。 結合は、2つのテーブルのデータを結合します。 外部キーの追跡に加えて、テーブルを結合する4つの方法があります-

簡単な結合
Asof Join
左結合
組合加入

ここで、この章では、これらの各結合について詳しく説明します。

単純結合

単純な結合は、カンマ「、」で実行される最も基本的な種類の結合です。この場合、2つのテーブルは type conformant である必要があります。つまり、両方のテーブルは同じ順序で同じ列数と同じキーを持っています。

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

同じ長さのテーブルにカンマごとの結合を使用して、横方向に結合できます。ここでテーブルの1つにキーを付けることができます。

Table1, `Table2

Asof Join（aj）

あるテーブルのフィールドの値を別のテーブルの時点で取得するために使用される最も強力な結合です。一般的に、各取引の時点で一般的な入札と依頼を得るために使用されます。

一般的な形式

aj[joinColumns;tbl1;tbl2]

例えば、

aj[`sym`time;trade;quote]

例

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

左結合（lj）

これはajの特殊なケースであり、2番目の引数はキー付きテーブルであり、1番目の引数には正しい引数のキーの列が含まれます。

一般的な形式

table1 lj Keyed-table

例

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

ユニオン結合（uj）

異なるスキーマを持つ2つのテーブルの結合を作成できます。基本的には、単純な結合（、）の拡張です

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

キー付きテーブルでujを使用している場合、主キーは一致する必要があります。

Q言語-関数

機能の種類

関数はさまざまな方法で分類できます。ここでは、引数の数とタイプ、および結果のタイプに基づいて分類しました。機能は、

Atomic -引数がアトミックであり、アトミックな結果を生成する場合
Aggregate -リストからの原子
均一（リストからのリスト）-リストに適用されるアトムの概念を拡張しました。引数リストのカウントは、結果リストのカウントと等しくなります。
その他-関数が上記のカテゴリに属さない場合。

数学の二項演算は、qでは*ダイアディック関数*と呼ばれます。たとえば、「+」。同様に、単項演算は*モナド関数*と呼ばれます。たとえば、「abs」または「floor」。

よく使う機能

*q* プログラミングで頻繁に使用される関数はかなりあります。 ここで、このセクションでは、いくつかの一般的な機能の使用方法を確認します-

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

最大（＆）、最小（|）、および非（！）

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

カウント

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

port

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

cut

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"

削除する

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

はっきりした

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

入隊

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

塗りつぶし（^）

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

塗りつぶし

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

最初

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

イデスク

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

q)idesc 0 1 3 4

3 2 1 0

in

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

インサート

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

key

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..

下

q)/lower - Convert to lower case and floor

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

最大および最小（つまり、 |および＆）

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

桃

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

ランダム（？）

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

Raze

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…

逆

q)/reverse - Reverse a list

q)reverse 2 30 29 1 3 4

4 3 1 29 30 2

q)reverse "HelloWorld"

"dlroWolleH"

set

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"

ひも

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

システム

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"

テーブル

q)/tables - list all tables

q)tables `

`s#`tab1`tab2`trade

Til

q)/til - Enumerate

q)til 5

0 1 2 3 4

trim

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

システムコマンド

システムコマンドは q 環境を制御します。彼らは次の形式です-

\cmd [p]       where p may be optional

一般的なシステムコマンドのいくつかは以下で議論されています-

\ a [名前空間] –指定された名前空間のテーブルを一覧表示する

q)/Tables in default namespace

q)\a
,`trade

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

\ b –依存関係の表示

q)/views/dependencies

q)a:: x+y     /global assingment

q)b:: x+1

q)\b
`s#`a`b

\ B –保留中のビュー/依存関係

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 –ディレクトリの変更

q)/change directory, \cd [name]

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

q)\cd ../new-account

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

\ d –現在の名前空間を設定します

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 – dbからファイルまたはディレクトリをロードする

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 –ポート番号

q)/assign port number, \p

q)\p
5001i

q)\p 8888

q)\p
8888i

\\-qコンソールを終了します

\\ - exit
Exit form q.

Q言語-組み込み関数

*q* プログラミング言語には、豊富で強力な組み込み関数のセットがあります。 組み込み関数は、次のタイプにすることができます-

文字列関数-入力として文字列を受け取り、文字列を返します。
集計関数-入力としてリストを取り、アトムを返します。
均一関数-リストを取得し、同じカウントのリストを返します。
数学関数-数値引数を取り、数値引数を返します。
その他の機能-上記以外のすべての機能。

文字列関数

Like-パターンマッチング

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-先行ブランクを削除します

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

q)ltrim " Rick "
"Rick "

rtrim-末尾の空白を削除します

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

q)rtrim " Rick "
" Rick"

ss-文字列検索

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

trim-先頭と末尾の空白を削除します

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

q)trim " John "
"John"

数学関数

acos-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

cor-相関を与える

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

cross-デカルト積

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 −分散

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

集約関数

すべて-および操作

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

任意-|操作

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-算術積

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

合計-算術合計

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

均一関数

デルタ-前のアイテムとの違い。

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

fills-null値を埋めます

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-累積最大

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

その他の機能

カウント-要素の数を返す

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

個別-個別のエンティティを返します

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

例外-2番目の引数に存在しない要素。

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-最初の引数でnullを埋める

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"

Q言語-クエリ

*q* のクエリはより短く簡単で、sqlの機能を拡張します。 メインのクエリ式は「選択式」で、最も単純な形式ではサブテーブルを抽出しますが、新しい列を作成することもできます。

選択式*の一般的な形式は次のとおりです-

Select columns by columns from table where conditions

- - 注-by＆where *句はオプションです。「from expression」のみが必須です。

一般的に、構文は次のようになります-

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

*q* 式の構文はSQLに非常に似ていますが、 *q* 式は単純で強力です。 上記の *q* 式と同等のSQL式は次のようになります-

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

すべての句は列で実行されるため、 q は順序を利用できます。 SQLクエリは順序に基づいていないため、その利点を活用できません。

*q* リレーショナルクエリは、通常、対応するsqlと比較してサイズがはるかに小さくなります。 順序付けられた機能的なクエリは、SQLでは難しいことを行います。

履歴データベースでは、クエリのパフォーマンスに影響するため、 where 句の順序は非常に重要です。 partition 変数（日付/月/日）が常に最初に来て、その後にソートされインデックスされた列（通常はsym列）が続きます。

例えば、

select from table where date in d, sym in s

よりもずっと速い

select from table where sym in s, date in d

基本クエリ

クエリスクリプトをメモ帳で作成し（以下を参照）、保存（* .q）してから読み込みます。

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.

制約付きのクエリ

HDBクエリを示します*

すべてのIBM取引を選択

select from trade where sym in `IBM

*特定の日にすべてのIBM取引を選択します

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

100を超える価格のすべてのIBM取引を選択*

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

100以下の価格のすべてのIBM取引を選択します*

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

*特定の日付の午前10時30分から10時40分までのすべてのIBM取引を選択します

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

価格の昇順ですべてのIBM取引を選択します

`price xasc select from trade where sym =`IBM

*特定の時間枠で価格の降順ですべてのIBM取引を選択します

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

複合ソート-symで昇順をソートし、価格の降順で結果をソートします

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

すべてのIBMまたはMSFT取引を選択

select from trade where sym in `IBM`MSFT

*特定の時間枠内で昇順ですべてのシンボルのカウントを計算します

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

*特定の時間枠内で降順ですべてのシンボルのカウントを計算します

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

特定の期間内のIBM株の最高価格はいくらですか？

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

1時間ごとのバケットで各symの最終価格を選択します*

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

集計を含むクエリ

すべてのシンボルのvwap（ボリューム加重平均価格）を計算します*

select vwap:size wavg price by sym from trade

特定の月のレコード数（百万単位）をカウントします*

(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 –特定の月のCSCOの毎日の高値、安値、始値および終値*

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

*特定の月のCSCOの毎日のVwap*

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

*AIG* の価格の時間平均、分散、標準偏差を計算します

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

価格範囲を1時間ごとに選択します

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

特定の月のCSCOの日次スプレッド（平均入札価格）*

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

特定の月のすべてのsymの日次取引値*

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

CSCOの5分間のvwapを抽出します*

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

CSCOの10分足を抽出*

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

特定の日のCSCOの最終価格に対して価格が100ベーシスポイント（100e-4）を超える時間を検索します*

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

データベースの最後の日付の1分間隔でのMSFTの1日の価格とボリューム*

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

Q言語-プロセス間通信

KDB +では、1つのプロセスがプロセス間通信を介して別のプロセスと通信できます。 Kdb +プロセスは、同じコンピューター、同じネットワーク、またはリモートにある他のkdb +に接続できます。ポートを指定するだけで、クライアントはそのポートと通信できます。ネットワーク上でアクセス可能で、接続をリッスンしている限り、任意の q プロセスは他の q プロセスと通信できます。

サーバープロセスは接続をリッスンし、リクエストを処理します
クライアントプロセスが接続を開始し、実行するコマンドを送信します

クライアントとサーバーは、同じマシン上にあっても、異なるマシン上にあってもかまいません。プロセスは、クライアントとサーバーの両方にすることができます。

コミュニケーションは、

同期（結果が返されるのを待つ）
非同期（待機も結果も返されません）

サーバーの初期化

*q* サーバーは、リッスンするポートを指定することにより初期化されます。

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

通信ハンドル

通信ハンドルは、「：」で始まり、次の形式の記号です-

`:[server]:port-number

例

`::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

接続を開始するには、整数接続ハンドルを返す関数「hopen」を使用します。このハンドルは、後続のすべてのクライアント要求に使用されます。たとえば-

q)h:hopen `::5001

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

q)hclose h

同期および非同期メッセージ

ハンドルを取得したら、同期的または非同期的にメッセージを送信できます。

同期メッセージ-メッセージが送信されると、待機して結果を返します。その形式は次のとおりです-

handle “message”

非同期メッセージ-メッセージの送信後、待機して結果を返すことなく、すぐに次のステートメントの処理を開始します。その形式は次のとおりです-

neg[handle] “message”

関数呼び出しやselectステートメントなどの応答を必要とするメッセージは、通常、同期形式を使用します。一方、テーブルに更新を挿入するなど、出力を返す必要のないメッセージは非同期になります。

Q言語-メッセージハンドラー

*q* プロセスがプロセス間通信を介して別の *q* プロセスに接続すると、メッセージハンドラーによって処理されます。 これらのメッセージハンドラにはデフォルトの動作があります。 たとえば、同期メッセージ処理の場合、ハンドラーはクエリの値を返します。 この場合の同期ハンドラーは *.z.pg* であり、要件ごとにオーバーライドできます。

Kdb +プロセスには、いくつかの定義済みのメッセージハンドラがあります。データベースを構成するには、メッセージハンドラーが重要です。使用法のいくつかが含まれます-

ロギング-受信メッセージをログに記録します（致命的なエラーが発生した場合に役立ちます）。
セキュリティ-ユーザー名/IPアドレスに基づいて、データベースへのアクセス、特定の関数呼び出しなどを許可/禁止します。許可されたサブスクライバーのみにアクセスを提供するのに役立ちます。
*他のプロセスからの接続/切断*を処理します。

定義済みのメッセージハンドラ

定義済みのメッセージハンドラの一部については、以下で説明します。

.z.pg

同期メッセージハンドラー（プロセスget）です。この関数は、kdb +インスタンスで同期メッセージが受信されるたびに自動的に呼び出されます。

パラメーターは、実行される文字列/関数呼び出し、つまり渡されたメッセージです。デフォルトでは、次のように定義されています-

.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

非同期メッセージハンドラー（プロセスセット）です。非同期メッセージの同等のハンドラーです。パラメーターは、実行される文字列/関数呼び出しです。デフォルトでは、次のように定義されています。

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

以下は、保護された実行を使用した非同期メッセージ用のカスタマイズされたメッセージハンドラです。

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

ここで、 errhandler は、予期しないエラーが発生した場合に使用される関数です。

.z.po []

接続オープンハンドラー（プロセスオープン）です。リモートプロセスが接続を開いたときに実行されます。プロセスへの接続が開かれたときにハンドルを確認するには、.z.poを次のように定義します。

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

.z.pc []

これは、接続を閉じるハンドラーです（process-close）。接続が閉じられたときに呼び出されます。グローバル接続ハンドルを0にリセットし、タイマーを3秒（3000ミリ秒）ごとに起動（実行）するように設定するコマンドを発行できる独自のクローズハンドラーを作成できます。

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

タイマーハンドラー（.z.ts）は、接続を再度開こうとします。成功すると、タイマーがオフになります。

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

.z.pi []

PIはプロセス入力を表します。あらゆる種類の入力に対して呼び出されます。コンソール入力またはリモートクライアント入力の処理に使用できます。 .z.pi []を使用すると、コンソール入力を検証したり、デフォルトのディスプレイを置き換えたりできます。さらに、あらゆる種類のロギング操作に使用できます。

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

これは、検証接続ハンドラー（ユーザー認証）です。 kdb +セッションへの接続が開かれているときに、追加のコールバックを追加します。 -u/-Uチェックの後、.z.po（ポートが開く）の前に呼び出されます。

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

入力は userid （記号）および password （テキスト）です。

Q言語-属性

テーブルのリスト、辞書、または列には、属性を適用できます。属性はリストに特定のプロパティを課します。一部の属性は変更時に消える場合があります。

属性の種類

ソート済み（ `s＃）

`s＃は、リストが昇順でソートされることを意味します。リストがasc（またはxasc）で明示的にソートされている場合、リストにはソートされた属性が自動的に設定されます。

q)L1: asc 40 30 20 50 9 4

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

ソートされることがわかっているリストには、属性を明示的に設定することもできます。 Q はリストがソートされているかどうかをチェックし、ソートされていない場合は s-fail エラーがスローされます。

q)L2:30 40 24 30 2

q)`s#L2
's-fail

ソートされていない属性は、ソートされていない追加時に失われます。

別れた（ `p＃）

`p＃は、リストが分割され、同一のアイテムが連続して保存されることを意味します。

範囲は int または temporal type で、年、月、日などの基本的なint値を持ちます。列挙されているシンボルをパーティション分割することもできます。

parted属性を適用すると、一意の各出力値をその最初の出現位置にマップするインデックスディクショナリが作成されます。リストが分割されると、線形検索がハッシュテーブル検索に置き換えられるため、検索がはるかに高速になります。

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

注-

parted属性は、リストに対する操作の下では保持されません。操作はパーティションを保持します。
エンティティの数が10億に達し、パーティションのほとんどがかなりのサイズである場合、つまり、かなりの繰り返しがある場合、parted属性を考慮する必要があります。

グループ化（ `g＃）

`g＃はリストがグループ化されていることを意味します。内部ディクショナリが作成および維持され、一意の各アイテムが各インデックスにマップされ、かなりのストレージスペースが必要になります。サイズ s の u 固有項目を含む長さ L のリストの場合、これは*（L×4）+（u×s）*バイトになります。

グループ化は、その構造について他の仮定ができない場合にリストに適用できます。

この属性は、入力されたリストに適用できます。追加時には維持されますが、削除時には失われます。

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

ユニーク（ `#u）

一意の属性（ `u＃）をリストに適用することは、リストのアイテムが異なることを示します。リストの要素が一意であることを知っていると、区別*が劇的に高速化され、 *q がいくつかの比較を早期に実行できるようになります。

リストに一意のフラグが立てられると、リスト内の各アイテムに対して内部ハッシュマップが作成されます。リストの操作は一意性を保持する必要があります。そうしないと、属性が失われます。

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

注-

`u＃は、一意性を保持する連結で保持されます。削除および一意でない連結では失われます。
`u＃リストの検索は、ハッシュ関数を介して行われます。

属性を削除する

属性を削除するには、 `＃を適用します。

属性を適用する

属性を適用するための3つの形式は次のとおりです-

* L： `s＃14 2 3 3 9 */リスト作成中に指定
* @ [。; `L; `s＃] */機能的に適用、つまり変数リストL +/デフォルトの名前空間（つまり、 `。）apply +/ソートされた</literal> s＃属性
* tabから s＃timeを更新* /テーブル（タブ）を更新して、/属性を適用します。

上記の3つの異なる形式に例を適用してみましょう。

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#).

Q言語-機能クエリ

機能的（動的）クエリを使用すると、一般的なq-sqlのselect/exec/delete列のシンボルとして列名を指定できます。列名を動的に指定する場合に非常に便利です。

機能形態は次のとおりです-

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

どこで

t はテーブルです。
a は集計の辞書です。
b フレーズ。そして
c は制約のリストです。

注-

a 、 b 、および c のすべての q エンティティは、名前で参照する必要があります。これは、エンティティ名を含むシンボルとして意味します。
selectおよびupdateの構文形式は、 q インタープリターによって同等の機能形式に解析されるため、2つの形式の間にパフォーマンスの違いはありません。

機能選択

次のコードブロックは、*機能選択*の使用方法を示しています-

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

例1

最も簡単なケースから始めましょう。*「select from t」*の機能バージョンは次のようになります-

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

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

例2

次の例では、enlist関数を使用してシングルトンを作成し、適切なエンティティがリストであることを確認します。

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

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

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

実施例３

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

機能実行

execの機能形式は、 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

機能更新

更新の機能形式は、 select の機能形式と完全に類似しています。次の例では、enlistを使用してシングルトンを作成し、入力エンティティがリストであることを確認します。

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

機能削除

機能削除は、機能更新の簡略化された形式です。その構文は次のとおりです-

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

機能的な削除がどのように機能するかを示すために例を見てみましょう-

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

Q言語-テーブル算術

この章では、辞書を操作してからテーブルを操作する方法を学びます。辞書から始めましょう-

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

辞書の値を修正する必要がある場合、修正定式化することができます-

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

Kdbplus-q-tables-on-disk

Q言語-メンテナンス機能

.Q.en

*.Q.en* は、シンボル列を列挙することでテーブルを表示するのに役立つ2項関数です。 これは、履歴データベース（表示、パーティションテーブルなど）を処理する場合に特に便利です。 −

.Q.en[`:directory;table]

ここで、 directory は* symファイル*が配置されている履歴データベースのホームディレクトリであり、 table は列挙されるテーブルです。

テーブルを手動で列挙する必要はありません。これは、展開されたテーブルとして保存するために必要です。

.Q.en[`:directory_where_symbol_file_stored]table_name

.Q.dpft

*.Q.dpft* 関数は、パーティションテーブルおよびセグメントテーブルの作成に役立ちます。 テーブルを展開するだけでなく、パーティションテーブルも作成するため、*。Q.en *の高度な形式です。

*.Q.dpft* で使用される4つの引数があります-

パーティションを作成するデータベースのシンボリックファイルハンドル、
q テーブルのパーティション分割に使用するデータ値、
parted（ p＃）属性が適用されるフィールドの名前（通常は sym）
テーブル名。

それがどのように機能するかを見てみましょう-

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

メモリからテーブル tab を削除しました。次に、dbからロードします。

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 is a monadic function whose single parameter is the symbolic file handle of the root directory. It creates empty tables in a partition, wherever necessary, by examining each partition subdirectories in the root..

.Q.chk `:directory

ここで、 directory は履歴データベースのホームディレクトリです。

Kdbplus-quick-guide

KDB +の概要

バックグラウンド

KDB +を使用する理由と場所

入門

KDB +のダウンロードとインストール

ディレクトリレイアウト

KDB +アーキテクチャ

Kdb +/tickアーキテクチャ

Kdb + Tickアーキテクチャのコンポーネント

データフィード

フィードハンドラー

ティッカープラント

リアルタイムデータベース

歴史的データベース

Qプログラミング言語

「q」環境の開始

データ型

原子とリストの形成

例1 –アトムとリストの形成

Q言語-型キャスト

整数から浮動小数点数へのキャスト

文字列をシンボルにキャスト

文字列を非シンボルにキャストする

Q言語-時間データ

Date

タイムズ

日時

Q言語-リスト

リストの種類

カウント

単純なリストの例

Q言語-インデックス作成

インデックス表記

インデックス付き割り当て

変数からのリスト

参加リスト

ネスティング

深さ

深さでのインデックス作成

除外インデックス

Q言語-辞書

見上げる

動詞での検索@

辞書の操作

修正とアップサート

検索を使用した逆引き（？）

エントリの削除

列辞書

辞書の反転

列辞書の反転

反転した列辞書の反転

Q言語-テーブル

テーブルを作成する

テーブル情報の取得

主キーとキー付きテーブル

キー付きテーブル

ForeignKeys

テーブルの操作

選択する

インサート

削除する

更新

Q言語-動詞と副詞

Each

各左および各右

Q言語-結合

単純結合

Asof Join（aj）

一般的な形式

例

左結合（lj）

一般的な形式

例

ユニオン結合（uj）

Q言語-関数

機能の種類

よく使う機能

abs

all