michaelmior / NoSE

      include Comparable

      def initialize(statement, index, trees, update_steps, cost_model)

        @statement = statement

        @index = index

        @trees = trees

        @query_plans = nil # these will be set later when we pick indexes

        update_steps.each { |step| step.calculate_cost cost_model }

        @update_steps = update_steps

        @cost_model = cost_model

        # Update with fields specified in the settings and conditions

        # (rewrite from foreign keys to IDs if needed)

        @update_fields = if statement.is_a?(Connection) ||

                            statement.is_a?(Delete)

                           []

                         else

                           statement.settings.map(&:field)

                         end

        @update_fields += statement.conditions.each_value.map(&:field)

        @update_fields.map! do |field|

          field.is_a?(Fields::ForeignKeyField) ? field.entity.id_field : field

        end

      end

      # The weight of this query for a given workload

      # @return [Fixnum]

    # A planner for update statements in the workload

    class UpdatePlanner

      def initialize(model, trees, cost_model, by_id_graph = false)

        @logger = Logging.logger['nose::update_planner']

        @model = model

        @cost_model = cost_model

        @by_id_graph = by_id_graph

        # Remove anything not a support query then group by statement and index

        @query_plans = trees.select do |tree|

          tree.query.is_a? SupportQuery

        end

        @query_plans = @query_plans.group_by { |tree| tree.query.statement }

        @query_plans.each do |plan_stmt, plan_trees|

          @query_plans[plan_stmt] = plan_trees.group_by do |tree|

            index = tree.query.index

            index = index.to_id_path if @by_id_path

            index

          end

        end

      end

      # Find the necessary update plans for a given set of indexes

      # @return [Array<UpdatePlan>]