Fix the tests and examples to match the new open/create_database API

Author: Kerollmops

heed/examples/all-types-poly.rs

@@ -22,19 +22,19 @@ fn main() -> Result<(), Box<dyn Error>> {
     //
     // like here we specify that the key will be an array of two i32
     // and the data will be an str
-    let db = env.create_poly_database(Some("kikou"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db = env.create_poly_database(&mut wtxn, Some("kikou"))?;
+
     db.put::<OwnedType<[i32; 2]>, Str>(&mut wtxn, &[2, 3], "what's up?")?;
     let ret = db.get::<OwnedType<[i32; 2]>, Str>(&wtxn, &[2, 3])?;
 
     println!("{:?}", ret);
     wtxn.commit()?;
 
     // here the key will be an str and the data will be a slice of u8
-    let db = env.create_poly_database(Some("kiki"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db = env.create_poly_database(&mut wtxn, Some("kiki"))?;
+
     db.put::<Str, ByteSlice>(&mut wtxn, "hello", &[2, 3][..])?;
     let ret = db.get::<Str, ByteSlice>(&wtxn, "hello")?;
 
@@ -47,9 +47,8 @@ fn main() -> Result<(), Box<dyn Error>> {
         string: &'a str,
     }
 
-    let db = env.create_poly_database(Some("serde"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db = env.create_poly_database(&mut wtxn, Some("serde"))?;
 
     let hello = Hello { string: "hi" };
     db.put::<Str, SerdeBincode<Hello>>(&mut wtxn, "hello", &hello)?;
@@ -71,9 +70,8 @@ fn main() -> Result<(), Box<dyn Error>> {
         bytes: [u8; 12],
     }
 
-    let db = env.create_poly_database(Some("nocopy-struct"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db = env.create_poly_database(&mut wtxn, Some("nocopy-struct"))?;
 
     let zerobytes = ZeroBytes { bytes: [24; 12] };
     db.put::<Str, UnalignedType<ZeroBytes>>(&mut wtxn, "zero", &zerobytes)?;
@@ -84,9 +82,9 @@ fn main() -> Result<(), Box<dyn Error>> {
     wtxn.commit()?;
 
     // you can ignore the data
-    let db = env.create_poly_database(Some("ignored-data"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db = env.create_poly_database(&mut wtxn, Some("ignored-data"))?;
+
     db.put::<Str, Unit>(&mut wtxn, "hello", &())?;
     let ret = db.get::<Str, Unit>(&wtxn, "hello")?;
 
@@ -97,26 +95,26 @@ fn main() -> Result<(), Box<dyn Error>> {
     println!("{:?}", ret);
     wtxn.commit()?;
 
-    // database opening and types are tested in a way
+    // database opening and types are tested in a safe way
     //
     // we try to open a database twice with the same types
-    let _db = env.create_poly_database(Some("ignored-data"))?;
+    let mut wtxn = env.write_txn()?;
+    let _db = env.create_poly_database(&mut wtxn, Some("ignored-data"))?;
 
     // and here we try to open it with other types
     // asserting that it correctly returns an error
     //
     // NOTE that those types are not saved upon runs and
     // therefore types cannot be checked upon different runs,
     // the first database opening fix the types for this run.
-    let result = env.create_database::<OwnedType<BEI64>, Unit>(Some("ignored-data"));
+    let result = env.create_database::<OwnedType<BEI64>, Unit>(&mut wtxn, Some("ignored-data"));
     assert!(result.is_err());
 
     // you can iterate over keys in order
     type BEI64 = I64<BE>;
 
-    let db = env.create_poly_database(Some("big-endian-iter"))?;
+    let db = env.create_poly_database(&mut wtxn, Some("big-endian-iter"))?;
 
-    let mut wtxn = env.write_txn()?;
     db.put::<OwnedType<BEI64>, Unit>(&mut wtxn, &BEI64::new(0), &())?;
     db.put::<OwnedType<BEI64>, Unit>(&mut wtxn, &BEI64::new(68), &())?;
     db.put::<OwnedType<BEI64>, Unit>(&mut wtxn, &BEI64::new(35), &())?;

heed/examples/all-types.rs

@@ -22,19 +22,19 @@ fn main() -> Result<(), Box<dyn Error>> {
     //
     // like here we specify that the key will be an array of two i32
     // and the data will be an str
-    let db: Database<OwnedType<[i32; 2]>, Str> = env.create_database(Some("kikou"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db: Database<OwnedType<[i32; 2]>, Str> = env.create_database(&mut wtxn, Some("kikou"))?;
+
     let _ret = db.put(&mut wtxn, &[2, 3], "what's up?")?;
     let ret: Option<&str> = db.get(&wtxn, &[2, 3])?;
 
     println!("{:?}", ret);
     wtxn.commit()?;
 
     // here the key will be an str and the data will be a slice of u8
-    let db: Database<Str, ByteSlice> = env.create_database(Some("kiki"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db: Database<Str, ByteSlice> = env.create_database(&mut wtxn, Some("kiki"))?;
+
     let _ret = db.put(&mut wtxn, "hello", &[2, 3][..])?;
     let ret: Option<&[u8]> = db.get(&wtxn, "hello")?;
 
@@ -47,9 +47,9 @@ fn main() -> Result<(), Box<dyn Error>> {
         string: &'a str,
     }
 
-    let db: Database<Str, SerdeBincode<Hello>> = env.create_database(Some("serde-bincode"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db: Database<Str, SerdeBincode<Hello>> =
+        env.create_database(&mut wtxn, Some("serde-bincode"))?;
 
     let hello = Hello { string: "hi" };
     db.put(&mut wtxn, "hello", &hello)?;
@@ -59,9 +59,8 @@ fn main() -> Result<(), Box<dyn Error>> {
 
     wtxn.commit()?;
 
-    let db: Database<Str, SerdeJson<Hello>> = env.create_database(Some("serde-json"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db: Database<Str, SerdeJson<Hello>> = env.create_database(&mut wtxn, Some("serde-json"))?;
 
     let hello = Hello { string: "hi" };
     db.put(&mut wtxn, "hello", &hello)?;
@@ -78,9 +77,9 @@ fn main() -> Result<(), Box<dyn Error>> {
         bytes: [u8; 12],
     }
 
-    let db: Database<Str, UnalignedType<ZeroBytes>> = env.create_database(Some("simple-struct"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db: Database<Str, UnalignedType<ZeroBytes>> =
+        env.create_database(&mut wtxn, Some("simple-struct"))?;
 
     let zerobytes = ZeroBytes { bytes: [24; 12] };
     db.put(&mut wtxn, "zero", &zerobytes)?;
@@ -91,9 +90,9 @@ fn main() -> Result<(), Box<dyn Error>> {
     wtxn.commit()?;
 
     // you can ignore the data
-    let db: Database<Str, Unit> = env.create_database(Some("ignored-data"))?;
-
     let mut wtxn = env.write_txn()?;
+    let db: Database<Str, Unit> = env.create_database(&mut wtxn, Some("ignored-data"))?;
+
     let _ret = db.put(&mut wtxn, "hello", &())?;
     let ret: Option<()> = db.get(&wtxn, "hello")?;
 
@@ -104,26 +103,27 @@ fn main() -> Result<(), Box<dyn Error>> {
     println!("{:?}", ret);
     wtxn.commit()?;
 
-    // database opening and types are tested in a way
+    // database opening and types are tested in a safe way
     //
     // we try to open a database twice with the same types
-    let _db: Database<Str, Unit> = env.create_database(Some("ignored-data"))?;
+    let mut wtxn = env.write_txn()?;
+    let _db: Database<Str, Unit> = env.create_database(&mut wtxn, Some("ignored-data"))?;
 
     // and here we try to open it with other types
     // asserting that it correctly returns an error
     //
     // NOTE that those types are not saved upon runs and
     // therefore types cannot be checked upon different runs,
     // the first database opening fix the types for this run.
-    let result = env.create_database::<Str, OwnedSlice<i32>>(Some("ignored-data"));
+    let result = env.create_database::<Str, OwnedSlice<i32>>(&mut wtxn, Some("ignored-data"));
     assert!(result.is_err());
 
     // you can iterate over keys in order
     type BEI64 = I64<BE>;
 
-    let db: Database<OwnedType<BEI64>, Unit> = env.create_database(Some("big-endian-iter"))?;
+    let db: Database<OwnedType<BEI64>, Unit> =
+        env.create_database(&mut wtxn, Some("big-endian-iter"))?;
 
-    let mut wtxn = env.write_txn()?;
     let _ret = db.put(&mut wtxn, &BEI64::new(0), &())?;
     let _ret = db.put(&mut wtxn, &BEI64::new(68), &())?;
     let _ret = db.put(&mut wtxn, &BEI64::new(35), &())?;

heed/examples/clear-database.rs

@@ -18,8 +18,8 @@ fn main() -> Result<(), Box<dyn Error>> {
         .max_dbs(3)
         .open(env_path)?;
 
-    let db: Database<Str, Str> = env.create_database(Some("first"))?;
     let mut wtxn = env.write_txn()?;
+    let db: Database<Str, Str> = env.create_database(&mut wtxn, Some("first"))?;
 
     // We fill the db database with entries.
     db.put(&mut wtxn, "I am here", "to test things")?;

heed/examples/cursor-append.rs

@@ -18,10 +18,9 @@ fn main() -> Result<(), Box<dyn Error>> {
         .max_dbs(3)
         .open(env_path)?;
 
-    let first: Database<Str, Str> = env.create_database(Some("first"))?;
-    let second: Database<Str, Str> = env.create_database(Some("second"))?;
-
     let mut wtxn = env.write_txn()?;
+    let first: Database<Str, Str> = env.create_database(&mut wtxn, Some("first"))?;
+    let second: Database<Str, Str> = env.create_database(&mut wtxn, Some("second"))?;
 
     // We fill the first database with entries.
     first.put(&mut wtxn, "I am here", "to test things")?;

heed/examples/multi-env.rs

@@ -21,11 +21,12 @@ fn main() -> Result<(), Box<dyn Error>> {
         .max_dbs(3000)
         .open(env2_path)?;
 
-    let db1: Database<Str, ByteSlice> = env1.create_database(Some("hello"))?;
-    let db2: Database<OwnedType<u32>, OwnedType<u32>> = env2.create_database(Some("hello"))?;
+    let mut wtxn = env1.write_txn()?;
+    let db1: Database<Str, ByteSlice> = env1.create_database(&mut wtxn, Some("hello"))?;
+    let db2: Database<OwnedType<u32>, OwnedType<u32>> =
+        env2.create_database(&mut wtxn, Some("hello"))?;
 
     // clear db
-    let mut wtxn = env1.write_txn()?;
     db1.clear(&mut wtxn)?;
     wtxn.commit()?;
 

heed/examples/nested.rs

@@ -16,17 +16,16 @@ fn main() -> Result<(), Box<dyn Error>> {
         .open(path)?;
 
     // here the key will be an str and the data will be a slice of u8
-    let db: Database<Str, ByteSlice> = env.create_database(None)?;
+    let mut wtxn = env.write_txn()?;
+    let db: Database<Str, ByteSlice> = env.create_database(&mut wtxn, None)?;
 
     // clear db
-    let mut wtxn = env.write_txn()?;
     db.clear(&mut wtxn)?;
     wtxn.commit()?;
 
     // -----
 
     let mut wtxn = env.write_txn()?;
-
     let mut nwtxn = env.nested_write_txn(&mut wtxn)?;
 
     db.put(&mut nwtxn, "what", &[4, 5][..])?;