摘要：其中代表了列的類型，表示了是否存在任何外鍵。事實上，語言會自動地識別滿足表形式的列字典，在沒有任何請求詢問下，將其轉換為表形式。結果顯示的結果永遠是一個表。被用來合并兩個具有相同列的鍵表。屬性表明對所有出現的值，相同的值都是互相鄰近的。

表(Tables)和列表、字典一樣，都是q語言中的第一類對象(First-class entity)

Q表是*列導向的*

Q表是從字典構建的

1. 表作為列字典

q)dc:`name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
q)dc[`iq;]
98 42 126
q)dc[;2]
name| `Prefect
iq | 126
q)dc[`iq; 2]
126

我們通過flip指令來得到一個表

q)t:flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
q)t[;`iq]
98 42 126
q)t[2;]
name| `Prefect
iq  | 126
q)t[2;`iq]
126

所有表的類型都是98h。

類似于python的pandas包，可以通過t[`column]或者t.column來獲取一個列。但請注意，點操作符在函數內不起作用。

q)t[`name`iq]
Dent Beeblebrox Prefect
98   42         126

2. 表的顯示

q)dc
name| Dent Beeblebrox Prefect
iq  | 98   42         126
q)t
name       iq 
--------------
Dent       98 
Beeblebrox 42 
Prefect    126

3. 表定義語法
定義語法為([] c1:L1;...;cn:Ln)
其中ci是列名，Li是對應的列值。其中的冒號不是必須的。

q)t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
q)t~flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
1b

表定義中也可以直接使用變量，這樣對應的列名就是變量名了

q)c1:`Dent`Beeblebrox`Prefect
q)c2:98 42 126
q)([] c1; c2)
c1         c2
--------------
Dent       98
Beeblebrox 42
Prefect    126

atom元素會自動拓展到列長度

q)([] c1:`a`b`c; c2:42; c3:98.6)
c1 c2 c3  
----------
a  42 98.6
b  42 98.6
c  42 98.6

4. 表的元數據
可以通過cols指令來獲取表的列；可以通過meta來獲取表的元數據，結果是一個鍵表(keyed-table)。

q)meta t
c   | t f a
----| -----
name| s    
iq  | j

其中t代表了列的類型，f表示了是否存在任何外鍵。

指令tables返回當前命名空間下的表名, a效果相同：

q)t2:([] c1:1 2 3; c2:(1 2; enlist 3; 4 5 6))
q)t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
q)tables `.
`t`t2

5. 記錄
表在邏輯上是一個字典記錄(record)的列表，count返回記錄的個數。

q)count t
3

為了獲取表中的不帶列名的行，可以使用value函數

q)value t[1]
`Beeblebrox
42

6. 轉置的列字典 vs 記錄的列表
邏輯上，表既可以是轉置的列字典(Flipped column dictionary)，也可以是記錄的列表(list of records)，但是物理上它被儲存為列字典。事實上，Q語言會自動地識別滿足表形式的列字典，在沒有任何請求詢問下，將其轉換為表形式。
例如下兩例：

q)type (`name`iq!(`Dent;98); `nome`iq!(`Beeblebrox;42))
0h

q)type (`name`iq!(`Dent;98); `name`iq!(`Beeblebrox;42))
98h

表被儲存為列形式的一個壞處是，當想要刪除掉表中的一行時，花銷非常大。

The best way to deal with this in large tables is not to do it.

與其刪除一行，不如用一個表示flag的column來表示該行有沒有被刪除。

創建一般空表的方式：

q)([] name:(); iq:())

推薦的做法是給每列指定類型

q)([] name:`symbol$(); iq:`int$())

一種等價的創建帶類型的表的方法：

q)([] name:0#`; iq:0#0)
q)([] name:0#`; iq:0#0)~ ([] name:`symbol$(); iq:`int$())
1b

3. 基本的select和update操作
下面以這個表的操作為例

q)t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)

1. select的語法
基本語法為：

select cols from table 

取全部列直接省略掉cols即可，不用加*。

2. 結果顯示
select的結果永遠是一個表。

q)select from t
name       iq 
--------------
Dent       98 
Beeblebrox 42 
Prefect    126

3. 選擇列

q)select name from t
name
----------
Dent
Beeblebrox
Prefect
q)select c1:name, c2:iq from t

4. 基本的update
update的語法與select的語法基本相同，其使用冒號右邊的值來取代該列。

q)update iq:iq%100 from t
name       iq
---------------
Dent       0.98
Beeblebrox 0.42
Prefect    1.26

在SQL中，可以聲明一個或多個列作為主鍵，主鍵的值是unique的，使得通過主鍵的值來提取行成為可能。

1. 鍵表
定義：A keyed table is a dictionary mapping a table of key records to a table of value records.

一個鍵表并不是一個表——它是一個字典，所以類型是99h。

2. 簡單的例子
值的表(table of value)：

q)v:flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)

鍵的表(table of key)：

q)k:flip (enlist `eid)!enlist 1001 1002 1003

創建鍵表：

q)kt:k!v
q)kt
eid | name       iq 
----| --------------
1001| Dent       98 
1002| Beeblebrox 42 
1003| Prefect    126

3. 鍵表的定義語法
下面是通過字典形式對鍵表定義的常規語法：

q)kt:(flip (enlist `eid)!enlist 1001 1002 1003)! flip `name`iq!(`Dent`Beeblebrox`Prefect;98 42 126)
q)kt
eid | name       iq
----| --------------
1001| Dent       98
1002| Beeblebrox 42
1003| Prefect    126

直接使用表定義語法將更為簡單：

q)kt:([eid:1001 1002 1003] name:`Dent`BeebleBrox`Prefect; iq:98 42 126)

帶類型的空鍵表的定義形式如下：

q)ktempty:([eid:`int$()] `symbol$name:(); iq:`int$())
q)ktempty
eid| name iq
---| -------

q)ktempty:([eid:0#0] name:0#`;iq:0#0)

4. 獲取鍵表的記錄
因為鍵表本質上是一個字典映射，所以可以通過鍵值對記錄進行查找。注意鍵和值都對應的是字典。

q)kt[(enlist `eid)!enlist 1002]
name| `Beeblebrox
iq  | 42

上例可以簡化為：

q)kt[1002]
name| `Beeblebrox
iq  | 42

我們可以獲取某個列的值

q)kt[1002][`iq]
42

q)kt[1002;`iq]
42

5. 取多行的記錄

q)kt[1001]
name| `Dent
iq  | 98
q)kt 1001
name| `Dent
iq  | 98

為了取多行的數據，通過如下的方式去取是錯誤的

q)kt[1001 1002]
"length

正確的方式是：

q)kt[(enlist 1001;enlist 1002)]
name       iq
-------------
Dent       98
Beeblebrox 42
q)kt[flip enlist 1001 1002]

也可以通過構建一個匿名的表來取值

q)kt ([] eid:1001 1002)
name       iq
-------------
Dent       98
Beeblebrox 42

回想第5.2.2節指出的，可以通過命令#來提取一個子字典，對于鍵表同理：

q)([] eid:1001 1002)#kt
eid | name       iq
----| -------------
1001| Dent       98
1002| Beeblebrox 42

6. 反向查找
由于鍵表是一個字典，所以我們通過值來反響查找鍵。

q)kts:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect)
q)kts
eid | name
----| ----------
1001| Dent
1002| Beeblebrox
1003| Prefect

反向查找：

q)kts?([] name:`Prefect`Dent)
eid
----
1003
1001

7. 鍵表的成分
可以通過key和value來提取鍵表成分

q)key kt
eid
----
1001
1002
1003
q)value kt
name       iq
--------------
Dent       98
Beeblebrox 42
Prefect    126

函數keys和cols返回鍵表的鍵名和列名。

8. 表和鍵表
通過xkey來設置一列為鍵

q)t:([] eid:1001 1002 1003; name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
q)`eid xkey t
eid | name       iq 
----| --------------
1001| Dent       98 
1002| Beeblebrox 42 
1003| Prefect    126

在xkey左運算元設置為空列表時轉換為常規表

q)kt:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
q)() xkey kt
eid  name       iq 
-------------------
1001 Dent       98 
1002 Beeblebrox 42 
1003 Prefect    126

也可以使用!的又一重載用法：左運算元為一個非負的數字，代表左側將包含在鍵中的列數；右運算元為表或者鍵表。0代表沒有鍵。

q)1!t
q)0!kt
eid  name       iq 
-------------------
1001 Dent       98 
1002 Beeblebrox 42 
1003 Prefect    126
q)2!0!kt
eid  name      | iq
---------------| ---
1001 Dent      | 98
1002 Beeblebrox| 42
1003 Prefect   | 126

上述返回的結果都是在表的拷貝上進行的，如果要對表進行in-place的操作，則需要使用call-by-name

q)`eid xkey `t
`t
q)() xkey `kt
`kt
q)kt
eid  name       iq 
-------------------
1001 Dent       98 
1002 Beeblebrox 42 
1003 Prefect    126

9. 復合的主鍵

q)ktc:([lname:`Dent`Beeblebrox`Prefect; fname:`Arthur`Zaphod`Ford]; iq:98 42 126)
q)ktc
lname      fname | iq 
-----------------| ---
Dent       Arthur| 98 
Beeblebrox Zaphod| 42 
Prefect    Ford  | 126

復合主鍵的查找可以通過一個復合的鍵：

q)ktc[`lname`fname!`Beeblebrox`Zaphod]
iq| 42

對于一個簡單的鍵，我們可以簡化查找：

q)ktc[`Dent`Arthur]
iq| 98

空的多鍵值表的創建：

q)ktc:([lname:`symbol$();fname:`symbol$()] iq:`int$())
q)ktc:([lname:0#`;fname:0#`] iq:0#0)

10. 提取復合鍵
可以通過復合鍵的列表來提取對應的記錄

q)ktc (`Dent`Arthur;`Prefect`Ford)
iq
---
98
126

當然也可以通過匿名表來提取

q)ktc ([] lname:`Dent`Prefect; fname:`Arthur`Ford)

當然也可以用#來提取子字典

q)K:([] lname:`Dent`Prefect; fname:`Arthur`Ford)
q)K#ktc
lname   fname | iq 
--------------| ---
Dent    Arthur| 98 
Prefect Ford  | 126

11. 提取列數據
在這一小節中我們使用如下兩個例子：

q)kts:([k:101 102 103] v1:`a`b`c; v2:1.1 2.2 3.3)
q)kts
_
q)ktc:([k1:`a`b`c;k2:`x`y`z] v1:`a`b`c; v2:1.1 2.2 3.3)
q)ktc
_

提取特定列的做法：

q)kts[([] k:101 103)][`v1]
`a`c
q)ktc[([] k1:`a`c;k2:`x`z)][`v1`v2]

也可以使用index at depth的做法

q)kts[([] k:101 103); `v1]
_
q)ktc[([] k1:`a`c;k2:`x`z); `v1`v2]
_

外鍵是指表中的一列，該列的數據都在另一個表中的主鍵中。
1. 外鍵的定義
定義：A foreign key is one or more table columns whose values are defined as an enumeration over the key column(s) of a keyed table.

2， 外鍵的例子
以下表為例

q)kt:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)

以eid列為外鍵的表定義如下，這里用到了枚舉，強制保證了該列出現的值都在另一個表的鍵值中

q)tdetails:([] eid:`kt$1003 1001 1002 1001 1002 1001; sc:126 36 92 39 98 42)

在meta命令中，可以看到外鍵出現在f列中：

q)meta tdetails
c  | t f  a
---| ------
eid| j kt  
sc | j    

內置函數fkeys返回一個表示外鍵的字典

q)fkeys tdetails
eid| kt

3. 清除外鍵

當想清楚一個外鍵時，對枚舉的列使用value函數

q)meta update value eid from tdetails
c  | t f a
---| -----
eid| j    
sc | j    

4. 外鍵和關系
設tf是一個帶有鍵表kt外鍵f的表，為了獲取kt中的某一列c，可以直接在select語句中直接使用點操作符f.c即可。

q)select eid.name, sc from tdetails
name       sc 
--------------
Prefect    126
Dent       36 
Beeblebrox 92 
Dent       39 
Beeblebrox 98 
Dent       42 

在這一節中，我們使用如下例子

q)t:([] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)
q)kt:([eid:1001 1002 1003] name:`Dent`Beeblebrox`Prefect; iq:98 42 126)

1. Append記錄
使用,:，帶列名時可以不同考慮順序

q)t,:`name`iq!(`W; 26)
q)t,:`iq`name!(200; `Albert)
q)t
name       iq
--------------
Dent       98
Beeblebrox 42
Prefect    126
Albert     200

不帶列名時必須考慮順序

q)t,:(`H; 142)
_
q)t,:(97;`J)
"type
q)t
_

2. First和Last記錄
使用函數first和last

q)first t
name| `Dent
iq  | 98
q)last t
name| `Albert
iq  | 200

使用#獲取前后幾行記錄

q)2#t
q)-3#kt

3. Find
find操作符?返回記錄的索引

q)t?`name`iq!(`Dent;98)
0

上式可簡化為

q)t?(`Dent;98)
0

也可以查多列

q)t?((`Dent;98);(`Prefect;126))
0 2

由于鍵表是一個字典，所以使用?相當于執行了反向查找，返回對應的鍵值

q)kt?`name`iq!(`Dent;98)
eid| 1001
q)kt?(`Dent;98)
eid| 1001

單個列的查找必須生成列值，或者使用匿名表的結構

q)t1:([] eid:1001 1002 1003)
q)t1?enlist each 1001 1002
0 1
q)t1?([] eid:1001 1002)
0 1

4. Union with,
使用join操作符,追加記錄到一個表中，但是不會執行類型檢查。

q)t,`name`iq!(`Slaartibartfast; `123)
name            iq  
--------------------
Dent            98  
Beeblebrox      42  
Prefect         126 
Slaartibartfast `123

只有表有完全一樣的meta結果時，兩個表才能合并成一個表。

q)t,([] name:1#`W; iq:1#26)
q)t,t

當鍵表使用,合并兩個meta結果相同的鍵表時，右邊的鍵表將upsert(update and insert)左邊的鍵表，不同的鍵將append，相同的鍵將update。

q)kt,([eid:1003 1004] name:`Prefect`W; iq:150 26)
eid | name       iq 
----| --------------
1001| Dent       98 
1002| Beeblebrox 42 
1003| Prefect    150
1004| W          26 

5. Coalesce ^
Coalesce^被用來合并兩個具有相同列的鍵表。^的效果與,的相同，除了這種情況：兩個鍵表相同鍵合并時，右邊的鍵表若為null，則左邊的保留下來。

q)([k:`a`b`c] v:10 0N 30)^([k:`a`b`c] v:100 200 0N)
k| v
-| ---
a| 100
b| 200
c| 30
q)([k:`a`b`c`x] v:10 0N 30 40)^([k:`a`b`c`y]; v:100 200 0N 0N)
k| v
-| ---
a| 100
b| 200
c| 30
x| 40
y|

^的執行效率沒有,的高，因為右運算元需要檢查是否為null。

6. 列 Join
兩個具有相同數量記錄的表可以使用join-each(,")來合并列。

q)([] c1:`a`b`c),"([] c2:100 200 300)
c1 c2 
------
a  100
b  200
c  300

在鍵表上的列join：

q)([k:1 2 3] v1:10 20 30),"([k:3 4 5] v2:1000 2000 3000)
k| v1 v2  
-| -------
1| 10     
2| 20     
3| 30 1000
4|    2000
5|    3000

1. 簡單的例子
在如下表中，lh列中儲存了一個嵌套的列表

q)tp:([] d:2015.01.01 2015.01.02; lh:(67.9 82.10; 72.8 88.4))
q)tp 0
d | 2015.01.01
lh| 67.9 82.1
q)tp `lh
67.9 82.1
72.8 88.4

2. 復合列數據的操作
復合列數據的定義：嵌套列中的元素都是簡單列表。

q)tm:([] wk:2015.01.01 2015.01.08; rv:(38.92 67.34; 16.99 5.14 128.23 31.69))
q)tm
wk         rv                     
----------------------------------
2015.01.01 38.92 67.34            
2015.01.08 16.99 5.14 128.23 31.69

Nested columns mean adverbs. Lots of adverbs.

q)select wk, srt:desc each rv, avgr:avg each rv, hi:max each rv from tm
wk         srt                     avgr    hi    
-------------------------------------------------
2015.01.01 67.34 38.92             53.13   67.34 
2015.01.08 128.23 31.69 16.99 5.14 45.5125 128.23

q)select wk, drp:neg 1_"deltas each desc each rv from tm
wk         drp             
---------------------------
2015.01.01 ,28.42          
2015.01.08 96.54 14.7 11.85

3. 復合外鍵
復合主鍵的鍵表：

q)ktc:([lname: `Dent`Beeblebrox`Prefect; fname:`Arthur`Zaphod`Ford]; iq:98 42 126)

有ktc外鍵的表：

q)tdetails:([] name:`ktc$(`Beeblebrox`Zaphod;`Prefect`Ford;`Beeblebrox`Zaphod); sc:36 126 42)

ktc的列就可以作為tdetails的虛擬列了

q)select name.lname, name.iq, sc from tdetails
lname      iq  sc 
------------------
Beeblebrox 42  36 
Prefect    126 126
Beeblebrox 42  42 

Attributes are metadata that you attach to lists of special forms. They are also used on a dictionary domain or a table column to speed retrieval for some operations.

屬性是描述性的，當你指定表中某一列具有某種屬性時，q語言會去檢查確認，但并不會幫你完成這個操作。

Kx says not to expect significant benefit from an attribute for fewer than a million items.

1. Sorted `s#
當某一列被指定為sorted的時候，線性搜索就會被替換為二分查找，查找速度更快。

當屬性被成功應用于列表時，它就變成了列表的一部分，并且q會檢查這個列表是否滿足這一屬性。

q)`s#1 2 4 8
`s#1 2 4 8
q)`s#2 1 3 4
"s-fail

排序函數asc會自動在其結果上應用sorted屬性，但是til不會

q)asc 2 1 8 4
`s#1 2 4 8
q)til 5
0 1 2 3 4

q)L:`s#1 2 3 4 5
q)L,:6
q)L
`s#1 2 3 4 5 6
q)L,:0
q)L
1 2 3 4 5 6 0

對字典應用sorted屬性，會在應用到其鍵值上，其查找算法就會被替代為二分查找。

q)d:`s#10 20 30 40 50!`a`b`c`d`e
q)key d
`s#10 20 30 40 50
q)d 10
`a
q)d 12
`a
q)d 15
`a
q)d 20
`b

2. Unique `u#

q)`u#2 1 4 8
`u#2 1 4 8
q)`u#2 1 4 8 2
"u-fail

Unique屬性的amend操作：

q)L:`u#2 1 4 8
q)L,:3
q)L
`u#2 1 4 8 3
q)L,:2
q)L
2 1 4 8 3 2

unique屬性可以作用于字典的域，表的一列或者鍵表的鍵。但是不能作用于一個字典，表或者鍵表。

3. Parted `p#
Parted屬性 `p#表明對所有出現的值，相同的值都是互相鄰近的。

q)`p#2 2 2 1 1 4 4 4 4 3 3
`p#2 2 2 1 1 4 4 4 4 3 3
q)`p#2 2 2 1 1 4 4 4 4 3 3 2
"u-fail
  [0]  `p#2 2 2 1 1 4 4 4 4 3 3 2

parted屬性在任何list的操作上都不會被保留下來，即使折耳根操作保留了這個屬性。

q)L:`p#1 1 2 3 3
q)L
`p#1 1 2 3 3
q)L,:3
q)L
1 1 2 3 3 3

4. Grouped `g#
可以作用在任何list上。

It causes q to create and maintain an index – essentially a hash table.

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

5. 去除屬性 `#
通過指令 `# 可以去除列表上的任何屬性：

q)L:`s#til 10
q)L
`s#0 1 2 3 4 5 6 7 8 9
q)`#L
0 1 2 3 4 5 6 7 8 9

Section End.