nexia-sequel-vertica 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b5e872968a5395400e5af3cb43624b5bb449baad
+  data.tar.gz: 0456c06d3b644c55ef5a5f25cee332df42c13f50
+SHA512:
+  metadata.gz: 039af7ecb0fd587dc47010631d8c0bc8697cf0c64db3c1aa4f108b493f011ea0f5f4f32936f33516797d193c173309a9cf30abe1b5e8a86ea7f646562bc92821
+  data.tar.gz: 974da5305b4dac6a5975643198d1da336df67cf1ca54e77bbf4d6a5754121577344e8815da4b0c0505c3bbe508580ed91bf60cea4d287d7d33861c0850974e26

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+spec/spec_config.rb
+.rbenv-version
+vendor/

data/.rspec

@@ -0,0 +1 @@
+--color --format doc

data/.travis.yml

@@ -0,0 +1,19 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.1
+
+before_install:
+  - sudo wget -nv https://s3.amazonaws.com/circle-support-bucket/vertica_7.0.1-0_amd64.deb
+  - sudo dpkg -i vertica_7.0.1-0_amd64.deb
+  - sudo /opt/vertica/sbin/install_vertica --failure-threshold HALT --accept-eula --dba-user-password dbadmin --license CE -s localhost
+  - sudo -u dbadmin /opt/vertica/bin/adminTools -t create_db --database ci -s localhost -p dbadmin
+  # - sudo -u dbadmin openssl req -x509 -nodes -days 365 -newkey rsa:2048 -keyout /home/dbadmin/ci/v_ci_node0001_catalog/server.key -out /home/dbadmin/ci/v_ci_node0001_catalog/server.crt -batch
+  # - sudo -u dbadmin chmod 600 /home/dbadmin/ci/v_ci_node0001_catalog/server.key /home/dbadmin/ci/v_ci_node0001_catalog/server.crt
+  # - sudo -u dbadmin /opt/vertica/bin/adminTools -t stop_db --database ci -p dbadmin
+  # - sudo -u dbadmin sh -c 'echo "EnableSSL = 1" > /home/dbadmin/ci/v_ci_node0001_catalog/vertica.conf'
+  # - sudo -u dbadmin /opt/vertica/bin/adminTools -t start_db --database ci -p dbadmin
+
+before_script:
+  - cp ./spec/spec_config.example.rb ./spec/spec_config.rb

data/CHANGELOG

@@ -0,0 +1,11 @@
+0.2.1
+
+* Update sequel version
+
+0.2.0
+
+* ???
+
+0.1.0
+
+* Supports Vertica 6.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in sequel-vertica.gemspec
+gemspec

data/README.md

@@ -0,0 +1,16 @@
+# Sequel-vertica [![Build Status](https://travis-ci.org/camilo/sequel-vertica.svg?branch=travis)](https://travis-ci.org/camilo/sequel-vertica)
+
+A third party adapter to use Vertica through sequel, most of the actual work is
+done by sequel and the vertica gem.
+
+## Usage
+
+The usage is straight forward as any other Sequel adapter, just make sure to
+require sequel and the sequel-vertica gem.
+
+```ruby 
+require 'sequel'
+require 'sequel-vertica'
+
+$DB = Sequel.connect('vertica://user:pw@host/database_name')
+```

data/Rakefile

@@ -0,0 +1,13 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new #do |t|
+ #t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+#end

data/lib/sequel-vertica.rb

@@ -0,0 +1,4 @@
+require 'sequel-vertica/version'
+require 'sequel/adapters/vertica'
+
+Sequel::Database::ADAPTERS << 'vertica'

data/lib/sequel-vertica/version.rb

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

data/lib/sequel/adapters/vertica.rb

@@ -0,0 +1,156 @@
+require 'vertica'
+
+module Sequel
+  extension :core_extensions
+  module Vertica
+
+    class CreateTableGenerator < Sequel::Schema::CreateTableGenerator
+      def primary_key(name, *args)
+        super
+
+        if @primary_key[:auto_increment]
+          @primary_key.delete(:auto_increment)
+          @primary_key[:type] = Vertica::Database::AUTO_INCREMENT
+        end
+
+        @primary_key
+      end
+    end
+
+    class Database < Sequel::Database
+
+      ::Vertica::Connection.send(:alias_method, :execute, :query)
+
+      PK_NAME = 'C_PRIMARY'
+      AUTO_INCREMENT = 'AUTO_INCREMENT'
+      set_adapter_scheme :vertica
+
+      def connect(server)
+        opts = server_opts(server)
+        ::Vertica::Connection.new(
+          :host => opts[:host],
+          :user => opts[:user],
+          :password => opts[:password],
+          :port => opts[:port],
+          :schema => opts[:schema],
+          :database => opts[:database],
+          :read_timeout => opts[:read_timeout].nil? ? nil : opts[:read_timeout].to_i,
+          :ssl => opts[:ssl]
+        )
+      end
+
+      def execute(sql, opts = {}, &block)
+        res = nil
+        synchronize(opts[:server]) do |conn|
+          res = log_yield(sql) { conn.query(sql) }
+          res.each(&block)
+        end
+        res
+      rescue ::Vertica::Error => e
+        raise_error(e)
+      end
+
+      def execute_insert(sql, opts = {}, &block)
+        result = execute(sql, opts, &block)
+        result.first[:OUTPUT]
+      end
+
+      alias_method :execute_dui, :execute
+
+      def supports_create_table_if_not_exists?
+        true
+      end
+
+      def supports_drop_table_if_exists?
+        true
+      end
+
+      def supports_transaction_isolation_levels?
+        true
+      end
+
+      def identifier_input_method_default
+        nil
+      end
+
+      def identifier_output_method_default
+        nil
+      end
+
+      def locks
+        dataset.from(:v_monitor__locks)
+      end
+
+      def auto_increment_sql
+        AUTO_INCREMENT
+      end
+
+      def create_table_generator_class
+        Vertica::CreateTableGenerator
+      end
+
+      def tables(options = {})
+        schema = options[:schema]
+        filter = {}
+        filter[:table_schema] = schema.to_s if schema
+
+        dataset.select(:table_name).
+          from(:v_catalog__tables).
+          filter(filter).
+          to_a.
+          map { |h| h[:table_name].to_sym }
+      end
+
+      def schema_parse_table(table_name, options = {})
+        schema = options[:schema]
+
+        selector = [:column_name, :constraint_name, :is_nullable.as(:allow_null),
+                    (:column_default).as(:default), (:data_type).as(:db_type)]
+        filter = { :columns__table_name => table_name }
+        filter[:columns__table_schema] = schema.to_s if schema
+
+        dataset = metadata_dataset.
+          select(*selector).
+          filter(filter).
+          from(:v_catalog__columns).
+          left_outer_join(:v_catalog__table_constraints, :table_id => :table_id)
+
+        dataset.map do |row|
+          row[:default] = nil if blank_object?(row[:default])
+          row[:type] = schema_column_type(row[:db_type])
+          row[:primary_key] = row.delete(:constraint_name) == PK_NAME
+          [row.delete(:column_name).to_sym, row]
+        end
+      end
+    end
+
+    class Dataset < Sequel::Dataset
+      Database::DatasetClass = self
+      EXPLAIN = 'EXPLAIN '
+      EXPLAIN_LOCAL = 'EXPLAIN LOCAL '
+      QUERY_PLAN = 'QUERY PLAN'
+
+      def columns
+        return @columns if @columns
+        ds = unfiltered.unordered.clone(:distinct => nil, :limit => 0, :offset => nil)
+        res = @db.execute(ds.select_sql)
+        @columns = res.columns.map { |c| c.name }
+        @columns
+      end
+
+      def fetch_rows(sql)
+        execute(sql) do |row|
+          yield row
+        end
+      end
+
+      def explain(opts={})
+        execute((opts[:local] ? EXPLAIN_LOCAL : EXPLAIN) + select_sql).map { |k, v| k == QUERY_PLAN }.join("\$")
+      end
+
+      def supports_regexp?
+        true
+      end
+    end
+  end
+end

data/sequel-vertica.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sequel-vertica/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "nexia-sequel-vertica"
+  gem.version       = Sequel::Vertica::VERSION
+
+  gem.authors       = ["Camilo Lopez"]
+  gem.email         = ["camilo@camilolopez.com"]
+  gem.description   = %q{Sequel adapter for the Vertica database}
+  gem.summary       = %q{Sequel adapter for the Vertica database largely based on the PostgreSQL adapter}
+  gem.homepage      = "https://github.com/camilo/sequel-vertica"
+  gem.license     = "MIT"
+
+  gem.requirements  = "Vertica version 6.0 or higher"
+  gem.required_ruby_version = '>= 1.9.3'
+
+  gem.add_runtime_dependency "sequel", "~> 4.14"
+  gem.add_runtime_dependency "vertica", "~> 0.11"
+
+  gem.add_development_dependency "rake", "~> 10.3"
+  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

@@ -0,0 +1,317 @@
+require 'spec_helper'
+
+unless defined?(VERTICA_DB)
+  VERTICA_URL = 'vertica://vertica:vertica@localhost:5432/reality_spec' unless defined? VERTICA_URL
+  VERTICA_DB = Sequel.connect(ENV['SEQUEL_VERTICA_SPEC_DB']||VERTICA_URL)
+end
+INTEGRATION_DB = VERTICA_DB unless defined?(INTEGRATION_DB)
+
+def VERTICA_DB.sqls
+  (@sqls ||= [])
+end
+
+
+VERTICA_DB.create_table! :test do
+  varchar :name
+  integer :value
+end
+VERTICA_DB.create_table! :test2 do
+  varchar :name
+  integer :value
+end
+VERTICA_DB.create_table! :test3 do
+  integer :value
+  timestamp :time
+end
+VERTICA_DB.create_table! :test4 do
+  varchar :name, :size => 20
+  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
+    @db = VERTICA_DB
+  end
+
+  specify "should correctly parse the schema" do
+    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}]
+    ])
+    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
+    @db.create_table! :auto_inc_test do
+      primary_key :id
+      integer :value
+    end
+    expect(@db[<<-SQL].first[:COUNT]).to eq(1)
+      SELECT COUNT(1) FROM v_catalog.sequences WHERE identity_table_name='auto_inc_test'
+    SQL
+  end
+
+end
+
+describe "A vertica dataset" do
+  before do
+    @d = VERTICA_DB[:test]
+    @d.delete if @d.count > 0 # Vertica will throw an error if the table has just been created and does not have a super projection yet.
+  end
+
+  specify "should quote columns and tables using double quotes if quoting identifiers" do
+    expect(@d.select(:name).sql).to eq( \
+      'SELECT "name" FROM "test"'
+    )
+
+    expect(@d.select(Sequel.lit('COUNT(*)')).sql).to eq( \
+      'SELECT COUNT(*) FROM "test"'
+    )
+
+    expect(@d.select(:max.sql_function(:value)).sql).to eq( \
+      'SELECT max("value") FROM "test"'
+    )
+
+    expect(@d.select(:NOW.sql_function).sql).to eq( \
+    'SELECT NOW() FROM "test"'
+    )
+
+    expect(@d.select(:max.sql_function(:items__value)).sql).to eq( \
+      'SELECT max("items"."value") FROM "test"'
+    )
+
+    expect(@d.order(:name.desc).sql).to eq( \
+      'SELECT * FROM "test" ORDER BY "name" DESC'
+    )
+
+    expect(@d.select(Sequel.lit('test.name AS item_name')).sql).to eq( \
+      'SELECT test.name AS item_name FROM "test"'
+    )
+
+    expect(@d.select(Sequel.lit('"name"')).sql).to eq( \
+      'SELECT "name" FROM "test"'
+    )
+
+    expect(@d.select(Sequel.lit('max(test."name") AS "max_name"')).sql).to eq( \
+      'SELECT max(test."name") AS "max_name" FROM "test"'
+    )
+
+    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
+    expect(@d.reverse_order(:name).sql).to eq( \
+      'SELECT * FROM "test" ORDER BY "name" DESC'
+    )
+
+    expect(@d.reverse_order(:name.desc).sql).to eq( \
+      'SELECT * FROM "test" ORDER BY "name" ASC'
+    )
+
+    expect(@d.reverse_order(:name, :test.desc).sql).to eq( \
+      'SELECT * FROM "test" ORDER BY "name" DESC, "test" ASC'
+    )
+
+    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}
+
+    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
+    expect(@d.columns!).to eq([:name, :value])
+    expect(@d.select(:name).columns!).to eq([:name])
+  end
+end
+
+
+describe "A Vertica dataset with a timestamp field" do
+  before do
+    @db = VERTICA_DB
+    @d = @db[:test3]
+    @d.delete if @d.count > 0 # Vertica will throw an error if the table has just been created and does not have a super projection yet.
+  end
+  after do
+    @db.convert_infinite_timestamps = false if @db.adapter_scheme == :postgres
+  end
+
+  cspecify "should store milliseconds in time fields for Time objects", :do, :swift do
+    t = Time.now
+    @d << {:value=>1, :time=>t}
+    t2 = @d[:value =>1][:time]
+    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]
+    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]
+      expect{@d.explain}.not_to raise_error
+      expect{@d.explain(:local => true)}.not_to raise_error
+    end
+  end
+
+end
+
+
+describe "A Vertica database" do
+  before do
+    @db = VERTICA_DB
+  end
+
+  specify "should support ALTER TABLE DROP COLUMN" do
+    @db.create_table!(:test3) { varchar :name; integer :value }
+    expect(@db[:test3].columns).to eq([:name, :value])
+    @db.drop_column :test3, :value
+    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 }
+    expect{ @db.set_column_type :test4, :value, :float }.to raise_error(Sequel::DatabaseError,
+                                                    /Syntax error at or near "TYPE"/)
+  end
+
+  specify "should support rename column operations" do
+    @db.create_table!(:test5) { varchar :name; integer :value }
+    @db[:test5] << {:name => 'mmm', :value => 111}
+    @db.rename_column :test5, :value, :val
+    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 }
+    expect(@db[:test2].columns).to eq([:name, :value])
+
+    @db.add_column :test2, :xyz, :varchar, :default => '000'
+    expect(@db[:test2].columns).to eq([:name, :value, :xyz])
+    @db[:test2] << {:name => 'mmm', :value => 111}
+    expect(@db[:test2].first[:xyz]).to eq('000')
+  end
+
+  specify "#locks should be a dataset returning database locks " do
+    expect(@db.locks).to be_a_kind_of(Sequel::Dataset)
+    expect(@db.locks.all).to be_a_kind_of(Array)
+  end
+end
+
+describe "Vertica::Dataset#insert" do
+  before do
+    @db = VERTICA_DB
+    @db.create_table!(:test5){ :xid; Integer :value}
+    @db.sqls.clear
+    @ds = @db[:test5]
+  end
+
+  after do
+    @db.drop_table?(:test5)
+  end
+
+  specify "should work with static SQL" do
+    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
+    expect(@ds.insert([:value], [10])).to eq(1)
+    expect(@ds.all).to eq([{:value=>10}])
+  end
+end
+
+describe "Vertica::Database schema qualified tables" do
+  before do
+    VERTICA_DB << "CREATE SCHEMA schema_test"
+    VERTICA_DB.instance_variable_set(:@primary_keys, {})
+    VERTICA_DB.instance_variable_set(:@primary_key_sequences, {})
+  end
+
+  after do
+    VERTICA_DB << "DROP SCHEMA schema_test CASCADE"
+  end
+
+  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}
+    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}
+    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}
+    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}
+    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}
+    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
+    VERTICA_DB.create_table!(:domains){integer :d}
+    VERTICA_DB.create_table(:schema_test__domains){integer :i}
+    sch = VERTICA_DB.schema(:domains, :schema=>:schema_test)
+    cs = sch.map{|x| x.first}
+    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}
+    expect(VERTICA_DB.table_exists?(:schema_test__schema_test)).to eq(true)
+  end
+
+end

data/spec/spec_config.example.rb

@@ -0,0 +1 @@
+VERTICA_URL = 'vertica://dbadmin:dbadmin@127.0.0.1:5433/ci'

data/spec/spec_helper.rb

@@ -0,0 +1,55 @@
+require 'rubygems'
+require 'logger'
+require 'sequel'
+
+begin
+  require 'spec_config'
+rescue LoadError
+  $stderr.puts "Please create a file spec/spec_config.rb with a database connection string."
+  raise
+end
+
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
+
+Sequel.cache_anonymous_models = false
+
+class Sequel::Database
+  def log_duration(duration, message)
+    log_info(message)
+  end
+end
+
+(defined?(RSpec) ? RSpec::Core::ExampleGroup : Spec::Example::ExampleGroup).class_eval do
+  def log
+    begin
+      INTEGRATION_DB.loggers << Logger.new(STDOUT)
+      yield
+    ensure
+      INTEGRATION_DB.loggers.pop
+    end
+  end
+
+  def self.cspecify(message, *checked, &block)
+    return specify(message, &block) if ENV['SEQUEL_NO_PENDING']
+    pending = false
+    checked.each do |c|
+      case c
+      when INTEGRATION_DB.adapter_scheme
+        pending = c
+      when Proc
+        pending = c if c.first.call(INTEGRATION_DB)
+      when Array
+        pending = c if c.first == INTEGRATION_DB.adapter_scheme && c.last == INTEGRATION_DB.call(INTEGRATION_DB)
+      end
+    end
+    if pending
+      specify(message){pending("Not yet working on #{Array(pending).join(', ')}", &block)}
+    else
+      specify(message, &block)
+    end
+  end
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: nexia-sequel-vertica
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Camilo Lopez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.14'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.14'
+- !ruby/object:Gem::Dependency
+  name: vertica
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+description: Sequel adapter for the Vertica database
+email:
+- camilo@camilolopez.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG
+- Gemfile
+- README.md
+- Rakefile
+- lib/sequel-vertica.rb
+- lib/sequel-vertica/version.rb
+- lib/sequel/adapters/vertica.rb
+- sequel-vertica.gemspec
+- spec/adapters/vertica_spec.rb
+- spec/spec_config.example.rb
+- spec/spec_helper.rb
+homepage: https://github.com/camilo/sequel-vertica
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- Vertica version 6.0 or higher
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Sequel adapter for the Vertica database largely based on the PostgreSQL adapter
+test_files: []