monetdb 0.1.3 → 0.2.0

data/lib/monetdb/connection/messages.rb

@@ -0,0 +1,16 @@
+module MonetDB
+  class Connection
+    module Messages
+    private
+
+      def msg_chr(string)
+        string.empty? ? "" : string[0].chr
+      end
+
+      def msg?(string, msg)
+        msg_chr(string) == msg
+      end
+
+    end
+  end
+end

data/lib/monetdb/connection/query.rb

@@ -0,0 +1,136 @@
+module MonetDB
+  class Connection
+    module Query
+
+      def query(statement)
+        raise ConnectionError, "Not connected to server" unless connected?
+
+        write "s#{statement};"
+        response = read.split("\n")
+
+        query_header, table_header = extract_headers!(response)
+
+        if query_header[:type] == Q_TABLE
+          unless query_header[:rows] == response.size
+            raise QueryError, "Amount of fetched rows does not match header value (#{response.size} instead of #{query_header[:rows]})"
+          end
+          response = parse_rows(table_header, response.join("\n"))
+        else
+          response = true
+        end
+
+        response
+      end
+
+      alias :select_rows :query
+
+    private
+
+      def extract_headers!(response)
+        [parse_query_header!(response), parse_scheme_header!(response)]
+      end
+
+      def parse_query_header!(response)
+        header = response.shift
+
+        raise QueryError, header if header[0].chr == MSG_ERROR
+
+        unless header[0].chr == MSG_QUERY
+          raise QueryError, "Expected an query header (#{MSG_QUERY}) but got (#{header[0].chr})"
+        end
+
+        to_query_header_hash header
+      end
+
+      def to_query_header_hash(header)
+        hash = {:type => header[1].chr}
+
+        keys = {
+          Q_TABLE => [:id, :rows, :columns, :returned],
+          Q_BLOCK => [:id, :columns, :remains, :offset]
+        }[hash[:type]]
+
+        if keys
+          values = header.split(" ")[1, 4].collect(&:to_i)
+          hash.merge! Hash[keys.zip(values)]
+        end
+
+        hash.freeze
+      end
+
+      def parse_scheme_header!(response)
+        if (count = response.take_while{|x| x[0].chr == MSG_SCHEME}.size) > 0
+          header = response.shift(count).collect{|x| x.gsub(/(^#{MSG_SCHEME}\s+|\s+#[^#]+$)/, "").split(/,?\s+/)}
+          to_scheme_header_hash header
+        end
+      end
+
+      def to_scheme_header_hash(header)
+        table_name = header[0][0]
+        column_names = header[1]
+        column_types = header[2].collect(&:to_sym)
+        column_lengths = header[3].collect(&:to_i)
+
+        {:table_name => table_name, :column_names => column_names, :column_types => column_types, :column_lengths => column_lengths}.freeze
+      end
+
+      def parse_rows(table_header, response)
+        column_types = table_header[:column_types]
+        response.split("\t]\n").collect do |row|
+          parsed, values = [], row.slice(1..-1).split(",\t")
+          values.each_with_index do |value, index|
+            parsed << parse_value(column_types[index], value.strip)
+          end
+          parsed
+        end
+      end
+
+      def parse_value(type, value)
+        unless value == "NULL"
+          case type
+          when :varchar, :text
+            parse_string_value value
+          when :int, :smallint, :bigint
+            parse_integer_value value
+          when :double, :float, :real
+            parse_float_value value
+          when :date
+            parse_date_value value
+          when :timestamp
+            parse_date_time_value value
+          when :tinyint
+            parse_boolean_value value
+          else
+            raise NotImplementedError, "Cannot parse value of type #{type}"
+          end
+        end
+      end
+
+      def parse_string_value(value)
+        value.slice(1..-2).force_encoding("UTF-8")
+      end
+
+      def parse_integer_value(value)
+        value.to_i
+      end
+
+      def parse_float_value(value)
+        value.to_f
+      end
+
+      def parse_date_value(value)
+        Date.new *value.split("-").collect(&:to_i)
+      end
+
+      def parse_date_time_value(value)
+        date, time = value.split(" ")
+        Time.new *(date.split("-") + time.split(":")).collect(&:to_i)
+      end
+
+      def parse_boolean_value(value)
+        value == "1"
+      end
+
+    end
+  end
+end

data/lib/monetdb/connection/setup.rb

@@ -0,0 +1,125 @@
+module MonetDB
+  class Connection
+    module Setup
+    private
+
+      def setup
+        authenticate
+        set_timezone_interval
+        set_reply_size
+      end
+
+      def authenticate
+        obtain_server_challenge!
+
+        write authentication_string
+        response = read
+
+        case msg_chr(response)
+        when MSG_ERROR
+          raise MonetDB::AuthenticationError, "Authentication failed: #{response}"
+        when MSG_REDIRECT
+          authentication_redirect response
+        else
+          @authentication_redirects = nil
+          true
+        end
+      end
+
+      def obtain_server_challenge!
+        config.merge! server_challenge
+        assert_supported_protocol!
+        select_supported_auth_type!
+      end
+
+      def server_challenge
+        keys_and_values = [:salt, :server_name, :protocol, :auth_types, :server_endianness, :password_digest_method].zip read.split(":")
+        Hash[keys_and_values]
+      end
+
+      def assert_supported_protocol!
+        unless PROTOCOLS.include?(config[:protocol])
+          raise MonetDB::ProtocolError, "Protocol '#{config[:protocol]}' not supported. Only #{PROTOCOLS.collect{|x| "'#{x}'"}.join(", ")}."
+        end
+      end
+
+      def select_supported_auth_type!
+        unless config[:auth_type] = (AUTH_TYPES & (auth_types = config[:auth_types].split(","))).first
+          raise MonetDB::AuthenticationError, "Authentication types (#{auth_types.join(", ")}) not supported. Only #{AUTH_TYPES.join(", ")}."
+        end
+      end
+
+      def authentication_string
+        [ENDIANNESS, config[:username], "{#{config[:auth_type]}}#{authentication_hashsum}", LANG, config[:database], ""].join(":")
+      end
+
+      def authentication_hashsum
+        auth_type, password, password_digest_method = config.values_at(:auth_type, :password, :password_digest_method)
+
+        case auth_type
+        when AUTH_MD5, AUTH_SHA512, AUTH_SHA384, AUTH_SHA256, AUTH_SHA1
+          password = hexdigest(password_digest_method, password) if config[:protocol] == MAPI_V9
+          hexdigest(auth_type, password + config[:salt])
+        when AUTH_PLAIN
+          config[:password] + config[:salt]
+        end
+      end
+
+      def hexdigest(method, value)
+        Digest.const_get(method).new.hexdigest(value)
+      end
+
+      def authentication_redirect(response)
+        unless response.split("\n").detect{|x| x.match(/^\^mapi:(.*)/)}
+          raise MonetDB::AuthenticationError, "Authentication redirect not supported: #{response}"
+        end
+
+        begin
+          scheme, userinfo, host, port, registry, database = URI.split(uri = $1)
+        rescue URI::InvalidURIError
+          raise MonetDB::AuthenticationError, "Invalid authentication redirect URI: #{uri}"
+        end
+
+        case scheme
+        when "merovingian"
+          if (@authentication_redirects ||= 0) < 5
+            @authentication_redirects += 1
+            authenticate
+          else
+            raise MonetDB::AuthenticationError, "Merovingian: Too many redirects while proxying"
+          end
+        when "monetdb"
+          config[:host] = host
+          config[:port] = port
+          connect
+        else
+          raise MonetDB::AuthenticationError, "Cannot authenticate"
+        end
+      end
+
+      def set_timezone_interval
+        return false if @timezone_interval_set
+
+        offset = Time.now.gmt_offset / 3600
+        interval = "'+#{offset.to_s.rjust(2, "0")}:00'"
+
+        write "sSET TIME ZONE INTERVAL #{interval} HOUR TO MINUTE;"
+        response = read
+
+        raise CommandError, "Unable to set timezone interval: #{response}" if msg?(response, MSG_ERROR)
+        @timezone_interval_set = true
+      end
+
+      def set_reply_size
+        return false if @reply_size_set
+
+        write "Xreply_size #{REPLY_SIZE}\n"
+        response = read
+
+        raise CommandError, "Unable to set reply size: #{response}" if msg?(response, MSG_ERROR)
+        @reply_size_set = true
+      end
+
+    end
+  end
+end

data/lib/monetdb/error.rb

@@ -1,27 +1,21 @@
-class MonetDB
+module MonetDB
 
   class Error < StandardError
-    def initialize(e)
-      $stderr.puts e
-    end
   end
 
-  class QueryError < Error
-  end
-
-  class DataError < Error
+  class ConnectionError < Error
   end
 
-  class CommandError < Error
+  class ProtocolError < Error
   end
 
-  class ConnectionError < Error
+  class AuthenticationError < Error
   end
 
-  class SocketError < Error
+  class CommandError < Error
   end
 
-  class ProtocolError < Error
+  class QueryError < Error
   end
 
 end

data/lib/monetdb/version.rb

@@ -1,7 +1,7 @@
-class MonetDB
+module MonetDB
   MAJOR = 0
-  MINOR = 1
-  TINY  = 3
+  MINOR = 2
+  TINY  = 0
 
   VERSION = [MAJOR, MINOR, TINY].join(".")
 end

data/monetdb.gemspec

@@ -4,8 +4,8 @@ require File.expand_path("../lib/monetdb/version", __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ["Paul Engel"]
   gem.email         = ["pm_engel@icloud.com"]
-  gem.summary       = %q{A pure Ruby database driver for MonetDB}
-  gem.description   = %q{A pure Ruby database driver for MonetDB}
+  gem.summary       = %q{A pure Ruby database driver for MonetDB (monetdb5-sql)}
+  gem.description   = %q{A pure Ruby database driver for MonetDB (monetdb5-sql)}
   gem.homepage      = "https://github.com/archan937/monetdb"
 
   gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
@@ -15,9 +15,12 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   gem.version       = MonetDB::VERSION
 
+  gem.add_dependency "activesupport"
+
   gem.add_development_dependency "rake"
+  gem.add_development_dependency "yard"
   gem.add_development_dependency "pry"
   gem.add_development_dependency "simplecov"
   gem.add_development_dependency "minitest"
   gem.add_development_dependency "mocha"
-end
+end

data/script/console

@@ -3,5 +3,20 @@
 require "bundler"
 Bundler.require :default, :development
 
+QUERY = "SELECT * FROM stats LIMIT 2000"
+LOGIN = {
+  "host" => "localhost",
+  "port" => 50000,
+  "database" => "my_monetdb",
+  "username" => "monetdb",
+  "password" => "monetdb"
+}
+
+MonetDB.establish_connection LOGIN
+
+def query
+  MonetDB.connection.query QUERY
+end
+
 puts "Loading MonetDB development environment (#{MonetDB::VERSION})"
-Pry.start
+Pry.start

data/test/test_helper.rb

@@ -10,3 +10,6 @@ end
 
 require "bundler"
 Bundler.require :default, :development, :test
+
+require_relative "test_helper/minitest"
+require_relative "test_helper/simple_connection"

data/test/test_helper/minitest.rb

@@ -0,0 +1,7 @@
+class MiniTest::Test
+  def teardown
+    MonetDB.instance_variables.each do |name|
+      MonetDB.instance_variable_set name, nil
+    end
+  end
+end

data/test/test_helper/simple_connection.rb

@@ -0,0 +1,13 @@
+class SimpleConnection
+  attr_reader :config
+
+  def initialize
+    @config = {
+      :host => "localhost",
+      :port => 50000,
+      :username => "monetdb",
+      :password => "monetdb"
+    }
+  end
+
+end

data/test/unit/connection/test_messages.rb

@@ -0,0 +1,48 @@
+require_relative "../../test_helper"
+
+module Unit
+  module Connection
+    class TestSetup < MiniTest::Test
+
+      class Connection < SimpleConnection
+        include MonetDB::Connection::Messages
+      end
+
+      describe MonetDB::Connection::Messages do
+        before do
+          @connection = Connection.new
+        end
+
+        describe "#msg_chr" do
+          describe "when passing an empty string" do
+            it "returns an empty string" do
+              assert_equal "", @connection.send(:msg_chr, "")
+            end
+          end
+
+          describe "when passing a non-empty string" do
+            it "returns the first character" do
+              assert_equal " ", @connection.send(:msg_chr, "   ")
+              assert_equal "%", @connection.send(:msg_chr, "%foobar")
+            end
+          end
+        end
+
+        describe "#msg?" do
+          it "verifies whether the passed string matches the passed message character" do
+            assert_equal true , @connection.send(:msg?, "!syntax error", MonetDB::Connection::MSG_ERROR)
+            assert_equal false, @connection.send(:msg?, "!syntax error", MonetDB::Connection::MSG_PROMPT)
+
+            assert_equal true , @connection.send(:msg?, "", MonetDB::Connection::MSG_PROMPT)
+            assert_equal false, @connection.send(:msg?, "", MonetDB::Connection::MSG_ERROR)
+
+            @connection.expects(:msg_chr).with("foo").twice.returns("!")
+            assert_equal true , @connection.send(:msg?, "foo", MonetDB::Connection::MSG_ERROR)
+            assert_equal false, @connection.send(:msg?, "foo", MonetDB::Connection::MSG_PROMPT)
+          end
+        end
+      end
+
+    end
+  end
+end