diff --git a/example/main.cpp b/example/main.cpp
index 22e1a3a6..994ca02b 100644
--- a/example/main.cpp
+++ b/example/main.cpp
@@ -18,12 +18,13 @@
 using namespace ormpp;
 const char *password = "";
 const char *ip = "127.0.0.1";
+const char *username = "root";
 const char *db = "test_ormppdb";
 
 struct person {
-  int id;
   std::optional<std::string> name;
   std::optional<int> age;
+  int id;
 };
 REFLECTION(person, id, name, age)
 
@@ -38,11 +39,11 @@ int main() {
 #ifdef ORMPP_ENABLE_MYSQL
   {
     dbng<mysql> mysql;
-    if (mysql.connect(ip, "root", password, db)) {
+    if (mysql.connect(ip, username, password, db)) {
       mysql.create_datatable<person>(ormpp_auto_key{"id"});
       mysql.delete_records<person>();
-      mysql.insert<person>({0, "purecpp"});
-      mysql.insert<person>({0, "purecpp", 6});
+      mysql.insert<person>({"purecpp"});
+      mysql.insert<person>({"purecpp", 6});
     }
     else {
       std::cout << "connect fail" << std::endl;
@@ -50,7 +51,7 @@ int main() {
   }
 
   {
-    connection_pool<dbng<mysql>>::instance().init(4, ip, "root", password, db,
+    connection_pool<dbng<mysql>>::instance().init(4, ip, username, password, db,
                                                   5, 3306);
     auto conn = connection_pool<dbng<mysql>>::instance().get();
     conn_guard guard(conn);
@@ -68,10 +69,10 @@ int main() {
 
   {
     sqlite.delete_records<person>();
-    sqlite.insert<person>({0, "purecpp"});
-    sqlite.insert<person>({0, "purecpp", 6});
+    sqlite.insert<person>({"purecpp"});
+    sqlite.insert<person>({"purecpp", 6});
     auto vec = sqlite.query<person>();
-    for (auto &[id, name, age] : vec) {
+    for (auto &[name, age, id] : vec) {
       std::cout << id << ", " << *name << ", " << *age << "\n";
     }
   }
@@ -84,13 +85,13 @@ int main() {
     sqlite.insert<student>({0, "purecpp", 3});
     {
       auto vec = sqlite.query<student>("name='purecpp'", "order by age desc");
-      for (auto &[id, name, age] : vec) {
+      for (auto &[name, age, id] : vec) {
         std::cout << id << ", " << name << ", " << age << "\n";
       }
     }
     {
       auto vec = sqlite.query<student>("age=3", "order by id desc", "limit 1");
-      for (auto &[id, name, age] : vec) {
+      for (auto &[name, age, id] : vec) {
         std::cout << id << ", " << name << ", " << age << "\n";
       }
     }
diff --git a/include/mysql.hpp b/include/mysql.hpp
index 9c636d24..62968b78 100644
--- a/include/mysql.hpp
+++ b/include/mysql.hpp
@@ -449,6 +449,9 @@ class mysql {
 
   // just support execute string sql without placeholders
   bool execute(const std::string &sql) {
+#ifdef ORMPP_ENABLE_LOG
+    std::cout << sql << std::endl;
+#endif
     reset_error();
     if (mysql_query(con_, sql.data()) != 0) {
       set_last_error(mysql_error(con_));
diff --git a/include/postgresql.hpp b/include/postgresql.hpp
index 64690e8e..c396ce82 100644
--- a/include/postgresql.hpp
+++ b/include/postgresql.hpp
@@ -75,93 +75,22 @@ class postgresql {
 
   template <typename T, typename... Args>
   constexpr int insert(const T &t, Args &&...args) {
-    std::string sql = generate_auto_insert_sql<T>(auto_key_map_, false);
-    if (!prepare<T>(sql))
-      return INT_MIN;
-
-    return insert_impl(sql, t, std::forward<Args>(args)...);
+    return insert_or_update(false, t, std::forward<Args>(args)...);
   }
 
   template <typename T, typename... Args>
   constexpr int insert(const std::vector<T> &v, Args &&...args) {
-    std::string sql = generate_auto_insert_sql<T>(auto_key_map_, false);
-
-    if (!begin())
-      return INT_MIN;
-
-    if (!prepare<T>(sql))
-      return INT_MIN;
-
-    for (auto &item : v) {
-      auto result = insert_impl(sql, item, std::forward<Args>(args)...);
-      if (result == INT_MIN) {
-        rollback();
-        return INT_MIN;
-      }
-    }
-
-    if (!commit())
-      return INT_MIN;
-
-    return (int)v.size();
+    return insert_or_update(false, v, std::forward<Args>(args)...);
   }
 
-  // if there is no key in a table, you can set some fields as a condition in
-  // the args...
   template <typename T, typename... Args>
   constexpr int update(const T &t, Args &&...args) {
-    // transaction, firstly delete, secondly insert
-    auto name = get_name<T>();
-    auto it = key_map_.find(name.data());
-    auto key = it == key_map_.end() ? "" : it->second;
-
-    auto condition = get_condition(t, key, std::forward<Args...>(args)...);
-    if (!begin())
-      return INT_MIN;
-
-    if (!delete_records<T>(condition)) {
-      rollback();
-      return INT_MIN;
-    }
-
-    if (insert(t) < 0) {
-      rollback();
-      return INT_MIN;
-    }
-
-    if (!commit())
-      return INT_MIN;
-
-    return 1;
+    return insert_or_update(true, t, std::forward<Args>(args)...);
   }
 
   template <typename T, typename... Args>
   constexpr int update(const std::vector<T> &v, Args &&...args) {
-    // transaction, firstly delete, secondly insert
-    if (!begin())
-      return INT_MIN;
-
-    auto name = get_name<T>();
-    auto it = key_map_.find(name.data());
-    auto key = it == key_map_.end() ? "" : it->second;
-    for (auto &t : v) {
-      auto condition = get_condition(t, key, std::forward<Args...>(args)...);
-
-      if (!delete_records<T>(condition)) {
-        rollback();
-        return INT_MIN;
-      }
-
-      if (insert(t) < 0) {
-        rollback();
-        return INT_MIN;
-      }
-    }
-
-    if (!commit())
-      return INT_MIN;
-
-    return (int)v.size();
+    return insert_or_update(true, v, std::forward<Args>(args)...);
   }
 
   template <typename T, typename... Args>
@@ -253,16 +182,14 @@ class postgresql {
   template <typename T, typename... Args>
   constexpr bool delete_records(Args &&...where_conditon) {
     auto sql = generate_delete_sql<T>(std::forward<Args>(where_conditon)...);
-#ifdef ORMPP_ENABLE_LOG
-    std::cout << sql << std::endl;
-#endif
-    res_ = PQexec(con_, sql.data());
-    auto guard = guard_statment(res_);
-    return PQresultStatus(res_) == PGRES_COMMAND_OK;
+    return execute(sql);
   }
 
   // just support execute string sql without placeholders
   auto execute(const std::string &sql) {
+#ifdef ORMPP_ENABLE_LOG
+    std::cout << sql << std::endl;
+#endif
     res_ = PQexec(con_, sql.data());
     auto guard = guard_statment(res_);
     return PQresultStatus(res_) == PGRES_COMMAND_OK;
@@ -435,14 +362,11 @@ class postgresql {
   }
 
   template <typename T, typename... Args>
-  constexpr int insert_impl(const std::string &sql, const T &t,
-                            Args &&...args) {
-#ifdef ORMPP_ENABLE_LOG
-    std::cout << sql << std::endl;
-#endif
+  constexpr int insert_impl(bool update, const T &t, Args &&...args) {
     std::vector<std::vector<char>> param_values;
     auto it = auto_key_map_.find(get_name<T>());
-    std::string auto_key = (it == auto_key_map_.end()) ? "" : it->second;
+    std::string auto_key =
+        (update || it == auto_key_map_.end()) ? "" : it->second;
     iguana::for_each(t, [&t, &param_values, auto_key, this](auto item, auto i) {
       if (!auto_key.empty() &&
           auto_key == iguana::get_name<T>(decltype(i)::value).data()) {
@@ -466,6 +390,89 @@ class postgresql {
     return PQresultStatus(res_) == PGRES_COMMAND_OK ? 1 : INT_MIN;
   }
 
+  template <typename T, typename... Args>
+  constexpr int insert_or_update(bool update, const T &t, Args &&...args) {
+    std::string sql =
+        update ? generate_update_sql<T>(std::forward<Args...>(args)...)
+               : generate_auto_insert_sql<T>(auto_key_map_, false);
+#ifdef ORMPP_ENABLE_LOG
+    std::cout << sql << std::endl;
+#endif
+    if (!prepare<T>(sql))
+      return INT_MIN;
+
+    return insert_impl(update, t, std::forward<Args>(args)...);
+  }
+
+  template <typename T, typename... Args>
+  constexpr int insert_or_update(bool update, const std::vector<T> &v,
+                                 Args &&...args) {
+    std::string sql =
+        update ? generate_update_sql<T>(std::forward<Args...>(args)...)
+               : generate_auto_insert_sql<T>(auto_key_map_, false);
+#ifdef ORMPP_ENABLE_LOG
+    std::cout << sql << std::endl;
+#endif
+    if (!begin())
+      return INT_MIN;
+
+    if (!prepare<T>(sql))
+      return INT_MIN;
+
+    for (auto &item : v) {
+      auto result = insert_impl(update, item, std::forward<Args>(args)...);
+      if (result == INT_MIN) {
+        rollback();
+        return INT_MIN;
+      }
+    }
+
+    if (!commit())
+      return INT_MIN;
+
+    return (int)v.size();
+  }
+
+  template <typename T, typename... Args>
+  inline std::string generate_update_sql(Args &&...args) {
+    constexpr auto SIZE = iguana::get_value<T>();
+    std::string sql = "insert into ";
+    auto name = get_name<T>();
+    append(sql, name.data());
+    int index = 0;
+    std::string set;
+    std::string fields = "(";
+    std::string values = "values(";
+    auto it = key_map_.find(name.data());
+    for (auto i = 0; i < SIZE; ++i) {
+      std::string field_name = iguana::get_name<T>(i).data();
+      std::string value = "$" + std::to_string(++index);
+      set += field_name + "=" + value;
+      fields += field_name;
+      values += value;
+      if (i < SIZE - 1) {
+        fields += ", ";
+        values += ", ";
+        set += ", ";
+      }
+      else {
+        fields += ")";
+        values += ")";
+        set += ";";
+      }
+    }
+    std::string conflict = "on conflict(";
+    if constexpr (sizeof...(args) > 0) {
+      append(conflict, args...);
+    }
+    else {
+      conflict += it->second;
+    }
+    conflict += ")";
+    append(sql, fields, values, conflict, "do update set", set);
+    return sql;
+  }
+
   template <typename T>
   constexpr void set_param_values(std::vector<std::vector<char>> &param_values,
                                   T &&value) {
@@ -543,58 +550,6 @@ class postgresql {
     }
   }
 
-  template <typename T, typename... Args>
-  constexpr std::string get_condition(const T &t, const std::string &key,
-                                      Args &&...args) {
-    std::string result = "";
-    constexpr auto SIZE = iguana::get_value<T>();
-    iguana::for_each(t, [&](auto &item, auto i) {
-      constexpr auto Idx = decltype(i)::value;
-      using U = std::remove_reference_t<decltype(iguana::get<Idx>(
-          std::declval<T>()))>;
-      if (!key.empty() && key == iguana::get_name<T, Idx>().data()) {
-        if constexpr (std::is_arithmetic_v<U>) {
-          append(result, iguana::get_name<T, Idx>().data(), "=",
-                 std::to_string(t.*item));
-        }
-        else if constexpr (std::is_same_v<std::string, U>) {
-          append(result, iguana::get_name<T, Idx>().data(), "=", t.*item);
-        }
-      }
-
-      // if constexpr (sizeof...(Args)>0){
-      build_condition_by_key<T, Idx>(result, t.*item, args...);
-      //(test(args), ...);
-      //	(build_condition_by_key_impl(result, t.*item, args),...);
-      ////can't pass U in vs2017
-      //}
-    });
-
-    return result;
-  }
-
-  template <typename T, size_t Idx, typename V, typename... Args>
-  void build_condition_by_key(std::string &result, const V &t, Args... args) {
-    (build_condition_by_key<T, Idx>(result, t, args), ...);
-  }
-
-  template <typename T, size_t Idx, typename V, typename W>
-  void build_condition_by_key_impl(std::string &result, const V &val, W &key) {
-    using U =
-        std::remove_reference_t<decltype(iguana::get<Idx>(std::declval<T>()))>;
-    if (key == iguana::get_name<T, Idx>().data()) {
-      if constexpr (std::is_arithmetic_v<U>) {
-        append(result, " and ");
-        append(result, iguana::get_name<T, Idx>().data(), "=",
-               std::to_string(val));
-      }
-      else if constexpr (std::is_same_v<std::string, U>) {
-        append(result, " and ");
-        append(result, iguana::get_name<T, Idx>().data(), "=", val);
-      }
-    }
-  }
-
  private:
   struct guard_statment {
     guard_statment(PGresult *res) : res_(res) { reset_error(); }
diff --git a/include/sqlite.hpp b/include/sqlite.hpp
index fa6a8bb4..635a6e07 100644
--- a/include/sqlite.hpp
+++ b/include/sqlite.hpp
@@ -218,6 +218,9 @@ class sqlite {
 
   // just support execute string sql without placeholders
   bool execute(const std::string &sql) {
+#ifdef ORMPP_ENABLE_LOG
+    std::cout << sql << std::endl;
+#endif
     int result = sqlite3_prepare_v2(handle_, sql.data(), (int)sql.size(),
                                     &stmt_, nullptr);
     if (result != SQLITE_OK) {
diff --git a/include/utility.hpp b/include/utility.hpp
index 7c70da79..1ba3fa53 100644
--- a/include/utility.hpp
+++ b/include/utility.hpp
@@ -188,7 +188,7 @@ inline std::string generate_auto_insert_sql(
 
   int index = 0;
   std::string fields = "(";
-  std::string values = " values(";
+  std::string values = "values(";
   auto it = auto_key_map_.find(name.data());
   for (auto i = 0; i < SIZE; ++i) {
     std::string field_name = iguana::get_name<T>(i).data();
diff --git a/tests/test_ormpp.cpp b/tests/test_ormpp.cpp
index 70c35868..1662ca09 100644
--- a/tests/test_ormpp.cpp
+++ b/tests/test_ormpp.cpp
@@ -1014,12 +1014,12 @@ TEST_CASE("create table with unique") {
     mysql.execute("drop table if exists person");
     mysql.create_datatable<person>(ormpp_auto_key{"id"},
                                    ormpp_unique{{"name", "age"}});
-    mysql.insert<person>({"purecpp", 200});
+    mysql.insert<person>({"purecpp"});
     auto vec1 = mysql.query<person>("order by id");
     auto vec2 = mysql.query<person>("limit 1");
     CHECK(vec1.size() == 1);
     CHECK(vec2.size() == 1);
-    mysql.insert<person>({"purecpp", 200});
+    mysql.insert<person>({"purecpp"});
     auto vec3 = mysql.query<person>();
     CHECK(vec3.size() == 1);
   }
@@ -1031,12 +1031,12 @@ TEST_CASE("create table with unique") {
     sqlite.execute("drop table if exists person");
     sqlite.create_datatable<person>(ormpp_auto_key{"id"},
                                     ormpp_unique{{"name", "age"}});
-    sqlite.insert<person>({"purecpp", 200});
+    sqlite.insert<person>({"purecpp"});
     auto vec1 = sqlite.query<person>("order by id");
     auto vec2 = sqlite.query<person>("limit 1");
     CHECK(vec1.size() == 1);
     CHECK(vec2.size() == 1);
-    sqlite.insert<person>({"purecpp", 200});
+    sqlite.insert<person>({"purecpp"});
     auto vec3 = sqlite.query<person>();
     CHECK(vec3.size() == 1);
   }
@@ -1049,9 +1049,9 @@ TEST_CASE("get insert id") {
   if (mysql.connect(ip, username, password, db)) {
     mysql.execute("drop table if exists person");
     mysql.create_datatable<person>(ormpp_auto_key{"id"});
-    mysql.insert<person>({"purecpp", 200});
-    mysql.insert<person>({"purecpp", 200});
-    int id = mysql.insert<person>({"purecpp", 200}, true);
+    mysql.insert<person>({"purecpp"});
+    mysql.insert<person>({"purecpp"});
+    int id = mysql.insert<person>({"purecpp"}, true);
     CHECK(id == 3);
   }
 #endif
@@ -1061,9 +1061,9 @@ TEST_CASE("get insert id") {
   if (sqlite.connect(db)) {
     sqlite.execute("drop table if exists person");
     sqlite.create_datatable<person>(ormpp_auto_key{"id"});
-    sqlite.insert<person>({"purecpp", 200});
-    sqlite.insert<person>({"purecpp", 200});
-    int id = sqlite.insert<person>({"purecpp", 200}, true);
+    sqlite.insert<person>({"purecpp"});
+    sqlite.insert<person>({"purecpp"});
+    int id = sqlite.insert<person>({"purecpp"}, true);
     CHECK(id == 3);
   }
 #endif
@@ -1073,10 +1073,10 @@ TEST_CASE("delete records") {
 #ifdef ORMPP_ENABLE_MYSQL
   dbng<mysql> mysql;
   if (mysql.connect(ip, username, password, db)) {
+    mysql.execute("drop table if exists person");
     mysql.create_datatable<person>(ormpp_auto_key{"id"});
-    mysql.delete_records<person>();
-    mysql.insert<person>({"other", 200});
-    mysql.insert<person>({"purecpp", 200});
+    mysql.insert<person>({"other"});
+    mysql.insert<person>({"purecpp"});
     mysql.delete_records<person>("name = 'other';drop table person");
     auto vec = mysql.query<person>();
     CHECK(vec.size() == 2);
@@ -1085,10 +1085,10 @@ TEST_CASE("delete records") {
 #ifdef ORMPP_ENABLE_PG
   // dbng<postgresql> postgres;
   // if (postgres.connect(ip, username, password, db)) {
+  //   postgres.execute("drop table if exists person");
   //   postgres.create_datatable<person>(ormpp_auto_key{"id"});
-  //   postgres.delete_records<person>();
-  //   postgres.insert<person>({"other", 200});
-  //   postgres.insert<person>({purecpp", 200});
+  //   postgres.insert<person>({"other"});
+  //   postgres.insert<person>({"purecpp"});
   //   postgres.delete_records<person>("name = 'other';drop table person");
   //   auto vec = postgres.query<person>();
   //   CHECK(vec.size() == 2);
@@ -1097,10 +1097,10 @@ TEST_CASE("delete records") {
 #ifdef ORMPP_ENABLE_SQLITE3
   dbng<sqlite> sqlite;
   if (sqlite.connect(db)) {
+    sqlite.execute("drop table if exists person");
     sqlite.create_datatable<person>(ormpp_auto_key{"id"});
-    sqlite.delete_records<person>();
-    sqlite.insert<person>({"other", 200});
-    sqlite.insert<person>({"purecpp", 200});
+    sqlite.insert<person>({"other"});
+    sqlite.insert<person>({"purecpp"});
     sqlite.delete_records<person>("name = 'other';drop table person");
     auto vec = sqlite.query<person>();
     CHECK(vec.size() == 1);
@@ -1138,3 +1138,22 @@ TEST_CASE("alias") {
   }
 #endif
 }
+
+#ifdef ORMPP_ENABLE_PG
+TEST_CASE("pg update") {
+  dbng<postgresql> postgres;
+  if (postgres.connect(ip, username, password, db)) {
+    postgres.execute("drop table if exists person");
+    postgres.create_datatable<person>(ormpp_auto_key{"id"});
+    postgres.insert<person>({"purecpp"});
+    auto vec1 = postgres.query<person>();
+    CHECK(vec1.size() == 1);
+    vec1.front().name = "other";
+    postgres.update<person>(vec1.front());
+    auto vec2 = postgres.query<person>();
+    CHECK(vec2.size() == 1);
+    CHECK(vec2.front().name == "other");
+    CHECK(vec1.front().id == vec2.front().id);
+  }
+}
+#endif
\ No newline at end of file