The VECTOR_NUM_ELEMENTS function returns the number of elements in the vector.




  • vector_expression: An expression that evaluates to a vector. Vectors can be stored in SingleStore using the native VECTOR type (Vector Type) or the BLOB type (BLOB Types). SingleStore recommends using the VECTOR type when possible.

Return Type

Returns a 64-bit Integer or NULL.


If the input is NULL, NULL will be returned.


The examples below show two uses of VECTOR_ELEMENTS_SUM with different types of VECTOR arguments.

Example 1 - Vector with F32 Element Type

First create a table of vectors of length 4 using the VECTOR data type and insert data into that table.

CREATE TABLE vectors (id int, vec VECTOR(4) not null);
INSERT INTO vectors VALUES (1, '[0.45, 0.55, 0.495, 0.5]');
INSERT INTO vectors VALUES (2, '[0.1, 0.8, 0.2, 0.555]');
INSERT INTO vectors VALUES (3, '[-0.5, -0.03, -0.1, 0.86]');
INSERT INTO vectors VALUES (4, '[0.5, 0.3, 0.807, 0.1]');


The default element type for Vector Type is 32-bit floating point (F32). The Vector Type supports other element types, including integer types, as described in the Vector Type documentation.

The following SQL returns the number of elements in the vector with id of 2.

Click the Playground icon to the right of the SQL listing to try this query. Also, try experimenting and writing your own query.

FROM vectors
WHERE id = 2;
| id   | VECTOR_NUM_ELEMENTS(vec) |
|    2 |                        4 |

Example 2 - Vector with I16 Element Type

This example shows how to use VECTOR_ELEMENTS_SUM with a VECTOR with an elementType of 16-bit integer (I16).

CREATE TABLE vectors_i16(id INT, vec VECTOR(3, I16));
INSERT INTO vectors_i16 VALUES(1, '[1, 2, 3]');
INSERT INTO vectors_i16 VALUES(2, '[4, 5, 6]');
INSERT INTO vectors_i16 VALUES(3, '[1, 4, 8]');

The following SQL returns the number of elements in the vector with id of 3.

FROM vectors_i16
WHERE id = 3;
| id   | VECTOR_NUM_ELEMENTS(vec) |
|    3 |                        3 |

Using VECTOR_NUM_ELEMENTS with Vectors as BLOBs

The following examples and descriptions show the use of VECTOR_NUM_ELEMENTS with an argument that is a vector stored as a BLOB.

Example 1 - BLOB Argument

Create a table with a column of type BLOB to store the vectors. The second column in this table, with column name vec and type BLOB, will store the vectors. This example demonstrates storing vector data using BLOBs, hence the column of type BLOB named vec.

Then use the JSON_ARRAY_PACK built-in function to easily insert properly formatted vectors.

CREATE TABLE vectors_b (id int, vec BLOB not null);
INSERT INTO vectors_b VALUES (1, JSON_ARRAY_PACK('[0.1, 0.8, 0.2, 0.555]')); 
INSERT INTO vectors_b VALUES (2, JSON_ARRAY_PACK('[0.45, 0.55, 0.495, 0.5]'));

The following query counts the number of elements of the vectors in the vectors_b table.

FROM vectors_b
| id   | VECTOR_NUM_ELEMENTS(vec) |
|    1 |                        4 |
|    2 |                        4 |

Using Suffixes for Other Element Types with BLOBs

The default element type for vector storage and processing is 32-bit floating point (F32). However, other element types are supported.

You can specify the datatype of the vector elements to be used in the operation by adding a suffix to the function. All operations are done using the specified datatype. Omitting the suffix from the function is equivalent to suffixing it with _F32.

When using a suffix, the return type will be the type of the suffix.


The functions with suffixes do not work with the VECTOR type.

The following table lists the suffixes and their data type.


Data Type


8-bit signed integer


16-bit signed integer


32-bit signed integer


64-bit signed integer


32-bit floating-point number (IEEE standard format)


64-bit floating-point number (IEEE standard format)

Example 2 - BLOBs with 16-bit Integers

Below is an example of using JSON_ARRAY_PACK and VECTOR_NUM_ELEMENTS with 16-bit signed integers.

First create a table of vectors stored as 16-bit integers. Note the use of the _I16 suffix on JSON_ARRAY_PACK.

CREATE TABLE vectors_b_i (id int, vec BLOB not null);
INSERT INTO vectors_b_i VALUES (1, JSON_ARRAY_PACK_I16('[1, 3, 2, 5]')); 
INSERT INTO vectors_b_i VALUES(2, JSON_ARRAY_PACK_I16('[23, 4, 1, 8]'));

The following query counts the number of elements in the vectors in the vectors_b_i table.

FROM vectors_b_i
| id   | VECTOR_NUM_ELEMENTS_I16(vec) |
|    1 |                            4 |
|    2 |                            4 |


Be sure that the suffixes you use to pack the vector data match the suffixes you use to unpack the data and the suffixes you use on functions to process that data.

Formatting Binary Vector Data for BLOBs

When using the BLOB type for vector operations, vector data can be formatted using JSON_ARRAY_PACK. If your vector data is already in a packed binary format, you can load that data into the BLOBs. The data must be encoded as a BLOB containing packed numbers in little-endian byte order. Vectors stored as BLOBs can be of any length; however, the input blob length must be divisible by the size of the packed vector elements (1, 2, 4 , or 8 bytes, depending on the vector element).

Last modified: May 30, 2024

Was this article helpful?