pglpg 0.1.0 → 0.2.0

data/lib/pglpg/schema/graph_type.rb

@@ -49,8 +49,8 @@ module Pglpg
         @graph_type.node_types[type.name] = type
       end
 
-      def edge(name, from:, to:, unique: nil, symmetric: false, temporal: false, &block)
-        type = EdgeType.new(name, from:, to:, unique:, symmetric:, temporal:)
+      def edge(name, from:, to:, unique: nil, symmetric: false, allow_self_loops: false, temporal: false, &block)
+        type = EdgeType.new(name, from:, to:, unique:, symmetric:, allow_self_loops:, temporal:)
         raise SchemaError, "type #{type.name} is declared twice" if declared?(type.name)
 
         ElementBuilder.new(type).instance_eval(&block) if block
@@ -91,9 +91,10 @@ module Pglpg
 
     class NodeBuilder < ElementBuilder
       # Declares an exclusive key. Interactive inserts get a value from
-      # +generate+ (default: a random UUID); callers never choose it.
-      def key(name, generate: nil)
-        @type.key_property(name, generate:)
+      # +generate+ (default: a random UUID). Scoped keys may be caller-chosen
+      # with an explicit key_scope_allowed grant.
+      def key(name, generate: nil, scope: nil)
+        @type.key_property(name, generate:, scope:)
       end
     end
   end

data/lib/pglpg/schema/node_type.rb

@@ -7,10 +7,12 @@ module Pglpg
     # A node type: a key label, inherited labels and property types
     # (GQL node types, PG-Schema inheritance).
     class NodeType < ElementType
-      # An exclusive, mandatory key on one property (PG-Keys). +generator+
-      # produces values for interactive inserts, which never accept a
-      # caller-chosen key.
-      Key = Struct.new(:property, :declared_on, :generator, keyword_init: true) do
+      # An exclusive, mandatory string key, optionally scoped by another
+      # required string property. Caller-chosen scoped keys need an explicit
+      # occupancy grant; omitted keys use +generator+.
+      Key = Struct.new(:property, :declared_on, :generator, :scope, keyword_init: true) do
+        def properties = [scope, property].compact.freeze
+
         def generate(type) = generator.call(type)
       end
 
@@ -27,11 +29,11 @@ module Pglpg
 
       def abstract? = @abstract
 
-      def key_property(name, generate: nil)
+      def key_property(name, generate: nil, scope: nil)
         raise SchemaError, "#{self.name} declares more than one key" if @own_key
         raise SchemaError, "key generator for #{self.name} must respond to call" if generate && !generate.respond_to?(:call)
 
-        @own_key = Key.new(property: name.to_sym, declared_on: self.name, generator: generate || DEFAULT_KEY_GENERATOR)
+        @own_key = Key.new(property: name.to_sym, declared_on: self.name, generator: generate || DEFAULT_KEY_GENERATOR, scope: scope && Schema.check_name!(scope, "key scope"))
       end
 
       def own_key = @own_key
@@ -85,7 +87,14 @@ module Pglpg
         raise SchemaError, "key #{key.declared_on}.#{key.property} must be required" unless prop.required?
         raise SchemaError, "key #{key.declared_on}.#{key.property} must be a string" unless prop.type == :string
 
-        key
+        if key.scope
+          raise SchemaError, "scope must differ from key property" if key.scope == key.property
+          scope = @properties[key.scope]
+          unless scope && scope.required? && scope.type == :string
+            raise SchemaError, "key scope #{key.scope} must be a declared required string property"
+          end
+        end
+        key.freeze
       end
     end
   end

data/lib/pglpg/storage.rb

@@ -27,8 +27,10 @@ module Pglpg
         raise ConfigurationError, "pglpg needs PostgreSQL 18 or later"
       end
 
-      tables_sql(connection).each { connection.execute(_1) }
-      sync_constraints!(connection)
+      connection.transaction(requires_new: true) do
+        tables_sql(connection).each { connection.execute(_1) }
+        synchronize_constraints(connection)
+      end
     end
 
     def drop!(connection = graph.connection)
@@ -81,8 +83,9 @@ module Pglpg
       type.node_types.each_value do |t|
         has_label = "labels @> ARRAY[#{connection.quote(t.name.to_s)}]::text[]"
         if (key = t.own_key)
+          expressions = key.properties.map { "(properties->>#{connection.quote(_1.to_s)})" }.join(", ")
           list << [:index, nodes_table, "key_#{t.name}_#{key.property}",
-                   "ON #{n} ((properties->>#{connection.quote(key.property.to_s)})) WHERE #{has_label}"]
+                   "ON #{n} (#{expressions}) WHERE #{has_label}"]
         end
         t.own_properties.each_value.select(&:required?).each do |p|
           list << [:check, nodes_table, "req_#{t.name}_#{p.name}", "NOT (#{has_label}) OR #{typed_check(connection, p)}"]
@@ -92,6 +95,11 @@ module Pglpg
       type.edge_types.each_value do |t|
         is_type = "type = #{connection.quote(t.name.to_s)}"
         list << [:index, edges_table, "pair_#{t.name}", "ON #{e} (source_id, target_id) WHERE #{is_type}"] if t.unique_pair?
+        if t.symmetric?
+          # Canonical orientation, so a pair is stored one way only (ADR-0008).
+          list << [:check, edges_table, "sym_#{t.name}",
+                   "NOT (#{is_type}) OR source_id #{t.allow_self_loops? ? "<=" : "<"} target_id"]
+        end
         t.own_properties.each_value.select(&:required?).each do |p|
           list << [:check, edges_table, "req_#{t.name}_#{p.name}", "NOT (#{is_type}) OR #{typed_check(connection, p)}"]
         end
@@ -108,20 +116,11 @@ module Pglpg
       end
     end
 
-    # Adds missing generated constraints and drops stale ones.
+    # Atomic on the supplied connection: its own transaction or a savepoint
+    # within an ActiveRecord-managed caller transaction. Backfills belong in
+    # an explicit outer transaction on the same connection.
     def sync_constraints!(connection = graph.connection)
-      wanted = constraints(connection)
-      existing = existing_constraints(connection)
-      (existing.keys - wanted.keys).each do |name|
-        info = existing[name]
-        if info[:kind] == :index
-          connection.execute("DROP INDEX #{q(connection, name)}")
-        else
-          connection.execute("ALTER TABLE #{q(connection, info[:table])} DROP CONSTRAINT #{q(connection, name)}")
-        end
-      end
-      (wanted.keys - existing.keys).each { connection.execute(wanted[_1][:sql]) }
-      nil
+      connection.transaction(requires_new: true) { synchronize_constraints(connection) }
     end
 
     # Rewrites stored label sets to match the graph type.
@@ -149,6 +148,21 @@ module Pglpg
 
     private
 
+    def synchronize_constraints(connection)
+      wanted = constraints(connection)
+      existing = existing_constraints(connection)
+      (existing.keys - wanted.keys).each do |name|
+        info = existing[name]
+        if info[:kind] == :index
+          connection.execute("DROP INDEX #{q(connection, name)}")
+        else
+          connection.execute("ALTER TABLE #{q(connection, info[:table])} DROP CONSTRAINT #{q(connection, name)}")
+        end
+      end
+      (wanted.keys - existing.keys).each { connection.execute(wanted[_1][:sql]) }
+      nil
+    end
+
     def type = graph.type
 
     def q(connection, name) = connection.quote_table_name(name)

data/lib/pglpg/testing/leak_examples.rb

@@ -31,7 +31,8 @@ RSpec.shared_examples "a pglpg visibility policy" do
         property :uid, :string, required: true
         property :name, :string
         property :rank, :integer
-        key :uid
+        property :namespace, :string, required: true
+        key :uid, scope: :namespace
       end
       node :Project do
         property :uid, :string, required: true
@@ -47,6 +48,7 @@ RSpec.shared_examples "a pglpg visibility policy" do
       end
       edge :BASED_AT, from: :Project, to: :Location
       edge :KNOWS, from: :Person, to: :Person
+      edge :FRIEND, from: :Person, to: :Person, symmetric: true
     end
   end
 
@@ -65,10 +67,13 @@ RSpec.shared_examples "a pglpg visibility policy" do
     seed = pglpg_seed_graph.for(viewer: nil).trusted_writer
     vis = pglpg_visible_attrs
     hid = pglpg_hidden_attrs
-    person = ->(uid, name, rank, attrs) { seed.insert_node(:Person, properties: { uid:, name:, rank: }, attrs:) }
+    person = ->(uid, name, rank, attrs) { seed.insert_node(:Person, properties: { uid:, name:, rank:, namespace: attrs == hid ? "hidden" : "visible" }, attrs:) }
     node = ->(type, uid, attrs, **props) { seed.insert_node(type, properties: { uid:, **props }, attrs:) }
     edge = ->(type, from, to, attrs, **props) { seed.insert_edge(type, from:, to:, properties: props, attrs:) }
 
+    # Created first, so it has the smallest id: symmetric edges to it are
+    # stored with the hidden node in the source column.
+    h0 = person.("H0", "Abe", 0, hid)
     p1 = person.("P1", "Ann", 1, vis)
     p2 = person.("P2", "Bob", 2, vis)
     p3 = person.("P3", "Cid", 3, vis)
@@ -81,12 +86,16 @@ RSpec.shared_examples "a pglpg visibility policy" do
       edge.(:WORKS_ON, p3, j2, vis, role: "lead"),
       edge.(:BASED_AT, j1, l1, vis),
       edge.(:KNOWS, p1, p2, vis),
-      edge.(:KNOWS, p2, p3, vis)
+      edge.(:KNOWS, p2, p3, vis),
+      edge.(:FRIEND, p2, p1, vis),
+      edge.(:FRIEND, p3, p2, vis)
     ]
     visible_refs = [p1, p2, p3, j1, j2, l1, *visible_edges]
 
     ctx = pglpg_leak_graph.for(viewer: pglpg_viewer)
     before = Pglpg::Testing.observe(ctx, visible_refs)
+    # Three visible People plus two visible Projects in this fixture.
+    raise "lazy association observations are missing" unless before.keys.count { _1.to_s.start_with?("assoc_") } == 5
     if before[:persons].size != 3 || before[:works_on].size != 3
       raise "the visibility policy hides the visible fixture; check pglpg_visible_attrs"
     end
@@ -96,7 +105,13 @@ RSpec.shared_examples "a pglpg visibility policy" do
     hj = node.(:Project, "HJ", hid, title: "Apollo")
     hl = node.(:Location, "HL", hid)
     hidden_refs = [
-      h1, h2, hj, hl,
+      h0, h1, h2, hj, hl,
+      # symmetric edges: hidden between visible nodes, and visible ones through
+      # hidden nodes stored at either end (a hidden bridge p1 ~ h0 ~ p3)
+      edge.(:FRIEND, p3, p1, hid),
+      edge.(:FRIEND, p1, h0, vis),
+      edge.(:FRIEND, h0, p3, vis),
+      edge.(:FRIEND, p2, h1, vis),
       # hidden edges between visible nodes
       edge.(:WORKS_ON, p3, j1, hid, role: "lead"),
       edge.(:KNOWS, p3, p1, hid),
@@ -116,6 +131,12 @@ RSpec.shared_examples "a pglpg visibility policy" do
     before.each_key { |name| expect(after[name]).to eq(before[name]), "observation #{name} changed" }
 
     hidden_refs.each { |ref| expect(ctx.find(ref)).to be_nil, "#{ref} is visible" }
-    expect(ctx.find_node(:Person, uid: "H1")).to be_nil
+    expect(ctx.find_node(:Person, namespace: "hidden", uid: "H1")).to be_nil
+
+    models = Pglpg::Testing.leak_models(pglpg_leak_graph)
+    [h0, h1, h2].each do |ref|
+      expect { models[:Person].in(ctx).find(ref) }.to raise_error(Pglpg::Model::RecordNotFound), "#{ref} is visible"
+    end
+    expect { models[:Project].in(ctx).find(hj) }.to raise_error(Pglpg::Model::RecordNotFound), "#{hj} is visible"
   end
 end

data/lib/pglpg/testing.rb

@@ -35,7 +35,12 @@ module Pglpg
         projects: -> { m.().node(:p, :Person).out(:WORKS_ON, :j, :Project).return(:j).distinct },
         page: -> { m.().node(:p, :Person).out(:WORKS_ON, :j, :Project).limit(2).offset(1) },
         ann: -> { m.().node(:p, :Person, name: "Ann").out(:WORKS_ON, :j, :Project) },
-        cid_knows: -> { m.().node(:p, :Person, name: "Cid").out(:KNOWS, :q) }
+        cid_knows: -> { m.().node(:p, :Person, name: "Cid").out(:KNOWS, :q) },
+        friends: -> { m.().node(:p, :Person).both(:FRIEND, :q, :Person, edge: :f) },
+        friend_edges: -> { m.().node(:p, :Person).both(:FRIEND, :q, edge: :f).return(:f).distinct },
+        friend_chain: -> { m.().node(:a, :Person).both(:FRIEND, :b).both(:FRIEND, :c) },
+        ann_friends: -> { m.().node(:p, :Person, name: "Ann").both(:FRIEND, :q) },
+        friends_page: -> { m.().node(:p, :Person).both(:FRIEND, :q).limit(2).offset(1) }
       }
       out = {}
       queries.each do |name, q|
@@ -44,12 +49,126 @@ module Pglpg
         out[:"#{name}_exists"] = q.().exists?
         out[:"#{name}_first"] = q.().first&.transform_values { element_data(_1) }
       end
+      reach = {
+        knows: { via: %i[KNOWS] },
+        knows_in: { via: %i[KNOWS], direction: :in },
+        friends: { via: %i[FRIEND], direction: :both },
+        works: { via: %i[WORKS_ON BASED_AT] },
+        works_in: { via: %i[WORKS_ON BASED_AT], direction: :in },
+        knows_capped: { via: %i[KNOWS], max_nodes: 1 },
+        friends_capped: { via: %i[FRIEND], direction: :both, max_nodes: 1 }
+      }
+      # Within the application's row cap, which may be smaller than 10.
+      budget = [10, Pglpg.configuration.max_rows].min
+      reach.each do |name, args|
+        out[:"reach_#{name}"] = refs.select(&:node?).map do |ref|
+          r = ctx.reachable(from: ref, max_depth: 3, max_nodes: budget, **args)
+          [r.nodes.map { |node, depth| [node.id, depth] }, r.complete, r.stopped_at_depth]
+        end
+      end
       out[:last_by_name] = element_data(m.().node(:p, :Person).order(p: { name: :desc }).first&.fetch(:p))
       out[:find] = refs.map { element_data(ctx.find(_1)) }
-      out[:find_node] = %w[P1 P2 P3 H1].map { element_data(ctx.find_node(:Person, uid: _1)) }
+      out[:find_node] = %w[P1 P2 P3 H1].map { element_data(ctx.find_node(:Person, namespace: _1 == "H1" ? "hidden" : "visible", uid: _1)) }
+      out.merge(observe_models(ctx, refs))
+    end
+
+    # The same observations through the model layer (ADR-0010).
+    def observe_models(ctx, refs)
+      models = leak_models(ctx.graph)
+      relations = {
+        persons: -> { models[:Person].in(ctx).order(:name) },
+        ranked: -> { models[:Person].in(ctx).where(rank: Pglpg.gte(2)).order(rank: :desc) },
+        persons_page: -> { models[:Person].in(ctx).order(:name).limit(2).offset(1) },
+        projects: -> { models[:Project].in(ctx) },
+        works_on: -> { models[:WORKS_ON].in(ctx).order(:role) },
+        leads: -> { models[:WORKS_ON].in(ctx).where(role: "lead") },
+        knows: -> { models[:KNOWS].in(ctx) },
+        friends: -> { models[:FRIEND].in(ctx) },
+        friends_page: -> { models[:FRIEND].in(ctx).limit(1).offset(1) }
+      }
+      out = {}
+      relations.each do |name, r|
+        out[:"model_#{name}"] = r.().map { model_data(_1) }
+        out[:"model_#{name}_count"] = r.().count
+        out[:"model_#{name}_exists"] = r.().exists?
+        out[:"model_#{name}_first"] = model_data(r.().first)
+        out[:"model_#{name}_pluck"] = r.().pluck(:id, *r.().model.attribute_names)
+      end
+      out[:model_find_by] = %w[P1 P2 P3 H1].map { model_data(models[:Person].in(ctx).find_by(uid: _1)) }
+      out[:model_find] = refs.map do |ref|
+        model = ref.node? ? models[:Person] : models[:WORKS_ON]
+        model_data(model.in(ctx).find(ref))
+      rescue Pglpg::Model::RecordNotFound
+        nil
+      end
+      out.merge!(observe_associations(ctx, models))
+      owners = models[:Person].in(ctx).with_associations(:known, :known_by, :friends, :projects).to_a +
+               models[:Project].in(ctx).with_associations(:people).to_a
+      eager = observe_associations(ctx, models, owners)
+      eager.each { |name, value| raise "preload differs from lazy #{name}" unless value == out.fetch(name) }
+      out[:eager_associations] = eager
+      nested = models[:Person].in(ctx).with_associations(friends: :friends, projects: :people)
+      out[:eager_nested] = nested.map do |owner|
+        [owner.uid, { friends: :friends, projects: :people }.map do |name, child|
+          owner.public_send(name).map do |target|
+            cached = target.public_send(child).map { model_data(_1) }
+            lazy = target.class.in(ctx).find(target.ref).public_send(child).map { model_data(_1) }
+            raise "nested preload differs from lazy #{name}.#{child}" unless cached == lazy
+
+            [model_data(target), cached]
+          end
+        end]
+      end
       out
     end
 
+    # Association target and binding queries from every visible owner.
+    def observe_associations(ctx, models, owners = nil)
+      pair = ->((node, edge)) { [model_data(node), model_data(edge)] }
+      owners ||= models[:Person].in(ctx).order(:uid).to_a + models[:Project].in(ctx).order(:uid).to_a
+      owners.to_h do |owner|
+        data = owner.class.associations.keys.to_h do |name|
+          targets = -> { owner.public_send(name) }
+          [name, {
+            rows: targets.().map { model_data(_1) },
+            count: targets.().count,
+            exists: targets.().exists?,
+            first: model_data(targets.().first),
+            page: targets.().limit(1).offset(1).map { model_data(_1) },
+            pairs: targets.().with_rel.map(&pair),
+            pairs_count: targets.().with_rel.count,
+            pairs_page: targets.().with_rel.limit(1).offset(1).map(&pair),
+            pluck: targets.().pluck(:id, *targets.().model.attribute_names),
+            pairs_pluck: targets.().with_rel.pluck(:id, rel: [:id, *models.fetch(owner.class.associations[name].edge_type).attribute_names])
+          }]
+        end
+        data[:leads] = owner.projects.rel_where(role: "lead").map { model_data(_1) } if owner.respond_to?(:projects)
+        [:"assoc_#{owner.uid}", data]
+      end
+    end
+
+    def model_data(record)
+      return nil if record.nil?
+
+      data = [record.class.schema_type.name, record.id, record.attributes, record.extra_properties]
+      data + (record.is_a?(Pglpg::Model::Edge) ? [record.source.id, record.target.id] : [record.labels])
+    end
+
+    # One model per type of the leak graph, built once per graph.
+    def leak_models(leak_graph)
+      (@leak_models ||= ObjectSpace::WeakKeyMap.new)[leak_graph] ||=
+        %i[Person Project WORKS_ON KNOWS FRIEND].to_h do |type|
+          base = leak_graph.type.node_types.key?(type) ? Pglpg::Model::Node : Pglpg::Model::Edge
+          [type, Class.new(base) { graph(leak_graph, type:) }]
+        end.tap do |models|
+          models[:Person].has_many :projects, :out, edge: :WORKS_ON
+          models[:Person].has_many :known, :out, edge: :KNOWS
+          models[:Person].has_many :known_by, :in, edge: :KNOWS
+          models[:Person].has_many :friends, :both, edge: :FRIEND
+          models[:Project].has_many :people, :in, edge: :WORKS_ON
+        end
+    end
+
     def element_data(element)
       case element
       when nil then nil
@@ -61,4 +180,5 @@ module Pglpg
   end
 end
 
+require_relative "model"
 require_relative "testing/leak_examples" if defined?(RSpec)

data/lib/pglpg/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Pglpg
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/pglpg/writer.rb

@@ -8,6 +8,9 @@ module Pglpg
   #   target:    the Ref being changed (update and delete), else nil
   #   from, to:  endpoint Refs for edge inserts and upserts
   #   key:       the key for upserts
+  # Scope-wide occupancy permission, distinct from write or read access.
+  KeyScopeRequest = Data.define(:context, :domain, :scope)
+
   WriteRequest = Data.define(:viewer, :operation, :type, :target, :from, :to, :key, :properties, :attrs, :trusted)
 
   # Compiles writes into single statements. Visibility of the existing row,
@@ -15,6 +18,8 @@ module Pglpg
   # statement, so they hold against the row the statement actually touches,
   # even under concurrent writes.
   class Writer
+    attr_reader :context
+
     def initialize(context, trusted:)
       @context = context
       @graph = context.graph
@@ -26,7 +31,7 @@ module Pglpg
       props = properties.transform_keys(&:to_sym)
       if (key = node_type.key)
         if props.key?(key.property)
-          raise ArgumentError, "#{node_type.name}.#{key.property} is a key and is generated" unless @trusted
+          raise ArgumentError, "#{node_type.name}.#{key.property} is a key and is generated" unless @trusted || key.scope
         else
           props[key.property] = key.generate(node_type.name)
         end
@@ -34,6 +39,12 @@ module Pglpg
       json = node_type.encode_properties(props)
       cols = encode_attrs(@graph.type.node_columns, attrs, insert: true)
       authorize!(:insert_node, node_type.name, properties: props, attrs:)
+      if key&.scope && !@trusted && properties.keys.map(&:to_sym).include?(key.property)
+        scope = { key.scope => props.fetch(key.scope).dup.freeze }.freeze
+        request = KeyScopeRequest.new(context:, domain: key.declared_on, scope:)
+        allowed = @graph.key_scope_allowed
+        raise WriteRejected unless allowed.respond_to?(:call) && allowed.call(request) == true
+      end
 
       sql = new_sql
       insert_node_values(sql, node_type, json, cols)
@@ -46,7 +57,7 @@ module Pglpg
       node = @context.find(ref) or raise WriteRejected
       node_type = @graph.type.node_type!(node.key_label)
       props = properties.transform_keys(&:to_sym)
-      raise ArgumentError, "keys cannot be changed" if node_type.key && props.key?(node_type.key.property)
+      raise ArgumentError, "keys cannot be changed" if node_type.key && (props.keys & node_type.key.properties).any?
 
       json = node_type.encode_properties(props, partial: true)
       cols = encode_attrs(@graph.type.node_columns, attrs, insert: false)
@@ -70,10 +81,10 @@ module Pglpg
       node_type = concrete_node_type!(type)
       node_key = node_type.key or raise ArgumentError, "#{node_type.name} has no key"
       key = key.transform_keys(&:to_sym)
-      raise ArgumentError, "#{node_type.name} is upserted by #{node_key.property.inspect}" unless key.keys == [node_key.property]
+      raise ArgumentError, "#{node_type.name} is upserted by #{node_key.properties.inspect}" unless key.keys.sort == node_key.properties.sort
 
       props = properties.transform_keys(&:to_sym)
-      raise ArgumentError, "pass the key in key:, not properties:" if props.key?(node_key.property)
+      raise ArgumentError, "pass the key in key:, not properties:" if (props.keys & node_key.properties).any?
 
       props = props.merge(key)
       json = node_type.encode_properties(props)
@@ -82,8 +93,13 @@ module Pglpg
 
       sql = new_sql
       insert_node_values(sql, node_type, json, cols)
-      sql << " ON CONFLICT ((properties->>"
-      sql.literal(node_key.property) << ")) WHERE labels @> ARRAY["
+      sql << " ON CONFLICT ("
+      node_key.properties.each_with_index do |property, i|
+        sql << ", " if i.positive?
+        sql << "(properties->>"
+        sql.literal(property) << ")"
+      end
+      sql << ") WHERE labels @> ARRAY["
       sql.literal(node_key.declared_on) << "]::text[] DO UPDATE SET "
       set_properties(sql, "tgt.properties", json, null_keys(props), excluded: true)
       set_columns(sql, cols, excluded: true)
@@ -166,6 +182,14 @@ module Pglpg
     def write_edge(operation, edge_type, from, to, properties, attrs)
       @graph.check_ref!(from, :node)
       @graph.check_ref!(to, :node)
+      if edge_type.symmetric?
+        if from.id == to.id && !edge_type.allow_self_loops?
+          raise ArgumentError, "#{edge_type.name} does not allow self-loops"
+        end
+
+        # Stored in canonical orientation, so either order names the same pair.
+        from, to = to, from if from.id > to.id
+      end
       props = properties.transform_keys(&:to_sym)
       json = edge_type.encode_properties(props)
       cols = encode_attrs(@graph.type.edge_columns, attrs, insert: true)
@@ -183,9 +207,14 @@ module Pglpg
       end
       sql << " FROM " << table(@graph.nodes_table) << " AS s, " << table(@graph.nodes_table) << " AS t WHERE s.id = "
       sql.bind(from.id, "bigint") << " AND t.id = "
-      sql.bind(to.id, "bigint") << " AND s.labels @> "
-      sql.bind_text_array([edge_type.from]) << " AND t.labels @> "
-      sql.bind_text_array([edge_type.to]) << " AND "
+      sql.bind(to.id, "bigint") << " AND ("
+      endpoint_labels(sql, edge_type.from, edge_type.to)
+      if edge_type.symmetric? && edge_type.from != edge_type.to
+        # Either endpoint may carry either label.
+        sql << " OR "
+        endpoint_labels(sql, edge_type.to, edge_type.from)
+      end
+      sql << ") AND "
       @context.append_node_visible(sql, "s")
       sql << " AND "
       @context.append_node_visible(sql, "t")
@@ -203,6 +232,12 @@ module Pglpg
       ref(:edge, write(sql))
     end
 
+    def endpoint_labels(sql, source_label, target_label)
+      sql << "(s.labels @> "
+      sql.bind_text_array([source_label]) << " AND t.labels @> "
+      sql.bind_text_array([target_label]) << ")"
+    end
+
     def insert_node_values(sql, node_type, json, cols)
       sql << "INSERT INTO " << table(@graph.nodes_table) << " AS tgt (key_label, labels, properties"
       cols.each { |c, _| sql << ", " << ident(c.name) }
@@ -312,7 +347,7 @@ module Pglpg
       id.to_i
     rescue ActiveRecord::StatementInvalid => e
       case e.cause
-      when PG::UniqueViolation, PG::ForeignKeyViolation, PG::RestrictViolation then raise WriteRejected
+      when PG::UniqueViolation, PG::ForeignKeyViolation, PG::RestrictViolation then raise WriteRejected, cause: nil
       when PG::NotNullViolation, PG::CheckViolation then raise ValidationError, e.message
       else raise
       end

data/lib/pglpg.rb

@@ -21,6 +21,7 @@ require_relative "pglpg/graph"
 require_relative "pglpg/context"
 require_relative "pglpg/writer"
 require_relative "pglpg/query"
+require_relative "pglpg/reachability"
 
 # Labeled property graphs stored in plain PostgreSQL tables.
 module Pglpg

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pglpg
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Anton Fefilov
@@ -54,7 +54,13 @@ files:
 - lib/pglpg/element.rb
 - lib/pglpg/errors.rb
 - lib/pglpg/graph.rb
+- lib/pglpg/model.rb
+- lib/pglpg/model/base.rb
+- lib/pglpg/model/edge.rb
+- lib/pglpg/model/node.rb
+- lib/pglpg/model/relation.rb
 - lib/pglpg/query.rb
+- lib/pglpg/reachability.rb
 - lib/pglpg/ref.rb
 - lib/pglpg/schema/column.rb
 - lib/pglpg/schema/edge_type.rb