gqlite 1.3.1 → 1.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 38e53ea482654edda2dec42d18ba7aff7e5660f5643f80f66dfd966e21415ebd
-  data.tar.gz: ce0cb6a21adbca63605e86d753a3c20f281a2126601c5225c446d161efe97094
+  metadata.gz: 5aac591ce0775f004fc859b9cd453a940d39f9f80aa1535e2a37aae948b6baac
+  data.tar.gz: c66e83597f70d3c69ed412d5431530d1c2cc211507b68c18c7df74b65da017ef
 SHA512:
-  metadata.gz: f1b60e9c256da4300381ef244158ea61a464529e7518dfe1ee532c0e5ada468860ea08a5c0ab91304b00b5e09590774131fd7487d0bb79d2435d7c13009bd0e6
-  data.tar.gz: 4009f247ebcdc9519bfa40853b5ab8b32ab3c53fd365cf6f9dd3a25e395596dc70a2c12f7e795496695d8227428f37edfb1375cbcc59ac35e71a76ba973bd318
+  metadata.gz: 32503eae6aec73407846b1cce09f58374445473ef59122efe87280b4b756118d202199fc07da0b2ae7dd906f457997aac7b27d47eb17e490ce9c1a648c4e76cf
+  data.tar.gz: 95f14af4c49792144d5efa84ccc906c9d49ac065d808d927858d3d3a448ece3aa3137b1ece5057bb5b3534b301dd839e159a4fb745af0265efb352255c36d5c0

data/ext/Cargo.toml

@@ -3,19 +3,20 @@ resolver = "2"
 members = ["gqliterb", "gqlitedb", "graphcore"]
 
 [workspace.package]
-version = "0.6.0"
+version = "0.8.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://gqlite.org"
 repository = "https://gitlab.com/gqlite/gqlite"
 
 [workspace.dependencies]
-graphcore = { version = "0.2.0", path = "graphcore" }
-gqlitedb = { version = "0.6.0", path = "gqlitedb" }
+graphcore = { version = "0.8.0", path = "graphcore" }
+gqlitedb = { version = "0.8.0", path = "gqlitedb" }
 
-askama = { version = "0.14" }
+askama = { version = "0.15" }
 ccutils = { version = "0.4" }
 itertools = "0.14"
+rusqlite = { version = "0.37" }
 serde = "1"
 thiserror = "2"
 uuid = { version = "1", features = ["v4"] }

data/ext/gqlitedb/Cargo.toml

@@ -12,19 +12,19 @@ repository.workspace = true
 crate-type = ["cdylib", "lib"]
 
 [features]
-default = ["redb", "capi", "sqlite"]
+default = ["capi", "redb"]
 _backtrace = []
 capi = []
 redb = ["dep:redb", "dep:redb2"]
-_pgql = ["dep:pgrx"]
+_pgrx = ["dep:pgrx"]
 _pg13 = ["pgrx/pg13"]
 _pg14 = ["pgrx/pg14"]
 _pg15 = ["pgrx/pg15"]
 _pg16 = ["pgrx/pg16"]
 _pg17 = ["pgrx/pg17"]
+postgres = ["dep:postgres", "dep:askama"]
 sqlite = ["dep:rusqlite", "dep:askama"]
-_value_private = []
-bundled = ["rusqlite/bundled"]
+_cmake = ["postgres", "redb", "sqlite"]
 
 [dependencies]
 graphcore = { workspace = true }
@@ -33,13 +33,17 @@ askama = { workspace = true, optional = true }
 ccutils = { workspace = true, features = ["alias", "pool", "sync"] }
 ciborium = "0.2"
 itertools = { workspace = true }
-pgrx = { version = "0.16", optional = true }
 pest = "2"
 pest_derive = "2"
+pgrx = { version = "0.16", optional = true }
+postgres = { version = "0.19", optional = true, features = [
+  "with-uuid-1",
+  "with-serde_json-1",
+] }
 rand = "0.9"
 redb = { version = "3", optional = true }
 redb2 = { version = "2", optional = true, package = "redb" }
-rusqlite = { package = "rusqlite", version = "0.37", optional = true, features = [
+rusqlite = { workspace = true, optional = true, features = [
   "functions",
   "uuid",
 ] }
@@ -54,6 +58,9 @@ divan = "0.1"
 iai-callgrind = { version = "0.16" }
 regex = "1"
 
+[target.'cfg(not(windows))'.dev-dependencies]
+pgtemp = "0.7"
+
 # web:
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 # rusqlite_wasm = { package = "rusqlite", version = "0.37", optional = true, git = "https://github.com/Spxg/rusqlite.git", branch = "wasm-demo", features = [
@@ -68,6 +75,9 @@ uuid = { version = "1", features = ["js"] }
 #   "uuid",
 # ] }
 
+[target.'cfg(windows)'.dependencies]
+rusqlite = { workspace = true, features = ["bundled"] }
+
 [[bench]]
 name = "pokec_divan"
 harness = false

data/ext/gqlitedb/benches/common/pokec.rs

@@ -5,10 +5,15 @@ use gqlitedb::{value_map, Connection};
 use rand::{seq::IndexedRandom, Rng};
 use regex::Regex;
 
+/// Marker trait to keep backend-specific resources alive for the benchmark lifetime.
+trait BackendResource {}
+impl BackendResource for TemporaryFile {}
+impl BackendResource for pgtemp::PgTempDB {}
+
 pub(crate) struct Pokec
 {
   #[allow(dead_code)]
-  temporary_file: TemporaryFile,
+  file_handle: Box<dyn BackendResource>,
   connection: Connection,
   ids: Vec<i64>,
 }
@@ -28,17 +33,64 @@ impl Pokec
     {
       "sqlite" => gqlitedb::Backend::SQLite,
       "redb" => gqlitedb::Backend::Redb,
+      "postgres" => gqlitedb::Backend::Postgres,
       o => panic!("Unknown backend '{}'", o),
     };
-    let temporary_file = TemporaryFile::builder()
-      .should_create_file(false)
-      .label("gqlite_bench")
-      .create();
-    let connection = Connection::builder()
-      .path(temporary_file.path())
-      .backend(backend)
-      .create()
-      .unwrap();
+    let (file_handle, connection): (Box<dyn BackendResource>, _) = match backend
+    {
+      gqlitedb::Backend::Redb | gqlitedb::Backend::SQLite =>
+      {
+        let temporary_file = TemporaryFile::builder()
+          .should_create_file(false)
+          .label("gqlite_bench")
+          .create();
+        let connection = Connection::builder()
+          .path(temporary_file.path())
+          .backend(backend)
+          .create()
+          .unwrap();
+        (Box::new(temporary_file), connection)
+      }
+      gqlitedb::Backend::Postgres =>
+      {
+        use std::{
+          thread::sleep,
+          time::{Duration, Instant},
+        };
+        let output = std::process::Command::new("pg_config")
+          .arg("--bindir")
+          .output()
+          .expect("failed to execute pg_config");
+
+        let bin_path = String::from_utf8_lossy(&output.stdout).trim().to_string();
+
+        let db = pgtemp::PgTempDB::builder().with_bin_path(bin_path).start();
+
+        const MAX_WAIT: Duration = Duration::from_secs(30);
+        const INTERVAL: Duration = Duration::from_secs(1);
+
+        let deadline = Instant::now() + MAX_WAIT;
+
+        let mut connection = Connection::builder()
+          .set_option("url", db.connection_uri())
+          .backend(backend)
+          .create();
+        while connection.is_err() && Instant::now() < deadline
+        {
+          sleep(INTERVAL);
+          connection = Connection::builder()
+            .set_option("url", db.connection_uri())
+            .backend(backend)
+            .create()
+        }
+        let connection = connection.expect("Failed to connect to temporary Postgres DB within 30s");
+        (Box::new(db), connection)
+      }
+      gqlitedb::Backend::Automatic =>
+      {
+        panic!("Should not be selected.")
+      }
+    };
 
     let filename = match size
     {
@@ -52,7 +104,7 @@ impl Pokec
       .execute_oc_query(import_query, Default::default())
       .unwrap();
     Self {
-      temporary_file,
+      file_handle,
       connection,
       ids: Default::default(),
     }

data/ext/gqlitedb/benches/pokec_divan.rs

@@ -23,13 +23,13 @@ fn load_pokec(backend: &str) -> Pokec
 }
 
 // Import the tiny `pokec` dataset.
-#[divan::bench(args = ["sqlite", "redb"], sample_count = IMPORT_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = IMPORT_COUNT)]
 fn import_tiny_pokec(backend: &str)
 {
   let _ = load_pokec(backend);
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
 fn single_vertex(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -40,7 +40,7 @@ fn single_vertex(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = SINGLE_VERTEX_COUNT)]
 fn single_vertex_where(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -51,7 +51,7 @@ fn single_vertex_where(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn friend_of(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -62,7 +62,7 @@ fn friend_of(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn friend_of_filter(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -73,7 +73,7 @@ fn friend_of_filter(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn friend_of_friend_of(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -84,7 +84,7 @@ fn friend_of_friend_of(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn friend_of_friend_of_filter(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -95,7 +95,7 @@ fn friend_of_friend_of_filter(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
+#[divan::bench(args = ["postgres", "sqlite", "redb"], sample_count = FRIEND_OF_COUNT)]
 fn reciprocal_friends(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend).read_ids();
@@ -106,7 +106,7 @@ fn reciprocal_friends(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"])]
+#[divan::bench(args = ["postgres", "sqlite", "redb"])]
 fn aggregate_count(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend);
@@ -116,7 +116,7 @@ fn aggregate_count(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"])]
+#[divan::bench(args = ["postgres", "sqlite", "redb"])]
 fn aggregate_count_filter(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend);
@@ -126,7 +126,7 @@ fn aggregate_count_filter(bencher: Bencher, backend: &str)
   });
 }
 
-#[divan::bench(args = ["sqlite", "redb"])]
+#[divan::bench(args = ["postgres", "sqlite", "redb"])]
 fn aggregate_min_max_avg(bencher: Bencher, backend: &str)
 {
   let tiny_pokec = load_pokec(backend);

data/ext/gqlitedb/benches/pokec_iai.rs

@@ -18,6 +18,7 @@ fn load_with_ids(backend: &str) -> Pokec
 }
 
 #[library_benchmark]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn import_micro_pokec(backend: &str)
@@ -26,6 +27,7 @@ fn import_micro_pokec(backend: &str)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn single_vertex(micro_pokec: Pokec)
@@ -35,6 +37,7 @@ fn single_vertex(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn single_vertex_where(micro_pokec: Pokec)
@@ -44,6 +47,7 @@ fn single_vertex_where(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn friend_of(micro_pokec: Pokec)
@@ -53,6 +57,7 @@ fn friend_of(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn friend_of_filter(micro_pokec: Pokec)
@@ -62,6 +67,7 @@ fn friend_of_filter(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn friend_of_friend_of(micro_pokec: Pokec)
@@ -71,6 +77,7 @@ fn friend_of_friend_of(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn friend_of_friend_of_filter(micro_pokec: Pokec)
@@ -80,6 +87,7 @@ fn friend_of_friend_of_filter(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_with_ids)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn reciprocal_friends(micro_pokec: Pokec)
@@ -89,6 +97,7 @@ fn reciprocal_friends(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn aggregate_count(micro_pokec: Pokec)
@@ -97,6 +106,7 @@ fn aggregate_count(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn aggregate_count_filter(micro_pokec: Pokec)
@@ -105,6 +115,7 @@ fn aggregate_count_filter(micro_pokec: Pokec)
 }
 
 #[library_benchmark(setup = load_pokec)]
+#[bench::postgres("postgres")]
 #[bench::redb("redb")]
 #[bench::sqlite("sqlite")]
 fn aggregate_min_max_avg(micro_pokec: Pokec)

data/ext/gqlitedb/src/aggregators/arithmetic.rs

@@ -46,6 +46,7 @@ where
       | Value::Edge(..)
       | Value::Array(..)
       | Value::String(..)
+      | Value::TimeStamp(..)
       | Value::Map(..)
       | Value::Path(..) => Err(RunTimeError::InvalidBinaryOperands)?,
       Value::Null =>

data/ext/gqlitedb/src/aggregators/containers.rs

@@ -21,7 +21,10 @@ impl AggregatorState for CollectState
 {
   fn next(&mut self, value: Value) -> crate::Result<()>
   {
-    self.value.push(value);
+    if !value.is_null()
+    {
+      self.value.push(value);
+    }
     Ok(())
   }
   fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>

data/ext/gqlitedb/src/aggregators/stats.rs

@@ -144,3 +144,132 @@ impl AggregatorState for MaxState
 }
 
 super::declare_aggregator!(max, Max, MaxState, () -> i64);
+
+#[derive(Debug)]
+struct PercentileDiscState
+{
+  values: Vec<f64>,
+  percentile: f64,
+}
+
+impl PercentileDiscState
+{
+  fn new(percentile: value::Value) -> Result<Self>
+  {
+    Ok(Self {
+      values: Default::default(),
+      percentile: percentile.try_into()?,
+    })
+  }
+}
+
+impl AggregatorState for PercentileDiscState
+{
+  fn next(&mut self, value: value::Value) -> crate::Result<()>
+  {
+    if !value.is_null()
+    {
+      self.values.push(value.try_into()?);
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    if !self.percentile.is_finite() || !(0.0..=1.0).contains(&self.percentile)
+    {
+      return Err(
+        RunTimeError::NumberOutOfRange {
+          value: self.percentile,
+          min: 0.0,
+          max: 1.0,
+        }
+        .into(),
+      );
+    }
+
+    if self.values.is_empty()
+    {
+      return Ok(0.0.into());
+    }
+
+    let mut sorted = self.values;
+    sorted.sort_by(|a, b| a.total_cmp(b));
+
+    let n = sorted.len() as f64;
+    let index = (self.percentile * (n - 1.0)).round() as usize;
+
+    Ok(sorted[index].into())
+  }
+}
+
+super::declare_aggregator!(percentiledisc, PercentileDisc, PercentileDiscState, (value::Value) -> f64);
+
+#[derive(Debug)]
+struct PercentileContState
+{
+  values: Vec<f64>,
+  percentile: f64,
+}
+
+impl PercentileContState
+{
+  fn new(percentile: value::Value) -> Result<Self>
+  {
+    Ok(Self {
+      values: Default::default(),
+      percentile: percentile.try_into()?,
+    })
+  }
+}
+
+impl AggregatorState for PercentileContState
+{
+  fn next(&mut self, value: value::Value) -> crate::Result<()>
+  {
+    if !value.is_null()
+    {
+      self.values.push(value.try_into()?);
+    }
+    Ok(())
+  }
+  fn finalise(self: Box<Self>) -> crate::Result<crate::value::Value>
+  {
+    if !self.percentile.is_finite() || !(0.0..=1.0).contains(&self.percentile)
+    {
+      return Err(
+        RunTimeError::NumberOutOfRange {
+          value: self.percentile,
+          min: 0.0,
+          max: 1.0,
+        }
+        .into(),
+      );
+    }
+
+    if self.values.is_empty()
+    {
+      return Ok(0.0.into());
+    }
+
+    let mut sorted = self.values;
+    sorted.sort_by(|a, b| a.total_cmp(b));
+
+    let n = sorted.len() as f64;
+    let pos = self.percentile * (n - 1.0);
+    let lower_index = pos.floor() as usize;
+    let upper_index = lower_index + 1;
+
+    if lower_index >= sorted.len() - 1
+    {
+      return Ok(sorted[sorted.len() - 1].into());
+    }
+
+    let weight = pos - pos.floor();
+    let lower = sorted[lower_index];
+    let upper = sorted[upper_index];
+
+    Ok((lower + weight * (upper - lower)).into())
+  }
+}
+
+super::declare_aggregator!(percentilecont, PercentileCont, PercentileContState, (value::Value) -> f64);

data/ext/gqlitedb/src/aggregators.rs

@@ -69,6 +69,8 @@ pub(crate) fn init_aggregators() -> std::collections::HashMap<String, Aggregator
     stats::Avg::create(),
     stats::Min::create(),
     stats::Max::create(),
+    stats::PercentileDisc::create(),
+    stats::PercentileCont::create(),
   ]
   .into()
 }

data/ext/gqlitedb/src/compiler/expression_analyser.rs

@@ -21,6 +21,7 @@ pub(crate) enum ExpressionType
   Float,
   Path,
   String,
+  TimeStamp,
   Variant,
 }
 
@@ -419,6 +420,7 @@ impl<'b> Analyser<'b>
           value::Value::Map(_) => ExpressionType::Map,
           value::Value::Path(_) => ExpressionType::Path,
           value::Value::String(_) => ExpressionType::String,
+          value::Value::TimeStamp(_) => ExpressionType::TimeStamp,
         },
         true,
         false,

data/ext/gqlitedb/src/compiler.rs

@@ -942,6 +942,7 @@ pub(crate) fn compile(
       {
         ast::Statement::CreateGraph(create_graph) => Ok(Block::CreateGraph {
           name: create_graph.name.to_owned(),
+          if_not_exists: create_graph.if_not_exists,
         }),
         ast::Statement::DropGraph(drop_graph) => Ok(Block::DropGraph {
           name: drop_graph.name.to_owned(),

data/ext/gqlitedb/src/connection.rs

@@ -4,16 +4,20 @@ use crate::{prelude::*, QueryResult};
 use value::ValueTryIntoRef;
 
 /// Backend
+#[derive(Debug, Clone, Copy)]
 pub enum Backend
 {
   /// Select the first available backend.
   Automatic,
-  /// SQLite backend.
-  #[cfg(feature = "sqlite")]
-  SQLite,
+  /// Postgres backend.
+  #[cfg(feature = "postgres")]
+  Postgres,
   /// Redb backend.
   #[cfg(feature = "redb")]
   Redb,
+  /// SQLite backend.
+  #[cfg(feature = "sqlite")]
+  SQLite,
 }
 
 /// Builder with high-level API for creating connection.
@@ -25,12 +29,16 @@ pub struct ConnectionBuilder
 impl ConnectionBuilder
 {
   /// Merge options. This might overwrite value from the builder
-  pub fn options(mut self, options: value::ValueMap) -> Self
+  pub fn options(mut self, options: impl Into<value::ValueMap>) -> Self
   {
-    for (k, v) in options.into_iter()
-    {
-      self.map.insert(k, v);
-    }
+    let mut options = options.into();
+    self.map.extend(options.drain());
+    self
+  }
+  /// Set the option value for the given key.
+  pub fn set_option(mut self, key: impl Into<String>, value: impl Into<value::Value>) -> Self
+  {
+    self.map.insert(key.into(), value.into());
     self
   }
   /// Set path
@@ -52,16 +60,21 @@ impl ConnectionBuilder
       {
         self.map.insert(key, "automatic".into());
       }
-      #[cfg(feature = "sqlite")]
-      Backend::SQLite =>
+      #[cfg(feature = "postgres")]
+      Backend::Postgres =>
       {
-        self.map.insert(key, "sqlite".into());
+        self.map.insert(key, "postgres".into());
       }
       #[cfg(feature = "redb")]
       Backend::Redb =>
       {
         self.map.insert(key, "redb".into());
       }
+      #[cfg(feature = "sqlite")]
+      Backend::SQLite =>
+      {
+        self.map.insert(key, "sqlite".into());
+      }
     }
     self
   }
@@ -204,7 +217,7 @@ impl Connection
 
             sq_r.map_err(|rb_e| {
               StoreError::OpeningError {
-                errors: error::vec_to_error(&vec![sq_e, rb_e]),
+                errors: error::vec_to_error(&[sq_e, rb_e]),
               }
               .into()
             })
@@ -251,6 +264,38 @@ impl Connection
           .boxed(),
         })
       }
+      #[cfg(feature = "postgres")]
+      "postgres" =>
+      {
+        let mut config = postgres::Config::new();
+        if let Some(url) = options.get("url")
+        {
+          config = url.to_string().parse()?;
+        }
+        if let Some(host) = options.get("host")
+        {
+          let host: &String = host.try_into_ref()?;
+          config.host(host);
+        }
+        if let Some(user) = options.get("user")
+        {
+          let user: &String = user.try_into_ref()?;
+          config.user(user);
+        }
+        if let Some(password) = options.get("password")
+        {
+          let password: &String = password.try_into_ref()?;
+          config.password(password);
+        }
+        let store = store::postgres::Store::connect(config)?;
+        Ok(Connection {
+          connection: ConnectionImpl {
+            store,
+            function_manager: functions::Manager::new(),
+          }
+          .boxed(),
+        })
+      }
       _ => Err(StoreError::UnknownBackend { backend }.into()),
     }
   }