sequel-vertica 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 224357ab7df2bccbf853e1a34c7bc5f6b1c89ebb
-  data.tar.gz: 2480bc67b31e77b8291d2fa3198f8c0bbe1bc074
+  metadata.gz: ce96b243358a0d65c1f5006e89a999af0570b724
+  data.tar.gz: 47759596fb816ecb87a37fc12088f942cf6cdd56
 SHA512:
-  metadata.gz: 2e5f8fd7028e06c8d0e7e5d78eb60a237f490adff29fea5dff4c42e718f614e50a666c83d02c8bb049130c60b62a16784e12cbfbc694427663e1bea0b5d742ab
-  data.tar.gz: 672e91d04cd326dfa20f961f268a675381565a44a6cc44ea6b260c83983924143fe3b7b37ec3207f47c277809a3e5618e9118b77c9e17913d616aaf35482bcc0
+  metadata.gz: 514ad89b3cdfd3594ae26498c8056a4da13b434fcdad5780277353a294246dc3edf1886d80deeabe40f8904c259a966a226652216548f87cfca2681fe88ddb35
+  data.tar.gz: 767a0c5e52ad27832eb35c508589d279838c3bc6756a907b5a4959d13b03eb54f7199f0d3db15de9fae856b919ba8f6270bf7703b743d8d4214d1cf83685470e

data/.gitignore

@@ -17,3 +17,4 @@ test/version_tmp
 tmp
 spec/spec_config.rb
 .rbenv-version
+vendor/

data/CHANGELOG

@@ -1,3 +1,14 @@
+0.2.1
+
+* Update sequel depenency
+* Add support for read_timeout option
+
+0.2.0
+
+* Update vertica gem depenency
+* Update sequel gem depenency
+* Enable CI
+
 0.1.0
 
 * Supports Vertica 6.0

data/lib/sequel-vertica/version.rb

@@ -1,5 +1,5 @@
 module Sequel
   module Vertica
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

data/lib/sequel/adapters/vertica.rb

@@ -34,7 +34,8 @@ module Sequel
           :port => opts[:port],
           :schema => opts[:schema],
           :database => opts[:database],
-          :ssl => opts[:ssl] 
+          :read_timeout => opts[:read_timeout].nil? ? nil : opts[:read_timeout].to_i,
+          :ssl => opts[:ssl]
         )
       end
 

data/sequel-vertica.gemspec

@@ -15,15 +15,15 @@ Gem::Specification.new do |gem|
   gem.requirements  = "Vertica version 6.0 or higher"
   gem.required_ruby_version = '>= 1.9.3'
 
-  gem.add_runtime_dependency "sequel", "~> 4.9.0"
-  gem.add_runtime_dependency "vertica", "~> 0.11.0"
+  gem.add_runtime_dependency "sequel", "~> 4.14"
+  gem.add_runtime_dependency "vertica", "~> 0.11.1"
 
   gem.add_development_dependency "rake", ">= 10"
-  gem.add_development_dependency "rspec" , "~> 2.14"
+  gem.add_development_dependency "rspec" , "~> 3.1"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   gem.files         = `git ls-files`.split("\n")
   gem.test_files    = `git ls-files -- {spec}/*`.split("\n")
-  
+
   gem.require_paths = ["lib"]
 end

data/spec/adapters/vertica_spec.rb

@@ -28,6 +28,15 @@ VERTICA_DB.create_table! :test4 do
   bytea :value
 end
 
+describe "A vertica sequel connection" do
+  specify "should set a read timeout" do
+    conn = Sequel.connect("#{ENV['SEQUEL_VERTICA_SPEC_DB']||VERTICA_URL}?read_timeout=1000")
+    conn.synchronize do |raw_conn|
+      expect(raw_conn.options[:read_timeout]).to eq(1000)
+    end
+  end
+end
+
 describe "A Vertica database" do
 
   before do
@@ -35,14 +44,14 @@ describe "A Vertica database" do
   end
 
   specify "should correctly parse the schema" do
-    @db.schema(:test3, :reload=>true).should == [
+    expect(@db.schema(:test3, :reload=>true)).to eq([
       [:value, {:type=>:integer, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"int", :primary_key=>false}],
       [:time, {:type=>:datetime, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"timestamp", :primary_key=>false}]
-    ]
-    @db.schema(:test4, :reload=>true).should == [
-      [:name, {:type=>:string, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"varchar(20)", :primary_key=>false}],
-      [:value, {:type=>:blob, :allow_null=>true, :default=>nil, :ruby_default=>nil, :db_type=>"varbinary(80)", :primary_key=>false}]
-    ]
+    ])
+    expect(@db.schema(:test4, :reload=>true)).to eq([
+      [:name, {:allow_null=>true, :default=>nil, :db_type=>"varchar(20)", :type=>:string, :primary_key=>false, :ruby_default=>nil, :max_length=>20}],
+      [:value, {:allow_null=>true, :default=>nil, :db_type=>"varbinary(80)", :type=>:blob, :primary_key=>false, :ruby_default=>nil}]
+    ])
   end
 
   specify "should create an auto incrementing primary key" do
@@ -50,7 +59,7 @@ describe "A Vertica database" do
       primary_key :id
       integer :value
     end
-    @db[<<-SQL].first[:COUNT].should == 1
+    expect(@db[<<-SQL].first[:COUNT]).to eq(1)
       SELECT COUNT(1) FROM v_catalog.sequences WHERE identity_table_name='auto_inc_test'
     SQL
   end
@@ -64,63 +73,77 @@ describe "A vertica dataset" do
   end
 
   specify "should quote columns and tables using double quotes if quoting identifiers" do
-    @d.select(:name).sql.should == \
+    expect(@d.select(:name).sql).to eq( \
       'SELECT "name" FROM "test"'
+    )
 
-    @d.select(Sequel.lit('COUNT(*)')).sql.should == \
+    expect(@d.select(Sequel.lit('COUNT(*)')).sql).to eq( \
       'SELECT COUNT(*) FROM "test"'
+    )
 
-    @d.select(:max.sql_function(:value)).sql.should == \
+    expect(@d.select(:max.sql_function(:value)).sql).to eq( \
       'SELECT max("value") FROM "test"'
+    )
 
-    @d.select(:NOW.sql_function).sql.should == \
+    expect(@d.select(:NOW.sql_function).sql).to eq( \
     'SELECT NOW() FROM "test"'
+    )
 
-    @d.select(:max.sql_function(:items__value)).sql.should == \
+    expect(@d.select(:max.sql_function(:items__value)).sql).to eq( \
       'SELECT max("items"."value") FROM "test"'
+    )
 
-    @d.order(:name.desc).sql.should == \
+    expect(@d.order(:name.desc).sql).to eq( \
       'SELECT * FROM "test" ORDER BY "name" DESC'
+    )
 
-    @d.select(Sequel.lit('test.name AS item_name')).sql.should == \
+    expect(@d.select(Sequel.lit('test.name AS item_name')).sql).to eq( \
       'SELECT test.name AS item_name FROM "test"'
+    )
 
-    @d.select(Sequel.lit('"name"')).sql.should == \
+    expect(@d.select(Sequel.lit('"name"')).sql).to eq( \
       'SELECT "name" FROM "test"'
+    )
 
-    @d.select(Sequel.lit('max(test."name") AS "max_name"')).sql.should == \
+    expect(@d.select(Sequel.lit('max(test."name") AS "max_name"')).sql).to eq( \
       'SELECT max(test."name") AS "max_name" FROM "test"'
+    )
 
-    @d.insert_sql(:x => :y).should =~ \
+    expect(@d.insert_sql(:x => :y)).to match( \
       /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
+    )
 
   end
 
   specify "should quote fields correctly when reversing the order if quoting identifiers" do
-    @d.reverse_order(:name).sql.should == \
+    expect(@d.reverse_order(:name).sql).to eq( \
       'SELECT * FROM "test" ORDER BY "name" DESC'
+    )
 
-    @d.reverse_order(:name.desc).sql.should == \
+    expect(@d.reverse_order(:name.desc).sql).to eq( \
       'SELECT * FROM "test" ORDER BY "name" ASC'
+    )
 
-    @d.reverse_order(:name, :test.desc).sql.should == \
+    expect(@d.reverse_order(:name, :test.desc).sql).to eq( \
       'SELECT * FROM "test" ORDER BY "name" DESC, "test" ASC'
+    )
 
-    @d.reverse_order(:name.desc, :test).sql.should == \
+    expect(@d.reverse_order(:name.desc, :test).sql).to eq( \
       'SELECT * FROM "test" ORDER BY "name" ASC, "test" DESC'
+    )
   end
 
   specify "should support regexps" do
     @d << {:name => 'abc', :value => 1}
     @d << {:name => 'bcd', :value => 2}
 
-    @d.filter(:name => /bc/).count.should == 2
-    @d.filter(:name => /^bc/).count.should == 1
+    expect(@d.filter(:name => /bc/).count).to eq(2)
+    expect(@d.filter(:name => /^bc/).count).to eq(1)
   end
 
   specify "#columns should return the correct column names" do
-    @d.columns!.should == [:name, :value]
-    @d.select(:name).columns!.should == [:name]
+    expect(@d.columns!).to eq([:name, :value])
+    expect(@d.select(:name).columns!).to eq([:name])
   end
 end
 
@@ -139,25 +162,25 @@ describe "A Vertica dataset with a timestamp field" do
     t = Time.now
     @d << {:value=>1, :time=>t}
     t2 = @d[:value =>1][:time]
-    @d.literal(t2).should == @d.literal(t)
-    t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
-    (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).should == t.usec
+    expect(@d.literal(t2)).to eq(@d.literal(t))
+    expect(t2.strftime('%Y-%m-%d %H:%M:%S')).to eq(t.strftime('%Y-%m-%d %H:%M:%S'))
+    expect(t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).to eq(t.usec)
   end
 
   cspecify "should store milliseconds in time fields for DateTime objects", :do, :swift do
     t = DateTime.now
     @d << {:value=>1, :time=>t}
     t2 = @d[:value =>1][:time]
-    @d.literal(t2).should == @d.literal(t)
-    t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
-    (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).should == t.strftime('%N').to_i/1000
+    expect(@d.literal(t2)).to eq(@d.literal(t))
+    expect(t2.strftime('%Y-%m-%d %H:%M:%S')).to eq(t.strftime('%Y-%m-%d %H:%M:%S'))
+    expect(t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).to eq(t.strftime('%N').to_i/1000)
   end
 
   describe "Verticas's EXPLAIN and EXPLAIN LOCAL" do
     specify "should not raise errors" do
       @d = VERTICA_DB[:test3]
-      proc{@d.explain}.should_not raise_error
-      proc{@d.explain(:local => true)}.should_not raise_error
+      expect{@d.explain}.not_to raise_error
+      expect{@d.explain(:local => true)}.not_to raise_error
     end
   end
 
@@ -171,14 +194,14 @@ describe "A Vertica database" do
 
   specify "should support ALTER TABLE DROP COLUMN" do
     @db.create_table!(:test3) { varchar :name; integer :value }
-    @db[:test3].columns.should == [:name, :value]
+    expect(@db[:test3].columns).to eq([:name, :value])
     @db.drop_column :test3, :value
-    @db[:test3].columns.should == [:name]
+    expect(@db[:test3].columns).to eq([:name])
   end
 
   specify "It does not support ALTER TABLE ALTER COLUMN TYPE" do
     @db.create_table!(:test4) { varchar :name; integer :value }
-    proc{ @db.set_column_type :test4, :value, :float }.should raise_error(Sequel::DatabaseError,
+    expect{ @db.set_column_type :test4, :value, :float }.to raise_error(Sequel::DatabaseError,
                                                     /Syntax error at or near "TYPE"/)
   end
 
@@ -186,23 +209,23 @@ describe "A Vertica database" do
     @db.create_table!(:test5) { varchar :name; integer :value }
     @db[:test5] << {:name => 'mmm', :value => 111}
     @db.rename_column :test5, :value, :val
-    @db[:test5].columns.should == [:name, :val]
-    @db[:test5].first[:val].should == 111
+    expect(@db[:test5].columns).to eq([:name, :val])
+    expect(@db[:test5].first[:val]).to eq(111)
   end
 
   specify "should support add column operations" do
     @db.create_table!(:test2) { varchar :name; integer :value }
-    @db[:test2].columns.should == [:name, :value]
+    expect(@db[:test2].columns).to eq([:name, :value])
 
     @db.add_column :test2, :xyz, :varchar, :default => '000'
-    @db[:test2].columns.should == [:name, :value, :xyz]
+    expect(@db[:test2].columns).to eq([:name, :value, :xyz])
     @db[:test2] << {:name => 'mmm', :value => 111}
-    @db[:test2].first[:xyz].should == '000'
+    expect(@db[:test2].first[:xyz]).to eq('000')
   end
 
   specify "#locks should be a dataset returning database locks " do
-    @db.locks.should be_a_kind_of(Sequel::Dataset)
-    @db.locks.all.should be_a_kind_of(Array)
+    expect(@db.locks).to be_a_kind_of(Sequel::Dataset)
+    expect(@db.locks.all).to be_a_kind_of(Array)
   end
 end
 
@@ -219,14 +242,14 @@ describe "Vertica::Dataset#insert" do
   end
 
   specify "should work with static SQL" do
-    @ds.with_sql('INSERT INTO test5 (value) VALUES (10)').insert.should == 1
-    @db['INSERT INTO test5 (value) VALUES (20)'].insert.should == 1
-    @ds.all.should == [{:value=>10}, {:value=>20}]
+    expect(@ds.with_sql('INSERT INTO test5 (value) VALUES (10)').insert).to eq(1)
+    expect(@db['INSERT INTO test5 (value) VALUES (20)'].insert).to eq(1)
+    expect(@ds.all).to include({:value=>10}, {:value=>20})
   end
 
   specify "should insert correctly if using a column array and a value array" do
-    @ds.insert([:value], [10]).should == 1
-    @ds.all.should == [{:value=>10}]
+    expect(@ds.insert([:value], [10])).to eq(1)
+    expect(@ds.all).to eq([{:value=>10}])
   end
 end
 
@@ -243,37 +266,37 @@ describe "Vertica::Database schema qualified tables" do
 
   specify "should be able to create, drop, select and insert into tables in a given schema" do
     VERTICA_DB.create_table(:schema_test__table_in_schema_test){integer :i}
-    VERTICA_DB[:schema_test__table_in_schema_test].first.should == nil
-    VERTICA_DB[:schema_test__table_in_schema_test].insert(:i=>1).should == 1
-    VERTICA_DB[:schema_test__table_in_schema_test].first.should == {:i=>1}
-    VERTICA_DB.from(Sequel.lit('schema_test.table_in_schema_test')).first.should == {:i=>1}
+    expect(VERTICA_DB[:schema_test__table_in_schema_test].first).to eq(nil)
+    expect(VERTICA_DB[:schema_test__table_in_schema_test].insert(:i=>1)).to eq(1)
+    expect(VERTICA_DB[:schema_test__table_in_schema_test].first).to eq({:i=>1})
+    expect(VERTICA_DB.from(Sequel.lit('schema_test.table_in_schema_test')).first).to eq({:i=>1})
     VERTICA_DB.drop_table(:schema_test__table_in_schema_test)
     VERTICA_DB.create_table(:table_in_schema_test.qualify(:schema_test)){integer :i}
-    VERTICA_DB[:schema_test__table_in_schema_test].first.should == nil
-    VERTICA_DB.from(Sequel.lit('schema_test.table_in_schema_test')).first.should == nil
+    expect(VERTICA_DB[:schema_test__table_in_schema_test].first).to eq(nil)
+    expect(VERTICA_DB.from(Sequel.lit('schema_test.table_in_schema_test')).first).to eq(nil)
     VERTICA_DB.drop_table(:table_in_schema_test.qualify(:schema_test))
   end
 
   specify "#tables should not include tables in a default non-public schema" do
     VERTICA_DB.create_table(:schema_test__table_in_schema_test){integer :i}
-    VERTICA_DB.tables.should include(:table_in_schema_test)
-    VERTICA_DB.tables.should_not include(:tables)
-    VERTICA_DB.tables.should_not include(:columns)
-    VERTICA_DB.tables.should_not include(:locks)
-    VERTICA_DB.tables.should_not include(:domain_udt_usage)
+    expect(VERTICA_DB.tables).to include(:table_in_schema_test)
+    expect(VERTICA_DB.tables).not_to include(:tables)
+    expect(VERTICA_DB.tables).not_to include(:columns)
+    expect(VERTICA_DB.tables).not_to include(:locks)
+    expect(VERTICA_DB.tables).not_to include(:domain_udt_usage)
   end
 
   specify "#tables should return tables in the schema provided by the :schema argument" do
     VERTICA_DB.create_table(:schema_test__table_in_schema_test){integer :i}
-    VERTICA_DB.tables(:schema=>:schema_test).should == [:table_in_schema_test]
+    expect(VERTICA_DB.tables(:schema=>:schema_test)).to eq([:table_in_schema_test])
   end
 
   specify "#schema should not include columns from tables in a default non-public schema" do
     VERTICA_DB.create_table(:schema_test__domains){integer :i}
     sch = VERTICA_DB.schema(:domains)
     cs = sch.map{|x| x.first}
-    cs.should include(:i)
-    cs.should_not include(:data_type)
+    expect(cs).to include(:i)
+    expect(cs).not_to include(:data_type)
   end
 
   specify "#schema should only include columns from the table in the given :schema argument" do
@@ -281,14 +304,14 @@ describe "Vertica::Database schema qualified tables" do
     VERTICA_DB.create_table(:schema_test__domains){integer :i}
     sch = VERTICA_DB.schema(:domains, :schema=>:schema_test)
     cs = sch.map{|x| x.first}
-    cs.should include(:i)
-    cs.should_not include(:d)
+    expect(cs).to include(:i)
+    expect(cs).not_to include(:d)
     VERTICA_DB.drop_table(:domains)
   end
 
   specify "#table_exists? should see if the table is in a given schema" do
     VERTICA_DB.create_table(:schema_test__schema_test){integer :i}
-    VERTICA_DB.table_exists?(:schema_test__schema_test).should == true
+    expect(VERTICA_DB.table_exists?(:schema_test__schema_test)).to eq(true)
   end
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel-vertica
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Camilo Lopez
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-14 00:00:00.000000000 Z
+date: 2014-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 4.9.0
+        version: '4.14'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 4.9.0
+        version: '4.14'
 - !ruby/object:Gem::Dependency
   name: vertica
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.11.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: 0.11.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -58,14 +58,14 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.14'
+        version: '3.1'
 description: Sequel adapter for the Vertica database
 email:
 - camilo@camilolopez.com
@@ -113,4 +113,3 @@ signing_key:
 specification_version: 4
 summary: Sequel adapter for the Vertica database largely based on the PostgreSQL adapter
 test_files: []
-has_rdoc: