praxis-mapper 3.1.1

data/lib/praxis-mapper/query/sql.rb

@@ -0,0 +1,183 @@
+require "set"
+
+module Praxis::Mapper
+  module Query
+
+    # An SQL 'SELECT' statement assembler.
+    # Assumes ISO SQL:2008 unless otherwise noted.
+    # TODO: rename to MySql or MySql5 or MySql51 or something
+    #
+    # The SQL SELECT statement returns a result set of records from one or more tables.
+    #
+    # The SELECT statement has two mandatory clauses:
+    # - SELECT specifies which columns/aliases to return.
+    # - FROM specifies which tables/views to query.
+    #
+    # The SELECT statement has many optional clauses:
+    # - WHERE specifies which rows to retrieve.
+    # - GROUP BY groups rows sharing a property so that an aggregate function can be applied to each group.
+    # - HAVING selects among the groups defined by the GROUP BY clause.
+    # - ORDER BY specifies an order in which to return the rows.
+    # - LIMIT specifies how many rows to return (non-standard).
+    #
+    # Currently only SELECT, FROM, WHERE and LIMIT has been implemented.
+    #
+    # @example "SELECT column1, column2 FROM table1 WHERE column1=value1 AND column2=value2"
+    #
+    # @see http://en.wikipedia.org/wiki/Select_(SQL)
+    class Sql < Base
+
+      # Executes a 'SELECT' statement.
+      #
+      # @param identity [Symbol|Array] a simple or composite key for this model
+      # @param values [Array] list of identifier values (ideally a sorted set)
+      # @return [Array] SQL result set
+      #
+      # @example numeric key
+      #     _multi_get(:id, [1, 2])
+      # @example string key
+      #     _multi_get(:uid, ['foo', 'bar'])
+      # @example composite key (possibly a combination of numeric and string keys)
+      #     _multi_get([:cloud_id, :account_id], [['foo1', 'bar1'], ['foo2', 'bar2']])
+      def _multi_get(identity, values)
+        dataset = connection[model.table_name.to_sym].where(identity => values)
+
+        # MySQL 5.1 won't use an index for a multi-column IN clause. Consequently, when adding
+        # multi-column IN clauses, we also add a single-column IN clause for the first column of
+        # the multi-column IN-clause. In this way, MySQL will be able to use an index for the
+        # single-column IN clause but will use the multi-column IN clauses to limit which
+        # records are returned.
+        if identity.kind_of?(Array)
+          dataset = dataset.where(identity.first => values.collect(&:first))
+        end
+
+        # preserve existing where condition from query
+        if @where
+          dataset = dataset.where(@where)
+        end
+
+        clause = dataset.opts[:where].sql_literal(dataset)
+
+        original_where = @where
+
+        self.where clause
+        _execute
+      ensure
+        @where = original_where
+      end
+
+      # Executes this SQL statement.
+      # Does not perform any validation of the statement before execution.
+      #
+      # @return [Array] result-set
+      def _execute
+        Praxis::Mapper.logger.debug "SQL:\n#{self.describe}\n"
+        self.statistics[:datastore_interactions] += 1
+        start_time = Time.now
+
+        rows = connection.fetch(self.sql).to_a
+
+        self.statistics[:datastore_interaction_time] += (Time.now - start_time)
+        return rows
+      end
+
+      # @see #sql
+      def describe
+        self.sql
+      end
+
+      # Constructs a raw SQL statement.
+      # No validation is performed here (security risk?).
+      #
+      # @param sql_text a custom SQL query
+      #
+      def raw(sql_text)
+        @raw_query = sql_text
+      end
+
+      # @return [String] raw or assembled SQL statement
+      def sql
+        if @raw_query
+          @raw_query
+        else
+          [select_clause, from_clause, where_clause, limit_clause].compact.join("\n")
+        end
+      end
+
+      # @return [String] SQL 'SELECT' clause
+      def select_clause
+        columns = []
+        if select
+          select.each do |alias_name, column_name|
+            if column_name
+              # alias_name is always a String, not a Symbol
+              columns << "#{column_name} AS #{alias_name}"
+            else
+              columns << (alias_name.is_a?(Symbol) ? alias_name.to_s : alias_name)
+            end
+          end
+        else
+          columns << '*'
+        end
+
+        "SELECT #{columns.join(', ')}"
+      end
+
+      # @return [String] SQL 'FROM' clause
+      #
+      # FIXME: use ANSI SQL double quotes instead of MySQL backticks
+      # @see http://stackoverflow.com/questions/261455/using-backticks-around-field-names
+      def from_clause
+        "FROM `#{model.table_name}`"
+      end
+
+      # @return [String] SQL 'LIMIT' clause or nil
+      #
+      # NOTE: implementation-dependent; not part of ANSI SQL
+      # TODO: replace with ISO SQL:2008 FETCH FIRST clause
+      def limit_clause
+        if self.limit
+          return "LIMIT #{self.limit}"
+        end
+      end
+
+      # Constructs the 'WHERE' clause with all active scopes (read: named conditions).
+      #
+      # @return [String] an SQL 'WHERE' clause or nil if no conditions
+      #
+      # FIXME: use ANSI SQL double quotes instead of MySQL backticks
+      # FIXME: Doesn't sanitize any values. Could be "fun" later (where fun means a horrible security hole)
+      # TODO: add per-model scopes, ie, servers might have a scope for type = "GenericServer"
+      def where_clause
+        # collects and compacts conditions as defined in identity map and model
+        conditions = identity_map.scope.collect do |name, condition|
+          # checks if this condition has been banned for this model
+          unless model.excluded_scopes.include? name
+            column, value = condition # example: "user_id", 123
+            case value
+            when Integer
+              "`#{column}`=#{value}"
+            when String
+              "`#{column}`='#{value}'"
+            when NilClass
+              "`#{column}` IS NULL"
+            else
+              raise "unknown type for scope #{name} with condition #{condition}"
+            end
+          end
+        end.compact
+
+        conditions << where if where
+
+        if conditions.any?
+          return "WHERE #{conditions.join(" AND ")}"
+        else
+          nil
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/praxis-mapper/query_statistics.rb

@@ -0,0 +1,46 @@
+module Praxis::Mapper
+
+  class QueryStatistics
+
+    def initialize(queries_by_model)
+      @queries_by_model = queries_by_model
+    end
+
+    # sums up statistics across all queries, indexed by model
+    def sum_totals_by_model
+      @sum_totals_by_model ||= begin
+        totals = Hash.new { |hash, key| hash[key] = Hash.new(0) }
+
+        @queries_by_model.each do |model, queries|
+          totals[model][:query_count] = queries.length
+          queries.each do |query|
+            query.statistics.each do |stat, value|
+              totals[model][stat] += value
+            end
+          end
+
+          totals[model][:datastore_interaction_time] = totals[model][:datastore_interaction_time]
+        end
+
+        totals
+      end
+    end
+
+    # sums up statistics across all models and queries
+    def sum_totals
+      @sum_totals ||= begin
+        totals = Hash.new(0)
+
+        sum_totals_by_model.each do |_, model_totals|
+          model_totals.each do |stat, value|
+            totals[stat] += value
+          end
+        end
+
+        totals
+      end
+    end
+
+  end
+
+end

data/lib/praxis-mapper/resource.rb

@@ -0,0 +1,226 @@
+require 'active_support/inflector'
+
+# A resource creates a data store and instantiates a list of models that it wishes to load, building up the overall set of data that it will need.
+# Once that is complete, the data set is iterated and a resultant view is generated.
+module Praxis::Mapper
+  class Resource
+    extend Finalizable
+
+    attr_accessor :record
+    
+    # TODO: also support an attribute of sorts on the versioned resource module. ie, V1::Resources.api_version.
+    #       replacing the self == Praxis::Mapper::Resource condition below.
+    def self.inherited(klass)
+      super
+
+      # It is expected that each versioned set of resources will have a common Base class.
+      # self is Praxis::Mapper::Resource only for Base resource classes which are versioned.
+      if self == Praxis::Mapper::Resource
+        klass.instance_variable_set(:@model_map, Hash.new)
+      elsif defined?(@model_map)
+        klass.instance_variable_set(:@model_map, @model_map)
+      end
+    end
+
+    def self.model_map
+      if defined? @model_map
+        return @model_map
+      else
+        return {}
+      end
+    end
+
+
+    #TODO: Take symbol/string and resolve the klass (but lazily, so we don't care about load order)
+    def self.model(klass=nil)
+      if klass
+        @model = klass
+        self.model_map[klass] = self
+      else
+        @model
+      end
+    end
+
+    def self._finalize!
+      finalize_resource_delegates
+      define_model_accessors
+      super
+    end
+
+    def self.finalize_resource_delegates
+      return unless @resource_delegates
+
+      @resource_delegates.each do |record_name, record_attributes|
+        record_attributes.each do |record_attribute|
+          self.define_resource_delegate(record_name, record_attribute)
+        end
+      end
+    end
+
+
+    def self.define_model_accessors
+      return if model.nil?
+      model.associations.each do |k,v|
+        if self.instance_methods.include? k
+          warn "WARNING: #{self.name} already has method named #{k.inspect}. Will not define accessor for resource association."
+        end
+        define_model_association_accessor(k,v)
+      end
+    end
+
+
+    def self.for_record(record)
+      return record._resource if record._resource
+
+      if resource_class_for_record = model_map[record.class]
+        return record._resource = resource_class_for_record.new(record)
+      else
+        version = self.name.split("::")[0..-2].join("::")
+        resource_name = record.class.name.split("::").last
+
+        raise "No resource class corresponding to the model class '#{record.class}' is defined. (Did you forget to define '#{version}::#{resource_name}'?)"
+      end
+    end
+
+
+    def self.wrap(records)
+      case records
+      when Model
+        return self.for_record(records)
+      when nil
+        # Return an empty set if `records` is nil
+        return []
+      else
+        return records.collect { |record| self.for_record(record) }
+      end
+    end
+
+
+    def self.get(condition)
+      record = self.model.get(condition)
+
+      self.wrap(record)
+    end
+
+    def self.all(condition={})
+      records = self.model.all(condition)
+
+      self.wrap(records)
+    end
+
+
+    def initialize(record)
+      @record = record
+    end
+
+    def respond_to_missing?(name,*)
+      @record.respond_to?(name) || super
+    end
+
+    def self.resource_delegates
+      @resource_delegates ||= {}
+    end
+
+    def self.resource_delegate(spec)
+      spec.each do |resource_name, attributes|
+        resource_delegates[resource_name] = attributes
+      end
+    end
+
+    # Defines wrapers for model associations that return Resources
+    def self.define_model_association_accessor(name, association_spec)
+      association_model = association_spec.fetch(:model)
+      association_resource_class = model_map[association_model]
+      if association_resource_class
+        module_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{name}
+            records = record.#{name}
+            return nil if records.nil?
+            @__#{name} ||= #{association_resource_class}.wrap(records)
+          end
+        RUBY
+      end
+    end
+
+    def self.define_resource_delegate(resource_name, resource_attribute)
+      related_model = model.associations[resource_name][:model]
+      related_association = related_model.associations[resource_attribute]
+
+      if related_association
+        self.define_delegation_for_related_association(resource_name, resource_attribute, related_association)
+      else
+        self.define_delegation_for_related_attribute(resource_name, resource_attribute)
+      end
+    end
+
+
+
+    def self.define_delegation_for_related_attribute(resource_name, resource_attribute)
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{resource_attribute}
+          @__#{resource_attribute} ||= if (rec = self.#{resource_name})
+            rec.#{resource_attribute}
+          end
+        end
+      RUBY
+    end
+
+    def self.define_delegation_for_related_association(resource_name, resource_attribute, related_association)
+      related_resource_class = model_map[related_association[:model]]
+      return unless related_resource_class
+
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{resource_attribute}
+          @__#{resource_attribute} ||= if (rec = self.#{resource_name})
+            if (related = rec.#{resource_attribute})
+              #{related_resource_class.name}.wrap(related)
+            end
+          end
+        end
+      RUBY
+    end
+
+    def self.define_accessor(name)
+      if name.to_s =~ /\?/
+        ivar_name = "is_#{name.to_s[0..-2]}"
+      else
+        ivar_name = "#{name}"
+      end
+
+      module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def #{name}
+          return @__#{ivar_name} if defined? @__#{ivar_name}
+          @__#{ivar_name} = record.#{name}
+        end
+      RUBY
+    end
+
+    def method_missing(name,*args)
+      if @record.respond_to?(name)
+        self.class.define_accessor(name)
+        self.send(name)
+      else
+        super
+      end
+    end
+
+    def self.member_name
+      @_member_name ||= self.name.split("::").last.underscore
+    end
+
+    def self.collection_name
+      @_collection_name ||= self.member_name.pluralize
+    end
+
+    def member_name
+      self.class.member_name
+    end
+
+    alias :type :member_name
+
+    def collection_name
+      self.class.collection_name
+    end
+
+  end
+end

data/lib/praxis-mapper/support/factory_girl.rb

@@ -0,0 +1,104 @@
+# Hackish write support for Praxis::Mapper, needed for FactoryGirl.create calls.
+# TODO: get rid of this and use current FactoryGirl features to do it the right way.
+
+module Praxis::Mapper
+  class Model
+
+    def _data
+      @data
+    end
+
+    def save!
+      @new_record = true
+      unless Praxis::Mapper::IdentityMap.current.add_records([self]).include? self
+        raise "Conflict trying to save record with type: #{self.class} and data:\n#{@data.pretty_inspect}"
+      end
+    end
+
+    alias_method :original_method_missing, :method_missing
+
+    def method_missing(name, *args)
+      if name.to_s =~ /=$/
+        name = name.to_s.sub!("=", "").to_sym
+        value = args.first
+
+        if self.class.associations.has_key?(name)
+          set_association(name, value)
+        elsif self.class.serialized_fields.has_key?(name)
+          set_serialized_field(name, value)
+        else
+          if value.kind_of?(Praxis::Mapper::Model)
+            raise "Can not set #{self.class.name}##{name} with Model instance. Are you missing an association?"
+          end
+          @data[name] = value
+        end
+      else
+        original_method_missing(name, *args)
+      end
+    end
+
+
+    def set_serialized_field(name,value)
+      @deserialized_data[name] = value
+
+      case self.class.serialized_fields[name]
+      when :json
+        @data[name] = JSON.dump(value)
+      when :yaml
+        @data[name] = YAML.dump(value)
+      else
+        @data[name] = value # dunno
+      end
+    end
+
+    def set_association(name, value)
+      spec = self.class.associations.fetch(name)
+
+      case spec[:type]
+      when :one_to_many
+        raise "can not set one_to_many associations to nil" if value.nil?
+        primary_key = @data[spec[:primary_key]]
+        setter_name = "#{spec[:key]}="
+        Array(value).each { |item| item.send(setter_name, primary_key) }
+      when :many_to_one
+        primary_key = value && value.send(spec[:primary_key])
+        @data[spec[:key]] = primary_key
+      else
+        raise "can not handle associations of type #{spec[:type]}"
+      end
+
+    end
+
+
+    def initialize(data={})
+      @data = data
+      @deserialized_data = {}
+      @new_record = false
+    end
+
+    attr_accessor :new_record
+
+  end
+
+  class IdentityMap
+
+    def persist!
+      @rows.each_with_object(Hash.new) do |(model, records), inserted|
+        next unless (table = model.table_name)
+
+        db ||= self.connection(model.repository_name)
+
+        new_records = records.select(&:new_record)
+        next if new_records.empty?
+        
+        db[table.to_sym].multi_insert new_records.collect(&:_data)
+
+        new_records.each { |rec| rec.new_record = false }
+        inserted[model] = new_records        
+      end
+    end
+
+
+  end
+
+end

data/lib/praxis-mapper/support/memory_query.rb

@@ -0,0 +1,34 @@
+# In-memory query designed for use with the MemoryRepository for specs
+
+module Praxis::Mapper
+  module Support
+    class MemoryQuery < Praxis::Mapper::Query::Base
+
+      def collection
+        connection.collection(model.table_name)
+      end
+
+      def _multi_get(key, values)
+        results = values.collect do |value|
+          connection.all(model, key =>  value)
+        end.flatten.uniq
+
+        results.select do |result|
+          where.nil? || where.all? do |k,v|
+            result[k] == v
+          end
+        end
+      end
+
+      def _execute
+        connection.all(model.table_name, self.where||{}).to_a
+      end
+
+      # Subclasses Must Implement
+      def describe
+        raise "subclass responsibility"
+      end
+
+    end
+  end
+end

data/lib/praxis-mapper/support/memory_repository.rb

@@ -0,0 +1,44 @@
+# Unoptimized, highly inefficient in-memory datastore designed for use with specs.
+
+module Praxis::Mapper
+  module Support
+    class MemoryRepository
+
+      attr_reader :collections
+
+      def initialize
+        clear!
+      end
+
+      def clear!
+        @collections = Hash.new do |hash, collection_name|
+          hash[collection_name] = Set.new
+        end
+      end
+
+      def collection(collection)
+        collection_name = if collection.respond_to?(:table_name)
+          collection.table_name.to_sym
+        else
+          collection.to_sym
+        end
+
+        @collections[collection_name]
+      end
+
+      def insert(collection, *values)
+        self.collection(collection).merge(*values)
+      end
+
+      # Retrieve all records for +collection+ matching all +conditions+.
+      def all(collection, **conditions)
+        self.collection(collection).select do |row|
+          conditions.all? do |k,v|
+            row[k] === v
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/praxis-mapper/support/schema_dumper.rb

@@ -0,0 +1,66 @@
+require 'fileutils'
+
+module Praxis::Mapper
+  module Support
+    class SchemaDumper
+
+      attr_reader :options, :repositories, :schema_root
+
+      def initialize(schema_root='.', **options)
+        @schema_root = Pathname.new(schema_root)
+
+        @options = options
+        @connection_manager = ConnectionManager.new
+
+        @repositories = Hash.new do |hash, repository_name|
+          hash[repository_name] = Set.new
+        end
+
+        setup!
+      end
+
+      def setup!
+        @connection_manager.repositories.each do |repository_name, config|
+          next unless config[:query] == Praxis::Mapper::Query::Sql
+
+          models = Praxis::Mapper::Model.descendants.
+            select { |model| model.repository_name == repository_name }.
+            select { |model| model.table_name }
+
+          models.each do |model|
+            table = model.table_name
+            repository = model.repository_name
+            self.repositories[repository] << table
+          end
+        end
+      end
+
+      def dump_all!
+        repositories.each do |repository_name, tables|
+          self.dump!(repository_name)
+        end
+      end
+
+      def dump!(repository_name)
+        connection = @connection_manager.checkout(repository_name)
+        connection.extension :schema_dumper
+
+        tables = self.repositories.fetch repository_name
+
+        FileUtils.mkdir_p(schema_root + repository_name.to_s)
+
+        tables.each do |table|
+          File.open(schema_root + repository_name.to_s + "#{table}.rb" ,"w+") do |file|
+            file.puts "Sequel.migration do"
+            file.puts "  up do"
+            file.puts connection.dump_table_schema(table).gsub(/^/o, '    ')
+            file.puts "\n"
+            file.puts "  end"
+            file.puts "end"
+          end
+        end
+      end
+    end
+
+  end
+end