Skip to content

Make key_source restrict-only: add key_source_restriction, deprecate parent-redefining overrides #1523

Open

Description

@dimitri-yatsenko

Summary

Make key_source a restrict-only surface. Today key_source can be overridden freely, including in ways that redefine the parent join — and that is the source of subtle, hard-to-diagnose bugs. Introduce a first-class key_source_restriction that applies a restriction to the default key_source without changing the parents, and steer users (and the docs) toward it.

Background

key_source defaults to the join of the tables referenced by the foreign keys in a computed/imported table's primary key (Autopopulate → Key Source Calculation). populate() iterates over it, passing each key to make(key).

The default is almost always correct. In practice, the only legitimate reason to modify it is to restrict it — compute a subset of the default source (e.g. a completion barrier that fires only when all members of a batch have results). Restricting keeps the parents and the grain intact; each make(key) still receives a fully-formed primary key.

Overriding key_source to redefine the parent join — dropping a parent, adding one, or reconstructing the key from an aggregate — is a different and dangerous operation: it can change or drop primary-key attributes, so make(key) receives a key that is missing attributes or has attributes the table's primary key doesn't declare. The downstream effects (partial inserts, mismatched keys, silent miscomputation) are hard to reason about, and the framework was not designed for it.

Proposal

  1. Introduce key_source_restriction — a declared restriction applied to the default key_source. It may be any valid DataJoint restriction, including a restriction by another table (a dependency visible in key_source but not necessarily as a formal FK edge). The computed source is default_key_source & key_source_restriction; the parents and grain are never changed.
  2. Deprecate user-facing redefinition of key_source. Treat key_source as an internal of the auto-populate machinery. Emit a warning when a subclass overrides key_source in a way that changes the parent join.
  3. Batching is a master–part concern, not a key_source concern. A run/cohort-level batch should be a master keyed on the batch with per-member results on a part — consistent with the DataJoint 2 rule that an auto-populated table introduces no new dimension (only its parts may). This removes the historical "batch by overriding key_source" motivation.

Rollout (per the 2026-07-24 design discussion)

  • 2.4: add key_source_restriction; begin warning on parent-redefining key_source overrides.
  • Docs now: remove key_source-override guidance/recommendations from the documentation; document key_source_restriction as the supported way to narrow a source.
  • Later: make key_source restriction-only (the override path removed as a user surface).

Docs task (coordinated)

datajoint-docs: pull any recommendation to override key_source, and document key_source_restriction + the "batch via master–part" guidance. (Autopopulate spec §2 and the how-to pages.)

cc @MilagrosMarin @ttngu207

Activity

  1. dimitri-yatsenko commented on Aug 17, 2026

    @dimitri-yatsenko
    MemberAuthor

    A second, independent justification for restrict-only: it is exactly what makes refreshing the jobs table without importing pipeline code possible.

    Today refresh() requires the pipeline codebase because an overridden key_source is arbitrary Python — unserializable in general. Any orchestration around DataJoint (a cron, a scheduler, a dashboard) must therefore run refresh inside an environment with the pipeline installed, just to materialize pending jobs.

    After this change, key_source = default FK-join & key_source_restriction, and the two halves have very different portability:

    • The FK-join is schema-derivable by any client — it is determined entirely by the primary-key foreign keys, which live in the database. No pipeline code needed.
    • The restriction is the only thing that needs registering, and a rendered restriction is a WHERE clause (or a pure-SQL subquery when restricting by another table). It cannot drift when parents change, because parents can't change it by construction.

    That suggests a small addition to this proposal: at declaration (or worker registration), write the rendered key_source_restriction SQL into the jobs table's metadata, with a stamp for staleness. Every jobs table becomes self-describing for refresh, and

    pending = (derived_fk_join & stored_restriction) - target - jobs
    

    becomes a generic operation any actor with DB credentials can run — a plain cron, an external scheduler, or eventually a trigger/CDC event restricted to the arriving key. Restrictions whose values must be recomputed at refresh time (moving clock windows, external-state probes) remain the one case needing code, and under restrict-only they are visibly deviant rather than structurally indistinguishable from normal overrides.

    Staleness also narrows: re-registration is needed only when the declared restriction changes, not on every code deployment.

    Worth weighing in the 2.4 design: whether the stored/rendered restriction (and a refresh() mode that executes from it) lands together with key_source_restriction or as a follow-up.

  2. github-actions commented on Oct 2, 2026

    @github-actions

    This issue is stale because it has been open for 45 days with no activity.

  3. added
    staleIndicates issues, pull requests, or discussions are inactive
    on Oct 2, 2026
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Metadata

Metadata

Assignees

No one assigned

    Labels

    staleIndicates issues, pull requests, or discussions are inactive

    Type

    No type

    Projects

    No projects

      Milestone

      No milestone

      Relationships

      None yet

      Development

      No branches or pull requests

      Issue actions