From c5eee38fbb44fbeae34736d4be4df6e4507a6fe0 Mon Sep 17 00:00:00 2001 From: Andrew Kane Date: Fri, 7 Aug 2026 22:34:12 -0700 Subject: [PATCH] Added comments to functions - #1013 [skip ci] --- sql/vector--0.8.6--0.8.7.sql | 228 +++++++++++++++++++++++++++++++++++ sql/vector.sql | 228 +++++++++++++++++++++++++++++++++++ 2 files changed, 456 insertions(+) diff --git a/sql/vector--0.8.6--0.8.7.sql b/sql/vector--0.8.6--0.8.7.sql index 5843358..39dd5a0 100644 --- a/sql/vector--0.8.6--0.8.7.sql +++ b/sql/vector--0.8.6--0.8.7.sql @@ -1,8 +1,236 @@ -- complain if script is sourced in psql, rather than via CREATE EXTENSION \echo Use "ALTER EXTENSION vector UPDATE TO '0.8.7'" to load this file. \quit +COMMENT ON FUNCTION vector_in(cstring, oid, integer) IS 'I/O'; + +COMMENT ON FUNCTION vector_out(vector) IS 'I/O'; + +COMMENT ON FUNCTION vector_typmod_in(cstring[]) IS 'I/O typmod'; + +COMMENT ON FUNCTION vector_recv(internal, oid, integer) IS 'I/O'; + +COMMENT ON FUNCTION vector_send(vector) IS 'I/O'; + COMMENT ON TYPE vector IS 'single-precision vector'; +COMMENT ON FUNCTION l2_distance(vector, vector) IS 'Euclidean distance'; + +COMMENT ON FUNCTION inner_product(vector, vector) IS 'inner product'; + +COMMENT ON FUNCTION cosine_distance(vector, vector) IS 'cosine distance'; + +COMMENT ON FUNCTION l1_distance(vector, vector) IS 'taxicab distance'; + +COMMENT ON FUNCTION vector_dims(vector) IS 'number of dimensions'; + +COMMENT ON FUNCTION vector_norm(vector) IS 'Euclidean norm'; + +COMMENT ON FUNCTION l2_normalize(vector) IS 'normalize with Euclidean norm'; + +COMMENT ON FUNCTION binary_quantize(vector) IS 'binary quantize'; + +COMMENT ON FUNCTION subvector(vector, int, int) IS 'subvector'; + +COMMENT ON FUNCTION vector_add(vector, vector) IS 'implementation of + operator'; + +COMMENT ON FUNCTION vector_sub(vector, vector) IS 'implementation of - operator'; + +COMMENT ON FUNCTION vector_mul(vector, vector) IS 'implementation of * operator'; + +COMMENT ON FUNCTION vector_concat(vector, vector) IS 'implementation of || operator'; + +COMMENT ON FUNCTION vector_lt(vector, vector) IS 'implementation of < operator'; + +COMMENT ON FUNCTION vector_le(vector, vector) IS 'implementation of <= operator'; + +COMMENT ON FUNCTION vector_eq(vector, vector) IS 'implementation of = operator'; + +COMMENT ON FUNCTION vector_ne(vector, vector) IS 'implementation of <> operator'; + +COMMENT ON FUNCTION vector_ge(vector, vector) IS 'implementation of >= operator'; + +COMMENT ON FUNCTION vector_gt(vector, vector) IS 'implementation of > operator'; + +COMMENT ON FUNCTION vector_cmp(vector, vector) IS 'less-equal-greater'; + +COMMENT ON FUNCTION vector_l2_squared_distance(vector, vector) IS 'squared Euclidean distance'; + +COMMENT ON FUNCTION vector_negative_inner_product(vector, vector) IS 'negative inner product'; + +COMMENT ON FUNCTION vector_spherical_distance(vector, vector) IS 'spherical distance'; + +COMMENT ON FUNCTION vector_accum(double precision[], vector) IS 'aggregate transition function'; + +COMMENT ON FUNCTION vector_avg(double precision[]) IS 'aggregate final function'; + +COMMENT ON FUNCTION vector_combine(double precision[], double precision[]) IS 'aggregate combine function'; + +COMMENT ON FUNCTION vector(vector, integer, boolean) IS 'adjust vector to typmod'; + +COMMENT ON FUNCTION array_to_vector(integer[], integer, boolean) IS 'convert int4 array to vector'; + +COMMENT ON FUNCTION array_to_vector(real[], integer, boolean) IS 'convert float4 array to vector'; + +COMMENT ON FUNCTION array_to_vector(double precision[], integer, boolean) IS 'convert float8 array to vector'; + +COMMENT ON FUNCTION array_to_vector(numeric[], integer, boolean) IS 'convert numeric array to vector'; + +COMMENT ON FUNCTION vector_to_float4(vector, integer, boolean) IS 'convert vector to float4 array'; + +COMMENT ON FUNCTION ivfflathandler(internal) IS 'ivfflat index access method handler'; + +COMMENT ON FUNCTION hnswhandler(internal) IS 'hnsw index access method handler'; + +COMMENT ON FUNCTION ivfflat_halfvec_support(internal) IS 'ivfflat halfvec support'; + +COMMENT ON FUNCTION ivfflat_bit_support(internal) IS 'ivfflat bit support'; + +COMMENT ON FUNCTION hnsw_halfvec_support(internal) IS 'hnsw halfvec support'; + +COMMENT ON FUNCTION hnsw_bit_support(internal) IS 'hnsw bit support'; + +COMMENT ON FUNCTION hnsw_sparsevec_support(internal) IS 'hnsw sparsevec support'; + +COMMENT ON FUNCTION halfvec_in(cstring, oid, integer) IS 'I/O'; + +COMMENT ON FUNCTION halfvec_out(halfvec) IS 'I/O'; + +COMMENT ON FUNCTION halfvec_typmod_in(cstring[]) IS 'I/O typmod'; + +COMMENT ON FUNCTION halfvec_recv(internal, oid, integer) IS 'I/O'; + +COMMENT ON FUNCTION halfvec_send(halfvec) IS 'I/O'; + COMMENT ON TYPE halfvec IS 'half-precision vector'; +COMMENT ON FUNCTION l2_distance(halfvec, halfvec) IS 'Euclidean distance'; + +COMMENT ON FUNCTION inner_product(halfvec, halfvec) IS 'inner product'; + +COMMENT ON FUNCTION cosine_distance(halfvec, halfvec) IS 'cosine distance'; + +COMMENT ON FUNCTION l1_distance(halfvec, halfvec) IS 'taxicab distance'; + +COMMENT ON FUNCTION vector_dims(halfvec) IS 'number of dimensions'; + +COMMENT ON FUNCTION l2_norm(halfvec) IS 'Euclidean norm'; + +COMMENT ON FUNCTION l2_normalize(halfvec) IS 'normalize with Euclidean norm'; + +COMMENT ON FUNCTION binary_quantize(halfvec) IS 'binary quantize'; + +COMMENT ON FUNCTION subvector(halfvec, int, int) IS 'subvector'; + +COMMENT ON FUNCTION halfvec_add(halfvec, halfvec) IS 'implementation of + operator'; + +COMMENT ON FUNCTION halfvec_sub(halfvec, halfvec) IS 'implementation of - operator'; + +COMMENT ON FUNCTION halfvec_mul(halfvec, halfvec) IS 'implementation of * operator'; + +COMMENT ON FUNCTION halfvec_concat(halfvec, halfvec) IS 'implementation of || operator'; + +COMMENT ON FUNCTION halfvec_lt(halfvec, halfvec) IS 'implementation of < operator'; + +COMMENT ON FUNCTION halfvec_le(halfvec, halfvec) IS 'implementation of <= operator'; + +COMMENT ON FUNCTION halfvec_eq(halfvec, halfvec) IS 'implementation of = operator'; + +COMMENT ON FUNCTION halfvec_ne(halfvec, halfvec) IS 'implementation of <> operator'; + +COMMENT ON FUNCTION halfvec_ge(halfvec, halfvec) IS 'implementation of >= operator'; + +COMMENT ON FUNCTION halfvec_gt(halfvec, halfvec) IS 'implementation of > operator'; + +COMMENT ON FUNCTION halfvec_cmp(halfvec, halfvec) IS 'less-equal-greater'; + +COMMENT ON FUNCTION halfvec_l2_squared_distance(halfvec, halfvec) IS 'squared Euclidean distance'; + +COMMENT ON FUNCTION halfvec_negative_inner_product(halfvec, halfvec) IS 'negative inner product'; + +COMMENT ON FUNCTION halfvec_spherical_distance(halfvec, halfvec) IS 'spherical distance'; + +COMMENT ON FUNCTION halfvec_accum(double precision[], halfvec) IS 'aggregate transition function'; + +COMMENT ON FUNCTION halfvec_avg(double precision[]) IS 'aggregate final function'; + +COMMENT ON FUNCTION halfvec_combine(double precision[], double precision[]) IS 'aggregate combine function'; + +COMMENT ON FUNCTION halfvec(halfvec, integer, boolean) IS 'adjust halfvec to typmod'; + +COMMENT ON FUNCTION halfvec_to_vector(halfvec, integer, boolean) IS 'convert halfvec to vector'; + +COMMENT ON FUNCTION vector_to_halfvec(vector, integer, boolean) IS 'convert vector to halfvec'; + +COMMENT ON FUNCTION array_to_halfvec(integer[], integer, boolean) IS 'convert int4 array to halfvec'; + +COMMENT ON FUNCTION array_to_halfvec(real[], integer, boolean) IS 'convert float4 array to halfvec'; + +COMMENT ON FUNCTION array_to_halfvec(double precision[], integer, boolean) IS 'convert float8 array to halfvec'; + +COMMENT ON FUNCTION array_to_halfvec(numeric[], integer, boolean) IS 'convert numeric array to halfvec'; + +COMMENT ON FUNCTION halfvec_to_float4(halfvec, integer, boolean) IS 'convert halfvec to float4 array'; + +COMMENT ON FUNCTION hamming_distance(bit, bit) IS 'Hamming distance'; + +COMMENT ON FUNCTION jaccard_distance(bit, bit) IS 'Jaccard distance'; + +COMMENT ON FUNCTION sparsevec_in(cstring, oid, integer) IS 'I/O'; + +COMMENT ON FUNCTION sparsevec_out(sparsevec) IS 'I/O'; + +COMMENT ON FUNCTION sparsevec_typmod_in(cstring[]) IS 'I/O typmod'; + +COMMENT ON FUNCTION sparsevec_recv(internal, oid, integer) IS 'I/O'; + +COMMENT ON FUNCTION sparsevec_send(sparsevec) IS 'I/O'; + COMMENT ON TYPE sparsevec IS 'single-precision sparse vector'; + +COMMENT ON FUNCTION l2_distance(sparsevec, sparsevec) IS 'Euclidean distance'; + +COMMENT ON FUNCTION inner_product(sparsevec, sparsevec) IS 'inner product'; + +COMMENT ON FUNCTION cosine_distance(sparsevec, sparsevec) IS 'cosine distance'; + +COMMENT ON FUNCTION l1_distance(sparsevec, sparsevec) IS 'taxicab distance'; + +COMMENT ON FUNCTION l2_norm(sparsevec) IS 'Euclidean norm'; + +COMMENT ON FUNCTION l2_normalize(sparsevec) IS 'normalize with Euclidean norm'; + +COMMENT ON FUNCTION sparsevec_lt(sparsevec, sparsevec) IS 'implementation of < operator'; + +COMMENT ON FUNCTION sparsevec_le(sparsevec, sparsevec) IS 'implementation of <= operator'; + +COMMENT ON FUNCTION sparsevec_eq(sparsevec, sparsevec) IS 'implementation of = operator'; + +COMMENT ON FUNCTION sparsevec_ne(sparsevec, sparsevec) IS 'implementation of <> operator'; + +COMMENT ON FUNCTION sparsevec_ge(sparsevec, sparsevec) IS 'implementation of >= operator'; + +COMMENT ON FUNCTION sparsevec_gt(sparsevec, sparsevec) IS 'implementation of > operator'; + +COMMENT ON FUNCTION sparsevec_cmp(sparsevec, sparsevec) IS 'less-equal-greater'; + +COMMENT ON FUNCTION sparsevec_l2_squared_distance(sparsevec, sparsevec) IS 'squared Euclidean distance'; + +COMMENT ON FUNCTION sparsevec_negative_inner_product(sparsevec, sparsevec) IS 'negative inner product'; + +COMMENT ON FUNCTION sparsevec(sparsevec, integer, boolean) IS 'adjust sparsevec to typmod'; + +COMMENT ON FUNCTION vector_to_sparsevec(vector, integer, boolean) IS 'convert vector to sparsevec'; + +COMMENT ON FUNCTION sparsevec_to_vector(sparsevec, integer, boolean) IS 'convert sparsevec to vector'; + +COMMENT ON FUNCTION halfvec_to_sparsevec(halfvec, integer, boolean) IS 'convert halfvec to sparsevec'; + +COMMENT ON FUNCTION sparsevec_to_halfvec(sparsevec, integer, boolean) IS 'convert sparsevec to halfvec'; + +COMMENT ON FUNCTION array_to_sparsevec(integer[], integer, boolean) IS 'convert int4 array to sparsevec'; + +COMMENT ON FUNCTION array_to_sparsevec(real[], integer, boolean) IS 'convert float4 array to sparsevec'; + +COMMENT ON FUNCTION array_to_sparsevec(double precision[], integer, boolean) IS 'convert float8 array to sparsevec'; + +COMMENT ON FUNCTION array_to_sparsevec(numeric[], integer, boolean) IS 'convert numeric array to sparsevec'; diff --git a/sql/vector.sql b/sql/vector.sql index 1814974..d5de317 100644 --- a/sql/vector.sql +++ b/sql/vector.sql @@ -8,18 +8,28 @@ CREATE TYPE vector; CREATE FUNCTION vector_in(cstring, oid, integer) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_in(cstring, oid, integer) IS 'I/O'; + CREATE FUNCTION vector_out(vector) RETURNS cstring AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_out(vector) IS 'I/O'; + CREATE FUNCTION vector_typmod_in(cstring[]) RETURNS integer AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_typmod_in(cstring[]) IS 'I/O typmod'; + CREATE FUNCTION vector_recv(internal, oid, integer) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_recv(internal, oid, integer) IS 'I/O'; + CREATE FUNCTION vector_send(vector) RETURNS bytea AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_send(vector) IS 'I/O'; + CREATE TYPE vector ( INPUT = vector_in, OUTPUT = vector_out, @@ -36,83 +46,135 @@ COMMENT ON TYPE vector IS 'single-precision vector'; CREATE FUNCTION l2_distance(vector, vector) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l2_distance(vector, vector) IS 'Euclidean distance'; + CREATE FUNCTION inner_product(vector, vector) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION inner_product(vector, vector) IS 'inner product'; + CREATE FUNCTION cosine_distance(vector, vector) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION cosine_distance(vector, vector) IS 'cosine distance'; + CREATE FUNCTION l1_distance(vector, vector) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l1_distance(vector, vector) IS 'taxicab distance'; + CREATE FUNCTION vector_dims(vector) RETURNS integer AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_dims(vector) IS 'number of dimensions'; + CREATE FUNCTION vector_norm(vector) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_norm(vector) IS 'Euclidean norm'; + CREATE FUNCTION l2_normalize(vector) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l2_normalize(vector) IS 'normalize with Euclidean norm'; + CREATE FUNCTION binary_quantize(vector) RETURNS bit AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION binary_quantize(vector) IS 'binary quantize'; + CREATE FUNCTION subvector(vector, int, int) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION subvector(vector, int, int) IS 'subvector'; + -- vector private functions CREATE FUNCTION vector_add(vector, vector) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_add(vector, vector) IS 'implementation of + operator'; + CREATE FUNCTION vector_sub(vector, vector) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_sub(vector, vector) IS 'implementation of - operator'; + CREATE FUNCTION vector_mul(vector, vector) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_mul(vector, vector) IS 'implementation of * operator'; + CREATE FUNCTION vector_concat(vector, vector) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_concat(vector, vector) IS 'implementation of || operator'; + CREATE FUNCTION vector_lt(vector, vector) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_lt(vector, vector) IS 'implementation of < operator'; + CREATE FUNCTION vector_le(vector, vector) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_le(vector, vector) IS 'implementation of <= operator'; + CREATE FUNCTION vector_eq(vector, vector) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_eq(vector, vector) IS 'implementation of = operator'; + CREATE FUNCTION vector_ne(vector, vector) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_ne(vector, vector) IS 'implementation of <> operator'; + CREATE FUNCTION vector_ge(vector, vector) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_ge(vector, vector) IS 'implementation of >= operator'; + CREATE FUNCTION vector_gt(vector, vector) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_gt(vector, vector) IS 'implementation of > operator'; + CREATE FUNCTION vector_cmp(vector, vector) RETURNS int4 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_cmp(vector, vector) IS 'less-equal-greater'; + CREATE FUNCTION vector_l2_squared_distance(vector, vector) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_l2_squared_distance(vector, vector) IS 'squared Euclidean distance'; + CREATE FUNCTION vector_negative_inner_product(vector, vector) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_negative_inner_product(vector, vector) IS 'negative inner product'; + CREATE FUNCTION vector_spherical_distance(vector, vector) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_spherical_distance(vector, vector) IS 'spherical distance'; + CREATE FUNCTION vector_accum(double precision[], vector) RETURNS double precision[] AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_accum(double precision[], vector) IS 'aggregate transition function'; + CREATE FUNCTION vector_avg(double precision[]) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_avg(double precision[]) IS 'aggregate final function'; + CREATE FUNCTION vector_combine(double precision[], double precision[]) RETURNS double precision[] AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_combine(double precision[], double precision[]) IS 'aggregate combine function'; + -- vector aggregates CREATE AGGREGATE avg(vector) ( @@ -136,21 +198,33 @@ CREATE AGGREGATE sum(vector) ( CREATE FUNCTION vector(vector, integer, boolean) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector(vector, integer, boolean) IS 'adjust vector to typmod'; + CREATE FUNCTION array_to_vector(integer[], integer, boolean) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_vector(integer[], integer, boolean) IS 'convert int4 array to vector'; + CREATE FUNCTION array_to_vector(real[], integer, boolean) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_vector(real[], integer, boolean) IS 'convert float4 array to vector'; + CREATE FUNCTION array_to_vector(double precision[], integer, boolean) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_vector(double precision[], integer, boolean) IS 'convert float8 array to vector'; + CREATE FUNCTION array_to_vector(numeric[], integer, boolean) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_vector(numeric[], integer, boolean) IS 'convert numeric array to vector'; + CREATE FUNCTION vector_to_float4(vector, integer, boolean) RETURNS real[] AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_to_float4(vector, integer, boolean) IS 'convert vector to float4 array'; + -- vector casts CREATE CAST (vector AS vector) @@ -252,6 +326,8 @@ CREATE OPERATOR > ( CREATE FUNCTION ivfflathandler(internal) RETURNS index_am_handler AS 'MODULE_PATHNAME' LANGUAGE C; +COMMENT ON FUNCTION ivfflathandler(internal) IS 'ivfflat index access method handler'; + CREATE ACCESS METHOD ivfflat TYPE INDEX HANDLER ivfflathandler; COMMENT ON ACCESS METHOD ivfflat IS 'ivfflat index access method'; @@ -259,6 +335,8 @@ COMMENT ON ACCESS METHOD ivfflat IS 'ivfflat index access method'; CREATE FUNCTION hnswhandler(internal) RETURNS index_am_handler AS 'MODULE_PATHNAME' LANGUAGE C; +COMMENT ON FUNCTION hnswhandler(internal) IS 'hnsw index access method handler'; + CREATE ACCESS METHOD hnsw TYPE INDEX HANDLER hnswhandler; COMMENT ON ACCESS METHOD hnsw IS 'hnsw index access method'; @@ -268,18 +346,28 @@ COMMENT ON ACCESS METHOD hnsw IS 'hnsw index access method'; CREATE FUNCTION ivfflat_halfvec_support(internal) RETURNS internal AS 'MODULE_PATHNAME' LANGUAGE C; +COMMENT ON FUNCTION ivfflat_halfvec_support(internal) IS 'ivfflat halfvec support'; + CREATE FUNCTION ivfflat_bit_support(internal) RETURNS internal AS 'MODULE_PATHNAME' LANGUAGE C; +COMMENT ON FUNCTION ivfflat_bit_support(internal) IS 'ivfflat bit support'; + CREATE FUNCTION hnsw_halfvec_support(internal) RETURNS internal AS 'MODULE_PATHNAME' LANGUAGE C; +COMMENT ON FUNCTION hnsw_halfvec_support(internal) IS 'hnsw halfvec support'; + CREATE FUNCTION hnsw_bit_support(internal) RETURNS internal AS 'MODULE_PATHNAME' LANGUAGE C; +COMMENT ON FUNCTION hnsw_bit_support(internal) IS 'hnsw bit support'; + CREATE FUNCTION hnsw_sparsevec_support(internal) RETURNS internal AS 'MODULE_PATHNAME' LANGUAGE C; +COMMENT ON FUNCTION hnsw_sparsevec_support(internal) IS 'hnsw sparsevec support'; + -- vector opclasses CREATE OPERATOR CLASS vector_ops @@ -340,18 +428,28 @@ CREATE TYPE halfvec; CREATE FUNCTION halfvec_in(cstring, oid, integer) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_in(cstring, oid, integer) IS 'I/O'; + CREATE FUNCTION halfvec_out(halfvec) RETURNS cstring AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_out(halfvec) IS 'I/O'; + CREATE FUNCTION halfvec_typmod_in(cstring[]) RETURNS integer AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_typmod_in(cstring[]) IS 'I/O typmod'; + CREATE FUNCTION halfvec_recv(internal, oid, integer) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_recv(internal, oid, integer) IS 'I/O'; + CREATE FUNCTION halfvec_send(halfvec) RETURNS bytea AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_send(halfvec) IS 'I/O'; + CREATE TYPE halfvec ( INPUT = halfvec_in, OUTPUT = halfvec_out, @@ -368,83 +466,135 @@ COMMENT ON TYPE halfvec IS 'half-precision vector'; CREATE FUNCTION l2_distance(halfvec, halfvec) RETURNS float8 AS 'MODULE_PATHNAME', 'halfvec_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l2_distance(halfvec, halfvec) IS 'Euclidean distance'; + CREATE FUNCTION inner_product(halfvec, halfvec) RETURNS float8 AS 'MODULE_PATHNAME', 'halfvec_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION inner_product(halfvec, halfvec) IS 'inner product'; + CREATE FUNCTION cosine_distance(halfvec, halfvec) RETURNS float8 AS 'MODULE_PATHNAME', 'halfvec_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION cosine_distance(halfvec, halfvec) IS 'cosine distance'; + CREATE FUNCTION l1_distance(halfvec, halfvec) RETURNS float8 AS 'MODULE_PATHNAME', 'halfvec_l1_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l1_distance(halfvec, halfvec) IS 'taxicab distance'; + CREATE FUNCTION vector_dims(halfvec) RETURNS integer AS 'MODULE_PATHNAME', 'halfvec_vector_dims' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_dims(halfvec) IS 'number of dimensions'; + CREATE FUNCTION l2_norm(halfvec) RETURNS float8 AS 'MODULE_PATHNAME', 'halfvec_l2_norm' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l2_norm(halfvec) IS 'Euclidean norm'; + CREATE FUNCTION l2_normalize(halfvec) RETURNS halfvec AS 'MODULE_PATHNAME', 'halfvec_l2_normalize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l2_normalize(halfvec) IS 'normalize with Euclidean norm'; + CREATE FUNCTION binary_quantize(halfvec) RETURNS bit AS 'MODULE_PATHNAME', 'halfvec_binary_quantize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION binary_quantize(halfvec) IS 'binary quantize'; + CREATE FUNCTION subvector(halfvec, int, int) RETURNS halfvec AS 'MODULE_PATHNAME', 'halfvec_subvector' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION subvector(halfvec, int, int) IS 'subvector'; + -- halfvec private functions CREATE FUNCTION halfvec_add(halfvec, halfvec) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_add(halfvec, halfvec) IS 'implementation of + operator'; + CREATE FUNCTION halfvec_sub(halfvec, halfvec) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_sub(halfvec, halfvec) IS 'implementation of - operator'; + CREATE FUNCTION halfvec_mul(halfvec, halfvec) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_mul(halfvec, halfvec) IS 'implementation of * operator'; + CREATE FUNCTION halfvec_concat(halfvec, halfvec) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_concat(halfvec, halfvec) IS 'implementation of || operator'; + CREATE FUNCTION halfvec_lt(halfvec, halfvec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_lt(halfvec, halfvec) IS 'implementation of < operator'; + CREATE FUNCTION halfvec_le(halfvec, halfvec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_le(halfvec, halfvec) IS 'implementation of <= operator'; + CREATE FUNCTION halfvec_eq(halfvec, halfvec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_eq(halfvec, halfvec) IS 'implementation of = operator'; + CREATE FUNCTION halfvec_ne(halfvec, halfvec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_ne(halfvec, halfvec) IS 'implementation of <> operator'; + CREATE FUNCTION halfvec_ge(halfvec, halfvec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_ge(halfvec, halfvec) IS 'implementation of >= operator'; + CREATE FUNCTION halfvec_gt(halfvec, halfvec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_gt(halfvec, halfvec) IS 'implementation of > operator'; + CREATE FUNCTION halfvec_cmp(halfvec, halfvec) RETURNS int4 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_cmp(halfvec, halfvec) IS 'less-equal-greater'; + CREATE FUNCTION halfvec_l2_squared_distance(halfvec, halfvec) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_l2_squared_distance(halfvec, halfvec) IS 'squared Euclidean distance'; + CREATE FUNCTION halfvec_negative_inner_product(halfvec, halfvec) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_negative_inner_product(halfvec, halfvec) IS 'negative inner product'; + CREATE FUNCTION halfvec_spherical_distance(halfvec, halfvec) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_spherical_distance(halfvec, halfvec) IS 'spherical distance'; + CREATE FUNCTION halfvec_accum(double precision[], halfvec) RETURNS double precision[] AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_accum(double precision[], halfvec) IS 'aggregate transition function'; + CREATE FUNCTION halfvec_avg(double precision[]) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_avg(double precision[]) IS 'aggregate final function'; + CREATE FUNCTION halfvec_combine(double precision[], double precision[]) RETURNS double precision[] AS 'MODULE_PATHNAME', 'vector_combine' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_combine(double precision[], double precision[]) IS 'aggregate combine function'; + -- halfvec aggregates CREATE AGGREGATE avg(halfvec) ( @@ -468,27 +618,43 @@ CREATE AGGREGATE sum(halfvec) ( CREATE FUNCTION halfvec(halfvec, integer, boolean) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec(halfvec, integer, boolean) IS 'adjust halfvec to typmod'; + CREATE FUNCTION halfvec_to_vector(halfvec, integer, boolean) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_to_vector(halfvec, integer, boolean) IS 'convert halfvec to vector'; + CREATE FUNCTION vector_to_halfvec(vector, integer, boolean) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_to_halfvec(vector, integer, boolean) IS 'convert vector to halfvec'; + CREATE FUNCTION array_to_halfvec(integer[], integer, boolean) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_halfvec(integer[], integer, boolean) IS 'convert int4 array to halfvec'; + CREATE FUNCTION array_to_halfvec(real[], integer, boolean) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_halfvec(real[], integer, boolean) IS 'convert float4 array to halfvec'; + CREATE FUNCTION array_to_halfvec(double precision[], integer, boolean) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_halfvec(double precision[], integer, boolean) IS 'convert float8 array to halfvec'; + CREATE FUNCTION array_to_halfvec(numeric[], integer, boolean) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_halfvec(numeric[], integer, boolean) IS 'convert numeric array to halfvec'; + CREATE FUNCTION halfvec_to_float4(halfvec, integer, boolean) RETURNS real[] AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_to_float4(halfvec, integer, boolean) IS 'convert halfvec to float4 array'; + -- halfvec casts CREATE CAST (halfvec AS halfvec) @@ -656,9 +822,13 @@ CREATE OPERATOR CLASS halfvec_l1_ops CREATE FUNCTION hamming_distance(bit, bit) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION hamming_distance(bit, bit) IS 'Hamming distance'; + CREATE FUNCTION jaccard_distance(bit, bit) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION jaccard_distance(bit, bit) IS 'Jaccard distance'; + -- bit operators CREATE OPERATOR <~> ( @@ -699,18 +869,28 @@ CREATE TYPE sparsevec; CREATE FUNCTION sparsevec_in(cstring, oid, integer) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_in(cstring, oid, integer) IS 'I/O'; + CREATE FUNCTION sparsevec_out(sparsevec) RETURNS cstring AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_out(sparsevec) IS 'I/O'; + CREATE FUNCTION sparsevec_typmod_in(cstring[]) RETURNS integer AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_typmod_in(cstring[]) IS 'I/O typmod'; + CREATE FUNCTION sparsevec_recv(internal, oid, integer) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_recv(internal, oid, integer) IS 'I/O'; + CREATE FUNCTION sparsevec_send(sparsevec) RETURNS bytea AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_send(sparsevec) IS 'I/O'; + CREATE TYPE sparsevec ( INPUT = sparsevec_in, OUTPUT = sparsevec_out, @@ -727,79 +907,127 @@ COMMENT ON TYPE sparsevec IS 'single-precision sparse vector'; CREATE FUNCTION l2_distance(sparsevec, sparsevec) RETURNS float8 AS 'MODULE_PATHNAME', 'sparsevec_l2_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l2_distance(sparsevec, sparsevec) IS 'Euclidean distance'; + CREATE FUNCTION inner_product(sparsevec, sparsevec) RETURNS float8 AS 'MODULE_PATHNAME', 'sparsevec_inner_product' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION inner_product(sparsevec, sparsevec) IS 'inner product'; + CREATE FUNCTION cosine_distance(sparsevec, sparsevec) RETURNS float8 AS 'MODULE_PATHNAME', 'sparsevec_cosine_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION cosine_distance(sparsevec, sparsevec) IS 'cosine distance'; + CREATE FUNCTION l1_distance(sparsevec, sparsevec) RETURNS float8 AS 'MODULE_PATHNAME', 'sparsevec_l1_distance' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l1_distance(sparsevec, sparsevec) IS 'taxicab distance'; + CREATE FUNCTION l2_norm(sparsevec) RETURNS float8 AS 'MODULE_PATHNAME', 'sparsevec_l2_norm' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l2_norm(sparsevec) IS 'Euclidean norm'; + CREATE FUNCTION l2_normalize(sparsevec) RETURNS sparsevec AS 'MODULE_PATHNAME', 'sparsevec_l2_normalize' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION l2_normalize(sparsevec) IS 'normalize with Euclidean norm'; + -- sparsevec private functions CREATE FUNCTION sparsevec_lt(sparsevec, sparsevec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_lt(sparsevec, sparsevec) IS 'implementation of < operator'; + CREATE FUNCTION sparsevec_le(sparsevec, sparsevec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_le(sparsevec, sparsevec) IS 'implementation of <= operator'; + CREATE FUNCTION sparsevec_eq(sparsevec, sparsevec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_eq(sparsevec, sparsevec) IS 'implementation of = operator'; + CREATE FUNCTION sparsevec_ne(sparsevec, sparsevec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_ne(sparsevec, sparsevec) IS 'implementation of <> operator'; + CREATE FUNCTION sparsevec_ge(sparsevec, sparsevec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_ge(sparsevec, sparsevec) IS 'implementation of >= operator'; + CREATE FUNCTION sparsevec_gt(sparsevec, sparsevec) RETURNS bool AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_gt(sparsevec, sparsevec) IS 'implementation of > operator'; + CREATE FUNCTION sparsevec_cmp(sparsevec, sparsevec) RETURNS int4 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_cmp(sparsevec, sparsevec) IS 'less-equal-greater'; + CREATE FUNCTION sparsevec_l2_squared_distance(sparsevec, sparsevec) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_l2_squared_distance(sparsevec, sparsevec) IS 'squared Euclidean distance'; + CREATE FUNCTION sparsevec_negative_inner_product(sparsevec, sparsevec) RETURNS float8 AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_negative_inner_product(sparsevec, sparsevec) IS 'negative inner product'; + -- sparsevec cast functions CREATE FUNCTION sparsevec(sparsevec, integer, boolean) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec(sparsevec, integer, boolean) IS 'adjust sparsevec to typmod'; + CREATE FUNCTION vector_to_sparsevec(vector, integer, boolean) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION vector_to_sparsevec(vector, integer, boolean) IS 'convert vector to sparsevec'; + CREATE FUNCTION sparsevec_to_vector(sparsevec, integer, boolean) RETURNS vector AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_to_vector(sparsevec, integer, boolean) IS 'convert sparsevec to vector'; + CREATE FUNCTION halfvec_to_sparsevec(halfvec, integer, boolean) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION halfvec_to_sparsevec(halfvec, integer, boolean) IS 'convert halfvec to sparsevec'; + CREATE FUNCTION sparsevec_to_halfvec(sparsevec, integer, boolean) RETURNS halfvec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION sparsevec_to_halfvec(sparsevec, integer, boolean) IS 'convert sparsevec to halfvec'; + CREATE FUNCTION array_to_sparsevec(integer[], integer, boolean) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_sparsevec(integer[], integer, boolean) IS 'convert int4 array to sparsevec'; + CREATE FUNCTION array_to_sparsevec(real[], integer, boolean) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_sparsevec(real[], integer, boolean) IS 'convert float4 array to sparsevec'; + CREATE FUNCTION array_to_sparsevec(double precision[], integer, boolean) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_sparsevec(double precision[], integer, boolean) IS 'convert float8 array to sparsevec'; + CREATE FUNCTION array_to_sparsevec(numeric[], integer, boolean) RETURNS sparsevec AS 'MODULE_PATHNAME' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE; +COMMENT ON FUNCTION array_to_sparsevec(numeric[], integer, boolean) IS 'convert numeric array to sparsevec'; + -- sparsevec casts CREATE CAST (sparsevec AS sparsevec)