dag_me 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba16630068a6ea6417e5aee617ba2d9621e7e711dfc7d4459721b48f399d0da7
-  data.tar.gz: 04ffb8914db06228c7b7851155f8b6b779f6dc86756e7b2f2dacf0d6be3541f4
+  metadata.gz: f9afbe234f1c36638c4a965eae2c76bfd93ffbc259b6f57fcf9c7ff57688176d
+  data.tar.gz: e50691a084e46d40e800f51635d7e1ab07e98fb865324a784a6ad88d51ccb93d
 SHA512:
-  metadata.gz: 9ddb66c78132f8766f56aa7d786a158968c09d83549121336597d755d2115bd6c85ef5158867926c9ab786379f6da2d331f3edb1cea2b1603c8b1bdef5e9fc21
-  data.tar.gz: d16ee5de2122fe5a72ec4ffef79270c32f5d20a529781e1cbb0d15cfa27f9948f0c5c1f9b106066d28bf660b4edb56207eb3c016c8a3a21ed1becea67d4f9e4e
+  metadata.gz: b6a321babe86ba1529efb4e30bfa742f2149e40d42cf9971c78b15810783eb425f7ba9d45b31d4def9a4a39e4f024f566f12d49dd52a8f30c2a3968c96134e16
+  data.tar.gz: 0b43392262483e5691e449c6eba57b7517e4649db776a5b6e29b50a1ca9868be83849f8297e69e47c564dd4988af127feead3c70978ffe7c3c92e3ea8949e25d

data/README.md

@@ -136,6 +136,20 @@ end
 `:recursive_cte` skips the closure table entirely - good for small graphs, high mutation
 rates, and as the truth oracle. Cycle rejection stays in-database either way.
 
+## Schema-qualified tables
+
+Node tables living in a named PostgreSQL schema work out of the box:
+
+```ruby
+class Station < ApplicationRecord
+  self.table_name = 'orbital.stations'
+  dag_me
+end
+```
+
+Generated tables (`orbital.station_dag_edges`, `orbital.station_dag_paths`) and
+functions land in the node table's schema; trigger names stay plain identifiers.
+
 ## Multi-tenancy
 
 ```ruby

data/lib/dag_me/configuration.rb

@@ -4,7 +4,7 @@ module DagMe
   class Configuration
     MAINTAIN_MODES = %i[postgresql_closure recursive_cte].freeze
 
-    attr_reader :model, :name, :maintain, :prefix, :edge_table, :paths_table, :scope_columns
+    attr_reader :model, :name, :maintain, :prefix, :schema, :edge_table, :paths_table, :scope_columns
 
     def initialize(model:, name: nil, maintain: :postgresql_closure, scope: nil, edge_table: nil, paths_table: nil)
       unless MAINTAIN_MODES.include?(maintain)
@@ -15,9 +15,13 @@ module DagMe
       @name = name&.to_sym
       @maintain = maintain
       @scope_columns = Array(scope).map(&:to_sym).freeze
-      @prefix = [model.table_name.singularize, @name, 'dag'].compact.join('_')
-      @edge_table = edge_table || "#{prefix}_edges"
-      @paths_table = paths_table || "#{prefix}_paths"
+      # Schema-qualified node tables ("ai.skills") keep the prefix a plain
+      # identifier - trigger and temp-table names cannot carry a schema - and
+      # place generated tables and functions in the node table's schema.
+      @schema, base_table = split_schema(model.table_name)
+      @prefix = [base_table.singularize, @name, 'dag'].compact.join('_')
+      @edge_table = edge_table || qualify("#{prefix}_edges")
+      @paths_table = paths_table || qualify("#{prefix}_paths")
       # Ivar peek keeps class load DB-free; composite keys must be declared
       # before the macro. Array === because AR seeds a BasicObject sentinel.
       @composite_pk = model.instance_variable_defined?(:@primary_key) &&
@@ -28,6 +32,22 @@ module DagMe
       maintain == :postgresql_closure
     end
 
+    # "skill_dag_edges" -> "ai.skill_dag_edges" when the node table lives in a
+    # named schema; identity otherwise.
+    def qualify(identifier)
+      schema ? "#{schema}.#{identifier}" : identifier
+    end
+
+    # Schema-qualified reference for a generated function ("ai.skill_dag_lock").
+    def function_ref(suffix)
+      qualify("#{prefix}_#{suffix}")
+    end
+
+    # Trigger names are plain identifiers; placement comes from ON <table>.
+    def trigger_name(suffix)
+      "#{prefix}_#{suffix}"
+    end
+
     # The unnamed dag from a bare `dag_me` call. Named dags come from
     # `dag_me :power` and get name-prefixed tables, constants, and
     # associations so several graphs can coexist on one model.
@@ -117,6 +137,12 @@ module DagMe
 
     private
 
+    def split_schema(table_name)
+      return table_name.split('.', 2) if table_name.include?('.')
+
+      [nil, table_name]
+    end
+
     def role_columns(role)
       return ["#{role}_id"].freeze unless composite_pk?
 

data/lib/dag_me/ddl.rb

@@ -77,22 +77,21 @@ module DagMe
     end
 
     def uninstall_sql
-      p = config.prefix
       [
-        "DROP TRIGGER IF EXISTS #{p}_node_insert ON #{config.node_table};",
-        "DROP TRIGGER IF EXISTS #{p}_node_update ON #{config.node_table};",
-        "DROP TRIGGER IF EXISTS #{p}_node_delete ON #{config.node_table};",
+        "DROP TRIGGER IF EXISTS #{config.trigger_name('node_insert')} ON #{config.node_table};",
+        "DROP TRIGGER IF EXISTS #{config.trigger_name('node_update')} ON #{config.node_table};",
+        "DROP TRIGGER IF EXISTS #{config.trigger_name('node_delete')} ON #{config.node_table};",
         "DROP TABLE IF EXISTS #{config.paths_table};",
         "DROP TABLE IF EXISTS #{config.edge_table};",
-        "DROP FUNCTION IF EXISTS #{p}_lock(text);",
-        "DROP FUNCTION IF EXISTS #{p}_edge_insert_check();",
-        "DROP FUNCTION IF EXISTS #{p}_edge_insert_apply();",
-        "DROP FUNCTION IF EXISTS #{p}_edge_delete_apply();",
-        "DROP FUNCTION IF EXISTS #{p}_node_insert();",
-        "DROP FUNCTION IF EXISTS #{p}_node_update();",
-        "DROP FUNCTION IF EXISTS #{p}_node_delete();",
-        "DROP FUNCTION IF EXISTS #{p}_rebuild_paths();",
-        "DROP FUNCTION IF EXISTS #{p}_validate_paths();"
+        "DROP FUNCTION IF EXISTS #{config.function_ref('lock')}(text);",
+        "DROP FUNCTION IF EXISTS #{config.function_ref('edge_insert_check')}();",
+        "DROP FUNCTION IF EXISTS #{config.function_ref('edge_insert_apply')}();",
+        "DROP FUNCTION IF EXISTS #{config.function_ref('edge_delete_apply')}();",
+        "DROP FUNCTION IF EXISTS #{config.function_ref('node_insert')}();",
+        "DROP FUNCTION IF EXISTS #{config.function_ref('node_update')}();",
+        "DROP FUNCTION IF EXISTS #{config.function_ref('node_delete')}();",
+        "DROP FUNCTION IF EXISTS #{config.function_ref('rebuild_paths')}();",
+        "DROP FUNCTION IF EXISTS #{config.function_ref('validate_paths')}();"
       ]
     end
 
@@ -176,10 +175,20 @@ module DagMe
       config.scope_columns.map { |c| "#{left}.#{c} IS DISTINCT FROM #{right}.#{c}" }.join(' OR ')
     end
 
+    # Honors PostgreSQLAdapter.create_unlogged_tables (Rails test-env speed
+    # setting): a logged table cannot FK-reference an unlogged node table.
+    def create_table_clause
+      if ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
+        'CREATE UNLOGGED TABLE'
+      else
+        'CREATE TABLE'
+      end
+    end
+
     def edges_table_sql
       defs = (col_defs(parent_cols) + col_defs(child_cols)).map { |d| "  #{d}," }.join("\n")
       <<~SQL
-        CREATE TABLE #{config.edge_table} (
+        #{create_table_clause} #{config.edge_table} (
           id bigint GENERATED BY DEFAULT AS IDENTITY PRIMARY KEY,
         #{defs}
           created_at timestamptz NOT NULL DEFAULT now()#{scope_column_defs},
@@ -195,7 +204,7 @@ module DagMe
     def paths_table_sql
       defs = (col_defs(anc_cols) + col_defs(desc_cols)).map { |d| "  #{d}," }.join("\n")
       <<~SQL
-        CREATE TABLE #{config.paths_table} (
+        #{create_table_clause} #{config.paths_table} (
         #{defs}
           min_depth integer NOT NULL,
           path_count numeric NOT NULL#{scope_column_defs},
@@ -211,7 +220,7 @@ module DagMe
     # snapshot after the lock wait, so anything above READ COMMITTED is refused.
     def lock_function_sql
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_lock(scope_key text) RETURNS void
+        CREATE OR REPLACE FUNCTION #{config.function_ref('lock')}(scope_key text) RETURNS void
         LANGUAGE plpgsql AS $$
         BEGIN
           IF current_setting('transaction_isolation') NOT IN ('read committed', 'read uncommitted') THEN
@@ -229,8 +238,7 @@ module DagMe
     # reject cross-scope edges, stamp NEW, and lock the scope. Unscoped graphs
     # just lock the single '' key.
     def edge_check_preamble
-      p = config.prefix
-      return "  PERFORM #{p}_lock('');" unless scoped?
+      return "  PERFORM #{config.function_ref('lock')}('');" unless scoped?
 
       stamps = config.scope_columns.map { |c| "  NEW.#{c} := parent_row.#{c};" }.join("\n")
       # FOR SHARE pins both node rows so a concurrent scope UPDATE cannot race
@@ -243,7 +251,7 @@ module DagMe
               USING ERRCODE = '#{SQLSTATE_CROSS_SCOPE}';
           END IF;
         #{stamps}
-          PERFORM #{p}_lock(#{scope_key_expr('parent_row')});
+          PERFORM #{config.function_ref('lock')}(#{scope_key_expr('parent_row')});
       SQL
     end
 
@@ -279,7 +287,7 @@ module DagMe
 
     def closure_edge_insert_check_sql
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_edge_insert_check() RETURNS trigger
+        CREATE OR REPLACE FUNCTION #{config.function_ref('edge_insert_check')}() RETURNS trigger
         LANGUAGE plpgsql AS $$
         #{edge_check_declarations}
         BEGIN
@@ -300,7 +308,7 @@ module DagMe
     def edge_insert_apply_sql
       paths = config.paths_table
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_edge_insert_apply() RETURNS trigger
+        CREATE OR REPLACE FUNCTION #{config.function_ref('edge_insert_apply')}() RETURNS trigger
         LANGUAGE plpgsql AS $$
         BEGIN
           -- ancestors-incl-self of parent x descendants-incl-self of child
@@ -328,10 +336,10 @@ module DagMe
       y_cols = pk_cols.map { |c| "y_#{c}" }
       rect_defs = (col_defs(x_cols) + col_defs(y_cols)).map { |d| "    #{d}," }.join("\n")
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{p}_edge_delete_apply() RETURNS trigger
+        CREATE OR REPLACE FUNCTION #{config.function_ref('edge_delete_apply')}() RETURNS trigger
         LANGUAGE plpgsql AS $$
         BEGIN
-          PERFORM #{p}_lock(#{scope_key_expr('OLD')});
+          PERFORM #{config.function_ref('lock')}(#{scope_key_expr('OLD')});
 
           -- The affected rectangle: every pair (x, y) with x reaching OLD's parent
           -- and OLD's child reaching y lost `removed` paths through this edge.
@@ -401,7 +409,7 @@ module DagMe
 
     def node_insert_function_sql
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_node_insert() RETURNS trigger
+        CREATE OR REPLACE FUNCTION #{config.function_ref('node_insert')}() RETURNS trigger
         LANGUAGE plpgsql AS $$
         BEGIN
           INSERT INTO #{config.paths_table} (#{list(anc_cols)}, #{list(desc_cols)}, min_depth, path_count#{scope_column_list})
@@ -414,10 +422,10 @@ module DagMe
 
     def node_delete_function_sql
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_node_delete() RETURNS trigger
+        CREATE OR REPLACE FUNCTION #{config.function_ref('node_delete')}() RETURNS trigger
         LANGUAGE plpgsql AS $$
         BEGIN
-          PERFORM #{config.prefix}_lock(#{scope_key_expr('OLD')});
+          PERFORM #{config.function_ref('lock')}(#{scope_key_expr('OLD')});
           -- Remove edges through their triggers so the closure shrinks
           -- incrementally instead of relying on FK-cascade ordering.
           DELETE FROM #{config.edge_table}
@@ -441,7 +449,7 @@ module DagMe
                   '-- edges only: nothing materialized to restamp'
                 end
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_node_update() RETURNS trigger
+        CREATE OR REPLACE FUNCTION #{config.function_ref('node_update')}() RETURNS trigger
         LANGUAGE plpgsql AS $$
         BEGIN
           IF #{scope_distinct_expr('NEW', 'OLD')} THEN
@@ -461,22 +469,23 @@ module DagMe
     end
 
     def closure_trigger_sql
-      p = config.prefix
       triggers = [
-        trigger_sql("#{p}_edge_insert_check", 'BEFORE INSERT', config.edge_table),
-        trigger_sql("#{p}_edge_insert_apply", 'AFTER INSERT', config.edge_table),
-        trigger_sql("#{p}_edge_delete_apply", 'AFTER DELETE', config.edge_table),
-        trigger_sql("#{p}_node_insert", 'AFTER INSERT', config.node_table),
-        trigger_sql("#{p}_node_delete", 'BEFORE DELETE', config.node_table)
+        trigger_sql('edge_insert_check', 'BEFORE INSERT', config.edge_table),
+        trigger_sql('edge_insert_apply', 'AFTER INSERT', config.edge_table),
+        trigger_sql('edge_delete_apply', 'AFTER DELETE', config.edge_table),
+        trigger_sql('node_insert', 'AFTER INSERT', config.node_table),
+        trigger_sql('node_delete', 'BEFORE DELETE', config.node_table)
       ]
-      triggers << trigger_sql("#{p}_node_update", 'BEFORE UPDATE', config.node_table) if scoped?
+      triggers << trigger_sql('node_update', 'BEFORE UPDATE', config.node_table) if scoped?
       triggers
     end
 
-    def trigger_sql(name, timing, table)
+    # Trigger names are plain identifiers; the executed function carries the
+    # schema qualification.
+    def trigger_sql(suffix, timing, table)
       <<~SQL
-        CREATE TRIGGER #{name} #{timing} ON #{table}
-          FOR EACH ROW EXECUTE FUNCTION #{name}();
+        CREATE TRIGGER #{config.trigger_name(suffix)} #{timing} ON #{table}
+          FOR EACH ROW EXECUTE FUNCTION #{config.function_ref(suffix)}();
       SQL
     end
 
@@ -504,7 +513,7 @@ module DagMe
       scope_join = scoped? ? "JOIN #{config.node_table} n ON #{eq(pk_cols, anc_cols, left: 'n', right: 'walk')}" : ''
       scope_group = config.scope_columns.map { |c| ", n.#{c}" }.join
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_rebuild_paths() RETURNS void
+        CREATE OR REPLACE FUNCTION #{config.function_ref('rebuild_paths')}() RETURNS void
         LANGUAGE plpgsql AS $$
         BEGIN
           LOCK TABLE #{config.node_table}, #{config.edge_table} IN SHARE ROW EXCLUSIVE MODE;
@@ -531,7 +540,7 @@ module DagMe
                 .map { |d| "  #{d}," }.join("\n")
       coalesced = (anc_cols + desc_cols).map { |c| "COALESCE(t.#{c}, s.#{c})" }.join(",\n                 ")
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_validate_paths()
+        CREATE OR REPLACE FUNCTION #{config.function_ref('validate_paths')}()
         RETURNS TABLE(
         #{returns}
           stored_min_depth integer,
@@ -571,7 +580,7 @@ module DagMe
 
     def cte_edge_insert_check_sql
       <<~SQL
-        CREATE OR REPLACE FUNCTION #{config.prefix}_edge_insert_check() RETURNS trigger
+        CREATE OR REPLACE FUNCTION #{config.function_ref('edge_insert_check')}() RETURNS trigger
         LANGUAGE plpgsql AS $$
         #{edge_check_declarations}
         BEGIN
@@ -593,9 +602,8 @@ module DagMe
     end
 
     def cte_trigger_sql
-      p = config.prefix
-      triggers = [trigger_sql("#{p}_edge_insert_check", 'BEFORE INSERT', config.edge_table)]
-      triggers << trigger_sql("#{p}_node_update", 'BEFORE UPDATE', config.node_table) if scoped?
+      triggers = [trigger_sql('edge_insert_check', 'BEFORE INSERT', config.edge_table)]
+      triggers << trigger_sql('node_update', 'BEFORE UPDATE', config.node_table) if scoped?
       triggers
     end
   end

data/lib/dag_me/graph.rb

@@ -51,7 +51,7 @@ module DagMe
       return self unless config.closure?
 
       model.connection_pool.with_connection do |conn|
-        conn.execute("SELECT #{conn.quote_table_name("#{config.prefix}_rebuild_paths")}();")
+        conn.execute("SELECT #{conn.quote_table_name(config.function_ref('rebuild_paths'))}();")
       end
       self
     end
@@ -62,7 +62,7 @@ module DagMe
       return [] unless config.closure?
 
       model.connection_pool.with_connection do |conn|
-        conn.select_all("SELECT * FROM #{conn.quote_table_name("#{config.prefix}_validate_paths")}();").to_a
+        conn.select_all("SELECT * FROM #{conn.quote_table_name(config.function_ref('validate_paths'))}();").to_a
       end
     end
 

data/lib/dag_me/task_helpers.rb

@@ -76,7 +76,7 @@ module DagMe
         JOIN pg_class c ON c.oid = t.tgrelid
         JOIN pg_namespace n ON n.oid = c.relnamespace
         WHERE NOT t.tgisinternal
-          AND n.nspname = ANY (current_schemas(false))
+          AND #{namespace_filter(conn, config)}
           AND t.tgname LIKE #{conn.quote("#{config.prefix}\\_%")}
       SQL
       (expected - installed).map { |name| bad("trigger #{name} missing") }
@@ -96,13 +96,21 @@ module DagMe
       installed = conn.select_values(<<~SQL)
         SELECT p.proname FROM pg_proc p
         JOIN pg_namespace n ON n.oid = p.pronamespace
-        WHERE n.nspname = ANY (current_schemas(false))
+        WHERE #{namespace_filter(conn, config)}
           AND p.proname LIKE #{conn.quote("#{config.prefix}\\_%")}
       SQL
       (expected - installed).map { |name| bad("function #{name} missing") }
                             .presence || [ok("functions (#{expected.length})")]
     end
 
+    # Objects for schema-qualified node tables live in that schema regardless
+    # of search_path; unqualified ones resolve through it.
+    def namespace_filter(conn, config)
+      return "n.nspname = #{conn.quote(config.schema)}" if config.schema
+
+      'n.nspname = ANY (current_schemas(false))'
+    end
+
     def closure_check(model, config)
       return ok('closure: not materialized (recursive_cte)') unless config.closure?
       return nil unless model.connection.table_exists?(config.paths_table)

data/lib/dag_me/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DagMe
-  VERSION = '0.1.0'
+  VERSION = '0.3.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dag_me
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Abdelkader Boudih