upgrade to 0.8.0 (#160)

wangfenjin · web-flow · commit cfda58b8622b · 2023-05-20T20:21:40.000+08:00
* upgrade to 0.8.0

* try fix windows

* update code

* fix test

* fix build error

* update

* fix path
diff --git a/.github/workflows/rust.yaml b/.github/workflows/rust.yaml
@@ -38,7 +38,7 @@ jobs:
         name: Download duckdb
         with:
           repository: "duckdb/duckdb"
-          tag: "v0.7.1"
+          tag: "v0.8.0"
           fileName: ${{ matrix.duckdb }}
           out-file-path: .
 
diff --git a/Cargo.toml b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "duckdb"
-version = "0.7.1"
+version = "0.8.0"
 authors = ["wangfenjin <wangfenj@gmail.com>"]
 edition = "2021"
 description = "Ergonomic wrapper for DuckDB"
@@ -81,7 +81,7 @@ tempdir = "0.3.7"
 
 [dependencies.libduckdb-sys]
 path = "libduckdb-sys"
-version = "0.7.1"
+version = "0.8.0"
 
 [package.metadata.docs.rs]
 features = []
diff --git a/libduckdb-sys/Cargo.toml b/libduckdb-sys/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "libduckdb-sys"
-version = "0.7.1"
+version = "0.8.0"
 authors = ["wangfenjin <wangfenj@gmail.com>"]
 edition = "2021"
 build = "build.rs"
diff --git a/libduckdb-sys/build.rs b/libduckdb-sys/build.rs
@@ -100,8 +100,7 @@ mod build_bundled {
         #[cfg(not(feature = "buildtime_bindgen"))]
         {
             use std::fs;
-            fs::copy(format!("{}/bindgen_bundled_version.rs", lib_name), out_path)
-                .expect("Could not copy bindings to output directory");
+            fs::copy("src/bindgen_bundled_version.rs", out_path).expect("Could not copy bindings to output directory");
         }
 
         let manifest_file = std::fs::File::open(format!("{}/manifest.json", lib_name)).expect("manifest file");
diff --git a/libduckdb-sys/duckdb-sources b/libduckdb-sys/duckdb-sources
@@ -1 +1 @@
-Subproject commit b00b93f0b14bfff869e1facfd86a6b556a6f1c6e
+Subproject commit e8e4cea5ec9d1a84c1f516d0f0674f8785a3e786
diff --git a/libduckdb-sys/duckdb.tar.gz b/libduckdb-sys/duckdb.tar.gz
diff --git a/libduckdb-sys/src/bindgen_bundled_version.rs b/libduckdb-sys/src/bindgen_bundled_version.rs
diff --git a/libduckdb-sys/update_sources.py b/libduckdb-sys/update_sources.py
@@ -11,6 +11,8 @@
 DUCKDB_SCRIPTS_DIR = os.path.join(SCRIPT_DIR, "duckdb-sources", "scripts")
 # Path to target
 TARGET_DIR = os.path.join(SCRIPT_DIR, "duckdb")
+# Path to src
+SRC_DIR = os.path.join(SCRIPT_DIR, "src")
 
 # List of extensions' sources to grab. Technically, these sources will be compiled
 # but not included in the final build unless they're explicitly enabled.
@@ -27,6 +29,7 @@
 # Clear the duckdb directory
 try:
     shutil.rmtree(os.path.join(TARGET_DIR))
+    os.remove(os.path.join(SCRIPT_DIR, "duckdb.tar.gz"))
 except FileNotFoundError:
     pass
 
@@ -73,6 +76,12 @@ def get_sources(extensions):
     json.dump(manifest, f, indent=2)
 
 
+subprocess.check_call(
+    "tar -czf duckdb.tar.gz duckdb",
+    shell=True,
+    cwd=SCRIPT_DIR,
+)
+
 subprocess.check_call(
     'find "' + SCRIPT_DIR + '/../target" -type f -name bindgen.rs -exec rm {} \;',
     shell=True,
@@ -82,18 +91,19 @@ def get_sources(extensions):
     'env LIBDUCKDB_SYS_BUNDLING=1 cargo test --features "bundled buildtime_bindgen"',
     shell=True,
 )
+
 print(
     'find "'
     + SCRIPT_DIR
     + '/../target" -type f -name "bindgen.rs" -exec cp {} "'
-    + TARGET_DIR
+    + SRC_DIR
     + '/bindgen_bundled_version.rs" \;'
 )
 subprocess.check_call(
     'find "'
     + SCRIPT_DIR
     + '/../target" -type f -name "bindgen.rs" -exec cp {} "'
-    + TARGET_DIR
+    + SRC_DIR
     + '/bindgen_bundled_version.rs" \;',
     shell=True,
 )
@@ -104,9 +114,3 @@ def get_sources(extensions):
         SCRIPT_DIR, "duckdb-sources", "extension", "httpfs", "httpfs_config.py"
     )
 )
-
-subprocess.check_call(
-    "tar -czf duckdb.tar.gz duckdb",
-    shell=True,
-    cwd=SCRIPT_DIR,
-)
diff --git a/libduckdb-sys/upgrade.sh b/libduckdb-sys/upgrade.sh
@@ -10,12 +10,12 @@ export DUCKDB_LIB_DIR="$SCRIPT_DIR/duckdb"
 export DU_INCLUDE_DIR="$DUCKDB_LIB_DIR"
 
 # Download and extract amalgamation
-DUCKDB_VERSION=v0.7.1
-git submodule update --init
+DUCKDB_VERSION=v0.8.0
+git submodule update --init --checkout
 cd "$SCRIPT_DIR/duckdb-sources" || { echo "fatal error" >&2; exit 1; }
 git checkout "$DUCKDB_VERSION"
 cd "$SCRIPT_DIR" || { echo "fatal error" >&2; exit 1; }
-python "$SCRIPT_DIR/update_sources.py"
+python3 "$SCRIPT_DIR/update_sources.py"
 
 # Regenerate bindgen file for DUCKDB
 rm -f "$SCRIPT_DIR/src/bindgen_bundled_version.rs"
diff --git a/src/cache.rs b/src/cache.rs
@@ -205,14 +205,14 @@ mod test {
         {
             let mut stmt = db.prepare_cached(sql)?;
             assert_eq!(0, cache.len());
-            assert_eq!(4, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            assert_eq!("memory", stmt.query_row([], |r| r.get::<_, String>(1))?);
         }
         assert_eq!(1, cache.len());
 
         {
             let mut stmt = db.prepare_cached(sql)?;
             assert_eq!(0, cache.len());
-            assert_eq!(4, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            assert_eq!("memory", stmt.query_row([], |r| r.get::<_, String>(1))?);
         }
         assert_eq!(1, cache.len());
 
@@ -231,7 +231,7 @@ mod test {
         {
             let mut stmt = db.prepare_cached(sql)?;
             assert_eq!(0, cache.len());
-            assert_eq!(4, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            assert_eq!("memory", stmt.query_row([], |r| r.get::<_, String>(1))?);
         }
         assert_eq!(1, cache.len());
 
@@ -241,15 +241,15 @@ mod test {
         {
             let mut stmt = db.prepare_cached(sql)?;
             assert_eq!(0, cache.len());
-            assert_eq!(4, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            assert_eq!("memory", stmt.query_row([], |r| r.get::<_, String>(1))?);
         }
         assert_eq!(0, cache.len());
 
         db.set_prepared_statement_cache_capacity(8);
         {
             let mut stmt = db.prepare_cached(sql)?;
             assert_eq!(0, cache.len());
-            assert_eq!(4, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            assert_eq!("memory", stmt.query_row([], |r| r.get::<_, String>(1))?);
         }
         assert_eq!(1, cache.len());
         Ok(())
@@ -264,7 +264,7 @@ mod test {
         {
             let mut stmt = db.prepare_cached(sql)?;
             assert_eq!(0, cache.len());
-            assert_eq!(4, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            assert_eq!("memory", stmt.query_row([], |r| r.get::<_, String>(1))?);
             stmt.discard();
         }
         assert_eq!(0, cache.len());
@@ -325,14 +325,14 @@ mod test {
         {
             let mut stmt = db.prepare_cached(sql)?;
             assert_eq!(0, cache.len());
-            assert_eq!(4, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            assert_eq!("memory", stmt.query_row([], |r| r.get::<_, String>(1))?);
         }
         assert_eq!(1, cache.len());
 
         {
             let mut stmt = db.prepare_cached(sql)?;
             assert_eq!(0, cache.len());
-            assert_eq!(4, stmt.query_row([], |r| r.get::<_, i64>(0))?);
+            assert_eq!("memory", stmt.query_row([], |r| r.get::<_, String>(1))?);
         }
         assert_eq!(1, cache.len());
         Ok(())
diff --git a/src/config.rs b/src/config.rs
@@ -156,10 +156,11 @@ mod test {
             .collect();
         let val = val?;
         let mut iter = val.iter();
-        assert!(iter.next().unwrap().is_none());
+        assert_eq!(val.len(), 4);
         assert_eq!(iter.next().unwrap().as_ref().unwrap(), "a");
         assert_eq!(iter.next().unwrap().as_ref().unwrap(), "b");
         assert_eq!(iter.next().unwrap().as_ref().unwrap(), "c");
+        assert!(iter.next().unwrap().is_none());
         assert_eq!(iter.next(), None);
 
         Ok(())
diff --git a/src/transaction.rs b/src/transaction.rs
@@ -501,7 +501,7 @@ mod test {
         db.execute_batch(
             r"
             CREATE TABLE foo (x INTEGER);
-            SET AUTOCOMMIT TO OFF;
+            -- SET AUTOCOMMIT TO OFF;
         ",
         )?;
         Ok(db)
diff --git a/src/vtab/excel.rs b/src/vtab/excel.rs
@@ -191,7 +191,7 @@ impl VTab for ExcelVTab {
 #[cfg(test)]
 mod test {
     use crate::{vtab::excel::ExcelVTab, Connection, Result};
-    use arrow::array::{Array, Date32Array, Float64Array, StringArray};
+    use arrow::array::{Array, Date32Array, Float64Array, LargeStringArray};
     use std::error::Error;
 
     #[test]
@@ -204,7 +204,6 @@ mod test {
             .query_row::<i64, _, _>([], |row| row.get(0))?;
         assert_eq!(3039, val);
         let mut stmt = db.prepare("select genres, sum(movie_facebook_likes) from excel('./examples/Movies_Social_metadata.xlsx', 'Data') group by genres order by genres limit 4")?;
-        let mut arr = stmt.query_arrow([])?;
         // +-------------+---------------------------+
         // | genres      | sum(movie_facebook_likes) |
         // +-------------+---------------------------+
@@ -213,8 +212,10 @@ mod test {
         // | Animation   | 202219.0                  |
         // | Biography   | 1724632.0                 |
         // +-------------+---------------------------+
+        let mut arr = stmt.query_arrow([])?;
         let rb = arr.next().expect("no record batch");
-        let column = rb.column(0).as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(rb.num_rows(), 4);
+        let column = rb.column(0).as_any().downcast_ref::<LargeStringArray>().unwrap();
         assert_eq!(column.len(), 4);
         assert_eq!(column.value(0), "Action");
         assert_eq!(column.value(1), "Adventure");

Original file line number	Diff line number	Diff line change
`@@ -100,8 +100,7 @@ mod build_bundled {`
`100`	`100`	`#[cfg(not(feature = "buildtime_bindgen"))]`
`101`	`101`	`{`
`102`	`102`	`use std::fs;`
`103`		`- fs::copy(format!("{}/bindgen_bundled_version.rs", lib_name), out_path)`
`104`		`- .expect("Could not copy bindings to output directory");`
	`103`	`+ fs::copy("src/bindgen_bundled_version.rs", out_path).expect("Could not copy bindings to output directory");`
`105`	`104`	`}`
`106`	`105`
`107`	`106`	`let manifest_file = std::fs::File::open(format!("{}/manifest.json", lib_name)).expect("manifest file");`
Original file line number	Diff line number	Diff line change
`@@ -205,14 +205,14 @@ mod test {`
`205`	`205`	`{`
`206`	`206`	`let mut stmt = db.prepare_cached(sql)?;`
`207`	`207`	`assert_eq!(0, cache.len());`
`208`		`- assert_eq!(4, stmt.query_row([], \|r\| r.get::<_, i64>(0))?);`
	`208`	`+ assert_eq!("memory", stmt.query_row([], \|r\| r.get::<_, String>(1))?);`
`209`	`209`	`}`
`210`	`210`	`assert_eq!(1, cache.len());`
`211`	`211`
`212`	`212`	`{`
`213`	`213`	`let mut stmt = db.prepare_cached(sql)?;`
`214`	`214`	`assert_eq!(0, cache.len());`
`215`		`- assert_eq!(4, stmt.query_row([], \|r\| r.get::<_, i64>(0))?);`
	`215`	`+ assert_eq!("memory", stmt.query_row([], \|r\| r.get::<_, String>(1))?);`
`216`	`216`	`}`
`217`	`217`	`assert_eq!(1, cache.len());`
`218`	`218`
`@@ -231,7 +231,7 @@ mod test {`
`231`	`231`	`{`
`232`	`232`	`let mut stmt = db.prepare_cached(sql)?;`
`233`	`233`	`assert_eq!(0, cache.len());`
`234`		`- assert_eq!(4, stmt.query_row([], \|r\| r.get::<_, i64>(0))?);`
	`234`	`+ assert_eq!("memory", stmt.query_row([], \|r\| r.get::<_, String>(1))?);`
`235`	`235`	`}`
`236`	`236`	`assert_eq!(1, cache.len());`
`237`	`237`
`@@ -241,15 +241,15 @@ mod test {`
`241`	`241`	`{`
`242`	`242`	`let mut stmt = db.prepare_cached(sql)?;`
`243`	`243`	`assert_eq!(0, cache.len());`
`244`		`- assert_eq!(4, stmt.query_row([], \|r\| r.get::<_, i64>(0))?);`
	`244`	`+ assert_eq!("memory", stmt.query_row([], \|r\| r.get::<_, String>(1))?);`
`245`	`245`	`}`
`246`	`246`	`assert_eq!(0, cache.len());`
`247`	`247`
`248`	`248`	`db.set_prepared_statement_cache_capacity(8);`
`249`	`249`	`{`
`250`	`250`	`let mut stmt = db.prepare_cached(sql)?;`
`251`	`251`	`assert_eq!(0, cache.len());`
`252`		`- assert_eq!(4, stmt.query_row([], \|r\| r.get::<_, i64>(0))?);`
	`252`	`+ assert_eq!("memory", stmt.query_row([], \|r\| r.get::<_, String>(1))?);`
`253`	`253`	`}`
`254`	`254`	`assert_eq!(1, cache.len());`
`255`	`255`	`Ok(())`
`@@ -264,7 +264,7 @@ mod test {`
`264`	`264`	`{`
`265`	`265`	`let mut stmt = db.prepare_cached(sql)?;`
`266`	`266`	`assert_eq!(0, cache.len());`
`267`		`- assert_eq!(4, stmt.query_row([], \|r\| r.get::<_, i64>(0))?);`
	`267`	`+ assert_eq!("memory", stmt.query_row([], \|r\| r.get::<_, String>(1))?);`
`268`	`268`	`stmt.discard();`
`269`	`269`	`}`
`270`	`270`	`assert_eq!(0, cache.len());`
`@@ -325,14 +325,14 @@ mod test {`
`325`	`325`	`{`
`326`	`326`	`let mut stmt = db.prepare_cached(sql)?;`
`327`	`327`	`assert_eq!(0, cache.len());`
`328`		`- assert_eq!(4, stmt.query_row([], \|r\| r.get::<_, i64>(0))?);`
	`328`	`+ assert_eq!("memory", stmt.query_row([], \|r\| r.get::<_, String>(1))?);`
`329`	`329`	`}`
`330`	`330`	`assert_eq!(1, cache.len());`
`331`	`331`
`332`	`332`	`{`
`333`	`333`	`let mut stmt = db.prepare_cached(sql)?;`
`334`	`334`	`assert_eq!(0, cache.len());`
`335`		`- assert_eq!(4, stmt.query_row([], \|r\| r.get::<_, i64>(0))?);`
	`335`	`+ assert_eq!("memory", stmt.query_row([], \|r\| r.get::<_, String>(1))?);`
`336`	`336`	`}`
`337`	`337`	`assert_eq!(1, cache.len());`
`338`	`338`	`Ok(())`