monetdb 0.1.3 → 0.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZWY3ZDg1YzZlMDc5MDk4YTIyNWIwMmZlMjBhNzhmYTFhZGZiYjhhZg==
-  data.tar.gz: !binary |-
-    NjJiZWNiZDM2MjA5Zjg2ZmNkNGU1YTllNmU2YjA5MjkwYjNjNWEzMw==
+SHA1:
+  metadata.gz: b124803dcab2b1006f95c5bfd252d1982350ae6c
+  data.tar.gz: 7472c8d1410fa5cd5e39bb79dea8059c43d5ba7a
 SHA512:
-  metadata.gz: !binary |-
-    NmEyNTZjNDE2NWQ5ZjIyOTMyZTNjM2NiOGQ0MWMwMjBkMjFjYTdkZWViZDUx
-    ZGVjNzM1OWQ1YjFiNGZkNDVkYzUyYTlkOTZkODNlMDhhNjQyMjk4NTJlMDUx
-    YWM1ZGYzMTdiMTlhNThmNGYzMjU0OThlY2MzYzYwZjAwZjFjZWU=
-  data.tar.gz: !binary |-
-    ZjY3NTY2ZDMzYzAzMGRhNTU4MTM2YzEwZTg2OWFiZGY1MDU1ZGZjMzUwMWVi
-    MTMwNThmMTI1N2FlYWQ2OGNhZjI4ZmQ5MWYzZjNiYTMxMjEzYTk3YWE2NDQx
-    ZGNiOTNhN2JmOGUzOTRjODY1NGVhY2EyYzNjZDBjOTc4NzQ3ZTM=
+  metadata.gz: b894e704798f71cd4791a4c019fde839a69cb75c89d30073210c8032e0e8e042da347cf786bdb8615dd86a26fe946994f6513e0d9b4ed238811da96f8ef44f71
+  data.tar.gz: 7bc0cd53a34cf88e7c85c5ede1343fe35e3a63ab9659b9c427a7a582f6a2df33f93f167703bd3d434cff036914faea273ce6d450ca282846428fb9ccfe29d69e

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.0.0
+  - 1.9.3

data/CHANGELOG.rdoc

@@ -1,5 +1,9 @@
 = MonetDB CHANGELOG
 
+== Version 0.2.0 (October 13, 2014)
+
+* Complete rewrite of the gem (only focussed on querying data using SQL)
+
 == Version 0.1.3 (October 8, 2014)
 
 * Corrected MonetDB#select_rows (was not fetching entire result set)

data/Gemfile

@@ -1,18 +1,3 @@
 source "https://rubygems.org"
 
 gemspec
-
-group :development do
-  gem "yard"
-end
-
-group :development, :test do
-  gem "monetdb", :path => "."
-  gem "pry"
-end
-
-group :test do
-  gem "simplecov", :require => false
-  gem "minitest"
-  gem "mocha"
-end

data/README.rdoc

@@ -1,6 +1,6 @@
-== MonetDB
+== MonetDB {<img src="https://secure.travis-ci.org/archan937/monetdb.png"/>}[http://travis-ci.org/archan937/monetdb] {<img src="https://codeclimate.com/github/archan937/monetdb/badges/gpa.svg"/>}[https://codeclimate.com/github/archan937/monetdb]
 
-A pure Ruby database driver for MonetDB (monetdb5).
+A pure Ruby database driver for MonetDB (monetdb5-sql).
 
 === Installation
 

data/Rakefile

@@ -7,4 +7,4 @@ task :default => :test
 
 Rake::TestTask.new do |test|
   test.pattern = "test/**/test_*.rb"
-end
+end

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.2.0

data/lib/monetdb.rb

@@ -1,118 +1,10 @@
-require "monetdb/core_ext"
-require "monetdb/hasher"
+require "active_support/core_ext/hash/reverse_merge"
+
 require "monetdb/connection"
-require "monetdb/transaction"
-require "monetdb/data"
 require "monetdb/error"
 require "monetdb/version"
 
-# A typical sequence of events is as follows: Create a database instance (handle), invoke query using the database handle to send the statement to the server and get back a result set object.
-#
-# A result set object is an instance of the MonetDB::Data class and has methods for fetching rows, moving around in the result set, obtaining column metadata, and releasing the result set.
-#
-# Records can be returned as arrays and iterators over the set.
-#
-# A database handler (dbh) is an instance of the MonetDB class.
-#
-#
-# = Connection management
-#
-#   connect       - establish a new connection
-#                   * user      : username (default is monetdb)
-#                   * passwd    : password (default is monetdb)
-#                   * lang      : language (default is sql)
-#                   * host      : server hostanme or ip  (default is localhost)
-#                   * port      : server port (default is 50000)
-#                   * db_name   : name of the database to connect to
-#                   * auth_type : hashing function to use during authentication (default is SHA1)
-#   connected?    - returns true if there is an active connection to a server, false otherwise
-#   reconnect     - reconnect to a server
-#   close         - terminate a connection
-#   auto_commit?  - returns ture if the session is running in auto commit mode, false otherwise
-#   auto_commit   - enable/disable auto commit mode
-#   query         - fire a query
-#
-# Currently MAPI protocols 8 and 9 are supported.
-#
-#
-# = Managing record sets
-#
-# A record set is represented as an instance of the MonetDB::Data class; the class provides methods to manage retrieved data.
-#
-# The following methods allow to iterate over data:
-#
-#   fetch          - iterates over the record set and retrieves on row at a time. Each row is returned as an array
-#   fetch_hash     - iterates over columns (on cell at a time)
-#   fetch_all_hash - returns record set entries hashed by column name orderd by column position
-#
-# To return the record set as an array (with each tuple stored as array of fields) the following method can be used:
-#
-#   fetch_all      - fetch all rows and store them
-#
-# Information about the retrieved record set can be obtained via the following methods:
-#
-#   num_rows       - returns the number of rows present in the record set
-#   num_fields     - returns the number of fields (columns) that compose the schema
-#   name_fields    - returns the (ordered) name of the schema's columns
-#   type_fields    - returns the (ordered) types list of the schema's columns
-#
-# To release a record set MonetDB::Data#free can be used.
-#
-#
-# = Type conversion
-#
-# A mapping between SQL and ruby type is supported. Each retrieved field can be converted to a ruby datatype via
-# a getTYPE method.
-#
-# The currently supported cast methods are:
-#
-#   getInt        - convert to an integer value
-#   getFloat      - convert to a floating point value
-#   getString     - return a string representation of the value, with trailing and leading " characters removed
-#   getBlob       - convert an SQL stored HEX string to its binary representation
-#   getTime       - return a string representation of a TIME field
-#   getDate       - return a string representation of a DATE field
-#   getDateTime   - convert a TIMESTAMP field to a ruby Time object
-#   getChar       - on Ruby >= 1.9, convert a CHAR field to char
-#   getBool       - convert a BOOLEAN field to a ruby bool object. If the value of the field is unknown, nil is returned
-#   getNull       - convert a NULL value to a nil object
-#
-#
-# = Transactions
-#
-# By default MonetDB works in auto_commit mode. To turn this feature off MonetDB#auto_commit(flag = false) can be used.
-#
-# Once auto_commit has been disabled it is possible to start transactions, create/delete savepoints, rollback and commit with
-# the usual SQL statements.
-#
-# Savepoints IDs can be generated using the MonetDB#save method. To release a savepoint ID use MonetDB#release.
-#
-# You can access savepoints (as a stack) with the MonetDB#transactions method.
-#
-
-class MonetDB
-
-  Q_TABLE             = "1" # SELECT operation
-  Q_UPDATE            = "2" # INSERT/UPDATE operations
-  Q_CREATE            = "3" # CREATE/DROP TABLE operations
-  Q_TRANSACTION       = "4" # TRANSACTION
-  Q_PREPARE           = "5" # QPREPARE message
-  Q_BLOCK             = "6" # QBLOCK message
-
-  MSG_REDIRECT        = "^" # auth redirection through merovingian
-  MSG_QUERY           = "&"
-  MSG_SCHEMA_HEADER   = "%"
-  MSG_INFO            = "!" # info response from mserver
-  MSG_TUPLE           = "["
-  MSG_PROMPT          = ""
-
-  REPLY_SIZE          = "-1"
-  MAX_AUTH_ITERATION  = 10  # maximum number of auth iterations (through merovingian) allowed
-  MONET_ERROR         = -1
-
-  LANG_SQL            = "sql"
-  LANG_XQUERY         = "xquery"
-  XQUERY_OUTPUT_SEQ   = true # use MonetDB XQuery's output seq
+module MonetDB
 
   def self.logger=(logger)
     @logger = logger
@@ -133,13 +25,10 @@ class MonetDB
   def self.establish_connection(arg)
     config = arg.is_a?(Hash) ? arg : (configurations || {})[arg.to_s]
     if config
-      @connection = MonetDB.new.tap do |connection|
-        config = {language: "sql", encryption: "SHA1"}.merge(config.inject({}){|h, (k, v)| h[k.to_sym] = v; h})
-        connection.instance_variable_set(:@config, config)
-        connection.connect *config.values_at(:username, :password, :language, :host, :port, :database, :encryption)
-      end
+      @connection = Connection.new(config)
+      @connection.connect
     else
-      raise Error, "Unable to establish connection for #{arg.inspect}"
+      raise ConnectionError, "Unable to establish connection for #{arg.inspect}"
     end
   end
 
@@ -147,142 +36,4 @@ class MonetDB
     @connection
   end
 
-  # Establish a new connection.
-  #   * user      : username (default is monetdb)
-  #   * passwd    : password (default is monetdb)
-  #   * lang      : language (default is sql)
-  #   * host      : server hostanme or ip  (default is localhost)
-  #   * port      : server port (default is 50000)
-  #   * db_name   : name of the database to connect to
-  #   * auth_type : hashing function to use during authentication (default is SHA1)
-  def connect(username = "monetdb", password = "monetdb", lang = "sql", host = "127.0.0.1", port = "50000", db_name = "test", auth_type = "SHA1")
-    # TODO: Handle pools of connections
-    @username = username
-    @password = password
-    @lang = lang
-    @host = host
-    @port = port
-    @db_name = db_name
-    @auth_type = auth_type
-    @connection = MonetDB::Connection.new(user = @username, passwd = @password, lang = @lang, host = @host, port = @port)
-    @connection.connect(@db_name, @auth_type)
-  end
-
-  # Send a <b>user submitted</b> query to the server and store the response.
-  #
-  # Returns an instance of MonetDB::Data.
-  def query(q = "")
-    unless @connection.nil?
-      @data = MonetDB::Data.new(@connection)
-      @data.execute(q)
-    end
-    @data
-  end
-
-  # Send a <b>user submitted select</b> query to the server and store the response.
-  #
-  # Returns an array of arrays with casted values.
-  def select_rows(qry)
-    return if @connection.nil?
-    data = MonetDB::Data.new @connection
-
-    start = Time.now
-    @connection.send(data.send(:format_query, qry))
-    response = @connection.receive.split("\n")
-
-    if (row = response[0]).chr == MSG_INFO
-      raise QueryError, row
-    end
-
-    headers, rows = response.partition{|x| [MSG_SCHEMA_HEADER, MSG_QUERY].include? x[0]}
-    data.send :receive_record_set, headers.join("\n")
-    query_header = data.send :parse_header_query, headers.shift
-    table_header = data.send :parse_header_table, headers
-    rows = rows.join("\n")
-
-    row_count = rows.split("\t]\n").size
-    while row_count < query_header["rows"].to_i
-      received = @connection.receive
-      row_count += received.scan("\t]\n").size
-      rows << received
-    end
-    rows = rows.split("\t]\n")
-
-    log :info, "\n  SQL (#{((Time.now - start) * 1000).round(1)}ms)  #{qry}"
-
-    column_types = table_header["columns_type"]
-    types = table_header["columns_name"].collect{|x| column_types[x]}
-
-    rows.collect do |row|
-      parsed, values = [], row.gsub(/^\[\s*/, "").split(",\t")
-      values.each_with_index do |value, index|
-        parsed << begin
-          unless value.strip == "NULL"
-            case types[index]
-            when "bigint", "int"
-              value.to_i
-            when "double"
-              value.to_f
-            else
-              value.strip.gsub(/(^"|"$|\\|\")/, "").force_encoding("UTF-8")
-            end
-          end
-        end
-      end
-      parsed
-    end
-  end
-
-  # Returns whether a "connection" object exists.
-  def connected?
-    !@connection.nil?
-  end
-
-  # Reconnect to the server.
-  def reconnect
-    if @connection != nil
-      self.close
-      @connection = MonetDB::Connection.new(user = @username, passwd = @password, lang = @lang, host = @host, port = @port)
-      @connection.connect(db_name = @db_name, auth_type = @auth_type)
-    end
-  end
-
-  # Turn auto commit on/off.
-  def auto_commit(flag = true)
-    @connection.set_auto_commit(flag)
-  end
-
-  # Returns the current auto commit (on/off) setting.
-  def auto_commit?
-    @connection.auto_commit?
-  end
-
-  # Returns the name of the last savepoint in a transactions pool.
-  def transactions
-    @connection.savepoint
-  end
-
-  # Create a new savepoint ID.
-  def save
-    @connection.transactions.save
-  end
-
-  # Release a savepoint ID.
-  def release
-    @connection.transactions.release
-  end
-
-  # Close an active connection.
-  def close
-    @connection.disconnect
-    @connection = nil
-  end
-
-private
-
-  # Log message.
-  def log(type, msg)
-    MonetDB.logger.send type, msg  if MonetDB.logger
-  end
-
 end

data/lib/monetdb/connection.rb

@@ -1,442 +1,124 @@
 require "socket"
-require "time"
-require "uri"
+require "monetdb/connection/messages"
+require "monetdb/connection/setup"
+require "monetdb/connection/query"
 
-#
-# Implements the MAPI communication protocol
-#
-
-class MonetDB
+module MonetDB
   class Connection
 
-    # enable debug output
-    @@DEBUG               = false
-
-    # hour in seconds, used for timezone calculation
-    @@HOUR                = 3600
-
-    # maximum size (in bytes) for a monetdb message to be sent
-    @@MAX_MESSAGE_SIZE    = 32766
-
-    # endianness of a message sent to the server
-    @@CLIENT_ENDIANNESS   = "BIG"
-
-    # MAPI protocols supported by the driver
-    @@SUPPORTED_PROTOCOLS = [8, 9]
-
-    attr_reader :socket, :auto_commit, :transactions, :lang
-
-    # A new instance of MonetDB::Connection.
-    #  * user   : username (default is monetdb)
-    #  * passwd : password (default is monetdb)
-    #  * lang   : language (default is sql)
-    #  * host   : server hostanme or ip (default is localhost)
-    #  * port   : server port (default is 50000)
-    def initialize(user = "monetdb", passwd = "monetdb", lang = "sql", host = "127.0.0.1", port = "50000")
-      @user = user
-      @passwd = passwd
-      @lang = lang.downcase
-      @host = host
-      @port = port
-
-      @client_endianness = @@CLIENT_ENDIANNESS
-      @auth_iteration = 0
-      @connection_established = false
-      @transactions = MonetDB::Transaction.new
-    end
-
-    # Connect to the database, creates a new socket.
-    def connect(db_name = "demo", auth_type = "SHA1")
-      @database = db_name
-      @auth_type = auth_type
-      @socket = TCPSocket.new(@host, @port.to_i)
-
-      if real_connect
-        if @lang == LANG_SQL
-          set_timezone
-          set_reply_size
-        elsif (@lang == LANG_XQUERY) and XQUERY_OUTPUT_SEQ
-          # require xquery output to be in seq format
-          send(format_command("output seq"))
-        end
-        true
-      else
-        false
-      end
-    end
-
-    # Perform a real connection; retrieve challenge, proxy through merovinginan, build challenge and set the timezone.
-    def real_connect
-      server_challenge = retrieve_server_challenge()
-
-      if server_challenge != nil
-        salt = server_challenge.split(':')[0]
-        @server_name = server_challenge.split(':')[1]
-        @protocol = server_challenge.split(':')[2].to_i
-        @supported_auth_types = server_challenge.split(':')[3].split(',')
-        @server_endianness = server_challenge.split(':')[4]
-        if @protocol == 9
-          @pwhash = server_challenge.split(':')[5]
-        end
-      else
-        raise MonetDB::ConnectionError, "Error: server returned an empty challenge string."
-      end
-
-      # The server supports only RIPMED168 or crypt as an authentication hash function, but the driver does not.
-      if @supported_auth_types.length == 1
-        auth = @supported_auth_types[0]
-        if auth.upcase == "RIPEMD160" or auth.upcase == "CRYPT"
-          raise MonetDB::ConnectionError, auth.upcase + " " + ": algorithm not supported by ruby-monetdb."
-        end
-      end
-
-      # If the server protocol version is not 8: abort and notify the user.
-      if @@SUPPORTED_PROTOCOLS.include?(@protocol) == false
-        raise MonetDB::ProtocolError, "Protocol not supported. The current implementation of ruby-monetdb works with MAPI protocols #{@@SUPPORTED_PROTOCOLS} only."
-
-      elsif mapi_proto_v8?
-        reply = build_auth_string_v8(@auth_type, salt, @database)
-      elsif mapi_proto_v9?
-        reply = build_auth_string_v9(@auth_type, salt, @database)
-      end
-
-      if @socket != nil
-        @connection_established = true
-
-        send(reply)
-        monetdb_auth = receive
-
-        if monetdb_auth.length == 0
-          # auth succedeed
-          true
-        else
-          if monetdb_auth[0].chr == MSG_REDIRECT
-          #redirection
-
-            redirects = [] # store a list of possible redirects
-
-            monetdb_auth.split('\n').each do |m|
-              # strip the trailing ^mapi:
-              # if the redirect string start with something != "^mapi:" or is empty, the redirect is invalid and shall not be included.
-              if m[0..5] == "^mapi:"
-                redir = m[6..m.length]
-                # url parse redir
-                redirects.push(redir)
-              else
-                $stderr.print "Warning: Invalid Redirect #{m}"
-              end
-            end
-
-            if redirects.size == 0
-              raise MonetDB::ConnectionError, "No valid redirect received"
-            else
-              begin
-                uri = URI.split(redirects[0])
-                # Splits the string on following parts and returns array with result:
-                #
-                #  * Scheme
-                #  * Userinfo
-                #  * Host
-                #  * Port
-                #  * Registry
-                #  * Path
-                #  * Opaque
-                #  * Query
-                #  * Fragment
-                server_name = uri[0]
-                host   = uri[2]
-                port   = uri[3]
-                database   = uri[5].gsub(/^\//, '') if uri[5] != nil
-              rescue URI::InvalidURIError
-                raise MonetDB::ConnectionError, "Invalid redirect: #{redirects[0]}"
-              end
-            end
-
-            if server_name == "merovingian"
-              if @auth_iteration <= 10
-                @auth_iteration += 1
-                real_connect
-              else
-                raise MonetDB::ConnectionError, "Merovingian: too many iterations while proxying."
-              end
-            elsif server_name == "monetdb"
-              begin
-                @socket.close
-              rescue
-                raise MonetDB::ConnectionError, "I/O error while closing connection to #{@socket}"
-              end
-              # reinitialize a connection
-              @host = host
-              @port = port
-
-              connect(database, @auth_type)
-            else
-              @connection_established = false
-              raise MonetDB::ConnectionError, monetdb_auth
-            end
-          elsif monetdb_auth[0].chr == MSG_INFO
-            raise MonetDB::ConnectionError, monetdb_auth
-          end
-        end
-      end
-    end
-
-    def savepoint
-      @transactions.savepoint
-    end
-
-    # Formats a <i>command</i> string so that it can be parsed by the server.
-    def format_command(x)
-      "X" + x + "\n"
-    end
-
-    # Send an 'export' command to the server.
-    def set_export(id, idx, offset)
-      send(format_command("export " + id.to_s + " " + idx.to_s + " " + offset.to_s ))
+    include Messages
+    include Setup
+    include Query
+
+    Q_TABLE        = "1" # SELECT statement
+    Q_UPDATE       = "2" # INSERT/UPDATE statement
+    Q_CREATE       = "3" # CREATE/DROP TABLE statement
+    Q_TRANSACTION  = "4" # TRANSACTION
+    Q_PREPARE      = "5" # QPREPARE message
+    Q_BLOCK        = "6" # QBLOCK message
+
+    MSG_PROMPT     = ""
+    MSG_ERROR      = "!"
+    MSG_REDIRECT   = "^"
+    MSG_QUERY      = "&"
+    MSG_SCHEME     = "%"
+    MSG_TUPLE      = "["
+
+    ENDIANNESS     = "BIG"
+    LANG           = "sql"
+    REPLY_SIZE     = "-1"
+    MAX_MSG_SIZE   = 32766
+
+    MAPI_V8        = "8"
+    MAPI_V9        = "9"
+    PROTOCOLS      = [MAPI_V8, MAPI_V9]
+
+    AUTH_MD5       = "MD5"
+    AUTH_SHA512    = "SHA512"
+    AUTH_SHA384    = "SHA384"
+    AUTH_SHA256    = "SHA256"
+    AUTH_SHA1      = "SHA1"
+    AUTH_PLAIN     = "PLAIN"
+    AUTH_TYPES     = [AUTH_MD5, AUTH_SHA512, AUTH_SHA384, AUTH_SHA256, AUTH_SHA1, AUTH_PLAIN]
+
+    def initialize(config = {})
+      @config = {
+        :host => "localhost",
+        :port => 50000,
+        :username => "monetdb",
+        :password => "monetdb"
+      }.merge(
+        config.inject({}){|h, (k, v)| h[k.to_sym] = v; h}
+      )
+    end
+
+    def connect
+      disconnect if connected?
+      @socket = TCPSocket.new config[:host], config[:port].to_i
+      setup
+      true
+    end
+
+    def connected?
+      !socket.nil?
     end
 
-    # Send a 'reply_size' command to the server.
-    def set_reply_size
-      send(format_command(("reply_size " + REPLY_SIZE)))
-      response = receive
-
-      if response == MSG_PROMPT
-        true
-      elsif response[0] == MSG_INFO
-        raise MonetDB::CommandError, "Unable to set reply_size: #{response}"
-      end
-    end
-
-    def set_output_seq
-      send(format_command("output seq"))
-    end
-
-    # Disconnect from server.
     def disconnect
-      if @connection_established
-        begin
-          @socket.close
-        rescue => e
-          $stderr.print e
-        end
-      else
-        raise MonetDB::ConnectionError, "No connection established."
-      end
-    end
-
-    # Send data to a monetdb5 server instance and returns server response.
-    def send(data)
-      encode_message(data).each do |m|
-        @socket.write(m)
-      end
+      socket.disconnect if connected?
+      @socket = nil
     end
 
-    # Receive data from a monetdb5 server instance.
-    def receive
-      is_final, chunk_size = recv_decode_hdr
-
-      if chunk_size == 0
-        return "" # needed on ruby-1.8.6 linux/64bit; recv(0) hangs on this configuration.
-      end
-
-      data = @socket.recv(chunk_size)
+  private
 
-      if is_final == false
-        while is_final == false
-          is_final, chunk_size = recv_decode_hdr
-          data +=  @socket.recv(chunk_size)
-        end
-      end
-
-      data
+    def config
+      @config
     end
 
-    # Build and authentication string given the parameters submitted by the user (MAPI protocol v8).
-    def build_auth_string_v8(auth_type, salt, db_name)
-      # seed = password + salt
-      if (auth_type.upcase == "MD5" or auth_type.upcase == "SHA1") and @supported_auth_types.include?(auth_type.upcase)
-        auth_type = auth_type.upcase
-        digest = Hasher.new(auth_type, @passwd+salt)
-        hashsum = digest.hashsum
-      elsif auth_type.downcase == "plain" or not  @supported_auth_types.include?(auth_type.upcase)
-        auth_type = 'plain'
-        hashsum = @passwd + salt
-
-      elsif auth_type.downcase == "crypt"
-        auth_type =  @supported_auth_types[@supported_auth_types.index(auth_type)+1]
-        $stderr.print "The selected hashing algorithm is not supported by the Ruby driver. #{auth_type} will be used instead."
-        digest = Hasher.new(auth_type, @passwd+salt)
-        hashsum = digest.hashsum
-      else
-        # The user selected an auth type not supported by the server.
-        raise MonetDB::ConnectionError, "#{auth_type} not supported by the server. Please choose one from #{@supported_auth_types}"
-
-      end
-      # Build the reply message with header
-      reply = @client_endianness + ":" + @user + ":{" + auth_type + "}" + hashsum + ":" + @lang + ":" + db_name + ":"
+    def socket
+      @socket
     end
 
-    # Build and authentication string given the parameters submitted by the user (MAPI protocol v9).
-    def build_auth_string_v9(auth_type, salt, db_name)
-      if (auth_type.upcase == "MD5" or auth_type.upcase == "SHA1") and @supported_auth_types.include?(auth_type.upcase)
-        auth_type = auth_type.upcase
-        # Hash the password
-        pwhash = Hasher.new(@pwhash, @passwd)
-
-        digest = Hasher.new(auth_type, pwhash.hashsum + salt)
-        hashsum = digest.hashsum
-
-      elsif auth_type.downcase == "plain" # or not  @supported_auth_types.include?(auth_type.upcase)
-        # Keep it for compatibility with merovingian
-        auth_type = 'plain'
-        hashsum = @passwd + salt
-      elsif @supported_auth_types.include?(auth_type.upcase)
-        if auth_type.upcase == "RIPEMD160"
-          auth_type =  @supported_auth_types[@supported_auth_types.index(auth_type)+1]
-          $stderr.print "The selected hashing algorithm is not supported by the Ruby driver. #{auth_type} will be used instead."
-        end
-        # Hash the password
-        pwhash = Hasher.new(@pwhash, @passwd)
-
-        digest = Hasher.new(auth_type, pwhash.hashsum + salt)
-        hashsum = digest.hashsum
-      else
-        # The user selected an auth type not supported by the server.
-        raise MonetDB::ConnectionError, "#{auth_type} not supported by the server. Please choose one from #{@supported_auth_types}"
-      end
-      # Build the reply message with header
-      reply = @client_endianness + ":" + @user + ":{" + auth_type + "}" + hashsum + ":" + @lang + ":" + db_name + ":"
+    def log(type, msg)
+      MonetDB.logger.send(type, msg) if MonetDB.logger
     end
 
-    # Build a message to be sent to the server.
-    def encode_message(msg = "")
-      message = Array.new
-      data = ""
-
-      hdr = 0 # package header
-      pos = 0
-      is_final = false # last package in the stream
-
-      while (! is_final)
-        data = msg[pos..pos+[@@MAX_MESSAGE_SIZE.to_i, (msg.length - pos).to_i].min]
-        pos += data.length
+    def read
+      raise ConnectionError, "Not connected to server" unless connected?
 
-        if (msg.length - pos) == 0
-          last_bit = 1
-          is_final = true
-        else
-          last_bit = 0
-        end
+      length, last_chunk = read_length
+      data, iterations = "", 0
 
-        hdr = [(data.length << 1) | last_bit].pack('v')
-
-        message << hdr + data.to_s # Short Little Endian Encoding
+      while (length > 0) && (iterations < 1000) do
+        received = socket.recv(length)
+        data << received
+        length -= received.bytesize
+        iterations += 1
       end
+      data << read unless last_chunk
 
-      message.freeze # freeze and return the encode message
-    end
-
-    # Used as the first step in the authentication phase; retrieves a challenge string from the server.
-    def retrieve_server_challenge
-      server_challenge = receive
-    end
-
-    # Reads and decodes the header of a server message.
-    def recv_decode_hdr
-      if @socket != nil
-        fb = @socket.recv(1)
-        sb = @socket.recv(1)
-
-        # Use execeptions handling to keep compatibility between different ruby
-        # versions.
-        #
-        # Chars are treated differently in ruby 1.8 and 1.9
-        # try do to ascii to int conversion using ord (ruby 1.9)
-        # and if it fail fallback to character.to_i (ruby 1.8)
-        begin
-          fb = fb[0].ord
-          sb = sb[0].ord
-        rescue NoMethodError => one_eight
-          fb = fb[0].to_i
-          sb = sb[0].to_i
-        end
-
-        chunk_size = (sb << 7) | (fb >> 1)
-
-        is_final = false
-        if ( (fb & 1) == 1 )
-          is_final = true
-
-        end
-        # return the size of the chunk (in bytes)
-        return is_final, chunk_size
-      else
-        raise MonetDB::SocketError, "Error while receiving data\n"
-      end
+      data
     end
 
-    # Sets the time zone according to the Operating System settings.
-    def set_timezone
-      tz = Time.new
-      tz_offset = tz.gmt_offset / @@HOUR
-
-      if tz_offset <= 9 # verify minute count!
-        tz_offset = "'+0" + tz_offset.to_s + ":00'"
-      else
-        tz_offset = "'+" + tz_offset.to_s + ":00'"
-      end
-      query_tz = "sSET TIME ZONE INTERVAL " + tz_offset + " HOUR TO MINUTE;"
-
-      # Perform the query directly within the method
-      send(query_tz)
-      response = receive
-
-      if response == MSG_PROMPT
-        true
-      elsif response[0].chr == MSG_INFO
-        raise MonetDB::QueryError, response
-      end
+    def read_length
+      bytes = socket.recv(2).unpack("v")[0]
+      [(bytes >> 1), (bytes & 1) == 1]
     end
 
-    # Turns auto commit on/off.
-    def set_auto_commit(flag = true)
-      if flag == false
-        ac = " 0"
-      else
-        ac = " 1"
+    def write(message)
+      raise ConnectionError, "Not connected to server" unless connected?
+      pack(message).each do |chunk|
+        socket.write(chunk)
       end
-
-      send(format_command("auto_commit " + ac))
-      response = receive
-
-      if response == MSG_PROMPT
-        @auto_commit = flag
-      elsif response[0].chr == MSG_INFO
-        raise MonetDB::CommandError, response
-      end
-    end
-
-    # Check the auto commit status (on/off).
-    def auto_commit?
-      !!@auto_commit
-    end
-
-    # Check if monetdb is running behind the merovingian proxy and forward the connection in case.
-    def merovingian?
-      @server_name.downcase == "merovingian"
-    end
-
-    def mserver?
-      @server_name.downcase == "monetdb"
-    end
-
-    # Check which protocol is spoken by the server.
-    def mapi_proto_v8?
-      @protocol == 8
+      true
     end
 
-    def mapi_proto_v9?
-      @protocol == 9
+    def pack(message)
+      chunks = message.scan(/.{1,#{MAX_MSG_SIZE}}/m)
+      chunks.each_with_index.to_a.collect do |chunk, index|
+        last_bit = (index == chunks.size - 1) ? 1 : 0
+        length = [(chunk.size << 1) | last_bit].pack("v")
+        "#{length}#{chunk}"
+      end.freeze
     end
 
   end