ruby-monetdb-sql 0.1

data/README

@@ -0,0 +1,154 @@
+== Standalone driver ==
+This directory contains the a ruby interface to monetdb5 
+written in pure ruby.
+
+lib/MonetDB.rb
+lib/MonetDBConnection.rb
+lib/MonetDBStatements.rb
+lib/MonetDBData.rb
+lib/MonetDBExceptions.rb
+lib/hasher.rb
+lib/demo.rb: demo application how to interact with the database
+
+ruby-monetdb-sql-0.1.gemspec: make file for rubygems
+
+doc/: rubydoc in HTML format
+
+== Installation ==
+
+The standalone monetdb driver can be installed using the RubyGems Package Manager.
+
+First build a gem file starting from the gemspec configuration:
+
+$ gem build ruby-monetdb-sql-0.1.gemspec
+
+Then install with the command:
+
+$ gem install ruby-monetdb-sql-0.1.gem
+
+== Usage ==
+To use the standalone driver import the 'MonetDB' class and 'rubygems' (in case you installed it using gems).
+
+A typical sequence of events is as follows:
+Invoke query using the database handle to send the statement to the server and get back a result set object.
+
+A result set object  has methods for fetching rows, moving around in the result set, obtaining column metadata, and releasing the result set.
+Use a row fetching method such as fetch_row or an iterator such as each to access the rows of the result set.
+If you want a count of the number of rows in the result set: invoke 'num_rows' method.
+Invoke 'free' to release the result set. 
+
+== Example ==
+
+require 'MonetDB'
+
+db = MonetDB.new
+db.connect(user = "monetdb", passwd = "monetdb", lang = "sql", host="127.0.0.1", port = 50000, db_name = "demo", auth_type = "SHA1")
+
+# set type_cast=true to enable MonetDB to Ruby type mapping
+res = db.query("SELECT * from tables;", type_cast = false)
+
+#puts res.debug_columns_type
+
+puts "Number of rows returned: " + res.num_rows.to_s
+puts "Number of fields: " + res.num_fields.to_s
+
+
+# Get the columns' name
+col_names = res.name_fields
+
+
+# Iterate over the record set and retrieve on row at a time
+puts res.fetch
+while row = res.fetch do
+  printf "%s \n", row
+end
+
+# Release the result set.
+res.free
+
+# Disconnect from server
+db.close
+
+See lib/demo.rb and the MonetDBDatar class documentation for more examples.
+
+
+
+== ActiveRecord connector adapter ==
+Active Record connects business objects and database tables to create a persistable domain model where logic and data are presented in one wrapping. It‘s an implementation of the object-relational mapping (ORM) pattern.
+
+Required files:
+
+adapter/lib/active_record/monetdb_adapter.rb
+
+Usage example follows:
+require 'active_record'
+
+ActiveRecord::Base.logger = Logger.new(STDERR)
+ActiveRecord::Base.colorize_logging = true
+
+ActiveRecord::Base.establish_connection(
+        :adapter => "monetdb",
+        :host => "localhost",
+        :database => "demo"
+)
+
+# Create a new table
+class AddTests < ActiveRecord::Migration
+  def self.up
+    create_table :tests do |table|
+        table.column :name, :string
+        table.column :surname, :string
+    end
+  end
+
+  def self.down
+   drop_table :tests
+  end
+
+end
+
+AddTests.up
+
+# Migration: add a column name with a default value
+class AddAge < ActiveRecord::Migration 
+  def self.up
+    add_column :tests, :age, :smallint, :default => 18
+  end
+
+  def self.down
+    remove_column :tests, :age
+  end
+
+end
+
+class Test < ActiveRecord::Base
+end
+
+# Insert an entry in the table
+Test.create(:name => 'X', :surname => 'Y')
+
+# add a column
+AddAge.up
+
+# return the first result of the query SELECT * from tables
+row = Test.find(:first)
+printf "SELECT * from tests LIMIT 1:\n"
+printf "Name: %s, Surname: %s, Age: %s\n", row.name, row.surname, row.age
+
+# Drop the table
+AddTests.down
+
+== Rubygem ==
+
+The standalone ruby driver can be distributed as a ruby gem.
+A gem file is already available; however, it can be generated 
+starting from the ruby-monetdb-sql-0.1.gemspec file:
+
+$ gem build ruby-monetdb-sql-0.1.gemspec
+
+To install the file run the command:
+
+$ gem install ruby-monetdb-sql-0.1.gem
+
+Documentation in ri and html format will be generated and installed as well
+

data/lib/MonetDB.rb

@@ -0,0 +1,274 @@
+# The contents of this file are subject to the MonetDB Public License
+# Version 1.1 (the "License"); you may not use this file except in
+# compliance with the License. You may obtain a copy of the License at
+# http://monetdb.cwi.nl/Legal/MonetDBLicense-1.1.html
+#
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+# License for the specific language governing rights and limitations
+# under the License.
+#
+# The Original Code is the MonetDB Database System.
+#
+# The Initial Developer of the Original Code is CWI.
+# Portions created by CWI are Copyright (C) 1997-July 2008 CWI.
+# Copyright August 2008-2011 MonetDB B.V.
+# All Rights Reserved.
+
+
+# A typical sequence of events is as follows:
+# Fire a query using the database handle to send the statement to the server and get back a result set object.
+
+# A result set object  has methods for fetching rows, moving around in the result set, obtaining column metadata, and releasing the result set.
+# Use a row fetching method such as 'fetch_row' or an iterator such as each to access the rows of the result set.
+# Call 'free' to release the result set. 
+
+
+#module MonetDB
+
+  require 'MonetDBConnection'
+  require 'MonetDBData'
+  require 'MonetDBExceptions'
+  
+    # = Introduction
+    #
+    # 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  has methods for fetching rows, moving around in the result set, obtaining column metadata, and releasing the result set.
+    # A result set object is an instance of the MonetDBData class.
+    #
+    # Records can be returneds as arrays and iterators over the set.
+    #
+    # A database handler (dbh) is and 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)
+    #
+    #  is_connected? - returns true if there is an active connection to a server, false otherwise 
+    #  reconnect     - recconnect 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 MonetDBData 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 MonetDBData#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 disable 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.
+    # 
+    # Savepoints can be accessed (as a stack) with the MonetDB#transactions method.
+    #
+    # example/standalone.rb contains usage example of the above mentioned methods.
+
+    # = Introduction
+    #
+    # 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  has methods for fetching rows, moving around in the result set, obtaining column metadata, and releasing the result set.
+    # A result set object is an instance of the MonetDBData class.
+    #
+    # Records can be returneds as arrays and iterators over the set.
+    #
+    # A database handler (dbh) is and 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)
+    #
+    #  is_connected? - returns true if there is an active connection to a server, false otherwise 
+    #  reconnect     - recconnect 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 MonetDBData 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
+    #
+    # To release a record set MonetDBData#free can be used.
+    #
+    # = Type conversion 
+    #
+    # Invoking MonetDB#query with the flag type_conversion=true will result in a type cast of the record set fields from SQL types to ruby types
+    #
+    # demo.rb contains usage example of the above mentioned methods.
+
+  class MonetDB
+    def initalize()
+      @connection = nil 
+    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 = MonetDBConnection.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 and instance of MonetDBData.
+    def query(q = "")
+      if  @connection != nil 
+        @data = MonetDBData.new(@connection)
+        @data.execute(q)    
+      end
+      return @data
+    end
+    
+    # Return true if there exists a "connection" object
+    def is_connected?
+      if @connection == nil
+        return false
+      else 
+        return true
+      end
+    end
+  
+    # Reconnect to the server
+    def reconnect
+      if @connection != nil
+        self.close
+        
+        @connection = MonetDBConnection.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) settings.
+    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
+  end
+#end

data/lib/MonetDBConnection.rb

@@ -0,0 +1,550 @@
+# The contents of this file are subject to the MonetDB Public License
+# Version 1.1 (the "License"); you may not use this file except in
+# compliance with the License. You may obtain a copy of the License at
+# http://monetdb.cwi.nl/Legal/MonetDBLicense-1.1.html
+#
+# Software distributed under the License is distributed on an "AS IS"
+# basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
+# License for the specific language governing rights and limitations
+# under the License.
+#
+# The Original Code is the MonetDB Database System.
+#
+# The Initial Developer of the Original Code is CWI.
+# Portions created by CWI are Copyright (C) 1997-July 2008 CWI.
+# Copyright August 2008-2011 MonetDB B.V.
+# All Rights Reserved.
+
+# Implements the MAPI communication protocol
+
+
+require 'socket'
+require 'time'
+require 'hasher'
+require 'MonetDBExceptions'
+require 'iconv' # utf-8 support
+require 'uri'   # parse merovingian redirects
+
+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"
+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 atuh iterations (thorough merovingian) allowed
+ 
+MONET_ERROR           = -1
+
+LANG_SQL = "sql"
+
+# Xquery support
+LANG_XQUERY = "xquery"
+XQUERY_OUTPUT_SEQ = true # use monetdb xquery's output seq
+
+class MonetDBConnection
+ 
+  
+  # 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
+  
+  # Instantiates a new MonetDBConnection object
+  # * 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 = MonetDBTransaction.new # handles a pool of transactions (generates and keeps track of savepoints)
+    
+    if @@DEBUG == true
+      require 'logger'
+    end
+    
+  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
+    end
+    false
+  end
+  
+
+  # perform a real connection; retrieve challenge, proxy through merovinginan, build challenge and set the timezone
+  def real_connect
+    
+    server_challenge = retrieve_server_challenge()
+    print "CHALLENGE: " + server_challenge.to_s
+    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 MonetDBConnectionError, "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 MonetDBConnectionError, 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 MonetDBProtocolError, "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 MonetDBConnectionError, "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 MonetDBConnectionError, "Invalid redirect: #{redirects[0]}"
+            end
+          end
+          
+          if server_name == "merovingian"
+            if @auth_iteration <= 10
+              @auth_iteration += 1
+              real_connect
+            else
+              raise MonetDBConnectionError, "Merovingian: too many iterations while proxying."
+            end
+          elsif server_name == "monetdb"
+            begin
+              @socket.close
+            rescue
+              raise MonetDBConnectionError, "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 MonetDBConnectionError, monetdb_auth
+          end
+        elsif monetdb_auth[0].chr == MSG_INFO
+          raise MonetDBConnectionError, 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)
+      return "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 ))
+  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 MonetDBCommandError, "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 MonetDBConnectionError, "No connection established."
+    end
+  end
+  
+  # send data to a monetdb5 server instance and returns server's response
+  def send(data)
+    encode_message(data).each do |m|
+      @socket.write(m)
+    end
+  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)
+    
+    if is_final == false 
+      while is_final == false
+        is_final, chunk_size = recv_decode_hdr
+        data +=  @socket.recv(chunk_size)
+      end
+    end
+  
+    return data
+  end
+    
+  # Builds 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 MonetDBConnectionError, "#{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 + ":"
+  end
+
+  #
+  # Builds 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 MonetDBConnectionError, "#{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 + ":"
+  end
+
+  # builds 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 
+      
+      if (msg.length - pos) == 0
+        last_bit = 1
+        is_final = true
+      else
+        last_bit = 0
+      end
+      
+      hdr = [(data.length << 1) | last_bit].pack('v')
+      
+      message << hdr + data.to_s # Short Little Endian Encoding  
+    end
+    
+    message.freeze # freeze and return the encode message
+  end
+
+  # Used as the first step in the authentication phase; retrives 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 MonetDBSocketError, "Error while receiving data\n"
+    end 
+  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 MonetDBQueryError, response
+    end
+  end
+  
+  # Turns auto commit on/off
+  def set_auto_commit(flag=true)
+    if flag == false 
+      ac = " 0"
+    else 
+      ac = " 1"
+    end
+
+    send(format_command("auto_commit " + ac))
+    
+    response = receive
+    if response == MSG_PROMPT
+      @auto_commit = flag
+    elsif response[0].chr == MSG_INFO
+      raise MonetDBCommandError, response
+      return 
+    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?
+    if @server_name.downcase == 'merovingian'
+      true
+    else
+      false
+    end
+  end
+  
+  def mserver?
+    if @server_name.downcase == 'monetdb'
+      true
+    else
+      false
+    end
+  end
+  
+  # Check which protocol is spoken by the server
+  def mapi_proto_v8?
+    if @protocol == 8
+      true
+    else
+      false
+    end
+  end
+  
+  def mapi_proto_v9?
+    if @protocol == 9
+      true
+    else
+      false
+    end    
+  end
+end
+
+# handles transactions and savepoints. Can be used to simulate nested transactions.
+class MonetDBTransaction  
+  def initialize
+    @id = 0
+    @savepoint = ""
+  end
+  
+  def savepoint
+    @savepoint = "monetdbsp" + @id.to_s
+  end
+  
+  def release
+    prev_id
+  end
+  
+  def save
+    next_id
+  end
+  
+  private
+  def next_id
+    @id += 1
+  end
+  
+  def prev_id
+    @id -= 1
+  end
+  
+end