redgraph 0.1.1 → 0.2.1

data/lib/redgraph/graph/edge_methods.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Redgraph
+  class Graph
+    module EdgeMethods
+      # Adds an edge. If successul it returns the created object, otherwise false
+      #
+      def add_edge(edge)
+        merge_or_add_edge(edge, :create)
+      end
+
+      # Merges (creates an edge unless one with the same type and properties exists) an edge.
+      # If successul it returns the object, otherwise false
+      #
+      def merge_edge(edge)
+        merge_or_add_edge(edge, :merge)
+      end
+
+      # Finds edges. Options:
+      #
+      # - type
+      # - src
+      # - dest
+      # - properties
+      # - order
+      # - limit
+      # - skip
+      #
+      def edges(type: nil, src: nil, dest: nil, properties: nil, order: nil, limit: nil, skip: nil)
+        _order = if order
+          raise MissingAliasPrefixError unless order.include?("edge.")
+          "ORDER BY #{order}"
+        end
+        _limit = "LIMIT #{limit}" if limit
+        _skip = "SKIP #{skip}" if skip
+
+        _where = if src || dest
+          clauses = [
+            ("ID(src) = #{src.id}" if src),
+            ("ID(dest) = #{dest.id}" if dest)
+          ].compact.join(" AND ")
+          "WHERE #{clauses}"
+        end
+
+        edge = Edge.new(type: type, src: src, dest: dest, properties: properties)
+
+        cmd = "MATCH #{edge.to_query_string} #{_where}
+               RETURN src, edge, dest #{_order} #{_skip} #{_limit}"
+        result = _query(cmd)
+
+        result.resultset.map do |item|
+          src = node_from_resultset_item(item["src"])
+          dest = node_from_resultset_item(item["dest"])
+          edge = edge_from_resultset_item(item["edge"])
+
+          edge.src = src
+          edge.dest = dest
+
+          edge
+        end
+      end
+
+      # Counts edges. Options:
+      #
+      # - type: filter by type
+      # - properties: filter by properties
+      #
+      def count_edges(type: nil, properties: nil)
+        edge = Edge.new(type: type, properties: properties)
+
+        cmd = "MATCH #{edge.to_query_string} RETURN COUNT(edge)"
+        query(cmd).flatten[0]
+      end
+
+
+      private
+
+      def edge_from_resultset_item(item)
+        (edge_id, type_id, _src_id, _dest_id, props) = item
+        attrs = HashWithIndifferentAccess.new
+
+        props.each do |(index, type, value)|
+          attrs[get_property(index)] = value
+        end
+
+        Edge.new.tap do |edge|
+          edge.id = edge_id
+          edge.type = get_relationship_type(type_id)
+          edge.properties = attrs
+        end
+      end
+
+      def merge_or_add_edge(edge, verb = :create)
+        verb = verb == :create ? "CREATE" : "MERGE"
+        result = _query("MATCH (src), (dest)
+                        WHERE ID(src) = #{edge.src.id} AND ID(dest) = #{edge.dest.id}
+                        #{verb} #{edge.to_query_string} RETURN ID(edge)")
+        return false if result.stats[:relationships_created] != 1
+        id = result.resultset.first["ID(edge)"]
+        edge.id = id
+        edge
+      end
+    end
+  end
+end

data/lib/redgraph/graph/node_methods.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Redgraph
+  class Graph
+    module NodeMethods
+      # Adds a node. If successul it returns the created object, otherwise false
+      #
+      def add_node(node)
+        merge_or_add_node(node, :create)
+      end
+
+      # Merges (creates a node unless one with the same label and properties exists). If successul
+      # it returns the object, otherwise false
+      #
+      def merge_node(node)
+        merge_or_add_node(node, :merge)
+      end
+
+      def find_node_by_id(id)
+        result = _query("MATCH (node) WHERE ID(node) = #{id} RETURN node")
+        return nil if result.resultset.empty?
+        (node_id, labels, properties) = result.resultset.first["node"]
+        attrs = {}
+
+        properties.each do |(index, type, value)|
+          attrs[get_property(index)] = value
+        end
+        Node.new(label: get_label(labels.first), properties: attrs).tap do |node|
+          node.id = node_id
+        end
+      end
+
+
+      # Returns nodes. Options:
+      #
+      # - label: filter by label
+      # - properties: filter by properties
+      # - order: node.name ASC, node.year DESC
+      # - limit: number of items
+      # - skip: items offset (useful for pagination)
+      #
+      def nodes(label: nil, properties: nil, order: nil, limit: nil, skip: nil)
+        _label = ":`#{label}`" if label
+        _order = if order
+          raise MissingAliasPrefixError unless order.include?("node.")
+          "ORDER BY #{order}"
+        end
+        _limit = "LIMIT #{limit}" if limit
+        _skip = "SKIP #{skip}" if skip
+
+        node = Node.new(label: label, properties: properties)
+
+        cmd = "MATCH #{node.to_query_string} RETURN node #{_order} #{_skip} #{_limit}"
+
+        result = _query(cmd)
+
+        result.resultset.map do |item|
+          node_from_resultset_item(item["node"])
+        end
+      end
+
+      # Counts nodes. Options:
+      #
+      # - label: filter by label
+      # - properties: filter by properties
+      #
+      def count_nodes(label: nil, properties: nil)
+        node = Node.new(label: label, properties: properties)
+
+        cmd = "MATCH #{node.to_query_string} RETURN COUNT(node)"
+        # RedisGraph bug: if there are no matches COUNT returns zero rows
+        # https://github.com/RedisGraph/RedisGraph/issues/1455
+        query(cmd).flatten[0] || 0
+      end
+
+      def update_node(node)
+        return false unless node.persisted?
+        _set = node.properties.map do |(key, val)|
+          "node.#{key} = #{escape_value(val)}"
+        end.join(", ")
+
+        cmd = "MATCH (node) WHERE ID(node) = #{node.id} SET #{_set} RETURN node"
+        result = _query(cmd)
+        node_from_resultset_item(result.resultset.first["node"])
+      end
+
+      def destroy_node(node)
+        return false unless node.persisted?
+        cmd = "MATCH (node) WHERE ID(node) = #{node.id} DELETE node"
+        result = _query(cmd)
+        result.stats["nodes_deleted"] == 1
+      end
+
+      private
+
+      # Builds a Node object from the raw data
+      #
+      def node_from_resultset_item(item)
+        (node_id, labels, props) = item
+        attrs = HashWithIndifferentAccess.new
+
+        props.each do |(index, type, value)|
+          attrs[get_property(index)] = value
+        end
+        Node.new(label: get_label(labels.first), properties: attrs).tap do |node|
+          node.id = node_id
+        end
+      end
+
+      def merge_or_add_node(node, verb = :create)
+        verb = verb == :create ? "CREATE" : "MERGE"
+        result = _query("#{verb} #{node.to_query_string} RETURN ID(node)")
+        # Should we treat this case differently?
+        # return false if result.stats[:nodes_created] != 1
+        id = result.resultset.first["ID(node)"]
+        node.id = id
+        node
+      end
+
+
+    end
+  end
+end

data/lib/redgraph/node.rb

@@ -2,19 +2,27 @@
 
 module Redgraph
   class Node
+    include Util
+
     attr_accessor :id, :label, :properties
 
-    def initialize(label:, properties: {})
+    def initialize(label: nil, properties: nil, id: nil)
+      @id = id
       @label = label
-      @properties = properties
+      @properties = (properties || {}).with_indifferent_access
     end
 
     def persisted?
-      !id.nil?
+      id.present?
     end
 
     def ==(other)
       super || other.instance_of?(self.class) && !id.nil? && other.id == id
     end
+
+    def to_query_string(item_alias: 'node')
+      _label = ":#{label}" if label
+      "(#{item_alias}#{_label} #{properties_to_string(properties)})"
+    end
   end
 end

data/lib/redgraph/node_model.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+require_relative 'node_model/class_methods'
+require_relative 'node_model/graph_manipulation'
+require_relative 'node_model/persistence'
+
+module Redgraph
+  # This mixin allows you to use an interface similar to ActiveRecord
+  #
+  # class Actor
+  #   include Redgraph::NodeModel
+  #
+  #   self.graph = Redgraph::Graph.new("movies", url: $REDIS_URL)
+  #   self.label = "actor" # optional, if missing it will be extracted from the class name
+  #   attribute :name
+  # end
+  #
+  # You will then be able to
+  #
+  # john = Actor.find(123)
+  # total = Actor.count
+  #
+  # When you create a record it will automatically set the _type property with the class name.
+  # This allows reifying the node into the corresponding NodeModel class.
+  #
+  module NodeModel
+    extend ActiveSupport::Concern
+
+    included do |base|
+      include Persistence
+      include GraphManipulation
+
+      @attribute_names = [:id]
+
+      attr_accessor :id, :_type
+
+      class << self
+        attr_reader :attribute_names
+        attr_accessor :graph
+
+        def attribute(name)
+          @attribute_names << name
+          attr_accessor(name)
+        end
+
+        private
+
+        def inherited(subclass)
+          super
+          subclass.instance_variable_set(:@attribute_names, @attribute_names.dup)
+          subclass.instance_variable_set(:@graph, @graph.dup)
+        end
+      end
+    end
+
+    def initialize(**args)
+      absent_attributes = args.keys.map(&:to_sym) - self.class.attribute_names - [:_type]
+
+      if absent_attributes.any?
+        raise ArgumentError, "Unknown attribute #{absent_attributes}"
+      end
+
+      args.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    # The current graph
+    #
+    def graph
+      self.class.graph
+    end
+
+    def label
+      self.class.label
+    end
+
+    # Object attributes as a hash
+    #
+    def attributes
+      self.class.attribute_names.to_h { |name| [name, public_send(name)] }
+    end
+
+    def assign_attributes(attrs = {})
+      attrs.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    def to_node
+      props = attributes.except(:id).merge(_type: self.class.name)
+      Redgraph::Node.new(id: id, label: label, properties: props)
+    end
+
+    def ==(other)
+      attributes == other.attributes && id == other.id
+    end
+
+  end
+end

data/lib/redgraph/node_model/class_methods.rb

@@ -0,0 +1,83 @@
+module Redgraph
+  module NodeModel
+    module ClassMethods
+      # Returns an array of nodes. Options:
+      #
+      # - label: filter by label
+      # - properties: filter by properties
+      # - order: node.name ASC, node.year DESC
+      # - limit: number of items
+      # - skip: items offset (useful for pagination)
+      #
+      def all(label: nil, properties: {}, limit: nil, skip: nil, order: nil)
+        graph.nodes(label: label, properties: properties_plus_type(properties),
+                    limit: limit, skip: skip, order: nil).map do |node|
+          reify_from_node(node)
+        end
+      end
+
+      # Returns the number of nodes with the current label. Options:
+      #
+      # - properties: filter by properties
+      #
+      def count(label: nil, properties: nil)
+        graph.count_nodes(label: label, properties: properties_plus_type(properties))
+      end
+
+      # Finds a node by id. Returns nil if not found
+      #
+      def find(id)
+        node = graph.find_node_by_id(id)
+        return unless node
+        reify_from_node(node)
+      end
+
+      # Sets the label for this class of nodes. If missing it will be computed from the class name
+      def label=(x)
+        @label = x
+      end
+
+      # Current label
+      #
+      def label
+        @label ||= default_label
+      end
+
+      # Converts a Node object into NodeModel
+      #
+      def reify_from_node(node)
+        klass = node.properties[:_type].to_s.safe_constantize || self
+        klass.new(id: node.id, **node.properties)
+      end
+
+      # Runs a query on the graph, but converts the nodes to the corresponding ActiveModel class
+      # if available - otherwise they stay NodeObjects.
+      #
+      # Returns an array of rows.
+      #
+      def query(cmd)
+        raise MissingGraphError unless graph
+
+        graph.query(cmd).map do |row|
+          row.map do |item|
+            item.is_a?(Node) ? reify_from_node(item) : item
+          end
+        end
+      end
+
+      def create(properties)
+        new(**properties).add_to_graph
+      end
+
+      private
+
+      def default_label
+        name.demodulize.underscore
+      end
+
+      def properties_plus_type(properties = {})
+        {_type: name}.merge(properties || {})
+      end
+    end
+  end
+end

data/lib/redgraph/node_model/graph_manipulation.rb

@@ -0,0 +1,24 @@
+module Redgraph
+  module NodeModel
+    module GraphManipulation
+      # Adds a relation between the node and another node.
+      #
+      # - type: type of relation
+      # - node: the destination node
+      # - properties: optional properties hash
+      # - allow_duplicates: if false it will create a relation between two nodes with the same type
+      #     and properties only if not present
+      #
+      def add_relation(type:, node:, properties: nil, allow_duplicates: true)
+        edge = Edge.new(type: type, src: to_node, dest: node.to_node, properties: properties)
+        allow_duplicates ? graph.add_edge(edge) : graph.merge_edge(edge)
+      end
+
+      # Runs a custom query on the graph
+      #
+      def query(cmd)
+        self.class.query(cmd)
+      end
+    end
+  end
+end