redgraph 0.1.0 → 0.2.0

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,104 @@
+# 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
+
+      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,123 @@
+# frozen_string_literal: true
+require_relative 'node_model/class_methods'
+
+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|
+      @attribute_names = [:id]
+
+      attr_accessor :id
+      attr_accessor :_type
+
+      class << self
+        attr_reader :attribute_names
+        attr_accessor :graph
+
+        def attribute(name)
+          @attribute_names << name
+          attr_reader(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 persisted?
+      id.present?
+    end
+
+    # Adds the node to the graph
+    #
+    # - allow_duplicates: if false it will create a node with the same type and properties only if
+    #     not present
+    #
+    def add_to_graph(allow_duplicates: true)
+      item = allow_duplicates ? graph.add_node(to_node) : graph.merge_node(to_node)
+      self.id = item.id
+      self
+    end
+
+    # 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
+
+    def to_node
+      props = attributes.except(:id).merge(_type: self.class.name)
+      Redgraph::Node.new(id: id, label: label, properties: props)
+    end
+
+    # Converts a Node object into NodeModel
+    #
+    def reify_from_node(node)
+      self.class.reify_from_node(node)
+    end
+
+    def ==(other)
+      attributes == other.attributes && id == other.id
+    end
+
+  end
+end

data/lib/redgraph/node_model/class_methods.rb

@@ -0,0 +1,76 @@
+module Redgraph
+  module NodeModel
+    module ClassMethods
+      # Returns an array of nodes. Options:
+      #
+      # - properties: filter by properties
+      # - order: node.name ASC, node.year DESC
+      # - limit: number of items
+      # - skip: items offset (useful for pagination)
+      #
+      def all(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(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)
+        graph.query(cmd).map do |row|
+          row.map do |item|
+            item.is_a?(Node) ? reify_from_node(item) : item
+          end
+        end
+      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/query_response.rb

@@ -10,8 +10,28 @@ module Redgraph
   # - query stats
   #
   class QueryResponse
-    def initialize(response)
+    TYPES = [
+      UNKNOWN = 0,
+      NULL    = 1,
+      STRING  = 2,
+      INTEGER = 3,
+      BOOLEAN = 4,
+      DOUBLE  = 5,
+      ARRAY   = 6,
+      EDGE    = 7,
+      NODE    = 8,
+      PATH    = 9,
+      MAP     = 10,
+      POINT   = 11
+    ].freeze
+
+    def initialize(response, graph)
       @response = response
+      @graph = graph
+
+      @header_row = @response[0]
+      @result_rows = @response[1]
+      @query_statistics = @response[2]
     end
 
     def stats
@@ -26,19 +46,76 @@ module Redgraph
       @resultset ||= parse_resultset
     end
 
+    # Wraps in custom datatypes if needed
+    #
+    def rows
+      @result_rows.map do |column|
+        column.map do |data|
+          reify_column_item(data)
+        end
+
+      end
+    end
+
     private
 
+    def reify_column_item(data)
+      value_type, value = data
+
+      case value_type
+      when STRING, INTEGER, BOOLEAN, DOUBLE then value
+      when NODE then reify_node_item(value)
+      when EDGE then reify_edge_item(value)
+      else
+        "other"
+      end
+    end
+
+    def reify_node_item(data)
+      (node_id, labels, props) = data
+
+      label = @graph.get_label(labels[0]) # Only one label is currently supported
+
+      node = Node.new(label: label)
+      node.id = node_id
+
+      props.each do |(prop_id, prop_type, prop_value)|
+        prop_name = @graph.get_property(prop_id)
+        node.properties[prop_name] = prop_value
+      end
+
+      node
+    end
+
+    def reify_edge_item(data)
+      (edge_id, type_id, src_id, dest_id, props) = data
+
+      type = @graph.get_relationship_type(type_id)
+
+      edge = Edge.new(type: type)
+      edge.id = edge_id
+      edge.src_id = src_id
+      edge.dest_id = dest_id
+
+      props.each do |(prop_id, prop_type, prop_value)|
+        prop_name = @graph.get_property(prop_id)
+        edge.properties[prop_name] = prop_value
+      end
+
+      edge
+    end
+
     # The header lists the entities described in the RETURN clause. It is an
     # array of [ColumnType (enum), name (string)] elements. We can ignore the
     # enum, it is always 1 (COLUMN_SCALAR).
     def parse_header
-      @response[0].map{|item| item[1]}
+      @header_row.map{|item| item[1]}
     end
 
     def parse_stats
       stats = {}
 
-      @response[2].each do |item|
+      @query_statistics.each do |item|
         label, value = item.split(":")
 
         case label
@@ -58,8 +135,8 @@ module Redgraph
 
     # The resultset has one element per entity (as described by the header)
     def parse_resultset
-      @response[1].map do |item|
-        out = {}
+      @result_rows.map do |item|
+        out = HashWithIndifferentAccess.new
 
         item.each.with_index do |(type, value), i|
           out[entities[i]] = value