sequel-vertica 0.0.1

data/.gitignore

@@ -0,0 +1,19 @@
+*.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

data/Gemfile

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

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/Readme.md

@@ -0,0 +1,16 @@
+## 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/lib/sequel-vertica.rb

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

data/lib/sequel-vertica/version.rb

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

data/lib/sequel/adapters/vertica.rb

@@ -0,0 +1,110 @@
+require 'vertica'
+
+module Sequel
+  module Vertica
+    class Database < Sequel::Database
+      ::Vertica::Connection.send(:alias_method,:execute, :query)
+      PK_NAME = 'C_PRIMARY'
+      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],
+          :ssl => opts[:ssl] )
+      end
+
+      def execute(sql, opts = {}, &block)
+        synchronize(opts[:server]) do |conn|
+          res = conn.query(sql)
+          res.each(&block)
+        end
+      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 tables(options = {} )
+        schema = options[:schema]
+        filter = {}
+        filter[:table_schema] = schema.to_s if schema
+
+        ds = dataset.select(:table_name).from(:v_catalog__tables).
+          filter(filter)
+
+        ds.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 = { :table_name => table_name }
+        filter [: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 fetch_rows(sql)
+        execute(sql) do  |row| 
+          @columns ||= row.keys 
+          yield row 
+        end
+      end
+
+      def explain(opts={})
+        execute((opts[:local] ? EXPLAIN_LOCAL : EXPLAIN) + select_sql).map{ |k, v| k == QUERY_PLAN }.join("\$")
+      end
+    end
+  end
+end

data/sequel-vertica.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/sequel-vertica/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  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      = ""
+
+  gem.add_development_dependency "rspec"
+  gem.add_runtime_dependency "sequel"
+  gem.add_runtime_dependency "vertica"
+
+  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.name          = "sequel-vertica"
+  gem.require_paths = ["lib"] 
+  gem.version       = Sequel::Vertica::VERSION
+end

data/spec/adapters/spec_helper.rb

@@ -0,0 +1,54 @@
+require 'rubygems'
+require 'logger'
+unless Object.const_defined?('Sequel')
+  $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
+  require 'sequel'
+end
+begin
+  require File.join(File.dirname(File.dirname(File.expand_path(__FILE__))), 'spec_config.rb')
+rescue LoadError
+end
+
+if ENV['SEQUEL_COLUMNS_INTROSPECTION']
+  Sequel.extension :columns_introspection
+  Sequel::Dataset.introspect_all_columns
+end
+
+Sequel::Model.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

data/spec/adapters/vertica_spec.rb

@@ -0,0 +1,284 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+
+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 database" do 
+
+  before do
+    @db = VERTICA_DB
+  end
+
+  specify "should correctly parse the schema" do
+    @db.schema(:test3, :reload=>true).should == [
+      [: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}]
+    ]
+  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
+    @d.select(:name).sql.should == \
+      'SELECT "name" FROM "test"'
+
+    @d.select('COUNT(*)'.lit).sql.should == \
+      'SELECT COUNT(*) FROM "test"'
+
+    @d.select(:max.sql_function(:value)).sql.should == \
+      'SELECT max("value") FROM "test"'
+
+    @d.select(:NOW.sql_function).sql.should == \
+    'SELECT NOW() FROM "test"'
+
+    @d.select(:max.sql_function(:items__value)).sql.should == \
+      'SELECT max("items"."value") FROM "test"'
+
+    @d.order(:name.desc).sql.should == \
+      'SELECT * FROM "test" ORDER BY "name" DESC'
+
+    @d.select('test.name AS item_name'.lit).sql.should == \
+      'SELECT test.name AS item_name FROM "test"'
+
+    @d.select('"name"'.lit).sql.should == \
+      'SELECT "name" FROM "test"'
+
+    @d.select('max(test."name") AS "max_name"'.lit).sql.should == \
+      'SELECT max(test."name") AS "max_name" FROM "test"'
+
+    @d.insert_sql(:x => :y).should =~ \
+      /\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 == \
+      'SELECT * FROM "test" ORDER BY "name" DESC'
+
+    @d.reverse_order(:name.desc).sql.should == \
+      'SELECT * FROM "test" ORDER BY "name" ASC'
+
+    @d.reverse_order(:name, :test.desc).sql.should == \
+      'SELECT * FROM "test" ORDER BY "name" DESC, "test" ASC'
+
+    @d.reverse_order(:name.desc, :test).sql.should == \
+      '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
+  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]
+    @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
+  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
+  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
+    end
+  end
+
+end
+
+
+describe "A Vertica database" do
+  before do
+    @db = VERTICA_DB
+  end
+
+  specify "should support column operations" do
+    @db.create_table!(:test2){varchar :name; integer :value}
+    @db[:test2] << {}
+    @db[:test2].columns.should == [:name, :value]
+
+    @db.add_column :test2, :xyz, :varchar, :default => '000'
+    @db[:test2].columns.should == [:name, :value, :xyz]
+    @db[:test2] << {:name => 'mmm', :value => 111}
+    @db[:test2].first[:xyz].should == '000'
+
+    @db[:test2].columns.should == [:name, :value, :xyz]
+    proc{ @db.drop_column :test2, :xyz }.should raise_error(Vertica::Error::QueryError,
+                                                    /ALTER TABLE DROP COLUMN not supported/)
+
+    @db[:test2].columns.should ==[:name, :value, :xyz]
+
+    @db[:test2].delete
+    @db.add_column :test2, :xyz2, :varchar, :default => '000'
+    @db[:test2] << {:name => 'mmm', :value => 111, :xyz2 => 'qqqq'}
+
+    @db[:test2].columns.should == [:name, :value, :xyz, :xyz2]
+    @db.rename_column :test2, :xyz, :zyx
+    @db[:test2].columns.should == [:name, :value, :zyx, :xyz2]
+    @db[:test2].first[:xyz2].should == 'qqqq'
+
+    @db.add_column :test2, :xyz, :float
+    @db[:test2].delete
+    @db[:test2] << {:name => 'mmm', :value => 111, :xyz => 56.78}
+
+    proc{ @db.set_column_type :test2, :xyz, :integer }.should raise_error(Vertica::Error::QueryError,
+                                                    /ALTER TABLE ALTER COLUMN not supported/)
+  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)
+  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
+    @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}]
+  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}]
+  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"
+    VERTICA_DB.default_schema = nil
+  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}
+    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('schema_test.table_in_schema_test'.lit).first.should == {: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('schema_test.table_in_schema_test'.lit).first.should == 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)
+  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]
+  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)
+  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}
+    cs.should include(:i)
+    cs.should_not 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
+  end
+
+end

data/spec/spec_config.example.rb

@@ -0,0 +1 @@
+VERTICA_URL = 'vertica://dbadmin:@192.168.56.101:5433/warehouse'

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: sequel-vertica
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Camilo Lopez
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-06 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70287178230020 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70287178230020
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: &70287178229280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70287178229280
+- !ruby/object:Gem::Dependency
+  name: vertica
+  requirement: &70287178228620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70287178228620
+description: Sequel adapter for the Vertica database
+email:
+- camilo@camilolopez.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- Readme.md
+- lib/sequel-vertica.rb
+- lib/sequel-vertica/version.rb
+- lib/sequel/adapters/vertica.rb
+- sequel-vertica.gemspec
+- spec/adapters/spec_helper.rb
+- spec/adapters/vertica_spec.rb
+- spec/spec_config.example.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Sequel adapter for the Vertica database largely based on the PostgreSQL adapter
+test_files: []