vertica 0.12.0 → 1.0.0.rc1

data/lib/vertica/{messages/frontend_messages → protocol/frontend}/startup.rb

@@ -1,5 +1,5 @@
 module Vertica
-  module Messages
+  module Protocol
 
     class Startup < FrontendMessage
       message_id nil
@@ -10,13 +10,12 @@ module Vertica
         @options  = options
       end
 
-      def to_bytes
+      def message_body
         str =  [Vertica::PROTOCOL_VERSION].pack('N')
         str << ["user", @user].pack('Z*Z*')         if @user
         str << ["database", @database].pack('Z*Z*') if @database
         str << ["options", @options].pack('Z*Z*')   if @options
         str << [].pack('x')
-        message_string str
       end
     end
   end

data/lib/vertica/{messages/frontend_messages → protocol/frontend}/sync.rb

@@ -1,5 +1,5 @@
 module Vertica
-  module Messages
+  module Protocol
     class Sync < FrontendMessage
       message_id 'S'
     end

data/lib/vertica/{messages/frontend_messages → protocol/frontend}/terminate.rb

@@ -1,5 +1,5 @@
 module Vertica
-  module Messages
+  module Protocol
     class Terminate < FrontendMessage
       message_id 'X'
     end

data/lib/vertica/protocol/message.rb

@@ -0,0 +1,86 @@
+module Vertica
+  module Protocol
+
+    class Message
+      def self.message_id(message_id)
+        self.send(:define_method, :message_id) { message_id }
+      end
+    end
+
+    class BackendMessage < Message
+      MessageIdMap = {}
+
+      def self.factory(type, data)
+        if klass = MessageIdMap[type]
+          klass.new(data)
+        else
+          Protocol::Unknown.new(type, data)
+        end
+      end
+
+      def self.message_id(message_id)
+        super
+        MessageIdMap[message_id] = self
+      end
+
+      def initialize(_data)
+      end
+    end
+
+    class FrontendMessage < Message
+      def to_bytes
+        prepend_message_header(message_body)
+      end
+
+      protected
+
+      def message_body
+        ''
+      end
+
+      def prepend_message_header(msg)
+        if message_id
+          [message_id, 4 + msg.bytesize, msg].pack('aNa*')
+        else
+          [4 + msg.bytesize, msg].pack('Na*')
+        end
+      end
+    end
+  end
+end
+
+require 'vertica/protocol/backend/authentication'
+require 'vertica/protocol/backend/backend_key_data'
+require 'vertica/protocol/backend/bind_complete'
+require 'vertica/protocol/backend/close_complete'
+require 'vertica/protocol/backend/command_complete'
+require 'vertica/protocol/backend/data_row'
+require 'vertica/protocol/backend/empty_query_response'
+require 'vertica/protocol/backend/notice_response'
+require 'vertica/protocol/backend/error_response'
+require 'vertica/protocol/backend/no_data'
+require 'vertica/protocol/backend/parameter_description'
+require 'vertica/protocol/backend/parameter_status'
+require 'vertica/protocol/backend/parse_complete'
+require 'vertica/protocol/backend/portal_suspended'
+require 'vertica/protocol/backend/ready_for_query'
+require 'vertica/protocol/backend/row_description'
+require 'vertica/protocol/backend/copy_in_response'
+require 'vertica/protocol/backend/unknown'
+
+require 'vertica/protocol/frontend/bind'
+require 'vertica/protocol/frontend/cancel_request'
+require 'vertica/protocol/frontend/close'
+require 'vertica/protocol/frontend/describe'
+require 'vertica/protocol/frontend/execute'
+require 'vertica/protocol/frontend/flush'
+require 'vertica/protocol/frontend/parse'
+require 'vertica/protocol/frontend/password'
+require 'vertica/protocol/frontend/query'
+require 'vertica/protocol/frontend/ssl_request'
+require 'vertica/protocol/frontend/startup'
+require 'vertica/protocol/frontend/sync'
+require 'vertica/protocol/frontend/terminate'
+require 'vertica/protocol/frontend/copy_done'
+require 'vertica/protocol/frontend/copy_fail'
+require 'vertica/protocol/frontend/copy_data'

data/lib/vertica/query.rb

@@ -1,85 +1,104 @@
 class Vertica::Query
 
-  attr_reader :connection, :sql, :result, :error
-  attr_accessor :row_handler, :copy_handler, :row_style
+  attr_reader :connection, :sql, :error, :result
 
-  def initialize(connection, sql, options = {})
+  def initialize(connection, sql, row_handler: nil, copy_handler: nil)
     @connection, @sql = connection, sql
-    
-    @row_style    = options[:row_style] || @connection.row_style || :hash
-    @row_handler  = options[:row_handler]
-    @copy_handler = options[:copy_handler]
-
-    @error  = nil
-    @result = Vertica::Result.new(row_style)
+    if row_handler.nil?
+      @buffer = []
+      @row_handler = lambda { |row| buffer_row(row) }
+    else
+      @row_handler = row_handler
+    end
+    @copy_handler = copy_handler
+    @error = nil
   end
 
   def run
-    @connection.write_message(Vertica::Messages::Query.new(sql))
+    @connection.write_message(Vertica::Protocol::Query.new(sql))
 
     begin
       process_message(message = @connection.read_message)
-    end until message.kind_of?(Vertica::Messages::ReadyForQuery)
+    end until message.kind_of?(Vertica::Protocol::ReadyForQuery)
 
     raise error unless error.nil?
     return result
   end
 
-  def write(data)
-    @connection.write_message(Vertica::Messages::CopyData.new(data))
-    return self
-  end
-
-  alias_method :<<, :write
-
   def to_s
     @sql
   end
 
   protected
 
+  def buffer_rows?
+    !!@buffer
+  end
+
   def process_message(message)
     case message
-    when Vertica::Messages::ErrorResponse
+    when Vertica::Protocol::ErrorResponse
       @error = Vertica::Error::QueryError.from_error_response(message, @sql)
-    when Vertica::Messages::EmptyQueryResponse
+    when Vertica::Protocol::EmptyQueryResponse
       @error = Vertica::Error::EmptyQueryError.new("A SQL string was expected, but the given string was blank or only contained SQL comments.")
-    when Vertica::Messages::CopyInResponse
-      handle_copy_from_stdin
-    when Vertica::Messages::RowDescription
-      result.descriptions = message
-    when Vertica::Messages::DataRow
-      handle_datarow(message)
-    when Vertica::Messages::CommandComplete
-      result.tag = message.tag
+    when Vertica::Protocol::CopyInResponse
+      handle_copy_in_response(message)
+    when Vertica::Protocol::RowDescription
+      handle_row_description(message)
+    when Vertica::Protocol::DataRow
+      handle_data_row(message)
+    when Vertica::Protocol::CommandComplete
+      handle_command_complete(message)
     else
       @connection.process_message(message)
     end
   end
 
-  def handle_copy_from_stdin
-    if copy_handler.nil?
-      @connection.write_message(Vertica::Messages::CopyFail.new('no handler provided'))
+  def handle_row_description(message)
+    @row_description = Vertica::RowDescription.build(message)
+  end
+
+  def handle_data_row(message)
+    @row_handler.call(@row_description.build_row(message))
+  end
+
+  def handle_command_complete(message)
+    if buffer_rows?
+      @result = Vertica::Result.build(row_description: @row_description, rows: @buffer, tag: message.tag)
+      @row_description, @buffer = nil, nil
+    else
+      @result = message.tag
+    end
+  end
+
+  def handle_copy_in_response(_message)
+    if @copy_handler.nil?
+      @connection.write_message(Vertica::Protocol::CopyFail.new('no handler provided'))
     else
       begin
-        if copy_handler.call(self) == :rollback
-          @connection.write_message(Vertica::Messages::CopyFail.new("rollback"))
-        else
-          @connection.write_message(Vertica::Messages::CopyDone.new)
-        end
+        @copy_handler.call(CopyFromStdinWriter.new(connection))
+        @connection.write_message(Vertica::Protocol::CopyDone.new)
       rescue => e
-        @connection.write_message(Vertica::Messages::CopyFail.new(e.message))
+        @connection.write_message(Vertica::Protocol::CopyFail.new(e.message))
       end
     end
   end
 
-  def handle_datarow(datarow_message)
-    record = result.format_row(datarow_message)
-    result.add_row(record) if buffer_rows?
-    row_handler.call(record) if row_handler
+  def buffer_row(row)
+    @buffer << row
   end
 
-  def buffer_rows?
-    row_handler.nil? && copy_handler.nil?
+  class CopyFromStdinWriter
+    def initialize(connection)
+      @connection = connection
+    end
+
+    def write(data)
+      @connection.write_message(Vertica::Protocol::CopyData.new(data))
+      return self
+    end
+
+    alias_method :<<, :write
   end
+  private_constant :CopyFromStdinWriter
 end

data/lib/vertica/result.rb

@@ -1,70 +1,48 @@
 class Vertica::Result
   include Enumerable
 
-  attr_reader :columns
+  attr_reader :row_description
   attr_reader :rows
-  attr_accessor :tag, :notice
+  attr_reader :tag
 
-  def initialize(row_style = :hash)
-    @row_style = row_style
-    @rows = []
+  def initialize(row_description: nil, rows: nil, tag: nil)
+    @row_description, @rows, @tag = row_description, rows, tag
   end
 
-  def descriptions=(message)
-    @columns = message.fields.map { |fd| Vertica::Column.new(fd) }
-  end
-
-  def format_row_as_hash(row_data)
-    row = {}
-    row_data.values.each_with_index do |value, idx|
-      col = columns.fetch(idx)
-      row[col.name] = col.convert(value)
-    end
-    row
+  def each(&block)
+    @rows.each(&block)
   end
 
-  def format_row(row_data)
-    send("format_row_as_#{@row_style}", row_data)
+  def empty?
+    @rows.empty?
   end
 
-  def format_row_as_array(row_data)
-    row = []
-    row_data.values.each_with_index do |value, idx|
-      row << columns.fetch(idx).convert(value)
-    end
-    row
+  def size
+    @rows.length
   end
 
-  def add_row(row)
-    @rows << row
-  end
+  alias_method :count, :size
+  alias_method :length, :size
 
-  def each_row(&block)
-    @rows.each(&block)
+  def fetch(row_index, col = nil)
+    row = rows.fetch(row_index)
+    return row if col.nil?
+    row.fetch(col)
   end
 
-  def empty?
-    @rows.empty?
-  end
+  alias_method :[], :fetch
 
-  def the_value
-    if empty?
-      nil
-    else
-      @row_style == :array ? rows[0][0] : rows[0][columns[0].name]
-    end
+  def value
+    fetch(0, 0)
   end
 
-  def [](row, col = nil)
-    col.nil? ? row[row] : rows[row][col]
-  end
+  alias_method :the_value, :value
 
-  alias_method :each, :each_row
+  alias_method :columns, :row_description
 
-  def row_count
-    @rows.size
+  def self.build(row_description: nil, rows: [], tag: nil)
+    row_description = Vertica::RowDescription.build(row_description)
+    rows = rows.map { |values| row_description.build_row(values) }
+    new(row_description: row_description, rows: rows, tag: tag)
   end
-
-  alias_method :size, :row_count
-  alias_method :length, :row_count
 end

data/lib/vertica/row.rb

@@ -0,0 +1,44 @@
+class Vertica::Row
+  include Enumerable
+
+  def initialize(row_description, values)
+    @row_description, @values = row_description, values
+  end
+
+  def each(&block)
+    @values.each(&block)
+  end
+
+  def fetch(name_or_index)
+    @values.fetch(column_index(name_or_index))
+  end
+
+  def inspect
+    "<Vertica::Row#{@values.inspect}>"
+  end
+
+  alias_method :[], :fetch
+
+  def to_a
+    @values.to_a
+  end
+
+  def to_h(symbolize_keys: false)
+    @row_description.inject({}) do |carry, column|
+      key = symbolize_keys ? column.name.to_sym : column.name
+      carry.merge(key => fetch(column.name))
+    end
+  end
+
+  def column(name_or_index)
+    column_with_index(name_or_index).fetch(0)
+  end
+
+  def column_index(name_or_index)
+    column_with_index(name_or_index).fetch(1)
+  end
+
+  def column_with_index(name_or_index)
+    @row_description.column_with_index(name_or_index)
+  end
+end

data/lib/vertica/row_description.rb

@@ -0,0 +1,102 @@
+class Vertica::RowDescription
+  include Enumerable
+
+  def self.build(columns)
+    case columns
+    when Vertica::Protocol::RowDescription
+      new(columns.fields.map { |fd| Vertica::Column.new(fd) })
+    when Vertica::RowDescription
+      columns
+    when Array
+      new(columns)
+    when nil
+      nil
+    else
+      raise ArgumentError, "Invalid list of columns: #{columns.inspect}"
+    end
+  end
+
+  def initialize(columns)
+    @columns = columns
+  end
+
+  def column(name_or_index)
+    column_with_index(name_or_index).first
+  end
+
+  alias_method :[], :column
+
+  def column_with_index(name_or_index)
+    columns_index.fetch(name_or_index)
+  end
+
+  def each(&block)
+    @columns.each(&block)
+  end
+
+  def size
+    @columns.size
+  end
+
+  alias_method :length, :size
+
+  def to_a
+    @columns.clone
+  end
+
+  def to_h(symbolize_keys: false)
+    @columns.inject({}) do |carry, column|
+      key = symbolize_keys ? column.name.to_sym : column.name
+      carry.merge(key => column)
+    end
+  end
+
+  def build_row(values)
+    case values
+    when Vertica::Row
+      values
+
+    when Vertica::Protocol::DataRow
+      converted_values = @columns.map.with_index do |column, index|
+        column.convert(values.values.fetch(index))
+      end
+      Vertica::Row.new(self, converted_values)
+
+    when Array
+      raise ArgumentError, "Number of values does not match row description" if values.size != size
+      Vertica::Row.new(self, values)
+
+    when Hash
+      raise ArgumentError, "Number of values does not match row description" if values.size != size
+      values_as_array = @columns.map { |column| values[column.name] || values[column.name.to_sym] }
+      Vertica::Row.new(self, values_as_array)
+
+    else
+      raise ArgumentError, "Don't know how to build a row from a #{values.class.name} instance"
+    end
+  end
+
+  def eql?(other)
+    self.class === other && other.to_a == self.to_a
+  end
+
+  alias_method :==, :eql?
+
+  def hash
+    @columns.hash
+  end
+
+  protected
+
+  def columns_index
+    @columns_index ||= begin
+      result = {}
+      @columns.each_with_index do |column, index|
+        result[index]              = [column, index]
+        result[column.name.to_s]   = [column, index]
+        result[column.name.to_sym] = [column, index]
+      end
+      result
+    end
+  end
+end