dearsky/wifi-densepose
1
0
Fork 0
Code Issues 20 Pull Requests 5 Actions Packages Projects Releases 1 Wiki Activity

Merge commit 'd803bfe2b1fe7f5e219e50ac20d6801a0a58ac75' as 'vendor/ruvector'

Browse Source
This commit is contained in:
ruv
2026-02-28 14:39:40 -05:00
parent 7885bf6278 d803bfe2b1
commit cd5943df23
7854 changed files with 3522914 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

43
vendor/ruvector/crates/ruvector-postgres/sql/access_methods.sql vendored Normal file
View File

@@ -0,0 +1,43 @@
-- ============================================================================
-- HNSW Access Method
-- ============================================================================
-- HNSW Access Method Handler
CREATE OR REPLACE FUNCTION hnsw_handler(internal)
RETURNS index_am_handler
AS 'MODULE_PATHNAME', 'hnsw_handler_wrapper'
LANGUAGE C STRICT;
-- Create HNSW Access Method
CREATE ACCESS METHOD hnsw TYPE INDEX HANDLER hnsw_handler;
-- ============================================================================
-- Operator Classes for HNSW
-- ============================================================================
-- HNSW Operator Class for L2 (Euclidean) distance
CREATE OPERATOR CLASS ruvector_l2_ops
DEFAULT FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <-> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_l2_distance(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_l2_ops USING hnsw IS
'ruvector HNSW operator class for L2/Euclidean distance';
-- HNSW Operator Class for Cosine distance
CREATE OPERATOR CLASS ruvector_cosine_ops
FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <=> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_cosine_distance(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_cosine_ops USING hnsw IS
'ruvector HNSW operator class for cosine distance';
-- HNSW Operator Class for Inner Product
CREATE OPERATOR CLASS ruvector_ip_ops
FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <#> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_inner_product(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_ip_ops USING hnsw IS
'ruvector HNSW operator class for inner product (max similarity)';

68
vendor/ruvector/crates/ruvector-postgres/sql/embeddings.sql vendored Normal file
View File

@@ -0,0 +1,68 @@
-- ============================================================================
-- Embedding Generation Functions
-- ============================================================================
-- Generate embedding from text using default or specified model
CREATE OR REPLACE FUNCTION ruvector_embed(text text, model_name text DEFAULT 'all-MiniLM-L6-v2')
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_embed_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Generate embeddings for multiple texts in batch
CREATE OR REPLACE FUNCTION ruvector_embed_batch(texts text[], model_name text DEFAULT 'all-MiniLM-L6-v2')
RETURNS real[][]
AS 'MODULE_PATHNAME', 'ruvector_embed_batch_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- List all available embedding models
CREATE OR REPLACE FUNCTION ruvector_embedding_models()
RETURNS TABLE (
model_name text,
dimensions integer,
description text,
is_loaded boolean
)
AS 'MODULE_PATHNAME', 'ruvector_embedding_models_wrapper'
LANGUAGE C IMMUTABLE STRICT;
-- Load embedding model into memory
CREATE OR REPLACE FUNCTION ruvector_load_model(model_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_load_model_wrapper'
LANGUAGE C STRICT;
-- Unload embedding model from memory
CREATE OR REPLACE FUNCTION ruvector_unload_model(model_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_unload_model_wrapper'
LANGUAGE C STRICT;
-- Get information about a specific model
CREATE OR REPLACE FUNCTION ruvector_model_info(model_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_model_info_wrapper'
LANGUAGE C IMMUTABLE STRICT;
-- Set default embedding model
CREATE OR REPLACE FUNCTION ruvector_set_default_model(model_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_set_default_model_wrapper'
LANGUAGE C STRICT;
-- Get current default embedding model
CREATE OR REPLACE FUNCTION ruvector_default_model()
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_default_model_wrapper'
LANGUAGE C IMMUTABLE STRICT;
-- Get embedding generation statistics
CREATE OR REPLACE FUNCTION ruvector_embedding_stats()
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_embedding_stats_wrapper'
LANGUAGE C IMMUTABLE STRICT;
-- Get dimensions for a specific model
CREATE OR REPLACE FUNCTION ruvector_embedding_dims(model_name text)
RETURNS integer
AS 'MODULE_PATHNAME', 'ruvector_embedding_dims_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;

327
vendor/ruvector/crates/ruvector-postgres/sql/graph_examples.sql vendored Normal file
View File

@@ -0,0 +1,327 @@
-- Graph Operations Examples for ruvector-postgres
-- This file demonstrates the graph database capabilities
-- ============================================================================
-- Basic Graph Operations
-- ============================================================================
-- Create a new graph
SELECT ruvector_create_graph('social_network');
-- List all graphs
SELECT ruvector_list_graphs();
-- ============================================================================
-- Social Network Example
-- ============================================================================
-- Add users
SELECT ruvector_add_node(
'social_network',
ARRAY['Person'],
jsonb_build_object('name', 'Alice', 'age', 30, 'city', 'New York')
) AS alice_id;
SELECT ruvector_add_node(
'social_network',
ARRAY['Person'],
jsonb_build_object('name', 'Bob', 'age', 25, 'city', 'San Francisco')
) AS bob_id;
SELECT ruvector_add_node(
'social_network',
ARRAY['Person'],
jsonb_build_object('name', 'Charlie', 'age', 35, 'city', 'Boston')
) AS charlie_id;
SELECT ruvector_add_node(
'social_network',
ARRAY['Person'],
jsonb_build_object('name', 'Diana', 'age', 28, 'city', 'Seattle')
) AS diana_id;
-- Create friendships
SELECT ruvector_add_edge(
'social_network',
1, 2, -- Alice -> Bob
'FRIENDS',
jsonb_build_object('since', '2020-01-15', 'strength', 0.9)
);
SELECT ruvector_add_edge(
'social_network',
2, 3, -- Bob -> Charlie
'FRIENDS',
jsonb_build_object('since', '2019-06-20', 'strength', 0.8)
);
SELECT ruvector_add_edge(
'social_network',
1, 4, -- Alice -> Diana
'FRIENDS',
jsonb_build_object('since', '2021-03-10', 'strength', 0.7)
);
SELECT ruvector_add_edge(
'social_network',
3, 4, -- Charlie -> Diana
'FRIENDS',
jsonb_build_object('since', '2020-09-05', 'strength', 0.85)
);
-- Get graph statistics
SELECT ruvector_graph_stats('social_network');
-- Find nodes by label
SELECT ruvector_find_nodes_by_label('social_network', 'Person');
-- Get neighbors of Alice (node 1)
SELECT ruvector_get_neighbors('social_network', 1);
-- Find shortest path from Alice to Charlie
SELECT ruvector_shortest_path('social_network', 1, 3, 10);
-- Find weighted shortest path
SELECT ruvector_shortest_path_weighted('social_network', 1, 3, 'strength');
-- ============================================================================
-- Cypher Query Examples
-- ============================================================================
-- Create nodes with Cypher
SELECT ruvector_cypher(
'social_network',
'CREATE (n:Person {name: ''Eve'', age: 27, city: ''Austin''}) RETURN n',
NULL
);
-- Match all persons
SELECT ruvector_cypher(
'social_network',
'MATCH (n:Person) RETURN n.name, n.age',
NULL
);
-- Match with WHERE clause
SELECT ruvector_cypher(
'social_network',
'MATCH (n:Person) WHERE n.age > 28 RETURN n.name, n.age',
NULL
);
-- Parameterized query
SELECT ruvector_cypher(
'social_network',
'MATCH (n:Person) WHERE n.name = $name RETURN n',
jsonb_build_object('name', 'Alice')
);
-- Create relationship with Cypher
SELECT ruvector_cypher(
'social_network',
'CREATE (a:Person {name: ''Frank''})-[:KNOWS {since: 2022}]->(b:Person {name: ''Grace''}) RETURN a, b',
NULL
);
-- ============================================================================
-- Knowledge Graph Example
-- ============================================================================
SELECT ruvector_create_graph('knowledge');
-- Add concepts
SELECT ruvector_cypher(
'knowledge',
'CREATE (ml:Concept {name: ''Machine Learning'', category: ''AI''})
CREATE (nn:Concept {name: ''Neural Networks'', category: ''AI''})
CREATE (dl:Concept {name: ''Deep Learning'', category: ''AI''})
CREATE (cv:Concept {name: ''Computer Vision'', category: ''AI''})
CREATE (nlp:Concept {name: ''Natural Language Processing'', category: ''AI''})
RETURN ml, nn, dl, cv, nlp',
NULL
);
-- Create relationships between concepts
WITH ids AS (
SELECT generate_series(1, 5) AS id
)
SELECT
CASE
WHEN i.id = 1 THEN ruvector_add_edge('knowledge', 1, 2, 'INCLUDES', '{"strength": 0.9}'::jsonb)
WHEN i.id = 2 THEN ruvector_add_edge('knowledge', 2, 3, 'SPECIALIZES_IN', '{"strength": 0.95}'::jsonb)
WHEN i.id = 3 THEN ruvector_add_edge('knowledge', 3, 4, 'APPLIES_TO', '{"strength": 0.85}'::jsonb)
WHEN i.id = 4 THEN ruvector_add_edge('knowledge', 3, 5, 'APPLIES_TO', '{"strength": 0.9}'::jsonb)
END AS edge_id
FROM ids i
WHERE i.id <= 4;
-- Find path from Machine Learning to Computer Vision
SELECT ruvector_shortest_path('knowledge', 1, 4, 10);
-- ============================================================================
-- Recommendation System Example
-- ============================================================================
SELECT ruvector_create_graph('recommendations');
-- Add users and movies
SELECT ruvector_cypher(
'recommendations',
'CREATE (u1:User {name: ''Alice'', preference: ''SciFi''})
CREATE (u2:User {name: ''Bob'', preference: ''Action''})
CREATE (u3:User {name: ''Charlie'', preference: ''SciFi''})
CREATE (m1:Movie {title: ''Inception'', genre: ''SciFi''})
CREATE (m2:Movie {title: ''Interstellar'', genre: ''SciFi''})
CREATE (m3:Movie {title: ''The Matrix'', genre: ''SciFi''})
CREATE (m4:Movie {title: ''Die Hard'', genre: ''Action''})
RETURN u1, u2, u3, m1, m2, m3, m4',
NULL
);
-- Create watch history
SELECT ruvector_add_edge('recommendations', 1, 4, 'WATCHED', '{"rating": 5, "timestamp": "2024-01-15"}'::jsonb);
SELECT ruvector_add_edge('recommendations', 1, 5, 'WATCHED', '{"rating": 4, "timestamp": "2024-01-20"}'::jsonb);
SELECT ruvector_add_edge('recommendations', 2, 7, 'WATCHED', '{"rating": 5, "timestamp": "2024-01-18"}'::jsonb);
SELECT ruvector_add_edge('recommendations', 3, 4, 'WATCHED', '{"rating": 5, "timestamp": "2024-01-22"}'::jsonb);
SELECT ruvector_add_edge('recommendations', 3, 6, 'WATCHED', '{"rating": 4, "timestamp": "2024-01-25"}'::jsonb);
-- Get statistics
SELECT ruvector_graph_stats('recommendations');
-- ============================================================================
-- Organizational Hierarchy Example
-- ============================================================================
SELECT ruvector_create_graph('org_chart');
-- Create organizational structure
SELECT ruvector_cypher(
'org_chart',
'CREATE (ceo:Employee {name: ''Jane Doe'', title: ''CEO'', level: 1})
CREATE (cto:Employee {name: ''John Smith'', title: ''CTO'', level: 2})
CREATE (cfo:Employee {name: ''Emily Brown'', title: ''CFO'', level: 2})
CREATE (dev1:Employee {name: ''Alex Johnson'', title: ''Senior Dev'', level: 3})
CREATE (dev2:Employee {name: ''Sarah Wilson'', title: ''Senior Dev'', level: 3})
CREATE (acc1:Employee {name: ''Michael Davis'', title: ''Accountant'', level: 3})
RETURN ceo, cto, cfo, dev1, dev2, acc1',
NULL
);
-- Create reporting structure
SELECT ruvector_add_edge('org_chart', 2, 1, 'REPORTS_TO', '{}'::jsonb);
SELECT ruvector_add_edge('org_chart', 3, 1, 'REPORTS_TO', '{}'::jsonb);
SELECT ruvector_add_edge('org_chart', 4, 2, 'REPORTS_TO', '{}'::jsonb);
SELECT ruvector_add_edge('org_chart', 5, 2, 'REPORTS_TO', '{}'::jsonb);
SELECT ruvector_add_edge('org_chart', 6, 3, 'REPORTS_TO', '{}'::jsonb);
-- Find all employees reporting to CTO (directly or indirectly)
SELECT ruvector_shortest_path('org_chart', 4, 1, 5); -- Path from dev1 to CEO
SELECT ruvector_shortest_path('org_chart', 5, 1, 5); -- Path from dev2 to CEO
-- ============================================================================
-- Transport Network Example
-- ============================================================================
SELECT ruvector_create_graph('transport');
-- Add cities as nodes
SELECT ruvector_add_node('transport', ARRAY['City'], '{"name": "New York", "population": 8336817}'::jsonb);
SELECT ruvector_add_node('transport', ARRAY['City'], '{"name": "Boston", "population": 692600}'::jsonb);
SELECT ruvector_add_node('transport', ARRAY['City'], '{"name": "Philadelphia", "population": 1584064}'::jsonb);
SELECT ruvector_add_node('transport', ARRAY['City'], '{"name": "Washington DC", "population": 705749}'::jsonb);
-- Add routes with distances
SELECT ruvector_add_edge('transport', 1, 2, 'ROUTE', '{"distance": 215, "mode": "train", "duration": 4.5}'::jsonb);
SELECT ruvector_add_edge('transport', 1, 3, 'ROUTE', '{"distance": 95, "mode": "train", "duration": 1.5}'::jsonb);
SELECT ruvector_add_edge('transport', 3, 4, 'ROUTE', '{"distance": 140, "mode": "train", "duration": 2.5}'::jsonb);
SELECT ruvector_add_edge('transport', 2, 3, 'ROUTE', '{"distance": 310, "mode": "train", "duration": 5.5}'::jsonb);
-- Find shortest route by distance
SELECT ruvector_shortest_path_weighted('transport', 2, 4, 'distance');
-- Find fastest route by duration
SELECT ruvector_shortest_path_weighted('transport', 2, 4, 'duration');
-- ============================================================================
-- Analytics Queries
-- ============================================================================
-- Get all graphs with their statistics
SELECT
name,
(ruvector_graph_stats(name)::jsonb)->>'node_count' AS nodes,
(ruvector_graph_stats(name)::jsonb)->>'edge_count' AS edges
FROM (
SELECT unnest(ruvector_list_graphs()) AS name
) graphs;
-- ============================================================================
-- Cleanup
-- ============================================================================
-- Delete specific graph
-- SELECT ruvector_delete_graph('social_network');
-- Delete all graphs
-- SELECT ruvector_delete_graph(name)
-- FROM unnest(ruvector_list_graphs()) AS name;
-- ============================================================================
-- Performance Testing
-- ============================================================================
-- Create a larger graph for performance testing
SELECT ruvector_create_graph('perf_test');
-- Generate random nodes
DO $$
DECLARE
i INTEGER;
BEGIN
FOR i IN 1..1000 LOOP
PERFORM ruvector_add_node(
'perf_test',
ARRAY['Node'],
jsonb_build_object('id', i, 'value', random() * 100)
);
END LOOP;
END $$;
-- Generate random edges
DO $$
DECLARE
i INTEGER;
source_id INTEGER;
target_id INTEGER;
BEGIN
FOR i IN 1..5000 LOOP
source_id := 1 + floor(random() * 1000)::INTEGER;
target_id := 1 + floor(random() * 1000)::INTEGER;
IF source_id <> target_id THEN
BEGIN
PERFORM ruvector_add_edge(
'perf_test',
source_id,
target_id,
'CONNECTS',
jsonb_build_object('weight', random())
);
EXCEPTION WHEN OTHERS THEN
-- Ignore errors (e.g., duplicate edges)
NULL;
END;
END IF;
END LOOP;
END $$;
-- Check performance stats
SELECT ruvector_graph_stats('perf_test');
-- Test path finding performance
\timing on
SELECT ruvector_shortest_path('perf_test', 1, 500, 20);
SELECT ruvector_shortest_path_weighted('perf_test', 1, 500, 'weight');
\timing off
-- Cleanup performance test
-- SELECT ruvector_delete_graph('perf_test');

203
vendor/ruvector/crates/ruvector-postgres/sql/hnsw_index.sql vendored Normal file
View File

@@ -0,0 +1,203 @@
-- ============================================================================
-- HNSW Index Access Method
-- ============================================================================
-- This file defines the HNSW (Hierarchical Navigable Small World) index
-- access method for PostgreSQL, providing fast approximate nearest neighbor
-- search for vector similarity queries.
--
-- The HNSW index stores vectors in a multi-layer graph structure optimized
-- for logarithmic search complexity.
-- ============================================================================
-- Access Method Registration
-- ============================================================================
-- Register HNSW as a PostgreSQL index access method
CREATE ACCESS METHOD hnsw TYPE INDEX HANDLER hnsw_handler;
COMMENT ON ACCESS METHOD hnsw IS 'HNSW (Hierarchical Navigable Small World) index for approximate nearest neighbor search';
-- ============================================================================
-- Operator Families
-- ============================================================================
-- L2 (Euclidean) distance operator family
CREATE OPERATOR FAMILY hnsw_l2_ops USING hnsw;
-- Cosine distance operator family
CREATE OPERATOR FAMILY hnsw_cosine_ops USING hnsw;
-- Inner product operator family
CREATE OPERATOR FAMILY hnsw_ip_ops USING hnsw;
-- ============================================================================
-- Distance Operators (using array-based functions for now)
-- ============================================================================
-- Note: These operators work with real[] type
-- Future version will support custom vector types
-- L2 distance operator: <->
CREATE OPERATOR <-> (
LEFTARG = real[],
RIGHTARG = real[],
FUNCTION = l2_distance_arr,
COMMUTATOR = '<->'
);
COMMENT ON OPERATOR <->(real[], real[]) IS 'L2 (Euclidean) distance';
-- Cosine distance operator: <=>
CREATE OPERATOR <=> (
LEFTARG = real[],
RIGHTARG = real[],
FUNCTION = cosine_distance_arr,
COMMUTATOR = '<=>'
);
COMMENT ON OPERATOR <=>(real[], real[]) IS 'Cosine distance';
-- Inner product operator: <#>
CREATE OPERATOR <#> (
LEFTARG = real[],
RIGHTARG = real[],
FUNCTION = neg_inner_product_arr,
COMMUTATOR = '<#>'
);
COMMENT ON OPERATOR <#>(real[], real[]) IS 'Negative inner product (for ORDER BY)';
-- ============================================================================
-- Operator Classes for HNSW - L2 Distance
-- ============================================================================
CREATE OPERATOR CLASS hnsw_l2_ops
FOR TYPE real[] USING hnsw
FAMILY hnsw_l2_ops AS
-- Distance operator for ORDER BY
OPERATOR 1 <-> (real[], real[]) FOR ORDER BY float_ops,
-- Support function: distance calculation
FUNCTION 1 l2_distance_arr(real[], real[]);
COMMENT ON OPERATOR CLASS hnsw_l2_ops USING hnsw IS
'HNSW index operator class for L2 (Euclidean) distance on real[] vectors';
-- ============================================================================
-- Operator Classes for HNSW - Cosine Distance
-- ============================================================================
CREATE OPERATOR CLASS hnsw_cosine_ops
FOR TYPE real[] USING hnsw
FAMILY hnsw_cosine_ops AS
-- Distance operator for ORDER BY
OPERATOR 1 <=> (real[], real[]) FOR ORDER BY float_ops,
-- Support function: distance calculation
FUNCTION 1 cosine_distance_arr(real[], real[]);
COMMENT ON OPERATOR CLASS hnsw_cosine_ops USING hnsw IS
'HNSW index operator class for cosine distance on real[] vectors';
-- ============================================================================
-- Operator Classes for HNSW - Inner Product
-- ============================================================================
CREATE OPERATOR CLASS hnsw_ip_ops
FOR TYPE real[] USING hnsw
FAMILY hnsw_ip_ops AS
-- Distance operator for ORDER BY
OPERATOR 1 <#> (real[], real[]) FOR ORDER BY float_ops,
-- Support function: distance calculation
FUNCTION 1 neg_inner_product_arr(real[], real[]);
COMMENT ON OPERATOR CLASS hnsw_ip_ops USING hnsw IS
'HNSW index operator class for inner product on real[] vectors';
-- ============================================================================
-- Index Creation Syntax Examples
-- ============================================================================
/*
-- Create table with vectors
CREATE TABLE items (
id SERIAL PRIMARY KEY,
embedding real[]
);
-- Create HNSW index with L2 distance (default)
CREATE INDEX ON items USING hnsw (embedding hnsw_l2_ops);
-- Create HNSW index with options
CREATE INDEX ON items USING hnsw (embedding hnsw_l2_ops)
WITH (m = 16, ef_construction = 64);
-- Create HNSW index with cosine distance
CREATE INDEX ON items USING hnsw (embedding hnsw_cosine_ops);
-- Create HNSW index with inner product
CREATE INDEX ON items USING hnsw (embedding hnsw_ip_ops);
-- Query examples:
-- Find 10 nearest neighbors using L2 distance
SELECT id, embedding <-> ARRAY[0.1, 0.2, 0.3]::real[] AS distance
FROM items
ORDER BY embedding <-> ARRAY[0.1, 0.2, 0.3]::real[]
LIMIT 10;
-- Find 10 nearest neighbors using cosine distance
SELECT id, embedding <=> ARRAY[0.1, 0.2, 0.3]::real[] AS distance
FROM items
ORDER BY embedding <=> ARRAY[0.1, 0.2, 0.3]::real[]
LIMIT 10;
-- Find 10 nearest neighbors using inner product
SELECT id, embedding <#> ARRAY[0.1, 0.2, 0.3]::real[] AS distance
FROM items
ORDER BY embedding <#> ARRAY[0.1, 0.2, 0.3]::real[]
LIMIT 10;
-- Index parameters:
-- - m: Maximum number of connections per layer (default: 16)
-- Higher values improve recall but increase memory usage
-- - ef_construction: Size of dynamic candidate list during construction (default: 64)
-- Higher values improve index quality but slow down build time
-- - ef_search: Size of dynamic candidate list during search (default: 40, set via GUC)
-- Higher values improve recall but slow down queries
-- Can be set per-session: SET ruvector.ef_search = 100;
*/
-- ============================================================================
-- Index Options Support
-- ============================================================================
-- Note: The actual options parsing is handled in the Rust code via hnsw_options callback
-- Supported options:
-- - m (integer): Maximum connections per layer, default 16, range 2-128
-- - ef_construction (integer): Construction candidate list size, default 64, range 4-1000
-- - metric (string): Distance metric 'l2', 'cosine', or 'ip', default 'l2'
-- ============================================================================
-- Performance Tuning
-- ============================================================================
-- Global settings (in postgresql.conf or ALTER SYSTEM):
-- ruvector.ef_search = 40 # Query-time candidate list size
-- ruvector.maintenance_work_mem # Use standard PostgreSQL setting
-- Session settings:
-- SET ruvector.ef_search = 100; # Increase recall for current session
-- SET maintenance_work_mem = '1GB'; # Increase for faster index builds
-- ============================================================================
-- Monitoring and Maintenance
-- ============================================================================
-- View index statistics
SELECT ruvector_memory_stats();
-- Perform index maintenance (rebuild connections, optimize graph)
SELECT ruvector_index_maintenance('items_embedding_idx');
-- Check index size
SELECT pg_size_pretty(pg_relation_size('items_embedding_idx'));
-- View index definition
SELECT indexdef FROM pg_indexes WHERE indexname = 'items_embedding_idx';

61
vendor/ruvector/crates/ruvector-postgres/sql/ivfflat_am.sql vendored Normal file
View File

@@ -0,0 +1,61 @@
-- IVFFlat Index Access Method Installation
-- ============================================================================
-- Creates the ruivfflat access method for PostgreSQL
-- Compatible with pgvector's ivfflat interface
-- Create access method
CREATE ACCESS METHOD ruivfflat TYPE INDEX HANDLER ruivfflat_handler;
-- Create operator classes for different distance metrics
-- L2 (Euclidean) distance operator class
CREATE OPERATOR CLASS ruvector_ivfflat_l2_ops
FOR TYPE vector USING ruivfflat AS
OPERATOR 1 <-> (vector, vector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_l2_distance(vector, vector);
-- Inner product distance operator class
CREATE OPERATOR CLASS ruvector_ivfflat_ip_ops
FOR TYPE vector USING ruivfflat AS
OPERATOR 1 <#> (vector, vector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_ip_distance(vector, vector);
-- Cosine distance operator class
CREATE OPERATOR CLASS ruvector_ivfflat_cosine_ops
FOR TYPE vector USING ruivfflat AS
OPERATOR 1 <=> (vector, vector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_cosine_distance(vector, vector);
-- Helper function to get IVFFlat index statistics
CREATE OR REPLACE FUNCTION ruvector_ivfflat_stats(index_name text)
RETURNS TABLE(
lists integer,
probes integer,
dimensions integer,
trained boolean,
vector_count bigint,
metric text
)
AS $$
BEGIN
-- This would query the index metadata
-- For now, return dummy data
RETURN QUERY SELECT
100::integer as lists,
1::integer as probes,
0::integer as dimensions,
false::boolean as trained,
0::bigint as vector_count,
'euclidean'::text as metric;
END;
$$ LANGUAGE plpgsql;
-- Example usage:
--
-- CREATE INDEX ON items USING ruivfflat (embedding vector_l2_ops)
-- WITH (lists = 100, probes = 1);
--
-- CREATE INDEX ON items USING ruivfflat (embedding vector_cosine_ops)
-- WITH (lists = 500, probes = 10);
--
-- SELECT * FROM ruvector_ivfflat_stats('items_embedding_idx');

495
vendor/ruvector/crates/ruvector-postgres/sql/routing_example.sql vendored Normal file
View File

@@ -0,0 +1,495 @@
-- Tiny Dancer Routing Module - SQL Examples
--
-- Complete examples for agent registration, routing, and monitoring
-- ============================================================================
-- Setup: Create supporting tables
-- ============================================================================
-- Table for storing requests with embeddings
CREATE TABLE ai_requests (
id BIGSERIAL PRIMARY KEY,
query_text TEXT NOT NULL,
embedding vector(384), -- Request embedding
task_type TEXT, -- 'coding', 'writing', 'analysis', etc.
priority TEXT, -- 'low', 'medium', 'high', 'critical'
created_at TIMESTAMPTZ DEFAULT NOW()
);
-- Table for tracking request completions
CREATE TABLE request_completions (
id BIGSERIAL PRIMARY KEY,
request_id BIGINT REFERENCES ai_requests(id),
agent_name TEXT NOT NULL,
latency_ms FLOAT NOT NULL,
cost FLOAT NOT NULL,
quality_score FLOAT,
success BOOLEAN DEFAULT true,
error_message TEXT,
completed_at TIMESTAMPTZ DEFAULT NOW()
);
-- ============================================================================
-- Agent Registration
-- ============================================================================
-- Register OpenAI models
SELECT ruvector_register_agent(
'gpt-4',
'llm',
ARRAY['coding', 'reasoning', 'math', 'writing', 'analysis'],
0.03, -- $0.03 per request
500.0, -- 500ms average latency
0.95 -- 0.95 quality score
);
SELECT ruvector_register_agent(
'gpt-4-turbo',
'llm',
ARRAY['coding', 'reasoning', 'fast', 'multimodal'],
0.02,
300.0,
0.93
);
SELECT ruvector_register_agent(
'gpt-3.5-turbo',
'llm',
ARRAY['general', 'fast', 'chat'],
0.002,
150.0,
0.75
);
-- Register Anthropic models
SELECT ruvector_register_agent(
'claude-3-opus',
'llm',
ARRAY['coding', 'reasoning', 'analysis', 'writing'],
0.025,
400.0,
0.93
);
SELECT ruvector_register_agent(
'claude-3-sonnet',
'llm',
ARRAY['coding', 'balanced', 'analysis'],
0.01,
250.0,
0.88
);
SELECT ruvector_register_agent(
'claude-3-haiku',
'llm',
ARRAY['fast', 'general', 'chat'],
0.003,
100.0,
0.80
);
-- Register open-source models
SELECT ruvector_register_agent(
'llama-2-70b',
'llm',
ARRAY['local', 'private', 'coding', 'general'],
0.0, -- Free (self-hosted)
800.0,
0.72
);
SELECT ruvector_register_agent(
'mixtral-8x7b',
'llm',
ARRAY['local', 'private', 'fast', 'coding'],
0.0,
600.0,
0.78
);
-- Register specialized models
SELECT ruvector_register_agent(
'codellama-34b',
'specialized',
ARRAY['coding', 'local', 'specialized'],
0.0,
700.0,
0.82
);
SELECT ruvector_register_agent(
'deepseek-coder',
'specialized',
ARRAY['coding', 'specialized', 'fast'],
0.005,
200.0,
0.85
);
-- ============================================================================
-- Basic Routing Examples
-- ============================================================================
-- Example 1: Balanced routing (default)
SELECT ruvector_route(
(SELECT embedding FROM ai_requests WHERE id = 1),
'balanced',
NULL
) AS routing_decision;
-- Example 2: Cost-optimized routing
SELECT ruvector_route(
(SELECT embedding FROM ai_requests WHERE id = 2),
'cost',
NULL
) AS routing_decision;
-- Example 3: Quality-optimized routing
SELECT ruvector_route(
(SELECT embedding FROM ai_requests WHERE id = 3),
'quality',
'{"min_quality": 0.9}'::jsonb
) AS routing_decision;
-- Example 4: Latency-optimized routing
SELECT ruvector_route(
(SELECT embedding FROM ai_requests WHERE id = 4),
'latency',
'{"max_latency_ms": 300.0}'::jsonb
) AS routing_decision;
-- ============================================================================
-- Constraint-Based Routing
-- ============================================================================
-- Example 5: Routing with cost constraint
SELECT
r.id,
r.query_text,
(ruvector_route(
r.embedding,
'quality',
'{"max_cost": 0.01}'::jsonb
))::jsonb->>'agent_name' AS selected_agent,
(ruvector_route(
r.embedding,
'quality',
'{"max_cost": 0.01}'::jsonb
))::jsonb->>'estimated_cost' AS estimated_cost
FROM ai_requests r
WHERE r.id = 5;
-- Example 6: Routing with multiple constraints
SELECT ruvector_route(
(SELECT embedding FROM ai_requests WHERE id = 6),
'balanced',
'{
"max_cost": 0.02,
"max_latency_ms": 500.0,
"min_quality": 0.85,
"required_capabilities": ["coding", "analysis"]
}'::jsonb
) AS routing_decision;
-- Example 7: Exclude specific agents
SELECT ruvector_route(
(SELECT embedding FROM ai_requests WHERE id = 7),
'quality',
'{
"excluded_agents": ["gpt-3.5-turbo", "llama-2-70b"],
"min_quality": 0.9
}'::jsonb
) AS routing_decision;
-- ============================================================================
-- Capability-Based Routing
-- ============================================================================
-- Example 8: Route coding tasks
SELECT
r.id,
r.query_text,
(ruvector_route(
r.embedding,
'quality',
'{"required_capabilities": ["coding"]}'::jsonb
))::jsonb AS routing
FROM ai_requests r
WHERE r.task_type = 'coding'
LIMIT 10;
-- Example 9: Route with multiple required capabilities
SELECT ruvector_route(
(SELECT embedding FROM ai_requests WHERE task_type = 'complex_analysis' LIMIT 1),
'balanced',
'{
"required_capabilities": ["coding", "reasoning", "analysis"],
"min_quality": 0.85
}'::jsonb
) AS routing_decision;
-- ============================================================================
-- Batch Routing
-- ============================================================================
-- Example 10: Process batch of requests
CREATE TEMP TABLE batch_routing_results AS
SELECT
r.id,
r.query_text,
r.task_type,
r.priority,
(ruvector_route(
r.embedding,
CASE
WHEN r.priority = 'critical' THEN 'quality'
WHEN r.priority = 'high' THEN 'balanced'
ELSE 'cost'
END,
CASE
WHEN r.priority = 'critical' THEN '{"min_quality": 0.95}'::jsonb
WHEN r.priority = 'high' THEN '{"min_quality": 0.85, "max_latency_ms": 500.0}'::jsonb
ELSE '{"max_cost": 0.005}'::jsonb
END
))::jsonb AS routing_decision
FROM ai_requests r
WHERE created_at > NOW() - INTERVAL '1 hour'
AND r.id NOT IN (SELECT request_id FROM request_completions);
-- View batch results
SELECT
id,
task_type,
priority,
routing_decision->>'agent_name' AS agent,
(routing_decision->>'confidence')::float AS confidence,
(routing_decision->>'estimated_cost')::float AS cost,
(routing_decision->>'estimated_latency_ms')::float AS latency_ms,
routing_decision->>'reasoning' AS reasoning
FROM batch_routing_results
ORDER BY priority DESC, id;
-- Calculate batch statistics
SELECT
task_type,
routing_decision->>'agent_name' AS agent,
COUNT(*) AS requests,
AVG((routing_decision->>'estimated_cost')::float) AS avg_cost,
AVG((routing_decision->>'estimated_latency_ms')::float) AS avg_latency,
AVG((routing_decision->>'confidence')::float) AS avg_confidence
FROM batch_routing_results
GROUP BY task_type, routing_decision->>'agent_name'
ORDER BY requests DESC;
-- ============================================================================
-- Performance Tracking
-- ============================================================================
-- Example 11: Record request completion
INSERT INTO request_completions (request_id, agent_name, latency_ms, cost, quality_score, success)
VALUES (1, 'gpt-4', 450.0, 0.03, 0.92, true);
-- Update agent metrics after completion
SELECT ruvector_update_agent_metrics(
'gpt-4',
450.0,
true,
0.92
);
-- Example 12: Track performance over time
SELECT
agent_name,
DATE_TRUNC('hour', completed_at) AS hour,
COUNT(*) AS requests,
AVG(latency_ms) AS avg_latency,
AVG(cost) AS avg_cost,
AVG(quality_score) AS avg_quality,
SUM(CASE WHEN success THEN 1 ELSE 0 END)::float / COUNT(*) AS success_rate
FROM request_completions
WHERE completed_at > NOW() - INTERVAL '24 hours'
GROUP BY agent_name, DATE_TRUNC('hour', completed_at)
ORDER BY hour DESC, requests DESC;
-- ============================================================================
-- Agent Management
-- ============================================================================
-- Example 13: List all agents with statistics
SELECT
name,
agent_type,
capabilities,
cost_per_request,
avg_latency_ms,
quality_score,
success_rate,
total_requests,
is_active
FROM ruvector_list_agents()
ORDER BY total_requests DESC;
-- Example 14: Find best agents by capability
SELECT * FROM ruvector_find_agents_by_capability('coding', 5);
SELECT * FROM ruvector_find_agents_by_capability('writing', 5);
SELECT * FROM ruvector_find_agents_by_capability('fast', 5);
-- Example 15: Get detailed agent information
SELECT ruvector_get_agent('gpt-4') AS agent_details;
SELECT ruvector_get_agent('claude-3-opus') AS agent_details;
-- Example 16: View routing statistics
SELECT ruvector_routing_stats() AS stats;
-- ============================================================================
-- Advanced Routing Patterns
-- ============================================================================
-- Example 17: Create smart routing function
CREATE OR REPLACE FUNCTION smart_route(
request_embedding vector,
task_type TEXT,
priority TEXT DEFAULT 'medium',
max_budget FLOAT DEFAULT NULL
) RETURNS jsonb AS $$
DECLARE
optimization_target TEXT;
constraints jsonb;
BEGIN
-- Determine optimization strategy
optimization_target := CASE
WHEN priority = 'critical' THEN 'quality'
WHEN priority = 'high' THEN 'balanced'
WHEN priority = 'low' THEN 'cost'
ELSE 'balanced'
END;
-- Build constraints
constraints := jsonb_build_object(
'max_cost', COALESCE(max_budget, 1.0),
'min_quality', CASE
WHEN priority = 'critical' THEN 0.95
WHEN priority = 'high' THEN 0.85
ELSE 0.70
END,
'required_capabilities', CASE
WHEN task_type = 'coding' THEN ARRAY['coding']
WHEN task_type = 'writing' THEN ARRAY['writing']
WHEN task_type = 'analysis' THEN ARRAY['analysis', 'reasoning']
ELSE ARRAY[]::text[]
END
);
RETURN ruvector_route(
request_embedding::float4[],
optimization_target,
constraints
);
END;
$$ LANGUAGE plpgsql;
-- Use smart routing
SELECT smart_route(
(SELECT embedding FROM ai_requests WHERE id = 100),
'coding',
'high',
0.05
) AS routing_decision;
-- Example 18: Cost-aware view with fallback
CREATE VIEW cost_optimized_routing AS
SELECT
r.id,
r.query_text,
r.task_type,
r.priority,
-- Try cost-optimized first
COALESCE(
(SELECT ruvector_route(r.embedding, 'cost', '{"max_cost": 0.01, "min_quality": 0.8}'::jsonb)),
-- Fallback to balanced if no cheap option
ruvector_route(r.embedding, 'balanced', '{"max_cost": 0.05}'::jsonb)
) AS routing_decision
FROM ai_requests r;
-- Example 19: A/B testing framework
CREATE TABLE routing_experiments (
id BIGSERIAL PRIMARY KEY,
request_id BIGINT REFERENCES ai_requests(id),
agent_a TEXT,
agent_b TEXT,
selected_agent TEXT,
a_score FLOAT,
b_score FLOAT,
actual_quality FLOAT,
created_at TIMESTAMPTZ DEFAULT NOW()
);
-- Run A/B test
INSERT INTO routing_experiments (request_id, agent_a, agent_b, selected_agent, a_score, b_score)
SELECT
r.id,
'gpt-4' AS agent_a,
'claude-3-opus' AS agent_b,
CASE WHEN random() < 0.5 THEN 'gpt-4' ELSE 'claude-3-opus' END AS selected_agent,
(ruvector_route(r.embedding, 'quality', '{"excluded_agents": ["claude-3-opus"]}'::jsonb))::jsonb->>'expected_quality' AS a_score,
(ruvector_route(r.embedding, 'quality', '{"excluded_agents": ["gpt-4"]}'::jsonb))::jsonb->>'expected_quality' AS b_score
FROM ai_requests r
WHERE created_at > NOW() - INTERVAL '1 hour'
LIMIT 100;
-- ============================================================================
-- Monitoring and Alerts
-- ============================================================================
-- Example 20: Monitor agent health
CREATE VIEW agent_health AS
SELECT
name,
avg_latency_ms,
quality_score,
success_rate,
total_requests,
CASE
WHEN NOT is_active THEN 'inactive'
WHEN success_rate < 0.90 THEN 'critical'
WHEN avg_latency_ms > 1000 THEN 'slow'
WHEN quality_score < 0.75 THEN 'low_quality'
ELSE 'healthy'
END AS health_status
FROM ruvector_list_agents();
-- Find unhealthy agents
SELECT * FROM agent_health WHERE health_status != 'healthy';
-- Example 21: Cost tracking
CREATE VIEW daily_routing_costs AS
SELECT
DATE_TRUNC('day', completed_at) AS day,
agent_name,
COUNT(*) AS requests,
SUM(cost) AS total_cost,
AVG(cost) AS avg_cost_per_request,
AVG(quality_score) AS avg_quality
FROM request_completions
WHERE completed_at > NOW() - INTERVAL '30 days'
GROUP BY DATE_TRUNC('day', completed_at), agent_name
ORDER BY day DESC, total_cost DESC;
-- ============================================================================
-- Cleanup
-- ============================================================================
-- Example 22: Deactivate underperforming agents
UPDATE ruvector_list_agents()
SET is_active = false
WHERE success_rate < 0.80;
-- Example 23: Remove inactive agents
SELECT ruvector_remove_agent(name)
FROM ruvector_list_agents()
WHERE NOT is_active
AND total_requests = 0;
-- Example 24: Clear all agents (testing only)
-- SELECT ruvector_clear_agents();

829
vendor/ruvector/crates/ruvector-postgres/sql/ruvector--0.1.0.sql vendored Normal file
View File

@@ -0,0 +1,829 @@
-- RuVector PostgreSQL Extension
-- Version: 0.1.0
-- High-performance vector similarity search with SIMD optimizations
-- Complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION ruvector" to load this file. \quit
-- ============================================================================
-- Utility Functions
-- ============================================================================
-- Get extension version
CREATE OR REPLACE FUNCTION ruvector_version()
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_version_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get SIMD info
CREATE OR REPLACE FUNCTION ruvector_simd_info()
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_simd_info_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get memory stats
CREATE OR REPLACE FUNCTION ruvector_memory_stats()
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_memory_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- Native RuVector Type (pgvector-compatible)
-- ============================================================================
-- Create the ruvector type using low-level I/O functions
CREATE TYPE ruvector;
CREATE OR REPLACE FUNCTION ruvector_in(cstring) RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_in' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_out(ruvector) RETURNS cstring
AS 'MODULE_PATHNAME', 'ruvector_out' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_recv(internal) RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_recv' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_send(ruvector) RETURNS bytea
AS 'MODULE_PATHNAME', 'ruvector_send' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_typmod_in(cstring[]) RETURNS int
AS 'MODULE_PATHNAME', 'ruvector_typmod_in' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_typmod_out(int) RETURNS cstring
AS 'MODULE_PATHNAME', 'ruvector_typmod_out' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE TYPE ruvector (
INPUT = ruvector_in,
OUTPUT = ruvector_out,
RECEIVE = ruvector_recv,
SEND = ruvector_send,
TYPMOD_IN = ruvector_typmod_in,
TYPMOD_OUT = ruvector_typmod_out,
STORAGE = extended,
INTERNALLENGTH = VARIABLE,
ALIGNMENT = double
);
-- ============================================================================
-- Native RuVector Distance Functions (SIMD-optimized)
-- ============================================================================
-- L2 distance for native ruvector type
CREATE OR REPLACE FUNCTION ruvector_l2_distance(a ruvector, b ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_l2_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Cosine distance for native ruvector type
CREATE OR REPLACE FUNCTION ruvector_cosine_distance(a ruvector, b ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_cosine_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Inner product for native ruvector type
CREATE OR REPLACE FUNCTION ruvector_inner_product(a ruvector, b ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_inner_product_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Manhattan (L1) distance for native ruvector type
CREATE OR REPLACE FUNCTION ruvector_l1_distance(a ruvector, b ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_l1_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get dimensions of ruvector
CREATE OR REPLACE FUNCTION ruvector_dims(v ruvector)
RETURNS int
AS 'MODULE_PATHNAME', 'ruvector_dims_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get L2 norm of ruvector
CREATE OR REPLACE FUNCTION ruvector_norm(v ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_norm_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Normalize ruvector
CREATE OR REPLACE FUNCTION ruvector_normalize(v ruvector)
RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_normalize_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Add two ruvectors
CREATE OR REPLACE FUNCTION ruvector_add(a ruvector, b ruvector)
RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_add_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Subtract two ruvectors
CREATE OR REPLACE FUNCTION ruvector_sub(a ruvector, b ruvector)
RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_sub_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Multiply ruvector by scalar
CREATE OR REPLACE FUNCTION ruvector_mul_scalar(v ruvector, s real)
RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_mul_scalar_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Operators for Native RuVector Type
-- ============================================================================
-- L2 distance operator (<->)
CREATE OPERATOR <-> (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_l2_distance,
COMMUTATOR = '<->'
);
-- Cosine distance operator (<=>)
CREATE OPERATOR <=> (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_cosine_distance,
COMMUTATOR = '<=>'
);
-- Inner product operator (<#>)
CREATE OPERATOR <#> (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_inner_product,
COMMUTATOR = '<#>'
);
-- Addition operator (+)
CREATE OPERATOR + (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_add,
COMMUTATOR = '+'
);
-- Subtraction operator (-)
CREATE OPERATOR - (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_sub
);
-- ============================================================================
-- Distance Functions (array-based with SIMD optimization)
-- ============================================================================
-- L2 (Euclidean) distance between two float arrays
CREATE OR REPLACE FUNCTION l2_distance_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'l2_distance_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Inner product between two float arrays
CREATE OR REPLACE FUNCTION inner_product_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'inner_product_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Negative inner product (for ORDER BY ASC nearest neighbor)
CREATE OR REPLACE FUNCTION neg_inner_product_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'neg_inner_product_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Cosine distance between two float arrays
CREATE OR REPLACE FUNCTION cosine_distance_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'cosine_distance_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Cosine similarity between two float arrays
CREATE OR REPLACE FUNCTION cosine_similarity_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'cosine_similarity_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- L1 (Manhattan) distance between two float arrays
CREATE OR REPLACE FUNCTION l1_distance_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'l1_distance_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Vector Utility Functions
-- ============================================================================
-- Normalize a vector to unit length
CREATE OR REPLACE FUNCTION vector_normalize(v real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_normalize_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Add two vectors element-wise
CREATE OR REPLACE FUNCTION vector_add(a real[], b real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_add_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Subtract two vectors element-wise
CREATE OR REPLACE FUNCTION vector_sub(a real[], b real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_sub_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Multiply vector by scalar
CREATE OR REPLACE FUNCTION vector_mul_scalar(v real[], scalar real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_mul_scalar_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get vector dimensions
CREATE OR REPLACE FUNCTION vector_dims(v real[])
RETURNS int
AS 'MODULE_PATHNAME', 'vector_dims_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get vector L2 norm
CREATE OR REPLACE FUNCTION vector_norm(v real[])
RETURNS real
AS 'MODULE_PATHNAME', 'vector_norm_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Average two vectors
CREATE OR REPLACE FUNCTION vector_avg2(a real[], b real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_avg2_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Quantization Functions
-- ============================================================================
-- Binary quantize a vector
CREATE OR REPLACE FUNCTION binary_quantize_arr(v real[])
RETURNS bytea
AS 'MODULE_PATHNAME', 'binary_quantize_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Scalar quantize a vector (SQ8)
CREATE OR REPLACE FUNCTION scalar_quantize_arr(v real[])
RETURNS jsonb
AS 'MODULE_PATHNAME', 'scalar_quantize_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Aggregate Functions
-- ============================================================================
-- State transition function for vector sum
CREATE OR REPLACE FUNCTION vector_sum_state(state real[], value real[])
RETURNS real[]
AS $$
SELECT CASE
WHEN state IS NULL THEN value
WHEN value IS NULL THEN state
ELSE vector_add(state, value)
END;
$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
-- Final function for vector average
CREATE OR REPLACE FUNCTION vector_avg_final(state real[], count bigint)
RETURNS real[]
AS $$
SELECT CASE
WHEN state IS NULL OR count = 0 THEN NULL
ELSE vector_mul_scalar(state, 1.0 / count::real)
END;
$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
-- Vector sum aggregate
CREATE AGGREGATE vector_sum(real[]) (
SFUNC = vector_sum_state,
STYPE = real[],
PARALLEL = SAFE
);
-- ============================================================================
-- Fast Pre-Normalized Cosine Distance (3x faster)
-- ============================================================================
-- Cosine distance for pre-normalized vectors (only dot product)
CREATE OR REPLACE FUNCTION cosine_distance_normalized_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'cosine_distance_normalized_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Temporal Compression Functions
-- ============================================================================
-- Compute delta between two consecutive vectors
CREATE OR REPLACE FUNCTION temporal_delta(current real[], previous real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'temporal_delta_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Reconstruct vector from delta and previous vector
CREATE OR REPLACE FUNCTION temporal_undelta(delta real[], previous real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'temporal_undelta_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Exponential moving average update
CREATE OR REPLACE FUNCTION temporal_ema_update(current real[], ema_prev real[], alpha real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'temporal_ema_update_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Compute temporal drift (rate of change)
CREATE OR REPLACE FUNCTION temporal_drift(v1 real[], v2 real[], time_delta real)
RETURNS real
AS 'MODULE_PATHNAME', 'temporal_drift_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Compute velocity (first derivative)
CREATE OR REPLACE FUNCTION temporal_velocity(v_t0 real[], v_t1 real[], dt real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'temporal_velocity_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Attention Mechanism Functions
-- ============================================================================
-- Compute scaled attention score between query and key
CREATE OR REPLACE FUNCTION attention_score(query real[], key real[])
RETURNS real
AS 'MODULE_PATHNAME', 'attention_score_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Apply softmax to scores array
CREATE OR REPLACE FUNCTION attention_softmax(scores real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'attention_softmax_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Weighted vector addition for attention
CREATE OR REPLACE FUNCTION attention_weighted_add(accumulator real[], value real[], weight real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'attention_weighted_add_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Initialize attention accumulator
CREATE OR REPLACE FUNCTION attention_init(dim int)
RETURNS real[]
AS 'MODULE_PATHNAME', 'attention_init_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Compute single attention (returns JSON with score and value)
CREATE OR REPLACE FUNCTION attention_single(query real[], key real[], value real[], score_offset real)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'attention_single_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Graph Traversal Functions
-- ============================================================================
-- Compute edge similarity between two vectors
CREATE OR REPLACE FUNCTION graph_edge_similarity(source real[], target real[])
RETURNS real
AS 'MODULE_PATHNAME', 'graph_edge_similarity_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- PageRank contribution calculation
CREATE OR REPLACE FUNCTION graph_pagerank_contribution(importance real, num_neighbors int, damping real)
RETURNS real
AS 'MODULE_PATHNAME', 'graph_pagerank_contribution_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- PageRank base importance
CREATE OR REPLACE FUNCTION graph_pagerank_base(num_nodes int, damping real)
RETURNS real
AS 'MODULE_PATHNAME', 'graph_pagerank_base_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Check semantic connection
CREATE OR REPLACE FUNCTION graph_is_connected(v1 real[], v2 real[], threshold real)
RETURNS boolean
AS 'MODULE_PATHNAME', 'graph_is_connected_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Centroid update for clustering
CREATE OR REPLACE FUNCTION graph_centroid_update(centroid real[], neighbor real[], weight real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'graph_centroid_update_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Bipartite matching score for RAG
CREATE OR REPLACE FUNCTION graph_bipartite_score(query real[], node real[], edge_weight real)
RETURNS real
AS 'MODULE_PATHNAME', 'graph_bipartite_score_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Hyperbolic Geometry Functions
-- ============================================================================
-- Poincare distance
CREATE OR REPLACE FUNCTION ruvector_poincare_distance(a real[], b real[], curvature real DEFAULT -1.0)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_poincare_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Lorentz/hyperboloid distance
CREATE OR REPLACE FUNCTION ruvector_lorentz_distance(a real[], b real[], curvature real DEFAULT -1.0)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_lorentz_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Mobius addition in Poincare ball
CREATE OR REPLACE FUNCTION ruvector_mobius_add(a real[], b real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_mobius_add_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Exponential map (tangent to manifold)
CREATE OR REPLACE FUNCTION ruvector_exp_map(base real[], tangent real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_exp_map_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Logarithmic map (manifold to tangent)
CREATE OR REPLACE FUNCTION ruvector_log_map(base real[], target real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_log_map_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Convert Poincare to Lorentz coordinates
CREATE OR REPLACE FUNCTION ruvector_poincare_to_lorentz(poincare real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_poincare_to_lorentz_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Convert Lorentz to Poincare coordinates
CREATE OR REPLACE FUNCTION ruvector_lorentz_to_poincare(lorentz real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_lorentz_to_poincare_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Minkowski inner product
CREATE OR REPLACE FUNCTION ruvector_minkowski_dot(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_minkowski_dot_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- GNN (Graph Neural Network) Functions
-- ============================================================================
-- Note: GCN and GraphSAGE functions are auto-generated by pgrx with JsonB signature
-- The functions ruvector_gcn_forward and ruvector_graphsage_forward use JsonB types
-- and are defined in src/gnn/operators.rs with #[pg_extern] macro
-- ============================================================================
-- Routing/Agent Functions (Tiny Dancer)
-- ============================================================================
-- Register an agent
CREATE OR REPLACE FUNCTION ruvector_register_agent(name text, agent_type text, capabilities text[], cost_per_request real, avg_latency_ms real, quality_score real)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_register_agent_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Register agent with full config
CREATE OR REPLACE FUNCTION ruvector_register_agent_full(config jsonb)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_register_agent_full_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Update agent metrics
CREATE OR REPLACE FUNCTION ruvector_update_agent_metrics(name text, latency_ms real, success boolean, quality real DEFAULT NULL)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_update_agent_metrics_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Remove agent
CREATE OR REPLACE FUNCTION ruvector_remove_agent(name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_remove_agent_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Set agent active status
CREATE OR REPLACE FUNCTION ruvector_set_agent_active(name text, is_active boolean)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_set_agent_active_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Route request to best agent
CREATE OR REPLACE FUNCTION ruvector_route(embedding real[], optimize_for text DEFAULT 'balanced', constraints jsonb DEFAULT NULL)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_route_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- List all agents
CREATE OR REPLACE FUNCTION ruvector_list_agents()
RETURNS SETOF jsonb
AS 'MODULE_PATHNAME', 'ruvector_list_agents_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get agent details
CREATE OR REPLACE FUNCTION ruvector_get_agent(name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_get_agent_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Find agents by capability
CREATE OR REPLACE FUNCTION ruvector_find_agents_by_capability(capability text, max_results int DEFAULT 10)
RETURNS SETOF jsonb
AS 'MODULE_PATHNAME', 'ruvector_find_agents_by_capability_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get routing statistics
CREATE OR REPLACE FUNCTION ruvector_routing_stats()
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_routing_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Clear all agents
CREATE OR REPLACE FUNCTION ruvector_clear_agents()
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_clear_agents_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- Learning/ReasoningBank Functions
-- ============================================================================
-- Enable learning for a table
CREATE OR REPLACE FUNCTION ruvector_enable_learning(table_name text, config jsonb DEFAULT NULL)
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_enable_learning_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Record feedback for learning
CREATE OR REPLACE FUNCTION ruvector_record_feedback(table_name text, query_vector real[], relevant_ids bigint[], irrelevant_ids bigint[])
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_record_feedback_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get learning statistics
CREATE OR REPLACE FUNCTION ruvector_learning_stats(table_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_learning_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Auto-tune search parameters
CREATE OR REPLACE FUNCTION ruvector_auto_tune(table_name text, optimize_for text DEFAULT 'balanced', sample_queries real[][] DEFAULT NULL)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_auto_tune_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Extract query patterns
CREATE OR REPLACE FUNCTION ruvector_extract_patterns(table_name text, num_clusters int DEFAULT 10)
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_extract_patterns_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get optimized search parameters for query
CREATE OR REPLACE FUNCTION ruvector_get_search_params(table_name text, query_vector real[])
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_get_search_params_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Clear learning data
CREATE OR REPLACE FUNCTION ruvector_clear_learning(table_name text)
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_clear_learning_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- Graph/Cypher Functions
-- ============================================================================
-- Create a new graph
CREATE OR REPLACE FUNCTION ruvector_create_graph(name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_create_graph_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Execute Cypher query
CREATE OR REPLACE FUNCTION ruvector_cypher(graph_name text, query text, params jsonb DEFAULT NULL)
RETURNS SETOF jsonb
AS 'MODULE_PATHNAME', 'ruvector_cypher_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Add node to graph
CREATE OR REPLACE FUNCTION ruvector_add_node(graph_name text, labels text[], properties jsonb)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_add_node_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Add edge to graph
CREATE OR REPLACE FUNCTION ruvector_add_edge(graph_name text, source_id bigint, target_id bigint, edge_type text, properties jsonb)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_add_edge_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Find shortest path
CREATE OR REPLACE FUNCTION ruvector_shortest_path(graph_name text, start_id bigint, end_id bigint, max_hops int DEFAULT 10)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_shortest_path_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get graph statistics
CREATE OR REPLACE FUNCTION ruvector_graph_stats(graph_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_graph_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- List all graphs
CREATE OR REPLACE FUNCTION ruvector_list_graphs()
RETURNS text[]
AS 'MODULE_PATHNAME', 'ruvector_list_graphs_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Delete a graph
CREATE OR REPLACE FUNCTION ruvector_delete_graph(graph_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_delete_graph_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- SPARQL / RDF Triple Store Operations (W3C SPARQL 1.1)
-- ============================================================================
-- Create a new RDF triple store
CREATE OR REPLACE FUNCTION ruvector_create_rdf_store(name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_create_rdf_store_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Execute SPARQL query with format selection
CREATE OR REPLACE FUNCTION ruvector_sparql(store_name text, query text, format text)
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_sparql_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Execute SPARQL query and return JSONB
CREATE OR REPLACE FUNCTION ruvector_sparql_json(store_name text, query text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_sparql_json_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Insert RDF triple
CREATE OR REPLACE FUNCTION ruvector_insert_triple(store_name text, subject text, predicate text, object text)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_insert_triple_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Insert RDF triple into named graph
CREATE OR REPLACE FUNCTION ruvector_insert_triple_graph(store_name text, subject text, predicate text, object text, graph text)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_insert_triple_graph_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Bulk load N-Triples format
CREATE OR REPLACE FUNCTION ruvector_load_ntriples(store_name text, ntriples text)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_load_ntriples_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get RDF store statistics
CREATE OR REPLACE FUNCTION ruvector_rdf_stats(store_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_rdf_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Query triples by pattern (NULL for wildcards)
CREATE OR REPLACE FUNCTION ruvector_query_triples(store_name text, subject text DEFAULT NULL, predicate text DEFAULT NULL, object text DEFAULT NULL)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_query_triples_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Clear all triples from store
CREATE OR REPLACE FUNCTION ruvector_clear_rdf_store(store_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_clear_rdf_store_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Delete RDF triple store
CREATE OR REPLACE FUNCTION ruvector_delete_rdf_store(store_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_delete_rdf_store_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- List all RDF stores
CREATE OR REPLACE FUNCTION ruvector_list_rdf_stores()
RETURNS text[]
AS 'MODULE_PATHNAME', 'ruvector_list_rdf_stores_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Execute SPARQL UPDATE operations
CREATE OR REPLACE FUNCTION ruvector_sparql_update(store_name text, query text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_sparql_update_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- Comments
-- ============================================================================
COMMENT ON FUNCTION ruvector_version() IS 'Returns RuVector extension version';
COMMENT ON FUNCTION ruvector_simd_info() IS 'Returns SIMD capability information';
COMMENT ON FUNCTION ruvector_memory_stats() IS 'Returns memory statistics for the extension';
COMMENT ON FUNCTION l2_distance_arr(real[], real[]) IS 'Compute L2 (Euclidean) distance between two vectors';
COMMENT ON FUNCTION cosine_distance_arr(real[], real[]) IS 'Compute cosine distance between two vectors';
COMMENT ON FUNCTION cosine_distance_normalized_arr(real[], real[]) IS 'Fast cosine distance for pre-normalized vectors (3x faster)';
COMMENT ON FUNCTION inner_product_arr(real[], real[]) IS 'Compute inner product between two vectors';
COMMENT ON FUNCTION l1_distance_arr(real[], real[]) IS 'Compute L1 (Manhattan) distance between two vectors';
COMMENT ON FUNCTION vector_normalize(real[]) IS 'Normalize a vector to unit length';
COMMENT ON FUNCTION vector_add(real[], real[]) IS 'Add two vectors element-wise';
COMMENT ON FUNCTION vector_sub(real[], real[]) IS 'Subtract two vectors element-wise';
COMMENT ON FUNCTION vector_mul_scalar(real[], real) IS 'Multiply vector by scalar';
COMMENT ON FUNCTION vector_dims(real[]) IS 'Get vector dimensions';
COMMENT ON FUNCTION vector_norm(real[]) IS 'Get vector L2 norm';
COMMENT ON FUNCTION binary_quantize_arr(real[]) IS 'Binary quantize a vector (32x compression)';
COMMENT ON FUNCTION scalar_quantize_arr(real[]) IS 'Scalar quantize a vector (4x compression)';
COMMENT ON FUNCTION temporal_delta(real[], real[]) IS 'Compute delta between consecutive vectors for compression';
COMMENT ON FUNCTION temporal_undelta(real[], real[]) IS 'Reconstruct vector from delta encoding';
COMMENT ON FUNCTION temporal_ema_update(real[], real[], real) IS 'Exponential moving average update step';
COMMENT ON FUNCTION temporal_drift(real[], real[], real) IS 'Compute temporal drift (rate of change) between vectors';
COMMENT ON FUNCTION temporal_velocity(real[], real[], real) IS 'Compute velocity (first derivative) of vector';
COMMENT ON FUNCTION attention_score(real[], real[]) IS 'Compute scaled attention score between query and key';
COMMENT ON FUNCTION attention_softmax(real[]) IS 'Apply softmax to scores array';
COMMENT ON FUNCTION attention_weighted_add(real[], real[], real) IS 'Weighted vector addition for attention';
COMMENT ON FUNCTION attention_init(int) IS 'Initialize zero-vector accumulator for attention';
COMMENT ON FUNCTION attention_single(real[], real[], real[], real) IS 'Single key-value attention with score';
COMMENT ON FUNCTION graph_edge_similarity(real[], real[]) IS 'Compute edge similarity (cosine) between vectors';
COMMENT ON FUNCTION graph_pagerank_contribution(real, int, real) IS 'Calculate PageRank contribution to neighbors';
COMMENT ON FUNCTION graph_pagerank_base(int, real) IS 'Initialize PageRank base importance';
COMMENT ON FUNCTION graph_is_connected(real[], real[], real) IS 'Check if vectors are semantically connected';
COMMENT ON FUNCTION graph_centroid_update(real[], real[], real) IS 'Update centroid with neighbor contribution';
-- SPARQL / RDF Comments
COMMENT ON FUNCTION ruvector_create_rdf_store(text) IS 'Create a new RDF triple store for SPARQL queries';
COMMENT ON FUNCTION ruvector_sparql(text, text, text) IS 'Execute W3C SPARQL 1.1 query (SELECT, ASK, CONSTRUCT, DESCRIBE) with format selection (json, xml, csv, tsv)';
COMMENT ON FUNCTION ruvector_sparql_json(text, text) IS 'Execute SPARQL query and return results as JSONB';
COMMENT ON FUNCTION ruvector_insert_triple(text, text, text, text) IS 'Insert RDF triple (subject, predicate, object) into store';
COMMENT ON FUNCTION ruvector_insert_triple_graph(text, text, text, text, text) IS 'Insert RDF triple into named graph';
COMMENT ON FUNCTION ruvector_load_ntriples(text, text) IS 'Bulk load RDF triples from N-Triples format';
COMMENT ON FUNCTION ruvector_rdf_stats(text) IS 'Get statistics for RDF triple store (counts, graphs)';
COMMENT ON FUNCTION ruvector_query_triples(text, text, text, text) IS 'Query triples by pattern (use NULL for wildcards)';
COMMENT ON FUNCTION ruvector_clear_rdf_store(text) IS 'Clear all triples from RDF store';
COMMENT ON FUNCTION ruvector_delete_rdf_store(text) IS 'Delete RDF triple store completely';
COMMENT ON FUNCTION ruvector_list_rdf_stores() IS 'List all RDF triple stores';
COMMENT ON FUNCTION ruvector_sparql_update(text, text) IS 'Execute SPARQL UPDATE operations (INSERT DATA, DELETE DATA, DELETE/INSERT WHERE)';
COMMENT ON FUNCTION graph_bipartite_score(real[], real[], real) IS 'Compute bipartite matching score for RAG';
-- ============================================================================
-- ============================================================================
-- Embedding Generation Functions
-- ============================================================================
-- Note: Embedding functions require the 'embeddings' feature flag to be enabled
-- during compilation. These functions are not available in the default build.
-- To enable, build with: cargo pgrx package --features embeddings
-- ============================================================================
-- HNSW Access Method
-- ============================================================================
-- HNSW Access Method Handler
CREATE OR REPLACE FUNCTION hnsw_handler(internal)
RETURNS index_am_handler
AS 'MODULE_PATHNAME', 'hnsw_handler_wrapper'
LANGUAGE C STRICT;
-- Create HNSW Access Method
CREATE ACCESS METHOD hnsw TYPE INDEX HANDLER hnsw_handler;
-- ============================================================================
-- Operator Classes for HNSW
-- ============================================================================
-- HNSW Operator Class for L2 (Euclidean) distance
CREATE OPERATOR CLASS ruvector_l2_ops
DEFAULT FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <-> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_l2_distance(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_l2_ops USING hnsw IS
'ruvector HNSW operator class for L2/Euclidean distance';
-- HNSW Operator Class for Cosine distance
CREATE OPERATOR CLASS ruvector_cosine_ops
FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <=> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_cosine_distance(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_cosine_ops USING hnsw IS
'ruvector HNSW operator class for cosine distance';
-- HNSW Operator Class for Inner Product
CREATE OPERATOR CLASS ruvector_ip_ops
FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <#> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_inner_product(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_ip_ops USING hnsw IS
'ruvector HNSW operator class for inner product (max similarity)';

1094
vendor/ruvector/crates/ruvector-postgres/sql/ruvector--0.3.0.sql vendored Normal file
View File

File diff suppressed because it is too large Load Diff

239
vendor/ruvector/crates/ruvector-postgres/sql/ruvector--2.0.0--0.3.0.sql vendored Normal file
View File

@@ -0,0 +1,239 @@
-- RuVector PostgreSQL Extension v0.3 Upgrade Script
-- Upgrades from 2.0.0 to 0.3.0
-- Adds: Solver, Math/Spectral, TDA, Extended Attention, Sona, Domain Expansion
\echo Use "ALTER EXTENSION ruvector UPDATE TO '0.3.0'" to load this file. \quit
-- ============================================================================
-- Solver Functions (feature: solver)
-- ============================================================================
CREATE OR REPLACE FUNCTION ruvector_pagerank(edges_json jsonb, alpha real DEFAULT 0.85, epsilon real DEFAULT 1e-6)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_pagerank_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_pagerank_personalized(edges_json jsonb, source int, alpha real DEFAULT 0.85, epsilon real DEFAULT 1e-6)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_pagerank_personalized_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_pagerank_multi_seed(edges_json jsonb, seeds_json jsonb, alpha real DEFAULT 0.85, epsilon real DEFAULT 1e-6)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_pagerank_multi_seed_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_solve_sparse(matrix_json jsonb, rhs real[], method text DEFAULT 'neumann')
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_solve_sparse_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_solve_laplacian(laplacian_json jsonb, rhs real[])
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_solve_laplacian_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_effective_resistance(laplacian_json jsonb, source int, target int)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_effective_resistance_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_graph_pagerank(graph_name text, alpha real DEFAULT 0.85, epsilon real DEFAULT 1e-6)
RETURNS TABLE(node_id bigint, rank double precision)
AS 'MODULE_PATHNAME', 'ruvector_graph_pagerank_wrapper'
LANGUAGE C;
CREATE OR REPLACE FUNCTION ruvector_solver_info()
RETURNS TABLE(algorithm text, description text, complexity text)
AS 'MODULE_PATHNAME', 'ruvector_solver_info_wrapper'
LANGUAGE C;
CREATE OR REPLACE FUNCTION ruvector_matrix_analyze(matrix_json jsonb)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_matrix_analyze_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_conjugate_gradient(matrix_json jsonb, rhs real[], tol real DEFAULT 1e-6, max_iter int DEFAULT 1000)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_conjugate_gradient_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_graph_centrality(graph_name text, method text DEFAULT 'pagerank')
RETURNS TABLE(node_id bigint, centrality double precision)
AS 'MODULE_PATHNAME', 'ruvector_graph_centrality_wrapper'
LANGUAGE C;
-- ============================================================================
-- Math Distance & Spectral Functions (feature: math-distances)
-- ============================================================================
CREATE OR REPLACE FUNCTION ruvector_wasserstein_distance(a real[], b real[], p int DEFAULT 1)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_wasserstein_distance_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_sinkhorn_distance(cost_json jsonb, w_a real[], w_b real[], reg real DEFAULT 0.1)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_sinkhorn_distance_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_sliced_wasserstein(pts_a_json jsonb, pts_b_json jsonb, n_proj int DEFAULT 100)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_sliced_wasserstein_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_kl_divergence(p real[], q real[])
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_kl_divergence_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_jensen_shannon(p real[], q real[])
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_jensen_shannon_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_fisher_information(dist real[], tangent real[])
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_fisher_information_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_spectral_cluster(adj_json jsonb, k int)
RETURNS int[]
AS 'MODULE_PATHNAME', 'ruvector_spectral_cluster_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_chebyshev_filter(adj_json jsonb, signal real[], filter_type text DEFAULT 'low_pass', degree int DEFAULT 10)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_chebyshev_filter_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_graph_diffusion(adj_json jsonb, signal real[], diffusion_time real DEFAULT 1.0, degree int DEFAULT 10)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_graph_diffusion_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_product_manifold_distance(a real[], b real[], e_dim int, h_dim int, s_dim int)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_product_manifold_distance_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_spherical_distance(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_spherical_distance_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_gromov_wasserstein(dist_a_json jsonb, dist_b_json jsonb)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_gromov_wasserstein_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
-- ============================================================================
-- TDA Functions (feature: tda)
-- ============================================================================
CREATE OR REPLACE FUNCTION ruvector_persistent_homology(points_json jsonb, max_dim int DEFAULT 1, max_radius real DEFAULT 3.0)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_persistent_homology_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_betti_numbers(points_json jsonb, radius real, max_dim int DEFAULT 2)
RETURNS int[]
AS 'MODULE_PATHNAME', 'ruvector_betti_numbers_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_bottleneck_distance(diag_a_json jsonb, diag_b_json jsonb)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_bottleneck_distance_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_persistence_wasserstein(diag_a_json jsonb, diag_b_json jsonb, p int DEFAULT 2)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_persistence_wasserstein_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_topological_summary(points_json jsonb, max_dim int DEFAULT 1)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_topological_summary_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_embedding_drift(old_json jsonb, new_json jsonb)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_embedding_drift_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_vietoris_rips(points_json jsonb, max_radius real DEFAULT 2.0, max_dim int DEFAULT 2)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_vietoris_rips_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
-- ============================================================================
-- Extended Attention Functions (feature: attention-extended)
-- ============================================================================
CREATE OR REPLACE FUNCTION ruvector_linear_attention(q real[], keys_json jsonb, values_json jsonb)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_linear_attention_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_sliding_window_attention(q real[], keys_json jsonb, values_json jsonb, window_size int DEFAULT 256)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_sliding_window_attention_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_cross_attention(q real[], ctx_keys_json jsonb, ctx_values_json jsonb)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_cross_attention_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_sparse_attention(q real[], keys_json jsonb, values_json jsonb, top_k int DEFAULT 8)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_sparse_attention_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_moe_attention(q real[], keys_json jsonb, values_json jsonb, n_experts int DEFAULT 4, top_k int DEFAULT 2)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_moe_attention_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_hyperbolic_attention(q real[], keys_json jsonb, values_json jsonb, curvature real DEFAULT 1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_hyperbolic_attention_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_attention_benchmark(dim int DEFAULT 64, seq_len int DEFAULT 128, attention_type text DEFAULT 'scaled_dot')
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_attention_benchmark_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
-- ============================================================================
-- Sona Learning Functions (feature: sona-learning)
-- ============================================================================
CREATE OR REPLACE FUNCTION ruvector_sona_learn(table_name text, trajectory_json jsonb)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_sona_learn_wrapper'
LANGUAGE C;
CREATE OR REPLACE FUNCTION ruvector_sona_apply(table_name text, embedding real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_sona_apply_wrapper'
LANGUAGE C IMMUTABLE PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_sona_ewc_status(table_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_sona_ewc_status_wrapper'
LANGUAGE C;
CREATE OR REPLACE FUNCTION ruvector_sona_stats(table_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_sona_stats_wrapper'
LANGUAGE C;
-- ============================================================================
-- Domain Expansion Functions (feature: domain-expansion)
-- ============================================================================
CREATE OR REPLACE FUNCTION ruvector_domain_transfer(embeddings_json jsonb, target_domain text, config_json jsonb DEFAULT '{}'::jsonb)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_domain_transfer_wrapper'
LANGUAGE C;

861
vendor/ruvector/crates/ruvector-postgres/sql/ruvector--2.0.0.sql vendored Normal file
View File

@@ -0,0 +1,861 @@
-- RuVector PostgreSQL Extension v2
-- Version: 2.0.0
-- High-performance vector similarity search with SIMD optimizations
-- Features: 230+ SQL functions, Flash Attention, GNN, hybrid search, multi-tenancy, self-healing
-- Complain if script is sourced in psql, rather than via CREATE EXTENSION
\echo Use "CREATE EXTENSION ruvector" to load this file. \quit
-- ============================================================================
-- Utility Functions
-- ============================================================================
-- Get extension version
CREATE OR REPLACE FUNCTION ruvector_version()
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_version_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get SIMD info
CREATE OR REPLACE FUNCTION ruvector_simd_info()
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_simd_info_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get memory stats
CREATE OR REPLACE FUNCTION ruvector_memory_stats()
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_memory_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- Native RuVector Type (pgvector-compatible)
-- ============================================================================
-- Create the ruvector type using low-level I/O functions
CREATE TYPE ruvector;
CREATE OR REPLACE FUNCTION ruvector_in(cstring) RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_in' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_out(ruvector) RETURNS cstring
AS 'MODULE_PATHNAME', 'ruvector_out' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_recv(internal) RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_recv' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_send(ruvector) RETURNS bytea
AS 'MODULE_PATHNAME', 'ruvector_send' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_typmod_in(cstring[]) RETURNS int
AS 'MODULE_PATHNAME', 'ruvector_typmod_in' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE OR REPLACE FUNCTION ruvector_typmod_out(int) RETURNS cstring
AS 'MODULE_PATHNAME', 'ruvector_typmod_out' LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
CREATE TYPE ruvector (
INPUT = ruvector_in,
OUTPUT = ruvector_out,
RECEIVE = ruvector_recv,
SEND = ruvector_send,
TYPMOD_IN = ruvector_typmod_in,
TYPMOD_OUT = ruvector_typmod_out,
STORAGE = extended,
INTERNALLENGTH = VARIABLE,
ALIGNMENT = double
);
-- ============================================================================
-- Native RuVector Distance Functions (SIMD-optimized)
-- ============================================================================
-- L2 distance for native ruvector type
CREATE OR REPLACE FUNCTION ruvector_l2_distance(a ruvector, b ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_l2_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Cosine distance for native ruvector type
CREATE OR REPLACE FUNCTION ruvector_cosine_distance(a ruvector, b ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_cosine_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Inner product for native ruvector type
CREATE OR REPLACE FUNCTION ruvector_inner_product(a ruvector, b ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_inner_product_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Manhattan (L1) distance for native ruvector type
CREATE OR REPLACE FUNCTION ruvector_l1_distance(a ruvector, b ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_l1_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get dimensions of ruvector
CREATE OR REPLACE FUNCTION ruvector_dims(v ruvector)
RETURNS int
AS 'MODULE_PATHNAME', 'ruvector_dims_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get L2 norm of ruvector
CREATE OR REPLACE FUNCTION ruvector_norm(v ruvector)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_norm_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Normalize ruvector
CREATE OR REPLACE FUNCTION ruvector_normalize(v ruvector)
RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_normalize_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Add two ruvectors
CREATE OR REPLACE FUNCTION ruvector_add(a ruvector, b ruvector)
RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_add_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Subtract two ruvectors
CREATE OR REPLACE FUNCTION ruvector_sub(a ruvector, b ruvector)
RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_sub_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Multiply ruvector by scalar
CREATE OR REPLACE FUNCTION ruvector_mul_scalar(v ruvector, s real)
RETURNS ruvector
AS 'MODULE_PATHNAME', 'ruvector_mul_scalar_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Operators for Native RuVector Type
-- ============================================================================
-- L2 distance operator (<->)
CREATE OPERATOR <-> (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_l2_distance,
COMMUTATOR = '<->'
);
-- Cosine distance operator (<=>)
CREATE OPERATOR <=> (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_cosine_distance,
COMMUTATOR = '<=>'
);
-- Inner product operator (<#>)
CREATE OPERATOR <#> (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_inner_product,
COMMUTATOR = '<#>'
);
-- Addition operator (+)
CREATE OPERATOR + (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_add,
COMMUTATOR = '+'
);
-- Subtraction operator (-)
CREATE OPERATOR - (
LEFTARG = ruvector,
RIGHTARG = ruvector,
FUNCTION = ruvector_sub
);
-- ============================================================================
-- Distance Functions (array-based with SIMD optimization)
-- ============================================================================
-- L2 (Euclidean) distance between two float arrays
CREATE OR REPLACE FUNCTION l2_distance_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'l2_distance_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Inner product between two float arrays
CREATE OR REPLACE FUNCTION inner_product_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'inner_product_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Negative inner product (for ORDER BY ASC nearest neighbor)
CREATE OR REPLACE FUNCTION neg_inner_product_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'neg_inner_product_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Cosine distance between two float arrays
CREATE OR REPLACE FUNCTION cosine_distance_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'cosine_distance_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Cosine similarity between two float arrays
CREATE OR REPLACE FUNCTION cosine_similarity_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'cosine_similarity_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- L1 (Manhattan) distance between two float arrays
CREATE OR REPLACE FUNCTION l1_distance_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'l1_distance_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Vector Utility Functions
-- ============================================================================
-- Normalize a vector to unit length
CREATE OR REPLACE FUNCTION vector_normalize(v real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_normalize_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Add two vectors element-wise
CREATE OR REPLACE FUNCTION vector_add(a real[], b real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_add_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Subtract two vectors element-wise
CREATE OR REPLACE FUNCTION vector_sub(a real[], b real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_sub_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Multiply vector by scalar
CREATE OR REPLACE FUNCTION vector_mul_scalar(v real[], scalar real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_mul_scalar_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get vector dimensions
CREATE OR REPLACE FUNCTION vector_dims(v real[])
RETURNS int
AS 'MODULE_PATHNAME', 'vector_dims_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Get vector L2 norm
CREATE OR REPLACE FUNCTION vector_norm(v real[])
RETURNS real
AS 'MODULE_PATHNAME', 'vector_norm_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Average two vectors
CREATE OR REPLACE FUNCTION vector_avg2(a real[], b real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'vector_avg2_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Quantization Functions
-- ============================================================================
-- Binary quantize a vector
CREATE OR REPLACE FUNCTION binary_quantize_arr(v real[])
RETURNS bytea
AS 'MODULE_PATHNAME', 'binary_quantize_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Scalar quantize a vector (SQ8)
CREATE OR REPLACE FUNCTION scalar_quantize_arr(v real[])
RETURNS jsonb
AS 'MODULE_PATHNAME', 'scalar_quantize_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Aggregate Functions
-- ============================================================================
-- State transition function for vector sum
CREATE OR REPLACE FUNCTION vector_sum_state(state real[], value real[])
RETURNS real[]
AS $$
SELECT CASE
WHEN state IS NULL THEN value
WHEN value IS NULL THEN state
ELSE vector_add(state, value)
END;
$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
-- Final function for vector average
CREATE OR REPLACE FUNCTION vector_avg_final(state real[], count bigint)
RETURNS real[]
AS $$
SELECT CASE
WHEN state IS NULL OR count = 0 THEN NULL
ELSE vector_mul_scalar(state, 1.0 / count::real)
END;
$$ LANGUAGE SQL IMMUTABLE PARALLEL SAFE;
-- Vector sum aggregate
CREATE AGGREGATE vector_sum(real[]) (
SFUNC = vector_sum_state,
STYPE = real[],
PARALLEL = SAFE
);
-- ============================================================================
-- Fast Pre-Normalized Cosine Distance (3x faster)
-- ============================================================================
-- Cosine distance for pre-normalized vectors (only dot product)
CREATE OR REPLACE FUNCTION cosine_distance_normalized_arr(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'cosine_distance_normalized_arr_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Temporal Compression Functions
-- ============================================================================
-- Compute delta between two consecutive vectors
CREATE OR REPLACE FUNCTION temporal_delta(current real[], previous real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'temporal_delta_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Reconstruct vector from delta and previous vector
CREATE OR REPLACE FUNCTION temporal_undelta(delta real[], previous real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'temporal_undelta_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Exponential moving average update
CREATE OR REPLACE FUNCTION temporal_ema_update(current real[], ema_prev real[], alpha real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'temporal_ema_update_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Compute temporal drift (rate of change)
CREATE OR REPLACE FUNCTION temporal_drift(v1 real[], v2 real[], time_delta real)
RETURNS real
AS 'MODULE_PATHNAME', 'temporal_drift_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Compute velocity (first derivative)
CREATE OR REPLACE FUNCTION temporal_velocity(v_t0 real[], v_t1 real[], dt real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'temporal_velocity_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Attention Mechanism Functions
-- ============================================================================
-- Compute scaled attention score between query and key
CREATE OR REPLACE FUNCTION attention_score(query real[], key real[])
RETURNS real
AS 'MODULE_PATHNAME', 'attention_score_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Apply softmax to scores array
CREATE OR REPLACE FUNCTION attention_softmax(scores real[])
RETURNS real[]
AS 'MODULE_PATHNAME', 'attention_softmax_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Weighted vector addition for attention
CREATE OR REPLACE FUNCTION attention_weighted_add(accumulator real[], value real[], weight real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'attention_weighted_add_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Initialize attention accumulator
CREATE OR REPLACE FUNCTION attention_init(dim int)
RETURNS real[]
AS 'MODULE_PATHNAME', 'attention_init_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Compute single attention (returns JSON with score and value)
CREATE OR REPLACE FUNCTION attention_single(query real[], key real[], value real[], score_offset real)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'attention_single_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Graph Traversal Functions
-- ============================================================================
-- Compute edge similarity between two vectors
CREATE OR REPLACE FUNCTION graph_edge_similarity(source real[], target real[])
RETURNS real
AS 'MODULE_PATHNAME', 'graph_edge_similarity_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- PageRank contribution calculation
CREATE OR REPLACE FUNCTION graph_pagerank_contribution(importance real, num_neighbors int, damping real)
RETURNS real
AS 'MODULE_PATHNAME', 'graph_pagerank_contribution_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- PageRank base importance
CREATE OR REPLACE FUNCTION graph_pagerank_base(num_nodes int, damping real)
RETURNS real
AS 'MODULE_PATHNAME', 'graph_pagerank_base_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Check semantic connection
CREATE OR REPLACE FUNCTION graph_is_connected(v1 real[], v2 real[], threshold real)
RETURNS boolean
AS 'MODULE_PATHNAME', 'graph_is_connected_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Centroid update for clustering
CREATE OR REPLACE FUNCTION graph_centroid_update(centroid real[], neighbor real[], weight real)
RETURNS real[]
AS 'MODULE_PATHNAME', 'graph_centroid_update_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Bipartite matching score for RAG
CREATE OR REPLACE FUNCTION graph_bipartite_score(query real[], node real[], edge_weight real)
RETURNS real
AS 'MODULE_PATHNAME', 'graph_bipartite_score_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- Hyperbolic Geometry Functions
-- ============================================================================
-- Poincare distance
CREATE OR REPLACE FUNCTION ruvector_poincare_distance(a real[], b real[], curvature real DEFAULT -1.0)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_poincare_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Lorentz/hyperboloid distance
CREATE OR REPLACE FUNCTION ruvector_lorentz_distance(a real[], b real[], curvature real DEFAULT -1.0)
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_lorentz_distance_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Mobius addition in Poincare ball
CREATE OR REPLACE FUNCTION ruvector_mobius_add(a real[], b real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_mobius_add_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Exponential map (tangent to manifold)
CREATE OR REPLACE FUNCTION ruvector_exp_map(base real[], tangent real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_exp_map_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Logarithmic map (manifold to tangent)
CREATE OR REPLACE FUNCTION ruvector_log_map(base real[], target real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_log_map_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Convert Poincare to Lorentz coordinates
CREATE OR REPLACE FUNCTION ruvector_poincare_to_lorentz(poincare real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_poincare_to_lorentz_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Convert Lorentz to Poincare coordinates
CREATE OR REPLACE FUNCTION ruvector_lorentz_to_poincare(lorentz real[], curvature real DEFAULT -1.0)
RETURNS real[]
AS 'MODULE_PATHNAME', 'ruvector_lorentz_to_poincare_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- Minkowski inner product
CREATE OR REPLACE FUNCTION ruvector_minkowski_dot(a real[], b real[])
RETURNS real
AS 'MODULE_PATHNAME', 'ruvector_minkowski_dot_wrapper'
LANGUAGE C IMMUTABLE STRICT PARALLEL SAFE;
-- ============================================================================
-- GNN (Graph Neural Network) Functions
-- ============================================================================
-- Note: GCN and GraphSAGE functions are auto-generated by pgrx with JsonB signature
-- The functions ruvector_gcn_forward and ruvector_graphsage_forward use JsonB types
-- and are defined in src/gnn/operators.rs with #[pg_extern] macro
-- ============================================================================
-- Routing/Agent Functions (Tiny Dancer)
-- ============================================================================
-- Register an agent
CREATE OR REPLACE FUNCTION ruvector_register_agent(name text, agent_type text, capabilities text[], cost_per_request real, avg_latency_ms real, quality_score real)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_register_agent_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Register agent with full config
CREATE OR REPLACE FUNCTION ruvector_register_agent_full(config jsonb)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_register_agent_full_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Update agent metrics
CREATE OR REPLACE FUNCTION ruvector_update_agent_metrics(name text, latency_ms real, success boolean, quality real DEFAULT NULL)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_update_agent_metrics_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Remove agent
CREATE OR REPLACE FUNCTION ruvector_remove_agent(name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_remove_agent_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Set agent active status
CREATE OR REPLACE FUNCTION ruvector_set_agent_active(name text, is_active boolean)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_set_agent_active_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Route request to best agent
CREATE OR REPLACE FUNCTION ruvector_route(embedding real[], optimize_for text DEFAULT 'balanced', constraints jsonb DEFAULT NULL)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_route_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- List all agents
CREATE OR REPLACE FUNCTION ruvector_list_agents()
RETURNS TABLE(name text, agent_type text, capabilities text[], cost_per_request real, avg_latency_ms real, quality_score real, success_rate real, total_requests bigint, is_active boolean)
AS 'MODULE_PATHNAME', 'ruvector_list_agents_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get agent details
CREATE OR REPLACE FUNCTION ruvector_get_agent(name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_get_agent_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Find agents by capability
CREATE OR REPLACE FUNCTION ruvector_find_agents_by_capability(capability text, max_results int DEFAULT 10)
RETURNS TABLE(name text, quality_score real, avg_latency_ms real, cost_per_request real)
AS 'MODULE_PATHNAME', 'ruvector_find_agents_by_capability_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get routing statistics
CREATE OR REPLACE FUNCTION ruvector_routing_stats()
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_routing_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Clear all agents
CREATE OR REPLACE FUNCTION ruvector_clear_agents()
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_clear_agents_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- Learning/ReasoningBank Functions
-- ============================================================================
-- Enable learning for a table
CREATE OR REPLACE FUNCTION ruvector_enable_learning(table_name text, config jsonb DEFAULT NULL)
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_enable_learning_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Record feedback for learning
CREATE OR REPLACE FUNCTION ruvector_record_feedback(table_name text, query_vector real[], relevant_ids bigint[], irrelevant_ids bigint[])
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_record_feedback_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get learning statistics
CREATE OR REPLACE FUNCTION ruvector_learning_stats(table_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_learning_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Auto-tune search parameters
CREATE OR REPLACE FUNCTION ruvector_auto_tune(table_name text, optimize_for text DEFAULT 'balanced', sample_queries real[][] DEFAULT NULL)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_auto_tune_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Extract query patterns
CREATE OR REPLACE FUNCTION ruvector_extract_patterns(table_name text, num_clusters int DEFAULT 10)
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_extract_patterns_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get optimized search parameters for query
CREATE OR REPLACE FUNCTION ruvector_get_search_params(table_name text, query_vector real[])
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_get_search_params_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Clear learning data
CREATE OR REPLACE FUNCTION ruvector_clear_learning(table_name text)
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_clear_learning_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- Graph/Cypher Functions
-- ============================================================================
-- Create a new graph
CREATE OR REPLACE FUNCTION ruvector_create_graph(name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_create_graph_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Execute Cypher query
CREATE OR REPLACE FUNCTION ruvector_cypher(graph_name text, query text, params jsonb DEFAULT NULL)
RETURNS SETOF jsonb
AS 'MODULE_PATHNAME', 'ruvector_cypher_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Add node to graph
CREATE OR REPLACE FUNCTION ruvector_add_node(graph_name text, labels text[], properties jsonb)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_add_node_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Add edge to graph
CREATE OR REPLACE FUNCTION ruvector_add_edge(graph_name text, source_id bigint, target_id bigint, edge_type text, properties jsonb)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_add_edge_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Find shortest path
CREATE OR REPLACE FUNCTION ruvector_shortest_path(graph_name text, start_id bigint, end_id bigint, max_hops int DEFAULT 10)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_shortest_path_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get graph statistics
CREATE OR REPLACE FUNCTION ruvector_graph_stats(graph_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_graph_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- List all graphs
CREATE OR REPLACE FUNCTION ruvector_list_graphs()
RETURNS text[]
AS 'MODULE_PATHNAME', 'ruvector_list_graphs_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Delete a graph
CREATE OR REPLACE FUNCTION ruvector_delete_graph(graph_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_delete_graph_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- SPARQL / RDF Triple Store Operations (W3C SPARQL 1.1)
-- ============================================================================
-- Create a new RDF triple store
CREATE OR REPLACE FUNCTION ruvector_create_rdf_store(name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_create_rdf_store_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Execute SPARQL query with format selection
CREATE OR REPLACE FUNCTION ruvector_sparql(store_name text, query text, format text)
RETURNS text
AS 'MODULE_PATHNAME', 'ruvector_sparql_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Execute SPARQL query and return JSONB
CREATE OR REPLACE FUNCTION ruvector_sparql_json(store_name text, query text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_sparql_json_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Insert RDF triple
CREATE OR REPLACE FUNCTION ruvector_insert_triple(store_name text, subject text, predicate text, object text)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_insert_triple_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Insert RDF triple into named graph
CREATE OR REPLACE FUNCTION ruvector_insert_triple_graph(store_name text, subject text, predicate text, object text, graph text)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_insert_triple_graph_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Bulk load N-Triples format
CREATE OR REPLACE FUNCTION ruvector_load_ntriples(store_name text, ntriples text)
RETURNS bigint
AS 'MODULE_PATHNAME', 'ruvector_load_ntriples_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Get RDF store statistics
CREATE OR REPLACE FUNCTION ruvector_rdf_stats(store_name text)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_rdf_stats_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Query triples by pattern (NULL for wildcards)
CREATE OR REPLACE FUNCTION ruvector_query_triples(store_name text, subject text DEFAULT NULL, predicate text DEFAULT NULL, object text DEFAULT NULL)
RETURNS jsonb
AS 'MODULE_PATHNAME', 'ruvector_query_triples_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Clear all triples from store
CREATE OR REPLACE FUNCTION ruvector_clear_rdf_store(store_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_clear_rdf_store_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Delete RDF triple store
CREATE OR REPLACE FUNCTION ruvector_delete_rdf_store(store_name text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_delete_rdf_store_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- List all RDF stores
CREATE OR REPLACE FUNCTION ruvector_list_rdf_stores()
RETURNS text[]
AS 'MODULE_PATHNAME', 'ruvector_list_rdf_stores_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- Execute SPARQL UPDATE operations
CREATE OR REPLACE FUNCTION ruvector_sparql_update(store_name text, query text)
RETURNS boolean
AS 'MODULE_PATHNAME', 'ruvector_sparql_update_wrapper'
LANGUAGE C VOLATILE PARALLEL SAFE;
-- ============================================================================
-- Comments
-- ============================================================================
COMMENT ON FUNCTION ruvector_version() IS 'Returns RuVector extension version';
COMMENT ON FUNCTION ruvector_simd_info() IS 'Returns SIMD capability information';
COMMENT ON FUNCTION ruvector_memory_stats() IS 'Returns memory statistics for the extension';
COMMENT ON FUNCTION l2_distance_arr(real[], real[]) IS 'Compute L2 (Euclidean) distance between two vectors';
COMMENT ON FUNCTION cosine_distance_arr(real[], real[]) IS 'Compute cosine distance between two vectors';
COMMENT ON FUNCTION cosine_distance_normalized_arr(real[], real[]) IS 'Fast cosine distance for pre-normalized vectors (3x faster)';
COMMENT ON FUNCTION inner_product_arr(real[], real[]) IS 'Compute inner product between two vectors';
COMMENT ON FUNCTION l1_distance_arr(real[], real[]) IS 'Compute L1 (Manhattan) distance between two vectors';
COMMENT ON FUNCTION vector_normalize(real[]) IS 'Normalize a vector to unit length';
COMMENT ON FUNCTION vector_add(real[], real[]) IS 'Add two vectors element-wise';
COMMENT ON FUNCTION vector_sub(real[], real[]) IS 'Subtract two vectors element-wise';
COMMENT ON FUNCTION vector_mul_scalar(real[], real) IS 'Multiply vector by scalar';
COMMENT ON FUNCTION vector_dims(real[]) IS 'Get vector dimensions';
COMMENT ON FUNCTION vector_norm(real[]) IS 'Get vector L2 norm';
COMMENT ON FUNCTION binary_quantize_arr(real[]) IS 'Binary quantize a vector (32x compression)';
COMMENT ON FUNCTION scalar_quantize_arr(real[]) IS 'Scalar quantize a vector (4x compression)';
COMMENT ON FUNCTION temporal_delta(real[], real[]) IS 'Compute delta between consecutive vectors for compression';
COMMENT ON FUNCTION temporal_undelta(real[], real[]) IS 'Reconstruct vector from delta encoding';
COMMENT ON FUNCTION temporal_ema_update(real[], real[], real) IS 'Exponential moving average update step';
COMMENT ON FUNCTION temporal_drift(real[], real[], real) IS 'Compute temporal drift (rate of change) between vectors';
COMMENT ON FUNCTION temporal_velocity(real[], real[], real) IS 'Compute velocity (first derivative) of vector';
COMMENT ON FUNCTION attention_score(real[], real[]) IS 'Compute scaled attention score between query and key';
COMMENT ON FUNCTION attention_softmax(real[]) IS 'Apply softmax to scores array';
COMMENT ON FUNCTION attention_weighted_add(real[], real[], real) IS 'Weighted vector addition for attention';
COMMENT ON FUNCTION attention_init(int) IS 'Initialize zero-vector accumulator for attention';
COMMENT ON FUNCTION attention_single(real[], real[], real[], real) IS 'Single key-value attention with score';
COMMENT ON FUNCTION graph_edge_similarity(real[], real[]) IS 'Compute edge similarity (cosine) between vectors';
COMMENT ON FUNCTION graph_pagerank_contribution(real, int, real) IS 'Calculate PageRank contribution to neighbors';
COMMENT ON FUNCTION graph_pagerank_base(int, real) IS 'Initialize PageRank base importance';
COMMENT ON FUNCTION graph_is_connected(real[], real[], real) IS 'Check if vectors are semantically connected';
COMMENT ON FUNCTION graph_centroid_update(real[], real[], real) IS 'Update centroid with neighbor contribution';
-- SPARQL / RDF Comments
COMMENT ON FUNCTION ruvector_create_rdf_store(text) IS 'Create a new RDF triple store for SPARQL queries';
COMMENT ON FUNCTION ruvector_sparql(text, text, text) IS 'Execute W3C SPARQL 1.1 query (SELECT, ASK, CONSTRUCT, DESCRIBE) with format selection (json, xml, csv, tsv)';
COMMENT ON FUNCTION ruvector_sparql_json(text, text) IS 'Execute SPARQL query and return results as JSONB';
COMMENT ON FUNCTION ruvector_insert_triple(text, text, text, text) IS 'Insert RDF triple (subject, predicate, object) into store';
COMMENT ON FUNCTION ruvector_insert_triple_graph(text, text, text, text, text) IS 'Insert RDF triple into named graph';
COMMENT ON FUNCTION ruvector_load_ntriples(text, text) IS 'Bulk load RDF triples from N-Triples format';
COMMENT ON FUNCTION ruvector_rdf_stats(text) IS 'Get statistics for RDF triple store (counts, graphs)';
COMMENT ON FUNCTION ruvector_query_triples(text, text, text, text) IS 'Query triples by pattern (use NULL for wildcards)';
COMMENT ON FUNCTION ruvector_clear_rdf_store(text) IS 'Clear all triples from RDF store';
COMMENT ON FUNCTION ruvector_delete_rdf_store(text) IS 'Delete RDF triple store completely';
COMMENT ON FUNCTION ruvector_list_rdf_stores() IS 'List all RDF triple stores';
COMMENT ON FUNCTION ruvector_sparql_update(text, text) IS 'Execute SPARQL UPDATE operations (INSERT DATA, DELETE DATA, DELETE/INSERT WHERE)';
COMMENT ON FUNCTION graph_bipartite_score(real[], real[], real) IS 'Compute bipartite matching score for RAG';
-- ============================================================================
-- ============================================================================
-- Embedding Generation Functions
-- ============================================================================
-- Note: Embedding functions require the 'embeddings' feature flag to be enabled
-- during compilation. These functions are not available in the default build.
-- To enable, build with: cargo pgrx package --features embeddings
-- ============================================================================
-- HNSW Access Method
-- ============================================================================
-- HNSW Access Method Handler
CREATE OR REPLACE FUNCTION hnsw_handler(internal)
RETURNS index_am_handler
AS 'MODULE_PATHNAME', 'hnsw_handler_wrapper'
LANGUAGE C STRICT;
-- Create HNSW Access Method
CREATE ACCESS METHOD hnsw TYPE INDEX HANDLER hnsw_handler;
-- ============================================================================
-- Operator Classes for HNSW
-- ============================================================================
-- HNSW Operator Class for L2 (Euclidean) distance
CREATE OPERATOR CLASS ruvector_l2_ops
DEFAULT FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <-> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_l2_distance(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_l2_ops USING hnsw IS
'ruvector HNSW operator class for L2/Euclidean distance';
-- HNSW Operator Class for Cosine distance
CREATE OPERATOR CLASS ruvector_cosine_ops
FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <=> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_cosine_distance(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_cosine_ops USING hnsw IS
'ruvector HNSW operator class for cosine distance';
-- HNSW Operator Class for Inner Product
CREATE OPERATOR CLASS ruvector_ip_ops
FOR TYPE ruvector USING hnsw AS
OPERATOR 1 <#> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_inner_product(ruvector, ruvector);
COMMENT ON OPERATOR CLASS ruvector_ip_ops USING hnsw IS
'ruvector HNSW operator class for inner product (max similarity)';
-- ============================================================================
-- IVFFlat Access Method
-- ============================================================================
-- IVFFlat Access Method Handler
CREATE OR REPLACE FUNCTION ruivfflat_handler(internal)
RETURNS index_am_handler
AS 'MODULE_PATHNAME', 'ruivfflat_handler_wrapper'
LANGUAGE C STRICT;
-- Create IVFFlat Access Method (also aliased as 'ivfflat' for pgvector compatibility)
CREATE ACCESS METHOD ruivfflat TYPE INDEX HANDLER ruivfflat_handler;
-- Operator Classes for IVFFlat (L2/Euclidean distance)
CREATE OPERATOR CLASS ruvector_l2_ops
DEFAULT FOR TYPE ruvector USING ruivfflat AS
OPERATOR 1 <-> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_l2_distance(ruvector, ruvector);
-- IVFFlat Cosine Operator Class
CREATE OPERATOR CLASS ruvector_cosine_ops
FOR TYPE ruvector USING ruivfflat AS
OPERATOR 1 <=> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_cosine_distance(ruvector, ruvector);
-- IVFFlat Inner Product Operator Class
CREATE OPERATOR CLASS ruvector_ip_ops
FOR TYPE ruvector USING ruivfflat AS
OPERATOR 1 <#> (ruvector, ruvector) FOR ORDER BY float_ops,
FUNCTION 1 ruvector_inner_product(ruvector, ruvector);