Use name aliases for update and delete in datamapper

Author: Yaraslaut

src/Lightweight/DataMapper/DataMapper.hpp

@@ -832,7 +832,7 @@ void DataMapper::Update(Record& record)
     {
         if (record.[:el:].IsModified())
         {
-            _stmt.BindInputParameter(i++, record.[:el:].Value(), std::meta::identifier_of(el));
+            _stmt.BindInputParameter(i++, record.[:el:].Value(), FieldNameOf<el>);
         }
     }
 
@@ -841,23 +841,21 @@ void DataMapper::Update(Record& record)
         using FieldType = typename[:std::meta::type_of(el):];
         if constexpr (FieldType::IsPrimaryKey)
         {
-            _stmt.BindInputParameter(i++, record.[:el:].Value(), std::meta::identifier_of(el));
+            _stmt.BindInputParameter(i++, record.[:el:].Value(), FieldNameOf<el>);
         }
     }
 #else
     // Bind the SET clause
-    Reflection::CallOnMembers(
-        record, [this, &i]<typename Name, typename FieldType>(Name const& name, FieldType const& field) mutable {
-            if (field.IsModified())
-                _stmt.BindInputParameter(i++, field.Value(), name);
-        });
+    Reflection::CallOnMembersWithoutName(record, [this, &i]<size_t I, typename FieldType>(FieldType const& field) {
+        if (field.IsModified())
+            _stmt.BindInputParameter(i++, field.Value(), FieldNameAt<I, Record>);
+    });
 
     // Bind the WHERE clause
-    Reflection::CallOnMembers(
-        record, [this, &i]<typename Name, typename FieldType>(Name const& name, FieldType const& field) mutable {
-            if constexpr (FieldType::IsPrimaryKey)
-                _stmt.BindInputParameter(i++, field.Value(), name);
-        });
+    Reflection::CallOnMembersWithoutName(record, [this, &i]<size_t I, typename FieldType>(FieldType const& field) {
+        if constexpr (IsPrimaryKey<Reflection::MemberTypeOf<I, Record>>)
+            _stmt.BindInputParameter(i++, field.Value(), FieldNameAt<I, Record>);
+    });
 #endif
 
     _stmt.Execute();
@@ -878,14 +876,13 @@ std::size_t DataMapper::Delete(Record const& record)
     {
         using FieldType = typename[:std::meta::type_of(el):];
         if constexpr (FieldType::IsPrimaryKey)
-            std::ignore = query.Where(std::meta::identifier_of(el), SqlWildcard);
+            std::ignore = query.Where(FieldNameOf<el>, SqlWildcard);
     }
 #else
-    Reflection::CallOnMembers(record,
-                              [&query]<typename Name, typename FieldType>(Name const& name, FieldType const& /*field*/) {
-                                  if constexpr (FieldType::IsPrimaryKey)
-                                      std::ignore = query.Where(name, SqlWildcard);
-                              });
+    Reflection::CallOnMembersWithoutName(record, [&query]<size_t I, typename FieldType>(FieldType const& /*field*/) {
+        if constexpr (IsPrimaryKey<Reflection::MemberTypeOf<I, Record>>)
+            std::ignore = query.Where(FieldNameAt<I, Record>, SqlWildcard);
+    });
 #endif
 
     _stmt.Prepare(query);
@@ -897,16 +894,15 @@ std::size_t DataMapper::Delete(Record const& record)
         using FieldType = typename[:std::meta::type_of(el):];
         if constexpr (FieldType::IsPrimaryKey)
         {
-            _stmt.BindInputParameter(i++, record.[:el:].Value(), std::meta::identifier_of(el));
+            _stmt.BindInputParameter(i++, record.[:el:].Value(), FieldNameOf<el>);
         }
     }
 #else
     // Bind the WHERE clause
-    Reflection::CallOnMembers(
-        record,
-        [this, i = SQLSMALLINT { 1 }]<typename Name, typename FieldType>(Name const& name, FieldType const& field) mutable {
-            if constexpr (FieldType::IsPrimaryKey)
-                _stmt.BindInputParameter(i++, field.Value(), name);
+    Reflection::CallOnMembersWithoutName(
+        record, [this, i = SQLSMALLINT { 1 }]<size_t I, typename FieldType>(FieldType const& field) mutable {
+            if constexpr (IsPrimaryKey<Reflection::MemberTypeOf<I, Record>>)
+                _stmt.BindInputParameter(i++, field.Value(), FieldNameAt<I, Record>);
         });
 #endif
 

src/tests/DataMapper/NamingTests.cpp

@@ -70,6 +70,13 @@ struct NamingTest2
     static constexpr std::string_view TableName = "NamingTest2_aliased"sv;
 };
 
+struct Person
+{
+    Light::Field<int, Light::PrimaryKey::AutoAssign, Light::SqlRealName { "index" }> id;
+    Light::Field<Light::SqlAnsiString<50>, Light::SqlRealName { "not_name" }> name;
+    static constexpr std::string_view TableName = "Human"sv;
+};
+
 } // namespace Models
 
 TEST_CASE_METHOD(SqlTestFixture, "SQL entity naming (namespace)", "[DataMapper]")
@@ -82,3 +89,44 @@ TEST_CASE_METHOD(SqlTestFixture, "SQL entity naming (namespace)", "[DataMapper]"
     CHECK(FieldNameAt<1, Models::NamingTest2> == "Second_PK"sv);
     CHECK(RecordTableName<Models::NamingTest2> == "NamingTest2_aliased"sv);
 }
+
+TEST_CASE_METHOD(SqlTestFixture, "Check aliasing of the columns and table for crud operation", "[DataMapper]")
+{
+    auto dm = DataMapper::Create();
+
+    dm->CreateTable<Models::Person>();
+
+    auto record1 = Models::Person {};
+    record1.name = "42";
+
+    CHECK(dm->Query<Models::Person>().Count() == 0);
+    CHECK(record1.id.Value() == 0);
+    dm->Create(record1);
+    CHECK(dm->Query<Models::Person>().Count() == 1);
+    CHECK(record1.id.Value() != 0);
+    {
+        auto queriedRecordResult = dm->QuerySingle<Models::Person>(record1.id);
+        CHECK(queriedRecordResult.has_value());
+        CHECK(queriedRecordResult.value().name.Value().ToStringView()
+              == "42"sv); // NOLINT(bugprone-unchecked-optional-access)
+    }
+
+    record1.name = "43";
+    dm->Update(record1);
+
+    SqlStatement(dm->Connection())
+        .ExecuteDirect(R"( INSERT INTO "Human" ("index", "not_name") VALUES (5, 'Direct Insert') )");
+    CHECK(dm->Query<Models::Person>().Count() == 2);
+    {
+        auto queriedRecordResult = dm->QuerySingle<Models::Person>(record1.id);
+        CHECK(queriedRecordResult.has_value());
+        CHECK(queriedRecordResult.value().name.Value().ToStringView()
+              == "43"sv); // NOLINT(bugprone-unchecked-optional-access)
+    }
+    dm->Delete(record1);
+    CHECK(dm->Query<Models::Person>().Count() == 1);
+    {
+        auto queriedRecord = dm->QuerySingle<Models::Person>(record1.id);
+        CHECK(!queriedRecord.has_value());
+    }
+}