hubble数据库函数之_数组函数

原创琳哥 2023-01-31

163

函数	说明	返回值类型
`array_append(array: bool[], elem: bool)`	将elem附加到数组中，返回结果。	bool[]
`array_append(array: bytes[], elem: bytes)`	将elem附加到数组中，返回结果。	bytes[]
`array_append(array: date[], elem: date)`	将elem附加到数组中，返回结果。	date[]
`array_append(array: decimal[], elem: decimal)`	将elem附加到数组中，返回结果。	decimal[]
`array_append(array: float[], elem: float)`	将elem附加到数组中，返回结果。	float[]
`array_append(array: inet[], elem: inet)`	将elem附加到数组中，返回结果。	inet[]
`array_append(array: int[], elem: int)`	将elem附加到数组中，返回结果。	int[]
`array_append(array: interval[], elem: interval)`	将elem附加到数组中，返回结果。	interval[]
`array_append(array: string[], elem: string)`	将elem附加到数组中，返回结果。	string[]
`array_append(array: time[], elem: time)`	将elem附加到数组中，返回结果。	time[]
`array_append(array: timestamp[], elem: timestamp)`	将elem附加到数组中，返回结果。	timestamp[]
`array_append(array: timestamptz[], elem: timestamptz)`	将elem附加到数组中，返回结果。	timestamptz[]
`array_append(array: uuid[], elem: uuid)`	将elem附加到数组中，返回结果。	uuid[]
`array_append(array: varbit[], elem: varbit)`	将elem附加到数组中，返回结果。	varbit[]
`array_cat(left: bool[], right: bool[])`	追加两个数组。	bool[]
`array_cat(left: bytes[], right: bytes[])`	追加两个数组。	bytes[]
`array_cat(left: date[], right: date[])`	追加两个数组。	date[]
`array_cat(left: decimal[], right: decimal[])`	追加两个数组。	decimal[]
`array_cat(left: float[], right: float[])`	追加两个数组。	float[]
`array_cat(left: inet[], right: inet[])`	追加两个数组。	inet[]
`array_cat(left: int[], right: int[])`	追加两个数组。	int[]
`array_cat(left: interval[], right: interval[])`	追加两个数组。	interval[]
`array_cat(left: string[], right: string[])`	追加两个数组。	string[]
`array_cat(left: time[], right: time[])`	追加两个数组。	time[]
`array_cat(left: timestamp[], right: timestamp[])`	追加两个数组。	timestamp[]
`array_cat(left: timestamptz[], right: timestamptz[])`	追加两个数组。	timestamptz[]
`array_cat(left: uuid[], right: uuid[])`	追加两个数组。	uuid[]
`array_cat(left: varbit[], right: varbit[])`	追加两个数组。	varbit[]
`array_length(input: anyelement[], array_dimension: int)`	计算`input`提供的上的长度`array_dimension`。但是，由于目前尚不支持多维数组，因此唯一支持的`array_dimension`是1。	int
`array_lower(input: anyelement[], array_dimension: int)`	计算`input`提供的上的最小值`array_dimension`。但是，由于目前尚不支持多维数组，因此唯一支持的`array_dimension`是1。	int
`array_position(array: bool[], elem: bool)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: bytes[], elem: bytes)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: date[], elem: date)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: decimal[], elem: decimal)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: float[], elem: float)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: inet[], elem: inet)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: int[], elem: int)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: interval[], elem: interval)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: string[], elem: string)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: time[], elem: time)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: timestamp[], elem: timestamp)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: timestamptz[], elem: timestamptz)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: uuid[], elem: uuid)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: oid[], elem: oid)`	返回数组中`elem` 第一次出现的索引。	int
`array_position(array: varbit[], elem: varbit)`	返回数组中`elem` 第一次出现的索引。	int
`array_positions(array: bool[], elem: bool)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: bytes[], elem: bytes)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: date[], elem: date)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: decimal[], elem: decimal)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: float[], elem: float)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: inet[], elem: inet)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: int[], elem: int)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: interval[], elem: interval)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: string[], elem: string)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: time[], elem: time)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: timestamp[], elem: timestamp)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: timestamptz[], elem: timestamptz)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: uuid[], elem: uuid)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: oid[], elem: oid)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_positions(array: varbit[], elem: varbit)`	返回所有`elem` 在数组中出现的索引的数组。	int[]
`array_prepend(elem: bool, array: bool[])`	将`elem` 加入数组，返回结果。	bool[]
`array_prepend(elem: bytes, array: bytes[])`	将`elem` 加入数组，返回结果。	bytes[]
`array_prepend(elem: date, array: date[])`	将`elem` 加入数组，返回结果。	date[]
`array_prepend(elem: decimal, array: decimal[])`	将`elem` 加入数组，返回结果。	decimal[]
`array_prepend(elem: float, array: float[])`	将`elem` 加入数组，返回结果。	float[]
`array_prepend(elem: inet, array: inet[])`	将`elem` 加入数组，返回结果。	inet[]
`array_prepend(elem: int, array: int[])`	将`elem` 加入数组，返回结果。	int[]
`array_prepend(elem: interval, array: interval[])`	将`elem` 加入数组，返回结果。	interval[]
`array_prepend(elem: string, array: string[])`	将`elem` 加入数组，返回结果。	string[]
`array_prepend(elem: time, array: time[])`	将`elem` 加入数组，返回结果。	time[]
`array_prepend(elem: timestamp, array: timestamp[])`	将`elem` 加入数组，返回结果。	timestamp[]
`array_prepend(elem: timestamptz, array: timestamptz[])`	将`elem` 加入数组，返回结果。	timestamptz[]
`array_prepend(elem: uuid, array: uuid[])`	将`elem` 加入数组，返回结果。	uuid[]
`array_prepend(elem: varbit, array: varbit[])`	将`elem` 加入数组，返回结果。	varbit[]
`array_remove(array: bool[], elem: bool)`	从数组中删除所有等于`elem`的元素。	bool[]
`array_remove(array: bytes[], elem: bytes)`	从数组中删除所有等于`elem`的元素。	bytes[]
`array_remove(array: date[], elem: date)`	从数组中删除所有等于`elem`的元素。	date[]
`array_remove(array: decimal[], elem: decimal)`	从数组中删除所有等于`elem`的元素。	decimal[]
`array_remove(array: float[], elem: float)`	从数组中删除所有等于`elem`的元素。	float[]
`array_remove(array: inet[], elem: inet)`	从数组中删除所有等于`elem`的元素。	inet[]
`array_remove(array: int[], elem: int) → int[]`	从数组中删除所有等于`elem`的元素。	int[]
`array_remove(array: interval[], elem: interval)`	从数组中删除所有等于`elem`的元素。	interval[]
`array_remove(array: string[], elem: string)`	从数组中删除所有等于`elem`的元素。	string[]
`array_remove(array: time[], elem: time)`	从数组中删除所有等于`elem`的元素。	time[]
`array_remove(array: timestamp[], elem: timestamp)`	从数组中删除所有等于`elem`的元素。	timestamp[]
`array_remove(array: timestamptz[], elem: timestamptz)`	从数组中删除所有等于`elem`的元素。	timestamptz[]
`array_remove(array: uuid[], elem: uuid)`	从数组中删除所有等于`elem`的元素。	uuid[]
`array_remove(array: varbit[], elem: varbit)`	从数组中删除所有等于`elem`的元素。	varbit[]
`array_replace(array: bool[], toreplace: bool, replacewith: bool)`	用replacewith替换数组中出现的所有toreplace。	bool[]
`array_replace(array: bytes[], toreplace: bytes, replacewith: bytes)`	用replacewith替换数组中出现的所有toreplace。	bytes[]
`array_replace(array: date[], toreplace: date, replacewith: date)`	用replacewith替换数组中出现的所有toreplace。	date[]
`array_replace(array: decimal[], toreplace: decimal, replacewith: decimal)`	用replacewith替换数组中出现的所有toreplace。	decimal[]
`array_replace(array: float[], toreplace: float, replacewith: float)`	用replacewith替换数组中出现的所有toreplace。	float[]
`array_replace(array: inet[], toreplace: inet, replacewith: inet)`	用replacewith替换数组中出现的所有toreplace。	inet[]
`array_replace(array: int[], toreplace: int, replacewith: int)`	用replacewith替换数组中出现的所有toreplace。	int[]
`array_replace(array: interval[], toreplace: interval, replacewith: interval)`	用replacewith替换数组中出现的所有toreplace。	interval[]
`array_replace(array: string[], toreplace: string, replacewith: string)`	用replacewith替换数组中出现的所有toreplace。	string[]
`array_replace(array: time[], toreplace: time, replacewith: time)`	用replacewith替换数组中出现的所有toreplace。	time[]
`array_replace(array: timestamp[], toreplace: timestamp, replacewith: timestamp)`	用replacewith替换数组中出现的所有toreplace。	timestamp[]
`array_replace(array: timestamptz[], toreplace: timestamptz, replacewith: timestamptz)`	用replacewith替换数组中出现的所有toreplace。	timestamptz[]
`array_replace(array: uuid[], toreplace: uuid, replacewith: uuid)`	用replacewith替换数组中出现的所有toreplace。	uuid[]
`array_replace(array: varbit[], toreplace: varbit, replacewith: varbit)`	用replacewith替换数组中出现的所有toreplace。	varbit[]
`array_to_string(input: anyelement[], delim: string)`	用定界符将数组连接到字符串中。	string
`array_to_string(input: anyelement[], delimiter: string, null: string)`	用分隔符将数组连接到字符串中，用空字符串替换NULL。	string
`array_upper(input: anyelement[], array_dimension: int)`	计算`input`提供的上的最大值`array_dimension`。但是，由于目前尚不支持多维数组，因此唯一支持的`array_dimension`是1。	int
`string_to_array(str: string, delimiter: string)`	将字符串拆分为分隔符上的组件。	string[]
`string_to_array(str: string, delimiter: string, null: string)`	使用指定的字符串将字符串拆分为定界符上的组件，以将其视为NULL。	string[]

利用正则表达式将字符串分割成数组

select regexp_split_to_array('hello world', E'\\s+')

  regexp_split_to_array              
+----------------------------+
      {hello,world}

数据示例

CREATE TABLE test_array (a STRING[]);
INSERT INTO test_array VALUES (ARRAY['Monday', 'Tuesday', 'Wednesday']);
select * from test_array;

              a               
+----------------------------+
  {Monday,Tuesday,Wednesday}

regexp_split_to_table

select  regexp_split_to_table('11,22,33',',');

  regexp_split_to_table
-------------------------
  11
  22
  33

append(array: x[], elem: y) → bool[]

数组拼接单个元素

select array_append(a,'Thursday') from test_array;

             array_append              
+-------------------------------------+

  {Monday,Tuesday,Wednesday,Thursday}

array_cat(array: x[], array y[])

两个数组拼接

select array_cat(a,ARRAY['Thursday', 'Friday', 'Saturday']) from test_array;

                       array_cat                       
+-----------------------------------------------------+
  {Monday,Tuesday,Wednesday,Thursday,Friday,Saturday}

array_length(array:x[],1)

数组大小，第二个参数暂时只支持1个间隔计算。

select array_length(a,1) from test_array;

  array_length  
+--------------+
          3

array_lower(array:x[],1)

返回指定的数组维数的下界，第二个参数暂时只支持1个间隔计算。

select array_lower(a,1) from test_array;

  array_lower  
+-------------+
          1

array_upper(array:x[],1)

返回指定数组维数的上界，第二个参数暂时只支持1个间隔计算。

select array_upper(a,1) from test_array;

  array_upper  
+-------------+
          3

array_position(array:x[],y)

返回元素的位置

select array_position(a,'Tuesday') from test_array;

  array_position  
+----------------+
          2

array_prepend(y,array:x[])

数组之前插入元素

select array_prepend('Thursday',a) from test_array;

             array_prepend             
+-------------------------------------+
  {Thursday,Monday,Tuesday,Wednesday}

array_remove(array:x[],y)

数组中删除元素

select array_remove(a,'Tuesday') from test_array;

     array_remove     
+--------------------+
  {Monday,Wednesday}

array_replace(array:x[],y,z)

替换数组中的元素y为z

select array_replace(a,'Tuesday','Thursday') from test_array;

         array_replace         
+-----------------------------+
  {Monday,Thursday,Wednesday}

array_to_string(array:x[],delim)

数组转字符串，按delim分隔

select array_to_string(a,',') from test_array;

      array_to_string       
+--------------------------+
  Monday,Tuesday,Wednesday

array_to_string(array:x[],delim,y)

数组转字符串，按delim分隔，y代替null,即保留null在字符串中的位置。

select array_to_string(ARRAY['Thursday', 'Friday', 'Saturday',null,'Friday'],',');

          array_to_string          
+---------------------------------+
  Thursday,Friday,Saturday,Friday

select array_to_string(ARRAY['Thursday', 'Friday', 'Saturday',null,'Friday'],',','y');

          array_to_string           
+----------------------------------+
  Thursday,Friday,Saturday,y,Friday

string_to_array(str:string,delim)

字符串转数组，按分隔符拆分

select string_to_array('Thursday,Friday,Saturday,Friday',',');

           string_to_array           
+-----------------------------------+
  {Thursday,Friday,Saturday,Friday}

string_to_array(str:string,delim,y)

字符串转数组，按分隔符拆分，将y视为null

select string_to_array('Thursday,Friday,Saturday,y,Friday',',','y');

             string_to_array              
+----------------------------------------+
  {Thursday,Friday,Saturday,NULL,Friday}

hubble 函数

「喜欢这篇文章，您的关注和赞赏是给作者最好的鼓励」

关注作者

hubble数据库函数之_数组函数

评论