Rename class

Author: Giorgi

ClassMap-Usage.md AppenderMap-Usage.mdClassMap-Usage.md renamed to AppenderMap-Usage.md

@@ -1,19 +1,19 @@
-# ClassMap-based Type-Safe Appender
+# AppenderMap-based Type-Safe Appender
 
-This implementation provides a type-safe way to append data to DuckDB tables using ClassMap-based mappings with automatic type validation.
+This implementation provides a type-safe way to append data to DuckDB tables using AppenderMap-based mappings with automatic type validation.
 
 ## Problem Solved
 
-The original issue was that users could accidentally append values with mismatched types (e.g., `decimal` to `REAL` column), causing silent data corruption. The ClassMap approach validates types against actual column types from the database.
+The original issue was that users could accidentally append values with mismatched types (e.g., `decimal` to `REAL` column), causing silent data corruption. The AppenderMap approach validates types against actual column types from the database.
 
 ## How It Works
 
-### 1. Define a ClassMap
+### 1. Define an AppenderMap
 
-Create a ClassMap that defines property mappings in column order:
+Create an AppenderMap that defines property mappings in column order:
 
 ```csharp
-public class PersonMap : DuckDBClassMap<Person>
+public class PersonMap : DuckDBAppenderMap<Person>
 {
     public PersonMap()
     {
@@ -61,7 +61,7 @@ The mapped appender retrieves actual column types from the database and validate
 
 ### 3. **Support for Default and Null Values**
 ```csharp
-public class MyMap : DuckDBClassMap<MyData>
+public class MyMap : DuckDBAppenderMap<MyData>
 {
     public MyMap()
     {

DuckDB.NET.Data/DuckDBConnection.cs

@@ -187,43 +187,43 @@ string GetTableName()
     }
 
     /// <summary>
-    /// Creates a type-safe appender using a ClassMap for property-to-column mappings.
+    /// Creates a type-safe appender using an AppenderMap for property-to-column mappings.
     /// </summary>
     /// <typeparam name="T">The type to append</typeparam>
-    /// <typeparam name="TMap">The ClassMap type defining the mappings</typeparam>
+    /// <typeparam name="TMap">The AppenderMap type defining the mappings</typeparam>
     /// <param name="table">The table name</param>
     /// <returns>A type-safe mapped appender</returns>
     public DuckDBMappedAppender<T, TMap> CreateAppender<T, TMap>(string table) 
-        where TMap : Mapping.DuckDBClassMap<T>, new()
+        where TMap : Mapping.DuckDBAppenderMap<T>, new()
     {
         return CreateAppender<T, TMap>(null, null, table);
     }
 
     /// <summary>
-    /// Creates a type-safe appender using a ClassMap for property-to-column mappings.
+    /// Creates a type-safe appender using an AppenderMap for property-to-column mappings.
     /// </summary>
     /// <typeparam name="T">The type to append</typeparam>
-    /// <typeparam name="TMap">The ClassMap type defining the mappings</typeparam>
+    /// <typeparam name="TMap">The AppenderMap type defining the mappings</typeparam>
     /// <param name="schema">The schema name</param>
     /// <param name="table">The table name</param>
     /// <returns>A type-safe mapped appender</returns>
     public DuckDBMappedAppender<T, TMap> CreateAppender<T, TMap>(string? schema, string table)
-        where TMap : Mapping.DuckDBClassMap<T>, new()
+        where TMap : Mapping.DuckDBAppenderMap<T>, new()
     {
         return CreateAppender<T, TMap>(null, schema, table);
     }
 
     /// <summary>
-    /// Creates a type-safe appender using a ClassMap for property-to-column mappings.
+    /// Creates a type-safe appender using an AppenderMap for property-to-column mappings.
     /// </summary>
     /// <typeparam name="T">The type to append</typeparam>
-    /// <typeparam name="TMap">The ClassMap type defining the mappings</typeparam>
+    /// <typeparam name="TMap">The AppenderMap type defining the mappings</typeparam>
     /// <param name="catalog">The catalog name</param>
     /// <param name="schema">The schema name</param>
     /// <param name="table">The table name</param>
     /// <returns>A type-safe mapped appender</returns>
     public DuckDBMappedAppender<T, TMap> CreateAppender<T, TMap>(string? catalog, string? schema, string table)
-        where TMap : Mapping.DuckDBClassMap<T>, new()
+        where TMap : Mapping.DuckDBAppenderMap<T>, new()
     {
         var appender = CreateAppender(catalog, schema, table);
         return new DuckDBMappedAppender<T, TMap>(appender);

DuckDB.NET.Data/DuckDBMappedAppender.cs

@@ -7,11 +7,11 @@
 namespace DuckDB.NET.Data;
 
 /// <summary>
-/// A type-safe appender that uses ClassMap to validate type mappings.
+/// A type-safe appender that uses AppenderMap to validate type mappings.
 /// </summary>
 /// <typeparam name="T">The type being appended</typeparam>
-/// <typeparam name="TMap">The ClassMap type defining the mappings</typeparam>
-public class DuckDBMappedAppender<T, TMap> : IDisposable where TMap : DuckDBClassMap<T>, new()
+/// <typeparam name="TMap">The AppenderMap type defining the mappings</typeparam>
+public class DuckDBMappedAppender<T, TMap> : IDisposable where TMap : DuckDBAppenderMap<T>, new()
 {
     private readonly DuckDBAppender appender;
     private readonly List<IPropertyMapping<T>> mappings;
@@ -27,13 +27,13 @@ internal DuckDBMappedAppender(DuckDBAppender appender)
         // Validate mappings match the table structure
         if (mappings.Count == 0)
         {
-            throw new InvalidOperationException($"ClassMap {typeof(TMap).Name} has no property mappings defined");
+            throw new InvalidOperationException($"AppenderMap {typeof(TMap).Name} has no property mappings defined");
         }
 
         var columnTypes = appender.LogicalTypes;
         if (mappings.Count != columnTypes.Count)
         {
-            throw new InvalidOperationException($"ClassMap {typeof(TMap).Name} has {mappings.Count} mappings but table has {columnTypes.Count} columns");
+            throw new InvalidOperationException($"AppenderMap {typeof(TMap).Name} has {mappings.Count} mappings but table has {columnTypes.Count} columns");
         }
 
         for (int index = 0; index < mappings.Count; index++)

DuckDB.NET.Data/Mapping/DuckDBClassMap.cs …DB.NET.Data/Mapping/DuckDBAppenderMap.csDuckDB.NET.Data/Mapping/DuckDBClassMap.cs renamed to DuckDB.NET.Data/Mapping/DuckDBAppenderMap.cs DuckDB.NET.Data/Mapping/DuckDBClassMap.cs renamed to DuckDB.NET.Data/Mapping/DuckDBAppenderMap.cs

@@ -6,10 +6,10 @@
 namespace DuckDB.NET.Data.Mapping;
 
 /// <summary>
-/// Base class for defining mappings between .NET classes and DuckDB table columns.
+/// Base class for defining mappings between .NET classes and DuckDB table columns for appender operations.
 /// </summary>
 /// <typeparam name="T">The type to map</typeparam>
-public abstract class DuckDBClassMap<T>
+public abstract class DuckDBAppenderMap<T>
 {
     /// <summary>
     /// Gets the property mappings defined for this class map.

DuckDB.NET.Test/DuckDBMappedAppenderTests.cs

@@ -16,8 +16,8 @@ public class Person
         public DateTime BirthDate { get; set; }
     }
 
-    // ClassMap for Person - matches the example from the comment
-    public class PersonMap : DuckDBClassMap<Person>
+    // AppenderMap for Person - matches the example from the comment
+    public class PersonMap : DuckDBAppenderMap<Person>
     {
         public PersonMap()
         {
@@ -66,7 +66,7 @@ public void MappedAppender_ValidatesTypeMatching()
     }
 
     // Example with type mismatch - should throw
-    public class WrongTypeMap : DuckDBClassMap<Person>
+    public class WrongTypeMap : DuckDBAppenderMap<Person>
     {
         public WrongTypeMap()
         {
@@ -98,7 +98,7 @@ public class PersonWithDefaults
         public string Name { get; set; } = string.Empty;
     }
 
-    public class PersonWithDefaultsMap : DuckDBClassMap<PersonWithDefaults>
+    public class PersonWithDefaultsMap : DuckDBAppenderMap<PersonWithDefaults>
     {
         public PersonWithDefaultsMap()
         {