rename dummy-extension and dummy-embedded-extension to example-extens…

…ion and example-embedded-extension

.github/workflows/main.yml

@@ -117,21 +117,21 @@ jobs:
       - run: cargo build --features sqlcipher --workspace --all-targets --verbose
       - run: cargo test --features sqlcipher --workspace --all-targets --verbose
 
-  dummy-extension:
-    name: Test loadable_extension with dummy-extension
+  example-extension:
+    name: Test loadable_extension with example-extension
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: hecrj/setup-rust-action@v1
-      - run: ./dummy-extension/integration-test.sh
+      - run: ./example-extension/integration-test.sh
 
-  dummy-embedded-extension:
-    name: Test loadable_extension_embedded with dummy-embedded-extension
+  example-embedded-extension:
+    name: Test loadable_extension_embedded with example-embedded-extension
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: hecrj/setup-rust-action@v1
-      - run: ./dummy-embedded-extension/integration-test.sh
+      - run: ./example-embedded-extension/integration-test.sh
 
   sanitizer:
     name: Address Sanitizer
@@ -167,7 +167,7 @@ jobs:
       - run: cargo clippy --all-targets --workspace --features bundled -- -D warnings
       # Clippy with all non-conflicting features
       - run: cargo clippy --all-targets --workspace --features 'bundled-full session buildtime_bindgen' -- -D warnings
-      - run: (cd dummy-extension && cargo clippy --all-targets -- -D warnings)
+      - run: (cd example-extension && cargo clippy --all-targets -- -D warnings)
 
   # Ensure patch is formatted.
   fmt:

example-embedded-extension/.gitignore

@@ -0,0 +1,3 @@
+example-embedded-extension.h
+example-c-host-extension/libexample_c_host_extension.so
+target/

dummy-embedded-extension/Cargo.toml → example-embedded-extension/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
-name = "dummy-embedded-extension"
+name = "example-embedded-extension"
 version = "0.0.1"
 authors = ["The rusqlite developers"]
 edition = "2018"
 repository = "https://github.com/rusqlite/rusqlite"
-description = "Dummy embedded extension to demonstrate and test rusqlite feature loadable_extension_embedded"
+description = "Example embedded extension to demonstrate and test rusqlite feature loadable_extension_embedded"
 license = "MIT"
 keywords = ["sqlite", "extension"]
 

dummy-embedded-extension/build.rs → example-embedded-extension/build.rs

@@ -11,5 +11,5 @@ fn main() {
         .with_crate(crate_dir)
         .generate()
         .expect("Unable to generate bindings")
-        .write_to_file("dummy-embedded-extension.h");
+        .write_to_file("example-embedded-extension.h");
 }

dummy-embedded-extension/dummy-c-host-extension/dummy_c_host_extension.c → example-embedded-extension/example-c-host-extension/example_c_host_extension.c

@@ -3,10 +3,10 @@
 SQLITE_EXTENSION_INIT1
 
 // include the cbindgen-generated bindings for the embedded extension
-#include "dummy-embedded-extension.h"
+#include "example-embedded-extension.h"
 
 // the extension entry point
-int sqlite3_dummychostextension_init(
+int sqlite3_examplechostextension_init(
                                         sqlite3 *db,
                                         char **pzErrMsg,
                                         const sqlite3_api_routines *pApi
@@ -16,7 +16,7 @@ int sqlite3_dummychostextension_init(
 
   // for this example, we essentially just pass through to the embedded
   // extension and return the result.
-  rc = dummy_embedded_extension_init(db, pzErrMsg);
+  rc = example_embedded_extension_init(db, pzErrMsg);
 
   return rc;
 }

dummy-embedded-extension/integration-test.sh → example-embedded-extension/integration-test.sh

@@ -6,18 +6,18 @@ set -euf -o pipefail
 crate_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
 # location of the cdylib embedded library within the target dir to be embedded within the c host extension
-dummy_embedded_extension_lib_dir="${crate_dir}/target/debug"
-dummy_embedded_extension_lib="dummy_embedded_extension"
+example_embedded_extension_lib_dir="${crate_dir}/target/debug"
+example_embedded_extension_lib="example_embedded_extension"
 
 # location of the c host extension to be loaded by sqlite
-dummy_c_host_extension_dir="${crate_dir}/dummy-c-host-extension"
-dummy_c_host_extension="${dummy_c_host_extension_dir}/libdummy_c_host_extension" # sqlite will try adding .so, .dll, .dylib to this on its own
+example_c_host_extension_dir="${crate_dir}/example-c-host-extension"
+example_c_host_extension="${example_c_host_extension_dir}/libexample_c_host_extension" # sqlite will try adding .so, .dll, .dylib to this on its own
 
 # expected output from vtable query
-expected_vtable_output="dummy_embedded_test_value"
+expected_vtable_output="example_embedded_test_value"
 
 # expected output from function query
-expected_function_output="Dummy embedded extension loaded correctly!"
+expected_function_output="Example embedded extension loaded correctly!"
 
 # sqlite3 include dir (location of sqlite3ext.h) - can be set by SQLITE3_INCLUDE_DIR env var or defaults to bundled version
 sqlite3_include_dir=${SQLITE3_INCLUDE_DIR:-${crate_dir}/../sqlite3}
@@ -26,23 +26,23 @@ sqlite3_include_dir=${SQLITE3_INCLUDE_DIR:-${crate_dir}/../sqlite3}
 sqlite3_cmd=$(which sqlite3)
 >&2 echo "sqlite3 found: ${sqlite3_cmd}"
 
-# build the dummy-embedded-extension crate
->&2 echo "building the dummy-embedded-extension crate in ${crate_dir}"
+# build the example-embedded-extension crate
+>&2 echo "building the example-embedded-extension crate in ${crate_dir}"
 (cd "${crate_dir}" && cargo build --all-targets --verbose)
->&2 echo "successfully built the dummy-embedded-extension crate"
+>&2 echo "successfully built the example-embedded-extension crate"
 
 # build the C-based host extension
->&2 echo "building the dummy-c-host-extension"
-clang -g -fPIC -O2 -shared -I${sqlite3_include_dir} -I${crate_dir} -L${dummy_embedded_extension_lib_dir} -Wl,-rpath,${dummy_embedded_extension_lib_dir} -l${dummy_embedded_extension_lib} ${dummy_c_host_extension_dir}/dummy_c_host_extension.c -o ${dummy_c_host_extension}.so
->&2 echo "successfully built the dummy-c-host-extension"
+>&2 echo "building the example-c-host-extension"
+clang -g -fPIC -O2 -shared -I${sqlite3_include_dir} -I${crate_dir} -L${example_embedded_extension_lib_dir} -Wl,-rpath,${example_embedded_extension_lib_dir} -l${example_embedded_extension_lib} ${example_c_host_extension_dir}/example_c_host_extension.c -o ${example_c_host_extension}.so
+>&2 echo "successfully built the example-c-host-extension"
 
->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${dummy_c_host_extension} vtable (embedded within C-based extension)"
-actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${dummy_c_host_extension}" :memory: "SELECT value FROM dummy_embedded LIMIT 1;")
+>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${example_c_host_extension} vtable (embedded within C-based extension)"
+actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${example_c_host_extension}" :memory: "SELECT value FROM example_embedded LIMIT 1;")
 >&2 echo "sqlite3 command returned successfully from vtable test, checking output is as expected"
 test "${actual_vtable_output}" = "${expected_vtable_output}" && echo "OK" || (echo "vtable output '${actual_vtable_output}' was not as expected '${expected_vtable_output}'"; echo "FAIL"; exit 1)
 
->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${dummy_c_host_extension} function (embedded within C-based extension)"
-actual_function_output=$(${sqlite3_cmd} -cmd ".load ${dummy_c_host_extension}" :memory: "SELECT dummy_embedded_test_function();")
+>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension_embedded ${example_c_host_extension} function (embedded within C-based extension)"
+actual_function_output=$(${sqlite3_cmd} -cmd ".load ${example_c_host_extension}" :memory: "SELECT example_embedded_test_function();")
 >&2 echo "sqlite3 command returned successfully from function test, checking output is as expected"
 test  "${actual_function_output}" = "${expected_function_output}" && echo "OK" || (echo "function output '${actual_function_output}' was not as expected '${expected_function_output}'"; echo "FAIL"; exit 1)
 

dummy-embedded-extension/src/lib.rs → example-embedded-extension/src/lib.rs

@@ -12,13 +12,13 @@ use rusqlite::{
 };
 use rusqlite::{to_sqlite_error, Connection, Result};
 
-/// dummy_embedded_extension_init is the entry point for this library.
+/// example_embedded_extension_init is the entry point for this library.
 ///
 /// This crate produces a cdylib that is intended to be embedded within
 /// (i.e. linked into) another library that implements the sqlite loadable
 /// extension entrypoint.
 ///
-/// In the case of this example code, refer to the `dummy-c-host-extension`
+/// In the case of this example code, refer to the `example-c-host-extension`
 /// C code to find where this entry point is invoked.
 ///
 /// Note that this interface is private between the host extension and this
@@ -28,11 +28,11 @@ use rusqlite::{to_sqlite_error, Connection, Result};
 /// It does *not* have to return sqlite status codes (such as SQLITE_OK), we
 /// just do that here to keep the C extension simple.
 #[no_mangle]
-pub extern "C" fn dummy_embedded_extension_init(
+pub extern "C" fn example_embedded_extension_init(
     db: *mut ffi::sqlite3,
     pz_err_msg: *mut *mut c_char,
 ) -> c_int {
-    let res = dummy_embedded_init(db);
+    let res = example_embedded_init(db);
     if let Err(err) = res {
         return unsafe { to_sqlite_error(&err, pz_err_msg) };
     }
@@ -41,21 +41,21 @@ pub extern "C" fn dummy_embedded_extension_init(
 }
 
 #[repr(C)]
-struct DummyEmbeddedTab {
+struct ExampleEmbeddedTab {
     /// Base class. Must be first
     base: sqlite3_vtab,
 }
 
-unsafe impl<'vtab> VTab<'vtab> for DummyEmbeddedTab {
+unsafe impl<'vtab> VTab<'vtab> for ExampleEmbeddedTab {
     type Aux = ();
-    type Cursor = DummyEmbeddedTabCursor<'vtab>;
+    type Cursor = ExampleEmbeddedTabCursor<'vtab>;
 
     fn connect(
         _: &mut VTabConnection,
         _aux: Option<&()>,
         _args: &[&[u8]],
-    ) -> Result<(String, DummyEmbeddedTab)> {
-        let vtab = DummyEmbeddedTab {
+    ) -> Result<(String, ExampleEmbeddedTab)> {
+        let vtab = ExampleEmbeddedTab {
             base: sqlite3_vtab::default(),
         };
         Ok(("CREATE TABLE x(value TEXT)".to_owned(), vtab))
@@ -66,22 +66,22 @@ unsafe impl<'vtab> VTab<'vtab> for DummyEmbeddedTab {
         Ok(())
     }
 
-    fn open(&'vtab self) -> Result<DummyEmbeddedTabCursor<'vtab>> {
-        Ok(DummyEmbeddedTabCursor::default())
+    fn open(&'vtab self) -> Result<ExampleEmbeddedTabCursor<'vtab>> {
+        Ok(ExampleEmbeddedTabCursor::default())
     }
 }
 
 #[derive(Default)]
 #[repr(C)]
-struct DummyEmbeddedTabCursor<'vtab> {
+struct ExampleEmbeddedTabCursor<'vtab> {
     /// Base class. Must be first
     base: sqlite3_vtab_cursor,
     /// The rowid
     row_id: i64,
-    phantom: PhantomData<&'vtab DummyEmbeddedTab>,
+    phantom: PhantomData<&'vtab ExampleEmbeddedTab>,
 }
 
-unsafe impl VTabCursor for DummyEmbeddedTabCursor<'_> {
+unsafe impl VTabCursor for ExampleEmbeddedTabCursor<'_> {
     fn filter(
         &mut self,
         _idx_num: c_int,
@@ -102,26 +102,26 @@ unsafe impl VTabCursor for DummyEmbeddedTabCursor<'_> {
     }
 
     fn column(&self, ctx: &mut Context, _: c_int) -> Result<()> {
-        ctx.set_result(&"dummy_embedded_test_value".to_string())
+        ctx.set_result(&"example_embedded_test_value".to_string())
     }
 
     fn rowid(&self) -> Result<i64> {
         Ok(self.row_id)
     }
 }
 
-fn dummy_embedded_init(db: *mut ffi::sqlite3) -> Result<()> {
+fn example_embedded_init(db: *mut ffi::sqlite3) -> Result<()> {
     let conn = unsafe { Connection::from_handle(db)? };
-    eprintln!("inited dummy embedded extension module {:?}", db);
+    eprintln!("inited example embedded extension module {:?}", db);
     conn.create_scalar_function(
-        "dummy_embedded_test_function",
+        "example_embedded_test_function",
         0,
         FunctionFlags::SQLITE_DETERMINISTIC,
         |_ctx| {
             Ok(ToSqlOutput::Owned(Value::Text(
-                "Dummy embedded extension loaded correctly!".to_string(),
+                "Example embedded extension loaded correctly!".to_string(),
             )))
         },
     )?;
-    conn.create_module::<DummyEmbeddedTab>("dummy_embedded", eponymous_only_module::<DummyEmbeddedTab>(), None)
+    conn.create_module::<ExampleEmbeddedTab>("example_embedded", eponymous_only_module::<ExampleEmbeddedTab>(), None)
 }

dummy-extension/Cargo.toml → example-extension/Cargo.toml

@@ -1,10 +1,10 @@
 [package]
-name = "dummy-extension"
+name = "example-extension"
 version = "0.0.1"
 authors = ["The rusqlite developers"]
 edition = "2018"
 repository = "https://github.com/rusqlite/rusqlite"
-description = "Dummy extension to demonstrate and test rusqlite feature loadable_extension"
+description = "Example extension to demonstrate and test rusqlite feature loadable_extension"
 license = "MIT"
 keywords = ["sqlite", "extension"]
 

dummy-extension/integration-test.sh → example-extension/integration-test.sh

@@ -6,30 +6,30 @@ set -euf -o pipefail
 crate_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
 
 # location of the cdylib extension within the target dir
-dummy_extension="${crate_dir}/target/debug/libdummy_extension" # sqlite will try adding .so, .dll, .dylib to this on its own
+example_extension="${crate_dir}/target/debug/libexample_extension" # sqlite will try adding .so, .dll, .dylib to this on its own
 
 # expected output from vtable query
 expected_vtable_output="1"
 
 # expected output from function query
-expected_function_output="Dummy extension loaded correctly!"
+expected_function_output="Example extension loaded correctly!"
 
 >&2 echo "checking for sqlite3 shell"
 sqlite3_cmd=$(which sqlite3)
 >&2 echo "sqlite3 found: ${sqlite3_cmd}"
 
-# build the dummy-extension crate
->&2 echo "building the dummy-extension crate in ${crate_dir}"
+# build the example-extension crate
+>&2 echo "building the example-extension crate in ${crate_dir}"
 (cd "${crate_dir}" && cargo build --all-targets --verbose)
->&2 echo "successfully built the dummy-extension crate"
+>&2 echo "successfully built the example-extension crate"
 
->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${dummy_extension} vtable"
-actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${dummy_extension}" :memory: "SELECT value FROM dummy LIMIT 1;")
+>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${example_extension} vtable"
+actual_vtable_output=$(${sqlite3_cmd} -cmd ".load ${example_extension}" :memory: "SELECT value FROM example LIMIT 1;")
 >&2 echo "sqlite3 command returned successfully from vtable test, checking output is as expected"
 test "${actual_vtable_output}" = "${expected_vtable_output}" && echo "OK" || (echo "vtable output '${actual_vtable_output}' was not as expected '${expected_vtable_output}'"; echo "FAIL"; exit 1)
 
->&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${dummy_extension} function"
-actual_function_output=$(${sqlite3_cmd} -cmd ".load ${dummy_extension}" :memory: "SELECT dummy_test_function();")
+>&2 echo "running sqlite3 (${sqlite3_cmd}) to test loadable_extension ${example_extension} function"
+actual_function_output=$(${sqlite3_cmd} -cmd ".load ${example_extension}" :memory: "SELECT example_test_function();")
 >&2 echo "sqlite3 command returned successfully from function test, checking output is as expected"
 test  "${actual_function_output}" = "${expected_function_output}" && echo "OK" || (echo "function output '${actual_function_output}' was not as expected '${expected_function_output}'"; echo "FAIL"; exit 1)