Array

The ARRAY data type offers a convenient way to store ordered collections of elements in a single column. It provides storage efficiency by allowing multiple values of the same data type to be compactly stored, optimizing space utilization and enhancing database performance. Working with ARRAY simplifies queries as operations and manipulations can be performed on the entire ARRAY, resulting in more concise and readable code.

An ARRAY represents a sequence of zero or more elements of the same data type. Arrays in the same column can contain varying numbers of elements across different rows. Arrays can include null values, eliminating the need for separate SQL declarations.

Each data type has its companion ARRAY type, such as INT[] for integers and TEXT[] for text values.

You may use the ARRAY data type with all SQreamDB connectors, except for ODBC since the ODBC protocol does not support ARRAY.

The maximum size of an ARRAY, indicating the number of elements it can hold, is 65535. You have the option to specify the size of an ARRAY, providing a maximum allowed size, while each row can have a different number of elements up to the specified maximum. If the ARRAY size is not specified, the maximum size is assumed.

Syntax

Defining an ARRAY is done by appending the [] notation to a supported data type, for example, INT[] for an array of integers.

CREATE TABLE
 < table_name > (< column1 > TEXT [], < column2 > INT [])

INSERT INTO
  TABLE < table_name >
VALUES
  (ARRAY ['a','b','c'], ARRAY [1,2,NULL])

Supported Operators

Operator	Description	Example
Literals `ARRAY []`	Literals are created using the `ARRAY` operator	`ARRAY[1,2,3]`
Mapping	Parquet, ORC, JSON, and AVRO `ARRAY` types may be mapped into SQreamDB `ARRAY`	See extended section under Examples
Indexing	Access to specific elements within the array by using a zero-based index	`SELECT (<column_name>[2]) FROM <table_name>` returns the third element of the specified column
`UNNEST`	Converts the arrayed elements within a single row into a set of rows	`SELECT UNNEST(<column_name>) FROM <table_name>`
Concatenate `\|\|`	Converts arrayed elements into one string	`SELECT (<column_name>) \|\| (<column2_name>) FROM <table_name>` `SELECT (<column_name>) \|\| ARRAY[1,2,3] FROM <table_name>`
`array_length`	Returns the number of arrayed elements within the specified column	`SELECT array_length(<column_name>) FROM <table_name>`
`array_position`	Locates the position of the specified value within the specified array. Returns `NULL` if the value is not found	`SELECT array_position(<column_name>,<value>) FROM <table_name>;`
`array_remove`	Returns the specified `ARRAY` column with the specified value deducted	`SELECT array_remove(<column_name>,<value>) FROM <table_name>;`
`array_replace`	Enables replacing values within an `ARRAY` column	`SELECT array_replace(<column_name>,<value_to_replace>,<replacing_value>) FROM <table_name>;`
Limiting number of arrayed elements	You may limit the number of arrayed elements within an `ARRAY`	Limiting the number of arrayed elements to 4: `CREATE TABLE <table_name> (<column1> TEXT[4]);`
Compression	You may follow SQreamDB compression guide for compression types and methods	`CREATE TABLE t (comp_dict INT[] CHECK('CS "dict"');`
Aggregation	The `array_agg()` function arrays groups created using the `GROUP BY` clause	`CREATE TABLE t2 (x INT, y INT);` `SELECT x, array_agg(y) FROM t2 GROUP BY x;`
Sorting	`TEXT[]` elements are considered together as a single text, and comparisons are made based on their lexicographic order. In contrast, for arrays of non-TEXT data types, comparisons are performed on the individual elements of the arrays	`CREATE TABLE t (x TEXT[]);` `INSERT INTO t VALUES (ARRAY['1']),(ARRAY['1','22']),(ARRAY['1','3']);` `SELECT x FROM t ORDER BY x;` Output: [‘1’] [‘1’,’22’] [‘1’,’3’]

Examples

`ARRAY` Statements

Creating a table with arrayed columns:

CREATE TABLE
  my_array (
    clmn1 TEXT [],
    clmn2 TEXT [],
    clmn3 INT [],
    clmn4 NUMERIC(38, 20) []
  );

Inserting arrayed values into a table:

INSERT INTO
  my_array
VALUES
  (
    ARRAY ['1','2','3'],
    ARRAY ['4','5','6'],
    ARRAY [7,8,9,10],
    ARRAY [0.4354,0.5365435,3.6456]
  );

Converting arrayed elements into a set of rows:

SELECT
  UNNEST(clmn1) FROM my_array;

 clmn1  |
--------+
 1      |
 2      |
 3      |

Updating table values:

UPDATE
  my_array
SET
  clmn1 [0] = 'A';

SELECT
  *
FROM
  my_array;

clmn1                | clmn2            | clmn3
---------------------+------------------+-----------
["A","1","2","3"]    | ["4","5","6"]    | [7,8,9,10]

Ingesting Arrayed Data from External Files

Consider the following JSON file named t, located under /tmp/:

{
    "name": "Avery Bradley",
    "age": 25,
    "position": "PG",
    "years_in_nba": [
        2010,
        2011,
        2012,
        2013,
        2014,
        2015,
        2016,
        2017,
        2018,
        2019,
        2020,
        2021
    ]
},
{
    "name": "Jae Crowder",
    "age": 25,
    "position": "PG",
    "years_in_nba": [
        2012,
        2013,
        2014,
        2015,
        2016,
        2017,
        2018,
        2019,
        2020,
        2021
    ]
},
{
    "name": "John Holland",
    "age": 27,
    "position": "SG",
    "years_in_nba": [
        2017,
        2018
    ]
}

]

Execute the following statement:

CREATE FOREIGN TABLE nba (name text, age int, position text, years_in_nba int [])
WRAPPER
  json_fdw
OPTIONS
  (location = '/tmp/t.json');

SELECT
  *
FROM
  nba;

Output:

name           | age    | position    | years_in_nba
---------------+--------+-------------+-------------------------------------------------------------------------
Avery Bradley  | 25     | PG          | [2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021]
Jae Crowder    | 25     | PG          | [2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 2021]
John Holland   | 27     | SG          | [2017, 2018]

Limitations

Casting Limitations

`NUMERIC`

Numeric data types smaller than INT, such as TINYINT, SMALLINT, and BOOL, must explicitly be cast.

CREATE OR REPLACE TABLE my_array (clmn1 tinyint []);
SELECT array_replace(clmn1 , 4::tinyint, 5::tinyint) FROM my_array;

CREATE OR REPLACE TABLE my_array (clmn1 bool []);
SELECT array_replace(clmn1 , 0::bool, 1::bool) FROM my_array;

`TEXT`

Casting TEXT to non-TEXT and non-TEXT to TEXT data types is not supported.

CREATE TABLE t_text (xtext TEXT[]);
CREATE TABLE t_int (xint INT[]);
INSERT INTO t_int VALUES (array[1,2,3]);
INSERT INTO t_text SELECT xint::TEXT[] FROM t_int;

Connectors

`.NET` and `ODBC`

Please note that the SQreamDB ODBC and .NET connectors do not support the use of ARRAY data types. If your database schema includes ARRAY columns, you may encounter compatibility issues when using these connectors.

`Pysqream`

Please note that SQLAlchemy does not support the ARRAY data type.

Functions

|| (Concatenate)

Using the || (Concatenate) function with two different data types requires explicit casting.

SELECT (clmn1, 4::tinyint) || (clmn2, 5::tinyint) FROM my_array;

UNNEST

The UNNEST function is computationally intensive; therefore, it is recommended to use up to 10 UNNEST clauses per statement as a best practice. To improve performance, consider filtering the results before applying UNNEST to reduce data volume and optimize query runtime.

Window

Window functions are not supported.

Type	Details
`TINYINT`, `SMALLINT`, `INT`, `BIGINT`	`true` → `1`, `false` → `0`
`REAL`, `DOUBLE`	`true` → `1.0`, `false` → `0.0`

FROM / TO	BOOL	TINYINT/SMALLINT/INT/BIGINT	REAL/FLOAT	NUMERIC	DATE/DATETIME/DATETIME2	TEXT
BOOL	N/A	✓	✗	✗	✗	✓
TINYINT/SMALLINT/INT/BIGINT	✓	N/A	✓	✓	✗	✓
REAL/FLOAT	✗	✓	N/A	✓	✗	✓
NUMERIC	✗	✓	✓	✓	✗	✓
DATE/DATETIME/DATETIME2	✗	✗	✗	✗	✓	✓
TEXT	✓	✓	✓	✓	✓	N/A

Type	Details
`TEXT`	`'1997-01-01'` → `'1997-01-01 00:00:00.000000 +00:00'`, `'1955-11-05 01:24'` → `'1955-11-05 01:24:00.000000 +00:00'`
`DATE`	`'1997-01-01'` → `'1997-01-01 00:00:00.000000 +00:00'`
`DATETIME`	`'1955-11-05 01:24'` → `'1955-11-05 01:24:00.000000 +00:00'`

Name	Details	Data Size (Not Null, Uncompressed)	Example
`DATE`	Date	4 bytes	`'1955-11-05'`
`DATETIME`	Date and time pairing in UTC	8 bytes	`'1955-11-05 01:24:00.000'`

Name	Details	Data Size (Not Null, Uncompressed)	Example
`REAL`	Single precision floating point (inexact)	4 bytes	`3.141`
`DOUBLE`	Double precision floating point (inexact)	8 bytes	`0.000003`

Type	Details
`BOOL`	`1.0` → `true`, `0.0` → `false`
`TINYINT`, `SMALLINT`, `INT`, `BIGINT`	`2.0` → `2`, `3.14159265358979` → `3`, `2.718281828459` → `2`, `0.5` → `0`, `1.5` → `1`

Name	Details	Data Size (Not Null, Uncompressed)	Example
`TINYINT`	Unsigned integer (0 - 255)	1 byte	`5`
`SMALLINT`	Integer (-32,768 - 32,767)	2 bytes	`-155`
`INT`	Integer (-2,147,483,648 - 2,147,483,647)	4 bytes	`1648813`
`BIGINT`	Integer (-9,223,372,036,854,775,808 - 9,223,372,036,854,775,807)	8 bytes	`36124441255243`

Type	Details
`REAL`, `DOUBLE`	`1` → `1.0`, `-32` → `-32.0`
`TEXT` (All numberic values must fit in the string length)	`1` → `'1'`, `2451` → `'2451'`

Name	Description	Data Size (Not Null, Uncompressed)	Example	Alias
`BOOL`	Boolean values (`true`, `false`)	1 byte	`true`	`BIT`
`TINYINT`	Unsigned integer (0 - 255)	1 byte	`5`	NA
`SMALLINT`	Integer (-32,768 - 32,767)	2 bytes	`-155`	NA
`INT`	Integer (-2,147,483,648 - 2,147,483,647)	4 bytes	`1648813`	`INTEGER`
`BIGINT`	Integer (-9,223,372,036,854,775,808 - 9,223,372,036,854,775,807)	8 bytes	`36124441255243`
`REAL`	Floating point (inexact)	4 bytes	`3.141`	NA
`DOUBLE`	Floating point (inexact)	8 bytes	`0.000003`	`FLOAT`/`DOUBLE PRECISION`
`TEXT (n)`	Variable length string - UTF-8 unicode	Up to `4` bytes	`'Kiwis have tiny wings, but cannot fly.'`	`CHAR VARYING`, `CHAR`, `CHARACTER VARYING`, `CHARACTER`, `NATIONAL CHARACTER VARYING`, `NATIONAL CHARACTER`, `NCHAR VARYING`, `NCHAR`, `NATIONAL CHAR`, `NATIONAL CHAR VARYING`
`NUMERIC`	38 digits	16 bytes	`0.12324567890123456789012345678901234567`	`DECIMAL`, `NUMBER`
`DATE`	Date	4 bytes	`'1955-11-05'`	NA
`DATETIME`	Date and time pairing in UTC	8 bytes	`'1955-11-05 01:24:00.000'`	`TIMESTAMP`
`DATETIME2`	Date and time in nanosecond precision including UTC offset	16 bytes	`'1955-11-05 01:24:00.000000000 +00:00'`	NA

Type	Details
`BOOL`	`'true'` → `true`, `'false'` → `false`
`TINYINT`, `SMALLINT`, `INT`, `BIGINT`	`'2'` → `2`, `'-128'` → `-128`
`REAL`, `DOUBLE`	`'2.0'` → `2.0`, `'3.141592'` → `3.141592`
`DATE`, `DATETIME`	Requires a supported format, such as `'1955-11-05` → `date '1955-11-05'`, `'1955-11-05 01:24:00.000'` → `'1955-11-05 01:24:00.000'`

Column	Description
`database_name`	Shows the name of the databse containing the extent.
`table_id`	Shows the ID of the table containing the extent.
`column_id`	Shows the ID of the column containing the extent.
`extent_id`	Shows the ID for the extent.
`size`	Shows the extent size in megabytes.
`path`	Shows the full path to the extent on the file system.

Parameter	Default value	Value range	Description
`[schema_name.]table_name`	None		Table to copy data into
`QUOTE`	`"`		Specifies an alternative quote character. The quote character must be a single, 1-byte printable ASCII character, and the equivalent octal syntax of the copy command can be used. The quote character cannot be contained in the field delimiter, the record delimiter, or the null marker. `QUOTE` can be used with `csv_fdw` in `COPY FROM` and foreign tables. The following characters cannot be an alternative quote character: `"-.:\\0123456789abcdefghijklmnopqrstuvwxyzN"`
`fdw_name`		`csv_fdw`, `orc_fdw`, `parquet_fdw`, `json_fdw`, or `avro_fdw`	The name of the Foreign Data Wrapper to use
`LOCATION`	None		A path on the local filesystem, S3, or HDFS URI. For example, `/tmp/foo.csv`, `s3://my-bucket/foo.csv`, or `hdfs://my-namenode:8020/foo.csv`. The local path must be an absolute path that SQream DB can access. Wildcards are premitted in this field.
`OFFSET`	`1`	>1, but no more than the number of lines in the first file	The row number to start with. The first row is `1`.
`LIMIT`	unlimited	1 to 2147483647.	When specified, tells SQream DB to stop loading after the specified number of rows. Unlimited if unset.
`DELIMITER`	`','`	Almost any ASCII character, See field delimiters section below	Specifies the field terminator - the character (or characters) that separates fields or columns within each row of the file.
`RECORD_DELIMITER`	`\n` (UNIX style newline)	`\n`, `\r\n`, `\r`	Specifies the row terminator - the character that separates lines or rows, also known as a new line separator.
`ERROR_LOG`	No error log		When used, the `COPY` process will write error information from unparsable rows to the file specified by this parameter. `ERROR_LOG` requires `CONTINUE_ON_ERROR` to be set to `true` If an existing file path is specified, it will be overwritten. Specifying the same file for `ERROR_LOG` and `REJECTED_DATA` is not allowed and will result in error. Specifing an error log when creating a foreign table will write a new error log for every query on the foreign table.
`REJECTED_DATA`	Inactive		When used, the `COPY` process will write the rejected record lines to this file. If an existing file path is specified, it will be overwritten. Specifying the same file for `ERROR_LOG` and `REJECTED_DATA` is not allowed and will result in error. Specifing an error log when creating a foreign table will write a new error log for every query on the foreign table.
`CONTINUE_ON_ERROR`	`false`	`true` \| `false`	Specifies if errors should be ignored or skipped. When set to `true`, the transaction will continue despite rejected data. This parameter should be set together with `ERROR_COUNT` When reading multiple files, if an entire file can’t be opened it will be skipped.
`ERROR_COUNT`	`unlimited`	1 to 2147483647	Specifies the threshold for the maximum number of faulty records that will be ignored. This setting must be used in conjunction with `CONTINUE_ON_ERROR`.
`DATETIME_FORMAT`	ISO8601 for all columns	See table below	Allows specifying a non-default date formats for specific columns
`AWS_ID`, `AWS_SECRET`	None		Specifies the authentication details for secured S3 buckets
`DELETE_SOURCE_ON_SUCCESS`	`false`	`true` \| `false`	When set to `true`, the source file or files associated with the target path will be deleted after a successful completion of the `COPY FROM` operation. File deletion will not occur in the case of unsuccessful `COPY FROM` operations, such as when a user lacks delete permissions on their operating system. It’s important to note that this parameter cannot be used concurrently with the `OFFSET`, `ERROR_LOG`, `REJECTED_DATA`, `ERROR_COUNT`, and `LIMIT` parameters. This parameter is supported for S3, HDFS, and GCP Object Storage.

Name	Pattern	Examples
`ISO8601`, `DEFAULT`	`YYYY-MM-DD [hh:mm:ss[.SSS]]`	`2017-12-31 11:12:13.456`, `2018-11-02 11:05:00`, `2019-04-04`
`ISO8601C`	`YYYY-MM-DD [hh:mm:ss[:SSS]]`	`2017-12-31 11:12:13:456`
`DMY`	`DD/MM/YYYY [hh:mm:ss[.SSS]]`	`31/12/2017 11:12:13.123`
`YMD`	`YYYY/MM/DD [hh:mm:ss[.SSS]]`	`2017/12/31 11:12:13.678`
`MDY`	`MM/DD/YYYY [hh:mm:ss[.SSS]]`	`12/31/2017 11:12:13.456`
`YYYYMMDD`	`YYYYMMDD[hh[mm[ss[SSS]]]]`	`20171231111213456`
`YYYY-M-D`	`YYYY-M-D[ h:m[:s[.S]]]`	`2017-9-10 10:7:21.1` (optional leading zeroes)
`YYYY/M/D`	`YYYY/M/D[ h:m[:s[.S]]]`	`2017/9/10 10:7:21.1` (optional leading zeroes)
`DD-mon-YYYY`	`DD-mon-YYYY[ hh:mm[:ss[.SSS]]]`	`31-Dec-2017 11:12:13.456`
`YYYY-mon-DD`	`YYYY-mon-DD[ hh:mm[:ss[.SSS]]]`	`2017-Dec-31 11:12:13.456`

Pattern	Description
`YYYY`	four digit year representation (0000-9999)
`MM`	two digit month representation (01-12)
`DD`	two digit day of month representation (01-31)
`m`	short month representation (Jan-Dec)
`a`	short day of week representation (Sun-Sat).
`hh`	two digit 24 hour representation (00-23)
`h`	two digit 12 hour representation (00-12)
`P`	uppercase AM/PM representation
`mm`	two digit minute representation (00-59)
`ss`	two digit seconds representation (00-59)
`SSS`	3 digits fraction representation for milliseconds (000-999)

Character	Description	ASCII	Octal	Hex	Binary	HTML Code	HTML Name
(Space)	Space	32	40	20	100000
!	Exclamation Mark	33	41	21	100001	!	&excl;
#	Hash or Number	35	43	23	100011	#	&num;
$	Dollar Sign	36	44	24	100100	$	&dollar;
%	Percentage	37	45	25	100101	%	&percnt;
&	Ampersand	38	46	26	100110	&	&
(	Left Parenthesis	40	50	28	101000	(	(
)	Right Parenthesis	41	51	29	101001	)	)
*	Asterisk	42	52	2A	101010	*	&ast;
+	Plus Sign	43	53	2B	101011	+	+
,	Comma	44	54	2C	101100	,	,
/	Slash	47	57	2F	101111	/	/
;	Semicolon	59	73	3B	111011	;	&semi;
<	Less Than	60	74	3C	111100	<	<
=	Equals Sign	61	75	3D	111101	=	=
>	Greater Than	62	76	3E	111110	>	>
?	Question Mark	63	77	3F	111111	?	&quest;
@	At Sign	64	100	40	1000000	@	&commat;
[	Left Square Bracket	91	133	5B	1011011	[	[
\	Backslash	92	134	5C	1011100	\	\
]	Right Square Bracket	93	135	5D	1011101	]	]
^	Caret or Circumflex	94	136	5E	1011110	^	&hat;
_	Underscore	95	137	5F	1011111	_	&lowbar;
`	Grave Accent	96	140	60	1100000	`	&grave;
{	Left Curly Bracket	123	173	7B	1111011	{	{
\|	Vertical Bar	124	174	7C	1111100	\|	\|
}	Right Curly Bracket	125	175	7D	1111101	}	}
~	Tilde	126	176	7E	1111110	~	&tilde;
58	:	Colon	72	3A	111010	:	&colon;
65	A	A	101	41	1000001	A
66	B	B	102	42	1000010	B
67	C	C	103	43	1000011	C
68	D	D	104	44	1000100	D
69	E	E	105	45	1000101	E
70	F	F	106	46	1000110	F
71	G	G	107	47	1000111	G
72	H	H	110	48	1001000	H
73	I	I	111	49	1001001	I
74	J	J	112	4A	1001010	J
75	K	K	113	4B	1001011	K
76	L	L	114	4C	1001100	L
77	M	M	115	4D	1001101	M
79	O	O	117	4F	1001111	O
80	P	P	120	50	1010000	P
81	Q	Q	121	51	1010001	Q
82	R	R	122	52	1010010	R
83	S	S	123	53	1010011	S
84	T	T	124	54	1010100	T
85	U	U	125	55	1010101	U
86	V	V	126	56	1010110	V
87	W	W	127	57	1010111	W
88	X	X	130	58	1011000	X
89	Y	Y	131	59	1011001	Y
90	Z	Z	132	5A	1011010	Z
92	\	Backslash	134	5C	01011100	\
97	a	a	141	61	1100001	a
98	b	b	142	62	1100010	b
99	c	c	143	63	1100011	c
100	d	d	144	64	1100100	d
101	e	e	145	65	1100101	e
102	f	f	146	66	1100110	f
103	g	g	147	67	1100111	g
104	h	h	150	68	1101000	h
105	i	i	151	69	1101001	i
106	j	j	152	6A	1101010	j
107	k	k	153	6B	1101011	k
108	l	l	154	6C	1101100	l
109	m	m	155	6D	1101101	m
110	n	n	156	6E	1101110	n
111	o	o	157	6F	1101111	o
112	p	p	160	70	1110000	p
113	q	q	161	71	1110001	q
114	r	r	162	72	1110010	r
115	s	s	163	73	1110011	s
116	t	t	164	74	1110100	t
117	u	u	165	75	1110101	u
118	v	v	166	76	1110110	v
119	w	w	167	77	1110111	w
120	x	x	170	78	1111000	x
121	y	y	171	79	1111001	y
122	z	z	172	7A	1111010	z

Character	Description	Octal	ASCII	Hex	Binary	HTML Code	HTML Name
NUL	Null	0	0	0	0
SOH	Start of Heading	1	1	1	1
STX	Start of Text	2	2	2	10
ETX	End of Text	3	3	3	11
EOT	End of Transmission	4	4	4	100
ENQ	Enquiry	5	5	5	101
ACK	Acknowledge	6	6	6	110
BEL	Bell	7	7	7	111
BS	Backspace	10	8	8	1000
HT	Horizontal Tab	11	9	9	1001
VT	Vertical Tab	13	11	0B	1011
FF	NP Form Feed, New Page	14	12	0C	1100
SO	Shift Out	16	14	0E	1110
SI	Shift In	17	15	0F	1111
DLE	Data Link Escape	20	16	10	10000
DC1	Device Control 1	21	17	11	10001
DC2	Device Control 2	22	18	12	10010
DC3	Device Control 3	23	19	13	10011
DC4	Device Control 4	24	20	14	10100
NAK	Negative Acknowledge	25	21	15	10101
SYN	Synchronous Idle	26	22	16	10110
ETB	End of Transmission Block	27	23	17	10111
CAN	Cancel	30	24	18	11000
EM	End of Medium	31	25	19	11001
SUB	Substitute	32	26	1A	11010
ESC	Escape	33	27	1B	11011
FS	File Separator	34	28	1C	11100
GS	Group Separator	35	29	1D	11101
RS	Record Separator	36	30	1E	11110
US	Unit Separator	37	31	1F	11111
DEL	Delete	177	127	7F	1111111

ASCII	Character	Description	Octal	Hex	Binary	HTML Code	HTML Name
10	LF	NL Line Feed, New Line	12	0A	1010
13	CR	Carriage Return	15	0D	1101
34	“	Double Quote	42	22	100010	"	"
45	-	Minus Sign	55	2D	101101	-	−
46	.	Period	56	2E	101110	.	&period;
48	0	Zero	60	30	110000	0
49	1	Number One	61	31	110001	1
50	2	Number Two	62	32	110010	2
51	3	Number Three	63	33	110011	3
52	4	Number Four	64	34	110100	4
53	5	Number Five	65	35	110101	5
54	6	Number Six	66	36	110110	6
55	7	Number Seven	67	37	110111	7
56	8	Number Eight	70	38	111000	8
57	9	Number Nine	71	39	111001	9
58	:	Colon	72	3A	111010	:	&colon;
92	\	Backslash	134	5C	01011100	\
78	N	N	116	4E	1001110	N

Database Object	Table
Clustering Keys	`clustering_keys`
Columns	`columns`, `external_table_columns`
Databases	`databases`
Parameters	`parameters`
Permissions	`table_permissions`, `database_permissions`, `schema_permissions`, `permission_types`, `udf_permissions`, `sqream_catalog.table_default_permissions`
Queries	`savedqueries`
Roles	`roles`, `role_memberships`
Schemas	`schemas`
Tables	`tables`, `external_tables`
Views	`views`
User Defined Functions	`user_defined_functions`

Database Object	Table
Extents	Shows `extents`
Chunk columns	Shows `chunks_columns`
Chunks	Shows `chunks`
Delete predicates	Shows `delete_predicates`. For more information, see Deleting Data

Column	Description
`database_name`	Shows the name of the database containing the table.
`table_id`	Shows the ID of the table containing the column.
`schema_name`	Shows the name of the schema containing the table.
`table_name`	Shows the name of the table containing the column.
`clustering_key`	Shows the name of the column used as a clustering key for this table.

Column	Description
`database_Id`	Shows the database’s unique ID.
`database_name`	Shows the database’s name.
`default_disk_chunk_size`	Reserved for internal use.
`default_process_chunk_size`	Reserved for internal use.
`rechunk_size`	Reserved for internal use.
`storage_subchunk_size`	Reserved for internal use.
`compression_chunk_size_threshold`	Reserved for internal use.

Column	Description
`flag_name`	Shows the flag name
`value`	Shows the current flag configured value
`default_value`	Shows the flag default value
`scope`	Shows whether flag configuration is session-based or cluster-based
`description`	Describes the purpose of the flag

Column	Description
`permission_type_id`	Shows the permission type’s ID.
`name`	Shows the name of the permission type.

Column	Description
`database_name`	Shows the database that the default permission rule applies to.
`schema_id`	Shows the schema that the rule applies to, or `NULL` if the `ALTER` statement does not specify a schema.
`modifier_role_id`	Shows the role to apply the rule to.
`getter_role_id`	Shows the role that the permission is granted to.
`permission_type`	Shows the type of permission granted.

Column	Description
`database_name`	Shows the name of the database the permission applies to
`role_id`	Shows the ID of the role granted permissions.
`permission_type`	Identifies the permission type.

Column	Description
`name`	Shows the saved query name.
`num_parameters`	Shows the number of parameters to be replaced at run-time.

Column	Description
`role_id`	Shows the role’s database-unique ID.
`name`	Shows the role’s name.
`superuser`	Identifies whether the role is a superuser (`1` - superuser, `0` - regular user).
`login`	Identifies whether the role can be used to log in to SQream (`1` - yes, `0` - no).
`has_password`	Identifies whether the role has a password (`1` - yes, `0` - no).

Column	Description
`role_id`	Shows the role ID.
`member_role_id`	Shows the ID of the parent role that this role inherits from.
`inherit`	Identifies whether permissions are inherited (`1` - yes, `0` - no).
`admin`	Identifies whether role is admin (`1` - yes, `0` - no).

Column	Description
`schema_id`	Shows the schema’s unique ID.
`schema_name`	Shows the schema’s name.
`schema_owner`	Shows the name of the role that owns the schema.
`rechunker_ignore`	Reserved for internal use.

SQreamDB Complete Documentation

Table of Contents

Priority 1: 🔥 Core SQL Reference & Catalog

Data Type Guides

Reference

Priority 2: ⚡ Data Operations

Connecting To Sqream

Data Ingestion

Reference

Priority 3: ⚙️ Configuration & Performance

Configuration Guides

External Storage Platforms

Operational Guides

Priority 4: 🏗️ Architecture & Advanced Features

Architecture

Feature Guides

Sqream Studio

Priority 5: 🚀 Getting Started & Installation

Getting Started

Installation Guides

Troubleshooting

Priority 6: 📚 Additional Resources

Downloads

Images

Connecting To Sqream

Errors

Glossary.Html

Index.Html

Reference

Releases

Sqreamdb On Aws

P1: CORE Array

Array

Syntax

Supported Operators

Examples

ARRAY Statements

Ingesting Arrayed Data from External Files

Limitations

Casting Limitations

NUMERIC

TEXT

Connectors

.NET and ODBC

Pysqream

Functions

|| (Concatenate)

UNNEST

Window

P1: CORE Boolean

Boolean

Boolean Examples

Boolean Casts and Conversions

P1: CORE Casts and Conversions

Casts and Conversions

Conversion Methods

Supported Casts

Value Dependent Conversions

P1: CORE Data Types

Data Types

P1: CORE DateTime2

DateTime2

Aliases

Syntax

Size

Date Examples

Date Casts and Conversions

P1: CORE Date

Date

Date Types

Aliases

Syntax

Size

Date Examples

Date Casts and Conversions

P1: CORE Floating Point

Floating Point

Floating Point Types

Floating Point Examples

Floating Point Casts and Conversions

`ARRAY` Statements

`NUMERIC`

`TEXT`

`.NET` and `ODBC`

`Pysqream`

Loading Files Using `DELETE_SOURCE_ON_SUCCESS`

Loading Files Formatted for Windows (`\r\n`)

Column	Description
`view_id`	Shows the view’s database-unique ID.
`view_schema`	Shows the name of the schema containing the view.
`view_name`	Shows the name of the view.
`view_data`	Reserved for internal use.
`view_query_text`	Identifies the `AS` clause used to create the view.

Column	Description
`database_name`	Shows the name of the database containing the view.
`function_id`	Shows the UDF’s database-unique ID.
`function_name`	Shows the name of the UDF.

Function	Description
& (bitwise AND)	Bitwise AND
~ (bitwise NOT)	Bitwise NOT
\| (bitwise OR)	Bitwise OR
<< (bitwise shift left)	Bitwise shift left
>> (bitwise shift right)	Bitwise shift right
XOR (bitwise XOR)	Bitwise XOR

Function	Description
BETWEEN	Value is in [ or not within ] the range
CASE	Test a conditional expression, and depending on the result, evaluate additional expressions.
COALESCE	Evaluate first non-NULL expression
IN	Value is in [ or not within ] a set of values
ISNULL	Alias for COALESCE with two expressions
IS_ASCII	Test a `TEXT` for ASCII-only characters
IS NULL	Check for `NULL` [ or non-`NULL` ] values
IS TABLE EXISTS	Checks if the mentioned table exists in the mentioned schema
IS VIEW EXISTS	Checks if the mentioned view exists in the mentioned schema

Function	Description
FROM_UNIXTS, FROM_UNIXTSMS	Converts a UNIX Timestamp to `DATE` or `DATETIME`
TO_HEX	Converts a number to a hexadecimal string representation
TO_UNIXTS, TO_UNIXTSMS	Converts a `DATE` or `DATETIME` to a UNIX Timestamp
CHR	Returns the ASCII character representation of the supplied integer
IS CASTABLE	Checks whether a cast operation is possible or supported for a given column and data type and provides an alternative when there is an exception

Function	Description
CURDATE	Special syntax, equivalent to CURRENT_DATE
CURRENT_DATE	Returns the current date as `DATE`
CURRENT_TIMESTAMP	Equivalent to GETDATE
DATEPART	Extracts a date or time element from a date expression
DATEADD	Adds an interval to a date expression
DATEDIFF	Calculates the time difference between two date expressions
EOMONTH	Calculates the last day of the month of a given date expression
EXTRACT	ANSI syntax for extracting date or time element from a date expression
GETDATE	Returns the current timestamp as `DATETIME`
SYSDATE	Equivalent to GETDATE
Date and Time TRUNC	Truncates a date element down to a specified date or time element

Operator	Syntax	Description
`+` (unary)	`+a`	Converts a string to a numeric value. Identical to `a :: double`
`+`	`a + b`	Adds two expressions together
`-` (unary)	`-a`	Negates a numeric expression
`-`	`a - b`	Subtracts `b` from `a`
`*`	`a * b`	Multiplies `a` by `b`
`/`	`a / b`	Divides `a` by `b`
`%`	`a % b`	Modulu of `a` by `b`. See also MOD, %

Function	Description
ABS	Calculates the absolute value of an argument
ACOS	Calculates the inverse cosine of an argument
ASIN	Calculates the inverse sine of an argument
ATAN	Calculates the inverse tangent of an argument
ATN2	Calculates the inverse tangent for a point (y, x)
CEILING / CEIL	Calculates the next integer for an argument
COS	Calculates the cosine of an argument
COT	Calculates the cotangent of an argument
DEGREES	Converts a value from radian values to degrees
EXP	Calcalates the natural exponent for an argument (e^x)
FLOOR	Calculates the largest integer smaller than the argument
LOG	Calculates the natural log for an argument
LOG10	Calculates the 10-based log for an argument
MOD, %	Calculates the modulu (remainder) of two arguments
PI	Returns the constant value for π
POWER	Calculates x to the power of y (x^y)
RADIANS	Converts a value from degree values to radians
ROUND	Rounds an argument down to the nearest integer, or an arbitrary precision
SIN	Calculates the sine of an argument
SQRT	Calculates the square root of an argument (√x)
SQUARE	Raises an argument to the power of 2 (x^y)
TAN	Calculates the tangent of an argument
TRUNC	Rounds a number to its integer representation towards 0

Function	Description
CHARACTER_LENGTH / CHAR_LENGTH	Calculates number of characters in an argument
CHARINDEX	Calculates the position where a string starts inside another string
\|\| (Concatenate)	Concatenates two strings
CONCAT function	Concatenates multiple strings
CRC64	Calculates a CRC-64 hash of an argument
DECODE	Decodes or extracts binary data from a textual input string
ISPREFIXOF	Matches if a string is the prefix of another string
LEFT	Returns the first number of characters from an argument
LEN	Calculates the length of a string in characters
LIKE	Tests if a string argument matches a pattern
LOWER	Converts an argument to a lower-case equivalent
LTRIM	Trims whitespaces from the left side of an argument
OCTET_LENGTH	Calculates the length of a string in bytes
PATINDEX	Calculates the position where a pattern matches a string
REGEXP_COUNT	Calculates the number of matches of a regular expression match in an argument
REGEXP_INSTR	Returns the start position of a regular expression match in an argument
REGEXP_REPLACE	Replaces and returns the text column substrings of a regular expression match in an argument
REGEXP_SUBSTR	Returns a substring of an argument that matches a regular expression
REPEAT	Repeats a string as many times as specified
REPLACE	Replaces characters in a string
REVERSE	Reverses a string argument
RIGHT	Returns the last number of characters from an argument
RLIKE	Tests if a string argument matches a regular expression pattern
RTRIM	Trims whitespace from the right side of an argument
SUBSTRING	Returns a substring of an argument
TRIM	Trims whitespaces from an argument
UPPER	Converts an argument to an upper-case equivalent
ASCII	Returns an `INT` value representing the ASCII code of the leftmost character in a string

Function	Aliases	Description
AVG		Calculates the average of all of the values
CORR		Calculates the Pearson correlation coefficient
COUNT		Calculates the count of all of the values or only distinct values
COVAR_POP		Calculates population covariance of values
COVAR_SAMP		Calculates sample covariance of values
MAX		Returns maximum value of all values
MIN		Returns minimum value of all values
SUM		Calculates the sum of all of the values or only distinct values
STDDEV_SAMP	`stdev`, `stddev`	Calculates sample standard deviation of values
STDDEV_POP	`stdevp`	Calculates population standard deviation of values
VAR_SAMP	`var`, `variance`	Calculates sample variance of values
VAR_POP	`varp`	Calculates population variance of values