diff --git a/README.md b/README.md
index ea0380bd6e03fb37e121d187b61975fb5efb556c..86fac6aca7d0422bcd923f0d2d34833112b750b9 100644
--- a/README.md
+++ b/README.md
@@ -27,7 +27,7 @@ You can install the wasmedge as simple as
 
 Refer to [https://wasmedge.org/book/en/quick_start/install.html](https://wasmedge.org/book/en/quick_start/install.html) for more details.
 
-After that, run `CREATE EXTENSION wasm_executor` in a
+After that, run `CREATE EXTENSION wasm_engine` in a
 openGauss shell. One new function will appear: `wasm_new_instance`; It must be
 called with the absolute path to the shared library. It looks like
 this:
@@ -40,7 +40,7 @@ $ # Install the extension in the opengauss
 $ make install
 
 $ # Activate and initialize the extension.
-$ gsql -d postgres -c 'CREATE EXTENSION wasm_executor'
+$ gsql -d postgres -c 'CREATE EXTENSION wasm_engine'
 ```
 
 And you are ready to go!
diff --git a/odd/encrypt_decrypt/1_init_user_env b/odd/encrypt_decrypt/1_init_user_env
new file mode 100755
index 0000000000000000000000000000000000000000..8fb83bfb7a9f40440254db1421c4789856e055b1
--- /dev/null
+++ b/odd/encrypt_decrypt/1_init_user_env
@@ -0,0 +1,9 @@
+gsql -d opengauss -e -c "CREATE TABLE users (
+    username TEXT PRIMARY KEY,
+    email TEXT,
+    passwd TEXT
+);"
+
+gsql -d opengauss -e -c "CREATE TABLE secrets(secret text);
+INSERT INTO secrets VALUES ('s3cretk3y');"
+
diff --git a/odd/encrypt_decrypt/2_create_extension b/odd/encrypt_decrypt/2_create_extension
new file mode 100755
index 0000000000000000000000000000000000000000..d26ee4c698415e1f5a42c1415e21f1ee4a2771c8
--- /dev/null
+++ b/odd/encrypt_decrypt/2_create_extension
@@ -0,0 +1,2 @@
+gsql -d opengauss -e -c 'CREATE EXTENSION wasm_engine;'
+
diff --git a/odd/encrypt_decrypt/3_compile_load_show b/odd/encrypt_decrypt/3_compile_load_show
new file mode 100755
index 0000000000000000000000000000000000000000..eaea8968b7e6a07262d0a7e55be4c4b4629b268a
--- /dev/null
+++ b/odd/encrypt_decrypt/3_compile_load_show
@@ -0,0 +1,17 @@
+set -e
+
+echo "cargo build --release --target wasm32-unknown-unknown"
+cargo build --release --target wasm32-unknown-unknown
+
+echo "wasm-opt -Os  target/wasm32-unknown-unknown/release/opengauss_encrypt_decrypt.wasm  -o encrypt_decrypt.wasm"
+wasm-opt -Os  target/wasm32-unknown-unknown/release/opengauss_encrypt_decrypt.wasm  -o encrypt_decrypt.wasm
+
+gsql -d opengauss -e -c "SELECT wasm_new_instance('/home/opengauss/odd/encrypt_decrypt/encrypt_decrypt.wasm', 'gs');"
+
+gsql -d opengauss -e -c "select * from wasm.exported_functions;"
+
+
+
+
+
+
diff --git a/odd/encrypt_decrypt/4_create_trigger b/odd/encrypt_decrypt/4_create_trigger
new file mode 100755
index 0000000000000000000000000000000000000000..1f8d9cebd27c636db86f67bf7ed79bf5b85e91d7
--- /dev/null
+++ b/odd/encrypt_decrypt/4_create_trigger
@@ -0,0 +1,16 @@
+gsql -d opengauss -e -c "CREATE OR REPLACE FUNCTION encrypt_password() 
+RETURNS TRIGGER AS
+$$
+    DECLARE
+    BEGIN
+        UPDATE users SET passwd = gs_encrypt(NEW.passwd, 
+	    (SELECT secret FROM secrets LIMIT 1)) 
+	WHERE username = NEW.username;
+        RETURN NEW;
+    END
+$$LANGUAGE PLPGSQL;"
+
+gsql -d opengauss -e -c "CREATE TRIGGER encrypt_passwd_trigger AFTER 
+    INSERT ON users 
+FOR EACH ROW EXECUTE PROCEDURE encrypt_password();"
+
diff --git a/odd/encrypt_decrypt/5_insert_show b/odd/encrypt_decrypt/5_insert_show
new file mode 100755
index 0000000000000000000000000000000000000000..577414452e5baed8170d578042d9061b19333b66
--- /dev/null
+++ b/odd/encrypt_decrypt/5_insert_show
@@ -0,0 +1,9 @@
+gsql -d opengauss -e -c "INSERT INTO users VALUES ('nel', 'nel@xx.com', 'nelson_passwd');
+INSERT INTO users VALUES ('mic', 'mic@xx.com', 'mickle_passwd');
+INSERT INTO users VALUES ('jay', 'jay@xx.com', 'jackson_passwd');
+INSERT INTO users VALUES ('lily', 'lily@xx.com', 'lily_passwd');
+INSERT INTO users VALUES ('anna', 'anna@xx.com', 'anna_passwd');"
+
+gsql -d opengauss -e -c "SELECT username, passwd, gs_decrypt(passwd, 
+    (SELECT secret FROM secrets LIMIT 1)) AS decrypted 
+FROM users;"
diff --git a/odd/encrypt_decrypt/Cargo.toml b/odd/encrypt_decrypt/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..37f550008682aa3a817023daa3e1ee3eb75a6dc5
--- /dev/null
+++ b/odd/encrypt_decrypt/Cargo.toml
@@ -0,0 +1,13 @@
+[package]
+name = "opengauss_encrypt_decrypt"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+opengauss_bindgen = "0.1.0"
+magic-crypt = "3.1"
+
+[lib]
+crate-type = ["cdylib"]
diff --git a/odd/encrypt_decrypt/src/lib.rs b/odd/encrypt_decrypt/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..847e89a8b904ea9eb82457a1393be51304b711f7
--- /dev/null
+++ b/odd/encrypt_decrypt/src/lib.rs
@@ -0,0 +1,15 @@
+use opengauss_bindgen::*;
+use magic_crypt::{new_magic_crypt, MagicCryptTrait};
+
+#[opengauss_bindgen::opengauss_bindgen]
+pub fn encrypt(data: String, key: String) -> String {
+    let mc = new_magic_crypt!(key, 256);
+    mc.encrypt_str_to_base64(data)
+}
+
+#[opengauss_bindgen::opengauss_bindgen]
+pub fn decrypt(data: String, key: String) -> String {
+    let mc = new_magic_crypt!(key, 256);
+    mc.decrypt_base64_to_string(data)
+        .unwrap_or("[ACCESS DENIED]".to_owned())
+}
diff --git a/odd/fib/1_create_sql_func b/odd/fib/1_create_sql_func
new file mode 100755
index 0000000000000000000000000000000000000000..8f11b51ed5aaa4c7d7736ff644d81fde1c18b3af
--- /dev/null
+++ b/odd/fib/1_create_sql_func
@@ -0,0 +1,22 @@
+
+gsql -d opengauss -e -c '
+CREATE OR REPLACE FUNCTION sql_fib (n integer) RETURNS decimal AS $$ 
+DECLARE
+    counter bigint := 1; 
+    i decimal := 0;
+    j decimal := 1;
+BEGIN
+    IF (n <= 1) THEN
+        RETURN n;
+    END IF; 
+
+    WHILE counter <= n LOOP
+        counter := counter + 1; 
+        SELECT j, i + j INTO i, j;
+    END LOOP; 
+
+    RETURN i;
+END;
+$$ LANGUAGE plpgsql;'
+
+
diff --git a/odd/fib/2_compile_load_show b/odd/fib/2_compile_load_show
new file mode 100755
index 0000000000000000000000000000000000000000..c0cca5f7173c223b1c67a34395365d6877d583d3
--- /dev/null
+++ b/odd/fib/2_compile_load_show
@@ -0,0 +1,17 @@
+#!/usr/bin/env bash
+
+set -e
+
+echo "cargo build --release --target wasm32-unknown-unknown"
+cargo build --release --target wasm32-unknown-unknown
+
+echo "wasm-opt -Os  target/wasm32-unknown-unknown/release/fib.wasm  -o fib.wasm"
+wasm-opt -Os  target/wasm32-unknown-unknown/release/fib.wasm  -o fib.wasm
+
+gsql -d opengauss -e -c "SELECT wasm_new_instance('/home/opengauss/odd/fib/fib.wasm', 'ws');"
+
+gsql -d opengauss -e -c "select * from wasm.exported_functions;"
+
+gsql -d opengauss -c "select ws_fib(1);" -q -o ./init.log
+
+rm -f ./init.log
diff --git a/odd/fib/3_sql_benchmark b/odd/fib/3_sql_benchmark
new file mode 100755
index 0000000000000000000000000000000000000000..7219c11eea8d6c0655a064576a0278030996de07
--- /dev/null
+++ b/odd/fib/3_sql_benchmark
@@ -0,0 +1,3 @@
+
+gsql -d opengauss -e -f ./sql_benchmark.sql | tee ./sql.log
+
diff --git a/odd/fib/4_wasm_benchmark b/odd/fib/4_wasm_benchmark
new file mode 100755
index 0000000000000000000000000000000000000000..50ff989106deb52c643abf87edea4891e5f27512
--- /dev/null
+++ b/odd/fib/4_wasm_benchmark
@@ -0,0 +1,2 @@
+
+gsql -d opengauss -e -f ./wasm_benchmark.sql | tee ./wasm.log
diff --git a/odd/fib/5_compare_results b/odd/fib/5_compare_results
new file mode 100755
index 0000000000000000000000000000000000000000..81f28b27c481deda2d094bfa1647465ab6c09cf7
--- /dev/null
+++ b/odd/fib/5_compare_results
@@ -0,0 +1,22 @@
+#!/bin/bash
+
+INPUTS=(0 10 30 50 70 90)
+
+grep "Time: " ./sql.log | awk -F ":" '{print $2}' > ./sql.time
+grep "Time: " ./wasm.log | awk -F ":"  '{print $2}' > ./wasm.time
+
+echo "|  INPUT  |   PLPGSQL   |     WASM    |"
+echo "---------------------------------------"
+
+for line in `seq 1 5`
+do 
+    sql_time_tmp=`sed -n "${line}p" ./sql.time`
+    wasm_time_tmp=`sed -n "${line}p" ./wasm.time`
+    echo "|    ${INPUTS[${line}]}   |  ${sql_time_tmp}  |  ${wasm_time_tmp}  |"
+done
+
+echo "---------------------------------------"
+
+
+rm -f ./sql.time
+rm -f ./wasm.time
diff --git a/odd/fib/Cargo.toml b/odd/fib/Cargo.toml
new file mode 100644
index 0000000000000000000000000000000000000000..a3bfce995f76d83a3f8fadf7cc5f2766684b9f39
--- /dev/null
+++ b/odd/fib/Cargo.toml
@@ -0,0 +1,12 @@
+[package]
+name = "fib"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+opengauss_bindgen = "0.1.0"
+
+[lib]
+crate-type = ["cdylib"]
diff --git a/odd/fib/sql_benchmark.sql b/odd/fib/sql_benchmark.sql
new file mode 100644
index 0000000000000000000000000000000000000000..9c59a0bb0584ff26874b095eaa2ae212117ee142
--- /dev/null
+++ b/odd/fib/sql_benchmark.sql
@@ -0,0 +1,12 @@
+
+\timing
+
+select sql_fib(10);
+
+select sql_fib(30);
+
+select sql_fib(50);
+
+select sql_fib(70);
+
+select sql_fib(90);
diff --git a/odd/fib/src/lib.rs b/odd/fib/src/lib.rs
new file mode 100644
index 0000000000000000000000000000000000000000..3eb7704194b2814a99ae885c5980889e46b9475a
--- /dev/null
+++ b/odd/fib/src/lib.rs
@@ -0,0 +1,18 @@
+#[opengauss_bindgen::opengauss_bindgen]
+fn fib(n: u64) -> u64 {
+    if n <= 1 {
+        n
+    } else {
+        let mut accumulator = 0;
+        let mut last = 0;
+        let mut current = 1;
+
+        for _i in 1..n {
+            accumulator = last + current;
+            last = current;
+            current = accumulator;
+        }
+
+        accumulator
+    }
+}
diff --git a/odd/fib/wasm_benchmark.sql b/odd/fib/wasm_benchmark.sql
new file mode 100644
index 0000000000000000000000000000000000000000..73dc9f82a258c3efa30897c4620c8951d6b4ad00
--- /dev/null
+++ b/odd/fib/wasm_benchmark.sql
@@ -0,0 +1,13 @@
+
+\timing
+
+select ws_fib(10);
+
+select ws_fib(30);
+
+select ws_fib(50);
+
+select ws_fib(70);
+
+select ws_fib(90);
+
diff --git a/wasm/Makefile b/wasm/Makefile
index ed62f59313f6cffe26821f221ad50c3e08217b5b..3fc2b99970389ddbbc69f624b89bde114ab86745 100644
--- a/wasm/Makefile
+++ b/wasm/Makefile
@@ -1,10 +1,10 @@
 # contrib/wasm/Makefile
 
-MODULE_big = wasm_executor
-OBJS= wasm_executor.o
+MODULE_big = wasm_engine
+OBJS= wasm_engine.o
 
-EXTENSION = wasm_executor
-DATA = wasm_executor--1.0.sql
+EXTENSION = wasm_engine
+DATA = wasm_engine--1.0.sql
 
 SHLIB_LINK_INTERNAL = $(libpq)
 SHLIB_LINK += -lwasmedge
diff --git a/wasm/examples/encrypt_decrypt/Cargo.toml b/wasm/examples/encrypt_decrypt/Cargo.toml
index 68cc4249424efbae67c1e6f7676b02ed12b00262..37f550008682aa3a817023daa3e1ee3eb75a6dc5 100644
--- a/wasm/examples/encrypt_decrypt/Cargo.toml
+++ b/wasm/examples/encrypt_decrypt/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-opengauss_bindgen = { version = "0", path = "../../bindgen" }
+opengauss_bindgen = "0.1.0"
 magic-crypt = "3.1"
 
 [lib]
diff --git a/wasm/examples/encrypt_decrypt/README b/wasm/examples/encrypt_decrypt/README
index d72c98d03af1210271239b6fbc5804b51103dd68..79534f4088ed3e98b9b3267d7decab411fbe9bd4 100644
--- a/wasm/examples/encrypt_decrypt/README
+++ b/wasm/examples/encrypt_decrypt/README
@@ -1,11 +1,12 @@
-CREATE EXTENSION wasm_executor;
+
+CREATE EXTENSION wasm_engine;
 
 SELECT wasm_new_instance('/home/opengauss/encrypt_decrypt.wasm', 'gs');
 
 CREATE TABLE users (
-username TEXT PRIMARY KEY,
-email TEXT,
-passwd TEXT
+    username TEXT PRIMARY KEY,
+    email TEXT,
+    passwd TEXT
 );
 
 CREATE TABLE secrets(secret text);
diff --git a/wasm/wasm_executor--1.0.sql b/wasm/wasm_engine--1.0.sql
similarity index 100%
rename from wasm/wasm_executor--1.0.sql
rename to wasm/wasm_engine--1.0.sql
diff --git a/wasm/wasm_executor.control b/wasm/wasm_engine.control
similarity index 76%
rename from wasm/wasm_executor.control
rename to wasm/wasm_engine.control
index 35e09a0305107ff0cbc14e11654858d0368e8ec2..b0a37f8cac95a4564cfa7592b8476f12974ac2e2 100755
--- a/wasm/wasm_executor.control
+++ b/wasm/wasm_engine.control
@@ -1,5 +1,5 @@
 # wasm_executor extension
 comment = 'wasm runtime executor for opengauss based on wasmtime'
 default_version = '1.0'
-module_pathname = '$libdir/wasm_executor'
+module_pathname = '$libdir/wasm_engine'
 relocatable = true
diff --git a/wasm/wasm_executor.cpp b/wasm/wasm_engine.cpp
similarity index 88%
rename from wasm/wasm_executor.cpp
rename to wasm/wasm_engine.cpp
index e69996258a027f6536d7c01a1505ae2f49692368..904c86fc17981ae6ebcb8a1d417a8b3608d4177b 100644
--- a/wasm/wasm_executor.cpp
+++ b/wasm/wasm_engine.cpp
@@ -71,7 +71,7 @@ static WasmVM* find_wasm_vm(int64 instanceid)
         }
         itor++;
     }
-    // elog(DEBUG1, "wasm_executor: not find instance info for instanceid %ld", instanceid);
+    // elog(DEBUG1, "wasm_engine: not find instance info for instanceid %ld", instanceid);
     return NULL;
 }
 
@@ -84,7 +84,7 @@ static std::vector<WasmFuncInfo*>* find_exported_func_list(int64 instanceid)
         }
         itor++;
     }
-    // elog(DEBUG1, "wasm_executor: not find exported func info for instanceid %ld", instanceid);
+    // elog(DEBUG1, "wasm_engine: not find exported func info for instanceid %ld", instanceid);
     return NULL;
 }
 
@@ -99,7 +99,7 @@ static int64 wasm_invoke_function(char *instanceid_str, char* funcname, std::vec
     int64 instanceid = atol(instanceid_str);
     WasmVM* wasmVM = find_wasm_vm(instanceid);
     if (wasmVM == NULL) {
-        ereport(ERROR, (errmsg("wasm_executor: instance with id %ld is not find", instanceid)));
+        ereport(ERROR, (errmsg("wasm_engine: instance with id %ld is not find", instanceid)));
     }
 
     WasmEdge_Value params[args.size()];
@@ -112,7 +112,7 @@ static int64 wasm_invoke_function(char *instanceid_str, char* funcname, std::vec
     WasmEdge_Result ret = WasmEdge_VMExecute(wasmVM->vm_context, wasm_func, params, args.size(), result, 1);
     if (!WasmEdge_ResultOK(ret)) {
         WasmEdge_StringDelete(wasm_func);
-        ereport(ERROR, (errmsg("wasm_executor: call func %s failed", funcname)));
+        ereport(ERROR, (errmsg("wasm_engine: call func %s failed", funcname)));
     } 
     int64 ret_val = 0;
     ret_val = WasmEdge_ValueGetI64(result[0]);
@@ -127,7 +127,7 @@ static char* wasm_invoke_function2(char *instanceid_str, char* funcname, std::ve
     int64 instanceid = atol(instanceid_str);
     WasmVM* wasmVM = find_wasm_vm(instanceid);
     if (wasmVM == NULL) {
-        ereport(ERROR, (errmsg("wasm_executor: instance with id %ld is not find", instanceid)));
+        ereport(ERROR, (errmsg("wasm_engine: instance with id %ld is not find", instanceid)));
     }
 
     WasmEdge_VMContext *vm_context = wasmVM->vm_context;
@@ -152,7 +152,7 @@ static char* wasm_invoke_function2(char *instanceid_str, char* funcname, std::ve
         res = WasmEdge_VMExecute(vm_context, wasmedge_func_name, malloc_param, 1, results, 1);
         WasmEdge_StringDelete(wasmedge_func_name);
         if (!WasmEdge_ResultOK(res)) {
-            ereport(ERROR, (errmsg("wasm_executor: call opengauss malloc failed")));
+            ereport(ERROR, (errmsg("wasm_engine: call opengauss malloc failed")));
         }
         mem_offset = WasmEdge_ValueGetI32(results[0]);
 
@@ -167,7 +167,7 @@ static char* wasm_invoke_function2(char *instanceid_str, char* funcname, std::ve
     res = WasmEdge_VMExecute(vm_context, wasmedge_func_name, params, args.size(), results, 1);
     WasmEdge_StringDelete(wasmedge_func_name);
     if (!WasmEdge_ResultOK(res)) {
-        ereport(ERROR, (errmsg("wasm_executor: call func %s failed", funcname)));
+        ereport(ERROR, (errmsg("wasm_engine: call func %s failed", funcname)));
     }
 
     int type_offset = WasmEdge_ValueGetI32(results[0]);
@@ -196,14 +196,14 @@ static void wasm_export_funcs_query(int64 instanceid, TupleFuncState* inter_call
 {
     WasmVM *wasmVM = find_wasm_vm(instanceid);
     if (wasmVM == NULL) {
-        ereport(ERROR, (errmsg("wasm_executor: instance with id %ld is not find", instanceid)));
+        ereport(ERROR, (errmsg("wasm_engine: instance with id %ld is not find", instanceid)));
     }
 
     std::vector<WasmFuncInfo *>* functions = find_exported_func_list(instanceid);
     if (functions != NULL) {
         inter_call_data->currindex = functions->begin();
         inter_call_data->lastindex = functions->end();
-        //elog(DEBUG1, "wasm_executor:find exported func info for instanceid %ld", instanceid);
+        //elog(DEBUG1, "wasm_engine:find exported func info for instanceid %ld", instanceid);
         return;
     }
 
@@ -220,20 +220,20 @@ static void wasm_export_funcs_query(int64 instanceid, TupleFuncState* inter_call
     for (unsigned int i = 0; i < rel_func_num && i < BUF_LEN; ++i) {
         char tmp_buffer[BUF_LEN] = {0};
         uint32_t func_name_len = WasmEdge_StringCopy(func_name_list[i], tmp_buffer, sizeof(tmp_buffer));
-        // elog(DEBUG1, "wasm_executor: exported function string length: %u, name: %s\n", func_name_len, tmp_buffer);
+        // elog(DEBUG1, "wasm_engine: exported function string length: %u, name: %s\n", func_name_len, tmp_buffer);
         if (strcmp(tmp_buffer, malloc_func) == 0) {
-            // elog(DEBUG1, "wasm_executor: opengauss_malloc is not need to export to user\n");
+            // elog(DEBUG1, "wasm_engine: opengauss_malloc is not need to export to user\n");
             continue;
         }
 
         uint32_t param_nums = WasmEdge_FunctionTypeGetParametersLength(func_type_list[i]);
         if (param_nums > MAX_PARAMS) {
-            ereport(ERROR, (errmsg("wasm_executor: func %s has more than 10 params which not support", tmp_buffer)));
+            ereport(ERROR, (errmsg("wasm_engine: func %s has more than 10 params which not support", tmp_buffer)));
         }
 
         uint32_t return_num = WasmEdge_FunctionTypeGetReturnsLength(func_type_list[i]);
         if (return_num > MAX_RETURNS) {
-            ereport(ERROR, (errmsg("wasm_executor: func %s has more than 1 return value which not support", tmp_buffer)));
+            ereport(ERROR, (errmsg("wasm_engine: func %s has more than 1 return value which not support", tmp_buffer)));
         }
 
         WasmFuncInfo *funcinfo = new(std::nothrow)WasmFuncInfo();
@@ -246,7 +246,7 @@ static void wasm_export_funcs_query(int64 instanceid, TupleFuncState* inter_call
             } else if (param_buffer[j] == WasmEdge_ValType_I64) {
                 funcinfo->inputs.push_back("bigint");
             } else {
-                ereport(ERROR, (errmsg("wasm_executor: not support the value type(%d) for now", param_buffer[j])));
+                ereport(ERROR, (errmsg("wasm_engine: not support the value type(%d) for now", param_buffer[j])));
             }
         }
         
@@ -256,7 +256,7 @@ static void wasm_export_funcs_query(int64 instanceid, TupleFuncState* inter_call
         } else if (param_buffer[0] == WasmEdge_ValType_I64) {
             funcinfo->outputs = "bigint";
         } else {
-            ereport(ERROR, (errmsg("wasm_executor: not support the value type(%d) for now", param_buffer[0])));
+            ereport(ERROR, (errmsg("wasm_engine: not support the value type(%d) for now", param_buffer[0])));
         }
 
         funcinfo->funcname = std::string(tmp_buffer, func_name_len);
@@ -265,7 +265,7 @@ static void wasm_export_funcs_query(int64 instanceid, TupleFuncState* inter_call
 
     inter_call_data->currindex = functions->begin();
     inter_call_data->lastindex = functions->end();
-    // elog(DEBUG1, "wasm_executor:init exported func info for instanceid %ld", instanceid); 
+    // elog(DEBUG1, "wasm_engine:init exported func info for instanceid %ld", instanceid); 
 }
 
 static WasmVM* create_wasm_instance_internal(char* filepath)
@@ -278,19 +278,19 @@ static WasmVM* create_wasm_instance_internal(char* filepath)
     WasmEdge_Result result = WasmEdge_VMLoadWasmFromFile(vm_cxt, filepath);
     if (!WasmEdge_ResultOK(result)) {
         WasmEdge_ConfigureDelete(config_context);
-        ereport(ERROR, (errmsg("wasm_executor: failed to load %s", filepath)));
+        ereport(ERROR, (errmsg("wasm_engine: failed to load %s", filepath)));
     }
 
     result = WasmEdge_VMValidate(vm_cxt);
     if (!WasmEdge_ResultOK(result)) {
         WasmEdge_ConfigureDelete(config_context);
-        ereport(ERROR, (errmsg("wasm_executor: wasm file validation failed %s", WasmEdge_ResultGetMessage(result))));
+        ereport(ERROR, (errmsg("wasm_engine: wasm file validation failed %s", WasmEdge_ResultGetMessage(result))));
     }
 
     result = WasmEdge_VMInstantiate(vm_cxt);
     if (!WasmEdge_ResultOK(result)) {
         WasmEdge_ConfigureDelete(config_context);
-        ereport(ERROR, (errmsg("wasm_executor: wasm vm initialize failed: %s", WasmEdge_ResultGetMessage(result))));
+        ereport(ERROR, (errmsg("wasm_engine: wasm vm initialize failed: %s", WasmEdge_ResultGetMessage(result))));
     }
     WasmEdge_ConfigureDelete(config_context);
 
@@ -311,11 +311,11 @@ Datum wasm_create_instance(PG_FUNCTION_ARGS)
 
     if (!superuser())
         ereport(ERROR,
-            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("wasm_executor: must be system admin to create wasm instance"))));
+            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("wasm_engine: must be system admin to create wasm instance"))));
 
     WasmVM *wasmVM = find_wasm_vm(uuid);
     if (wasmVM != NULL) {
-        ereport(NOTICE, (errmsg("wasm_executor: instance already created for %s", filepath)));
+        ereport(NOTICE, (errmsg("wasm_engine: instance already created for %s", filepath)));
         return UInt32GetDatum(uuid);
     }
     
@@ -333,14 +333,14 @@ Datum wasm_drop_instance(PG_FUNCTION_ARGS)
     
     if (!superuser())
         ereport(ERROR,
-            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("wasm_executor: must be system admin to delete wasm instance"))));
+            (errcode(ERRCODE_INSUFFICIENT_PRIVILEGE), (errmsg("wasm_engine: must be system admin to delete wasm instance"))));
 
     std::map<int64, WasmVM*>::iterator institor = instances.begin();
     while (institor != instances.end() && institor->first != instanceid) {
         institor++;
     }
     if (institor == instances.end()) {
-        ereport(ERROR, (errmsg("wasm_executor:instance with id=%ld not exist", instanceid)));
+        ereport(ERROR, (errmsg("wasm_engine:instance with id=%ld not exist", instanceid)));
     }
     module_path = CStringGetTextDatum((institor->second->wasm_file).c_str());
     instances.erase(institor);
@@ -368,7 +368,7 @@ Datum wasm_get_instances(PG_FUNCTION_ARGS)
 
         /* Build a tuple descriptor for our result type */
         if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
-            elog(ERROR, "wasm_executor: return type must be a row type");
+            elog(ERROR, "wasm_engine: return type must be a row type");
 
         inter_call_data->tupd = tupdesc;
         inter_call_data->currindex = instances.begin();
@@ -421,7 +421,7 @@ Datum wasm_get_exported_functions(PG_FUNCTION_ARGS)
         
         /* Build a tuple descriptor for our result type */
         if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
-            elog(ERROR, "wasm_executor: return type must be a row type");
+            elog(ERROR, "wasm_engine: return type must be a row type");
 
         inter_call_data->tupd = tupdesc;
         wasm_export_funcs_query(instanceid, inter_call_data);
@@ -579,17 +579,17 @@ Datum wasm_invoke_function_text_2(PG_FUNCTION_ARGS)
 void _PG_init(void)
 {
     /**
-     * When openGauss start up and load the wasm_executor.so, it should call
+     * When openGauss start up and load the wasm_engine.so, it should call
      * this function to check whether it has created instances.
      * If has, call the create instance interface to restore them.
      */
     int ret;
     if ((ret = SPI_connect()) < 0) {
-        elog(ERROR, "wasm_executor: SPI_connect returned %d", ret);
+        elog(ERROR, "wasm_engine: SPI_connect returned %d", ret);
     }
 
     if ((ret = SPI_exec("SELECT id, wasm_file FROM wasm.instances", 0)) < 0) {
-        elog(ERROR, "wasm_executor: SPI_connect exec query failed: %d", ret);
+        elog(ERROR, "wasm_engine: SPI_connect exec query failed: %d", ret);
     }
     
     if (SPI_tuptable) {
@@ -608,4 +608,4 @@ void _PG_init(void)
     }
     
     SPI_finish();
-}
\ No newline at end of file
+}