diff --git a/pgml-dashboard/Cargo.toml b/pgml-dashboard/Cargo.toml index f356f0e27..1e0e8db14 100644 --- a/pgml-dashboard/Cargo.toml +++ b/pgml-dashboard/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pgml-dashboard" -version = "2.4.1" +version = "2.4.4" edition = "2021" authors = ["Lev Kokotov "] license = "MIT" diff --git a/pgml-extension/Cargo.lock b/pgml-extension/Cargo.lock index d2c4dbbed..f0344e89a 100644 --- a/pgml-extension/Cargo.lock +++ b/pgml-extension/Cargo.lock @@ -282,6 +282,16 @@ version = "1.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "89b2fd2a0dcf38d7971e2194b6b6eebab45ae01067456a7fd93d5547a61b70be" +[[package]] +name = "cargo_toml" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f83bc2e401ed041b7057345ebc488c005efa0341d5541ce7004d30458d0090b" +dependencies = [ + "serde", + "toml", +] + [[package]] name = "cblas-sys" version = "0.1.4" @@ -303,7 +313,7 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f4aedb84272dbe89af497cf81375129abda4fc0a9e7c5d317498c15cc30c0d27" dependencies = [ - "nom 5.1.2", + "nom 5.1.3", ] [[package]] @@ -349,9 +359,9 @@ dependencies = [ [[package]] name = "clap" -version = "4.2.4" +version = "4.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "956ac1f6381d8d82ab4684768f89c0ea3afe66925ceadb4eeb3fc452ffc55d62" +checksum = "8a1f23fa97e1d1641371b51f35535cb26959b8e27ab50d167a8b996b5bada819" dependencies = [ "clap_builder", "clap_derive", @@ -364,15 +374,15 @@ version = "0.10.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "eca953650a7350560b61db95a0ab1d9c6f7b74d146a9e08fb258b834f3cf7e2c" dependencies = [ - "clap 4.2.4", + "clap 4.2.5", "doc-comment", ] [[package]] name = "clap_builder" -version = "4.2.4" +version = "4.2.5" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84080e799e54cff944f4b4a4b0e71630b0e0443b25b985175c7dddc1a859b749" +checksum = "0fdc5d93c358224b4d6867ef1356d740de2303e9892edc06c5340daeccd96bab" dependencies = [ "anstyle", "bitflags", @@ -699,6 +709,26 @@ version = "1.8.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7fcaabb2fef8c910e7f4c7ce9f67a1283a1715879a7c230ca9d6d1ae31f16d91" +[[package]] +name = "enum-map" +version = "2.5.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "988f0d17a0fa38291e5f41f71ea8d46a5d5497b9054d5a759fae2cbb819f2356" +dependencies = [ + "enum-map-derive", +] + +[[package]] +name = "enum-map-derive" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "2a4da76b3b6116d758c7ba93f7ec6a35d2e2cf24feda76c6e38a375f4d5c59f2" +dependencies = [ + "proc-macro2", + "quote 1.0.26", + "syn 1.0.109", +] + [[package]] name = "env_logger" version = "0.8.4" @@ -787,9 +817,9 @@ checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" [[package]] name = "flate2" -version = "1.0.25" +version = "1.0.26" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8a2db397cb1c8772f31494cb8917e48cd1e64f0fa7efac59fbd741a0a8ce841" +checksum = "3b9429470923de8e8cbd4d2dc513535400b4b3fef0319fb5c4e1f520a7bef743" dependencies = [ "crc32fast", "miniz_oxide", @@ -1240,9 +1270,9 @@ dependencies = [ [[package]] name = "linux-raw-sys" -version = "0.3.4" +version = "0.3.6" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "36eb31c1778188ae1e64398743890d0877fef36d11521ac60406b42016e8c2cf" +checksum = "b64f40e5e03e0d54f03845c8197d0291253cdbedfb1cb46b13c2c117554a9f4c" [[package]] name = "lock_api" @@ -1265,10 +1295,11 @@ dependencies = [ [[package]] name = "matrixmultiply" -version = "0.3.3" +version = "0.3.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb99c395ae250e1bf9133673f03ca9f97b7e71b705436bf8f089453445d1e9fe" +checksum = "432b44fed6d9ed750739e7b719f0325555e6209d15e5ec3fd9e8a0a5509fdaf8" dependencies = [ + "autocfg", "rawpointer", ] @@ -1313,9 +1344,9 @@ checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a" [[package]] name = "miniz_oxide" -version = "0.6.2" +version = "0.7.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b275950c28b37e794e8c55d88aeb5e139d0ce23fdbbeda68f8d7174abdf9e8fa" +checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" dependencies = [ "adler", ] @@ -1404,9 +1435,9 @@ dependencies = [ [[package]] name = "nom" -version = "5.1.2" +version = "5.1.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffb4262d26ed83a1c0a33a38fe2bb15797329c85770da05e6b828ddb782627af" +checksum = "08959a387a676302eebf4ddbcbc611da04285579f76f88ee0506c63b1a61dd4b" dependencies = [ "memchr", "version_check", @@ -1561,9 +1592,9 @@ dependencies = [ [[package]] name = "openssl" -version = "0.10.51" +version = "0.10.52" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97ea2d98598bf9ada7ea6ee8a30fb74f9156b63bbe495d64ec2b87c269d2dda3" +checksum = "01b8574602df80f7b85fdfc5392fa884a4e3b3f4f35402c070ab34c3d3f78d56" dependencies = [ "bitflags", "cfg-if", @@ -1593,9 +1624,9 @@ checksum = "ff011a302c396a5197692431fc1948019154afc178baf7d8e37367442a4601cf" [[package]] name = "openssl-sys" -version = "0.9.86" +version = "0.9.87" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "992bac49bdbab4423199c654a5515bd2a6c6a23bf03f2dd3bdb7e5ae6259bc69" +checksum = "8e17f59264b2809d77ae94f0e1ebabc434773f370d6ca667bd223ea10e06cc7e" dependencies = [ "cc", "libc", @@ -1668,9 +1699,9 @@ checksum = "478c572c3d73181ff3c2539045f6eb99e5491218eae919370993b890cdbdd98e" [[package]] name = "pest" -version = "2.5.7" +version = "2.6.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b1403e8401ad5dedea73c626b99758535b342502f8d1e361f4a2dd952749122" +checksum = "e68e84bfb01f0507134eac1e9b410a12ba379d064eab48c50ba4ce329a527b70" dependencies = [ "thiserror", "ucd-trie", @@ -1688,7 +1719,7 @@ dependencies = [ [[package]] name = "pgml" -version = "2.4.3" +version = "2.4.4" dependencies = [ "anyhow", "blas", @@ -1723,13 +1754,14 @@ dependencies = [ [[package]] name = "pgrx" -version = "0.7.4" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "520e5f1b0c97fa07446eddf2e9c8a410ced351014a2339ef680bfc177d989b55" +checksum = "e815cc6705f0bbf0ec90106a49e4e2a9b032636ffb405ee8f99b90f390296fb2" dependencies = [ "atomic-traits", "bitflags", "bitvec", + "enum-map", "heapless", "libc", "once_cell", @@ -1743,16 +1775,14 @@ dependencies = [ "serde_json", "thiserror", "time", - "tracing", - "tracing-error", "uuid", ] [[package]] name = "pgrx-macros" -version = "0.7.4" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b28d2441f5e36140541868ef5fb92b964e9c10e242fe2cfdcb464f05afd7fd16" +checksum = "0e861719fca5712319294c3012e819509ba3877be40516eb0fb014f5f2e11987" dependencies = [ "pgrx-sql-entity-graph", "proc-macro2", @@ -1762,10 +1792,11 @@ dependencies = [ [[package]] name = "pgrx-pg-config" -version = "0.7.4" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bea222a7b5241102003693f48ee187878e92a5d4f6c5f344e00786899253978d" +checksum = "7285810dd15ab641a0ca08d28ceb31997ce6e4b118fa0bf9a30fad0d7efd8f6f" dependencies = [ + "cargo_toml", "dirs 4.0.0", "eyre", "owo-colors", @@ -1779,9 +1810,9 @@ dependencies = [ [[package]] name = "pgrx-pg-sys" -version = "0.7.4" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ad42206dbd7780516c159da71a46b6785ee958595adebc87cbfb21ceb18e9cf" +checksum = "5367f6473851410fa80891ce9e184b30794a37589532b649c85f8bcff6200412" dependencies = [ "bindgen 0.60.1", "eyre", @@ -1801,9 +1832,9 @@ dependencies = [ [[package]] name = "pgrx-sql-entity-graph" -version = "0.7.4" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87dd0800eb8ab52d161d57db297aaa00b2debdba77f738ff011664c8751e92c9" +checksum = "0ac8c3803da0dfb4c941d23d954d27a94d786494960e672ecc4f1678f2b41c8a" dependencies = [ "convert_case", "eyre", @@ -1816,9 +1847,9 @@ dependencies = [ [[package]] name = "pgrx-tests" -version = "0.7.4" +version = "0.8.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e4ab1f3b9bbcdbea070d439e49ad146ea8a5a25104128a8b7f8522d21445a940" +checksum = "e46d7ef30071b73ed1088de43a5b06038be30a0519282618a65e26e5cf03b414" dependencies = [ "clap-cargo", "eyre", @@ -2186,9 +2217,9 @@ dependencies = [ [[package]] name = "rustix" -version = "0.37.14" +version = "0.37.17" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9b864d3c18a5785a05953adeed93e2dca37ed30f18e69bba9f30079d51f363f" +checksum = "bc809f704c03a812ac71f22456c857be34185cac691a4316f27ab0f633bb9009" dependencies = [ "bitflags", "errno", @@ -2376,15 +2407,6 @@ dependencies = [ "digest", ] -[[package]] -name = "sharded-slab" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "900fba806f70c630b0a382d0d825e17a0f19fcd059a2ade1ff237bcddf446b31" -dependencies = [ - "lazy_static", -] - [[package]] name = "shlex" version = "0.1.1" @@ -2644,9 +2666,9 @@ dependencies = [ [[package]] name = "target-lexicon" -version = "0.12.6" +version = "0.12.7" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ae9980cab1db3fceee2f6c6f643d5d8de2997c58ee8d25fb0cc8a9e9e7348e5" +checksum = "fd1ba337640d60c3e96bc6f0638a939b9c9a7f2c316a1598c279828b3d1dc8c5" [[package]] name = "tempfile" @@ -2766,9 +2788,9 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" [[package]] name = "tokio" -version = "1.27.0" +version = "1.28.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d0de47a4eecbe11f498978a9b29d792f0d2692d1dd003650c24c76510e3bc001" +checksum = "c3c786bf8134e5a3a166db9b29ab8f48134739014a3eca7bc6bfa95d673b136f" dependencies = [ "autocfg", "bytes", @@ -2776,7 +2798,7 @@ dependencies = [ "mio", "pin-project-lite", "socket2 0.4.9", - "windows-sys 0.45.0", + "windows-sys 0.48.0", ] [[package]] @@ -2805,9 +2827,9 @@ dependencies = [ [[package]] name = "tokio-util" -version = "0.7.7" +version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5427d89453009325de0d8f342c9490009f76e999cb7672d77e46267448f7e6b2" +checksum = "806fe8c2c87eccc8b3267cbae29ed3ab2d0bd37fca70ab622e46aaa9375ddb7d" dependencies = [ "bytes", "futures-core", @@ -2859,21 +2881,9 @@ checksum = "8ce8c33a8d48bd45d624a6e523445fd21ec13d3653cd51f681abf67418f54eb8" dependencies = [ "cfg-if", "pin-project-lite", - "tracing-attributes", "tracing-core", ] -[[package]] -name = "tracing-attributes" -version = "0.1.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4017f8f45139870ca7e672686113917c71c7a6e02d4924eda67186083c03081a" -dependencies = [ - "proc-macro2", - "quote 1.0.26", - "syn 1.0.109", -] - [[package]] name = "tracing-core" version = "0.1.30" @@ -2883,27 +2893,6 @@ dependencies = [ "once_cell", ] -[[package]] -name = "tracing-error" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d686ec1c0f384b1277f097b2f279a2ecc11afe8c133c1aabf036a27cb4cd206e" -dependencies = [ - "tracing", - "tracing-subscriber", -] - -[[package]] -name = "tracing-subscriber" -version = "0.3.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "30a651bc37f915e81f087d86e62a18eec5f79550c7faff886f7090b4ea757c77" -dependencies = [ - "sharded-slab", - "thread_local", - "tracing-core", -] - [[package]] name = "typenum" version = "1.16.0" @@ -3019,9 +3008,9 @@ dependencies = [ [[package]] name = "uuid" -version = "1.3.1" +version = "1.3.2" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b55a3fef2a1e3b3a00ce878640918820d3c51081576ac657d23af9fc7928fdb" +checksum = "4dad5567ad0cf5b760e5665964bec1b47dfd077ba8a2544b513f3556d3d239a2" dependencies = [ "getrandom", ] @@ -3260,9 +3249,9 @@ checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a" [[package]] name = "winnow" -version = "0.4.1" +version = "0.4.4" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae8970b36c66498d8ff1d66685dc86b91b29db0c7739899012f63a63814b4b28" +checksum = "5617da7e1f97bf363947d767b91aaf3c2bbc19db7fda9c65af1278713d58e0a2" dependencies = [ "memchr", ] diff --git a/pgml-extension/Cargo.toml b/pgml-extension/Cargo.toml index 2a34148b1..fd0e46433 100644 --- a/pgml-extension/Cargo.toml +++ b/pgml-extension/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "pgml" -version = "2.4.3" +version = "2.4.4" edition = "2021" [lib] @@ -18,8 +18,8 @@ python = ["pyo3"] cuda = ["xgboost/cuda", "lightgbm/cuda"] [dependencies] -pgrx = "=0.7.4" -pgrx-pg-sys = "=0.7.4" +pgrx = "=0.8.2" +pgrx-pg-sys = "=0.8.2" xgboost = { git="https://github.com/postgresml/rust-xgboost.git", branch = "master" } once_cell = "1" rand = "0.8" @@ -48,7 +48,7 @@ flate2 = "1.0" csv = "1.1" [dev-dependencies] -pgrx-tests = "=0.7.4" +pgrx-tests = "=0.8.2" [profile.dev] panic = "unwind" diff --git a/pgml-extension/sql/pgml--2.4.3--2.4.4.sql b/pgml-extension/sql/pgml--2.4.3--2.4.4.sql new file mode 100644 index 000000000..977e54da7 --- /dev/null +++ b/pgml-extension/sql/pgml--2.4.3--2.4.4.sql @@ -0,0 +1,1348 @@ +/* +This file is auto generated by pgrx. + +The ordering of items is not stable, it is driven by a dependency graph. +*/ + +-- src/bindings/xgboost.rs:19 +-- pgml::bindings::xgboost::xgboost_version +DROP FUNCTION IF EXISTS pgml."xgboost_version"(); +CREATE FUNCTION pgml."xgboost_version"() RETURNS TEXT /* alloc::string::String */ +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'xgboost_version_wrapper'; + +-- src/api.rs:109 +-- pgml::api::version +DROP FUNCTION IF EXISTS pgml."version"(); +CREATE FUNCTION pgml."version"() RETURNS TEXT /* alloc::string::String */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'version_wrapper'; + +-- src/api.rs:73 +-- pgml::api::validate_shared_library +DROP FUNCTION IF EXISTS pgml."validate_shared_library"(); +CREATE FUNCTION pgml."validate_shared_library"() RETURNS void +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'validate_shared_library_wrapper'; + +-- src/api.rs:25 +-- pgml::api::validate_python_dependencies +DROP FUNCTION IF EXISTS pgml."validate_python_dependencies"(); +CREATE FUNCTION pgml."validate_python_dependencies"() RETURNS bool /* bool */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'validate_python_dependencies_wrapper'; + +-- src/api.rs:586 +-- pgml::api::transform +DROP FUNCTION IF EXISTS pgml."transform"(TEXT, jsonb, TEXT[], bool); +CREATE FUNCTION pgml."transform"( + "task" TEXT, /* alloc::string::String */ + "args" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "inputs" TEXT[] DEFAULT ARRAY[]::TEXT[], /* alloc::vec::Vec */ + "cache" bool DEFAULT false /* bool */ +) RETURNS jsonb /* pgrx::datum::json::JsonB */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'transform_string_wrapper'; + +-- src/api.rs:573 +-- pgml::api::transform +DROP FUNCTION IF EXISTS pgml."transform"(jsonb, jsonb, TEXT[], bool); +CREATE FUNCTION pgml."transform"( + "task" jsonb, /* pgrx::datum::json::JsonB */ + "args" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "inputs" TEXT[] DEFAULT ARRAY[]::TEXT[], /* alloc::vec::Vec */ + "cache" bool DEFAULT false /* bool */ +) RETURNS jsonb /* pgrx::datum::json::JsonB */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'transform_json_wrapper'; + +DROP AGGREGATE IF EXISTS pgml."sum"(real[]); + +-- src/vectors.rs:336 +-- pgml::vectors::sum_s_state +DROP FUNCTION IF EXISTS pgml."sum_s_state"(real[], real[]); +CREATE FUNCTION pgml."sum_s_state"( + "this" real[], /* core::option::Option> */ + "arg_one" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sum_s_state_wrapper'; + +-- src/vectors.rs:336 +-- pgml::vectors::sum_s_finalize +DROP FUNCTION IF EXISTS pgml."sum_s_finalize"(real[]); +CREATE FUNCTION pgml."sum_s_finalize"( + "this" real[] /* core::option::Option> */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sum_s_finalize_wrapper'; + +-- src/vectors.rs:336 +-- pgml::vectors::sum_s_combine +DROP FUNCTION IF EXISTS pgml."sum_s_combine"(real[], real[]); +CREATE FUNCTION pgml."sum_s_combine"( + "this" real[], /* core::option::Option> */ + "v" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sum_s_combine_wrapper'; + +-- src/vectors.rs:336 +-- pgml::vectors::SumS +CREATE AGGREGATE pgml.sum ( + real[] /* core::option::Option> */ +) +( + SFUNC = pgml."sum_s_state", /* pgml::vectors::SumS::state */ + STYPE = real[], /* core::option::Option> */ + FINALFUNC = pgml."sum_s_finalize", /* pgml::vectors::SumS::final */ + COMBINEFUNC = pgml."sum_s_combine" /* pgml::vectors::SumS::combine */ +); + +DROP AGGREGATE IF EXISTS pgml."sum"(double precision[]); + +-- src/vectors.rs:399 +-- pgml::vectors::sum_d_state +DROP FUNCTION IF EXISTS pgml."sum_d_state"(double precision[], double precision[]); +CREATE FUNCTION pgml."sum_d_state"( + "this" double precision[], /* core::option::Option> */ + "arg_one" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sum_d_state_wrapper'; + +-- src/vectors.rs:399 +-- pgml::vectors::sum_d_finalize +DROP FUNCTION IF EXISTS pgml."sum_d_finalize"(double precision[]); +CREATE FUNCTION pgml."sum_d_finalize"( + "this" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sum_d_finalize_wrapper'; + +-- src/vectors.rs:399 +-- pgml::vectors::sum_d_combine +DROP FUNCTION IF EXISTS pgml."sum_d_combine"(double precision[], double precision[]); +CREATE FUNCTION pgml."sum_d_combine"( + "this" double precision[], /* core::option::Option> */ + "v" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sum_d_combine_wrapper'; + +-- src/vectors.rs:399 +-- pgml::vectors::SumD +CREATE AGGREGATE pgml.sum ( + double precision[] /* core::option::Option> */ +) +( + SFUNC = pgml."sum_d_state", /* pgml::vectors::SumD::state */ + STYPE = double precision[], /* core::option::Option> */ + FINALFUNC = pgml."sum_d_finalize", /* pgml::vectors::SumD::final */ + COMBINEFUNC = pgml."sum_d_combine" /* pgml::vectors::SumD::combine */ +); + +-- src/vectors.rs:64 +-- pgml::vectors::subtract +DROP FUNCTION IF EXISTS pgml."subtract"(real[], real[]); +CREATE FUNCTION pgml."subtract"( + "vector" real[], /* alloc::vec::Vec */ + "subtahend" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'subtract_vector_s_wrapper'; + +-- src/vectors.rs:74 +-- pgml::vectors::subtract +DROP FUNCTION IF EXISTS pgml."subtract"(double precision[], double precision[]); +CREATE FUNCTION pgml."subtract"( + "vector" double precision[], /* alloc::vec::Vec */ + "subtahend" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'subtract_vector_d_wrapper'; + +-- src/vectors.rs:14 +-- pgml::vectors::subtract +DROP FUNCTION IF EXISTS pgml."subtract"(real[], real); +CREATE FUNCTION pgml."subtract"( + "vector" real[], /* alloc::vec::Vec */ + "subtahend" real /* f32 */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'subtract_scalar_s_wrapper'; + +-- src/vectors.rs:19 +-- pgml::vectors::subtract +DROP FUNCTION IF EXISTS pgml."subtract"(double precision[], double precision); +CREATE FUNCTION pgml."subtract"( + "vector" double precision[], /* alloc::vec::Vec */ + "subtahend" double precision /* f64 */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'subtract_scalar_d_wrapper'; + +-- src/api.rs:811 +-- pgml::api::sklearn_regression_metrics +DROP FUNCTION IF EXISTS pgml."sklearn_regression_metrics"(real[], real[]); +CREATE FUNCTION pgml."sklearn_regression_metrics"( + "ground_truth" real[], /* alloc::vec::Vec */ + "y_hat" real[] /* alloc::vec::Vec */ +) RETURNS jsonb /* pgrx::datum::json::JsonB */ +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sklearn_regression_metrics_wrapper'; + +-- src/api.rs:805 +-- pgml::api::sklearn_r2_score +DROP FUNCTION IF EXISTS pgml."sklearn_r2_score"(real[], real[]); +CREATE FUNCTION pgml."sklearn_r2_score"( + "ground_truth" real[], /* alloc::vec::Vec */ + "y_hat" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sklearn_r2_score_wrapper'; + +-- src/api.rs:799 +-- pgml::api::sklearn_f1_score +DROP FUNCTION IF EXISTS pgml."sklearn_f1_score"(real[], real[]); +CREATE FUNCTION pgml."sklearn_f1_score"( + "ground_truth" real[], /* alloc::vec::Vec */ + "y_hat" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sklearn_f1_score_wrapper'; + +-- src/api.rs:826 +-- pgml::api::sklearn_classification_metrics +DROP FUNCTION IF EXISTS pgml."sklearn_classification_metrics"(real[], real[], bigint); +CREATE FUNCTION pgml."sklearn_classification_metrics"( + "ground_truth" real[], /* alloc::vec::Vec */ + "y_hat" real[], /* alloc::vec::Vec */ + "num_classes" bigint /* i64 */ +) RETURNS jsonb /* pgrx::datum::json::JsonB */ +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'sklearn_classification_metrics_wrapper'; + +-- src/api.rs:90 +-- pgml::api::python_version +DROP FUNCTION IF EXISTS pgml."python_version"(); +CREATE FUNCTION pgml."python_version"() RETURNS TEXT /* alloc::string::String */ +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'python_version_wrapper'; + +-- src/api.rs:61 +-- pgml::api::python_package_version +DROP FUNCTION IF EXISTS pgml."python_package_version"(TEXT); +CREATE FUNCTION pgml."python_package_version"( + "name" TEXT /* &str */ +) RETURNS TEXT /* alloc::string::String */ +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'python_package_version_wrapper'; + +-- src/api.rs:460 +-- pgml::api::predict_proba +DROP FUNCTION IF EXISTS pgml."predict_proba"(TEXT, real[]); +CREATE FUNCTION pgml."predict_proba"( + "project_name" TEXT, /* &str */ + "features" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_proba_wrapper'; + +-- src/api.rs:487 +-- pgml::api::predict_proba +DROP FUNCTION IF EXISTS pgml."predict_proba"(bigint, real[]); +CREATE FUNCTION pgml."predict_proba"( + "model_id" bigint, /* i64 */ + "features" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_model_proba_wrapper'; + +-- src/api.rs:492 +-- pgml::api::predict_joint +DROP FUNCTION IF EXISTS pgml."predict_joint"(bigint, real[]); +CREATE FUNCTION pgml."predict_joint"( + "model_id" bigint, /* i64 */ + "features" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_model_joint_wrapper'; + +-- src/api.rs:465 +-- pgml::api::predict_joint +DROP FUNCTION IF EXISTS pgml."predict_joint"(TEXT, real[]); +CREATE FUNCTION pgml."predict_joint"( + "project_name" TEXT, /* &str */ + "features" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_joint_wrapper'; + +-- src/api.rs:497 +-- pgml::api::predict_batch +DROP FUNCTION IF EXISTS pgml."predict_batch"(bigint, real[]); +CREATE FUNCTION pgml."predict_batch"( + "model_id" bigint, /* i64 */ + "features" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_model_batch_wrapper'; + +-- src/api.rs:470 +-- pgml::api::predict_batch +DROP FUNCTION IF EXISTS pgml."predict_batch"(TEXT, real[]); +CREATE FUNCTION pgml."predict_batch"( + "project_name" TEXT, /* &str */ + "features" real[] /* alloc::vec::Vec */ +) RETURNS SETOF real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_batch_wrapper'; + +-- src/api.rs:477 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(TEXT, anyelement); +CREATE FUNCTION pgml."predict"( + "project_name" TEXT, /* &str */ + "row" anyelement /* pgrx::datum::anyelement::AnyElement */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_row_wrapper'; + +-- src/api.rs:502 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(bigint, anyelement); +CREATE FUNCTION pgml."predict"( + "model_id" bigint, /* i64 */ + "row" anyelement /* pgrx::datum::anyelement::AnyElement */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_model_row_wrapper'; + +-- src/api.rs:482 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(bigint, real[]); +CREATE FUNCTION pgml."predict"( + "model_id" bigint, /* i64 */ + "features" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_model_wrapper'; + +-- src/api.rs:447 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(TEXT, bigint[]); +CREATE FUNCTION pgml."predict"( + "project_name" TEXT, /* &str */ + "features" bigint[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_i64_wrapper'; + +-- src/api.rs:442 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(TEXT, INT[]); +CREATE FUNCTION pgml."predict"( + "project_name" TEXT, /* &str */ + "features" INT[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_i32_wrapper'; + +-- src/api.rs:437 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(TEXT, smallint[]); +CREATE FUNCTION pgml."predict"( + "project_name" TEXT, /* &str */ + "features" smallint[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_i16_wrapper'; + +-- src/api.rs:432 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(TEXT, double precision[]); +CREATE FUNCTION pgml."predict"( + "project_name" TEXT, /* &str */ + "features" double precision[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_f64_wrapper'; + +-- src/api.rs:427 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(TEXT, real[]); +CREATE FUNCTION pgml."predict"( + "project_name" TEXT, /* &str */ + "features" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_f32_wrapper'; + +-- src/api.rs:452 +-- pgml::api::predict +DROP FUNCTION IF EXISTS pgml."predict"(TEXT, bool[]); +CREATE FUNCTION pgml."predict"( + "project_name" TEXT, /* &str */ + "features" bool[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'predict_bool_wrapper'; + +-- src/vectors.rs:214 +-- pgml::vectors::normalize_max +DROP FUNCTION IF EXISTS pgml."normalize_max"(real[]); +CREATE FUNCTION pgml."normalize_max"( + "vector" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'normalize_max_s_wrapper'; + +-- src/vectors.rs:224 +-- pgml::vectors::normalize_max +DROP FUNCTION IF EXISTS pgml."normalize_max"(double precision[]); +CREATE FUNCTION pgml."normalize_max"( + "vector" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'normalize_max_d_wrapper'; + +-- src/vectors.rs:196 +-- pgml::vectors::normalize_l2 +DROP FUNCTION IF EXISTS pgml."normalize_l2"(real[]); +CREATE FUNCTION pgml."normalize_l2"( + "vector" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'normalize_l2_s_wrapper'; + +-- src/vectors.rs:205 +-- pgml::vectors::normalize_l2 +DROP FUNCTION IF EXISTS pgml."normalize_l2"(double precision[]); +CREATE FUNCTION pgml."normalize_l2"( + "vector" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'normalize_l2_d_wrapper'; + +-- src/vectors.rs:178 +-- pgml::vectors::normalize_l1 +DROP FUNCTION IF EXISTS pgml."normalize_l1"(real[]); +CREATE FUNCTION pgml."normalize_l1"( + "vector" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'normalize_l1_s_wrapper'; + +-- src/vectors.rs:187 +-- pgml::vectors::normalize_l1 +DROP FUNCTION IF EXISTS pgml."normalize_l1"(double precision[]); +CREATE FUNCTION pgml."normalize_l1"( + "vector" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'normalize_l1_d_wrapper'; + +-- src/vectors.rs:162 +-- pgml::vectors::norm_max +DROP FUNCTION IF EXISTS pgml."norm_max"(real[]); +CREATE FUNCTION pgml."norm_max"( + "vector" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'norm_max_s_wrapper'; + +-- src/vectors.rs:170 +-- pgml::vectors::norm_max +DROP FUNCTION IF EXISTS pgml."norm_max"(double precision[]); +CREATE FUNCTION pgml."norm_max"( + "vector" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision /* f64 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'norm_max_d_wrapper'; + +-- src/vectors.rs:152 +-- pgml::vectors::norm_l2 +DROP FUNCTION IF EXISTS pgml."norm_l2"(real[]); +CREATE FUNCTION pgml."norm_l2"( + "vector" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'norm_l2_s_wrapper'; + +-- src/vectors.rs:157 +-- pgml::vectors::norm_l2 +DROP FUNCTION IF EXISTS pgml."norm_l2"(double precision[]); +CREATE FUNCTION pgml."norm_l2"( + "vector" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision /* f64 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'norm_l2_d_wrapper'; + +-- src/vectors.rs:142 +-- pgml::vectors::norm_l1 +DROP FUNCTION IF EXISTS pgml."norm_l1"(real[]); +CREATE FUNCTION pgml."norm_l1"( + "vector" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'norm_l1_s_wrapper'; + +-- src/vectors.rs:147 +-- pgml::vectors::norm_l1 +DROP FUNCTION IF EXISTS pgml."norm_l1"(double precision[]); +CREATE FUNCTION pgml."norm_l1"( + "vector" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision /* f64 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'norm_l1_d_wrapper'; + +-- src/vectors.rs:124 +-- pgml::vectors::norm_l0 +DROP FUNCTION IF EXISTS pgml."norm_l0"(real[]); +CREATE FUNCTION pgml."norm_l0"( + "vector" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'norm_l0_s_wrapper'; + +-- src/vectors.rs:133 +-- pgml::vectors::norm_l0 +DROP FUNCTION IF EXISTS pgml."norm_l0"(double precision[]); +CREATE FUNCTION pgml."norm_l0"( + "vector" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision /* f64 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'norm_l0_d_wrapper'; + +-- src/vectors.rs:84 +-- pgml::vectors::multiply +DROP FUNCTION IF EXISTS pgml."multiply"(real[], real[]); +CREATE FUNCTION pgml."multiply"( + "vector" real[], /* alloc::vec::Vec */ + "multiplicand" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'multiply_vector_s_wrapper'; + +-- src/vectors.rs:94 +-- pgml::vectors::multiply +DROP FUNCTION IF EXISTS pgml."multiply"(double precision[], double precision[]); +CREATE FUNCTION pgml."multiply"( + "vector" double precision[], /* alloc::vec::Vec */ + "multiplicand" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'multiply_vector_d_wrapper'; + +-- src/vectors.rs:24 +-- pgml::vectors::multiply +DROP FUNCTION IF EXISTS pgml."multiply"(real[], real); +CREATE FUNCTION pgml."multiply"( + "vector" real[], /* alloc::vec::Vec */ + "multiplicand" real /* f32 */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'multiply_scalar_s_wrapper'; + +-- src/vectors.rs:29 +-- pgml::vectors::multiply +DROP FUNCTION IF EXISTS pgml."multiply"(double precision[], double precision); +CREATE FUNCTION pgml."multiply"( + "vector" double precision[], /* alloc::vec::Vec */ + "multiplicand" double precision /* f64 */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'multiply_scalar_d_wrapper'; + +DROP AGGREGATE IF EXISTS pgml."min"(real[]); + +-- src/vectors.rs:730 +-- pgml::vectors::min_s_state +DROP FUNCTION IF EXISTS pgml."min_s_state"(real[], real[]); +CREATE FUNCTION pgml."min_s_state"( + "this" real[], /* core::option::Option> */ + "arg_one" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_s_state_wrapper'; + +-- src/vectors.rs:730 +-- pgml::vectors::min_s_finalize +DROP FUNCTION IF EXISTS pgml."min_s_finalize"(real[]); +CREATE FUNCTION pgml."min_s_finalize"( + "this" real[] /* core::option::Option> */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_s_finalize_wrapper'; + +-- src/vectors.rs:730 +-- pgml::vectors::min_s_combine +DROP FUNCTION IF EXISTS pgml."min_s_combine"(real[], real[]); +CREATE FUNCTION pgml."min_s_combine"( + "this" real[], /* core::option::Option> */ + "v" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_s_combine_wrapper'; + +-- src/vectors.rs:730 +-- pgml::vectors::MinS +CREATE AGGREGATE pgml.min ( + real[] /* core::option::Option> */ +) +( + SFUNC = pgml."min_s_state", /* pgml::vectors::MinS::state */ + STYPE = real[], /* core::option::Option> */ + FINALFUNC = pgml."min_s_finalize", /* pgml::vectors::MinS::final */ + COMBINEFUNC = pgml."min_s_combine" /* pgml::vectors::MinS::combine */ +); + +DROP AGGREGATE IF EXISTS pgml."min"(double precision[]); + +-- src/vectors.rs:797 +-- pgml::vectors::min_d_state +DROP FUNCTION IF EXISTS pgml."min_d_state"(double precision[], double precision[]); +CREATE FUNCTION pgml."min_d_state"( + "this" double precision[], /* core::option::Option> */ + "arg_one" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_d_state_wrapper'; + +-- src/vectors.rs:797 +-- pgml::vectors::min_d_finalize +DROP FUNCTION IF EXISTS pgml."min_d_finalize"(double precision[]); +CREATE FUNCTION pgml."min_d_finalize"( + "this" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_d_finalize_wrapper'; + +-- src/vectors.rs:797 +-- pgml::vectors::min_d_combine +DROP FUNCTION IF EXISTS pgml."min_d_combine"(double precision[], double precision[]); +CREATE FUNCTION pgml."min_d_combine"( + "this" double precision[], /* core::option::Option> */ + "v" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_d_combine_wrapper'; + +-- src/vectors.rs:797 +-- pgml::vectors::MinD +CREATE AGGREGATE pgml.min ( + double precision[] /* core::option::Option> */ +) +( + SFUNC = pgml."min_d_state", /* pgml::vectors::MinD::state */ + STYPE = double precision[], /* core::option::Option> */ + FINALFUNC = pgml."min_d_finalize", /* pgml::vectors::MinD::final */ + COMBINEFUNC = pgml."min_d_combine" /* pgml::vectors::MinD::combine */ +); + +DROP AGGREGATE IF EXISTS pgml."min_abs"(real[]); + +-- src/vectors.rs:864 +-- pgml::vectors::min_abs_s_state +DROP FUNCTION IF EXISTS pgml."min_abs_s_state"(real[], real[]); +CREATE FUNCTION pgml."min_abs_s_state"( + "this" real[], /* core::option::Option> */ + "arg_one" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_abs_s_state_wrapper'; + +-- src/vectors.rs:864 +-- pgml::vectors::min_abs_s_finalize +DROP FUNCTION IF EXISTS pgml."min_abs_s_finalize"(real[]); +CREATE FUNCTION pgml."min_abs_s_finalize"( + "this" real[] /* core::option::Option> */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_abs_s_finalize_wrapper'; + +-- src/vectors.rs:864 +-- pgml::vectors::min_abs_s_combine +DROP FUNCTION IF EXISTS pgml."min_abs_s_combine"(real[], real[]); +CREATE FUNCTION pgml."min_abs_s_combine"( + "this" real[], /* core::option::Option> */ + "v" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_abs_s_combine_wrapper'; + +-- src/vectors.rs:864 +-- pgml::vectors::MinAbsS +CREATE AGGREGATE pgml.min_abs ( + real[] /* core::option::Option> */ +) +( + SFUNC = pgml."min_abs_s_state", /* pgml::vectors::MinAbsS::state */ + STYPE = real[], /* core::option::Option> */ + FINALFUNC = pgml."min_abs_s_finalize", /* pgml::vectors::MinAbsS::final */ + COMBINEFUNC = pgml."min_abs_s_combine" /* pgml::vectors::MinAbsS::combine */ +); + +DROP AGGREGATE IF EXISTS pgml."min_abs"(double precision[]); + +-- src/vectors.rs:931 +-- pgml::vectors::min_abs_d_state +DROP FUNCTION IF EXISTS pgml."min_abs_d_state"(double precision[], double precision[]); +CREATE FUNCTION pgml."min_abs_d_state"( + "this" double precision[], /* core::option::Option> */ + "arg_one" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_abs_d_state_wrapper'; + +-- src/vectors.rs:931 +-- pgml::vectors::min_abs_d_finalize +DROP FUNCTION IF EXISTS pgml."min_abs_d_finalize"(double precision[]); +CREATE FUNCTION pgml."min_abs_d_finalize"( + "this" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_abs_d_finalize_wrapper'; + +-- src/vectors.rs:931 +-- pgml::vectors::min_abs_d_combine +DROP FUNCTION IF EXISTS pgml."min_abs_d_combine"(double precision[], double precision[]); +CREATE FUNCTION pgml."min_abs_d_combine"( + "this" double precision[], /* core::option::Option> */ + "v" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'min_abs_d_combine_wrapper'; + +-- src/vectors.rs:931 +-- pgml::vectors::MinAbsD +CREATE AGGREGATE pgml.min_abs ( + double precision[] /* core::option::Option> */ +) +( + SFUNC = pgml."min_abs_d_state", /* pgml::vectors::MinAbsD::state */ + STYPE = double precision[], /* core::option::Option> */ + FINALFUNC = pgml."min_abs_d_finalize", /* pgml::vectors::MinAbsD::final */ + COMBINEFUNC = pgml."min_abs_d_combine" /* pgml::vectors::MinAbsD::combine */ +); + +DROP AGGREGATE IF EXISTS pgml."max"(real[]); + +-- src/vectors.rs:596 +-- pgml::vectors::max_s_state +DROP FUNCTION IF EXISTS pgml."max_s_state"(real[], real[]); +CREATE FUNCTION pgml."max_s_state"( + "this" real[], /* core::option::Option> */ + "arg_one" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_s_state_wrapper'; + +-- src/vectors.rs:596 +-- pgml::vectors::max_s_finalize +DROP FUNCTION IF EXISTS pgml."max_s_finalize"(real[]); +CREATE FUNCTION pgml."max_s_finalize"( + "this" real[] /* core::option::Option> */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_s_finalize_wrapper'; + +-- src/vectors.rs:596 +-- pgml::vectors::max_s_combine +DROP FUNCTION IF EXISTS pgml."max_s_combine"(real[], real[]); +CREATE FUNCTION pgml."max_s_combine"( + "this" real[], /* core::option::Option> */ + "v" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_s_combine_wrapper'; + +-- src/vectors.rs:596 +-- pgml::vectors::MaxS +CREATE AGGREGATE pgml.max ( + real[] /* core::option::Option> */ +) +( + SFUNC = pgml."max_s_state", /* pgml::vectors::MaxS::state */ + STYPE = real[], /* core::option::Option> */ + FINALFUNC = pgml."max_s_finalize", /* pgml::vectors::MaxS::final */ + COMBINEFUNC = pgml."max_s_combine" /* pgml::vectors::MaxS::combine */ +); + +DROP AGGREGATE IF EXISTS pgml."max"(double precision[]); + +-- src/vectors.rs:663 +-- pgml::vectors::max_d_state +DROP FUNCTION IF EXISTS pgml."max_d_state"(double precision[], double precision[]); +CREATE FUNCTION pgml."max_d_state"( + "this" double precision[], /* core::option::Option> */ + "arg_one" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_d_state_wrapper'; + +-- src/vectors.rs:663 +-- pgml::vectors::max_d_finalize +DROP FUNCTION IF EXISTS pgml."max_d_finalize"(double precision[]); +CREATE FUNCTION pgml."max_d_finalize"( + "this" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_d_finalize_wrapper'; + +-- src/vectors.rs:663 +-- pgml::vectors::max_d_combine +DROP FUNCTION IF EXISTS pgml."max_d_combine"(double precision[], double precision[]); +CREATE FUNCTION pgml."max_d_combine"( + "this" double precision[], /* core::option::Option> */ + "v" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_d_combine_wrapper'; + +-- src/vectors.rs:663 +-- pgml::vectors::MaxD +CREATE AGGREGATE pgml.max ( + double precision[] /* core::option::Option> */ +) +( + SFUNC = pgml."max_d_state", /* pgml::vectors::MaxD::state */ + STYPE = double precision[], /* core::option::Option> */ + FINALFUNC = pgml."max_d_finalize", /* pgml::vectors::MaxD::final */ + COMBINEFUNC = pgml."max_d_combine" /* pgml::vectors::MaxD::combine */ +); + +DROP AGGREGATE IF EXISTS pgml."max_abs"(real[]); + +-- src/vectors.rs:462 +-- pgml::vectors::max_abs_s_state +DROP FUNCTION IF EXISTS pgml."max_abs_s_state"(real[], real[]); +CREATE FUNCTION pgml."max_abs_s_state"( + "this" real[], /* core::option::Option> */ + "arg_one" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_abs_s_state_wrapper'; + +-- src/vectors.rs:462 +-- pgml::vectors::max_abs_s_finalize +DROP FUNCTION IF EXISTS pgml."max_abs_s_finalize"(real[]); +CREATE FUNCTION pgml."max_abs_s_finalize"( + "this" real[] /* core::option::Option> */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_abs_s_finalize_wrapper'; + +-- src/vectors.rs:462 +-- pgml::vectors::max_abs_s_combine +DROP FUNCTION IF EXISTS pgml."max_abs_s_combine"(real[], real[]); +CREATE FUNCTION pgml."max_abs_s_combine"( + "this" real[], /* core::option::Option> */ + "v" real[] /* core::option::Option> */ +) RETURNS real[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_abs_s_combine_wrapper'; + +-- src/vectors.rs:462 +-- pgml::vectors::MaxAbsS +CREATE AGGREGATE pgml.max_abs ( + real[] /* core::option::Option> */ +) +( + SFUNC = pgml."max_abs_s_state", /* pgml::vectors::MaxAbsS::state */ + STYPE = real[], /* core::option::Option> */ + FINALFUNC = pgml."max_abs_s_finalize", /* pgml::vectors::MaxAbsS::final */ + COMBINEFUNC = pgml."max_abs_s_combine" /* pgml::vectors::MaxAbsS::combine */ +); + +DROP AGGREGATE IF EXISTS pgml."max_abs"(double precision[]); + +-- src/vectors.rs:529 +-- pgml::vectors::max_abs_d_state +DROP FUNCTION IF EXISTS pgml."max_abs_d_state"(double precision[], double precision[]); +CREATE FUNCTION pgml."max_abs_d_state"( + "this" double precision[], /* core::option::Option> */ + "arg_one" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_abs_d_state_wrapper'; + +-- src/vectors.rs:529 +-- pgml::vectors::max_abs_d_finalize +DROP FUNCTION IF EXISTS pgml."max_abs_d_finalize"(double precision[]); +CREATE FUNCTION pgml."max_abs_d_finalize"( + "this" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_abs_d_finalize_wrapper'; + +-- src/vectors.rs:529 +-- pgml::vectors::max_abs_d_combine +DROP FUNCTION IF EXISTS pgml."max_abs_d_combine"(double precision[], double precision[]); +CREATE FUNCTION pgml."max_abs_d_combine"( + "this" double precision[], /* core::option::Option> */ + "v" double precision[] /* core::option::Option> */ +) RETURNS double precision[] /* core::option::Option> */ +IMMUTABLE PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'max_abs_d_combine_wrapper'; + +-- src/vectors.rs:529 +-- pgml::vectors::MaxAbsD +CREATE AGGREGATE pgml.max_abs ( + double precision[] /* core::option::Option> */ +) +( + SFUNC = pgml."max_abs_d_state", /* pgml::vectors::MaxAbsD::state */ + STYPE = double precision[], /* core::option::Option> */ + FINALFUNC = pgml."max_abs_d_finalize", /* pgml::vectors::MaxAbsD::final */ + COMBINEFUNC = pgml."max_abs_d_combine" /* pgml::vectors::MaxAbsD::combine */ +); + +-- src/api.rs:541 +-- pgml::api::load_dataset +DROP FUNCTION IF EXISTS pgml."load_dataset"(TEXT, TEXT, bigint, jsonb); +CREATE FUNCTION pgml."load_dataset"( + "source" TEXT, /* &str */ + "subset" TEXT DEFAULT NULL, /* core::option::Option */ + "limit" bigint DEFAULT NULL, /* core::option::Option */ + "kwargs" jsonb DEFAULT '{}' /* pgrx::datum::json::JsonB */ +) RETURNS TABLE ( + "table_name" TEXT, /* alloc::string::String */ + "rows" bigint /* i64 */ +) +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'load_dataset_wrapper'; + +-- src/api.rs:883 +-- pgml::api::load_all +DROP FUNCTION IF EXISTS pgml."load_all"(TEXT); +CREATE FUNCTION pgml."load_all"( + "path" TEXT /* &str */ +) RETURNS void +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'load_all_wrapper'; + +-- src/api.rs:611 +-- pgml::api::generate +DROP FUNCTION IF EXISTS pgml."generate"(TEXT, TEXT[], jsonb); +CREATE FUNCTION pgml."generate"( + "project_name" TEXT, /* &str */ + "inputs" TEXT[], /* alloc::vec::Vec<&str> */ + "config" jsonb DEFAULT '{}' /* pgrx::datum::json::JsonB */ +) RETURNS TEXT[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'generate_batch_wrapper'; + +-- src/api.rs:602 +-- pgml::api::generate +DROP FUNCTION IF EXISTS pgml."generate"(TEXT, TEXT, jsonb); +CREATE FUNCTION pgml."generate"( + "project_name" TEXT, /* &str */ + "inputs" TEXT, /* &str */ + "config" jsonb DEFAULT '{}' /* pgrx::datum::json::JsonB */ +) RETURNS TEXT /* alloc::string::String */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'generate_wrapper'; + +-- src/api.rs:567 +-- pgml::api::embed +DROP FUNCTION IF EXISTS pgml."embed"(TEXT, TEXT, jsonb); +CREATE FUNCTION pgml."embed"( + "transformer" TEXT, /* &str */ + "text" TEXT, /* &str */ + "kwargs" jsonb DEFAULT '{}' /* pgrx::datum::json::JsonB */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'embed_wrapper'; + +-- src/api.rs:845 +-- pgml::api::dump_all +DROP FUNCTION IF EXISTS pgml."dump_all"(TEXT); +CREATE FUNCTION pgml."dump_all"( + "path" TEXT /* &str */ +) RETURNS void +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'dump_all_wrapper'; + +-- src/vectors.rs:276 +-- pgml::vectors::dot_product +DROP FUNCTION IF EXISTS pgml."dot_product"(real[], real[]); +CREATE FUNCTION pgml."dot_product"( + "vector" real[], /* alloc::vec::Vec */ + "other" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'dot_product_s_wrapper'; + +-- src/vectors.rs:289 +-- pgml::vectors::dot_product +DROP FUNCTION IF EXISTS pgml."dot_product"(double precision[], double precision[]); +CREATE FUNCTION pgml."dot_product"( + "vector" double precision[], /* alloc::vec::Vec */ + "other" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision /* f64 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'dot_product_d_wrapper'; + +-- src/vectors.rs:104 +-- pgml::vectors::divide +DROP FUNCTION IF EXISTS pgml."divide"(real[], real[]); +CREATE FUNCTION pgml."divide"( + "vector" real[], /* alloc::vec::Vec */ + "dividend" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'divide_vector_s_wrapper'; + +-- src/vectors.rs:114 +-- pgml::vectors::divide +DROP FUNCTION IF EXISTS pgml."divide"(double precision[], double precision[]); +CREATE FUNCTION pgml."divide"( + "vector" double precision[], /* alloc::vec::Vec */ + "dividend" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'divide_vector_d_wrapper'; + +-- src/vectors.rs:34 +-- pgml::vectors::divide +DROP FUNCTION IF EXISTS pgml."divide"(real[], real); +CREATE FUNCTION pgml."divide"( + "vector" real[], /* alloc::vec::Vec */ + "dividend" real /* f32 */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'divide_scalar_s_wrapper'; + +-- src/vectors.rs:39 +-- pgml::vectors::divide +DROP FUNCTION IF EXISTS pgml."divide"(double precision[], double precision); +CREATE FUNCTION pgml."divide"( + "vector" double precision[], /* alloc::vec::Vec */ + "dividend" double precision /* f64 */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'divide_scalar_d_wrapper'; + +-- src/vectors.rs:254 +-- pgml::vectors::distance_l2 +DROP FUNCTION IF EXISTS pgml."distance_l2"(real[], real[]); +CREATE FUNCTION pgml."distance_l2"( + "vector" real[], /* alloc::vec::Vec */ + "other" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'distance_l2_s_wrapper'; + +-- src/vectors.rs:265 +-- pgml::vectors::distance_l2 +DROP FUNCTION IF EXISTS pgml."distance_l2"(double precision[], double precision[]); +CREATE FUNCTION pgml."distance_l2"( + "vector" double precision[], /* alloc::vec::Vec */ + "other" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision /* f64 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'distance_l2_d_wrapper'; + +-- src/vectors.rs:234 +-- pgml::vectors::distance_l1 +DROP FUNCTION IF EXISTS pgml."distance_l1"(real[], real[]); +CREATE FUNCTION pgml."distance_l1"( + "vector" real[], /* alloc::vec::Vec */ + "other" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'distance_l1_s_wrapper'; + +-- src/vectors.rs:244 +-- pgml::vectors::distance_l1 +DROP FUNCTION IF EXISTS pgml."distance_l1"(double precision[], double precision[]); +CREATE FUNCTION pgml."distance_l1"( + "vector" double precision[], /* alloc::vec::Vec */ + "other" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision /* f64 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'distance_l1_d_wrapper'; + +-- src/vectors.rs:302 +-- pgml::vectors::cosine_similarity +DROP FUNCTION IF EXISTS pgml."cosine_similarity"(real[], real[]); +CREATE FUNCTION pgml."cosine_similarity"( + "vector" real[], /* alloc::vec::Vec */ + "other" real[] /* alloc::vec::Vec */ +) RETURNS real /* f32 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'cosine_similarity_s_wrapper'; + +-- src/vectors.rs:318 +-- pgml::vectors::cosine_similarity +DROP FUNCTION IF EXISTS pgml."cosine_similarity"(double precision[], double precision[]); +CREATE FUNCTION pgml."cosine_similarity"( + "vector" double precision[], /* alloc::vec::Vec */ + "other" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision /* f64 */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'cosine_similarity_d_wrapper'; + +-- src/vectors.rs:44 +-- pgml::vectors::add +DROP FUNCTION IF EXISTS pgml."add"(real[], real[]); +CREATE FUNCTION pgml."add"( + "vector" real[], /* alloc::vec::Vec */ + "addend" real[] /* alloc::vec::Vec */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'add_vector_s_wrapper'; + +-- src/vectors.rs:54 +-- pgml::vectors::add +DROP FUNCTION IF EXISTS pgml."add"(double precision[], double precision[]); +CREATE FUNCTION pgml."add"( + "vector" double precision[], /* alloc::vec::Vec */ + "addend" double precision[] /* alloc::vec::Vec */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'add_vector_d_wrapper'; + +-- src/vectors.rs:4 +-- pgml::vectors::add +DROP FUNCTION IF EXISTS pgml."add"(real[], real); +CREATE FUNCTION pgml."add"( + "vector" real[], /* alloc::vec::Vec */ + "addend" real /* f32 */ +) RETURNS real[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'add_scalar_s_wrapper'; + +-- src/vectors.rs:9 +-- pgml::vectors::add +DROP FUNCTION IF EXISTS pgml."add"(double precision[], double precision); +CREATE FUNCTION pgml."add"( + "vector" double precision[], /* alloc::vec::Vec */ + "addend" double precision /* f64 */ +) RETURNS double precision[] /* alloc::vec::Vec */ +IMMUTABLE STRICT PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'add_scalar_d_wrapper'; + +-- src/api.rs:19 +-- pgml::api::activate_venv +DROP FUNCTION IF EXISTS pgml."activate_venv"(text); +CREATE FUNCTION pgml."activate_venv"( + "venv" TEXT /* &str */ +) RETURNS bool /* bool */ +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'activate_venv_wrapper'; + +-- src/api.rs:522 +-- pgml::api::snapshot +DROP FUNCTION IF EXISTS pgml."snapshot"(text, text, real, pgml.Sampling, jsonb); +CREATE FUNCTION pgml."snapshot"( + "relation_name" TEXT, /* &str */ + "y_column_name" TEXT, /* &str */ + "test_size" real DEFAULT 0.25, /* f32 */ + "test_sampling" pgml.Sampling DEFAULT 'last', /* pgml::orm::sampling::Sampling */ + "preprocess" jsonb DEFAULT '{}' /* pgrx::datum::json::JsonB */ +) RETURNS TABLE ( + "relation" TEXT, /* alloc::string::String */ + "y_column_name" TEXT /* alloc::string::String */ +) +STRICT +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'snapshot_wrapper'; + +-- src/api.rs:626 +-- pgml::api::tune +DROP FUNCTION IF EXISTS pgml."tune"(text, text, text, text, text, jsonb, real, pgml.Sampling, bool, bool); +CREATE FUNCTION pgml."tune"( + "project_name" TEXT, /* &str */ + "task" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "relation_name" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "y_column_name" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "model_name" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "hyperparams" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "test_size" real DEFAULT 0.25, /* f32 */ + "test_sampling" pgml.Sampling DEFAULT 'last', /* pgml::orm::sampling::Sampling */ + "automatic_deploy" bool DEFAULT true, /* core::option::Option */ + "materialize_snapshot" bool DEFAULT false /* bool */ +) RETURNS TABLE ( + "status" TEXT, /* alloc::string::String */ + "task" TEXT, /* alloc::string::String */ + "algorithm" TEXT, /* alloc::string::String */ + "deployed" bool /* bool */ +) +PARALLEL SAFE +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'tune_wrapper'; + +-- src/api.rs:115 +-- pgml::api::train +DROP FUNCTION IF EXISTS pgml."train"(text, text, text, text, pgml.Algorithm, jsonb, pgml.Search, jsonb, jsonb, real, pgml.Sampling, pgml.Runtime, bool, bool, jsonb); +CREATE FUNCTION pgml."train"( + "project_name" TEXT, /* &str */ + "task" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "relation_name" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "y_column_name" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "algorithm" pgml.Algorithm DEFAULT 'linear', /* pgml::orm::algorithm::Algorithm */ + "hyperparams" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "search" pgml.Search DEFAULT NULL, /* core::option::Option */ + "search_params" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "search_args" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "test_size" real DEFAULT 0.25, /* f32 */ + "test_sampling" pgml.Sampling DEFAULT 'last', /* pgml::orm::sampling::Sampling */ + "runtime" pgml.Runtime DEFAULT NULL, /* core::option::Option */ + "automatic_deploy" bool DEFAULT true, /* core::option::Option */ + "materialize_snapshot" bool DEFAULT false, /* bool */ + "preprocess" jsonb DEFAULT '{}' /* pgrx::datum::json::JsonB */ +) RETURNS TABLE ( + "project" TEXT, /* alloc::string::String */ + "task" TEXT, /* alloc::string::String */ + "algorithm" TEXT, /* alloc::string::String */ + "deployed" bool /* bool */ +) +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'train_wrapper'; + +-- src/api.rs:161 +-- pgml::api::train_joint +DROP FUNCTION IF EXISTS pgml."train_joint"(text, text, text, text[], pgml.Algorithm, jsonb, pgml.Search, jsonb, jsonb, real, pgml.Sampling, pgml.Runtime, bool, bool, jsonb); +CREATE FUNCTION pgml."train_joint"( + "project_name" TEXT, /* &str */ + "task" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "relation_name" TEXT DEFAULT NULL, /* core::option::Option<&str> */ + "y_column_name" TEXT[] DEFAULT NULL, /* core::option::Option> */ + "algorithm" pgml.Algorithm DEFAULT 'linear', /* pgml::orm::algorithm::Algorithm */ + "hyperparams" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "search" pgml.Search DEFAULT NULL, /* core::option::Option */ + "search_params" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "search_args" jsonb DEFAULT '{}', /* pgrx::datum::json::JsonB */ + "test_size" real DEFAULT 0.25, /* f32 */ + "test_sampling" pgml.Sampling DEFAULT 'last', /* pgml::orm::sampling::Sampling */ + "runtime" pgml.Runtime DEFAULT NULL, /* core::option::Option */ + "automatic_deploy" bool DEFAULT true, /* core::option::Option */ + "materialize_snapshot" bool DEFAULT false, /* bool */ + "preprocess" jsonb DEFAULT '{}' /* pgrx::datum::json::JsonB */ +) RETURNS TABLE ( + "project" TEXT, /* alloc::string::String */ + "task" TEXT, /* alloc::string::String */ + "algorithm" TEXT, /* alloc::string::String */ + "deployed" bool /* bool */ +) +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'train_joint_wrapper'; + +-- src/api.rs:317 +-- pgml::api::deploy +DROP FUNCTION IF EXISTS pgml."deploy"(text, pgml.Strategy, pgml.Algorithm); +CREATE FUNCTION pgml."deploy"( + "project_name" TEXT, /* &str */ + "strategy" pgml.Strategy, /* pgml::orm::strategy::Strategy */ + "algorithm" pgml.Algorithm DEFAULT NULL /* core::option::Option */ +) RETURNS TABLE ( + "project" TEXT, /* alloc::string::String */ + "strategy" TEXT, /* alloc::string::String */ + "algorithm" TEXT /* alloc::string::String */ +) +LANGUAGE c /* Rust */ +AS 'MODULE_PATHNAME', 'deploy_wrapper'; diff --git a/pgml-extension/src/api.rs b/pgml-extension/src/api.rs index af8c497c3..0ba04d466 100644 --- a/pgml-extension/src/api.rs +++ b/pgml-extension/src/api.rs @@ -21,7 +21,7 @@ pub fn activate_venv(venv: &str) -> bool { } #[cfg(feature = "python")] -#[pg_extern] +#[pg_extern(immutable, parallel_safe)] pub fn validate_python_dependencies() -> bool { crate::bindings::venv::activate(); @@ -105,7 +105,7 @@ pub fn python_version() -> String { String::from("Python is not installed, recompile with `--features python`") } -#[pg_extern] +#[pg_extern(immutable, parallel_safe)] fn version() -> String { crate::VERSION.to_string() } @@ -423,32 +423,32 @@ fn deploy( ) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_f32(project_name: &str, features: Vec) -> f32 { predict_model(Project::get_deployed_model_id(project_name), features) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_f64(project_name: &str, features: Vec) -> f32 { predict_f32(project_name, features.iter().map(|&i| i as f32).collect()) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_i16(project_name: &str, features: Vec) -> f32 { predict_f32(project_name, features.iter().map(|&i| i as f32).collect()) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_i32(project_name: &str, features: Vec) -> f32 { predict_f32(project_name, features.iter().map(|&i| i as f32).collect()) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_i64(project_name: &str, features: Vec) -> f32 { predict_f32(project_name, features.iter().map(|&i| i as f32).collect()) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_bool(project_name: &str, features: Vec) -> f32 { predict_f32( project_name, @@ -456,49 +456,49 @@ fn predict_bool(project_name: &str, features: Vec) -> f32 { ) } -#[pg_extern(strict, name = "predict_proba")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict_proba")] fn predict_proba(project_name: &str, features: Vec) -> Vec { predict_model_proba(Project::get_deployed_model_id(project_name), features) } -#[pg_extern(strict, name = "predict_joint")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict_joint")] fn predict_joint(project_name: &str, features: Vec) -> Vec { predict_model_joint(Project::get_deployed_model_id(project_name), features) } -#[pg_extern(strict, name = "predict_batch")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict_batch")] fn predict_batch(project_name: &str, features: Vec) -> SetOfIterator<'static, f32> { SetOfIterator::new( predict_model_batch(Project::get_deployed_model_id(project_name), features).into_iter(), ) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_row(project_name: &str, row: pgrx::datum::AnyElement) -> f32 { predict_model_row(Project::get_deployed_model_id(project_name), row) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_model(model_id: i64, features: Vec) -> f32 { Model::find_cached(model_id).predict(&features) } -#[pg_extern(strict, name = "predict_proba")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict_proba")] fn predict_model_proba(model_id: i64, features: Vec) -> Vec { Model::find_cached(model_id).predict_proba(&features) } -#[pg_extern(strict, name = "predict_joint")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict_joint")] fn predict_model_joint(model_id: i64, features: Vec) -> Vec { Model::find_cached(model_id).predict_joint(&features) } -#[pg_extern(strict, name = "predict_batch")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict_batch")] fn predict_model_batch(model_id: i64, features: Vec) -> Vec { Model::find_cached(model_id).predict_batch(&features) } -#[pg_extern(strict, name = "predict")] +#[pg_extern(immutable, parallel_safe, strict, name = "predict")] fn predict_model_row(model_id: i64, row: pgrx::datum::AnyElement) -> f32 { let model = Model::find_cached(model_id); let snapshot = &model.snapshot; @@ -563,13 +563,13 @@ fn load_dataset( TableIterator::new(vec![(name, rows)].into_iter()) } -#[pg_extern] +#[pg_extern(immutable, parallel_safe)] pub fn embed(transformer: &str, text: &str, kwargs: default!(JsonB, "'{}'")) -> Vec { crate::bindings::transformers::embed(transformer, &text, &kwargs.0) } #[cfg(feature = "python")] -#[pg_extern(name = "transform")] +#[pg_extern(immutable, parallel_safe, name = "transform")] pub fn transform_json( task: JsonB, args: default!(JsonB, "'{}'"), @@ -582,7 +582,7 @@ pub fn transform_json( } #[cfg(feature = "python")] -#[pg_extern(name = "transform")] +#[pg_extern(immutable, parallel_safe, name = "transform")] pub fn transform_string( task: String, args: default!(JsonB, "'{}'"), @@ -598,7 +598,7 @@ pub fn transform_string( } #[cfg(feature = "python")] -#[pg_extern(name = "generate")] +#[pg_extern(immutable, parallel_safe, name = "generate")] fn generate(project_name: &str, inputs: &str, config: default!(JsonB, "'{}'")) -> String { generate_batch(project_name, Vec::from([inputs]), config) .first() @@ -607,7 +607,7 @@ fn generate(project_name: &str, inputs: &str, config: default!(JsonB, "'{}'")) - } #[cfg(feature = "python")] -#[pg_extern(name = "generate")] +#[pg_extern(immutable, parallel_safe, name = "generate")] fn generate_batch( project_name: &str, inputs: Vec<&str>, @@ -622,7 +622,7 @@ fn generate_batch( #[cfg(feature = "python")] #[allow(clippy::too_many_arguments)] -#[pg_extern] +#[pg_extern(parallel_safe)] fn tune( project_name: &str, task: default!(Option<&str>, "NULL"), diff --git a/pgml-extension/src/vectors.rs b/pgml-extension/src/vectors.rs index 1ee72e57c..5f335a4db 100644 --- a/pgml-extension/src/vectors.rs +++ b/pgml-extension/src/vectors.rs @@ -333,13 +333,14 @@ fn cosine_similarity_d(vector: Vec, other: Vec) -> f64 { #[derive(Copy, Clone, Default, Debug)] pub struct SumS; -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for SumS { const NAME: &'static str = "sum"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -361,6 +362,7 @@ impl Aggregate for SumS { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -379,6 +381,7 @@ impl Aggregate for SumS { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -393,13 +396,14 @@ impl Aggregate for SumS { #[derive(Copy, Clone, Default, Debug)] pub struct SumD; -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for SumD { const NAME: &'static str = "sum"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -421,6 +425,7 @@ impl Aggregate for SumD { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -439,6 +444,7 @@ impl Aggregate for SumD { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -453,13 +459,14 @@ impl Aggregate for SumD { #[derive(Copy, Clone, Default, Debug)] pub struct MaxAbsS; -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for MaxAbsS { const NAME: &'static str = "max_abs"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -483,6 +490,7 @@ impl Aggregate for MaxAbsS { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -503,6 +511,7 @@ impl Aggregate for MaxAbsS { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -517,13 +526,14 @@ impl Aggregate for MaxAbsS { #[derive(Copy, Clone, Default, Debug)] pub struct MaxAbsD {} -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for MaxAbsD { const NAME: &'static str = "max_abs"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -547,6 +557,7 @@ impl Aggregate for MaxAbsD { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -567,6 +578,7 @@ impl Aggregate for MaxAbsD { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -581,13 +593,14 @@ impl Aggregate for MaxAbsD { #[derive(Copy, Clone, Default, Debug)] pub struct MaxS; -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for MaxS { const NAME: &'static str = "max"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -611,6 +624,7 @@ impl Aggregate for MaxS { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -631,6 +645,7 @@ impl Aggregate for MaxS { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -645,13 +660,14 @@ impl Aggregate for MaxS { #[derive(Copy, Clone, Default, Debug)] pub struct MaxD {} -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for MaxD { const NAME: &'static str = "max"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -675,6 +691,7 @@ impl Aggregate for MaxD { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -695,6 +712,7 @@ impl Aggregate for MaxD { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -709,13 +727,14 @@ impl Aggregate for MaxD { #[derive(Copy, Clone, Default, Debug)] pub struct MinS; -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for MinS { const NAME: &'static str = "min"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -739,6 +758,7 @@ impl Aggregate for MinS { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -759,6 +779,7 @@ impl Aggregate for MinS { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -773,13 +794,14 @@ impl Aggregate for MinS { #[derive(Copy, Clone, Default, Debug)] pub struct MinD {} -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for MinD { const NAME: &'static str = "min"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -803,6 +825,7 @@ impl Aggregate for MinD { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -823,6 +846,7 @@ impl Aggregate for MinD { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -837,13 +861,14 @@ impl Aggregate for MinD { #[derive(Copy, Clone, Default, Debug)] pub struct MinAbsS; -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for MinAbsS { const NAME: &'static str = "min_abs"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -867,6 +892,7 @@ impl Aggregate for MinAbsS { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -887,6 +913,7 @@ impl Aggregate for MinAbsS { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, @@ -901,13 +928,14 @@ impl Aggregate for MinAbsS { #[derive(Copy, Clone, Default, Debug)] pub struct MinAbsD {} -#[pg_aggregate] +#[pg_aggregate(parrallel_safe)] impl Aggregate for MinAbsD { const NAME: &'static str = "min_abs"; type Args = Option>; type State = Option>; type Finalize = Vec; + #[pgrx(immutable, parallel_safe)] fn state( mut current: Self::State, arg: Self::Args, @@ -931,6 +959,7 @@ impl Aggregate for MinAbsD { current } + #[pgrx(immutable, parallel_safe)] fn combine( mut first: Self::State, second: Self::State, @@ -951,6 +980,7 @@ impl Aggregate for MinAbsD { } } + #[pgrx(immutable, parallel_safe)] fn finalize( mut current: Self::State, _direct_arg: Self::OrderedSetArgs, pFad - Phonifier reborn

Pfad - The Proxy pFad of © 2024 Garber Painting. All rights reserved.

Note: This service is not intended for secure transactions such as banking, social media, email, or purchasing. Use at your own risk. We assume no liability whatsoever for broken pages.


Alternative Proxies:

Alternative Proxy

pFad Proxy

pFad v3 Proxy

pFad v4 Proxy