gqlite 1.2.2 → 1.2.3

data/ext/gqliterb/vendor/gqlitedb/src/interpreter/evaluators.rs

@@ -16,18 +16,6 @@ enum Value
   EdgeQuery(store::SelectEdgeQuery),
 }
 
-impl Value
-{
-  fn is_null(&self) -> bool
-  {
-    match self
-    {
-      Value::GraphValue(gv) => gv.is_null(),
-      _ => false,
-    }
-  }
-}
-
 impl<T> From<T> for Value
 where
   T: Into<value::Value>,
@@ -659,10 +647,6 @@ fn eval_instructions(
         stack.push(a);
         stack.push(b);
       }
-      &instructions::Instruction::Drop =>
-      {
-        stack.try_pop()?;
-      }
       &instructions::Instruction::AndBinaryOperator
       | &instructions::Instruction::OrBinaryOperator
       | &instructions::Instruction::XorBinaryOperator =>
@@ -803,6 +787,10 @@ fn eval_instructions(
       {
         execute_binary_operator(stack, |a, b| a % b)?;
       }
+      &instructions::Instruction::ExponentBinaryOperator =>
+      {
+        execute_binary_operator(stack, |a, b| a.pow(b))?;
+      }
     }
   }
   Ok(())
@@ -874,8 +862,6 @@ pub(crate) fn eval_update_property<TStore: store::Store>(
   Ok(())
 }
 
-struct OrderByKey(Vec<(value::Value, bool)>);
-
 fn handle_asc(o: std::cmp::Ordering, asc: bool) -> std::cmp::Ordering
 {
   if asc
@@ -893,18 +879,6 @@ fn handle_asc(o: std::cmp::Ordering, asc: bool) -> std::cmp::Ordering
   }
 }
 
-fn compute_order_by(
-  a: &Vec<(value::Value, bool)>,
-  b: &Vec<(value::Value, bool)>,
-) -> std::cmp::Ordering
-{
-  a.iter()
-    .zip(b.iter())
-    .map(|(a, b)| handle_asc(a.0.orderability(&b.0), a.1))
-    .find(|p| *p != std::cmp::Ordering::Equal)
-    .unwrap_or(std::cmp::Ordering::Equal)
-}
-
 #[derive(Debug, Default, Clone, Hash, PartialEq)]
 struct RowKey(value_table::Row);
 
@@ -1012,8 +986,8 @@ fn compute_return_with_table(
       }
     }
 
-    // Aggregation always return at least once
-    if aggregation_table.is_empty()
+    // Aggregation always return at least once, unless there is a non-aggregated value
+    if aggregation_table.is_empty() && variables.iter().all(|v| v.aggregations.len() > 0)
     {
       let row = Row::new(Default::default(), variables_sizes.total_size());
       let aggregations_states = create_aggregations_states(&variables, parameters)?;
@@ -1024,6 +998,7 @@ fn compute_return_with_table(
 
     for (row, aggregations_states) in aggregation_table
     {
+      let mut non_null_aggregation = false;
       let mut out_row = value_table::Row::new(Default::default(), variables_sizes.total_size());
       for (idx, (rw_expr, aggregation_states)) in variables
         .iter()
@@ -1038,7 +1013,9 @@ fn compute_return_with_table(
         {
           for (name, s) in aggregation_states.into_iter()
           {
-            out_row.set(name, s.finalise()?)?;
+            let value = s.finalise()?;
+            non_null_aggregation = non_null_aggregation | !value.is_null();
+            out_row.set(name, value)?;
           }
           let mut stack = Stack::default();
           eval_instructions(&mut stack, &out_row, &rw_expr.instructions, &parameters)?;
@@ -1201,6 +1178,7 @@ fn is_write_program(program: &super::Program) -> bool
     | Block::Call { .. }
     | Block::With { .. } => false,
     Block::CreateGraph { .. }
+    | Block::DropGraph { .. }
     | Block::Create { .. }
     | Block::Update { .. }
     | Block::Delete { .. } => true,
@@ -1245,6 +1223,16 @@ pub(crate) fn eval_program<TStore: store::Store>(
             } ))?;
         graph_name = name.to_owned();
       }
+      instructions::Block::DropGraph { name, if_exists } =>
+      {
+        store
+          .drop_graph(&mut tx, name, *if_exists)
+          .map_err(|e|
+            error::map_error!(e, Error::StoreError(StoreError::UnknownGraph { graph_name }) => RunTimeError::UnknownGraph {
+              graph_name: graph_name.clone(),
+            } ))?;
+        graph_name = name.to_owned();
+      }
       instructions::Block::UseGraph { name } =>
       {
         graph_name = name.to_owned();

data/ext/gqliterb/vendor/gqlitedb/src/interpreter/instructions.rs

@@ -58,7 +58,6 @@ pub(crate) enum Instruction
   Rot3,        // If a is the top of the stack, then a b c -> b c a
   InverseRot3, // If a is the top of the stack, then a b c -> c a b
   Swap,
-  Drop,
   AndBinaryOperator,
   OrBinaryOperator,
   XorBinaryOperator,
@@ -78,6 +77,7 @@ pub(crate) enum Instruction
   MultiplicationBinaryOperator,
   DivisionBinaryOperator,
   ModuloBinaryOperator,
+  ExponentBinaryOperator,
 }
 
 pub(crate) type Instructions = Vec<Instruction>;
@@ -208,6 +208,10 @@ pub(crate) enum Block
   {
     name: String
   },
+  DropGraph
+  {
+    name: String, if_exists: bool
+  },
   UseGraph
   {
     name: String
@@ -233,6 +237,7 @@ pub(crate) enum Block
   },
   Call
   {
+    #[allow(dead_code)]
     arguments: Instructions,
     name: String,
   },

data/ext/gqliterb/vendor/gqlitedb/src/lib.rs

@@ -7,7 +7,6 @@
 //! for an example of use.
 
 #![warn(missing_docs)]
-#![allow(dead_code)]
 #![deny(warnings)]
 
 mod aggregators;
@@ -35,7 +34,7 @@ pub use {
   connection::Connection,
   error::{CompileTimeError, Error, RunTimeError, StoreError},
   graph::{Edge, Node, Path},
-  value::{Value, ValueMap},
+  value::{Value, ValueMap, ValueTryIntoRef},
 };
 
 /// GQLite Result alias. Usable as a standard `Result<T, E>` or default to gqlite::Error with `Result<T>`

data/ext/gqliterb/vendor/gqlitedb/src/parser/ast.rs

@@ -95,6 +95,7 @@ impl VariableIdentifiers
 pub(crate) enum Statement
 {
   CreateGraph(CreateGraph),
+  DropGraph(DropGraph),
   UseGraph(UseGraph),
   Create(Create),
   Match(Match),
@@ -122,12 +123,16 @@ pub(crate) type Statements = Vec<Statement>;
 pub(crate) type Queries = Vec<Statements>;
 
 #[derive(Debug)]
-pub(crate) enum Node {}
+pub(crate) struct CreateGraph
+{
+  pub(crate) name: String,
+}
 
 #[derive(Debug)]
-pub(crate) struct CreateGraph
+pub(crate) struct DropGraph
 {
   pub(crate) name: String,
+  pub(crate) if_exists: bool,
 }
 
 #[derive(Debug)]
@@ -198,18 +203,11 @@ pub(crate) struct Update
   pub(crate) updates: Vec<OneUpdate>,
 }
 
-#[derive(Debug)]
-pub(crate) struct Remove
-{
-  pub(crate) expressions: Vec<Expression>,
-}
-
 #[derive(Debug)]
 pub(crate) struct Call
 {
   pub(crate) name: String,
   pub(crate) arguments: Vec<Expression>,
-  pub(crate) yield_: Vec<String>,
 }
 
 // Set/remove Statements
@@ -294,6 +292,7 @@ pub(crate) enum Expression
   Multiplication(Box<Multiplication>),
   Division(Box<Division>),
   Modulo(Box<Modulo>),
+  Exponent(Box<Exponent>),
 
   Negation(Box<Negation>),
   LogicalNegation(Box<LogicalNegation>),
@@ -350,6 +349,7 @@ pub(crate) struct PathPattern
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) enum LabelExpression
 {
+  #[allow(dead_code)]
   Not(Box<LabelExpression>),
   And(Vec<Box<LabelExpression>>),
   Or(Vec<Box<LabelExpression>>),
@@ -421,10 +421,6 @@ impl LabelExpression
       },
     }
   }
-  fn clone_boxed(&self) -> Box<LabelExpression>
-  {
-    self.clone().boxed()
-  }
   pub(crate) fn boxed(self) -> Box<LabelExpression>
   {
     Box::new(self)
@@ -530,12 +526,6 @@ pub(crate) struct RangeAccess
   pub(crate) start: Option<Expression>,
   pub(crate) end: Option<Expression>,
 }
-#[derive(Debug)]
-pub(crate) struct HasLabels
-{
-  pub(crate) left: String,
-  pub(crate) labels: Vec<String>,
-}
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct FunctionCall
@@ -576,6 +566,7 @@ create_binary_op! {Subtraction}
 create_binary_op! {Multiplication}
 create_binary_op! {Division}
 create_binary_op! {Modulo}
+create_binary_op! {Exponent}
 
 macro_rules! create_unary_op {
   ( $x:tt ) => {
@@ -595,11 +586,6 @@ create_unary_op! {IsNotNull}
 
 // Values
 
-#[derive(Debug)]
-pub(crate) struct All {}
-#[derive(Debug)]
-pub(crate) struct EndOfList {}
-
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct Value
 {

data/ext/gqliterb/vendor/gqlitedb/src/parser/gql.pest

@@ -64,6 +64,8 @@ where_modifier = { "WHERE" ~ expression }
 // Statements
 statement = {
     create_graph_statement
+  | drop_graph_if_exists_statement
+  | drop_graph_statement
   | use_graph_statement
   | create_statement
   | optional_match_statement
@@ -81,6 +83,8 @@ statement = {
 star = { "*" }
 
 create_graph_statement   = { "CREATE" ~ "GRAPH" ~ ident }
+drop_graph_statement     = { "DROP" ~ "GRAPH" ~ ident }
+drop_graph_if_exists_statement     = { "DROP" ~ "GRAPH" ~ "IF" ~ "EXISTS" ~ ident }
 use_graph_statement      = { "USE" ~ ident }
 
 create_statement         = { "CREATE" ~ node_or_edge_pattern ~ ("," ~ node_or_edge_pattern)* }
@@ -121,7 +125,7 @@ remove_member_access =  { (("(" ~ ident ~ ")") | ident) ~ ("." ~ ident)+ }
 
 expression = { prefix* ~ expression_term ~ postfix* ~ (infix ~ prefix? ~ expression_term ~ postfix*)* }
 
-infix   = _{ addition | subtraction | multiplication | division | modulo | or | and | xor | equal | different | in_ | not_in | superior_equal | inferior_equal | superior | inferior }
+infix   = _{ addition | subtraction | multiplication | division | modulo | exponent | or | and | xor | equal | different | in_ | not_in | superior_equal | inferior_equal | superior | inferior }
 postfix = _{ is_null | is_not_null | member_access | range_access | range_access_to | index_access }
 prefix  = _{ negation | not }
 
@@ -130,6 +134,7 @@ subtraction    = { "-" }
 multiplication = { "*" }
 division       = { "/" }
 modulo         = { "%" }
+exponent       = { "^" }
 
 xor_kw         = @{ "XOR" ~ !ASCII_ALPHA }
 xor            =  { xor_kw }
@@ -164,8 +169,8 @@ label_check_expression = { ident ~ (":" ~ ident)+ }
 parenthesised_expression = { "(" ~ expression ~ ")" }
 named_expression         = { (expression ~ "AS" ~ ident) | expression }
 function_call            = { function_name ~ "(" ~ (expression ~ ("," ~ expression)*)? ~ ")" }
-count_star               = { "count" ~ "(" ~ "*" ~ ")" }
-expression_term          = { null_lit | true_lit | false_lit | num | hexa_int | octa_int | int | string_literal | map | array | label_check_expression | parameter | parenthesised_expression | function_call | count_star | ident }
+function_star            = { function_name ~ "(" ~ "*" ~ ")" }
+expression_term          = { null_lit | true_lit | false_lit | num | hexa_int | octa_int | int | string_literal | map | array | label_check_expression | parameter | parenthesised_expression | function_call | function_star | ident }
 
 parameter = { "$" ~ parameter_name }
 

data/ext/gqliterb/vendor/gqlitedb/src/parser/parser.rs

@@ -197,6 +197,13 @@ impl AstBuilder
           }
           .into(),
         ),
+        Rule::exponent => Ok(
+          ast::Exponent {
+            left: lhs?,
+            right: rhs?,
+          }
+          .into(),
+        ),
         Rule::or => Ok(
           ast::LogicalOr {
             left: lhs?,
@@ -360,10 +367,25 @@ impl AstBuilder
                 .collect::<Result<_>>()?,
             }))
           }
-          Rule::count_star => Ok(ast::Expression::FunctionCall(ast::FunctionCall {
-            name: "count".into(),
-            arguments: vec![ast::Expression::Value(ast::Value { value: 0.into() })],
-          })),
+          Rule::function_star =>
+          {
+            let mut it = pair.into_inner();
+            let function_name = it
+              .next()
+              .ok_or_else(|| error::InternalError::MissingFunctionName)?
+              .as_str();
+            if function_name.to_lowercase() != "count"
+            {
+              Err(error::CompileTimeError::UnknownFunction {
+                name: function_name.to_owned(),
+              })?;
+            }
+
+            Ok(ast::Expression::FunctionCall(ast::FunctionCall {
+              name: "count".into(),
+              arguments: vec![ast::Expression::Value(ast::Value { value: 0.into() })],
+            }))
+          }
           Rule::parenthesised_expression =>
           {
             let mut it = pair.into_inner();
@@ -874,6 +896,14 @@ impl AstBuilder
       Rule::create_graph_statement => Ok(ast::Statement::CreateGraph(ast::CreateGraph {
         name: self.build_ident(&mut pair.into_inner())?,
       })),
+      Rule::drop_graph_statement => Ok(ast::Statement::DropGraph(ast::DropGraph {
+        name: self.build_ident(&mut pair.into_inner())?,
+        if_exists: false,
+      })),
+      Rule::drop_graph_if_exists_statement => Ok(ast::Statement::DropGraph(ast::DropGraph {
+        name: self.build_ident(&mut pair.into_inner())?,
+        if_exists: true,
+      })),
       Rule::use_graph_statement => Ok(ast::Statement::UseGraph(ast::UseGraph {
         name: self.build_ident(&mut pair.into_inner())?,
       })),
@@ -1054,7 +1084,6 @@ impl AstBuilder
         Ok(ast::Statement::Call(ast::Call {
           name: name,
           arguments: Default::default(),
-          yield_: Default::default(),
         }))
       }
       unknown_expression => Err(
@@ -1086,7 +1115,8 @@ pub(crate) fn parse(input: &str) -> Result<ast::Queries>
     .op(
       Op::infix(Rule::multiplication, Assoc::Left)
         | Op::infix(Rule::division, Assoc::Left)
-        | Op::infix(Rule::modulo, Assoc::Left),
+        | Op::infix(Rule::modulo, Assoc::Left)
+        | Op::infix(Rule::exponent, Assoc::Left),
     )
     .op(Op::prefix(Rule::not) | Op::prefix(Rule::negation))
     .op(

data/ext/gqliterb/vendor/gqlitedb/src/store/redb.rs

@@ -164,21 +164,6 @@ impl EdgeIdResult
 //   | | (_| | |_) | |  __/
 //   |_|\__,_|_.__/|_|\___|
 
-trait NodeTableExtension
-{
-  fn get_node(&self, key: graph::Key) -> Result<graph::Node>;
-}
-
-impl<'txn> NodeTableExtension for redb::Table<'txn, graph::Key, &[u8]>
-{
-  fn get_node(&self, key: graph::Key) -> Result<graph::Node>
-  {
-    let v = self.get_required(key, || InternalError::UnknownNode)?;
-    let c = ciborium::from_reader::<graph::Node, &[u8]>(&mut v.value())?;
-    Ok::<graph::Node, crate::prelude::ErrorType>(c)
-  }
-}
-
 trait TableExtension<K, V>
 where
   K: redb::Key + 'static,
@@ -188,7 +173,7 @@ where
     &self,
     key: impl std::borrow::Borrow<K::SelfType<'a>>,
     f: impl FnOnce() -> TError,
-  ) -> Result<redb::AccessGuard<V>>;
+  ) -> Result<redb::AccessGuard<'_, V>>;
 }
 
 impl<'txn, K, V, T> TableExtension<K, V> for T
@@ -201,7 +186,7 @@ where
     &self,
     key: impl std::borrow::Borrow<K::SelfType<'a>>,
     f: impl FnOnce() -> TError,
-  ) -> Result<redb::AccessGuard<V>>
+  ) -> Result<redb::AccessGuard<'_, V>>
   {
     self.get(key)?.ok_or_else(|| f().into())
   }
@@ -217,6 +202,7 @@ where
 #[derive(Debug)]
 struct GraphInfo
 {
+  #[allow(dead_code)]
   name: String,
   nodes_table: String,
   edges_table: String,
@@ -314,19 +300,36 @@ type TransactionBox = store::TransactionBox<redb::ReadTransaction, redb::WriteTr
 impl Store
 {
   /// Crate a new store, with a default graph
-  pub(crate) fn new<P: AsRef<std::path::Path>>(path: P) -> Result<Store>
+  pub(crate) fn open<P: AsRef<std::path::Path>>(path: P) -> Result<Store>
   {
     let s = Self {
       redb_store: redb::Database::create(path.as_ref())?,
       graphs: Default::default(),
     };
+    s.initialise()?;
+    Ok(s)
+  }
+  /// Crate a new store, with a default graph, in memory
+  pub(crate) fn in_memory() -> Result<Store>
+  {
+    let s = Self {
+      redb_store: redb::Database::builder()
+        .create_with_backend(redb::backends::InMemoryBackend::new())?,
+      graphs: Default::default(),
+    };
+    s.initialise()?;
+    Ok(s)
+  }
+  fn initialise(&self) -> Result<()>
+  {
     use crate::store::Store;
-    let mut tx = s.begin_write()?;
-    s.create_graph(&mut tx, &"default".to_string(), true)?;
-    s.set_metadata_value(&mut tx, "version", &consts::GQLITE_VERSION)?;
+    let mut tx = self.begin_write()?;
+    self.create_graph(&mut tx, &"default".to_string(), true)?;
+    self.set_metadata_value(&mut tx, "version", &consts::GQLITE_VERSION)?;
     tx.close()?;
-    Ok(s)
+    Ok(())
   }
+  #[allow(dead_code)]
   fn get_metadata_from_table<TTable, TValue>(
     &self,
     table: TTable,
@@ -342,6 +345,7 @@ impl Store
       .ok_or_else(|| InternalError::MissingMetadata { key: key })?;
     Ok(ciborium::from_reader(value.value().as_slice())?)
   }
+  #[allow(dead_code)]
   fn get_metadata_value<T: for<'a> Deserialize<'a>>(
     &self,
     transaction: &mut TransactionBox,
@@ -829,8 +833,12 @@ impl store::Store for Store
 
     Ok(())
   }
-  fn delete_graph(&self, transaction: &mut Self::TransactionBox, graph_name: &String)
-    -> Result<()>
+  fn drop_graph(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &String,
+    if_exists: bool,
+  ) -> Result<()>
   {
     let mut graphs_list = self.graphs_list(transaction)?;
     if graphs_list.contains(graph_name)
@@ -848,6 +856,10 @@ impl store::Store for Store
 
       Ok(())
     }
+    else if if_exists
+    {
+      Ok(())
+    }
     else
     {
       Err(

data/ext/gqliterb/vendor/gqlitedb/src/store/sqlite.rs

@@ -1,5 +1,7 @@
 use std::{cell::RefCell, collections::HashSet, path::PathBuf};
 
+use rusqlite;
+
 use askama::Template;
 use ccutils::pool::{self, Pool};
 use rusqlite::{named_params, types::FromSql, OptionalExtension, ToSql};
@@ -264,35 +266,55 @@ ccutils::assert_impl_all!(Store: Sync, Send);
 impl Store
 {
   /// Crate a new store, with a default graph
-  pub(crate) fn new<P: AsRef<std::path::Path>>(path: P) -> Result<Store>
+  pub(crate) fn open<P: AsRef<std::path::Path>>(path: P) -> Result<Store>
   {
-    use store::Store;
     let path: PathBuf = path.as_ref().into();
     let connection = Pool::new(
       move || Ok(rusqlite::Connection::open(&path)?),
       pool::Options::default().minimum_pool_size(1).pool_size(3),
     )?;
     let s = Self { connection };
-
-    let mut tx = s.begin_write()?;
-    if s.check_if_table_exists(&mut tx, "gqlite_metadata")?
+    s.initialise()?;
+    Ok(s)
+  }
+  pub(crate) fn in_memory() -> Result<Store>
+  {
+    let id = uuid::Uuid::new_v4().as_u128();
+    let connection = Pool::new(
+      move || {
+        Ok(rusqlite::Connection::open_with_flags(
+          format!("file:{}?mode=memory&cache=shared", id),
+          rusqlite::OpenFlags::default(),
+        )?)
+      },
+      pool::Options::default().minimum_pool_size(1).pool_size(3),
+    )?;
+    let s = Self { connection };
+    s.initialise()?;
+    Ok(s)
+  }
+  fn initialise(&self) -> Result<()>
+  {
+    use store::Store;
+    let mut tx = self.begin_write()?;
+    if self.check_if_table_exists(&mut tx, "gqlite_metadata")?
     {
       // gqlite version 1.1 incorrectly use ' instead of " in the version number
-      let version_raw = s
+      let version_raw = self
         .get_metadata_value::<String>(&mut tx, "version")?
         .replace("'", "\"");
       let version: utils::Version = serde_json::from_str(&version_raw)?;
       if version.major != consts::GQLITE_VERSION.major
         || version.minor != consts::GQLITE_VERSION.minor
       {
-        s.upgrade_database(&mut tx, version)?;
+        self.upgrade_database(&mut tx, version)?;
       }
     }
-    else if !s.check_if_table_exists(&mut tx, "gqlite_metadata")?
-      && s.check_if_table_exists(&mut tx, "gqlite_default_nodes")?
+    else if !self.check_if_table_exists(&mut tx, "gqlite_metadata")?
+      && self.check_if_table_exists(&mut tx, "gqlite_default_nodes")?
     {
       // 1.0 didn't have the metadata table
-      s.upgrade_database(
+      self.upgrade_database(
         &mut tx,
         utils::Version {
           major: 1,
@@ -307,12 +329,12 @@ impl Store
         include_str!("../../templates/sql/sqlite/metadata_create_table.sql"),
         (),
       )?;
-      s.set_metadata_value_json(&mut tx, "graphs", &Vec::<String>::new())?;
-      s.create_graph(&mut tx, &"default".to_string(), true)?;
+      self.set_metadata_value_json(&mut tx, "graphs", &Vec::<String>::new())?;
+      self.create_graph(&mut tx, &"default".to_string(), true)?;
     }
-    s.set_metadata_value_json(&mut tx, "version", &consts::GQLITE_VERSION)?;
+    self.set_metadata_value_json(&mut tx, "version", &consts::GQLITE_VERSION)?;
     tx.close()?;
-    Ok(s)
+    Ok(())
   }
   fn upgrade_database(&self, transaction: &mut TransactionBox, from: utils::Version) -> Result<()>
   {
@@ -394,6 +416,7 @@ impl Store
       |row| row.get(0),
     )?)
   }
+  #[allow(dead_code)]
   pub(crate) fn get_metadata_value_or_else<T: FromSql>(
     &self,
     transaction: &mut TransactionBox,
@@ -437,6 +460,7 @@ impl Store
       &self.get_metadata_value::<String>(transaction, key)?,
     )?)
   }
+  #[allow(dead_code)]
   pub(crate) fn get_metadata_value_json_or_else<T: for<'a> Deserialize<'a>>(
     &self,
     transaction: &mut TransactionBox,
@@ -534,8 +558,12 @@ impl store::Store for Store
     self.set_metadata_value_json(transaction, "graphs", &graphs_list)?;
     Ok(())
   }
-  fn delete_graph(&self, transaction: &mut Self::TransactionBox, graph_name: &String)
-    -> Result<()>
+  fn drop_graph(
+    &self,
+    transaction: &mut Self::TransactionBox,
+    graph_name: &String,
+    if_exists: bool,
+  ) -> Result<()>
   {
     let mut graphs_list = self.graphs_list(transaction)?;
     if graphs_list.contains(graph_name)
@@ -552,6 +580,10 @@ impl store::Store for Store
 
       Ok(())
     }
+    else if if_exists
+    {
+      Ok(())
+    }
     else
     {
       Err(
@@ -972,7 +1004,7 @@ mod tests
   fn test_sqlite_metadata()
   {
     let temp_file = crate::tests::create_tmp_file();
-    let store = super::Store::new(temp_file.path()).unwrap();
+    let store = super::Store::open(temp_file.path()).unwrap();
     let mut tx = store.begin_read().unwrap();
     let version: utils::Version = store.get_metadata_value_json(&mut tx, "version").unwrap();
     assert_eq!(version.major, consts::GQLITE_VERSION.major);
@@ -982,7 +1014,7 @@ mod tests
     drop(store);
 
     // Try to reopen
-    let store = super::Store::new(temp_file.path()).unwrap();
+    let store = super::Store::open(temp_file.path()).unwrap();
     let mut tx = store.begin_read().unwrap();
     let version: utils::Version = store.get_metadata_value_json(&mut tx, "version").unwrap();
     assert_eq!(version.major, consts::GQLITE_VERSION.major);