- update documentation

Author: NinjaRocks

docs/advanced.md

@@ -6,7 +6,7 @@ Mark a field with `[Encrypted]` to have values automatically encrypted before
 INSERT/UPDATE and decrypted after SELECT.
 
 ```csharp
-public class SecureData : IdentDataObject
+public class SecureData : IdentityRecord
 {
     [Column("SSN")]
     [Encrypted(typeof(AesEncryption), EncryptionMethodType.AllDataEncrypted)]
@@ -48,9 +48,9 @@ Implement `IDBFieldMapper` to handle non-standard CLR ↔ DB type conversions:
 ```csharp
 public class JsonMapper : IDBFieldMapper
 {
-    private DataObject _container;
+    private Record _container;
 
-    public void SetContainingDataObject(DataObject obj) => _container = obj;
+    public void SetContainingDataObject(Record obj) => _container = obj;
 
     public object ConvertToDBValue(object value)
         => value is MyStruct s ? System.Text.Json.JsonSerializer.Serialize(s) : null;
@@ -85,12 +85,12 @@ Pass `AppFactory` to the connection constructor.
 
 ## Lookup Objects
 
-`LookupDataObject` is a base class for reference / code-table entities whose rows are
+`LookupRecord` is a base class for reference / code-table entities whose rows are
 cached in memory after the first load.
 
 ```csharp
 [Table("Statuses")]
-public class Status : LookupDataObject
+public class Status : LookupRecord
 {
     [Column("Code")]  public TString Code  = new TString();
     [Column("Label")] public TString Label = new TString();
@@ -102,7 +102,7 @@ public class Status : LookupDataObject
 }
 ```
 
-When the ORM resolves a foreign-key relationship to a `LookupDataObject`, it reads from
+When the ORM resolves a foreign-key relationship to a `LookupRecord`, it reads from
 the in-memory cache rather than issuing a JOIN, reducing round trips for high-read
 reference tables.
 
@@ -131,13 +131,13 @@ Similarly: `QueueForUpdate()`, `QueueForDelete()`.
 var result = conn.ExecStoredProcedure(
     template, "usp_GetProductsByCategory",
     0 /*start*/, 0 /*count (0=all)*/,
-    new DataObject.SPInputParameter("@CategoryID", 2));
+    new Record.SPInputParameter("@CategoryID", 2));
 ```
 
 ## Raw SQL
 
 ```csharp
-// Returns an ObjectCollection populated from the query
+// Returns an RecordCollection populated from the query
 var results = conn.ExecSQL(template,
     "SELECT * FROM Products WHERE CreatedAt > @since",
     new Dictionary<string, object> { { "@since", DateTime.Today.AddDays(-7) } });

docs/di-service-proxies.md

@@ -96,7 +96,7 @@ public class OrderService : IOrderService, IService
         _conn.Read(order);
 
         order.Status.SetValue("Shipped");
-        order.Update(DataObjectLock.UpdateOption.IgnoreLock);
+        order.Update(RecordLock.UpdateOption.IgnoreLock);
         shipment.OrderID.SetValue(orderId);
         shipment.Insert();
         // Connection opened before this method; transaction commits here on success.
@@ -356,7 +356,7 @@ ActiveForgeServiceLocator.SetProvider(app.Services);
 With.Transaction(() =>
 {
     order.Status.SetValue("Shipped");
-    order.Update(DataObjectLock.UpdateOption.IgnoreLock);
+    order.Update(RecordLock.UpdateOption.IgnoreLock);
 });
 ```
 

docs/field-subsets.md

@@ -74,7 +74,7 @@ Console.WriteLine(p.Price);         // populated
 Console.WriteLine(p.Description);   // IsNull() == true — was not fetched
 
 // QueryAll with subset
-ObjectCollection results = conn.QueryAll(template, term, sort, 0, nameAndPrice);
+RecordCollection results = conn.QueryAll(template, term, sort, 0, nameAndPrice);
 
 // QueryFirst with subset
 conn.QueryFirst(template, term, sort, nameAndPrice);
@@ -113,15 +113,15 @@ conn.ProcessActionQueue();
 
 ## Field Subsets on Embedded (Joined) Objects
 
-When a `DataObject` embeds another `DataObject` as a field (joined table), you can
+When a `Record` embeds another `Record` as a field (joined table), you can
 include or exclude the entire embedded object's fields:
 
 ```csharp
 // Include all fields of the embedded Category object
 FieldSubset withCategory = conn.FieldSubset(
     rootObject:      product,
     enclosing:       product,
-    enclosed:        product.Category   // a nested DataObject
+    enclosed:        product.Category   // a nested Record
 );
 
 // Or exclude it to skip the JOIN entirely

docs/getting-started.md

@@ -64,14 +64,14 @@ If consuming published NuGet packages:
 
 ## Concepts
 
-### DataObject — the Active Record base
+### Record — the Active Record base
 
-Every database entity extends `DataObject` (or `IdentDataObject` for auto-increment PK tables).
+Every database entity extends `Record` (or `IdentityRecord` for auto-increment PK tables).
 Fields are declared as **public fields** of a `TField` subtype — not properties.
 
 ```csharp
 [Table("Customers")]
-public class Customer : IdentDataObject
+public class Customer : IdentityRecord
 {
     [Column("FirstName")] public TString  FirstName = new TString();
     [Column("LastName")]  public TString  LastName  = new TString();
@@ -86,7 +86,7 @@ public class Customer : IdentDataObject
 
 The `[Table]` attribute names the SQL table.
 The `[Column]` attribute names the SQL column.
-`IdentDataObject` adds an `ID` field (`TPrimaryKey`) with `[Identity]` — auto-populated after INSERT.
+`IdentityRecord` adds an `ID` field (`TPrimaryKey`) with `[Identity]` — auto-populated after INSERT.
 
 ### TField — null-aware typed wrapper
 
@@ -156,7 +156,7 @@ if (found)
 
 ```csharp
 c.Balance.SetValue(250m);
-c.Update(DataObjectLock.UpdateOption.IgnoreLock);
+c.Update(RecordLock.UpdateOption.IgnoreLock);
 
 // To update all fields unconditionally:
 c.UpdateAll();
@@ -165,7 +165,7 @@ c.UpdateAll();
 c.UpdateChanged();
 ```
 
-`DataObjectLock.UpdateOption` values:
+`RecordLock.UpdateOption` values:
 - `ReleaseLock` — release the optimistic lock after update
 - `RetainLock` — keep the lock (for subsequent updates in same transaction)
 - `IgnoreLock` — skip all locking (simplest, use for non-concurrent tables)
@@ -221,7 +221,7 @@ public class CustomerRepository
         return c.Read() ? c : null;
     }
 
-    public ObjectCollection GetActive()
+    public RecordCollection GetActive()
     {
         var template = new Customer(_conn);
         var term = new EqualTerm(template, template.Active, true);
@@ -231,7 +231,7 @@ public class CustomerRepository
     public void Save(Customer c)
     {
         if (c.ID.IsNull()) c.Insert();
-        else               c.Update(DataObjectLock.UpdateOption.IgnoreLock);
+        else               c.Update(RecordLock.UpdateOption.IgnoreLock);
     }
 
     public void Delete(Customer c) => c.Delete();

docs/joins.md

@@ -7,7 +7,7 @@ This document covers how ActiveForge ORM handles SQL JOINs — both the automati
 ## Overview
 
 ActiveForge ORM derives JOIN SQL from the **structure of your entity class**, not from a query builder.
-When you embed a `DataObject` field inside another `DataObject`, the ORM automatically emits a JOIN between the two tables when you query the outer type.
+When you embed a `Record` field inside another `Record`, the ORM automatically emits a JOIN between the two tables when you query the outer type.
 
 There are three layers of JOIN control:
 
@@ -23,7 +23,7 @@ There are three layers of JOIN control:
 
 If your entity class has:
 - a `TForeignKey` field named `XID` (e.g. `CategoryID`)
-- a `DataObject` field named `X` (e.g. `Category`) whose class name ends in `X`
+- a `Record` field named `X` (e.g. `Category`) whose class name ends in `X`
 
 the ORM automatically produces:
 
@@ -35,7 +35,7 @@ No attribute required.
 
 ```csharp
 [Table("Products")]
-public class ProductWithCategory : IdentDataObject
+public class ProductWithCategory : IdentityRecord
 {
     [Column("Name")]        public TString     Name       = new TString();
     [Column("Price")]       public TDecimal    Price      = new TDecimal();
@@ -65,7 +65,7 @@ Use `[JoinSpec]` to override the join type or specify non-standard column names.
 ```csharp
 [Table("Products")]
 [JoinSpec("CategoryID", "Category", "ID", JoinSpecAttribute.JoinTypeEnum.LeftOuterJoin)]
-public class ProductWithOptionalCategory : IdentDataObject
+public class ProductWithOptionalCategory : IdentityRecord
 {
     [Column("Name")]        public TString     Name       = new TString();
     [Column("Price")]       public TDecimal    Price      = new TDecimal();
@@ -89,7 +89,7 @@ var results = conn.QueryAll(new ProductWithOptionalCategory(conn), null, null, 0
 ```csharp
 [JoinSpec(
     sourceField:   "CategoryID",   // FK column on the outer table
-    targetField:   "Category",     // embedded DataObject field name
+    targetField:   "Category",     // embedded Record field name
     joinField:     "ID",           // PK column on the inner table
     joinType:      JoinSpecAttribute.JoinTypeEnum.LeftOuterJoin)]
 ```
@@ -98,11 +98,11 @@ var results = conn.QueryAll(new ProductWithOptionalCategory(conn), null, null, 0
 
 ## 3. Multiple FK Joins
 
-Embed multiple `DataObject` fields to produce multiple JOINs in one query.
+Embed multiple `Record` fields to produce multiple JOINs in one query.
 
 ```csharp
 [Table("OrderLines")]
-public class OrderLineWithDetails : IdentDataObject
+public class OrderLineWithDetails : IdentityRecord
 {
     [Column("OrderID")]   public TForeignKey OrderID   = new TForeignKey();
     [Column("ProductID")] public TForeignKey ProductID = new TForeignKey();
@@ -128,7 +128,7 @@ var lines = conn.QueryAll(new OrderLineWithDetails(conn), null, null, 0, null);
 
 ## 4. Filtering on Joined Columns (QueryTerm API)
 
-Pass the **embedded DataObject** (not the root template) as the `target` argument when building a `QueryTerm` against a joined column:
+Pass the **embedded Record** (not the root template) as the `target` argument when building a `QueryTerm` against a joined column:
 
 ```csharp
 var template = new ProductWithCategory(conn);
@@ -144,7 +144,7 @@ var both    = conn.QueryAll(template, term & inStock, null, 0, null);
 // WHERE Categories.Name = 'Books' AND Products.InStock = 1
 ```
 
-> **Note**: The first `EqualTerm` argument must be the _containing_ `DataObject` instance
+> **Note**: The first `EqualTerm` argument must be the _containing_ `Record` instance
 > (the embedded field's owner), not the root query template.
 > For top-level fields, pass the root template; for joined fields, pass the embedded object.
 
@@ -159,12 +159,12 @@ When using the LINQ query layer (`conn.Query<T>()`), you can:
 
 ### 5.1 Cross-Join `Where` Predicates
 
-Navigate to the embedded DataObject field in your lambda — the ORM resolves the correct table column automatically:
+Navigate to the embedded Record field in your lambda — the ORM resolves the correct table column automatically:
 
 ```csharp
 using ActiveForge.Linq;
 
-// Filter on a joined column — x.Category.Name navigates the embedded DataObject
+// Filter on a joined column — x.Category.Name navigates the embedded Record
 var books = conn.Query<ProductWithCategory>()
     .Where(x => x.Category.Name == "Books")
     .ToList();
@@ -275,7 +275,7 @@ var orders     = conn.QueryAll(orderTemplate, existsTerm, null, 0, null);
 
 | Limitation | Notes |
 |------------|-------|
-| No `JOIN` between unrelated tables | Joins must be expressed via embedded `DataObject` fields |
+| No `JOIN` between unrelated tables | Joins must be expressed via embedded `Record` fields |
 | No self-joins | A type cannot embed itself |
 | No many-to-many navigation | Bridge-table entities with two FKs can model this |
 | LINQ `Where` LHS must be a `TField` | `x.Category.SomeField` — works; arbitrary expressions — not supported |

docs/linq-querying.md

@@ -43,11 +43,11 @@ var items = conn.Query<Product>()
 ```csharp
 // DataConnectionExtensions (ActiveForge.Linq namespace)
 public static OrmQueryable<T> Query<T>(this DataConnection connection)
-    where T : DataObject;
+    where T : Record;
 
 // Overload with pre-constructed template (useful with custom factories or join queries)
 public static OrmQueryable<T> Query<T>(this DataConnection connection, T template)
-    where T : DataObject;
+    where T : Record;
 ```
 
 Internally, `Query<T>()` creates a template instance (`conn.Create(typeof(T))`), wraps it in an `OrmQueryable<T>`, and returns it.
@@ -222,12 +222,12 @@ foreach (var product in products)
 
 ## Querying Across Joins
 
-When your entity embeds another `DataObject` (triggering a JOIN), LINQ predicates and sort selectors can navigate into the joined type directly.
+When your entity embeds another `Record` (triggering a JOIN), LINQ predicates and sort selectors can navigate into the joined type directly.
 
 ### Cross-Join `Where` Predicates
 
 ```csharp
-// x.Category.Name navigates the embedded DataObject → maps to Categories.Name
+// x.Category.Name navigates the embedded Record → maps to Categories.Name
 conn.Query(new ProductWithCategory(conn))
     .Where(x => x.Category.Name == "Books")
     .ToList();
@@ -290,14 +290,14 @@ OrmQueryable<Product> orm = (OrmQueryable<Product>)q;
 QueryTerm combined = orm.WhereTerm & new EqualTerm(product, product.Category, "Electronics");
 
 // Execute using the classic API:
-ObjectCollection results = conn.QueryAll(product, combined, null, 0, null);
+RecordCollection results = conn.QueryAll(product, combined, null, 0, null);
 ```
 
 ---
 
 ## How It Works
 
-1. `conn.Query<T>()` creates an `OrmQueryable<T>` wrapping a template `DataObject` instance.
+1. `conn.Query<T>()` creates an `OrmQueryable<T>` wrapping a template `Record` instance.
 2. Each LINQ operator (`.Where(...)`, `.OrderBy(...)`, etc.) calls `IQueryProvider.CreateQuery()` on `OrmQueryProvider<T>`.
 3. `OrmQueryProvider<T>` recursively walks the expression tree, translating each operator into ORM state (WhereTerm, SortOrder, PageSize, SkipCount).
 4. When you enumerate (`ToList()`, `foreach`, etc.), `OrmQueryable<T>.GetEnumerator()` calls `conn.LazyQueryAll<T>(...)` or `conn.QueryPage(...)` with the accumulated state.
@@ -311,8 +311,8 @@ The expression tree is traversed **at execution time**, so local variables are c
 | Limitation | Notes |
 |------------|-------|
 | No `GroupBy` | Not supported; use raw SQL or `ExecSQL`. |
-| No `Join` clause | Cross-join predicates and sorts work via embedded `DataObject` fields. See [joins.md](joins.md). |
-| No `Select` projection | Returns full typed `DataObject` instances; field subsets can be applied at the `conn.Query<T>(template)` level. |
+| No `Join` clause | Cross-join predicates and sorts work via embedded `Record` fields. See [joins.md](joins.md). |
+| No `Select` projection | Returns full typed `Record` instances; field subsets can be applied at the `conn.Query<T>(template)` level. |
 | No `Count()`, `First()`, etc. | Call the standard ORM methods (`conn.QueryCount(...)`, `conn.QueryFirst(...)`) directly. |
 | No async support | Use the synchronous API; async is planned for a future release. |
 

docs/provider-appendix.md

@@ -924,7 +924,7 @@ Metadata about a single mapped field. Populated by `DBDataConnection.PopulateSQL
 ```csharp
 public class TargetFieldInfo
 {
-    public FieldInfo FieldInfo;         // Reflection handle to the TField field on the DataObject
+    public FieldInfo FieldInfo;         // Reflection handle to the TField field on the Record
     public string    FieldName;         // C# field name (e.g. "Name")
     public string    TargetName;        // DB column name (e.g. "ProductName")
     public string    SourceName;        // DB table alias / source name (e.g. "Products")
@@ -1004,7 +1004,7 @@ Created by `OrmQueryable<T>.InnerJoin<TJoined>()` / `.LeftOuterJoin<TJoined>()`.
 ```csharp
 public readonly struct JoinOverride
 {
-    public readonly Type                          TargetType; // which embedded DataObject type to override
+    public readonly Type                          TargetType; // which embedded Record type to override
     public readonly JoinSpecification.JoinTypeEnum JoinType;  // the replacement join type
 
     public JoinOverride(Type targetType, JoinSpecification.JoinTypeEnum joinType);
@@ -1154,7 +1154,7 @@ Use this checklist when building a new provider.
 - [ ] Identity assignment — verify the identity field is populated after INSERT
 - [ ] Query terms — `EqualTerm`, `LikeTerm`, `GreaterThanTerm`, `ContainsTerm` (IN clause)
 - [ ] Pagination — `QueryPage` with non-zero `start`
-- [ ] JOIN queries — inner join, left outer join via `QueryAll` with embedded `DataObject`
+- [ ] JOIN queries — inner join, left outer join via `QueryAll` with embedded `Record`
 - [ ] Transactions — commit path, rollback path, nested UoW depth
 - [ ] `IUnitOfWork` depth counter — outer commit only commits at depth 0
 - [ ] LINQ layer — `conn.Query<T>().Where(...).OrderBy(...).Take(...).Skip(...).ToList()`