simple-sql 0.3.5 → 0.3.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b08f546478e2802e501c22208f65ed6314caf518
-  data.tar.gz: d6cb02a8df19e49a1c089dfc2582deb00d43aa2d
+  metadata.gz: 337ccb887e118d5d1220c0f3d169e7b5818d44d8
+  data.tar.gz: 3fc46560189f1cea77c830ed598b17ac2654eada
 SHA512:
-  metadata.gz: f17b07ed8d17ede670b0df1f488ef01e642af28ecbd1f1e4e96d00b54993b14f50626593dc018baf7d9ed93bc7f68b2231b385ae292c723164347baa8b806005
-  data.tar.gz: 33f1f2b749f2cad395d38eae9ee6700c53d1eac9b3037a8ec8e7e35fbbc4f9255711e0af0f12091015dfa32202f1f23e63bd8e38602c3f479d78420119bcd195
+  metadata.gz: 3f46132db9ebbaed89c5724e4688e1aabf16f951119fc4b9fc159435dffdfd0e270aed8b913c479b31f9eaf7a5b843744d71285016bf010ac7e937e6cdb77ee6
+  data.tar.gz: 7206041f5d04a31f9abfcbde92b61b8bf56d8e45b48547e62ef9a5915eeef7923787ae354684b6a7db419132d434ff4acb1f2fcc8ba267640a992a3c1a97aec4

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    simple-sql (0.3.5)
+    simple-sql (0.3.6)
       pg (~> 0.20)
       pg_array_parser (~> 0)
 

data/README.md

@@ -99,20 +99,28 @@ Simple::SQL.ask "SELECT id FROM users WHERE email=$1", "foo@local"         # ret
 Simple::SQL.ask "SELECT id, email FROM users WHERE email=$?", "foo@local"  # returns an array `[ <id>, <email> ]` (or `nil`)
 ```
 
-### Simple::SQL.record/Simple::SQL.records:  fetching hashes
+### Simple::SQL.ask/Simple::SQL.all:  fetching hashes
 
 While `ask` and `all` convert each result row into an Array, sometimes you might want
-to use Hashes or similar objects instead. To do so, you use the record and records functions:
+to use Hashes or similar objects instead. To do so, you use the `into:` keyword argument:
 
     # returns a single Hash (or nil)
-    Simple::SQL.record("SELECT id FROM users") 
+    Simple::SQL.ask("SELECT id FROM users", into: Hash) 
 
 If you want the returned record to be in a structure which is not a Hash, you can use
 the `into: <klass>` option. The following would return an array of up to two `OpenStruct`
 objects:
 
     sql = "SELECT id, email FROM users WHERE id = ANY($1) LIMIT 1", 
-    Simple::SQL.records sql, [1,2,3], into: OpenStruct
+    Simple::SQL.all sql, [1,2,3], into: OpenStruct
+
+This supports all target types that take a contructor which acceps Hash arguments.
+
+It also supports a :struct argument, in which case simple-sql creates uses a Struct-class.
+Struct classes are reused when possible, and are maintained by Simple::SQL. 
+
+    sql = "SELECT id, email FROM users WHERE id = ANY($1) LIMIT 1", 
+    Simple::SQL.all sql, [1,2,3], into: :struct
 
 ### Transaction support
 
@@ -161,3 +169,5 @@ strings containing the "`" character.
 1. `createdb simple-sql-test`
 2. `bundle install`
 3. `bin/rspec`
+
+## Test again

data/Rakefile

@@ -1,6 +1,11 @@
 Dir.glob("tasks/*.rake").each { |r| import r }
 
-task :default do
+
+task "test:prepare_db" do
+  sh "createdb simple-sql-test 2>&1 > /dev/null || true"
+end
+
+task default: "test:prepare_db" do
   sh "rspec"
   sh "USE_ACTIVE_RECORD=1 rspec"
   sh "rubocop -D"

data/config/database.yml

@@ -2,7 +2,7 @@ defaults: &defaults
   adapter: postgresql
   encoding: utf8
   host: '127.0.0.1'
-  username: postgres
+  # username: postgres
   pool: 5
   timeout: 5000
 

data/lib/simple/sql.rb

@@ -11,6 +11,8 @@ require_relative "sql/reflection.rb"
 require_relative "sql/insert.rb"
 require_relative "sql/duplicate.rb"
 
+# rubocop:disable Metrics/MethodLength
+
 module Simple
   # The Simple::SQL module
   module SQL
@@ -56,11 +58,9 @@ module Simple
     #   # do something
     # end
 
-    def all(sql, *args, &block)
-      result  = exec_logged(sql, *args)
-      decoder = Decoder.new(result)
-
-      enumerate(result, decoder, block)
+    def all(sql, *args, into: nil, &block)
+      result = exec_logged(sql, *args)
+      enumerate(result, into: into, &block)
     end
 
     # Runs a query and returns the first result row of a query.
@@ -71,38 +71,23 @@ module Simple
     #   returns a number (or +nil+)
     # - <tt>Simple::SQL.ask "SELECT id, email FROM users WHERE email=$?", "foo@local"</tt>
     #   returns an array <tt>[ <id>, <email> ]</tt> (or +nil+)
-    def ask(sql, *args)
+    def ask(sql, *args, into: nil)
       catch(:ok) do
-        all(sql, *args) { |row| throw :ok, row }
+        all(sql, *args, into: into) { |row| throw :ok, row }
         nil
       end
     end
 
-    # Runs a query, with optional arguments, and returns the result as an
-    # array of Hashes.
-    #
-    # Example:
-    #
-    # - <tt>Simple::SQL.records("SELECT id, email FROM users")</tt> returns an array of
-    #         hashes { id: id, email: email }
-    #
-    # Simple::SQL.records "SELECT id, email FROM users" do |record|
-    #   # do something
-    # end
-
+    # [Deprecated] Runs a query, with optional arguments, and returns the
+    # result as an array of Hashes.
     def records(sql, *args, into: Hash, &block)
-      result  = exec_logged(sql, *args)
-      decoder = Decoder.new(result, :record, into: into)
-
-      enumerate(result, decoder, block)
+      all sql, *args, into: into, &block
     end
 
-    # Runs a query and returns the first result row of a query as a Hash.
+    # [Deprecated] Runs a query and returns the first result row of a query
+    # as a Hash.
     def record(sql, *args, into: Hash)
-      catch(:ok) do
-        records(sql, *args, into: into) { |row| throw :ok, row }
-        nil
-      end
+      ask sql, *args, into: into
     end
 
     extend Forwardable
@@ -116,10 +101,12 @@ module Simple
       end
     end
 
-    def enumerate(result, decoder, block)
+    def enumerate(result, into:, &block)
+      decoder = Decoder.new(result, into: into)
+
       if block
         result.each_row do |row|
-          block.call decoder.decode(row)
+          yield decoder.decode(row)
         end
         self
       else

data/lib/simple/sql/config.rb

@@ -40,9 +40,14 @@ module Simple::SQL::Config
     abc = read_database_yml
     username, password, host, port, database = abc.values_at "username", "password", "host", "port", "database"
 
+    # raise username.inspect
     username_and_password = [username, password].compact.join(":")
     host_and_port = [host, port].compact.join(":")
-    "postgres://#{username_and_password}@#{host_and_port}/#{database}"
+    if username_and_password != ""
+      "postgres://#{username_and_password}@#{host_and_port}/#{database}"
+    else
+      "postgres://#{host_and_port}/#{database}"
+    end
   end
 
   def read_database_yml

data/lib/simple/sql/decoder.rb

@@ -4,10 +4,12 @@ require "time"
 module Simple::SQL::Decoder
   extend self
 
-  def new(result, mode = nil, into: nil)
-    if mode == :record        then Record.new(result, into: into)
+  def new(result, into:)
+    if into == Hash           then HashRecord.new(result)
+    elsif into == :struct     then StructRecord.new(result)
+    elsif into                then Record.new(result, into: into)
     elsif result.nfields == 1 then SingleColumn.new(result)
-    else                      MultiColumns.new(result)
+    else                           MultiColumns.new(result)
     end
   end
 
@@ -79,6 +81,18 @@ module Simple::SQL::Decoder
   end
 end
 
+class Simple::SQL::Decoder::SingleColumn
+  def initialize(result)
+    typename = ::Simple::SQL.send(: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(result)
     @field_types = 0.upto(result.fields.length - 1).map do |idx|
@@ -94,34 +108,41 @@ class Simple::SQL::Decoder::MultiColumns
   end
 end
 
-class Simple::SQL::Decoder::SingleColumn < Simple::SQL::Decoder::MultiColumns
+class Simple::SQL::Decoder::HashRecord < Simple::SQL::Decoder::MultiColumns
   def initialize(result)
-    super
-    @field_type = @field_types.first
+    super(result)
+    @field_names = result.fields.map(&:to_sym)
   end
 
   def decode(row)
-    value = row.first
-    value && Simple::SQL::Decoder.decode_value(@field_type, value)
+    decoded_row = super(row)
+    Hash[@field_names.zip(decoded_row)]
   end
 end
 
-class Simple::SQL::Decoder::Record < Simple::SQL::Decoder::MultiColumns
+class Simple::SQL::Decoder::Record < Simple::SQL::Decoder::HashRecord
   def initialize(result, into:)
     super(result)
-
     @into = into
-    @result = result
-    @field_names = @result.fields.map(&:to_sym)
+  end
+
+  def decode(row)
+    @into.new(super)
+  end
+end
+
+class Simple::SQL::Decoder::StructRecord < Simple::SQL::Decoder::MultiColumns
+  @@struct_cache = {}
+
+  def initialize(result)
+    super(result)
+
+    field_names = result.fields.map(&:to_sym)
+    @into = @@struct_cache[field_names] ||= Struct.new(*field_names)
   end
 
   def decode(row)
     decoded_row = super(row)
-    hsh = Hash[@field_names.zip(decoded_row)]
-    if @into && @into != Hash
-      @into.new(hsh)
-    else
-      hsh
-    end
+    @into.new(*decoded_row)
   end
 end

data/lib/simple/sql/insert.rb

@@ -1,22 +1,27 @@
 # rubocop:disable Style/ClassVars
 # rubocop:disable Metrics/AbcSize
-
+# rubocop:disable Metrics/LineLength
 module Simple
   module SQL
-    def insert(table, records)
+    #
+    # - table_name - the name of the table
+    # - records - a single hash of attributes or an array of hashes of attributes
+    # - on_conflict - uses a postgres ON CONFLICT clause to ignore insert conflicts if true
+    #
+    def insert(table, records, on_conflict: nil)
       if records.is_a?(Hash)
-        insert_many(table, [records]).first
+        insert_many(table, [records], on_conflict).first
       else
-        insert_many table, records
+        insert_many(table, records, on_conflict)
       end
     end
 
     private
 
-    def insert_many(table, records)
+    def insert_many(table, records, on_conflict)
       return [] if records.empty?
 
-      inserter = Inserter.create(table_name: table.to_s, columns: records.first.keys)
+      inserter = Inserter.create(table_name: table.to_s, columns: records.first.keys, on_conflict: on_conflict)
       inserter.insert(records: records)
     end
 
@@ -25,15 +30,15 @@ module Simple
 
       @@inserters = {}
 
-      def self.create(table_name:, columns:)
-        @@inserters[[table_name, columns]] ||= new(table_name: table_name, columns: columns)
+      def self.create(table_name:, columns:, on_conflict:)
+        @@inserters[[table_name, columns, on_conflict]] ||= new(table_name: table_name, columns: columns, on_conflict: on_conflict)
       end
 
       #
       # - table_name - the name of the table
       # - columns - name of columns, as Array[String] or Array[Symbol]
       #
-      def initialize(table_name:, columns:)
+      def initialize(table_name:, columns:, on_conflict:)
         @columns = columns
 
         cols = []
@@ -47,7 +52,19 @@ module Simple
         cols += timestamp_columns
         vals += timestamp_columns.map { "now()" }
 
-        @sql = "INSERT INTO #{table_name} (#{cols.join(',')}) VALUES(#{vals.join(',')}) RETURNING id"
+        @sql = "INSERT INTO #{table_name} (#{cols.join(',')}) VALUES(#{vals.join(',')}) #{confict_handling(on_conflict)} RETURNING id"
+      end
+
+      CONFICT_HANDLING = {
+        nil      => "",
+        :nothing => "ON CONFLICT DO NOTHING",
+        :ignore  => "ON CONFLICT DO NOTHING"
+      }
+
+      def confict_handling(on_conflict)
+        CONFICT_HANDLING.fetch(on_conflict) do
+          raise(ArgumentError, "Invalid on_conflict value #{on_conflict.inspect}")
+        end
       end
 
       def insert(records:)

data/lib/simple/sql/version.rb

@@ -1,5 +1,5 @@
 module Simple
   module SQL
-    VERSION = "0.3.5"
+    VERSION = "0.3.6"
   end
 end

data/spec/simple/sql_all_into_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "Simple::SQL.all into: argument" do
+  let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
+
+  it "calls the database" do
+    r = SQL.all("SELECT * FROM users", into: Hash)
+    expect(r).to be_a(Array)
+    expect(r.length).to eq(USER_COUNT)
+    expect(r.map(&:class).uniq).to eq([Hash])
+  end
+
+  it "returns an empty array when there is no match" do
+    r = SQL.all("SELECT * FROM users WHERE FALSE", into: Hash)
+    expect(r).to eq([])
+  end
+end

data/spec/simple/sql_ask_into_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe "Simple::SQL.ask into: argument" do
+  let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
+
+  it "calls the database" do
+    r = SQL.ask("SELECT COUNT(*) AS count FROM users", into: Hash)
+    expect(r).to eq({count: 2}) 
+  end
+
+  it "returns nil when there is no match" do
+    r = SQL.ask("SELECT * FROM users WHERE FALSE", into: Hash)
+    expect(r).to be_nil
+  end
+
+  it "returns a OpenStruct with into: OpenStruct" do
+    r = SQL.ask("SELECT COUNT(*) AS count FROM users", into: OpenStruct)
+    expect(r).to be_a(OpenStruct)
+    expect(r).to eq(OpenStruct.new(count: 2))
+  end
+
+  it "supports the into: option even with parameters" do
+    r = SQL.ask("SELECT $1::integer AS count FROM users", 2, into: OpenStruct)
+    expect(r).to be_a(OpenStruct)
+    expect(r).to eq(OpenStruct.new(count: 2))
+  end
+end

data/spec/simple/sql_ask_into_struct_spec.rb

@@ -0,0 +1,17 @@
+require "spec_helper"
+
+describe "Simple::SQL.ask into: :struct" do
+  let!(:users) { 1.upto(USER_COUNT).map { create(:user) } }
+
+  it "calls the database" do
+    r = SQL.ask("SELECT COUNT(*) AS count FROM users", into: :struct)
+    expect(r.count).to eq(2)
+    expect(r.class.members).to eq([:count])
+  end
+
+  it "reuses the struct" do
+    r1 = SQL.ask("SELECT COUNT(*) AS count FROM users", into: :struct)
+    r2 = SQL.ask("SELECT COUNT(*) AS count FROM users", into: :struct)
+    expect(r1.class.object_id).to eq(r2.class.object_id)
+  end
+end

data/spec/simple/sql_config_spec.rb

@@ -3,7 +3,7 @@ require "spec_helper"
 describe "Simple::SQL::Config" do
   describe ".determine_url" do
     it "reads config/database.yml" do
-      expect(SQL::Config.determine_url).to eq "postgres://postgres@127.0.0.1/simple-sql-test"
+      expect(SQL::Config.determine_url).to eq "postgres://127.0.0.1/simple-sql-test"
     end
   end
 

data/spec/simple/sql_insert_spec.rb

@@ -16,5 +16,40 @@ describe "Simple::SQL.insert" do
     expect(user.last_name).to eq("bar")
     expect(user.created_at).to be_a(Time)
   end
-end
 
+  describe 'confict handling' do
+    let!(:existing_user_id) { SQL.insert :users, {first_name: "foo", last_name: "bar"} }
+    let!(:total_users) { SQL.ask "SELECT count(*) FROM users" }
+    
+    context 'when called with on_conflict: :ignore' do
+      it 'ignores the conflict and does not create a user' do
+        # Try to insert using an existing primary key ...
+        result = SQL.insert :users, {id: existing_user_id, first_name: "foo", last_name: "bar"}, on_conflict: :ignore
+        expect(result).to be_nil
+
+        expect(SQL.ask("SELECT count(*) FROM users")).to eq(total_users)
+      end
+    end
+    
+    context 'when called with on_conflict: :nothing' do
+      it 'ignores the conflict and does not create a user' do
+        # Try to insert using an existing primary key ...
+        result = SQL.insert :users, {id: existing_user_id, first_name: "foo", last_name: "bar"}, on_conflict: :nothing
+        expect(result).to be_nil
+
+        expect(SQL.ask("SELECT count(*) FROM users")).to eq(total_users)
+      end
+    end
+
+    context 'when called with on_conflict: nil' do
+      it 'raises an error and does not create a user' do
+        # Try to insert using an existing primary key ...
+        expect {
+          SQL.insert :users, {id: existing_user_id, first_name: "foo", last_name: "bar"}, on_conflict: nil
+        }.to raise_error(PG::UniqueViolation)
+
+        expect(SQL.ask("SELECT count(*) FROM users")).to eq(total_users)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: simple-sql
 version: !ruby/object:Gem::Version
-  version: 0.3.5
+  version: 0.3.6
 platform: ruby
 authors:
 - radiospiel
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-08 00:00:00.000000000 Z
+date: 2018-04-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg_array_parser
@@ -180,6 +180,9 @@ files:
 - log/.gitkeep
 - simple-sql.gemspec
 - spec/simple/sql/version_spec.rb
+- spec/simple/sql_all_into_spec.rb
+- spec/simple/sql_ask_into_spec.rb
+- spec/simple/sql_ask_into_struct_spec.rb
 - spec/simple/sql_ask_spec.rb
 - spec/simple/sql_config_spec.rb
 - spec/simple/sql_conversion_spec.rb
@@ -220,6 +223,9 @@ specification_version: 4
 summary: SQL with a simple interface
 test_files:
 - spec/simple/sql/version_spec.rb
+- spec/simple/sql_all_into_spec.rb
+- spec/simple/sql_ask_into_spec.rb
+- spec/simple/sql_ask_into_struct_spec.rb
 - spec/simple/sql_ask_spec.rb
 - spec/simple/sql_config_spec.rb
 - spec/simple/sql_conversion_spec.rb