simple-sql 0.4.9 → 0.4.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 272c5b7847b93e3eba9c7705e48270e5c1ccde3182d230506693e36d6f35ba9d
-  data.tar.gz: ec175e9dce36cc4869c0dbe9848285c7f279174232324e746dcace81d4ddf34d
+  metadata.gz: f24d06442bae77c5c1a51362e9ef1ac83e50034e6ce1b47b480ed8290f40e2b3
+  data.tar.gz: b2b0a88578e3c977ecf88739512d94a39bcbc8ce9eafac7225e02a925300ac9a
 SHA512:
-  metadata.gz: ec84f765746d3ffaf73b1eaf108b50f712be07e66429cbd702c19385fc008aad5eef1c7a84244790a41b710c74996ec790b17b19158a43d721c0d0ac0e3c16f6
-  data.tar.gz: 8c5c6fb5cf4c3e2e6d4d4f5400714f056c9be11727d4ddc9ef97ce8fa1da79540c9fbd11dfe90fe299da8fd87acb73416938e3d766b8ba8d02106d0b127bccda
+  metadata.gz: 2ebd2eda811287cf9dbc8ec9deefb512aa7e5b02fbeb3d8c789d254958ff2d7148c16a65fb529ef672a7626f2e8871822493bb8444e602c112070b5be66f6aa5
+  data.tar.gz: bdfff2c6a865217aad9507ba6550b8122bc9f449a7cb8a09cc393ce97d75a60eec79a21f0edef183addc73e4378656e099b2ce84871f5a7e2b9721bbff670926

data/.rubocop.yml

@@ -12,6 +12,9 @@ AllCops:
 Metrics/LineLength:
   Max: 120
 
+Metrics/MethodLength:
+  Max: 20
+
 Style/SpecialGlobalVars:
   Enabled: false
 

data/Gemfile.lock

@@ -1,7 +1,8 @@
 PATH
   remote: .
   specs:
-    simple-sql (0.4.9)
+    simple-sql (0.4.10)
+      expectation (~> 1)
       pg (~> 0.20)
       pg_array_parser (~> 0)
 
@@ -29,6 +30,7 @@ GEM
     database_cleaner (1.6.2)
     diff-lcs (1.3)
     docile (1.1.5)
+    expectation (1.1.1)
     i18n (0.9.1)
       concurrent-ruby (~> 1.0)
     json (2.1.0)

data/lib/simple/sql.rb

@@ -1,18 +1,20 @@
 require "forwardable"
 require "logger"
-
-require_relative "sql/version.rb"
-require_relative "sql/decoder.rb"
-require_relative "sql/encoder.rb"
-require_relative "sql/config.rb"
-require_relative "sql/logging.rb"
-require_relative "sql/simple_transactions.rb"
-require_relative "sql/scope.rb"
-require_relative "sql/connection_adapter.rb"
-require_relative "sql/connection.rb"
-require_relative "sql/reflection.rb"
-require_relative "sql/insert.rb"
-require_relative "sql/duplicate.rb"
+require "expectation"
+
+require_relative "sql/version"
+require_relative "sql/helpers"
+
+require_relative "sql/result"
+require_relative "sql/config"
+require_relative "sql/logging"
+require_relative "sql/simple_transactions"
+require_relative "sql/scope"
+require_relative "sql/connection_adapter"
+require_relative "sql/connection"
+require_relative "sql/reflection"
+require_relative "sql/insert"
+require_relative "sql/duplicate"
 
 module Simple
   # The Simple::SQL module

data/lib/simple/sql/config.rb

@@ -1,6 +1,5 @@
 # rubocop:disable Metrics/AbcSize
 # rubocop:disable Metrics/CyclomaticComplexity
-# rubocop:disable Metrics/MethodLength
 # rubocop:disable Metrics/PerceivedComplexity
 
 # private
@@ -9,11 +8,9 @@ module Simple::SQL::Config
 
   # parse a DATABASE_URL, return PG::Connection settings.
   def parse_url(url)
-    require "uri"
-
-    raise ArgumentError, "Invalid URL #{url.inspect}" unless url.is_a?(String)
-    raise ArgumentError, "Invalid URL #{url.inspect}" unless url =~ /^postgres(ql)?s?:\/\//
+    expect! url => /^postgres(ql)?s?:\/\//
 
+    require "uri"
     uri = URI.parse(url)
     raise ArgumentError, "Invalid URL #{url}" unless uri.hostname && uri.path
 

data/lib/simple/sql/connection_adapter.rb

@@ -1,16 +1,13 @@
 # rubocop:disable Style/IfUnlessModifier
-# rubocop:disable Metrics/AbcSize
-# rubocop:disable Metrics/MethodLength
 
 # This module implements an adapter between the Simple::SQL interface
 # (i.e. ask, all, first, transaction) and a raw connection.
 #
 # This module can be mixed onto objects that implement a raw_connection
 # method, which must return a Pg::Connection.
+
 module Simple::SQL::ConnectionAdapter
   Logging = ::Simple::SQL::Logging
-  Encoder = ::Simple::SQL::Encoder
-  Decoder = ::Simple::SQL::Decoder
   Scope   = ::Simple::SQL::Scope
 
   # execute one or more sql statements. This method does not allow to pass in
@@ -37,12 +34,29 @@ module Simple::SQL::ConnectionAdapter
   # end
 
   def all(sql, *args, into: nil, &block)
-    result = exec_logged(sql, *args)
-    result = enumerate(result, into: into, &block)
+    pg_result = exec_logged(sql, *args)
+
+    # enumerate the rows in pg_result. This returns either an Array of Hashes
+    # (if into is set), or an array of row arrays or of singular values.
+    #
+    # Even if into is set to something different than a Hash, we'll convert
+    # each row into a Hash initially, and only later convert it to the final
+    # target type (via RowConverter.convert). This is to allow to fill in
+    # more entries later on.
+    records = enumerate(pg_result, into: into)
+
+    # optimization: If we wouldn't clear here the GC would do this later.
+    pg_result.clear unless pg_result.autoclear?
+
+    # [TODO] - resolve associations. Note that this is only possible if the type
+    # is not an Array (i.e. into is nil)
+
     if sql.is_a?(Scope) && sql.paginated?
-      add_page_info(sql, result)
+      records.send(:set_pagination_info, sql)
     end
-    result
+
+    records.each(&block) if block
+    records
   end
 
   # Runs a query and returns the first result row of a query.
@@ -62,19 +76,7 @@ module Simple::SQL::ConnectionAdapter
 
   private
 
-  def add_page_info(scope, results)
-    raise ArgumentError, "expect Array but get a #{results.class.name}" unless results.is_a?(Array)
-    raise ArgumentError, "per must be > 0" unless scope.per > 0
-
-    # optimization: add empty case (page <= 1 && results.empty?)
-    if scope.page <= 1 && results.empty?
-      Scope::PageInfo.attach(results, total_count: 0, per: scope.per, page: 1)
-    else
-      sql = "SELECT COUNT(*) FROM (#{scope.order_by(nil).to_sql(pagination: false)}) simple_sql_count"
-      total_count = ask(sql, *scope.args)
-      Scope::PageInfo.attach(results, total_count: total_count, per: scope.per, page: scope.page)
-    end
-  end
+  Encoder = ::Simple::SQL::Helpers::Encoder
 
   def exec_logged(sql_or_scope, *args)
     if sql_or_scope.is_a?(Scope)
@@ -91,19 +93,20 @@ module Simple::SQL::ConnectionAdapter
     end
   end
 
-  def enumerate(result, into:, &block)
-    decoder = Decoder.new(self, result, into: into)
+  Result = ::Simple::SQL::Result
+  Decoder = ::Simple::SQL::Helpers::Decoder
 
-    if block
-      result.each_row do |row|
-        yield decoder.decode(row)
-      end
-      self
-    else
-      ary = []
-      result.each_row { |row| ary << decoder.decode(row) }
-      ary
+  def enumerate(pg_result, into:)
+    records = []
+    pg_source_oid = nil
+
+    if pg_result.ntuples > 0 && pg_result.nfields > 0
+      decoder = Decoder.new(self, pg_result, into: (into ? Hash : nil))
+      pg_result.each_row { |row| records << decoder.decode(row) }
+      pg_source_oid = pg_result.ftable(0)
     end
+
+    Result.build(records, target_type: into, pg_source_oid: pg_source_oid)
   end
 
   public

data/lib/simple/sql/helpers.rb

@@ -0,0 +1,32 @@
+module ::Simple::SQL::Helpers
+end
+
+require_relative "helpers/decoder.rb"
+require_relative "helpers/encoder.rb"
+require_relative "helpers/row_converter.rb"
+
+module ::Simple::SQL::Helpers
+  extend self
+
+  def stable_group_by_key(ary, key)
+    hsh = Hash.new { |h, k| h[k] = [] }
+    ary.each do |entity|
+      group = entity.fetch(key)
+      hsh[group] << entity
+    end
+    hsh
+  end
+
+  def pluck(ary, key)
+    ary.map { |rec| rec.fetch(key) }
+  end
+
+  def by_key(ary, key)
+    hsh = {}
+    ary.each do |entity|
+      group = entity.fetch(key)
+      hsh[group] = entity
+    end
+    hsh
+  end
+end

data/lib/simple/sql/{decoder.rb → helpers/decoder.rb}

@@ -1,18 +1,9 @@
 require "time"
 
 # private
-module Simple::SQL::Decoder
+module Simple::SQL::Helpers::Decoder
   extend self
 
-  def new(connection, result, into:)
-    if into == Hash           then HashRecord.new(connection, result)
-    elsif into == :struct     then StructRecord.new(connection, result)
-    elsif into                then Record.new(connection, result, into: into)
-    elsif result.nfields == 1 then SingleColumn.new(connection, result)
-    else                           MultiColumns.new(connection, result)
-    end
-  end
-
   def parse_timestamp(s)
     r = ::Time.parse(s)
     return r if r.utc_offset == 0
@@ -21,7 +12,6 @@ module Simple::SQL::Decoder
 
   # rubocop:disable Metrics/AbcSize
   # rubocop:disable Metrics/CyclomaticComplexity
-  # rubocop:disable Metrics/MethodLength
   def decode_value(type, s)
     case type
     when :unknown                       then s
@@ -81,68 +71,50 @@ module Simple::SQL::Decoder
   end
 end
 
-class Simple::SQL::Decoder::SingleColumn
-  def initialize(connection, result)
-    typename = connection.resolve_type(result.ftype(0), result.fmod(0))
-    @field_type = typename.to_sym
-  end
-
-  def decode(row)
-    value = row.first
-    value && Simple::SQL::Decoder.decode_value(@field_type, value)
-  end
-end
-
-class Simple::SQL::Decoder::MultiColumns
-  def initialize(connection, result)
-    @field_types = 0.upto(result.fields.length - 1).map do |idx|
-      typename = connection.resolve_type(result.ftype(idx), result.fmod(idx))
-      typename.to_sym
+module Simple::SQL::Helpers::Decoder
+  def self.new(connection, result, into:)
+    if into == Hash           then HashRecord.new(connection, result)
+    elsif result.nfields == 1 then SingleColumn.new(connection, result)
+    else                           MultiColumns.new(connection, result)
     end
   end
 
-  def decode(row)
-    @field_types.zip(row).map do |field_type, value|
-      value && Simple::SQL::Decoder.decode_value(field_type, value)
+  class SingleColumn
+    def initialize(connection, result)
+      typename = connection.resolve_type(result.ftype(0), result.fmod(0))
+      @field_type = typename.to_sym
     end
-  end
-end
 
-class Simple::SQL::Decoder::HashRecord < Simple::SQL::Decoder::MultiColumns
-  def initialize(connection, result)
-    super(connection, result)
-    @field_names = result.fields.map(&:to_sym)
-  end
-
-  def decode(row)
-    decoded_row = super(row)
-    Hash[@field_names.zip(decoded_row)]
+    def decode(row)
+      value = row.first
+      value && Simple::SQL::Helpers::Decoder.decode_value(@field_type, value)
+    end
   end
-end
 
-class Simple::SQL::Decoder::Record < Simple::SQL::Decoder::HashRecord
-  def initialize(connection, result, into:)
-    super(connection, result)
-    @into = into
-  end
+  class MultiColumns
+    def initialize(connection, result)
+      @field_types = 0.upto(result.fields.length - 1).map do |idx|
+        typename = connection.resolve_type(result.ftype(idx), result.fmod(idx))
+        typename.to_sym
+      end
+    end
 
-  def decode(row)
-    @into.new(super)
+    def decode(row)
+      @field_types.zip(row).map do |field_type, value|
+        value && Simple::SQL::Helpers::Decoder.decode_value(field_type, value)
+      end
+    end
   end
-end
-
-class Simple::SQL::Decoder::StructRecord < Simple::SQL::Decoder::MultiColumns
-  @@struct_cache = {}
-
-  def initialize(connection, result)
-    super(connection, result)
 
-    field_names = result.fields.map(&:to_sym)
-    @into = @@struct_cache[field_names] ||= Struct.new(*field_names)
-  end
+  class HashRecord < MultiColumns
+    def initialize(connection, result)
+      super(connection, result)
+      @field_names = result.fields.map(&:to_sym)
+    end
 
-  def decode(row)
-    decoded_row = super(row)
-    @into.new(*decoded_row)
+    def decode(row)
+      decoded_row = super(row)
+      Hash[@field_names.zip(decoded_row)]
+    end
   end
 end

data/lib/simple/sql/{encoder.rb → helpers/encoder.rb}

@@ -1,5 +1,5 @@
 # private
-module Simple::SQL::Encoder
+module Simple::SQL::Helpers::Encoder
   extend self
 
   def encode_args(connection, args)

data/lib/simple/sql/helpers/row_converter.rb

@@ -0,0 +1,34 @@
+module Simple::SQL::Helpers::RowConverter
+  # returns an array of converted records
+  def self.convert(records, into:)
+    hsh = records.first
+    return records unless hsh
+
+    if into == :struct
+      converter = StructConverter.for(attributes: hsh.keys)
+      records.map { |record| converter.convert(record) }
+    else
+      records.map { |record| into.new(record) }
+    end
+  end
+
+  class StructConverter # :nodoc:
+    def self.for(attributes:)
+      @cache ||= {}
+      @cache[attributes] ||= new(attributes)
+    end
+
+    private
+
+    def initialize(attributes)
+      @klass = Struct.new(*attributes)
+    end
+
+    public
+
+    def convert(hsh)
+      values = hsh.values_at(*@klass.members)
+      @klass.new(*values)
+    end
+  end
+end

data/lib/simple/sql/reflection.rb

@@ -1,5 +1,3 @@
-# rubocop:disable Metrics/MethodLength
-
 module Simple
   module SQL
     module Reflection

data/lib/simple/sql/result.rb

@@ -0,0 +1,27 @@
+require_relative "helpers"
+
+class ::Simple::SQL::Result < Array
+end
+
+require_relative "result/rows"
+require_relative "result/records"
+
+# The result of SQL.all
+#
+# This class implements the interface of a Result.
+class ::Simple::SQL::Result < Array
+  # A Result object is requested via ::Simple::SQL::Result.build, which then
+  # chooses the correct implementation, based on the <tt>target_type:</tt>
+  # parameter.
+  def self.build(records, target_type:, pg_source_oid:) # :nodoc:
+    if target_type.nil?
+      Rows.new(records)
+    else
+      Records.new(records, target_type: target_type, pg_source_oid: pg_source_oid)
+    end
+  end
+
+  attr_reader :total_count
+  attr_reader :total_pages
+  attr_reader :current_page
+end

data/lib/simple/sql/result/association_loader.rb

@@ -0,0 +1,161 @@
+# rubocop:disable Metrics/AbcSize
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/ParameterLists
+
+#
+# This module implements a pretty generic AssociationLoader.
+#
+module ::Simple::SQL::Result::AssociationLoader # :nodoc:
+  extend self
+
+  SQL = ::Simple::SQL
+  H = ::Simple::SQL::Helpers
+
+  private
+
+  # Assuming association refers to a table, what would the table name be?
+  #
+  # For example, find_associated_table(:user, schema: "foo") could return
+  # "foo.users", if such a table exists.
+  #
+  # Raises an ArgumentError if no matching table can be found.
+  def find_associated_table(association, schema:)
+    association = association.to_s
+
+    tables_in_schema = ::Simple::SQL::Reflection.table_info(schema: schema).keys
+
+    return "#{schema}.#{association}"              if tables_in_schema.include?(association)
+    return "#{schema}.#{association.singularize}"  if tables_in_schema.include?(association.singularize)
+    return "#{schema}.#{association.pluralize}"    if tables_in_schema.include?(association.pluralize)
+
+    raise ArgumentError, "Don't know how to find foreign table for association #{association.inspect}"
+  end
+
+  # Given two tables returns a structure which describes a potential association
+  # between these tables, based on foreign key descriptions found in the database.
+  #
+  # The returned struct looks something like this:
+  #
+  #   #<struct
+  #       belonging_table="public.users",
+  #       belonging_column="organization_id",
+  #       having_table="public.organizations",
+  #       having_column="id"
+  #   >
+  #
+  # Raises an ArgumentError if no association can be found between these tables.
+  #
+  def find_matching_relation(host_table, associated_table)
+    sql = <<~SQL
+      WITH foreign_keys AS(
+        SELECT
+          tc.table_schema || '.' || tc.table_name   AS belonging_table,
+          kcu.column_name                           AS belonging_column,
+          ccu.table_schema || '.' || ccu.table_name AS having_table,
+          ccu.column_name                           AS having_column
+        FROM
+          information_schema.table_constraints AS tc
+          JOIN information_schema.key_column_usage AS kcu
+            ON tc.constraint_name = kcu.constraint_name AND tc.table_schema = kcu.table_schema
+          JOIN information_schema.constraint_column_usage AS ccu
+            ON ccu.constraint_name = tc.constraint_name AND ccu.table_schema = tc.table_schema
+        WHERE constraint_type = 'FOREIGN KEY'
+      )
+      SELECT * FROM foreign_keys
+      WHERE (belonging_table=$1 AND having_table=$2)
+        OR (belonging_table=$2 AND having_table=$1)
+    SQL
+
+    relations = SQL.all(sql, host_table, associated_table, into: :struct)
+    raise ArgumentError, "Found two potential matches for the #{association.inspect} relation" if relations.length > 1
+    raise ArgumentError, "Found no potential match for the #{association.inspect} relation" if relations.empty?
+
+    relations.first
+  end
+
+  # preloads a belongs_to association.
+  def preload_belongs_to(records, relation, as:)
+    belonging_column = relation.belonging_column.to_sym
+    having_column = relation.having_column.to_sym
+
+    foreign_ids = H.pluck(records, belonging_column).uniq.compact
+
+    scope = SQL::Scope.new(table: relation.having_table)
+    scope = scope.where(having_column => foreign_ids)
+
+    recs = SQL.all(scope, into: Hash)
+    recs_by_id = H.by_key(recs, having_column)
+
+    records.each do |model|
+      model[as] = recs_by_id[model.fetch(belonging_column)]
+    end
+  end
+
+  # preloads a has_one or has_many association.
+  def preload_has_one_or_many(records, relation, as:, order_by:, limit:)
+    if limit
+      # To really make sense limit must be implemented using window
+      # functions, because one (or, at lieast, I) would expect this code
+      #
+      #   organizations = SQL.all "SELECT * FROM organizations", into: Hash
+      #   organizations.preload :users, limit: 2, order_by: "id DESC"
+      #
+      # to return up to two users **per organization**.
+      #
+      raise "Support for limit: is not implemented yet!"
+    end
+
+    belonging_column  = relation.belonging_column.to_sym
+    having_column     = relation.having_column.to_sym
+
+    host_ids  = H.pluck(records, having_column).uniq.compact
+
+    scope     = SQL::Scope.new(table: relation.belonging_table)
+    scope     = scope.where(belonging_column => host_ids)
+    scope     = scope.order_by(order_by) if order_by
+
+    recs      = SQL.all(scope, into: Hash)
+
+    if as.to_s.singularize == as.to_s
+      recs_by_id = H.by_key(recs, belonging_column) # has_one
+    else
+      recs_by_id = H.stable_group_by_key(recs, belonging_column) # has_many
+    end
+
+    records.each do |model|
+      model[as] = recs_by_id[model.fetch(having_column)]
+    end
+  end
+
+  public
+
+  # Preloads a association into the records array.
+  #
+  # Parameters:
+  #
+  # - records: an Array of hashes.
+  # - association: the name of the association
+  # - host_table: the name of the table \a records has been loaded from.
+  # - schema: the schema name in the database.
+  # - as: the name to sue for the association. Defaults to +association+
+  def preload(records, association, host_table:, schema:, as:, order_by:, limit:)
+    return records if records.empty?
+
+    expect! records.first => Hash
+
+    as = association if as.nil?
+    fq_host_table = "#{schema}.#{host_table}"
+
+    associated_table = find_associated_table(association, schema: schema)
+    relation         = find_matching_relation(fq_host_table, associated_table)
+
+    if fq_host_table == relation.belonging_table
+      if order_by || limit
+        raise ArgumentError, "#{association.inspect} is a singular association, w/o support for order_by: and limit:"
+      end
+      preload_belongs_to records, relation, as: as
+    else
+      preload_has_one_or_many records, relation, as: as, order_by: order_by, limit: limit
+    end
+  end
+end