Populate lineage table at table declaration time

- Add populate_table_lineage() function in lineage.py
- Call it from Table.declare() after successful table creation
- For FK attributes: copy lineage from parent's lineage table
- For native PK attributes: set lineage to "schema.table.attribute"
- Native secondary attributes get no lineage entry

Author: claude

datajoint/lineage.py

@@ -125,6 +125,86 @@ def delete_table_lineage(self, table_name):
         (self & dict(table_name=table_name)).delete_quick()
 
 
+def populate_table_lineage(connection, schema, table_name, heading):
+    """
+    Populate lineage for a newly declared table.
+
+    Called at table declaration time to store lineage for all attributes:
+    - Native PK attributes: lineage = "schema.table.attribute"
+    - FK attributes: copy lineage from parent's lineage table
+    - Native secondary attributes: no entry (no lineage)
+
+    :param connection: database connection
+    :param schema: schema name
+    :param table_name: table name (without schema prefix)
+    :param heading: Heading object for the declared table
+    """
+    # Get or create the lineage table
+    lineage_table = LineageTable(connection, schema)
+
+    # Load FK info from dependencies
+    connection.dependencies.load(force=True)
+    full_table_name = f"`{schema}`.`{table_name}`"
+
+    # Build map of FK attributes -> (parent_schema, parent_table, parent_attr)
+    fk_sources = {}
+    if full_table_name in connection.dependencies:
+        for parent, props in connection.dependencies.parents(full_table_name).items():
+            # Skip alias nodes
+            if parent.isdigit():
+                continue
+            attr_map = props.get("attr_map", {})
+            parent_schema, parent_table = parse_full_table_name(parent)
+            for child_attr, parent_attr in attr_map.items():
+                fk_sources[child_attr] = (parent_schema, parent_table, parent_attr)
+
+    # Store lineage for each attribute
+    for attr_name in heading.names:
+        if attr_name in fk_sources:
+            # FK attribute - copy lineage from parent's lineage table
+            parent_schema, parent_table, parent_attr = fk_sources[attr_name]
+            parent_lineage = _get_parent_lineage(
+                connection, parent_schema, parent_table, parent_attr
+            )
+            if parent_lineage:
+                lineage_table.store_lineage(table_name, attr_name, parent_lineage)
+        elif attr_name in heading.primary_key:
+            # Native PK attribute - lineage to self
+            lineage = f"{schema}.{table_name}.{attr_name}"
+            lineage_table.store_lineage(table_name, attr_name, lineage)
+        # Native secondary attributes: no entry needed
+
+
+def _get_parent_lineage(connection, parent_schema, parent_table, parent_attr):
+    """
+    Get lineage for a parent attribute from its lineage table.
+
+    :param connection: database connection
+    :param parent_schema: parent schema name
+    :param parent_table: parent table name
+    :param parent_attr: parent attribute name
+    :return: lineage string or None
+    """
+    # Check if parent schema has a lineage table
+    lineage_table_exists = (
+        connection.query(
+            """
+        SELECT COUNT(*) FROM information_schema.tables
+        WHERE table_schema = %s AND table_name = '~lineage'
+        """,
+            args=(parent_schema,),
+        ).fetchone()[0]
+        > 0
+    )
+
+    if lineage_table_exists:
+        parent_lineage_table = LineageTable(connection, parent_schema)
+        return parent_lineage_table.get_lineage(parent_table, parent_attr)
+    else:
+        # Parent schema has no lineage table - attribute has no tracked lineage
+        return None
+
+
 # =============================================================================
 # Dependency Graph Method (fallback for non-DataJoint schemas)
 # =============================================================================

datajoint/table.py

@@ -119,6 +119,17 @@ def declare(self, context=None):
             pass
         else:
             self._log("Declared " + self.full_table_name)
+            # Populate lineage table for semantic matching
+            from .lineage import populate_table_lineage
+
+            try:
+                populate_table_lineage(
+                    self.connection, self.database, self.table_name, self.heading
+                )
+            except Exception as e:
+                logger.debug(
+                    f"Could not populate lineage for {self.full_table_name}: {e}"
+                )
 
     def alter(self, prompt=True, context=None):
         """