exwiw 1.1.5 → 1.1.7

data/lib/exwiw/query_ast_builder.rb

@@ -6,31 +6,77 @@ module Exwiw
       new(table_name, table_by_name, dump_target, logger, allow_reverse: allow_reverse, allow_declared_reverse: allow_declared_reverse, forward_path: forward_path, reverse_path: reverse_path, deep_chain_warned: deep_chain_warned, batch_ids: batch_ids).run
     end
 
+    # The self-referencing foreign keys whose ancestors a narrowed `table` also
+    # keeps. A polymorphic one is not supported: following it would also need its
+    # type column checked at every step.
+    def self.self_ancestor_links(table)
+      return [] if table.primary_key.nil?
+
+      table.belongs_tos.filter_map do |relation|
+        next unless relation.table_name == table.name
+        next if relation.polymorphic?
+
+        QueryAst::AncestorLink.new(foreign_key: relation.foreign_key, references: relation.references)
+      end.uniq
+    end
+
     # Scope-column mode classification for a single table. One of
     # :exempt / :direct / :via_path / :referenced_by / :via_scoped_parent / :unscopable.
     def self.scope_category(table_name, table_by_name, dump_target, logger)
       new(table_name, table_by_name, dump_target, logger).scope_category
     end
 
-    # Scope-column mode is active when EITHER the named `--target-table` declares a
-    # per-table `scope_column` (the preferred trigger: the target is then scoped
-    # like any other table — its `--ids` are scope-column values, not primary
-    # keys), OR the deprecated `--scope-column` flag is set (a global column with no
-    # target). In both cases every table is filtered by a shared column instead of
-    # being anchored on one named target's primary key.
+    # Scope-column mode is active when the named `--target-table` declares a
+    # per-table `scope_column` (the target is then scoped like any other table,
+    # and its `--ids` are scope-column values, not primary keys); when no target is
+    # named but `--ids` are given and some table declares a `scope_column`; or when
+    # the deprecated `--scope-column` flag is set (a global column with no target).
+    # In each case every table is filtered by a shared column instead of being
+    # anchored on one named target's primary key.
     def self.scope_mode?(table_by_name, dump_target)
       return true unless dump_target.scope_column.nil?
-      return false if dump_target.table_name.nil?
+      if dump_target.table_name.nil?
+        return ids_given?(dump_target) && scope_column_declared?(table_by_name)
+      end
 
       target = table_by_name[dump_target.table_name]
       !!(target && target.respond_to?(:scope_column) && target.scope_column)
     end
 
+    def self.ids_given?(dump_target)
+      dump_target.ids.each_value.any?(&:any?)
+    end
+
+    # An ignore:true table is not extracted, so its declaration cannot anchor the
+    # scope.
+    def self.scope_column_declared?(table_by_name)
+      table_by_name.each_value.any? do |table|
+        !table.ignore && table.respond_to?(:scope_column) && !table.scope_column.nil?
+      end
+    end
+
+    # `--ids` without `--target-table` (and without the deprecated flag) selects
+    # scope-column mode, which needs a declared `scope_column` to start from.
+    def self.validate_ids_anchor!(table_by_name, dump_target)
+      return unless dump_target.table_name.nil? && dump_target.scope_column.nil?
+      return unless ids_given?(dump_target)
+      return if scope_column_declared?(table_by_name)
+
+      raise ArgumentError,
+            "--ids was given without --target-table, but no table in the schema declares " \
+            "`scope_column` (tables marked `ignore: true` are not counted). Either name the table " \
+            "the ids belong to with --target-table (single-target mode), or declare " \
+            "`scope_column: <column>` on the tables to filter by it (scope-column mode)."
+    end
+
     # Strict pre-flight: abort if any extractable table cannot be scoped (scope
     # mode), or declares a `batch_scope` its scoping shape cannot be sliced by
     # (both modes) — before any output is written. `tables` is the set of
     # dumpable configs (ignore:true tables are skipped — they are not extracted).
     def self.validate_scope!(tables, table_by_name, dump_target, logger)
+      validate_ids_anchor!(table_by_name, dump_target)
+      validate_named_id_spaces_allowed!(tables, table_by_name, dump_target)
+
       # Unscopable is reported before a bad batch_scope shape — it is the more
       # fundamental problem.
       if scope_mode?(table_by_name, dump_target)
@@ -57,15 +103,91 @@ module Exwiw
                 "add a belongs_to path to a table that carries the scope column, mark it " \
                 "`scope_exempt: true` to export it in full, or set `ignore: true` to skip it."
         end
+
+        validate_id_space_values!(tables, table_by_name, dump_target, logger)
+        validate_single_id_space_per_table!(tables, table_by_name, dump_target, logger)
       end
 
       tables.reject(&:ignore).each do |table|
         next unless table.respond_to?(:batch_scope) && table.batch_scope
 
-        new(table.name, table_by_name, dump_target, logger).batch_scope_terminus!
+        builder = new(table.name, table_by_name, dump_target, logger)
+        builder.batch_scope_terminus!
+        builder.warn_batch_scope_ancestor_gaps
+      end
+    end
+
+    # Only scope-column mode on the SQL adapters can filter by a named ID space.
+    def self.validate_named_id_spaces_allowed!(tables, table_by_name, dump_target)
+      named = dump_target.named_id_spaces
+      return if named.empty?
+
+      given = named.map { |space| "'#{space}'" }.join(', ')
+      # The CLI rejects this up front; this covers callers that build a Runner directly.
+      if tables.any? { |table| table.is_a?(MongodbCollectionConfig) }
+        raise ArgumentError,
+              "--ids were given for the ID space(s) #{given}, but the mongodb adapter supports " \
+              "only the default ID space (--ids without a `<id_space>=` prefix)."
+      end
+
+      return if scope_mode?(table_by_name, dump_target)
+
+      raise ArgumentError,
+            "--ids were given for the ID space(s) #{given}, but --target-table " \
+            "'#{dump_target.table_name}' declares no scope_column, so the run is single-target mode, " \
+            "which uses only the default ID space. Name a table that declares a scope_column as " \
+            "--target-table, or drop the named --ids."
+    end
+
+    # Every ID space a scope_column belongs to must be given values,
+    # and every ID space given values must be used by some table.
+    def self.validate_id_space_values!(tables, table_by_name, dump_target, logger)
+      tables_by_space =
+        tables.reject(&:ignore).each_with_object({}) do |table, hash|
+          space = new(table.name, table_by_name, dump_target, logger).declared_id_space
+          (hash[space] ||= []) << table.name if space
+        end
+
+      missing = tables_by_space.keys.select { |space| dump_target.ids_for(space).empty? }.sort
+      if missing.any?
+        details = missing.map do |space|
+          flag = space == DEFAULT_ID_SPACE ? "--ids=<ids>" : "--ids=#{space}=<ids>"
+          "'#{space}' (#{tables_by_space[space].sort.join(', ')}; pass #{flag})"
+        end
+        raise ArgumentError,
+              "scope-column mode: no ids were given for the ID space(s) that these tables are " \
+              "filtered by: #{details.join('; ')}."
+      end
+
+      unused = dump_target.ids.keys.reject { |space| tables_by_space.key?(space) }.sort
+      if unused.any?
+        raise ArgumentError,
+              "scope-column mode: ids were given for the ID space(s) #{unused.map { |space| "'#{space}'" }.join(', ')}, " \
+              "but no table declares a scope_column in them (a table without `id_space` is in " \
+              "'#{DEFAULT_ID_SPACE}'). Check the ID space name, or declare `id_space` on the tables it scopes."
       end
     end
 
+    # A table is filtered by the values of one ID space only. Without this check
+    # the belongs_to walk would silently settle on the nearest scoped table and
+    # ignore a route into another space.
+    def self.validate_single_id_space_per_table!(tables, table_by_name, dump_target, logger)
+      return if dump_target.ids.size < 2
+
+      mixed =
+        tables.reject(&:ignore).filter_map do |table|
+          spaces = new(table.name, table_by_name, dump_target, logger).reached_id_spaces
+          "#{table.name} (#{spaces.join(', ')})" if spaces.size > 1
+        end
+      return if mixed.empty?
+
+      raise ArgumentError,
+            "scope-column mode: #{mixed.size} table(s) reach more than one ID space: #{mixed.sort.join(', ')}. " \
+            "A table must be scoped by the values of a single ID space; set `ignore: true` on the " \
+            "belongs_to (or remove the reverse_scope arm) that leads into the other space, or declare " \
+            "`scope_column:` on the table to filter it directly."
+    end
+
     attr_reader :table_name, :table_by_name, :dump_target
 
     # The multiple constrained referencers (comma-joined) that made the
@@ -110,14 +232,21 @@ module Exwiw
 
     def run
       table = table_by_name.fetch(table_name)
+      ast = scope_mode? ? build_scoped(table) : build_single_target(table)
+      with_self_ancestors(table, ast)
+    end
 
-      return build_scoped(table) if scope_mode?
-
+    private def build_single_target(table)
       arm_queries = target_polymorphic_arm_queries(table)
+      tree_route_clauses = arm_queries ? nil : dump_target_tree_route_clauses(table)
       if arm_queries
         where_clauses = [pk_union_clause(table, arm_queries)]
         where_clauses.push(table.filter) if table.filter
         join_clauses = []
+      elsif tree_route_clauses
+        where_clauses = tree_route_clauses
+        where_clauses.push(table.filter) if table.filter
+        join_clauses = []
       else
         where_clauses = build_where_clauses(table, dump_target)
         join_clauses = build_join_clauses(table, table_by_name, dump_target)
@@ -177,6 +306,13 @@ module Exwiw
         )
       end
 
+      new_extraction_query(table).tap do |ast|
+        join_clauses.each { |join_clause| ast.join(join_clause) }
+        where_clauses.each { |where_clause| ast.where(where_clause) }
+      end
+    end
+
+    private def new_extraction_query(table)
       QueryAst::Select.new.tap do |ast|
         ast.from(table.name)
         if table.rails_managed?
@@ -184,8 +320,28 @@ module Exwiw
         else
           ast.select(table.columns)
         end
-        join_clauses.each { |join_clause| ast.join(join_clause) }
-        where_clauses.each { |where_clause| ast.where(where_clause) }
+      end
+    end
+
+    # Keeps a narrowed tree table's parent ids from dangling. The ancestors are
+    # not held to the table's filter or scope, since valid foreign keys win. A
+    # batched table is left alone: every batch would repeat the ancestors.
+    private def with_self_ancestors(table, ast)
+      return ast unless @batch_ids.nil?
+      return ast if ast.where_clauses.empty? && ast.join_clauses.empty?
+
+      links = self.class.self_ancestor_links(table)
+      return ast if links.empty?
+
+      closure = QueryAst::RecursiveAncestorSubquery.new(
+        base: project_query_to(ast, [table.primary_key, *links.map(&:foreign_key)].uniq),
+        table_name: table.name,
+        primary_key: table.primary_key,
+        links: links
+      )
+
+      new_extraction_query(table).tap do |widened|
+        widened.where(QueryAst::WhereClause.new(column_name: table.primary_key, operator: :in_subquery, value: closure))
       end
     end
 
@@ -446,22 +602,52 @@ module Exwiw
         return nil
       end
 
-      relation, parent, parent_query = candidates.first
-
-      # Project the parent's extraction query down to just its primary key — the
-      # column this table's foreign key points at.
-      pk_column = TableColumn.from_symbol_keys(name: parent.primary_key)
-      projected = QueryAst::Select.new
-      projected.from(parent_query.from_table_name)
-      projected.select([pk_column])
-      parent_query.join_clauses.each { |j| projected.join(j) }
-      parent_query.where_clauses.each { |w| projected.where(w) }
+      relation, _parent, parent_query = candidates.first
+      parent_ids_clause(relation, parent_query)
+    end
 
+    # `<fk> IN (<the parent's extraction query, projected to its primary key>)`.
+    private def parent_ids_clause(relation, parent_query)
+      parent = table_by_name.fetch(relation.table_name)
       QueryAst::WhereClause.new(
         column_name: relation.foreign_key,
         operator: :in_subquery,
-        value: QueryAst::SelectSubquery.new(query: projected)
+        value: QueryAst::SelectSubquery.new(query: project_query_to(parent_query, parent.primary_key))
+      )
+    end
+
+    # A JOIN through a tree table applies that table's own conditions, which its
+    # ancestors are exempt from, so such a route narrows by the first hop's
+    # extraction query instead. A batched table keeps the JOIN its batches slice.
+    private def route_through_tree?(table, route_tables)
+      return false if batched?(table)
+
+      !tree_tables_in(route_tables).empty?
+    end
+
+    private def tree_tables_in(table_names)
+      table_names.select { |name| (hop = table_by_name[name]) && self.class.self_ancestor_links(hop).any? }
+    end
+
+    # nil keeps the JOIN: on a cycle, or when the parent is unconstrained or
+    # scoped through this very table.
+    private def route_parent_query(table, relation)
+      parent = table_by_name[relation.table_name]
+      return nil if parent.nil? || parent.primary_key.nil?
+      return nil if parent.name == table.name || @forward_path.include?(parent.name)
+
+      parent_query = self.class.run(
+        parent.name, table_by_name, dump_target, @logger,
+        forward_path: @forward_path + [table.name], reverse_path: @reverse_path, deep_chain_warned: @deep_chain_warned
       )
+      return nil unless parent_query.where_clauses.any? || parent_query.join_clauses.any?
+      return nil if QueryAst.reads_table?(parent_query, table.name)
+
+      parent_query
+    end
+
+    private def batched?(table)
+      table.respond_to?(:batch_scope) && !table.batch_scope.nil?
     end
 
     private def polymorphic_parent_groups(table)
@@ -530,7 +716,7 @@ module Exwiw
         clauses.push Exwiw::QueryAst::WhereClause.new(
           column_name: dump_target.ids_field || table.primary_key,
           operator: :eq,
-          value: dump_target.ids
+          value: dump_target.default_ids
         )
 
         return clauses
@@ -572,7 +758,7 @@ module Exwiw
         return Exwiw::QueryAst::WhereClause.new(
           column_name: foreign_key,
           operator: :eq,
-          value: dump_target.ids
+          value: dump_target.default_ids
         )
       end
 
@@ -584,11 +770,33 @@ module Exwiw
           table_name: target.name,
           select_column: target.primary_key,
           where_column: dump_target.ids_field,
-          where_values: dump_target.ids
+          where_values: dump_target.default_ids
         )
       )
     end
 
+    # Single-target counterpart of #path_or_parent_query_arm; nil keeps the JOIN.
+    private def dump_target_tree_route_clauses(table)
+      return nil if table.name == dump_target.table_name
+
+      relation = table.belongs_to(dump_target.table_name)
+      route = relation ? [dump_target.table_name] : dump_target_route_after_first_hop(table)
+      return nil if route.empty? || !route_through_tree?(table, route)
+
+      relation ||= table.belongs_to(route.first)
+      parent_query = route_parent_query(table, relation)
+      return nil if parent_query.nil?
+
+      [parent_ids_clause(relation, parent_query)].tap do |clauses|
+        clauses.push(polymorphic_type_clause(relation)) if relation.polymorphic?
+      end
+    end
+
+    private def dump_target_route_after_first_hop(table)
+      path = find_path_to_dump_target(table, table_by_name, dump_target)
+      path.size < 2 ? [] : path.drop(1) + [dump_target.table_name]
+    end
+
     # Single-target counterpart of #scoped_arms.
     private def target_polymorphic_arm_queries(table)
       return nil if table.name == dump_target.table_name
@@ -615,18 +823,25 @@ module Exwiw
     end
 
     private def target_arm_query(table, relation)
-      if relation.table_name == dump_target.table_name
+      target = table_by_name[relation.table_name]
+      return nil if target.nil?
+
+      on_target = relation.table_name == dump_target.table_name
+      path = on_target ? [] : find_path_to_dump_target(target, table_by_name, dump_target)
+      joinable = on_target || (path.any? && !path.include?(table.name))
+      route = on_target ? [target.name] : path + [dump_target.table_name]
+      if joinable && route_through_tree?(table, route) && (parent_query = route_parent_query(table, relation))
+        return target_ids_arm_query(table, relation, parent_query)
+      end
+
+      if on_target
         return arm_pk_query(table).tap do |query|
           query.where dump_target_fk_clause(relation.foreign_key)
           query.where polymorphic_type_clause(relation)
         end
       end
 
-      target = table_by_name[relation.table_name]
-      return nil if target.nil?
-
-      path = find_path_to_dump_target(target, table_by_name, dump_target)
-      if path.any? && !path.include?(table.name)
+      if joinable
         return arm_pk_query(table).tap do |query|
           query.join(build_join_clause(table, target, relation))
           build_join_clauses(target, table_by_name, dump_target).each { |join_clause| query.join(join_clause) }
@@ -672,7 +887,9 @@ module Exwiw
     # ------------------------------------------------------------------
 
     private def scope_mode?
-      self.class.scope_mode?(table_by_name, dump_target)
+      return @scope_mode if defined?(@scope_mode)
+
+      @scope_mode = self.class.scope_mode?(table_by_name, dump_target)
     end
 
     # Classifier used by validate_scope! and mirrored by build_scoped below.
@@ -687,6 +904,27 @@ module Exwiw
       :unscopable
     end
 
+    # The ID space this table's scope column belongs to, or nil when it has none.
+    # A scope_exempt table is dumped in full, but tables reaching it through
+    # belongs_to are still filtered by its scope column, so its ID space counts.
+    def declared_id_space
+      table = table_by_name.fetch(table_name)
+      return nil unless directly_scoped?(table)
+
+      id_space_of(table)
+    end
+
+    # The ID spaces a table that is not directly scoped can be scoped through:
+    # those of the scoped tables its belongs_to walk can stop at, and those its
+    # built query filters by (polymorphic arms, reverse_scope, referenced-by and
+    # the parent cascade).
+    def reached_id_spaces
+      table = table_by_name.fetch(table_name)
+      return [] if scope_exempt?(table) || directly_scoped?(table)
+
+      (belongs_to_reachable_id_spaces(table) | QueryAst.id_spaces(run)).sort
+    end
+
     # True when this table may still attempt the forward "scope via a scoped
     # belongs_to parent" rescue: it is not already on the forward-resolution
     # path, so descending into its parent cannot revisit it (a belongs_to cycle).
@@ -695,13 +933,7 @@ module Exwiw
     end
 
     private def build_scoped(table)
-      ast = QueryAst::Select.new
-      ast.from(table.name)
-      if table.rails_managed?
-        ast.select_all!
-      else
-        ast.select(table.columns)
-      end
+      ast = new_extraction_query(table)
 
       # Reference/master (or rails-managed) table: export every row.
       return ast if scope_exempt?(table)
@@ -723,6 +955,10 @@ module Exwiw
         build_scoped_join_clauses(arm.path, first_relation: arm.relation).each { |join_clause| ast.join(join_clause) }
         ast.where(table.filter) if table.filter
         return ast
+      elsif arms.size == 1 && !arms.first.relation.polymorphic?
+        ast.where(parent_ids_clause(arms.first.relation, arms.first.target_query))
+        ast.where(table.filter) if table.filter
+        return ast
       elsif arms.size >= 1
         # Several polymorphic arms: INNER JOINing one of them would drop the rows
         # of every other type, so constrain this table to the UNION of the ids the
@@ -791,15 +1027,43 @@ module Exwiw
       table.columns.any? { |c| c.name == column }
     end
 
+    private def id_space_of(table)
+      table.id_space || DEFAULT_ID_SPACE
+    end
+
     private def scope_where_clause(table)
       batch_clause = batch_ids_clause(table)
       return batch_clause if batch_clause
 
-      Exwiw::QueryAst::WhereClause.new(
+      Exwiw::QueryAst::ScopeWhereClause.new(
         column_name: resolved_scope_column(table),
         operator: :eq,
-        value: dump_target.ids
-      )
+        value: dump_target.ids_for(id_space_of(table))
+      ).tap { |clause| clause.id_space = id_space_of(table) }
+    end
+
+    # The ID spaces of every directly scoped table the belongs_to walk of
+    # #find_path_to_scoped could stop at, not only the nearest one.
+    private def belongs_to_reachable_id_spaces(table)
+      visited = Set[table.name]
+      queue = [table]
+      spaces = Set.new
+
+      until queue.empty?
+        current = queue.shift
+        current.belongs_tos.each do |relation|
+          next_table = table_by_name[relation.table_name]
+          next if next_table.nil? || !visited.add?(next_table.name)
+
+          if directly_scoped?(next_table)
+            spaces << id_space_of(next_table)
+          else
+            queue.push(next_table)
+          end
+        end
+      end
+
+      spaces
     end
 
     # This batch's ids, in place of the batch table's scope filter. nil when the
@@ -891,6 +1155,30 @@ module Exwiw
       terminus
     end
 
+    # These gaps should reject the batch_scope like the shapes
+    # #batch_scope_terminus! raises on, but only warn so that configs batching a
+    # table that now keeps ancestors still run. Called once from the pre-flight,
+    # after #batch_scope_terminus! accepts the shape; #batch_scope_terminus!
+    # itself also runs mid-extraction.
+    def warn_batch_scope_ancestor_gaps
+      table = table_by_name.fetch(table_name)
+
+      if self.class.self_ancestor_links(table).any?
+        @logger.warn(
+          "  #{table.name} references itself, but a batched table does not add the ancestors " \
+          "of its rows (every batch would repeat them); a kept row's parent may be missing."
+        )
+      end
+
+      route = directly_scoped?(table) ? [] : scoped_arms(table).first.path.drop(1)
+      tree_tables_in(route).each do |tree|
+        @logger.warn(
+          "  #{table.name} is batched through #{tree}, which keeps the ancestors of its rows, but " \
+          "the batches join #{tree} directly; #{table.name} rows of those ancestors are not extracted."
+        )
+      end
+    end
+
     # BFS over belongs_tos to the nearest *directly scoped* ancestor. Unlike the
     # target-mode walk, the returned path INCLUDES that ancestor: the scope column
     # lives on the ancestor itself (not on a foreign key of the child), so the
@@ -988,7 +1276,7 @@ module Exwiw
         else
           sibling_arms = polymorphic_sibling_arms(table, shortest[1])
           if sibling_arms.nil?
-            [ScopedArm.new(relation: nil, path: shortest)]
+            [path_or_parent_query_arm(table, table.belongs_to(shortest[1]), shortest, pinned: false)]
           else
             arms = sibling_arms.filter_map { |relation| resolve_scoped_arm(table, relation) }
             @logger.debug(
@@ -1013,12 +1301,21 @@ module Exwiw
     # up referenced_by / reverse_scope / the multi-hop cascade for free.
     private def resolve_scoped_arm(table, relation)
       path = find_path_to_scoped(table, first_relation: relation)
-      return ScopedArm.new(relation: relation, path: path) if path.size >= 2
+      return path_or_parent_query_arm(table, relation, path, pinned: true) if path.size >= 2
 
       target_query = scoped_target_query(table, relation, allow_automatic_reverse: true)
       target_query && ScopedArm.new(relation: relation, target_query: target_query)
     end
 
+    # `pinned` keeps the relation on a JOIN arm, which only a polymorphic arm needs.
+    private def path_or_parent_query_arm(table, relation, path, pinned:)
+      if route_through_tree?(table, path.drop(1)) && (parent_query = route_parent_query(table, relation))
+        return ScopedArm.new(relation: relation, target_query: parent_query)
+      end
+
+      ScopedArm.new(relation: pinned ? relation : nil, path: path)
+    end
+
     private def scoped_target_arm_query(table, relation)
       # A parent kept only by the automatic referenced_by exists to keep a child's
       # foreign key valid. Single-target mode extracts only what sits under the
@@ -1150,15 +1447,8 @@ module Exwiw
     # to be constrained: the foreign key alone cannot tell this arm's rows from
     # another arm's (record_id=1 may be any type).
     private def target_ids_arm_query(table, relation, target_query)
-      target = table_by_name.fetch(relation.table_name)
       arm_pk_query(table).tap do |query|
-        query.where QueryAst::WhereClause.new(
-          column_name: relation.foreign_key,
-          operator: :in_subquery,
-          value: QueryAst::SelectSubquery.new(
-            query: project_query_to(target_query, target.primary_key)
-          )
-        )
+        query.where parent_ids_clause(relation, target_query)
         query.where polymorphic_type_clause(relation)
       end
     end
@@ -1171,14 +1461,14 @@ module Exwiw
       )
     end
 
-    # Reduce an extraction query to a single-column id projection, keeping its
-    # joins and filters. The column is forced to a plain TableColumn so any
-    # masking (`replace_with` / `raw_sql`) configured on it cannot corrupt the id
+    # Reduce an extraction query to an id projection, keeping its joins and
+    # filters. The columns are forced to plain TableColumns so any masking
+    # (`replace_with` / `raw_sql`) configured on them cannot corrupt the id
     # comparison.
-    private def project_query_to(query, column_name)
+    private def project_query_to(query, column_names)
       projected = QueryAst::Select.new
       projected.from(query.from_table_name)
-      projected.select([TableColumn.from_symbol_keys(name: column_name)])
+      projected.select(Array(column_names).map { |name| TableColumn.from_symbol_keys(name: name) })
       query.join_clauses.each { |join_clause| projected.join(join_clause) }
       query.where_clauses.each { |where_clause| projected.where(where_clause) }
       projected

data/lib/exwiw/runner.rb

@@ -203,6 +203,7 @@ module Exwiw
       AfterInsertHook.run(
         path: @after_insert_hook_path,
         cli_options: @cli_options,
+        dump_target: @dump_target,
         output_dir: @output_dir,
         next_idx: total_size + 1,
         output_extension: adapter.output_extension,

data/lib/exwiw/table_config.rb

@@ -38,6 +38,9 @@ module Exwiw
     # different column name on this table).
     attribute :scope_exempt, Serdes::OptionalType.new(Serdes::ConcreteType.new(Boolean)), skip_serializing_if_nil: true
     attribute :scope_column, optional(String), skip_serializing_if_nil: true
+    # The ID space (Exwiw::DumpTarget#ids) the `scope_column` values belong to.
+    # nil means `default`. User-configured, never generated.
+    attribute :id_space, optional(String), skip_serializing_if_nil: true
 
     # `reverse_scope` opts a table into multi-referencer reverse scoping (see
     # Exwiw::ReverseScope and QueryAstBuilder#build_referenced_by_clause): a
@@ -175,6 +178,7 @@ module Exwiw
         merged_table.bulk_insert_chunk_size = bulk_insert_chunk_size
         merged_table.scope_exempt = scope_exempt
         merged_table.scope_column = scope_column
+        merged_table.id_space = id_space
         merged_table.reverse_scope = reverse_scope
         merged_table.batch_scope = batch_scope
 
@@ -250,6 +254,19 @@ module Exwiw
                 "Table '#{name}': reverse_scope.column '#{reverse_scope.column}' is not a declared column."
         end
 
+        if id_space
+          unless id_space.match?(ID_SPACE_NAME_PATTERN)
+            raise ArgumentError,
+                  "Table '#{name}': id_space '#{id_space}' must start with a lowercase letter and " \
+                  "contain only lowercase letters, digits and underscores."
+          end
+          if scope_column.nil?
+            raise ArgumentError,
+                  "Table '#{name}': id_space names the ID space of the scope_column values, " \
+                  "so it requires scope_column."
+          end
+        end
+
         columns.each { |column| validate_ruby_side_masking!(column) }
       end
     end

data/lib/exwiw/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Exwiw
-  VERSION = "1.1.5"
+  VERSION = "1.1.7"
 end