friendly_postgres 0.4.3

data/lib/friendly/document_table.rb

@@ -0,0 +1,56 @@
+require 'friendly/table'
+
+module Friendly
+  class DocumentTable < Table
+    attr_reader :klass, :translator
+
+    def initialize(klass, datastore=Friendly.datastore, translator=Translator.new)
+      super(datastore)
+      @klass      = klass
+      @translator = translator
+    end
+
+    def table_name
+      klass.table_name
+    end
+
+    def satisfies?(query)
+      query.conditions.keys == [:id] && !query.order
+    end
+
+    def create(document)
+      record = translator.to_record(document)
+      datastore.insert(document, record)
+      update_document(document, record)
+    end
+
+    def update(document)
+      record = translator.to_record(document)
+      datastore.update(document, document.id, record)
+      update_document(document, record)
+    end
+
+    def destroy(document)
+      datastore.delete(document, document.id)
+    end
+
+    def first(query)
+      record = datastore.first(klass, query)
+      record && to_object(record)
+    end
+
+    def all(query)
+      datastore.all(klass, query).map { |r| to_object(r) }
+    end
+
+    protected
+      def update_document(document, record)
+        attrs = record.reject { |k,v| k == :attributes }.merge(:new_record => false)
+        document.attributes = attrs
+      end
+
+      def to_object(record)
+        translator.to_object(klass, record)
+      end
+  end
+end

data/lib/friendly/index.rb

@@ -0,0 +1,73 @@
+require 'friendly/table'
+
+module Friendly
+  class Index < Table
+    attr_reader :klass, :fields, :datastore
+
+    def initialize(klass, fields, datastore = Friendly.datastore)
+      @klass     = klass
+      @fields    = fields
+      @datastore = datastore
+    end
+
+    def table_name
+      ["index", klass.table_name, "on", fields.join("_and_")].join("_")
+    end
+
+    def satisfies?(query)
+      exact_match?(query) || valid_partial_match?(query)
+    end
+
+    def first(query)
+      row = datastore.first(self, query)
+      row && klass.first(:id => row[:id])
+    end
+
+    def all(query)
+      ids = datastore.all(self, query).map { |row| row[:id] }
+      klass.all(:id => ids, :preserve_order! => !query.order.nil?)
+    end
+
+    def count(query)
+      datastore.count(self, query)
+    end
+
+    def create(document)
+      datastore.insert(self, record(document))
+    end
+
+    def update(document)
+      datastore.update(self, document.id, record(document))
+    end
+
+    def destroy(document)
+      datastore.delete(self, document.id)
+    end
+
+    protected
+      def exact_match?(query)
+        query.conditions.keys.map { |f| f.to_s }.sort == 
+          fields.map { |f| f.to_s }.sort && 
+            valid_order?(query.order)
+      end
+
+      def valid_partial_match?(query)
+        condition_fields = query.conditions.keys
+        sorted = condition_fields.sort { |a,b| field_index(a) <=> field_index(b) }
+        sorted << query.order.expression if query.order
+        sorted.zip(fields).all? { |a,b| a == b }
+      end
+
+      def valid_order?(order)
+        order.nil? || order.expression == fields.last
+      end
+
+      def field_index(attr)
+        fields.index(attr) || 0
+      end
+
+      def record(document)
+        Hash[*(fields + [:id]).map { |f| [f, document.send(f)] }.flatten]
+      end
+  end
+end

data/lib/friendly/memcached.rb

@@ -0,0 +1,48 @@
+module Friendly
+  class Memcached
+    attr_reader :cache
+
+    def initialize(cache)
+      @cache = cache
+    end
+
+    def set(key, value)
+      @cache.set(key, value)
+    end
+
+    def get(key)
+      @cache.get(key)
+    rescue ::Memcached::NotFound
+      if block_given?
+        miss(key) { yield }
+      end
+    end
+
+    def multiget(keys)
+      return {} if keys.empty?
+
+      hits         = @cache.get(keys)
+      missing_keys = keys - hits.keys
+
+      if !missing_keys.empty? && block_given?
+        missing_keys.each do |missing_key|
+          hits.merge!(missing_key => miss(missing_key) { yield(missing_key) })
+        end
+      end
+
+      hits
+    end
+
+    def delete(key)
+      cache.delete(key)
+    rescue ::Memcached::NotFound
+    end
+
+    protected
+      def miss(key)
+        value = yield
+        @cache.set(key, value)
+        value
+      end
+  end
+end

data/lib/friendly/named_scope.rb

@@ -0,0 +1,17 @@
+require 'friendly/scope'
+
+module Friendly
+  class NamedScope
+    attr_reader :klass, :parameters, :scope_klass
+
+    def initialize(klass, parameters, scope_klass = Scope)
+      @klass       = klass
+      @parameters  = parameters
+      @scope_klass = scope_klass
+    end
+
+    def scope
+      @scope_klass.new(@klass, @parameters)
+    end
+  end
+end

data/lib/friendly/newrelic.rb

@@ -0,0 +1,6 @@
+Friendly::Memcached.class_eval do
+  add_method_tracer :miss, "Friendly::Memcached/miss"
+  add_method_tracer :get, "Friendly::Memcached/get"
+  add_method_tracer :multiget, "Friendly::Memcached/multiget"
+end
+

data/lib/friendly/query.rb

@@ -0,0 +1,42 @@
+module Friendly
+  class Query
+    attr_reader :conditions, :limit, :order, 
+                :preserve_order, :offset, :uuid_klass,
+                :page, :per_page
+
+    def initialize(parameters, uuid_klass = UUID)
+      @uuid_klass = uuid_klass
+      @conditions = parameters.reject { |k,v| k.to_s =~ /!$/ }
+      @page       = (parameters[:page!] || 1).to_i
+      
+      [:per_page!, :limit!, :offset!, :order!, :preserve_order!].each do |p|
+        instance_variable_set("@#{p.to_s.gsub(/!/, '')}", parameters[p])
+      end
+
+      handle_pagination if per_page
+      convert_ids_to_uuids
+    end
+
+    def preserve_order?
+      preserve_order
+    end
+
+    def offset?
+      offset
+    end
+
+    protected
+      def convert_ids_to_uuids
+        if conditions[:id] && conditions[:id].is_a?(Array)
+          conditions[:id] = conditions[:id].map { |i| uuid_klass.new(i) }
+        elsif conditions[:id]
+          conditions[:id] = uuid_klass.new(conditions[:id])
+        end
+      end
+
+      def handle_pagination
+        @limit  = per_page
+        @offset = (page - 1) * per_page
+      end
+  end
+end

data/lib/friendly/scope.rb

@@ -0,0 +1,100 @@
+module Friendly
+  class Scope
+    attr_reader :klass, :parameters
+
+    def initialize(klass, parameters)
+      @klass      = klass
+      @parameters = parameters
+    end
+
+    # Fetch all documents at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def all(extra_parameters = {})
+      klass.all(params(extra_parameters))
+    end
+
+    # Fetch the first document at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def first(extra_parameters = {})
+      klass.first(params(extra_parameters))
+    end
+
+    # Paginate the documents at this scope.
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    # @return WillPaginate::Collection
+    #
+    def paginate(extra_parameters = {})
+      klass.paginate(params(extra_parameters))
+    end
+
+    # Build an object at this scope.
+    #
+    #   e.g.
+    #     Post.scope(:name => "James").build.name # => "James"
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def build(extra_parameters = {})
+      klass.new(params_without_modifiers(extra_parameters))
+    end
+
+    # Create an object at this scope.
+    #
+    #   e.g.
+    #     @post = Post.scope(:name => "James").create
+    #     @post.new_record? # => false
+    #     @post.name # => "James"
+    #
+    # @param [Hash] extra_parameters add extra parameters to this query.
+    #
+    def create(extra_parameters = {})
+      klass.create(params_without_modifiers(extra_parameters))
+    end
+
+    # Override #respond_to? so that we can return true when it's another named_scope.
+    #
+    # @override
+    #
+    def respond_to?(method_name, include_private = false)
+      klass.has_named_scope?(method_name) || super
+    end
+
+    # Use method_missing to respond to other named scopes on klass.
+    # 
+    # @override
+    #
+    def method_missing(method_name, *args, &block)
+      respond_to?(method_name) ? chain_with(method_name) : super
+    end
+
+    # Chain with another one of klass's named_scopes.
+    #
+    # @param [Symbol] scope_name The name of the scope to chain with.
+    #
+    def chain_with(scope_name)
+      self + klass.send(scope_name)
+    end
+
+    # Create a new Scope that is the combination of self and other, where other takes priority
+    #
+    # @param [Friendly::Scope] other The scope to merge with.
+    #
+    def +(other_scope)
+      self.class.new(klass, parameters.merge(other_scope.parameters))
+    end
+
+    protected
+      def params(extra)
+        parameters.merge(extra)
+      end
+
+      def params_without_modifiers(extra)
+        params(extra).reject { |k,v| k.to_s =~ /!$/ }
+      end
+  end
+end

data/lib/friendly/scope_proxy.rb

@@ -0,0 +1,45 @@
+require 'friendly/named_scope'
+
+module Friendly
+  class ScopeProxy
+    attr_reader :klass, :scope_klass, :scopes
+
+    def initialize(klass, scope_klass = Scope)
+      @klass       = klass
+      @scope_klass = scope_klass
+      @scopes      = {}
+    end
+
+    def add_named(name, parameters)
+      scopes[name] = parameters
+      add_scope_method_to_klass(name)
+    end
+
+    def get(name)
+      scopes[name]
+    end
+
+    def get_instance(name)
+      scope_klass.new(klass, get(name))
+    end
+
+    def ad_hoc(parameters)
+      scope_klass.new(klass, parameters)
+    end
+
+    def has_named_scope?(name)
+      scopes.has_key?(name)
+    end
+
+    protected
+      def add_scope_method_to_klass(scope_name)
+        klass.class_eval do
+          eval <<-__END__
+            def self.#{scope_name}
+              scope_proxy.get_instance(:#{scope_name})
+            end
+          __END__
+        end
+      end
+  end
+end

data/lib/friendly/sequel_monkey_patches.rb

@@ -0,0 +1,34 @@
+require 'sequel'
+
+# Out of the box, Sequel uses IS TRUE/FALSE for boolean parameters
+# This prevents MySQL from using indexes.
+#
+# This patch fixes that.
+module Sequel
+  module SQL
+    class BooleanExpression
+      def self.from_value_pairs(pairs, op=:AND, negate=false)
+        pairs = pairs.collect do |l,r|
+          ce = case r
+          when Range
+            new(:AND, new(:>=, l, r.begin), new(r.exclude_end? ? :< : :<=, l, r.end))
+          when Array, ::Sequel::Dataset, SQLArray
+            new(:IN, l, r)
+          when NegativeBooleanConstant
+            new(:"IS NOT", l, r.constant)
+          when BooleanConstant
+            new(:IS, l, r.constant)
+          when NilClass
+            new(:IS, l, r)
+          when Regexp
+            StringExpression.like(l, r)
+          else
+            new(:'=', l, r)
+          end
+          negate ? invert(ce) : ce
+        end
+        pairs.length == 1 ? pairs.at(0) : new(op, *pairs)
+      end
+    end
+  end
+end

data/lib/friendly/storage.rb

@@ -0,0 +1,31 @@
+module Friendly
+  class Storage
+    def create(document)
+      raise NotImplementedError, "#{self.class.name}#create is not implemented."
+    end
+
+    def update(document)
+      raise NotImplementedError, "#{self.class.name}#update is not implemented."
+    end
+
+    def destroy(document)
+      raise NotImplementedError, "#{self.class.name}#destroy is not implemented."
+    end
+
+    def first(conditions)
+      raise NotImplementedError, "#{self.class.name}#first is not implemented."
+    end
+
+    def all(conditions)
+      raise NotImplementedError, "#{self.class.name}#all is not implemented."
+    end
+
+    def count(query)
+      raise NotImplementedError, "#{self.class.name}#count is not implemented."
+    end
+
+    def satisfies?(conditions)
+      raise NotImplementedError, "#{self.class.name}#satisfies? is not implemented."
+    end
+  end
+end