ruvector-postgres 0.2.5

High-performance PostgreSQL vector database extension - pgvector drop-in replacement with 53+ SQL functions, SIMD acceleration, hyperbolic embeddings, GNN layers, and self-learning capabilities
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// build.rs - Build script for ruvector-postgres extension
// Detects CPU features at build time for SIMD optimizations

use std::env;

fn main() {
    // Get the target architecture
    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap_or_default();

    println!("cargo:rerun-if-changed=build.rs");
    println!("cargo:rerun-if-env-changed=RUSTFLAGS");

    // Detect CPU features at build time
    // This allows for compile-time optimization when building for specific hardware

    if target_arch == "x86_64" || target_arch == "x86" {
        // Check for AVX-512 support
        if is_x86_feature_detected("avx512f") {
            println!("cargo:rustc-cfg=has_avx512");
            println!("cargo:rustc-cfg=has_avx2");
            println!("cargo:warning=Building with AVX-512 support");
        }
        // Check for AVX2 support
        else if is_x86_feature_detected("avx2") {
            println!("cargo:rustc-cfg=has_avx2");
            println!("cargo:warning=Building with AVX2 support");
        }
        // Check for SSE4.2 support (baseline for x86_64)
        else if is_x86_feature_detected("sse4.2") {
            println!("cargo:rustc-cfg=has_sse42");
            println!("cargo:warning=Building with SSE4.2 support");
        }
    } else if target_arch == "aarch64" {
        // ARM NEON is standard on AArch64
        println!("cargo:rustc-cfg=has_neon");
        println!("cargo:warning=Building with ARM NEON support");
    }

    // Enable native features if simd-native is enabled
    if env::var("CARGO_FEATURE_SIMD_NATIVE").is_ok() {
        println!("cargo:rustc-env=RUSTFLAGS=-C target-cpu=native");
        println!("cargo:warning=Building with native CPU optimizations (-C target-cpu=native)");
    }

    // PostgreSQL version detection
    if let Ok(pg_config) = env::var("PG_CONFIG") {
        println!("cargo:rerun-if-env-changed=PG_CONFIG");
        println!("cargo:warning=Using pg_config at: {}", pg_config);
    }

    // Print feature status
    print_feature_status();
}

fn is_x86_feature_detected(feature: &str) -> bool {
    // Check if the feature is enabled via RUSTFLAGS or target-cpu
    if let Ok(rustflags) = env::var("RUSTFLAGS") {
        if rustflags.contains("target-cpu=native") {
            return check_native_feature(feature);
        }
        if rustflags.contains(&format!("target-feature=+{}", feature)) {
            return true;
        }
    }

    // Check if building with specific feature flag
    match feature {
        "avx512f" => env::var("CARGO_FEATURE_SIMD_AVX512").is_ok(),
        "avx2" => env::var("CARGO_FEATURE_SIMD_AVX2").is_ok(),
        "sse4.2" => true, // Assume SSE4.2 is available on x86_64
        _ => false,
    }
}

fn check_native_feature(feature: &str) -> bool {
    // When building with target-cpu=native, use runtime detection
    // This is a best-effort check during build
    #[cfg(target_arch = "x86_64")]
    {
        match feature {
            "avx512f" => std::is_x86_feature_detected!("avx512f"),
            "avx2" => std::is_x86_feature_detected!("avx2"),
            "sse4.2" => std::is_x86_feature_detected!("sse4.2"),
            _ => false,
        }
    }

    #[cfg(not(target_arch = "x86_64"))]
    {
        let _ = feature;
        false
    }
}

fn print_feature_status() {
    println!("cargo:warning=Feature Status:");

    // Index features
    if env::var("CARGO_FEATURE_INDEX_HNSW").is_ok() {
        println!("cargo:warning=  ✓ HNSW index enabled");
    }
    if env::var("CARGO_FEATURE_INDEX_IVFFLAT").is_ok() {
        println!("cargo:warning=  ✓ IVFFlat index enabled");
    }

    // Quantization features
    if env::var("CARGO_FEATURE_QUANTIZATION_SCALAR").is_ok() {
        println!("cargo:warning=  ✓ Scalar quantization enabled");
    }
    if env::var("CARGO_FEATURE_QUANTIZATION_PRODUCT").is_ok() {
        println!("cargo:warning=  ✓ Product quantization enabled");
    }
    if env::var("CARGO_FEATURE_QUANTIZATION_BINARY").is_ok() {
        println!("cargo:warning=  ✓ Binary quantization enabled");
    }

    // Optional features
    if env::var("CARGO_FEATURE_HYBRID_SEARCH").is_ok() {
        println!("cargo:warning=  ✓ Hybrid search enabled");
    }
    if env::var("CARGO_FEATURE_FILTERED_SEARCH").is_ok() {
        println!("cargo:warning=  ✓ Filtered search enabled");
    }
    if env::var("CARGO_FEATURE_NEON_COMPAT").is_ok() {
        println!("cargo:warning=  ✓ Neon compatibility enabled");
    }
}