列式元组（columnar tuple）

列式元组是一种特殊的元组类型，列式元组的元素可以是标量也可以是向量，且其值的类型必须保持一致。列式元组的取数规则和数组向量一致。

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

• 通过函数 isColumnarTuple 可以判断一个元组是否为列式元组。

  tp = [[1.3,2.5,2.3], [4.1,5.3], 6.3]
  isColumnarTuple(tp)
  // output
  false
  
  tp.setColumnarTuple!()
  isColumnarTuple(tp)
  // output
  true

普通元组按索引取出的是对应下标的元素值，而列式元组和数组向量则是返回每个元素对应下标的值组成的向量。

tp = [[1.3,2.5,2.3], [4.1,5.3], 6.3]
ctp = [[1.3,2.5,2.3], [4.1,5.3], 6.3].setColumnarTuple!()
av = array(DOUBLE[], 0, 20).append!([[1.3,2.5,2.3], [4.1,5.3], 6.3])

// 按索引取数
tp[0]
// output
[1.3,2.5,2.3]

ctp[0]
// output
[1.3,4.1,6.3]

av[0]
// output
[1.3,4.1,6.3]

按 slice 取数时（即 x[start:end]），若 slice 范围超过了列式元组中元素的长度，会自动填充空值。

当元素类型不为 STRING, SYMBOL 且 slice 的 end 不为空时，列式元组 slice 后的返回结果是一个数组向量，否则返回的仍然时列式元组。

//按 slice 取数
a = ctp[0:3]
a
// output
[[1.3,2.5,2.3],[4.1,5.3,00F],[6.3,6.3,6.3]]

b = ctp[0:]
b
// output
([1.3,2.5,2.3],[4.1,5.3],6.3)

和数组向量一致，若要单独取出每个元素的值可以通过 row 函数实现。

ctp.row(0)
// output
[1.3,2.5,2.3]

ctp = [[1.3,2.5,2.3], [4.1,5.3], 6.3].setColumnarTuple!()
ctp.append!([3.3,2.1])
ctp
// output
([1.3,2.5,2.3],[4.1,5.3],6.3,[3.3,2.1])

列式元组中的数据可以通过指定行和列的方式进行修改：obj[rowIndex, colIndex] = newValue

rowIndex 是标量或数据对，若是数据对，当不指定开始的索引时，表示第 0 行开始；当结束的索引不指定时，表示到最后一行结束。rowIndex 可以省略。省略时代表所有行中对应的 colIndex 位置的数据都要修改。

colIndex 是标量或数据对，不可省略。当是数据对时，数据对的开始和结束索引不可省略。

newValue 是标量、向量或元组：

• newValue 是一个标量时，所有通过 rowIndex 和 colIndex 指定的数据都会修改为 newValue；

• newValue 是与 colIndex 相同长度的标量或元组时，每一行中由 colIndex 指定的数据都会对应替换为该向量或元组的值；

• newValue 是长度与 rowIndex 相同的向量或元组时，其中 newValue 的元素为标量或者长度与 colIndex 相同的数组，每一行中的数据会替换为 newValue 中对应位置的元素。

// 创建列式元组 ctp
ctp = [1 2 3 4, 5 6 7 8 , 9 10 11 12].setColumnarTuple!()
print ctp 
// output
([1,2,3,4],[5,6,7,8],[9,10,11,12])

// 修改第0行、第1列的数据为 50
ctp[0,1] = 50
print ctp 
// output
([1,50,3,4],[5,6,7,8],[9,10,11,12])

// 修改第0到1行中第1到2列的数据为 100 200
ctp[0:2, 1:3] = 100 200
print ctp
// output
([1,100,200,4],[5,100,200,8],[9,10,11,12])

// 修改第0到1行中第1到2列的数据为 300 400，省略行索引的起始索引值
ctp[:2, 1:3] = 300 400
print ctp
// output
([1,300,400,4],[5,300,400,8],[9,10,11,12])

// 修改第0行中第1到2列的数据为 500 600，修改第1行中第1到2列的数据为 700 800
ctp[0:2, 1:3] = (500 600, 700 800)
print ctp
// output
([1,500,600,4],[5,700,800,8],[9,10,11,12])

// 修改所有行中第1到2列的数据为 900 1000
ctp[, 1:3] = 900 1000
print ctp
// output
([1,900,1000,4],[5,900,1000,8],[9,900,1000,12])

ctp = [[1.3,2.5,2.3], [4.1,5.3], 6.3].setColumnarTuple!()
rowSum(ctp)
// output
[6.1,9.4,6.3]

创建内存表时，DolphinDB 支持将元素不等长的普通元组存储为列式元组。

sym = `st1`st2`st3
price = [[3.1,2.5,2.8], [3.1,3.3], [3.2,2.9,3.3]]
t = table(sym, price)
t;

id = 1 2 3
val = [[1,2,3], [4,5,6],[7,8,9]]
table(id, val)

table(id, val.setColumnarTuple!())