nose 0.1.0pre

data/lib/nose/statements/connection.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+module NoSE
+  # Superclass for connect and disconnect statements
+  class Connection < Statement
+    include StatementSupportQuery
+
+    attr_reader :source_pk, :target, :target_pk, :conditions
+    alias source entity
+
+    def initialize(params, text, group: nil, label: nil)
+      super params, text, group: group, label: label
+      fail InvalidStatementException, 'Incorrect connection initialization' \
+        unless text.split.first == self.class.name.split('::').last.upcase
+
+      populate_conditions params
+    end
+
+    # Build a new disconnect from a provided parse tree
+    # @return [Connection]
+    def self.parse(tree, params, text, group: nil, label: nil)
+      keys_from_tree tree, params
+
+      new params, text, group: group, label: label
+    end
+
+    # @return[void]
+    def self.keys_from_tree(tree, params)
+      params[:source_pk] = tree[:source_pk]
+      params[:target] = params[:entity].foreign_keys[tree[:target].to_s]
+      params[:target_pk] = tree[:target_pk]
+    end
+
+    # Produce the SQL text corresponding to this connection
+    # @return [String]
+    def unparse
+      "CONNECT #{source.name}(\"#{source_pk}\") TO " \
+        "#{target.name}(\"#{target_pk}\")"
+    end
+
+    def ==(other)
+      self.class == other.class &&
+        @graph == other.graph &&
+        @source == other.source &&
+        @target == other.target &&
+        @conditions == other.conditions
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [@graph, @source, @target, @conditions].hash
+    end
+
+    # A connection modifies an index if the relationship is in the path
+    def modifies_index?(index)
+      index.path.include?(@target) || index.path.include?(@target.reverse)
+    end
+
+    # Get the support queries for updating an index
+    def support_queries(index)
+      return [] unless modifies_index?(index)
+
+      select = index.all_fields - @conditions.each_value.map(&:field).to_set
+      return [] if select.empty?
+
+      index.graph.split(entity).map do |graph|
+        support_fields = select.select do |field|
+          graph.entities.include? field.parent
+        end.to_set
+        conditions = @conditions.select do |_, c|
+          graph.entities.include? c.field.parent
+        end
+
+        split_entity = split_entity graph, index.graph, entity
+        build_support_query split_entity, index, graph, support_fields,
+                            conditions
+      end.compact
+    end
+
+    protected
+
+    # The two key fields are provided with the connection
+    def given_fields
+      [@target.parent.id_field, @target.entity.id_field]
+    end
+
+    private
+
+    # Validate the types of the primary keys
+    # @return [void]
+    def validate_keys
+      # XXX Only works for non-composite PKs
+      source_type = source.id_field.class.const_get 'TYPE'
+      fail TypeError unless source_type.nil? || source_pk.is_a?(type)
+
+      target_type = @target.class.const_get 'TYPE'
+      fail TypeError unless target_type.nil? || target_pk.is_a?(type)
+    end
+
+    # Populate the list of condition objects
+    # @return [void]
+    def populate_conditions(params)
+      @source_pk = params[:source_pk]
+      @target = params[:target]
+      @target_pk = params[:target_pk]
+
+      validate_keys
+
+      # This is needed later when planning updates
+      @eq_fields = [@target.parent.id_field,
+                    @target.entity.id_field]
+
+      source_id = source.id_field
+      target_id = @target.entity.id_field
+      @conditions = {
+        source_id.id => Condition.new(source_id, :'=', @source_pk),
+        target_id.id => Condition.new(target_id, :'=', @target_pk)
+      }
+    end
+
+    # Get the where clause for a support query over the given path
+    # @return [String]
+    def support_query_condition_for_path(path, reversed)
+      key = (reversed ? target.entity : target.parent).id_field
+      path = path.reverse if path.entities.last != key.entity
+      eq_key = path.entries[-1]
+      if eq_key.is_a? Fields::ForeignKeyField
+        where = "WHERE #{eq_key.name}.#{eq_key.entity.id_field.name} = ?"
+      else
+        where = "WHERE #{eq_key.parent.name}." \
+                "#{eq_key.parent.id_field.name} = ?"
+      end
+
+      where
+    end
+  end
+
+  # A representation of a connect in the workload
+  class Connect < Connection
+    # Specifies that connections require insertion
+    def requires_insert?(_index)
+      true
+    end
+  end
+
+  # A representation of a disconnect in the workload
+  class Disconnect < Connection
+    # Produce the SQL text corresponding to this disconnection
+    # @return [String]
+    def unparse
+      "DISCONNECT #{source.name}(\"#{source_pk}\") FROM " \
+        "#{target.name}(\"#{target_pk}\")"
+    end
+
+    # Specifies that disconnections require deletion
+    def requires_delete?(_index)
+      true
+    end
+  end
+end

data/lib/nose/statements/delete.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module NoSE
+  # A representation of a delete in the workload
+  class Delete < Statement
+    include StatementConditions
+    include StatementSupportQuery
+
+    def initialize(params, text, group: nil, label: nil)
+      super params, text, group: group, label: label
+
+      populate_conditions params
+    end
+
+    # Build a new delete from a provided parse tree
+    # @return [Delete]
+    def self.parse(tree, params, text, group: nil, label: nil)
+      conditions_from_tree tree, params
+
+      Delete.new params, text, group: group, label: label
+    end
+
+    # Produce the SQL text corresponding to this delete
+    # @return [String]
+    def unparse
+      delete = "DELETE #{entity.name} "
+      delete += "FROM #{from_path @key_path}"
+      delete << where_clause
+
+      delete
+    end
+
+    def ==(other)
+      other.is_a?(Delete) &&
+        @graph == other.graph &&
+        entity == other.entity &&
+        @conditions == other.conditions
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [@graph, entity, @conditions].hash
+    end
+
+    # Index contains the entity to be deleted
+    def modifies_index?(index)
+      index.graph.entities.include? entity
+    end
+
+    # Specifies that deletes require deletion
+    def requires_delete?(_index)
+      true
+    end
+
+    # Get the support queries for deleting from an index
+    def support_queries(index)
+      return [] unless modifies_index? index
+      select = (index.hash_fields + index.order_fields.to_set) -
+               @conditions.each_value.map(&:field).to_set
+      return [] if select.empty?
+
+      support_queries = []
+
+      # Build a support query which gets the IDs of the entities being deleted
+      graph = @graph.dup
+      support_fields = select.select do |field|
+        field.parent == entity
+      end.to_set
+      support_fields << entity.id_field \
+        unless @conditions.each_value.map(&:field).include? entity.id_field
+      conditions = Hash[@conditions.map { |k, v| [k.dup, v.dup] }]
+
+      support_queries << build_support_query(entity, index, graph,
+                                             support_fields, conditions)
+      support_queries.compact + support_queries_for_entity(index, select)
+    end
+
+    # The condition fields are provided with the deletion
+    def given_fields
+      @conditions.each_value.map(&:field)
+    end
+  end
+end

data/lib/nose/statements/insert.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module NoSE
+  # A representation of an insert in the workload
+  class Insert < Statement
+    include StatementConditions
+    include StatementSettings
+    include StatementSupportQuery
+
+    def initialize(params, text, group: nil, label: nil)
+      super params, text, group: group, label: label
+
+      @settings = params[:settings]
+      fail InvalidStatementException, 'Must insert primary key' \
+        unless @settings.map(&:field).include?(entity.id_field)
+
+      populate_conditions params
+    end
+
+    # Build a new insert from a provided parse tree
+    # @return [Insert]
+    def self.parse(tree, params, text, group: nil, label: nil)
+      settings_from_tree tree, params
+      conditions_from_tree tree, params
+
+      Insert.new params, text, group: group, label: label
+    end
+
+    # Extract conditions from a parse tree
+    # @return [Hash]
+    def self.conditions_from_tree(tree, params)
+      connections = tree[:connections] || []
+      connections = connections.map do |connection|
+        field = params[:entity][connection[:target].to_s]
+        value = connection[:target_pk]
+
+        type = field.class.const_get 'TYPE'
+        value = field.class.value_from_string(value.to_s) \
+          unless type.nil? || value.nil?
+
+        connection.delete :value
+        Condition.new field, :'=', value
+      end
+
+      params[:conditions] = Hash[connections.map do |connection|
+        [connection.field.id, connection]
+      end]
+    end
+    private_class_method :conditions_from_tree
+
+    # Produce the SQL text corresponding to this insert
+    # @return [String]
+    def unparse
+      insert = "INSERT INTO #{entity.name} "
+      insert += settings_clause
+
+      insert << ' AND CONNECT TO ' << @conditions.values.map do |condition|
+        value = maybe_quote condition.value, condition.field
+        "#{condition.field.name}(#{value})"
+      end.join(', ') unless @conditions.empty?
+
+      insert
+    end
+
+    def ==(other)
+      other.is_a?(Insert) &&
+        @graph == other.graph &&
+        entity == other.entity &&
+        @settings == other.settings &&
+        @conditions == other.conditions
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [@graph, entity, @settings, @conditions].hash
+    end
+
+    # Determine if this insert modifies an index
+    def modifies_index?(index)
+      return true if modifies_single_entity_index?(index)
+      return false if index.graph.size == 1
+      return false unless index.graph.entities.include? entity
+
+      # Check if the index crosses all of the connection keys
+      keys = @conditions.each_value.map(&:field)
+      index.graph.keys_from_entity(entity).all? { |k| keys.include? k }
+    end
+
+    # Specifies that inserts require insertion
+    def requires_insert?(_index)
+      true
+    end
+
+    # Support queries are required for index insertion with connection
+    # to select attributes of the other related entities
+    # @return [Array<SupportQuery>]
+    def support_queries(index)
+      return [] unless modifies_index?(index) &&
+                       !modifies_single_entity_index?(index)
+
+      # Get all fields which need to be selected by support queries
+      select = index.all_fields -
+               @settings.map(&:field).to_set -
+               @conditions.each_value.map do |condition|
+                 condition.field.entity.id_field
+               end.to_set
+      return [] if select.empty?
+
+      index.graph.split(entity).map do |graph|
+        support_fields = select.select do |field|
+          graph.entities.include? field.parent
+        end.to_set
+
+        # Build conditions by traversing the foreign keys
+        conditions = @conditions.each_value.map do |c|
+          next unless graph.entities.include? c.field.entity
+
+          Condition.new c.field.entity.id_field, c.operator, c.value
+        end.compact
+        conditions = Hash[conditions.map do |condition|
+          [condition.field.id, condition]
+        end]
+
+        split_entity = split_entity graph, index.graph, entity
+        build_support_query split_entity, index, graph, support_fields,
+                            conditions
+      end.compact
+    end
+
+    # The settings fields are provided with the insertion
+    def given_fields
+      @settings.map(&:field) + @conditions.each_value.map do |condition|
+        condition.field.entity.id_field
+      end
+    end
+
+    private
+
+    # Check if the insert modifies a single entity index
+    # @return [Boolean]
+    def modifies_single_entity_index?(index)
+      !(@settings.map(&:field).to_set & index.all_fields).empty? &&
+        index.graph.size == 1 && index.graph.entities.first == entity
+    end
+  end
+end

data/lib/nose/statements/query.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module NoSE
+  # A representation of a query in the workload
+  class Query < Statement
+    include StatementConditions
+
+    attr_reader :select, :order, :limit
+
+    def initialize(params, text, group: nil, label: nil)
+      super params, text, group: group, label: label
+
+      populate_conditions params
+      @select = params[:select]
+      @order = params[:order] || []
+
+      fail InvalidStatementException, 'can\'t order by IDs' \
+        if @order.any? { |f| f.is_a? Fields::IDField }
+
+      if join_order.first != @key_path.entities.first
+        @key_path = @key_path.reverse
+      end
+
+      fail InvalidStatementException, 'must have an equality predicate' \
+        if @conditions.empty? || @conditions.values.all?(&:is_range)
+
+      @limit = params[:limit]
+    end
+
+    # Build a new query from a provided parse tree
+    # @return [Query]
+    def self.parse(tree, params, text, group: nil, label: nil)
+      conditions_from_tree tree, params
+      fields_from_tree tree, params
+      order_from_tree tree, params
+      params[:limit] = tree[:limit].to_i if tree[:limit]
+
+      new params, text, group: group, label: label
+    end
+
+    # Produce the SQL text corresponding to this query
+    # @return [String]
+    def unparse
+      field_namer = -> (f) { field_path f }
+
+      query = 'SELECT ' + @select.map(&field_namer).join(', ')
+      query << " FROM #{from_path @graph.longest_path}"
+      query << where_clause(field_namer)
+
+      query << ' ORDER BY ' << @order.map(&field_namer).join(', ') \
+        unless @order.empty?
+      query << " LIMIT #{@limit}" unless @limit.nil?
+      query << " -- #{@comment}" unless @comment.nil?
+
+      query
+    end
+
+    def ==(other)
+      other.is_a?(Query) &&
+        @graph == other.graph &&
+        @select == other.select &&
+        @conditions == other.conditions &&
+        @order == other.order &&
+        @limit == other.limit &&
+        @comment == other.comment
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [@graph, @select, @conditions, @order, @limit, @comment].hash
+    end
+
+    # The order entities should be joined according to the query graph
+    # @return [Array<Entity>]
+    def join_order
+      @graph.join_order(@eq_fields)
+    end
+
+    # Specifies that queries don't modify data
+    def read_only?
+      true
+    end
+
+    # All fields referenced anywhere in the query
+    # @return [Set<Fields::Field>]
+    def all_fields
+      (@select + @conditions.each_value.map(&:field) + @order).to_set
+    end
+
+    # Extract fields to be selected from a parse tree
+    # @return [Set<Field>]
+    def self.fields_from_tree(tree, params)
+      params[:select] = tree[:select].flat_map do |field|
+        if field.last == '*'
+          # Find the entity along the path
+          entity = params[:key_path].entities[tree[:path].index(field.first)]
+          entity.fields.values
+        else
+          field = add_field_with_prefix tree[:path], field, params
+
+          fail InvalidStatementException, 'Foreign keys cannot be selected' \
+            if field.is_a? Fields::ForeignKeyField
+
+          field
+        end
+      end.to_set
+    end
+    private_class_method :fields_from_tree
+
+    # Extract ordering fields from a parse tree
+    # @return [Array<Field>]
+    def self.order_from_tree(tree, params)
+      return params[:order] = [] if tree[:order].nil?
+
+      params[:order] = tree[:order][:fields].each_slice(2).map do |field|
+        field = field.first if field.first.is_a?(Array)
+        add_field_with_prefix tree[:path], field, params
+      end
+    end
+    private_class_method :order_from_tree
+
+    private
+
+    def field_path(field)
+      path = @graph.path_between @graph.longest_path.entities.first,
+                                 field.parent
+      path = path.drop_while { |k| @graph.longest_path.include? k } << path[-1]
+      path = KeyPath.new(path) unless path.is_a?(KeyPath)
+
+      from_path path, @graph.longest_path, field
+    end
+  end
+
+  # A query required to support an update
+  class SupportQuery < Query
+    attr_reader :statement, :index, :entity
+
+    def initialize(entity, params, text, group: nil, label: nil)
+      super params, text, group: group, label: label
+
+      @entity = entity
+    end
+
+    # Support queries must also have their statement and index checked
+    def ==(other)
+      other.is_a?(SupportQuery) && @statement == other.statement &&
+        @index == other.index && @comment == other.comment
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= Zlib.crc32_combine super, @index.hash, @index.hash_str.length
+    end
+
+    # :nocov:
+    def to_color
+      super.to_color + ' for [magenta]' + @index.key + '[/]'
+    end
+    # :nocov:
+  end
+end

data/lib/nose/statements/update.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module NoSE
+  # A representation of an update in the workload
+  class Update < Statement
+    include StatementConditions
+    include StatementSettings
+    include StatementSupportQuery
+
+    def initialize(params, text, group: nil, label: nil)
+      super params, text, group: group, label: label
+
+      populate_conditions params
+      @settings = params[:settings]
+    end
+
+    # Build a new update from a provided parse tree
+    # @return [Update]
+    def self.parse(tree, params, text, group: nil, label: nil)
+      conditions_from_tree tree, params
+      settings_from_tree tree, params
+
+      Update.new params, text, group: group, label: label
+    end
+
+    # Produce the SQL text corresponding to this update
+    # @return [String]
+    def unparse
+      update = "UPDATE #{entity.name} "
+      update += "FROM #{from_path @key_path} "
+      update << settings_clause
+      update << where_clause
+
+      update
+    end
+
+    def ==(other)
+      other.is_a?(Update) &&
+        @graph == other.graph &&
+        entity == other.entity &&
+        @settings == other.settings &&
+        @conditions == other.conditions
+    end
+    alias eql? ==
+
+    def hash
+      @hash ||= [@graph, entity, @settings, @conditions].hash
+    end
+
+    # Specifies that updates require insertion
+    def requires_insert?(_index)
+      true
+    end
+
+    # Specifies that updates require deletion
+    def requires_delete?(index)
+      !(settings.map(&:field).to_set &
+        (index.hash_fields + index.order_fields.to_set)).empty?
+    end
+
+    # Get the support queries for updating an index
+    # @return [Array<SupportQuery>]
+    def support_queries(index)
+      return [] unless modifies_index? index
+
+      # Get the updated fields and check if an update is necessary
+      set_fields = settings.map(&:field).to_set
+
+      # We only need to fetch all the fields if we're updating a key
+      updated_key = !(set_fields &
+                      (index.hash_fields + index.order_fields)).empty?
+
+      select = if updated_key
+                 index.all_fields
+               else
+                 index.hash_fields + index.order_fields
+               end - set_fields - @conditions.each_value.map(&:field)
+      return [] if select.empty?
+
+      support_queries = []
+
+      graph = @graph.dup
+      support_fields = select.select do |field|
+        field.parent == entity
+      end.to_set
+      support_fields << entity.id_field \
+        unless @conditions.each_value.map(&:field).include? entity.id_field
+
+      support_queries << build_support_query(entity, index, graph,
+                                             support_fields, conditions)
+      support_queries.compact + support_queries_for_entity(index, select)
+    end
+
+    # The condition fields are provided with the update
+    # Note that we don't include the settings here because we
+    # care about the previously existing values in the database
+    def given_fields
+      @conditions.each_value.map(&:field)
+    end
+  end
+end