vertica 0.7.4

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2009 Matt Bauer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.textile

@@ -0,0 +1,69 @@
+h1. Vertica
+
+by Matt Bauer
+
+h2. Description
+
+Vertica is a pure Ruby library for connecting to Vertica databases.  You can learn more
+about Vertica at http://www.vertica.com.  This library currently supports queries and
+prepared statements.
+
+h2. Install
+
+  $ gem install mattbauer-vertica --source http://gems.github.com
+
+h2. Source
+
+Vertica's git repo is available on GitHub, which can be browsed at:
+
+  http://github.com/mattbauer/vertica
+
+and cloned from:
+
+  git://github.com/mattbauer/vertica.git
+
+h2. Usage
+
+h4. Example Query
+
+<pre>
+<code>
+  c = Vertica::Connection.new(
+    :user     => 'user',
+    :password => 'password',
+    :host     => 'db_server',
+    :port     => '5433',
+    :database => 'db
+  )
+  r = c.query("SELECT * FROM my_table")
+  puts r.row_count
+  puts r.columns[0].name
+  puts r.rows
+  c.close
+</code>
+</pre>
+
+h4. Example Prepared Statement
+
+<pre>
+<code>
+  c = Vertica::Connection.new(
+    :user     => 'user',
+    :password => 'password',
+    :host     => 'db_server',
+    :port     => '5433',
+    :database => 'db
+  )
+  c.prepare("my_prepared_statement", "SELECT * FROM my_table WHERE id = ?", 1)
+  r = c.execute_prepared("my_prepared_statement", 13)
+  puts r.row_count
+  puts r.columns[0].name
+  puts r.rows
+  c.close
+</code>
+</pre>
+
+h2. Running The Tests
+
+To run the tests, change the values in test_helper.rb to match your db configuration.  Then
+execute the create_schema.sql on the database.  Then you may run the tests.

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+load 'vertica.gemspec'
+ 
+Rake::GemPackageTask.new(VERTICA_SPEC) do |pkg|
+    pkg.need_tar = true
+end
+ 
+task :default => "test"
+
+desc "Clean"
+task :clean do
+  include FileUtils
+  rm_rf 'pkg'
+end
+ 
+desc "Run tests"
+Rake::TestTask.new("test") do |t|
+  t.libs << ["test", "ext"]
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = true
+end
+ 
+task :doc => [:rdoc]
+namespace :doc do
+  Rake::RDocTask.new do |rdoc|
+    files = ["README", "lib/**/*.rb"]
+    rdoc.rdoc_files.add(files)
+    rdoc.main = "README.textile"
+    rdoc.title = "Vertica Docs"
+    rdoc.rdoc_dir = "doc"
+    rdoc.options << "--line-numbers" << "--inline-source"
+  end
+end
+
+desc "Run rcov on current app"
+task :rcov do
+  system "rm -rf coverage && rcov -o coverage -x rcov.rb test/*_test.rb"
+  system("open coverage/index.html") if PLATFORM['darwin']
+end

data/lib/vertica/bit_helper.rb

@@ -0,0 +1,51 @@
+module Vertica
+  module BitHelper
+
+    def readn(n)
+      s = read(n)
+      raise "couldn't read #{n} characters" if s.nil? or s.size != n # TODO make into a Vertica Exception
+      s
+    end
+    
+    def write_byte(value)
+      write [value].pack('C')
+    end
+    
+    def read_byte
+      readn(1).unpack('C').first
+    end
+
+    def write_network_int16(value)
+      write [value].pack('n')
+    end
+    
+    def read_network_int16
+      readn(2).unpack('n').first
+    end
+    
+    def write_network_int32(value)
+      write [value].pack('N')
+    end
+    
+    def read_network_int32
+      handle_endian_flavor(readn(4)).unpack('l').first
+    end
+
+    def write_cstring(value)
+      raise ArgumentError, "Invalid cstring" if value.include?("\000")
+      write "#{value}\000"
+    end
+
+    def read_cstring
+      readline("\000")[0..-2]
+    end
+
+    def handle_endian_flavor(s)
+      little_endian? ? s.reverse : s
+    end
+    
+    def little_endian?
+      @little_endian ||= ([0x12345678].pack("L") == "\x12\x34\x56\x78" ? false : true)
+    end
+  end
+end

data/lib/vertica/column.rb

@@ -0,0 +1,68 @@
+module Vertica
+  class Column
+    attr_reader :name
+    attr_reader :table_oid
+    attr_reader :type_modifier
+    attr_reader :size
+    attr_reader :data_type
+
+    DATA_TYPES = [
+      :unspecified,
+      :tuple,
+      :pos,
+      :record,
+      :unknown,
+      :bool,
+      :in,
+      :float,
+      :char,
+      :varchar,
+      :date,
+      :time,
+      :timestamp,
+      :timestamp_tz,
+      :interval,
+      :time_tz,
+      :numberic,
+      :bytea,
+      :rle_tuple
+    ]
+    
+    DATA_TYPE_CONVERSIONS = {
+      :unspecified    => nil,
+      :tuple          => nil,
+      :pos            => nil,
+      :record         => nil,
+      :unknown        => nil,
+      :bool           => lambda { |s| s == 't' },
+      :in             => lambda { |s| s.to_i },
+      :float          => lambda { |s| s.to_f },
+      :char           => nil,
+      :varchar        => nil,
+      :date           => lambda { |s| Date.new(*s.split("-").map{|x| x.to_i}) },
+      :time           => lambda { |s| Time.parse(s) },
+      :timestamp      => lambda { |s| DateTime.parse(s, true) },
+      :timestamp_tz   => lambda { |s| DateTime.parse(s, true) },
+      :interval       => nil,
+      :time_tz        => lambda { |s| Time.parse(s) },
+      :numberic       => lambda { |s| s.to_d },
+      :bytea          => nil,
+      :rle_tuple      => nil
+    }
+
+    def initialize(type_modifier, format_code, table_oid, name, attribute_number, data_type_oid, size)
+      @type_modifier = type_modifier
+      @format = (format_code == 0 ? :text : :binary)
+      @table_oid = table_oid
+      @name = name
+      @attribute_number = attribute_number
+      @data_type = DATA_TYPES[data_type_oid]
+      @size = size
+    end
+    
+    def convert(s)
+      l = DATA_TYPE_CONVERSIONS[@data_type]
+      l ? l.call(s) : s
+    end
+  end
+end

data/lib/vertica/connection.rb

@@ -0,0 +1,247 @@
+require 'uri'
+require 'stringio'
+require 'vertica/vertica_socket'
+require 'vertica/messages/message'
+require 'openssl/ssl'
+
+module Vertica
+  
+  class Connection
+    
+    def initialize(options = {})
+      reset_values
+
+      @options = options
+      establish_connection
+      
+      unless options[:skip_startup]
+        Messages::Startup.new(@options[:user], @options[:database]).to_bytes(@conn)
+        process
+      end
+    end
+    
+    def close
+      raise_if_not_open
+      Messages::Terminate.new.to_bytes(@conn)
+      @conn.shutdown
+    rescue Errno::ENOTCONN
+      # the backend closed the connection already
+    ensure
+      reset_values
+    end
+    
+    def reset
+      close if opened?
+      reset_values
+      establish_connection
+    end
+
+    def options
+      @options.dup
+    end
+    
+    def transaction_status
+      @transaction_status
+    end
+
+    def backend_pid
+      @backend_pid
+    end
+    
+    def backend_key
+      @backend_key
+    end
+
+    def notifications
+      @notifications
+    end
+    
+    def parameters
+      @parameters.dup
+    end
+
+    def put_copy_data; raise NotImplementedError.new; end
+    def put_copy_end;  raise NotImplementedError.new; end
+    def get_copy_data; raise NotImplementedError.new; end
+    
+    def opened?
+      @conn && @backend_pid && @transaction_status
+    end
+    
+    def closed?
+      !opened?
+    end
+    
+    def query(query_string)
+      raise ArgumentError.new("Query string cannot be blank or empty.") if query_string.nil? || query_string.empty?
+      raise_if_not_open
+      reset_result
+
+      Messages::Query.new(query_string).to_bytes(@conn)
+      process(true)
+    end
+    
+    def prepare(name, query, params_count = 0)
+      raise_if_not_open
+      
+      param_types = Array.new(params_count).fill(0)
+      
+      Messages::Parse.new(name, query, param_types).to_bytes(@conn)
+      Messages::Describe.new(:prepared_statement, name).to_bytes(@conn)
+      Messages::Sync.new.to_bytes(@conn)
+      Messages::Flush.new.to_bytes(@conn)
+      
+      process
+    end
+    
+    def execute_prepared(name, *param_values)
+      raise_if_not_open
+      
+      portal_name = "" # use the unnamed portal
+      max_rows    = 0  # return all rows
+            
+      reset_result
+      
+      Messages::Bind.new(portal_name, name, param_values).to_bytes(@conn)
+      Messages::Execute.new(portal_name, max_rows).to_bytes(@conn)
+      Messages::Sync.new.to_bytes(@conn)
+            
+      result = process(true)
+
+      # Close the portal
+      Messages::Close.new(:portal, portal_name).to_bytes(@conn)
+      Messages::Flush.new.to_bytes(@conn)
+      
+      process
+      
+      # Return the result from the prepared statement
+      result
+    end
+
+    def self.cancel(existing_conn)
+      conn = new(existing_conn.options.merge(:skip_startup => true))
+      Messages::CancelRequest.new(existing_conn.backend_pid, existing_conn.backend_key).to_bytes(conn.send(:conn))
+      Messages::Flush.new.to_bytes(conn.send(:conn))
+      conn.close
+    end
+
+    protected
+    
+    def establish_connection
+      @conn = VerticaSocket.new(@options[:host], @options[:port].to_s)
+      
+      if @options[:ssl]
+        Messages::SslRequest.new.to_bytes(@conn)
+        if @conn.read_byte == ?S
+          @conn = OpenSSL::SSL::SSLSocket.new(@conn, OpenSSL::SSL::SSLContext.new)
+          @conn.sync = true
+          @conn.connect
+        else
+          raise Error::ConnectionError.new("SSL requested but server doesn't support it.")
+        end
+      end      
+    end
+    
+    def process(return_result = false)
+      loop do
+        message = Messages::BackendMessage.read(@conn)
+
+        case message
+        when Messages::Authentication
+          if message.code != Messages::Authentication::OK
+            Messages::Password.new(@options[:password], message.code, {:user => @options[:user], :salt => message.salt}).to_bytes(@conn)
+          end
+        when Messages::BackendKeyData
+          @backend_pid = message.pid
+          @backend_key = message.key
+        when Messages::BindComplete
+          :nothing
+        when Messages::CloseComplete
+          break
+        when Messages::CommandComplete
+          break
+        # when Messages::CopyData
+        #   # nothing
+        # when Messages::CopyDone
+        #   # nothing        
+        # when Messages::CopyInResponse
+        #   raise 'not done'
+        # when Messages::CopyOutResponse
+        #   raise 'not done'
+        when Messages::DataRow
+          @field_values << message.fields
+        when Messages::EmptyQueryResponse
+          break
+        when Messages::ErrorResponse
+          raise Error::MessageError.new(message.error)
+        when Messages::NoData
+          :nothing
+        when Messages::NoticeResponse
+          message.notices.each do |notice|
+            @notices << Notice.new(notice[0], notice[1])
+          end
+        when Messages::NotificationResponse
+          @notifications << Notification.new(message.pid, message.condition, message.additional_info)        
+        when Messages::ParameterDescription
+          :nothing
+        when Messages::ParameterStatus
+          @parameters[message.name] = message.value
+        when Messages::ParseComplete
+          break
+        when Messages::PortalSuspended
+          break
+        when Messages::ReadyForQuery
+          @transaction_status = convert_transaction_status_to_sym(message.transaction_status)
+          break unless return_result
+        when Messages::RowDescription
+          @field_descriptions = message.fields
+        when Messages::Unknown
+          raise Error::MessageError.new("Unknown message type: #{message.message_id}")
+        end
+      end
+      
+      return_result ? Result.new(@field_descriptions, @field_values) : nil
+    end
+    
+    def raise_if_not_open
+      raise ConnectionError.new("connection doesn't exist or is already closed") if @conn.nil?
+    end
+    
+    def reset_values
+      reset_notifications
+      reset_result
+      @parameters         = {}
+      @backend_pid        = nil
+      @backend_key        = nil
+      @transaction_status = nil
+      @conn               = nil
+    end
+    
+    def reset_notifications
+      @notifications      = []
+    end
+
+    def reset_result
+      @field_descriptions = []
+      @field_values       = []
+    end    
+    
+    def convert_transaction_status_to_sym(status)
+      case status
+      when ?I
+        :no_transaction
+      when ?T
+        :in_transaction
+      when ?E
+        :failed_transaction
+      else
+        nil
+      end
+    end
+
+    def conn
+      @conn
+    end
+
+  end
+end

data/lib/vertica/messages/authentication.rb

@@ -0,0 +1,33 @@
+module Vertica
+  module Messages
+    class Authentication < BackendMessage
+      message_id ?R
+
+      OK                  = 0
+      KERBEROS_V5         = 2
+      CLEARTEXT_PASSWORD  = 3
+      CRYPT_PASSWORD      = 4
+      MD5_PASSWORD        = 5
+      SCM_CREDENTIAL      = 6
+      GSS                 = 7
+      GSS_CONTINUE        = 8
+      SSPI                = 9
+      
+      attr_reader :code
+      attr_reader :salt
+      attr_reader :auth_data
+      
+      def initialize(stream, size)
+        super
+        @code = stream.read_network_int32
+        if @code == CRYPT_PASSWORD
+          @salt = stream.readn(2)
+        elsif @code == MD5_PASSWORD
+          @salt = stream.readn(4)
+        elsif @code == GSS_CONTINUE
+          @auth_data = stream.readn(size - 9)
+        end
+      end
+    end
+  end
+end

data/lib/vertica/messages/backend_key_data.rb

@@ -0,0 +1,16 @@
+module Vertica
+  module Messages
+    class BackendKeyData < BackendMessage
+      message_id ?K
+      
+      attr_reader :pid
+      attr_reader :key
+      
+      def initialize(stream, size)
+        super
+        @pid = stream.read_network_int32
+        @key = stream.read_network_int32
+      end
+    end
+  end
+end

data/lib/vertica/messages/bind.rb

@@ -0,0 +1,36 @@
+module Vertica
+  module Messages
+    class Bind < FrontendMessage
+      message_id ?B
+
+      def initialize(portal_name, prepared_statement_name, parameter_values)
+        @portal_name = portal_name
+        @prepared_statement_name = prepared_statement_name
+        @parameter_values = parameter_values.map { |pv| pv.to_s }
+      end
+
+      def to_bytes(stream)
+        size = LENGTH_SIZE
+        size += @portal_name.length + 1
+        size += @prepared_statement_name.length + 1
+        size += 2 # parameter format code (0)
+        size += 2 # number of parameter values
+        size += @parameter_values.inject(0) { |sum, e| sum += (e.length + 4) }
+        size += 2
+
+        stream.write_byte(message_id)
+        stream.write_network_int32(size)                      # size
+        stream.write_cstring(@portal_name)                    # portal name ("")
+        stream.write_cstring(@prepared_statement_name)        # prep
+        stream.write_network_int16(0)                         # format codes (0 - default text format)
+        stream.write_network_int16(@parameter_values.length)  # number of parameters
+        @parameter_values.each do |parameter_value|
+          stream.write_network_int32(parameter_value.length)  # parameter value (which is represented as a string) length
+          stream.write(parameter_value)               # parameter value written out in text representation
+        end
+        stream.write_network_int16(0)
+      end
+
+    end
+  end
+end

data/lib/vertica/messages/bind_complete.rb

@@ -0,0 +1,8 @@
+module Vertica
+  module Messages
+    class BindComplete < BackendMessage
+      message_id ?2
+      
+    end
+  end
+end

data/lib/vertica/messages/cancel_request.rb

@@ -0,0 +1,25 @@
+module Vertica
+  module Messages
+    class CancelRequest < FrontendMessage
+      message_id nil
+
+      def initialize(backend_pid, backend_key)
+        @backend_pid = backend_pid
+        @backend_key = backend_key
+      end
+
+      def to_bytes(stream)
+        size = LENGTH_SIZE
+        size += 4
+        size += 4
+        size += 4
+
+        stream.write_network_int32(size) # size
+        stream.write_network_int32(80877102)
+        stream.write_network_int32(@backend_pid)
+        stream.write_network_int32(@backend_key)
+      end
+
+    end
+  end
+end

data/lib/vertica/messages/close.rb

@@ -0,0 +1,30 @@
+module Vertica
+  module Messages
+    class Close < FrontendMessage
+      message_id ?C
+
+      def initialize(close_type, close_name)
+        if close_type == :portal
+          @close_type = ?P
+        elsif close_type == :prepared_statement
+          @close_type = ?S
+        else
+          raise ArgumentError.new("#{close_type} is not a valid close_type.  Must be either :portal or :prepared_statement.")
+        end
+        @close_name = close_name
+      end
+
+      def to_bytes(stream)
+        size = LENGTH_SIZE
+        size += 1
+        size += @close_name.length + 1
+        
+        stream.write_byte(message_id)
+        stream.write_network_int32(size) # size
+        stream.write_byte(@close_type)
+        stream.write_cstring(@close_name)
+      end
+
+    end
+  end
+end

data/lib/vertica/messages/close_complete.rb

@@ -0,0 +1,8 @@
+module Vertica
+  module Messages
+    class CloseComplete < BackendMessage
+      message_id ?3
+
+    end
+  end
+end

data/lib/vertica/messages/command_complete.rb

@@ -0,0 +1,16 @@
+module Vertica
+  module Messages
+    class CommandComplete < BackendMessage
+      message_id ?C
+      
+      attr_reader :tag
+      attr_reader :rows
+      
+      def initialize(stream, size)
+        @tag = stream.read_cstring
+        @rows = @tag.split[-1].to_i
+      end
+      
+    end
+  end
+end