历史高频行情数据存储最佳实践：DolphinDB Array Vector 使用指南

越来越多的机构使用 L1/L2 的快照行情数据进行量化金融的研究。作为一个高性能时序数据库，DolphinDB 非常适合存储和处理海量的历史高频行情数据。针对快照数据包含多档位信息的特点，DolphinDB 研发了一种方便、灵活且高效的数据结构——Array Vector，可以显著地简化某些常用的查询与计算代码，提高存储和计算地性能。Array Vector 还可以存储不定长的二维数组，在数据处理、模型应用等方面都具有重要意义。

体验 DolphinDB Array Vector 带来的性能提升！戳「链接」获取：高频行情存储&计算解决方案。

概念

DolphinDB 提供了一种特殊的数据结构，数组向量（Array Vector），用以存储比如股票的多档报价数据。顾名思义，Array Vector 的每一个元素是一个一维数组（类型完全相同）。这种存储方式不仅可以简化某些查询与计算的代码，在不同列中含有大量重复数据的情况下，还可以提高数据压缩比，提升查询速度。计算上，Array Vector 可以与标量、向量或另一个 Array Vector 进行二元运算，能够方便地实现向量化运算，提升计算性能。

Array Vector 和矩阵（Matrix）都可以组织二维的结构化数据，但两者有很大区别。首先矩阵的每一行长度相同，Array Vector 无这一要求。其次，在 DolphinDB 的实现中，矩阵的存储是列优先，而Array Vector是行优先。根据实现方式的不同，Array Vector 又可以进一步分为 **Fast Array Vector（数组向量）**和 **Columnar Tuple（列式元组）**两种。后续在无特殊注明的情况下，Array Vector 一般指 Fast Array Vector。

Fast Array Vector 的实现有两个常规的向量组成，第二个向量连续存储所有行的数据，第一个向量存储每一行的数据结束的索引。这一种存储方式十分紧凑，读写和计算的效率都很高，但很难改变每一行的长度。为弥补这个不足，DolphinDB 引入了 **Columnar Tuple。**顾名思义，Columnar Tuple 是一个元组，代表一列，其中每一个元素代表一行，但值类型必须保持一致。Columnar Tuple 的元素都是一个独立的对象（Scalar 或 Vector），因此可以方便的更改。

Fast Array Vector 和 Columnar Tuple 的区别：

Fast Array Vector 目前暂时不支持 SYMBOL 和 STRING 两种类型；Columnar Tuple 支持。
使用 typestr 函数查看数据类型，Fast Array Vector 返回的是 “FAST XXX[] VECTOR”；Columnar Tuple 返回的是 “ANY VECTOR”，所以需要用 isColumnarTuple 函数判断变量类型是否为列式元组。
Fast Array Vector 的存储、查询、计算等效率更高，但更新和删除操作效率较低并且每一行的元素长度不能改变；Columnar Tuple 在更新和删除操作上的表现更好且每一行的元素长度允许改变。【上述的更新和删除操作是通过底层的 C++ 代码实现的。目前更新和删除的接口未开放，脚本层面还不支持更新和删除 Array Vector 中的元素。所以一般情况下，推荐用户使用 Fast Array Vector (数组向量)。】

Fast Array Vector 和 Columnar Tuple 的应用场景：

Fast Array Vector：数值类型的二维数组的存储和计算。比如，Level 2 行情的十档量价和50档委托等。
Columnar Tuple：需要频繁更新二维数组元素的场景。比如，响应式状态引擎内部会自动把输入的 Fast Array Vector 的列转化为 Columnar Tuple，以此提高更新引擎状态的效率。这部分的转化是引擎内部自动完成的，对用户是透明的。用户不会感知到这一个过程，只需要向引擎传入 Fast Array Vector 的列即可。

Array Vector 支持的函数和操作

Array Vector 的创建

创建 Array Vector 类型的变量

Fast Array Vector (数组向量)

（1）通过 array 或 bigarray 函数定义空的数组向量，并通过 append! 添加数据

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
/* x
[[1,2,3],[4,5],[6,7,8],[9,10]]
*/

（2）通过 fixedLengthArrayVector 将多个向量/元组/矩阵或表拼接成数组向量。

vec = 1 2 3
tp = [4 5 6, 7 8 9]
m =  matrix(10 11 12, 13 14 15, 16 17 18)
tb = table(19 20 21 as v1, 22 23 24 as v2)
x = fixedLengthArrayVector(vec, tp, m, tb)
/* x
[[1,4,7,10,13,16,19,22],[2,5,8,11,14,17,20,23],[3,6,9,12,15,18,21,24]]
*/

（3）通过 arrayVector 将单个向量拆分成数组向量。

x = arrayVector(3 5 8 10, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
/* x
[[1,2,3],[4,5],[6,7,8],[9,10]]
*/

Columnar Tuple (列式元组)

通过 setColumnarTuple! 函数将一个普通元组转换成列式元组。

x = [[1,2,3],[4,5],[6,7,8],[9,10]].setColumnarTuple!()
/* x
([1,2,3],[4,5],[6,7,8],[9,10])
*/

创建含有 Array Vector 类型列的表

（1）创建 Array Vector 类型的变量，将其指定为表中的一列。

Fast Array Vector 的变量在表中的列类型是 "XXX[]"，比如 "INT[]"、"DOUBLE[]" 等；

Columnar Tuple 的变量在表中为 ”ANY“ 类型。

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
t = table(1 2 3 4 as id, x as newCol1)
update t set newCol2=x
t["newCol3"] = y
/* t
id newCol1 newCol2 newCol3
-- ------- ------- -------
1  [1,2,3] [1,2,3] [1,2,3]
2  [4,5]   [4,5]   [4,5]  
3  [6,7,8] [6,7,8] [6,7,8]
4  [9,10]  [9,10]  [9,10] 
*/

t.schema().colDefs
/*
name    typeString typeInt extra comment
------- ---------- ------- ----- -------
id      INT        4                    
newCol1 INT[]      68                   
newCol2 INT[]      68                   
newCol3 ANY        25   
*/

（2）通过 fixedLengthArrayVector 将表中多列拼成一列。

t = table(1 2 3 4 as id, 1 3 5 6 as v1, 4 7 9 3 as v2)
t = select *, fixedLengthArrayVector(v1, v2) as newCol from t
/* t
id v1 v2 newCol
-- -- -- ------
1  1  4  [1,4] 
2  3  7  [3,7] 
3  5  9  [5,9] 
4  6  3  [6,3] 
*/

（3）通过 toArray + group by 将表中每组的数据组合成 Array Vector。

t = table(1 1 3 4 as id, 1 3 5 6 as v1)
new_t = select toArray(v1) as newV1 from t group by id
/* new_t
id newV1
-- -----
1  [1,3]
3  [5]  
4  [6]  
*/

注意事项：

因为 toArray 生成的结果是 Fast Array Vector 类型的数据，Fast Array Vector 暂时不支持 SYMBOL 和 STRING 类型，所以 toArray 函数暂时也不支持对 SYMBOL 和 STRING 的列使用。

在 group by 的时候，如果需要将 SYMBOL 和 STRING 类型的数据组合，建议使用字符串拼接，比如

t = table(1 1 3 4 as group_id, `a1`a2`a3`a4 as name)
new_t = select concat(name, ";") as name from t group by group_id 
/* new_t
group_id name 
-------- -----
1        a1;a2
3        a3   
4        a4        
*/

使用的时候，用 split 函数再将字符串拆分，比如

select *, name.split(";")[0] as name0 from new_t
/*
group_id name  name0
-------- ----- -----
1        a1;a2 a1   
3        a3    a3   
4        a4    a4   
*/

（4）设置 loadText 的 schema 和 arrayDelimiter，从文本文件中读取含 Fast Array Vector 列的表。

用 saveText 存储数据时，Fast Array Vector 的列会自动存储为如下格式：Array Vector 内部用 arrayDelimiter 隔开。

x = array(INT[], 0).append!([1 3 5, 2 7 9])
t = table(1 2 as id, x as value) 
saveText(t, "./test.csv")

"./test.csv" 内的文本内容

id,value
1,"1,3,5"
2,"2,7,9"

针对上面的 csv，读文本数据时，schema 中设置 value 列的类型为 “INT[]”，arrayDelimiter 设置为逗号 “,“。

t = loadText("./test.csv", schema=table(`id`value as name, ["INT", "INT[]"] as type), arrayDelimiter=",")
/* t
id value  
-- -------
1  [1,3,5]
2  [2,7,9]
*/t = loadText("./test.csv", schema=table(`id`value as name, ["INT", "INT[]"] as type), arrayDelimiter=",") /* t id value   -- ------- 1  [1,3,5] 2  [2,7,9] */

Array Vector 的基础操作

访问 Array Vector 中的元素

用户可以通过函数（row、at）的方式访问 Array Vector 的行列；也可以通过下标（“x[index]”）的方式访问 Array Vector 的元素。

当使用下标的方式（“x[index]”）访问 Array Vector 时满足以下规则：

（1）当 index 为标量或者数据对的时候，表示对列操作，比如 index=0 或者 index=0:3；

（2）当 index 为向量的时候，表示对行的操作，比如 index = [1, 2, 3]；

（3）当 index 越界时，对应位置的数据会用空值填充；

访问 Array Vector 变量中的行

通过 row 函数读取 Array Vector 中的一行。【只能访问一行，返回一个向量】

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x.row(1)
/*
[4,5]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y.row(1)
/*
[4,5]
*/

// 当 index 越界时，空值填充
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x.row(10)
/*
[,,,]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y.row(10)
/*
[,,,]
*/

通过 x[index] 且 index 为向量的方式访问 Array Vector 的行。【可以访问多行，返回一个和 x 相同类型的 Array Vector】

// 读取一行
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[[1]]
/*
[[4,5]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[[1]]
/*
([4,5])
*/

// 读取多行
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[[1, 2]]
/*
[[4,5],[6,7,8]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[[1, 2]]
/*
([4,5],[6,7,8])
*/

// 当 index 越界时，空值填充
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[[3, 4]]
/*
[[9,10],]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[[3, 4]]
/*
([9,10],)
*/

访问 Array Vector 变量中的列

通过 x[index] 且 index 为标量的方式访问 Array Vector 的一列。【只能访问一列，返回一个向量】

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[1]
/*
[2,5,7,10]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[1]
/*
[2,5,7,10]
*/

// 当 index 越界时，空值填充
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[10]
/*
[,,,]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[10]
/*
[,,,]
*/

通过 x[start:end] 的方式访问 Array Vector 的列。【可以访问多行，返回一个 Array Vector】

// end 不为空
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[0:2]
/*
[[1,2],[4,5],[6,7],[9,10]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[0:2]
/*
[[1,2],[4,5],[6,7],[9,10]]
*/

// end 为空
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[1:]
/*
[[2,3],[5],[7,8],[10]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[1:]
/*
([2,3],[5],[7,8],[10])
*/

// 当 index 越界时，空值填充
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[1:4]
/*
[[2,3,],[5,,],[7,8,],[10,,]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[1:4]
/*
[[2,3,],[5,,],[7,8,],[10,,]]
*/

注意事项：

x[start:end] 中必须满足 start >= 0 且 start < end，否则参数校验时抛出异常。

当 x 是 STRING 或 SYMBOL 类型的 Columnar Tuple，结果返回一个 Columnar Tuple；

当 x 是 Columnar Tuple 且 end == NULL（每一行的长度可能不一致），结果返回一个 Columnar Tuple；

其他情况下，结果都会返回一个 Fast Array Vector。

访问 Array Vector 变量中 r 行 c 列的元素

Fast Array Vector 可以通过 x[r, c] 的方式定位一个元素；Columnar Tuple 可以通过 x[c, r] 的方式定位一个元素

r, c = 2, 1
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[r, c]
/*
[7]
*/

y = [[1,2,3],[4,5],[6,7,8],[9,10]].setColumnarTuple!()
y[c, r]
/*
7
*/

注意事项：x[r, c] 中的索引 r 和 c 不能越界，否则参数校验时抛出异常。

先定位行，再定位列

r, c = 2, 1
rows, cols = [1, 2, 3], 0:2

// 用函数先定位某一行，再定位某一列
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x.row(r).at(c)
/*
7
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y.row(r).at(c)
/*
7
*/

// 用下标先定位某一行，再定位某一列
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[[r]][c]
/*
[7]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[[r]][c]
/*
[7]
*/

// 用下标先定位某几行，再定位某几列
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[rows][cols]
/*
[[4,5],[6,7],[9,10]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[rows][cols]
/*
[[4,5],[6,7],[9,10]]
*/

// 当 index 越界时，空值填充
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[2 3 4][1:3]
/*
[[7,8],[10,],[,]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[2 3 4][1:3]
/*
[[7,8],[10,],[,]]
*/

先定位列，再定位行

r, c = 2, 1
rows, cols = [1, 2, 3], 0:2

// 用下标先定位某一列，再定位某一行
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[c][r]
/*
7
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[c][r]
/*
7
*/

// 用下标先定位某几列，再定位某几行
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[cols][rows]
/*
[[4,5],[6,7],[9,10]]
*/

y = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
y[cols][rows]
/*
[[4,5],[6,7],[9,10]]
*/

// 当 index 越界时，空值填充
x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x[1:3][2 3 4]
/*
[[7,8],[10,],]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
y[1:3][2 3 4]
/*
[[7,8],[10,],]
*/

访问表中 Array Vector 列的元素

可以通过 x[index] 且 index 为标量或者数据对的方式将表中 Array Vector 列的指定位置的元素取出。

当 index 越界时，指定位置元素用空值填充。

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
t = table(1 2 3 4 as id, x as x, y as y)
new_t = select *, x[2] as x_newCol1, x[1:3] as x_newCol2, y[2] as y_newCol1, y[1:3] as y_newCol2 from t
/* new_t
id x       y       x_newCol1 x_newCol2 y_newCol1 y_newCol2
-- ------- ------- --------- --------- --------- ---------
1  [1,2,3] [1,2,3] 3         [2,3]     3         [2,3]    
2  [4,5]   [4,5]             [5,]                [5,]     
3  [6,7,8] [6,7,8] 8         [7,8]     8         [7,8]    
4  [9,10]  [9,10]            [10,]               [10,]    
*/

Array Vector 插入数据

Array Vector 目前支持末尾增加行的操作，暂时不支持修改和删除元素的操作。

通过 append! 方法向 Array Vector 的变量中插入数据

// 插入一行
x = array(INT[], 0).append!([1 2 3, 4 5 6])
x.append!(7)
x.append!([8 9])
/* x
[[1,2,3],[4,5,6],[7],[8,9]]
*/

y = [1 2 3, 4 5 6].setColumnarTuple!()
y.append!(7)
y.append!([8 9])
/* y
([1,2,3],[4,5,6],7,[8,9])
*/

// 插入多行
x = array(INT[], 0).append!([1 2 3, 4 5 6])
x.append!([7, 8 9])
/* x
[[1,2,3],[4,5,6],[7],[8,9]]
*/

y = [1 2 3, 4 5 6].setColumnarTuple!()
y.append!([7, 8 9])
/* y
([1,2,3],[4,5,6],7,[8,9])
*/

通过 tableInsert 、 append! 等方法向含有 Array Vector 列的表中插入数据

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
t = table(1 2 3 4 as id, x as col1, y as col2)
t.tableInsert(5, 11, 11)
t.tableInsert(6, [12 13 14], [12 13 14])
t.append!(table(7 8 as id, [15 16, 17] as col1, [15 16, 17] as col2))
/* t
id col1       col2      
-- ---------- ----------
1  [1,2,3]    [1,2,3]   
2  [4,5]      [4,5]     
3  [6,7,8]    [6,7,8]   
4  [9,10]     [9,10]    
5  [11]       11        
6  [12,13,14] [12,13,14]
7  [15,16]    [15,16]   
8  [17]       17         
*/

转化 Array Vector 为向量、矩阵

（1）通过 flatten 函数可以将 Array Vector 展开成一维向量。

x = array(INT[], 0).append!([1 2 3, 4 5 6])
z = flatten(x)
/* z
[1,2,3,4,5,6]
*/

y = [1 2 3, 4 5 6].setColumnarTuple!()
z = flatten(y)
/* z
[1,2,3,4,5,6]
*/

（2）通过 matrix 函数可以将等长的 Array Vector 转化为矩阵。

x = array(INT[], 0).append!([1 2 3, 4 5 6])
z = matrix(x)
/* z
#0 #1 #2
-- -- --
1  2  3 
4  5  6 
*/

y = [1 2 3, 4 5 6].setColumnarTuple!()
z = matrix(y)
/* z
#0 #1
-- --
1  4 
2  5 
3  6 
*/

对 Fast Array Vector 的每个元素过滤

可以通过 x[cond] 的方式将 Fast Array Vector 所有满足 cond 条件的元素过滤出来。

（该功能 1.30.21 / 2.00.10 后支持）

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
z = x[x>=5]
/* z
[,[5],[6,7,8],[9,10]]
*/

t = table(1 2 3 4 as id, x as x)
new_t = select *, x[x>=5] as newCol from t
/* new_t
id x       newCol 
-- ------- -------
1  [1,2,3] []  
2  [4,5]   [5]    
3  [6,7,8] [6,7,8]
4  [9,10]  [9,10] 
*/

Array Vector 的计算

和标量计算

即把 Array Vector 的每个元素和标量做计算。

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
z = x + 1
/* z
[[2,3,4],[5,6],[7,8,9],[10,11]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
z = y + 1
/* z
([2,3,4],[5,6],[7,8,9],[10,11])
*/

t = table(1 2 3 4 as id, x as x, y as y)
new_t = select *, x + 1 as new_x, y + 1 as new_y from t
/* new_t
id x       y       new_x   new_y  
-- ------- ------- ------- -------
1  [1,2,3] [1,2,3] [2,3,4] [2,3,4]
2  [4,5]   [4,5]   [5,6]   [5,6]  
3  [6,7,8] [6,7,8] [7,8,9] [7,8,9]
4  [9,10]  [9,10]  [10,11] [10,11]
*/

和向量计算

要求向量的长度和 Array Vector 的行数相等。

即把 Array Vector 的每行数据和向量对应位置的元素做计算。

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
z = x * [1, 2, 3, 4]
/* z
[[1,2,3],[8,10],[18,21,24],[36,40]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
z = y * [1, 2, 3, 4]
/* z
([1,2,3],[8,10],[18,21,24],[36,40])
*/

t = table(1 2 3 4 as id, x as x, y as y)
new_t = select *, x*id as new_x, y*id as new_y from t
/* new_t
id x       y       new_x      new_y     
-- ------- ------- ---------- ----------
1  [1,2,3] [1,2,3] [1,2,3]    [1,2,3]   
2  [4,5]   [4,5]   [8,10]     [8,10]    
3  [6,7,8] [6,7,8] [18,21,24] [18,21,24]
4  [9,10]  [9,10]  [36,40]    [36,40]  
*/

和 Array Vector 计算

要求两个 Array Vector 的大小相等。

即把两个 Array Vector 的对应位置的元素做计算。

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
xx = array(INT[], 0).append!([3 1 2, 3 1, 1 2 3, 0 1])
z = pow(x, xx)
/* z
[[1,2,9],[64,5],[6,49,512],[1,10]]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
yy = [3 1 2, 3 1, 1 2 3, 0 1].setColumnarTuple!()
z = pow(y, yy)
/* z
([1,2,9],[64,5],[6,49,512],[1,10])
*/

t = table(1 2 3 4 as id, x as x, xx as xx, y as y, yy as yy)
new_t = select *, pow(x, xx) as new_x, pow(y, yy) as new_y from t
/* new_t
id x       xx      y       yy      new_x      new_y     
-- ------- ------- ------- ------- ---------- ----------
1  [1,2,3] [3,1,2] [1,2,3] [3,1,2] [1,2,9]    [1,2,9]   
2  [4,5]   [3,1]   [4,5]   [3,1]   [64,5]     [64,5]    
3  [6,7,8] [1,2,3] [6,7,8] [1,2,3] [6,49,512] [6,49,512]
4  [9,10]  [0,1]   [9,10]  [0,1]   [1,10]     [1,10]     
*/

注意事项：

Fast Array Vector 和 Columnar Tuple 之间不能直接计算。

按行计算

（1）Array Vector 支持行计算系列（row 系列）。

为了满足用户逐行计算的需求，DolphinDB 设计了 row 系列函数。

row 系列函数以 “rowFunc“ 的格式命名，例如 rowSum、rowAlign 等函数。

row 系列函数的输入的参数可以是向量 / 向量元组 / 矩阵 / Array Vector。

单目函数示例：按行求和

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
z = rowSum(x)
/* z
[6,9,21,19]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
z = rowSum(y)
/* z
[6,9,21,19]
*/

t = table(1 2 3 4 as id, x as x, y as y)
new_t = select *, rowSum(x) as new_x, rowSum(y) as new_y from t
/* new_t
id x       y       new_x new_y
-- ------- ------- ----- -----
1  [1,2,3] [1,2,3] 6     6    
2  [4,5]   [4,5]   9     9    
3  [6,7,8] [6,7,8] 21    21   
4  [9,10]  [9,10]  19    19   
*/

双目函数示例（Array Vector 和向量）：按行求加权平均

x = array(INT[], 0).append!([1 2 3, 4 5 6, 6 7 8, 9 10 11])
z = rowWavg(x, [1, 1, 2])
/* z
[2.25,5.25,7.25,10.25]
*/

y = [1 2 3, 4 5 6, 6 7 8, 9 10 11].setColumnarTuple!()
z = rowWavg(y, [1, 1, 2])
/* z
[2.25,5.25,7.25,10.25]
*/

t = table(1 2 3 4 as id, x as x, y as y)
new_t = select *, rowWavg(x, [1, 1, 2]) as new_x, rowWavg(y, [1, 1, 2]) as new_y from t
/* new_t
id x         y         new_x new_y
-- --------- --------- ----- -----
1  [1,2,3]   [1,2,3]   2.25  2.25 
2  [4,5,6]   [4,5,6]   5.25  5.25 
3  [6,7,8]   [6,7,8]   7.25  7.25 
4  [9,10,11] [9,10,11] 10.25 10.25
*/

双目函数示例（Array Vector 和 Array Vector）：按行求相关系数

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
xx = array(INT[], 0).append!([3 1 2, 3 1, 1 2 3, 0 1])
z = rowCorr(x, xx)
/* z
[-0.5,-1,1,1]
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
yy = [3 1 2, 3 1, 1 2 3, 0 1].setColumnarTuple!()
z = rowCorr(y, yy)
/* z
[-0.5,-1,1,1]
*/

t = table(1 2 3 4 as id, x as x, xx as xx, y as y, yy as yy)
new_t = select *, rowCorr(x, xx) as new_x, rowCorr(y, yy) as new_y from t
/* new_t
id x       xx      y       yy      new_x new_y
-- ------- ------- ------- ------- ----- -----
1  [1,2,3] [3,1,2] [1,2,3] [3,1,2] -0.5  -0.5 
2  [4,5]   [3,1]   [4,5]   [3,1]   -1    -1   
3  [6,7,8] [1,2,3] [6,7,8] [1,2,3] 1     1    
4  [9,10]  [0,1]   [9,10]  [0,1]   1     1       
*/

特殊双目函数示例：按行对齐

针对金融场景的存在的特殊的数据对齐规则，DolphinDB 开发了 rowAlign 和 rowAt 函数。

rowAlign(left, right, how)：实现 left 和 right 的数据对齐。输入参数 left、right 是数组向量，表示需要对齐的数据；how 是字符串，表述对齐的方式；最终返回一个长度为 2 的元组，分别表示对齐后数据在原数据中的索引。

rowAt(X, Y)：实现按行从 X 中取出 Y 索引的元素。输入参数 X 是矩阵或数组向量；当 Y 是和 X 行数相等的向量时，返回一个与 Y 长度相同的向量；当 Y 是和 X 行数相等的数组向量时，返回一个与 Y 维度相同的数组向量。

下面以 how="bid" 为例，说明具体的 rowAlign 对齐结果。

假设 left 是某个时刻的五档买价，right 是上一时刻的五档买价，都是严格单调减的序列

根据买价的值，按行进行数据对齐

根据 how 指定的对齐规则，保留满足条件的数据。how="bid" 时，最大值为 max(max(left), max(right)) = max(8.99, 9.00) = 9.00；最小值为 max(min(left), min(right)) = max(8.91, 8.95) = 8.95。【下图蓝色部分为删除部分】

获取剩余数据在原来向量中的索引，没有数据的位置用 -1 填充。

下面以上图 left 和 leftIndex 为例，说明具体的 rowAt(left, leftIndex) 取数结果。

left = array(DOUBLE[], 0).append!([9.00 8.98 8.97 8.96 8.95, 8.99 8.97 8.95 8.93 8.91])
right = prev(left)
/* 
left:[[9,8.98,8.97,8.96,8.949999999999999],[8.99,8.97,8.949999999999999,8.929999999999999,8.91]]
right:[,[9,8.98,8.97,8.96,8.949999999999999]]
*/

leftIndex, rightIndex = rowAlign(left, right, how="bid")
/*
leftIndex:[[0,1,2,3,4],[-1,0,-1,1,-1,2]]
rightIndex:[[-1,-1,-1,-1,-1],[0,-1,1,2,3,4]]
*/

leftResult = rowAt(left, leftIndex)
rightResult = rowAt(right, rightIndex)
/*
leftResult:[[9,8.98,8.97,8.96,8.949999999999999],[,8.99,,8.97,,8.949999999999999]]
rightResult:[[,,,,],[9,,8.98,8.97,8.96,8.949999999999999]]
*/

（2）Fast Array Vector 支持调用高阶函数 byRow，对数组向量的每行元素进行计算。

窗口函数示例：求每行的累计和

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
z = byRow(cumsum, x)
/* z
[[1,3,6],[4,9],[6,13,21],[9,19]]
*/

t = table(1 2 3 4 as id, x as x)
new_t = select *, byRow(cumsum, x) as new_x from t
/* new_t
id x       new_x        
-- ------- ---------
1  [1,2,3] [1,3,6]  
2  [4,5]   [4,9]    
3  [6,7,8] [6,13,21]
4  [9,10]  [9,19]   
*/

注意事项：

byRow 只支持 Fast Array Vector
使用 byRow 函数时，自定义函数 func 的返回值只能是标量（defg 定义的聚合函数）或者和 Fast Array Vector 每行等长的向量（类似窗口函数）。

// 返回值是标量
defg foo1(v){
    return last(v)-first(v)
}

// 返回值是和 v 等长的向量
def foo2(v){
    return v  prev(v) - 1
}

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
x1 = byRow(foo1, x)
x2 = byRow(foo2, x)
/*
x1: [2,1,2,1]
x2: [[,1,0.5],[,0.25],[,0.166666666666667,0.142857142857143],[,0.111111111111111]]
*/

t = table(1 2 3 4 as id, x as x)
new_t = select *, byRow(foo1, x) as x1, byRow(foo2, x) as x2 from t
/* new_t
id x       x1 x2                                    
-- ------- -- --------------------------------------
1  [1,2,3] 2  [,1,0.5]                              
2  [4,5]   1  [,0.25]                               
3  [6,7,8] 2  [,0.166666666666667,0.142857142857143]
4  [9,10]  1  [,0.111111111111111]                  
*/

（3）Array Vector 支持调用高阶函数 each 和 loop，对 Array Vector 的每行元素进行计算。和 byRow 函数使用方式类似，都是将自定义函数作用在 Array Vector 的每一行上。

两者的区别是：byRow 只支持 Fast Array Vector；each 和 loop 支持 Fast Array Vector 和 Columnar Tuple。each 和 loop 的自定义函数 func，返回值没有限制，可以是和每行元素不同长度的向量。自定义函数 func 返回值是向量时，返回的结果是 tuple 类型，对应表中的列是 Columnar Tuple 类型。byRow 的自定义函数 func 返回值是向量时，byRow 返回的结果是 Fast Array Vector 类型，对应表中的列也是 Fast Array Vector 类型。

// 返回值可以是和 v 不等长的向量
def foo3(v){
    return [last(v)-first(v), last(v)+first(v)]
} 

x = array(INT[], 0).append!([1 2 3, 4 5, 6 7 8, 9 10])
z = loop(foo3, x)
/* z
([2,4],[1,9],[2,14],[1,19])
*/

y = [1 2 3, 4 5, 6 7 8, 9 10].setColumnarTuple!()
z = loop(foo3, y)
/* z
([2,4],[1,9],[2,14],[1,19])
*/

t = table(1 2 3 4 as id, x as x, y as y)
new_t = select *, loop(foo3, x) as new_x, loop(foo3, y) as new_y from t
/* new_t
id x       y       new_x  new_y 
-- ------- ------- ------ ------
1  [1,2,3] [1,2,3] [2,4]  [2,4] 
2  [4,5]   [4,5]   [1,9]  [1,9] 
3  [6,7,8] [6,7,8] [2,14] [2,14]
4  [9,10]  [9,10]  [1,19] [1,19]
*/

API 写入

C++ API

Step1：C++ 中创建表对象。指定对应 Array Vector 列的类型为 DT_XX_ARRAY。

（比如下例中的 value 列是 INT 类型的 Array Vector，所以指定为 DT_INT_ARRAY）

int rowNum = 3;
int colNum = 2;
vector colNames = {"id","value"};
vector colTypes = {DT_INT, DT_INT_ARRAY};
ConstantSP table = Util::createTable(colNames, colTypes, rowNum, rowNum+1);
vector columnVecs;
columnVecs.reserve(colNum);
for(int i = 0; i < colNum; ++i) {
    columnVecs.emplace_back(table->getColumn(i));
}

Step2：逐行向 C++ 的表对象中添加数据。创建一个 DdbVector 类型的向量，作为 Array Vector 里的一行。

for(int i = 0; i < rowNum; ++i) {
    // 构造 Array Vector 的一行
    DdbVector intVec(0, 10);
    for(int j = 0; j < 3; ++j) {
        intVec.add(i*3+j);
    }
    VectorSP value_row = intVec.createVector(DT_INT);
    columnVecs[0]->setInt(i, i);        // id 列
    columnVecs[1]->set(i, value_row);    // value 列
}

Step3：连接 DolphinDB，上传数据。

（示例中，是通过 upload 方法把表数据 table 上传到 DolphinDB 的内存表 myTable。C++ API 的更多操作可以查看教程：C++ API使用教程）

// 连接 DolphinDB 节点
DBConnection conn;
conn.connect("127.0.0.1", 8848);
conn.login("admin", "123456", false);
// 上传数据到内存表
conn.upload("myTable", table);

Step4：查询数据

string script = "select * from myTable;";
ConstantSP result = conn.run(script);
std::cout<<"------ check data ------"<getString()<


Java API
Step1：连接 DolphinDB，并在DolphinDB 中创建一张维度表，用于接收数据。指定对应列的类型为 XX[]。
（比如下例中的 value 列是 INT 类型的 Array Vector，所以指定为 INT[]）
// 连接 DolphinDB 的节点
DBConnection conn = new DBConnection();
boolean success = conn.connect("127.0.0.1", 8848, "admin", "123456");
// 创建维度表
String ddb_script = "dbName = "dfs://testDB"
" +
                "tbName = "test"
" +
                "if(existsDatabase(dbName)) {
" +
                "    dropDatabase(dbName)
" +
                "}
" +
                "db = database(dbName, VALUE, 1 2 3 4, , 'TSDB')
" +
                "schemaTB = table(1:0, `id`value, [INT, INT[]])
" +
                "pt = createTable(db, schemaTB, tbName, sortColumns=`id)";
conn.run(ddb_script);
Step2：Java 构造数据，创建表对象。每一列对应一个 List，Array Vector 列是一个类型为 vector 的 List，其中每一行是一个向量。
List colNames = Arrays.asList("id", "value");
List cols = new ArrayList<>(6);
int rowNum = 4;
List idCol = new ArrayList<>(rowNum);
List valueCol = new ArrayList<>(rowNum);    // Array Vector 列
for(int i = 0; i < rowNum; ++i) {
    idCol.add(i + 1);
    List valueRow = new ArrayList<>(50);   // Array Vector 中的一行
    for(int j = 0; j < 3; ++j) {
        valueRow.add(i*3 +j);
    }
    valueCol.add(new BasicIntVector(valueRow));
}
cols.add(new BasicIntVector(idCol));
cols.add(new BasicArrayVector(valueCol));
BasicTable tb = new BasicTable(colNames, cols);
Step3：往预先创建的维度表中插入数据。
（示例中，是通过 tableInsert 方法把表数据 tb 上传到 DolphinDB 的维度表 loadTable ('dfs://testDB','test')。Java API 的更多操作可以查看教程：Java API使用教程）
List tbArg = new ArrayList<>(1);
tbArg.add(tb);
conn.run("tableInsert{loadTable('dfs://testDB','test')}", tbArg);
Step4：查询数据
BasicTable t;
t = (BasicTable)conn.run("select * from loadTable('dfs://testDB','test')");
System.out.println(t.getString());
Python API
Step1：Python 中创建表对象。
（比如下例中的 value 列是 INT 类型的 Array Vector）
df = pd.DataFrame({
    'id': [1, 2, 3, 4],
    'value': [np.array([1,2,3],dtype=np.int64), np.array([4,5,6],dtype=np.int64), np.array([7,8,9],dtype=np.int64), np.array([10,11,12],dtype=np.int64)]
})
Step2：连接 DolphinDB，上传数据。
（示例中，是通过 table 方法把数据框 df 上传到 DolphinDB 的内存表 myTable。Python API 的更多操作可以查看教程：Python API使用教程）
// 连接 DolphinDB 节点
s = ddb.session()
s.connect("127.0.0.1", 8848, "admin", "123456")
// 上传数据到内存表
s.table(data=df, tableAliasName="myTable")
Step3：查询数据
t = s.run("select * from myTable")
print(t)
Array Vector 在 level2 快照数据中的应用
快照数据的存储
Array Vector 在存储中的一个典型应用场景就是存储快照十档行情数据。
level 2 的快照数据包含买卖十档价格、十档成交量、十档实际总委托笔数、前 50 笔买卖订单等多种多档数据，并且后续也常常需要将这些数据整体计算处理，所以很适合将多档数据作为整体存储为一列。
多档多列存储
Array Vector 存储
以上交所 level 2 的快照数据为例，进行具体的说明。下面是本教程中的存储的分布式表结构。
字段名称 数据类型 数据说明
SecurityID SYMBOL 证券代码
DateTime TIMESTAMP 日期时间
PreClosePx DOUBLE 昨收价
OpenPx DOUBLE 开始价
HighPx DOUBLE 最高价
LowPx DOUBLE 最低价
LastPx DOUBLE 最新价
TotalVolumeTrade INT 成交总量
TotalValueTrade DOUBLE 成交总金额
InstrumentStatus SYMBOL 交易状态
BidPrice DOUBLE[] 申买十价
BidOrderQty INT[] 申买十量
BidNumOrders INT[] 申买十实际总委托笔数
BidOrders INT[] 申买一前 50 笔订单
OfferPrice DOUBLE[] 申卖十价
OfferOrderQty INT[] 申卖十量
OfferNumOrders INT[] 申卖十实际总委托笔数
OfferOrders INT[] 申卖一前 50 笔订单
NumTrades INT 成交笔数
IOPV DOUBLE ETF 净值估值
TotalBidQty INT 委托买入总量
TotalOfferQty INT 委托卖出总量
WeightedAvgBidPx DOUBLE 加权平均委买价格
WeightedAvgOfferPx DOUBLE 加权平均委卖价格
TotalBidNumber INT 买入总笔数
TotalOfferNumber INT 卖出总笔数
BidTradeMaxDuration INT 买入成交最大等待时间
OfferTradeMaxDuration INT 买入成交最大等待时间
NumBidOrders INT 买方委托价位数
NumOfferOrders INT 卖方委托价位数
WithdrawBuyNumber INT 买入撤单笔数
WithdrawBuyAmount INT 买入撤单数量
WithdrawBuyMoney DOUBLE 买入撤单金额
WithdrawSellNumber INT 卖出撤单笔数
WithdrawSellAmount INT 卖出撤单数量
WithdrawSellMoney DOUBLE 卖出撤单金额
ETFBuyNumber INT ETF 申购笔数
ETFBuyAmount INT ETF 申购数量
ETFBuyMoney DOUBLE ETF 申购金额
ETFSellNumber INT ETF 赎回笔数
ETFSellAmount INT ETF 赎回数量
ETFSellMoney DOUBLE ETF 赎回金额
其中，买卖十档价格（BidPrice / OfferPrice）、十档成交量（BidOrderQty / OfferOrderQty）、十档实际总委托笔数（BidNumOrders / OfferNumOrders）、前 50 笔买卖订单（BidOrders / OfferOrders）这 8 个字段都采用 Array Vector 的格式存储。在建表时，通过 “DOUBLE[]” 和 “INT[]” 的方式指定列的类型为 Array Vector。下面是对应的建表语句。
dbName = "dfs://SH_TSDB_snapshot_ArrayVector"
tbName = "snapshot"
if(existsDatabase(dbName)){
	dropDatabase(dbName)
}
db1 = database(, VALUE, 2020.01.01..2021.01.01)
db2 = database(, HASH, [SYMBOL, 20])
db = database(dbName, COMPO, [db1, db2], , "TSDB")
schemaTable = table(
	array(SYMBOL, 0) as SecurityID,
	array(TIMESTAMP, 0) as DateTime,
	array(DOUBLE, 0) as PreClosePx,
	array(DOUBLE, 0) as OpenPx,
	array(DOUBLE, 0) as HighPx,
	array(DOUBLE, 0) as LowPx,
	array(DOUBLE, 0) as LastPx,
	array(INT, 0) as TotalVolumeTrade,
	array(DOUBLE, 0) as TotalValueTrade,
	array(SYMBOL, 0) as InstrumentStatus,
	array(DOUBLE[], 0) as BidPrice,
	array(INT[], 0) as BidOrderQty,
	array(INT[], 0) as BidNumOrders,
	array(INT[], 0) as BidOrders,
	array(DOUBLE[], 0) as OfferPrice,
	array(INT[], 0) as OfferOrderQty,
	array(INT[], 0) as OfferNumOrders,
	array(INT[], 0) as OfferOrders,
	array(INT, 0) as NumTrades,
	array(DOUBLE, 0) as IOPV,
	array(INT, 0) as TotalBidQty,
	array(INT, 0) as TotalOfferQty,
	array(DOUBLE, 0) as WeightedAvgBidPx,
	array(DOUBLE, 0) as WeightedAvgOfferPx,
	array(INT, 0) as TotalBidNumber,
	array(INT, 0) as TotalOfferNumber,
	array(INT, 0) as BidTradeMaxDuration,
	array(INT, 0) as OfferTradeMaxDuration,
	array(INT, 0) as NumBidOrders,
	array(INT, 0) as NumOfferOrders,
	array(INT, 0) as WithdrawBuyNumber,
	array(INT, 0) as WithdrawBuyAmount,
	array(DOUBLE, 0) as WithdrawBuyMoney,
	array(INT, 0) as WithdrawSellNumber,
	array(INT, 0) as WithdrawSellAmount,
	array(DOUBLE, 0) as WithdrawSellMoney,
	array(INT, 0) as ETFBuyNumber,
	array(INT, 0) as ETFBuyAmount,
	array(DOUBLE, 0) as ETFBuyMoney,
	array(INT, 0) as ETFSellNumber,
	array(INT, 0) as ETFSellAmount,
	array(DOUBLE, 0) as ETFSellMoney
)
db.createPartitionedTable(table=schemaTable, tableName=tbName, partitionColumns=`DateTime`SecurityID, compressMethods={DateTime:"delta"}, sortColumns=`SecurityID`DateTime, keepDuplicates=ALL)
导入数据时，可以通过 fixedLengthArrayVector 函数将多档的数据合并成一列 Array Vector。下面是对应的导入数据脚本。
 def transform(data){
	t = select SecurityID, DateTime, PreClosePx, OpenPx, HighPx, LowPx, LastPx, TotalVolumeTrade, TotalValueTrade, InstrumentStatus,
		      fixedLengthArrayVector(BidPrice0, BidPrice1, BidPrice2, BidPrice3,  BidPrice4, BidPrice5, BidPrice6, BidPrice7, BidPrice8, BidPrice9) as BidPrice,
		      fixedLengthArrayVector(BidOrderQty0, BidOrderQty1, BidOrderQty2, BidOrderQty3,  BidOrderQty4, BidOrderQty5, BidOrderQty6, BidOrderQty7, BidOrderQty8, BidOrderQty9) as BidOrderQty,
		      fixedLengthArrayVector(BidNumOrders0, BidNumOrders1, BidNumOrders2, BidNumOrders3,  BidNumOrders4, BidNumOrders5, BidNumOrders6, BidNumOrders7, BidNumOrders8, BidNumOrders9) as BidNumOrders,
		      fixedLengthArrayVector(BidOrders0, BidOrders1, BidOrders2, BidOrders3,  BidOrders4, BidOrders5, BidOrders6, BidOrders7, BidOrders8, BidOrders9, BidOrders10, BidOrders11, BidOrders12, BidOrders13,  BidOrders14, BidOrders15, BidOrders16, BidOrders17, BidOrders18, BidOrders19, BidOrders20, BidOrders21, BidOrders22, BidOrders23,  BidOrders24, BidOrders25, BidOrders26, BidOrders27, BidOrders28, BidOrders29, BidOrders30, BidOrders31, BidOrders32, BidOrders33,  BidOrders34, BidOrders35, BidOrders36, BidOrders37, BidOrders38, BidOrders39, BidOrders40, BidOrders41, BidOrders42, BidOrders43,  BidOrders44, BidOrders45, BidOrders46, BidOrders47, BidOrders48, BidOrders49) as BidOrders,
		      fixedLengthArrayVector(OfferPrice0, OfferPrice1, OfferPrice2, OfferPrice3,  OfferPrice4, OfferPrice5, OfferPrice6, OfferPrice7, OfferPrice8, OfferPrice9) as OfferPrice,
		      fixedLengthArrayVector(OfferOrderQty0, OfferOrderQty1, OfferOrderQty2, OfferOrderQty3,  OfferOrderQty4, OfferOrderQty5, OfferOrderQty6, OfferOrderQty7, OfferOrderQty8, OfferOrderQty9) as OfferOrderQty,
		      fixedLengthArrayVector(OfferNumOrders0, OfferNumOrders1, OfferNumOrders2, OfferNumOrders3,  OfferNumOrders4, OfferNumOrders5, OfferNumOrders6, OfferNumOrders7, OfferNumOrders8, OfferNumOrders9) as OfferNumOrders,
		      fixedLengthArrayVector(OfferOrders0, OfferOrders1, OfferOrders2, OfferOrders3,  OfferOrders4, OfferOrders5, OfferOrders6, OfferOrders7, OfferOrders8, OfferOrders9, OfferOrders10, OfferOrders11, OfferOrders12, OfferOrders13,  OfferOrders14, OfferOrders15, OfferOrders16, OfferOrders17, OfferOrders18, OfferOrders19, OfferOrders20, OfferOrders21, OfferOrders22, OfferOrders23,  OfferOrders24, OfferOrders25, OfferOrders26, OfferOrders27, OfferOrders28, OfferOrders29, OfferOrders30, OfferOrders31, OfferOrders32, OfferOrders33,  OfferOrders34, OfferOrders35, OfferOrders36, OfferOrders37, OfferOrders38, OfferOrders39, OfferOrders40, OfferOrders41, OfferOrders42, OfferOrders43,  OfferOrders44, OfferOrders45, OfferOrders46, OfferOrders47, OfferOrders48, OfferOrders49) as OfferOrders,
		      NumTrades, IOPV, TotalBidQty, TotalOfferQty, WeightedAvgBidPx, WeightedAvgOfferPx, TotalBidNumber, TotalOfferNumber, BidTradeMaxDuration,OfferTradeMaxDuration, NumBidOrders, NumOfferOrders, WithdrawBuyNumber, WithdrawBuyAmount, WithdrawBuyMoney,WithdrawSellNumber, WithdrawSellAmount, WithdrawSellMoney, ETFBuyNumber, ETFBuyAmount, ETFBuyMoney, ETFSellNumber, ETFSellAmount, ETFSellMoney
		      from data
	return t
}

def loadData(csvDir, dbName, tbName){
	schemaTB = extractTextSchema(csvDir)
	update schemaTB set type = "SYMBOL" where name = "SecurityID"
	loadTextEx(dbHandle=database(dbName), tableName=tbName, partitionColumns=`DateTime`SecurityID, sortColumns=`SecurityID`DateTime, filename=csvDir, schema=schemaTB, transform=transform)
}
// 后台提交导入任务
csvDir = "/home/v2/下载/data/testdata/snapshot_100stocks_multi.csv"
dbName, tbName = "dfs://SH_TSDB_snapshot_ArrayVector", "snapshot"
submitJob("loadData", "load Data", loadData{csvDir, dbName, tbName})
getRecentJobs()
快照数据分组时保留明细
Array Vector 在存储中的另一个典型应用场景就是分组计算时将组内所有明细数据保留。
DolphinDB 提供了函数 toArray。toArray 搭配 group by 语句，可以将 group by 分组的数据存储成数组向量的一行，便于用户直接查看该分组下的所有数据。
比如，将快照数据聚合成 5 分钟 tick 数据并入库，结果表字段包括高开低收、成交量、成交金额、bid0 和ask0 的量价切片。
// 创建存储 5 min tick 数据的分布式库表
def createFiveMinuteBarDB(dbName, tbName){
	if(existsDatabase(dbName)){
		dropDatabase(dbName)
	}
	db = database(dbName, VALUE, 2021.01.01..2021.12.31, , "TSDB")
	colNames = `SecurityID`DateTime`OpenPx`HighPx`LowPx`LastPx`TotalVolume`TotalValueTrade`BidPrice0`BidOrderQty0`OfferPrice0`OfferOrderQty0
	colTypes = [SYMBOL, TIMESTAMP, DOUBLE, DOUBLE, DOUBLE, DOUBLE, LONG, DOUBLE, DOUBLE[], INT[], DOUBLE[], INT[]]
	schemaTable = table(1:0, colNames, colTypes)
	db.createPartitionedTable(table=schemaTable, tableName=tbName, partitionColumns=`DateTime, compressMethods={DateTime:"delta"}, sortColumns=`SecurityID`DateTime, keepDuplicates=ALL)
}
dbName, tbName = "dfs://fiveMinuteBar", "fiveMinuteBar"
createFiveMinuteBarDB(dbName, tbName)

// 根据快照数计算 5 min tick 数据
t = select first(OpenPx) as OpenPx, max(HighPx) as HighPx, min(LowPx) as LowPx, last(LastPx) as LastPx, last(TotalVolumeTrade) as TotalVolumeTrade, last(TotalValueTrade) as TotalValueTrade, toArray(BidPrice[0]) as BidPrice0,  toArray(BidOrderQty[0]) as BidOrderQty0, toArray(OfferPrice[0]) as OfferPrice0, toArray(OfferOrderQty[0]) as OfferOrderQty0 from loadTable("dfs://SH_TSDB_snapshot_ArrayVector", "snapshot") group by SecurityID, interval(DateTime, 5m, "none") as DateTime map

// 将数据存入数据库
loadTable(dbName, tbName).append!(t)
基于快照数据的高频因子计算
DolphinDB 不仅提供了高速存取时序数据的基本功能，还内置了向量化的多范式编程语言和强大的计算引擎，可高效用于量化金融的因子开发，包括基于历史数据的批量高频因子计算和基于实时 Level 2 行情的流式计算。
本章节以基于快照数据计算高频因子为例，展示 Array Vector 在因子计算中的应用。
净委买增额
根据《量化交易因子挖掘笔记-从限价订单簿（LOB）挖掘高频价量因子 》 中对净委买增额的定义和计算方法，实现的指标公式如下：
其中 bidAmtDifft 表示 t 时刻的委买增额； bidi,t 表示 t 时刻快照数据的第 i 档买方报价；指示函数 I 含义如下：
根据上述公式，结合 DolphinDB 丰富的内置函数（prev 获取上一个 tick 的价格；rowSum 计算 Array Vector 的行和），可以转写出如下代码：
@state
def calculateAmtDiff(bid, ask, bidvol, askvol){
	lastBidPrice = prev(bid[0])		// 上一个 tick 的买一价
	lastAskPrice = prev(ask[0])		// 上一个 tick 的卖一价
	lastBidQty = prev(bidvol[0])		// 上一个 tick 的买一量
	lastAskQty = prev(askvol[0])	// 上一个 tick 的卖一量
	// 求委买增额
	bidAmtDiff = rowSum(bid*bidvol*(bid >= lastBidPrice)) - lastBidPrice*lastBidQty
	// 求委卖增额
	askAmtDiff = rowSum(ask*askvol*(ask <= lastAskPrice)) - lastAskPrice*lastAskQty
	return bidAmtDiff - askAmtDiff
}
用上面的自定义函数，可以快速地实现净委买增额的批计算和流计算。
批计算
snapshot = loadTable("dfs://SH_TSDB_snapshot_ArrayVector", "snapshot")
res1 = select SecurityID, DateTime, calculateAmtDiff(BidPrice, OfferPrice, BidOrderQty, OfferOrderQty) as amtDiff from snapshot context by SecurityID csort DateTime
流计算
// 创建输入输出表
share(streamTable(1:0, snapshot.schema().colDefs.name, snapshot.schema().colDefs.typeString), `snapshotStreamTable)
share(streamTable(1:0, `SecurityID`DateTime`amtDiff, [SYMBOL, TIMESTAMP, DOUBLE]), `res2)
go
// 创建流计算引擎
createReactiveStateEngine(name="calAmtDiffDemo", metrics=<[DateTime, calculateAmtDiff(BidPrice, OfferPrice, BidOrderQty, OfferOrderQty)]>, dummyTable=snapshotStreamTable, outputTable=res2, keyColumn=`SecurityID)
// 创建订阅
subscribeTable(tableName="snapshotStreamTable", actionName="calAmtDiffTest", offset=-1, handler=getStreamEngine("calAmtDiffDemo"), msgAsTable=true)
// 取数据回放，模拟流数据
testData = select * from snapshot where date(DateTime)=2021.12.01 order by DateTime
submitJob("replayData", "replay snapshot data", replay{inputTables=testData, outputTables=snapshotStreamTable, dateColumn=`DateTime, timeColumn=`DateTime, replayRate=1000})
十档净委买增额
根据《DolphinDB 处理 Level 2 行情数据实例》 中 3.1.4 章节，实现的指标公式如下：
其中 level10_Difft 表示 t 时刻的委买增额； bidi,t 表示 t 时刻快照数据的第 i 档买方报价；指示函数 I 含义如下：
DolphinDB 中可以先通过行对齐函数 rowAlign 实现当前十档价格和前一个十档价格进行行对齐；然后通过 rowAt 和 nullFill 函数分别获取对应档位的委托量和价格；最后通过 rowSum 函数计算总的变化额。
@state
def level10_Diff(price, qty, buy){
        prevPrice = price.prev()
        left, right = rowAlign(price, prevPrice, how=iif(buy, "bid", "ask"))
        qtyDiff = (qty.rowAt(left).nullFill(0) - qty.prev().rowAt(right).nullFill(0)) 
        amtDiff = rowSum(nullFill(price.rowAt(left), prevPrice.rowAt(right)) * qtyDiff)
        return amtDiff
}

snapshot = loadTable("dfs://SH_TSDB_snapshot_ArrayVector", "snapshot")
res = select SecurityID, DateTime, level10_Diff(BidPrice, BidOrderQty, true) as level10_Diff from snapshot context by SecurityID csort DateTime
总结
针对不定长度二维数组的存储和计算，DolphinDB 提供了一种特殊的数据形式 —— Array Vector。
本教程针对 Array Vector 的特点、使用方式、注意事项、应用场景等做了一系列的介绍。
DolphinDB 能够存储大量的历史高频行情数据，为其后续的高效因子挖掘和计算提供支持，特别是在 level 2 快照数据的存储和计算上，Array Vector 展现了其简洁、高效、灵活的特点。
附件
snapshot_100stocks_multi.zip
体验 DolphinDB Array Vector 带来的性能提升！戳「链接」获取：高频行情存储&计算解决方案。




展开阅读全文

页面更新：2024-05-14

标签：新和   标量   向量   数组   使用指南   变量   函数   元素   类型   方式   行情   数据   历史


1
2
3
4
5




	
		
		
		
		
			
			lnmpmemadmin管理(memcached单进程)
			
			
			lnmp-memcache-memadmin管理(memcached单进程)1）源码安装nginx （在192.168.4.5上）[root@localhost 桌面]# yum -y install gcc gcc-c++[root@localhost 桌面]# yum -y install openssl-devel openssl zlib zlib-devel pc
			
		
	
	
		
		
		
		
			
			广州首迎跨境电商知识产权侵权责任险 6家投保商家代表拿到了承保证明
			
			
			文/羊城晚报全媒体记者 吴珊 通讯员 杨英德 陈雯图/羊城晚报全媒体记者 吴珊广州流花市场是全国较早从事外贸服装批发的市场之一，也是国内最早进行数字化转型的跨境电商平台。9月21日，这里迎来了一场特殊的活动——广州
			
		
	
	
		
		
		
		
			
			“极视角·智启新未来”人工智能产才专场对接会在青岛西海岸新区成功举办
			
			
			鲁网9月25日讯（记者 曹国凤 通讯员 杨文静）9月25日，“极视角·智启新未来”人工智能产才专场对接会在青岛西海岸新区成功举办。青岛市人社局人才开发处三级调研员曲荣研，青岛西海岸新区工委组织部副部长，区人社局党组书记
			
		
	
	
		
		
		
		
			
			本市建设领域“十四五”重点推广新技术②
			
			
			系列介绍为积极发挥科技保障作用，促进科技成果转化应用，上海市建设科技推广中心将一批新技术列入《上海市建设领域“十四五”重点推广应用新技术目录（第一批）》，主要包含以下五大技术领域：绿色低碳与生态城市、立体城市与地
			
		
	
	
		
		
		
		
			
			空中赏月 哪些航班和机型效果好？
			
			
			图片源于网络 图文无关今年中秋和国庆假期重叠，为更好满足人们庆贺团圆、游览山河的美好愿望，中国南方航空（以下简称“南航”)计划在中秋佳节期间（9月29日至10月2日）投放700多条航线9000多个航班，其中，赏月时段（19：00至2：00)共
			
		
	
	
		
		
		
		
			
			旗舰无损音质，华为FreeBuds Pro 3“星闪耳机”首发体验
			
			
			Hello大家好我是长安，华为再发新产品——华为FreeBuds Pro 3“星闪”耳机来啦！有幸提前体验了一段时间，现在就和大家来聊聊我的感受吧！咱们上来就直接硬核输出，本次华为FreeBuds Pro 3直接放大招：带来了超CD级的无损音质。
			
		
	
	
		
		
		
		
			
			推进机场建设，助力产业发展：吉木乃民用运输机场选址进行时
			
			
			中新网新疆新闻9月23日电（胡阿尼什·那斯哈提 阿丽娜·吾尓加甫 陈奕凡）9月20日至22日，受中国民用航空局委托，上海民航新时代机场设计研究院有限公司组织专家组、评审单位、设计单位前往吉木乃县，通过实地勘探、召开评审会
			
		
	
	
		
		
		
		
			
			Segment Routing SRV6 Policy 介绍及基础配置（SRV6 TE policy实验）
			
			
			SRv6 Policy简介 SRv6 Policy是在SRv6技术基础上发展的一种新的引流技术。SRv6 Policy路径表示为指定路径的段列表（Segment List)，称为SID列表(Segment ID List)。每个SID列表是从源到目的地的端到端路径，并指示网络中的
			
		
	
	
		
		
		
		
			
			2023年上海市技术标准创新基地（元宇宙）第一批元宇宙标准征集来啦！
			
			
			2023年上海市技术标准创新基地（元宇宙）第一批元宇宙标准征集通知点击【阅读原文】，查看附件欢迎转发，但请注明出处“上海经信委”觉得不错请点赞！
			
		
	
	
		
		
		
		
			
			重庆航空推出“赏月航班” 邀市民“打飞的”赏月
			
			
			中新网重庆9月25日电 (张旭)中秋佳节至，正是赏月时，地面赏月容易受天气影响，不妨打个“飞的”在空中赏月。重庆航空25日发布消息，汇总中秋期间适宜赏月的航班信息，包括热门赏月航线、最佳赏月航班位置等，供旅客参考。资料图
			
		
	
	
		
		
		
		
			
			高速涡轮分子泵动平衡仪X-Balancer+
			
			
			旋转机械的不平衡是引起振动的常见原因之一，由此产生的振动力取决于旋转速度以及不平衡的程度。而在高速旋转的机械中，不平衡则是非常严重的问题。尤其对转子速度高达90000RPM的涡轮分子泵而言，对于动平衡的要求非常高。
			
		
	
	
		
		
		
		
			
			48岁于震定居山东老家！住青砖瓦房四合院引羡慕，房顶跳舞心情好
			
			
			近年来，不少人选择离开城市的喧嚣，回归乡村，寻求内心的宁静。48岁的演员于震也不例外，他选择定居在山东老家，过起了远离尘嚣的乡村生活。于震在山东老家住在一座具有悠久历史的青砖瓦房四合院里。这座四合院古朴雅致，充满了
			
		
	
	
		
		
		
		
			
			张智霖涉13.7亿诈骗案被带走！奢靡生活令人咋舌，情况属实将判刑
			
			
			本文素材来自于网络，若与实际情况不相符或存在侵权行为，请联系删除。#娱乐评论奖#  香港“币圈”强震即将来临！9月21日，“香港明星张智霖前往警局协助调查”的帖子迅速登上热搜。网友看完帖子后都惊呆了。  原来，张智霖涉
			
		
	
	
		
		
		
		
			
			“浪子”徐少强：骗小15岁雪梨未婚生子，幡然醒悟后扶助儿女事
			
			
			本文内容来自于网络，若与实际情况不相符或存在侵权行为，请联系删除。本文仅在今日头条首发，请勿搬运。前言说起徐少强，大家第一个想到的应该是《武将》中的反派“赵无极”。虽然在剧中他是个坏人，但在现实中他却是一个好父
			
		
	
	
		
		
		
		
			
			洪金梅为了嫁入豪门，不惜穿着塑身衣30年，结果只得到一元？
			
			
			 在上世纪 70 至 80 年代，香港富豪的生活充满了公众的关注。他们各种行为和事迹常常成为各种花边新闻的主题。许多人梦想能够嫁给这些富人，成为阔太太。洪金梅也是其中之一。她成功嫁给了香港一位有头有脸的大富豪邓永
			
		
	
上滑加载更多 ↓
所有内容加载完毕

字段名称	数据类型	数据说明
SecurityID	SYMBOL	证券代码
DateTime	TIMESTAMP	日期时间
PreClosePx	DOUBLE	昨收价
OpenPx	DOUBLE	开始价
HighPx	DOUBLE	最高价
LowPx	DOUBLE	最低价
LastPx	DOUBLE	最新价
TotalVolumeTrade	INT	成交总量
TotalValueTrade	DOUBLE	成交总金额
InstrumentStatus	SYMBOL	交易状态
BidPrice	DOUBLE[]	申买十价
BidOrderQty	INT[]	申买十量
BidNumOrders	INT[]	申买十实际总委托笔数
BidOrders	INT[]	申买一前 50 笔订单
OfferPrice	DOUBLE[]	申卖十价
OfferOrderQty	INT[]	申卖十量
OfferNumOrders	INT[]	申卖十实际总委托笔数
OfferOrders	INT[]	申卖一前 50 笔订单
NumTrades	INT	成交笔数
IOPV	DOUBLE	ETF 净值估值
TotalBidQty	INT	委托买入总量
TotalOfferQty	INT	委托卖出总量
WeightedAvgBidPx	DOUBLE	加权平均委买价格
WeightedAvgOfferPx	DOUBLE	加权平均委卖价格
TotalBidNumber	INT	买入总笔数
TotalOfferNumber	INT	卖出总笔数
BidTradeMaxDuration	INT	买入成交最大等待时间
OfferTradeMaxDuration	INT	买入成交最大等待时间
NumBidOrders	INT	买方委托价位数
NumOfferOrders	INT	卖方委托价位数
WithdrawBuyNumber	INT	买入撤单笔数
WithdrawBuyAmount	INT	买入撤单数量
WithdrawBuyMoney	DOUBLE	买入撤单金额
WithdrawSellNumber	INT	卖出撤单笔数
WithdrawSellAmount	INT	卖出撤单数量
WithdrawSellMoney	DOUBLE	卖出撤单金额
ETFBuyNumber	INT	ETF 申购笔数
ETFBuyAmount	INT	ETF 申购数量
ETFBuyMoney	DOUBLE	ETF 申购金额
ETFSellNumber	INT	ETF 赎回笔数
ETFSellAmount	INT	ETF 赎回数量
ETFSellMoney	DOUBLE	ETF 赎回金额