Add string-based ontology API to eliminate double-interning

New constructors for ontology types that accept strings:
- IdentityKey::from_names(vec!["name", "email"], "key_name")
- StrongIdentifier::from_name("ssn", "ssn_unique")
- Constraint::unique_from_name("email", "unique_email")

The engine automatically interns pending attribute names when
the ontology is applied, eliminating the need to:
1. Create a temporary engine to get AttrIds
2. Configure the ontology with those IDs
3. Create a new engine with the configured ontology
4. Re-intern attributes

Before:
  let mut engine = Unirust::new(ontology.clone());
  let name = engine.intern_attr("name");
  ontology.add_identity_key(IdentityKey::new(vec![name], "key"));
  let mut engine = Unirust::new(ontology);  // recreate!
  let name = engine.intern_attr("name");    // re-intern!

After:
  ontology.add_identity_key(IdentityKey::from_names(vec!["name"], "key"));
  let mut engine = Unirust::new(ontology);  // auto-interns
  let name = engine.intern_attr("name");

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: script3r

examples/in_memory.rs

@@ -40,37 +40,25 @@ fn main() -> anyhow::Result<()> {
     // and strong identifiers as "these records are DEFINITELY different if this differs"
 
     let mut ontology = Ontology::new();
-    let mut engine = Unirust::new(ontology.clone());
-
-    // Create attribute IDs (interned strings for efficiency)
-    let name_attr = engine.intern_attr("name");
-    let email_attr = engine.intern_attr("email");
-    let _phone_attr = engine.intern_attr("phone");
-    let ssn_attr = engine.intern_attr("ssn");
 
     // Identity Key: Records with same (name + email) are candidates for merging
-    ontology.add_identity_key(IdentityKey::new(
-        vec![name_attr, email_attr],
-        "name_email".to_string(),
+    // Using from_names() - no need to pre-intern attributes!
+    ontology.add_identity_key(IdentityKey::from_names(
+        vec!["name", "email"],
+        "name_email",
     ));
 
     // Strong Identifier: SSN uniquely identifies a person
     // If two records have different SSNs, they CANNOT be merged
-    ontology.add_strong_identifier(StrongIdentifier::new(ssn_attr, "ssn_unique".to_string()));
+    ontology.add_strong_identifier(StrongIdentifier::from_name("ssn", "ssn_unique"));
 
     println!("Ontology configured:");
     println!("  - Identity Key: name + email (records match if both are equal)");
     println!("  - Strong ID: SSN (prevents merging if different)\n");
 
-    // Recreate engine with the configured ontology
+    // Create the engine - ontology attributes are automatically interned
     let mut engine = Unirust::new(ontology);
 
-    // Re-intern attributes (required after creating new engine)
-    let name_attr = engine.intern_attr("name");
-    let email_attr = engine.intern_attr("email");
-    let phone_attr = engine.intern_attr("phone"); // Used in records below
-    let ssn_attr = engine.intern_attr("ssn");
-
     // =========================================================================
     // Step 2: Create Records from Multiple Source Systems
     // =========================================================================
@@ -81,7 +69,12 @@ fn main() -> anyhow::Result<()> {
     // - RecordIdentity: Source system info (entity_type, perspective, uid)
     // - Descriptors: Attribute values with temporal validity intervals
 
-    // Intern the values we'll use
+    // Intern attributes and values for use in records
+    let name_attr = engine.intern_attr("name");
+    let email_attr = engine.intern_attr("email");
+    let phone_attr = engine.intern_attr("phone");
+    let ssn_attr = engine.intern_attr("ssn");
+
     let john_name = engine.intern_value("John Doe");
     let john_email = engine.intern_value("john@example.com");
     let ssn_123 = engine.intern_value("123-45-6789");

examples/persistent_shard.rs

@@ -73,47 +73,38 @@ fn main() -> anyhow::Result<()> {
     println!("Using tuning profile: {:?}\n", profile);
 
     // =========================================================================
-    // Step 3: Create Engine with Store
+    // Step 3: Configure Ontology
     // =========================================================================
     //
-    // Start with empty ontology - we'll configure it after interning attrs
+    // Using from_names() - no need to pre-intern attributes!
+    // The engine will automatically intern them when created.
 
-    let ontology = Ontology::new();
-    let mut engine = Unirust::with_store_and_tuning(ontology, store, tuning.clone());
+    let mut ontology = Ontology::new();
+
+    ontology.add_identity_key(IdentityKey::from_names(
+        vec!["name", "email"],
+        "name_email",
+    ));
+
+    ontology.add_strong_identifier(StrongIdentifier::from_name("ssn", "ssn_unique"));
+
+    println!("Ontology configured with identity key (name+email) and strong ID (ssn)\n");
 
     // =========================================================================
-    // Step 4: Configure Ontology
+    // Step 4: Create Engine with Store and Ontology
     // =========================================================================
     //
-    // Intern attribute IDs through the engine (which owns the store)
-    let name_attr = engine.intern_attr("name");
-    let email_attr = engine.intern_attr("email");
-    let _phone_attr = engine.intern_attr("phone");
-    let ssn_attr = engine.intern_attr("ssn");
-    let _dept_attr = engine.intern_attr("department");
-
-    // Create ontology with interned attributes
-    let mut ontology = Ontology::new();
-    ontology.add_identity_key(IdentityKey::new(
-        vec![name_attr, email_attr],
-        "name_email".to_string(),
-    ));
-    ontology.add_strong_identifier(StrongIdentifier::new(ssn_attr, "ssn_unique".to_string()));
+    // The engine automatically interns the ontology's attribute names.
 
-    // Recreate engine with configured ontology
-    // Note: Attributes are persisted, so they'll get the same IDs
-    let store = PersistentStore::open(&data_dir)?;
     let mut engine = Unirust::with_store_and_tuning(ontology, store, tuning);
 
-    // Re-intern attrs (will get same IDs from persisted interner)
+    // Intern attributes for use in records
     let name_attr = engine.intern_attr("name");
     let email_attr = engine.intern_attr("email");
     let phone_attr = engine.intern_attr("phone");
     let ssn_attr = engine.intern_attr("ssn");
     let dept_attr = engine.intern_attr("department");
 
-    println!("Ontology configured with identity key (name+email) and strong ID (ssn)\n");
-
     // =========================================================================
     // Step 5: Generate and Ingest Records
     // =========================================================================
@@ -240,12 +231,6 @@ fn main() -> anyhow::Result<()> {
     println!("  3. Re-open with PersistentStore::open()");
     println!("  4. All data would be recovered automatically");
 
-    // To actually demonstrate recovery:
-    // drop(engine);
-    // let store = PersistentStore::open(&data_dir)?;
-    // let engine = Unirust::with_store_and_tuning(ontology, store, tuning);
-    // println!("Recovered {} records", engine.stats().record_count);
-
     println!("\n✓ Example completed successfully!");
     println!("\nNext steps:");
     println!("  - Try 'cargo run --example cluster' for distributed mode");

src/conflicts.rs

@@ -1119,7 +1119,7 @@ impl ConflictDetector {
         // Check constraints across clusters (for unique constraints)
         for constraint in &ontology.constraints {
             match constraint {
-                Constraint::Unique { attribute, name } => {
+                Constraint::Unique { attribute, name, .. } => {
                     let cross_cluster_violations = Self::check_unique_constraint_across_clusters(
                         store, clusters, *attribute, name,
                     )?;
@@ -1262,12 +1262,12 @@ impl ConflictDetector {
         let mut violations = Vec::new();
 
         match constraint {
-            Constraint::Unique { attribute, name } => {
+            Constraint::Unique { attribute, name, .. } => {
                 let violations_for_attr =
                     Self::check_unique_constraint(store, cluster, *attribute, name)?;
                 violations.extend(violations_for_attr);
             }
-            Constraint::UniqueWithinPerspective { attribute, name } => {
+            Constraint::UniqueWithinPerspective { attribute, name, .. } => {
                 let violations_for_attr = Self::check_unique_within_perspective_constraint(
                     store, cluster, *attribute, name,
                 )?;

src/lib.rs

@@ -212,10 +212,17 @@ impl Unirust {
     }
 
     /// Create a new Unirust instance with a custom store implementation.
-    pub fn with_store<S>(ontology: Ontology, store: S) -> Self
+    ///
+    /// Any identity keys, strong identifiers, or constraints created with string-based
+    /// APIs (e.g., `IdentityKey::from_names`) will have their attribute names automatically
+    /// interned using the store's interner.
+    pub fn with_store<S>(mut ontology: Ontology, mut store: S) -> Self
     where
         S: RecordStore + 'static,
     {
+        // Intern any pending attribute names in the ontology
+        ontology.intern_attributes(|name| store.intern_attr(name));
+
         Self {
             store: Box::new(store),
             ontology,
@@ -228,10 +235,18 @@ impl Unirust {
         }
     }
 
-    pub fn with_store_and_tuning<S>(ontology: Ontology, store: S, tuning: StreamingTuning) -> Self
+    /// Create a new Unirust instance with a custom store and tuning configuration.
+    ///
+    /// Any identity keys, strong identifiers, or constraints created with string-based
+    /// APIs (e.g., `IdentityKey::from_names`) will have their attribute names automatically
+    /// interned using the store's interner.
+    pub fn with_store_and_tuning<S>(mut ontology: Ontology, mut store: S, tuning: StreamingTuning) -> Self
     where
         S: RecordStore + 'static,
     {
+        // Intern any pending attribute names in the ontology
+        ontology.intern_attributes(|name| store.intern_attr(name));
+
         Self {
             store: Box::new(store),
             ontology,