diff --git a/Changelog b/Changelog
deleted file mode 100644
index 186f9163be42c803b68f4e49239d6c2b571b5b8d..0000000000000000000000000000000000000000
--- a/Changelog
+++ /dev/null
@@ -1,38 +0,0 @@
-* Tue 30 Jun 2009 22:14:38 CEST
-Added test cases for the standalone driver (ruby unit test).
-
-* Thu 25 Jun 2009 17:31:02 CEST
-Fixed a major bug that resulted in data corruption;
-MAPI implementation code cleanup and bug fixes;
-Support to ruby 1.9;
-Both the standalone driver and activerecord now support transactions; nested transactions
-are simulated via savepoints in activerecord.
-Added a Rakefile and script to run activerecord unit test suite.
-Type conversion in the standalone driver is now performed after data has been retrieved and can be executed on single fields.
-
-* Mon 25 May 2009 17:52:01 CEST
-Imported last week changes (protocol 9 support, parametrized the connection options in the activerecord adapter, fixed a bug in the auth protocol v8).
-Fixed a bug in the mapi protocol that resulted in data loss (wrong handling of TRANSACTIONS).
-Began to port the activerecord test suite to monetdb (not all test cases can be performed).
-Removed an unneeded file ('lib/MonetDBStatement.rb') from the gemspec of the standalone driver (the feature will be moved to HEAD).
-Began to port the driver to ruby 1.9.
-Removed *.gem files from cvs.
-
-* Mon 18 May 2009 15:22:31 CEST
-Fixed bugs that prevented the correct working of activerecords' migration;
-The activerecord connector now supports insertion, update and alter table operations;
-Type casting is working in activerecord;
-Added a rubygem and rakefile for activerecord-monetdb-adapter;
-Added a new usage example for activerecord to the README file;
-Added an example directory to the cvs tree;
-The driver now correctly works with merovingian.
-
-
-* Sat  9 May 2009 15:58:36 CEST
-Fixed bugs with the query processing in the standalone driver;
-Added INSERT and UPDATE methods in the activerecord connector.
-
-* Thu  7 May 2009 17:03:01 CEST
-
-Added a check against the protocol version during authentication;
-Imported the activerecord code (available under adapter/).
diff --git a/README b/README
deleted file mode 100644
index 4143b64561faa30531f831aab92ca74079468429..0000000000000000000000000000000000000000
--- a/README
+++ /dev/null
@@ -1,154 +0,0 @@
-== 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
-
diff --git a/TODO b/TODO
deleted file mode 100644
index 8a4470bb1ccf98ed2a4bbfa241340a2e8aeac868..0000000000000000000000000000000000000000
--- a/TODO
+++ /dev/null
@@ -1,5 +0,0 @@
-* test and improve utf8 and type conversion
-
-* documentation cleanup
-
-* OSM on rails demo (slowed down due to third party plugins requirements)
diff --git a/adapter/Makefile.ag b/adapter/Makefile.ag
deleted file mode 100644
index b54b10b8363dcd124904aa54b1eecf3caed20665..0000000000000000000000000000000000000000
--- a/adapter/Makefile.ag
+++ /dev/null
@@ -1,24 +0,0 @@
-# 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.
-
-gem_adapter = {
-	FILES = activerecord-monetdb-adapter-0.1.gemspec
-	DIR = $(prefix)/$(RUBY_DIR)
-}
-
-EXTRA_DIST = activerecord-monetdb-adapter-0.1.gemspec
-EXTRA_DIST_DIR = active_record lib
diff --git a/adapter/activerecord-monetdb-adapter-0.1.gemspec b/adapter/activerecord-monetdb-adapter-0.1.gemspec
deleted file mode 100644
index 83d91d3b6aba6d3961f8e63e5c6696a8e832c798..0000000000000000000000000000000000000000
--- a/adapter/activerecord-monetdb-adapter-0.1.gemspec
+++ /dev/null
@@ -1,18 +0,0 @@
-Gem::Specification.new do |s|
-   s.required_ruby_version = '>= 2.1.0'
-   s.name = %q{activerecord-monetdb-adapter}
-   s.version = "0.2"
-   s.date = %q{2009-05-18}
-   s.authors = ["G Modena"]
-   s.email = %q{gm@cwi.nl}
-   s.summary = %q{ActiveRecord Connector for MonetDB}
-   s.homepage = %q{http://monetdb.cwi.nl/}
-   s.description = %q{ActiveRecord Connector for MonetDB built on top of the pure Ruby database driver}
-   s.files = [ "lib/active_record/connection_adapters/monetdb_adapter.rb" ]
-   s.has_rdoc = true
-   s.require_path = 'lib'
-   s.add_dependency(%q<activerecord>, [">= 2.3.2"])
-   s.add_dependency(%q<ruby-monetdb-sql>, [">= 0.1"])
-   # placeholder project to avoid warning about not having a rubyforge_project
-   s.rubyforge_project = "nowarning"
-end
diff --git a/adapter/lib/active_record/connection_adapters/monetdb_adapter.rb b/adapter/lib/active_record/connection_adapters/monetdb_adapter.rb
deleted file mode 100644
index fa5a7999f209c1dbe3a7f9fa7749ebb1ba411551..0000000000000000000000000000000000000000
--- a/adapter/lib/active_record/connection_adapters/monetdb_adapter.rb
+++ /dev/null
@@ -1,575 +0,0 @@
-# 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.
-
-# MonetDB Active Record adapter
-# monetdb_adapter.rb
-
-# The code is an adaption of the adapter developer by Michalis Polakis (2008), to work on top of the pure ruby MonetDB 
-# interface
-
-# Refreshed by Martin Samson (2011)
-
-MDB_SYS_SCHEMA = "sys."
-MDB_NON_SYSTEM_TABLES_ONLY = "and system = false"
-
-require 'active_record/connection_adapters/abstract_adapter'
-require 'MonetDB'
-
-module ActiveRecord
-  class Base
-    # Establishes a connection to the database that's used by all Active Record objects
-    def self.monetdb_connection(config)
-      # extract connection parameters
-      config = config.symbolize_keys
-
-      host = config[:host] || "127.0.0.1"
-      port = config[:port] || 50000
-      username = config[:username].to_s if config[:username]
-      password = config[:password].to_s if config[:password]
-
-      # Use "sql" as default language if none is specified
-      lang = config[:lang] || "sql"
-
-      if config.key?(:database)
-        database = config[:database]
-      else
-        raise ArgumentError, "No database specified. Missing argument: database."
-      end
-
-      dbh = MonetDB.new
-      ConnectionAdapters::MonetDBAdapter.new(dbh, logger, [host, port, username, password, database, lang], config)
-    end
-  end
-
-
-  module ConnectionAdapters
-    class MonetDBColumn < Column
-      # Handles the case where column type is int but default
-      # column value is the next value of a sequence(string).
-      # By overriding this function, extract_default in
-      # schema_definitions does not return a fixnum(0 or 1) but 
-      # the correct default value.
-      def type_cast(value)
-        if value.nil?
-          nil
-        elsif type == :integer && value =~/next value for/
-          nil
-        else
-          super
-        end
-      end
-
-      private
-
-      def simplified_type(field_type)
-        case field_type
-          when /int|smallint/i
-            :integer
-          when /real|double/i
-            :float
-          when /datetime/i
-            :timestamp
-          when /timestamp/i
-            :timestamp
-          when /char/i, /varchar/i
-            :string
-          when /bigint/i
-            :bigint
-          else
-            super
-        end
-      end
-
-    end #end of MonetDBColumn class
-
-    class TableDefinition
-      # Override so that we handle the fact that MonetDB 
-      # doesn't support "limit" on integer column.
-      # Otherwise same implementation
-      def column(name, type, options = {})
-        column = self[name] || ColumnDefinition.new(@base, name, type)
-
-        if type.to_sym != :integer and type.to_sym != :primary_key
-          column.limit = options[:limit] || native[type.to_sym][:limit] if options[:limit] or native[type.to_sym]
-        end
-
-        column.precision = options[:precision]
-        column.scale = options[:scale]
-        column.default = options[:default]
-        column.null = options[:null]
-
-        @columns << column unless @columns.include? column
-        self
-      end
-
-    end
-
-    class MonetDBAdapter < AbstractAdapter
-      class BindSubstitution < Arel::Visitors::MySQL
-        include Arel::Visitors::BindVisitor
-      end
-
-      def initialize(connection, logger, connection_options, config)
-        super(connection, logger)
-        @visitor = BindSubstitution.new self
-        @connection_options, @config = connection_options, config
-        connect
-      end
-
-      def adapter_name #:nodoc:
-        'MonetDB'
-      end
-
-      # Functions like rename_table, rename_column and 
-      # change_column cannot be implemented in MonetDB.
-      def supports_migrations?
-        true
-      end
-
-      # testing savepoints in progress
-      def supports_savepoints? #:nodoc:
-        true
-      end
-
-      def support_transaction? #:nodoc:
-        false
-      end
-
-      def supports_ddl_transactions?
-        false
-      end
-
-      def native_database_types
-        {
-            :primary_key => "int NOT NULL auto_increment PRIMARY KEY",
-            :string => {:name => "varchar", :limit => 255},
-            :text => {:name => "clob"},
-            :integer => {:name => "int"},
-            :float => {:name => "float"},
-            :decimal => {:name => "decimal"},
-            :datetime => {:name => "timestamp"},
-            :timestamp => {:name => "timestamp"},
-            :time => {:name => "time"},
-            :date => {:name => "date"},
-            :binary => {:name => "blob"},
-            :boolean => {:name => "boolean"},
-            :bigint => {:name => "bigint"}
-        }
-      end
-
-      #MonetDB does not support using DISTINCT withing COUNT
-      #by default
-      def supports_count_distinct?
-        false
-      end
-
-      #----------CONNECTION MANAGEMENT------------------
-
-      # Check if the connection is active
-      def active?
-        if @connection != nil
-          @connection.is_connected?
-        end
-
-        return false
-      end
-
-      # Close this connection and open a new one in its place.
-      def reconnect!
-        if @connection != nil
-          #@connection.reconnect
-          false
-        end
-      end
-
-      def disconnect!
-        #@connection.auto_commit(flag=true)
-        @connection.close
-      end
-
-      # -------END OF CONNECTION MANAGEMENT----------------
-
-
-      # ===============SCHEMA DEFINITIONS===========#
-
-      def binary_to_string(value)
-        res = ""
-        value.scan(/../).each { |i| res << i.hex.chr }
-        res
-      end
-
-      # ===========END OF SCHEMA DEFINITIONS========#
-
-
-      #===============SCHEMA STATEMENTS===========#
-      # The following schema_statements.rb functions are not supported by MonetDB (19/5/2008).
-      #
-      # -rename_table : not such functionality by MonetDB's API. Altering some 
-      #  administratives' tables values has no result.
-      #
-      # -rename_column : Could be possible if I make a new_name column copy the
-      # data from the old column there and then drop that column. But I would 
-      # also have to take care of references and other constraints. Not sure if
-      # this is desired.
-      # 
-      # -change_column : Alteration of a column's datatype is not supported. 
-      # NOTE WE MAY BE ABLE TO "CHANGE" A COLUMN DEFINITION IF WE DROP THE COLUMN
-      # AND CREATE A NEW ONE WITH THE OLD NAME. THIS COULD WORK AS LONG AS WE DON'T
-      # LOSE ANY DATA.
-
-
-      # Sets a new default value for a column.
-      # ===== Examples =====
-      #  change_column_default(:suppliers, :qualification, 'new')
-      #  change_column_default(:accounts, :authorized, 1)
-      def change_column_default(table_name, column_name, default)
-        sql = "ALTER TABLE #{table_name} ALTER COLUMN #{quote_column_name(column_name)} SET DEFAULT" #{quote(default)}"
-
-        if (default.nil? || (default.casecmp("NULL")==0))
-          sql << " NULL"
-        else
-          sql << quote(default)
-        end
-        p "SQL: " + sql + '\n'
-        hdl = execute(sql)
-      end
-
-      def remove_index(table_name, options = {})
-        hdl = execute("DROP INDEX #{index_name(table_name, options)}")
-      end
-
-      # MonetDB does not support limits on certain data types
-      # Limit is supported for the {char, varchar, clob, blob, time, timestamp} data types.
-      def type_to_sql(type, limit = nil, precision = nil, scale = nil)
-        return super if limit.nil?
-
-        # strip off limits on data types not supporting them
-        if [:integer, :double, :date, :bigint].include? type
-          type.to_s
-        else
-          super
-        end
-      end
-
-      # Returns an array of Column objects for the table specified by +table_name+.
-      def columns(table_name, name = nil)
-        return [] if table_name.to_s.strip.empty?
-        table_name = table_name.to_s if table_name.is_a?(Symbol)
-        table_name = table_name.split('.')[-1] unless table_name.nil?
-
-        hdl = execute("	SELECT name, type, type_digits, type_scale, \"default\", \"null\"  FROM #{MDB_SYS_SCHEMA}_columns 	WHERE table_id in (SELECT id FROM #{MDB_SYS_SCHEMA}_tables WHERE name = '#{table_name}' #{MDB_NON_SYSTEM_TABLES_ONLY})", name)
-
-        num_rows = hdl.num_rows
-        return [] unless num_rows >= 1
-
-        result = []
-
-
-        while row = hdl.fetch_hash do
-          col_name = row['name']
-          col_default = row['default']
-          # If there is no default value, it assigns NIL
-          col_default = nil if (col_default && col_default.upcase == 'NULL')
-          # Removes single quotes from the default value
-          col_default.gsub!(/^'(.*)'$/, '\1') unless col_default.nil?
-
-          # A string is returned so we must convert it to boolean
-          col_nullable = row['null']
-
-          if (col_nullable.casecmp("true") == 0)
-            col_nullable = true
-          elsif (col_nullable.casecmp("false") == 0)
-            col_nullable = false
-          end
-
-          col_type = row['type']
-          type_digits = row['type_digits']
-          type_scale = row['type_scale']
-
-
-          # Don't care about datatypes that aren't supported by
-          # ActiveRecord, like interval. 
-          # Also do nothing for datatypes that don't support limit
-          # like integer, double, date, bigint
-          if (col_type == "clob" || col_type == "blob")
-            if (type_digits.to_i > 0)
-              col_type << "(#{type_digits})"
-            end
-          elsif (col_type == "char" ||
-              col_type == "varchar" ||
-              col_type == "time" ||
-              col_type == "timestamp"
-          )
-            col_type << "(#{type_digits})"
-          elsif (col_type == "decimal")
-            if (type_scale.to_i == 0)
-              col_type << "(#{type_digits})"
-            else
-              col_type << "(#{type_digits},#{type_scale})"
-            end
-          end
-
-          # instantiate a new column and insert into the result array
-          result << MonetDBColumn.new(col_name, col_default, col_type, col_nullable)
-
-        end
-
-        #  check that free has been correctly performed
-        hdl.free
-
-        return result
-      end
-
-      def primary_key(table)
-        'id'
-      end
-
-      # Adds a new column to the named table.
-      # See TableDefinition#column for details of the options you can use.
-      def add_column(table_name, column_name, type, options = {})
-        if ((type.to_sym == :decimal) && (options[:precision].to_i+options[:scale].to_i > 18))
-          raise StandardError, "It is not possible to have a decimal column where Precision + Scale > 18 . The column will not be added to the table!"
-          return
-        else
-          super
-        end
-      end
-
-      # Return an array with all non-system table names of the current 
-      # database schema
-      def tables(name = nil)
-        cur_schema = select_value("select current_schema", name)
-        select_values("	SELECT t.name FROM #{MDB_SYS_SCHEMA}_tables t, sys.schemas s
-  			WHERE s.name = '#{cur_schema}' 
-  				AND t.schema_id = s.id 
-  				AND t.system = false", name)
-      end
-
-      # Returns an array of indexes for the given table.
-      def indexes(table_name, name = nil)
-        sql_query = "	SELECT distinct i.name as index_name, k.\"name\", k.nr
-  	 		FROM
-  				#{MDB_SYS_SCHEMA}idxs i, #{MDB_SYS_SCHEMA}_tables t, #{MDB_SYS_SCHEMA}objects k
-  	 		WHERE
-  				i.type = 0 AND i.name not like '%pkey' 
-  				AND i.id = k.id AND t.id = i.table_id 
-  				AND t.name = '#{table_name.to_s}'
-  	 		ORDER BY i.name, k.nr;"
-        result = select_all(sql_query, name);
-
-        cur_index = nil
-        indexes = []
-
-        result.each do |row|
-          if cur_index != row['index_name']
-            indexes << IndexDefinition.new(table_name, row['index_name'], false, [])
-            cur_index = row['index_name']
-          end
-
-          indexes.last.columns << row['name']
-        end
-
-        indexes
-      end
-
-      # ===========END OF SCHEMA STATEMENTS========#
-
-      # ===========QUOTING=========================#
-      def quote(value, column = nil)
-        if value.kind_of?(String) && column && column.type == :binary && column.class.respond_to?(:string_to_binary)
-          s = column.class.string_to_binary(value).unpack("H*")[0]
-          "BLOB '#{s}'"
-        else
-          super
-        end
-      end
-
-      def quote_column_name(name) #:nodoc:
-        "\"#{name.to_s}\""
-      end
-
-      def quote_table_name(name) #:nodoc:
-        quote_column_name(name).gsub('.', '"."')
-      end
-
-      # If the quoted true is 'true' MonetDB throws a string cast exception
-      def quoted_true
-        "true"
-      end
-
-      # If the quoted false is 'false' MonetDB throws a string cast exception
-      def quoted_false
-        "false"
-      end
-
-      # ===========END-OF-QUOTING==================#
-
-
-      # =========DATABASE=STATEMENTS===============#
-
-      # Returns an array of arrays containing the field values.
-      # Order of columns in tuple arrays is not guaranteed.
-      def select_rows(sql, name = nil)
-        result = select(sql, name)
-        result.map { |v| v.values }
-      end
-
-      def execute(sql, name = nil)
-        sql = sql.gsub('!=', '<>')
-        sql += ';'
-        @connection.query(sql)
-      end
-
-      def exec_query(sql, name = nil, binds = [])
-        select_rows(sql, name)
-      end
-
-      def last_inserted_id(result)
-        result.last_insert_id
-      end
-
-      def delete(arel, name = nil, binds = [])
-        res = super(arel, name, binds)
-        res.affected_rows
-      end
-
-      # Begins the transaction.
-      def begin_db_transaction
-        hdl = execute("START TRANSACTION")
-      end
-
-      # Commits the transaction (ends TRANSACTIOM). 
-      def commit_db_transaction
-        hdl = execute("COMMIT")
-      end
-
-      # Rolls back the transaction. Must be
-      # done if the transaction block raises an exception or returns false (ends TRANSACTIOM).
-      def rollback_db_transaction
-        hdl = execute("ROLLBACK")
-      end
-
-      def current_savepoint_name
-        @connection.transactions || 0
-      end
-
-      # Create a new savepoint
-      def create_savepoint
-        @connection.save
-        execute("SAVEPOINT #{current_savepoint_name}")
-      end
-
-      # rollback to the last savepoint
-      def rollback_to_savepoint
-        execute("ROLLBACK TO SAVEPOINT #{current_savepoint_name}")
-      end
-
-      # release current savepoint
-      def release_savepoint
-        execute("RELEASE SAVEPOINT #{current_savepoint_name}")
-      end
-
-      def add_lock!(sql, options)
-        @logger.info "Warning: MonetDB :lock option '#{options[:lock].inspect}' not supported. Returning unmodified sql statement!" if @logger && options.has_key?(:lock)
-        sql
-      end
-
-      def empty_insert_statement(table_name)
-        # Ensures that the auto-generated id  value will not violate the primary key constraint.
-        # comment out for production code(?)
-        #make_sure_pk_works(table_name, nil)
-        #"INSERT INTO #{quote_table_name(table_name)}"
-      end
-
-      #=======END=OF=DATABASE=STATEMENTS=========#
-
-      # Returns an array of record hashes with the column names as keys and
-      # column values as values.
-      def select(sql, name = nil, binds = [])
-        hdl = execute(sql, name)
-        hdl.result_hashes
-      end
-
-      # Executes the update statement and returns the number of rows affected.
-      def update_sql(sql, name = nil)
-        hdl = execute(sql, name)
-        hdl.affected_rows
-      end
-
-      # Returns the last auto-generated ID from the affected table.
-      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
-        # Ensures that the auto-generated id  value will not violate the
-        # primary key constraint. Read the comments of make_sure_pk_works
-        # and documentation for further information.
-        # comment out for production code(?)
-        # table_name = extract_table_name_from_insertion_query(sql)
-        # make_sure_pk_works(table_name,name)
-        hdl = execute(sql, name)
-        hdl.last_insert_id
-      end
-
-      protected
-      # Some tests insert some tuples with the id values set. In other words, the sequence
-      # is not used to generate a value for the primary key column named id. When a new tuple
-      # it to be inserted, where the id value is not set explicitly, a primary key violation will
-      # be raised because the generated from the sequence value is the same as one of the existing
-      # id values. This happens in unit tests quite often. So this function serves that the unit tests
-      # pass. However it is very expensive( sends 4 queries to the server) and probably not suitable for
-      # production code. Check the implementation for further info/details.
-      def make_sure_pk_works(table_name, name)
-        # Ensure the auto-generated id will not violate the primary key constraint.
-        # This is expensive and it's used so that the tests pass. Comment out for production code(?).
-        # Assume that table name has one primary key column named id that is associated with a sequence,
-        # otherwise return
-        hdl = nil
-        sequence_name = extract_sequence_name(select_value("select \"default\" from #{MDB_SYS_SCHEMA}_columns where table_id in (select id from #{MDB_SYS_SCHEMA}_tables where name = '#{table_name}') and name='id';"))
-
-        return if sequence_name.blank?
-
-        max_id = select_value("select max(id) from #{table_name}").to_i
-        next_seq_val = select_value("select next value for #{sequence_name}").to_i
-
-        if (max_id > next_seq_val)
-          hdl = execute("ALTER SEQUENCE #{sequence_name} RESTART WITH #{max_id+1}", name)
-        else
-          hdl = execute("ALTER SEQUENCE #{sequence_name} RESTART WITH #{next_seq_val+1}", name)
-        end
-      end
-
-      # Auxiliary function that extracts the table name from an insertion query
-      # It's called by insert_sql in order to assist at make_sure_pk_works.
-      # Ideally, if make_sure_pk_works is commented out for production code, this
-      # function will be never called.
-      def extract_table_name_from_insertion_query(sql)
-        $1 if sql =~ /INSERT INTO "(.*)" \(/
-      end
-
-      # Auxiliary function that extracts the sequence name.
-      # It's called by make_sure_pk_works.
-      # Ideally, if make_sure_pk_works is commented out for production code, this
-      # function will be never called.
-      def extract_sequence_name(seqStr)
-        $1 if seqStr =~ /\."(.*)"/
-      end
-
-      private
-      def connect
-        @connection.connect(user = @connection_options[2], passwd = @connection_options[3], lang = @connection_options[5], host = @connection_options[0], port = @connection_options[1], db_name = @connection_options[4], auth_type = "SHA1") if @connection
-      end
-    end
-  end
-end
diff --git a/lib/MonetDB.rb b/lib/MonetDB.rb
deleted file mode 100644
index d1936dc464ea7f74f7d87c025be17a2fa117d61f..0000000000000000000000000000000000000000
--- a/lib/MonetDB.rb
+++ /dev/null
@@ -1,312 +0,0 @@
-# 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
-    DEFAULT_USERNAME = "monetdb"
-    DEFAULT_PASSWORD = "monetdb"
-    DEFAULT_LANG     = LANG_SQL
-    DEFAULT_HOST     = "127.0.0.1"
-    DEFAULT_PORT     = 50000
-    DEFAULT_DATABASE = "test"
-    DEFAULT_AUTHTYPE = "SHA1"
-    
-    def initalize()
-      @connection = nil 
-    end
-  
-    # Establish a new connection.
-    #                * username: username (default is monetdb)
-    #                * password: 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=DEFAULT_USERNAME, password=DEFAULT_PASSWORD, lang=DEFAULT_LANG, host=DEFAULT_HOST, port=DEFAULT_PORT, db_name=DEFAULT_DATABASE, auth_type=DEFAULT_AUTHTYPE)
-      # 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
-  
-    # Establish a new connection using named parameters.
-    #                * user: username (default is monetdb)
-    #                * passwd: password (default is monetdb)
-    #                * language: lang (default is sql) 
-    #                * host: host to connect to  (default is localhost)
-    #                * port: port to connect to (default is 50000)
-    #                * database: name of the database to connect to
-    #                * auth_type: hashing function to use during authentication (default is SHA1)
-    #
-    # Conventionally named parameters are passed as an hash.
-    #
-    # Ruby 1.8:
-    # MonetDB::conn({ :user => "username", :passwd => "password", :database => "database"})
-    #
-    # Ruby 1.9:
-    # MonetDB::conn(user: "username", passwd: "password", database: "database")
-    def conn(options)      
-      user        = options[:user] || DEFAULT_USERNAME
-      passwd      = options[:passwd] || DEFAULT_PASSWORD
-      language    = options[:language] || DEFAULT_LANG
-      host        = options[:host] || DEFAULT_HOST
-      port        = options[:port] || DEFAULT_PORT
-      database    = options[:database] || DEFAULT_DATABASE
-      auth_type   = options[:auth_type] || DEFAULT_AUTHTYPE
-      
-      connect(user, passwd, language, host, port, database, 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
diff --git a/lib/MonetDBConnection.rb b/lib/MonetDBConnection.rb
deleted file mode 100644
index e18df90bc14416eb5651a3457488dc53d2cd007e..0000000000000000000000000000000000000000
--- a/lib/MonetDBConnection.rb
+++ /dev/null
@@ -1,548 +0,0 @@
-# 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 '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"
-
-# Protocols
-MAPIv8 = 8
-MAPIv9 = 9
-
-MONETDB_MEROVINGIAN = "merovingian"
-MONETDB_MSERVER = "monetdb"
-
-MEROVINGIAN_MAX_ITERATIONS = 10
-
-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 = 2048
-
-  # endianness of a message sent to the server
-  @@CLIENT_ENDIANNESS = "BIG"
-
-  # MAPI protocols supported by the driver
-  @@SUPPORTED_PROTOCOLS = [MAPIv8, MAPIv9]
-
-  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
-
-    if @lang[0, 3] == 'sql'
-      @lang = "sql"
-    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
-      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()
-    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 == MAPIv9
-        @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 == MONETDB_MEROVINGIAN
-            if @auth_iteration <= MEROVINGIAN_MAX_ITERATIONS
-              @auth_iteration += 1
-              real_connect
-            else
-              raise MonetDBConnectionError, "Merovingian: too many iterations while proxying."
-            end
-          elsif server_name == MONETDB_MSERVER
-            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 = "%+03d:00" % (tz.gmt_offset / @@HOUR)
-
-    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 == MONETDB_MEROVINGIAN
-      true
-    else
-      false
-    end
-  end
-
-  def mserver?
-    if @server_name.downcase == MONETDB_MSERVER
-      true
-    else
-      false
-    end
-  end
-
-  # Check which protocol is spoken by the server
-  def mapi_proto_v8?
-    if @protocol == MAPIv8
-      true
-    else
-      false
-    end
-  end
-
-  def mapi_proto_v9?
-    if @protocol == MAPIv9
-      true
-    else
-      false
-    end
-  end
-end
-
-# handles transactions and savepoints. Can be used to simulate nested transactions.
-class MonetDBTransaction
-  SAVEPOINT_STRING = "monetdbsp"
-
-  def initialize
-    @id = 0
-    @savepoint = ""
-  end
-
-  def savepoint
-    @savepoint = SAVEPOINT_STRING + @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
diff --git a/lib/MonetDBData.rb b/lib/MonetDBData.rb
deleted file mode 100644
index 7dd8509aca9653976a73c9350167cbf17e6b054c..0000000000000000000000000000000000000000
--- a/lib/MonetDBData.rb
+++ /dev/null
@@ -1,420 +0,0 @@
-# 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.
-
-# Models a MonetDB RecordSet
-require 'time'
-require 'ostruct'
-
-require "bigdecimal"
-
-require 'MonetDBConnection'
-
-require 'logger'
-
-class MonetDBData
-  @@DEBUG = false
-  attr_accessor :last_insert_id, :affected_rows
-
-  def initialize(connection)
-    @connection = connection
-    @lang = @connection.lang
-
-    # Structure containing the header+results set for a fired Q_TABLE query     
-    @header = []
-    @query = {}
-
-    @record_set = []
-    @index = 0 # Position of the last returned record
-
-    @row_count = 0
-    @row_offset = 10
-    @row_index = Integer(REPLY_SIZE)
-  end
-
-  # Fire a query and return the server response
-  def execute(q)
-    # fire a query and get ready to receive the data
-    @connection.send(format_query(q))
-    data = @connection.receive
-
-    return if data == nil
-
-    # temporarly store retrieved rows
-    record_set = receive_record_set(data)
-
-    if (@lang == LANG_SQL)
-      # the fired query is a SELECT; store and return the whole record set
-      if @action == Q_TABLE
-        @header = parse_header_table(@header)
-        @header.freeze
-
-        if @row_index.to_i < @row_count.to_i
-          block_rows = ""
-          while next_block
-            data = @connection.receive
-            block_rows += receive_record_set(data)
-          end
-          record_set += block_rows
-        end
-      end
-
-      # ruby string management seems to not properly understand the MSG_PROMPT escape character.
-      # In order to avoid data loss the @record_set array is built once that all tuples have been retrieved
-      @record_set = record_set.split("\t]\n")
-
-      if @record_set.length != @query['rows'].to_i
-        raise MonetDBQueryError, "Warning: Query #{@query['id']} declared to result in #{@query['rows']} but #{@record_set.length} returned instead"
-      end
-    end
-    @record_set.freeze
-  end
-
-  # Free memory used to store the record set
-  def free()
-    @connection = nil
-
-    @header = []
-    @query = {}
-
-    @record_set = []
-    @index = 0 # Position of the last returned record
-
-
-    @row_index = Integer(REPLY_SIZE)
-    @row_count = 0
-    @row_offset = 10
-
-  end
-
-  # Returns the record set entries hashed by column name orderd by column position
-  def fetch_all_hash()
-    columns = {}
-    @header["columns_name"].each do |col_name|
-      columns[col_name] = fetch_column_name(col_name)
-    end
-
-    return columns
-  end
-
-  def fetch_hash()
-    if @index >= @query['rows'].to_i
-      return false
-    else
-      columns = {}
-      @header["columns_name"].each do |col_name|
-        position = @header["columns_order"].fetch(col_name)
-        row = parse_tuple(@record_set[@index])
-        columns[col_name] = row[position]
-      end
-      @index += 1
-      return columns
-    end
-  end
-
-  # Returns the values for the column 'field'
-  def fetch_column_name(field="")
-    position = @header["columns_order"].fetch(field)
-
-    col = Array.new
-    # Scan the record set by row
-    @record_set.each do |row|
-      col << parse_tuple(row)[position]
-    end
-
-    return col
-  end
-
-  # returns result as an array of hashes
-  def result_hashes
-    result = []
-    @record_set.each do |row|
-      rec = parse_tuple(row)
-      hash = {}
-      @header['columns_name'].each_with_index do |item, i|
-        hash[item] = rec[i]
-        hash[item] = nil if hash[item] == 'NULL'
-      end
-      result << hash
-    end
-    result
-  end
-
-  def fetch()
-    @index
-    if @index > @query['rows'].to_i
-      false
-    else
-      parse_tuple(@record_set[@index])
-      @index += 1
-    end
-  end
-
-  # Cursor method that retrieves all the records present in a table and stores them in a cache.
-  def fetch_all()
-    if @query['type'] == Q_TABLE
-      rows = Array.new
-      @record_set.each do |row|
-        rows << parse_tuple(row)
-      end
-      @index = Integer(rows.length)
-    else
-      raise MonetDBDataError, "There is no record set currently available"
-    end
-
-    return rows
-  end
-
-  # Returns the number of rows in the record set
-  def num_rows()
-    return @query['rows'].to_i
-  end
-
-  # Returns the number of fields in the record set
-  def num_fields()
-    return @query['columns'].to_i
-  end
-
-  # Returns the (ordered) name of the columns in the record set
-  def name_fields()
-    return @header['columns_name']
-  end
-
-  # Returns the (ordered) name of the columns in the record set
-  def type_fields
-    return @header['columns_type']
-  end
-
-  private
-
-  # store block of data, parse it and store it.
-  def receive_record_set(response)
-    rows = ""
-    lines = response.lines.to_a
-    response.each_line do |row|
-      if row[0].chr == MSG_QUERY
-        if row[1].chr == Q_TABLE
-          @action = Q_TABLE
-          @query = parse_header_query(row)
-          @query.freeze
-          @row_count = @query['rows'].to_i #total number of rows in table            
-        elsif row[1].chr == Q_BLOCK
-          # strip the block header from data
-          @action = Q_BLOCK
-          @block = parse_header_query(row)
-        elsif row[1].chr == Q_TRANSACTION
-          @action = Q_TRANSACTION
-        elsif row[1].chr == Q_CREATE
-          @action = Q_CREATE
-        elsif row[1].chr == Q_UPDATE
-          @action = Q_UPDATE
-          result = row.split(' ')
-          @affected_rows = result[1].to_i
-          @last_insert_id = result[2].to_i
-        end
-      elsif row[0].chr == MSG_INFO
-        raise MonetDBQueryError, row
-      elsif row[0].chr == MSG_SCHEMA_HEADER
-        # process header data
-        @header << row
-      elsif row[0].chr == MSG_TUPLE
-        if REPLY_SIZE.to_i == -1
-          # if all results are returned in this response, we don't have to look ahead further
-          return lines.join
-        end
-        rows += row
-      elsif row[0] == MSG_PROMPT
-        return rows
-      end
-      lines.shift
-    end
-    rows # return an array of unparsed tuples
-  end
-
-  def next_block
-    if REPLY_SIZE.to_i == -1 or @row_index == @row_count
-      return false
-    else
-      # The increment step is small to better deal with ruby socket's performance.
-      # For larger values of the step performance drop;
-      #
-      @row_offset = [@row_offset, (@row_count - @row_index)].min
-
-      # export offset amount
-      @connection.set_export(@query['id'], @row_index.to_s, @row_offset.to_s)
-      @row_index += @row_offset
-      @row_offset += 1
-    end
-    return true
-  end
-
-  # Formats a query <i>string</i> so that it can be parsed by the server
-  def format_query(q)
-    if @lang == LANG_SQL
-      return "s" + q + ";"
-    else
-      raise LanguageNotSupported, @lang
-    end
-  end
-
-  # parse one tuple as returned from the server
-  def parse_tuple(tuple)
-    fields = Array.new
-    # remove trailing  "["
-    tuple = tuple.to_s.gsub(/^\[\s+/, '')
-
-    tuple.split(/,\t/).each do |f|
-      fields << f.gsub(/\\n/, "\n").gsub(/\\/, '').gsub(/^"/, '').gsub(/"$/, '').gsub(/\"/, '')
-    end
-
-    return fields.freeze
-  end
-
-  # Parses a query header and returns information about the query.
-  def parse_header_query(row)
-    type = row[1].chr
-    if type == Q_TABLE
-      # Performing a SELECT: store informations about the table size, query id, total number of records and returned.
-      id = row.split(' ')[1]
-      rows = row.split(' ')[2]
-      columns = row.split(' ')[3]
-      returned = row.split(' ')[4]
-
-      header = {"id" => id, "type" => type, "rows" => rows, "columns" => columns, "returned" => returned}
-    elsif type == Q_BLOCK
-      # processing block header
-
-      id = row.split(' ')[1]
-      columns = row.split(' ')[2]
-      remains = row.split(' ')[3]
-      offset = row.split(' ')[4]
-
-      header = {"id" => id, "type" => type, "remains" => remains, "columns" => columns, "offset" => offset}
-    else
-      header = {"type" => type}
-    end
-
-    return header.freeze
-  end
-
-  # Parses a Q_TABLE header and returns information about the schema.
-  def parse_header_table(header_t)
-    if @query["type"] == Q_TABLE
-      if header_t != nil
-        name_t = header_t[0].split(' ')[1].gsub(/,$/, '')
-        name_cols = Array.new
-
-        header_t[1].split('%')[1].gsub(/'^\%'/, '').split('#')[0].split(' ').each do |col|
-          name_cols << col.gsub(/,$/, '')
-        end
-
-        type_cols = {}
-        header_t[2].split('%')[1].gsub(/'^\%'/, '').split('#')[0].split(' ').each_with_index do |col, i|
-          if col.gsub(/,$/, '') != nil
-            type_cols[name_cols[i]] = col.gsub(/,$/, '')
-          end
-        end
-
-        length_cols = {}
-        header_t[3].split('%')[1].gsub(/'^\%'/, '').split('#')[0].split(' ').each_with_index do |col, i|
-          length_cols[name_cols[i]] = col.gsub(/,$/, '')
-        end
-
-        columns_order = {}
-        name_cols.each_with_index do |col, i|
-          columns_order[col] = i
-        end
-
-        return {"table_name" => name_t, "columns_name" => name_cols, "columns_type" => type_cols,
-                "columns_length" => length_cols, "columns_order" => columns_order}.freeze
-      end
-    end
-  end
-end
-
-# Overload the class string to convert monetdb to ruby types.
-class String
-  def getInt
-    self.to_i
-  end
-
-  def getFloat
-    self.to_f
-  end
-
-  def getString
-    self.gsub(/^"/, '').gsub(/"$/, '')
-  end
-
-  def getBlob
-    # first strip trailing and leading " characters 
-    self.gsub(/^"/, '').gsub(/"$/, '')
-
-    # convert from HEX to the origianl binary data.
-    blob = ""
-    self.scan(/../) { |tuple| blob += tuple.hex.chr }
-    return blob
-  end
-
-  # ruby currently supports only time + date frommatted timestamps;
-  # treat TIME and DATE as strings.
-  def getTime
-    # HH:MM:SS
-    self.gsub(/^"/, '').gsub(/"$/, '')
-  end
-
-  def getDate
-    self.gsub(/^"/, '').gsub(/"$/, '')
-  end
-
-  def getDateTime
-    #YYYY-MM-DD HH:MM:SS
-    date = self.split(' ')[0].split('-')
-    time = self.split(' ')[1].split(':')
-
-    Time.gm(date[0], date[1], date[2], time[0], time[1], time[2])
-  end
-
-  def getChar
-    # ruby < 1.9 does not have a Char datatype
-    begin
-      c = self.ord
-    rescue
-      c = self
-    end
-
-    return c
-  end
-
-  def getBool
-    if ['1', 'y', 't', 'true'].include?(self)
-      return true
-    elsif ['0', 'n', 'f', 'false'].include?(self)
-      return false
-    else
-      # unknown
-      return nil
-    end
-  end
-
-  def getNull
-    if self.upcase == 'NONE'
-      return nil
-    else
-      raise "Unknown value"
-    end
-  end
-end
diff --git a/lib/MonetDBExceptions.rb b/lib/MonetDBExceptions.rb
deleted file mode 100644
index 75745b5144ff680da4a20d97c6fbcaa969efbb40..0000000000000000000000000000000000000000
--- a/lib/MonetDBExceptions.rb
+++ /dev/null
@@ -1,25 +0,0 @@
-# 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.
-
-# Exception classes for the ruby-monetdb driver
-
-class MonetDBQueryError < StandardError; end
-class MonetDBDataError < StandardError; end
-class MonetDBCommandError < StandardError; end
-class MonetDBConnectionError < StandardError; end
-class MonetDBSocketError < StandardError; end
-class MonetDBProtocolError < StandardError; end
\ No newline at end of file
diff --git a/lib/demo.rb b/lib/demo.rb
deleted file mode 100644
index 94fd640a26e980f577b666bf14fc148637e8d5cd..0000000000000000000000000000000000000000
--- a/lib/demo.rb
+++ /dev/null
@@ -1,101 +0,0 @@
-# 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.
-
-require 'MonetDB'
-
-db = MonetDB.new
-
-db.conn({ :user => "monetdb", :passwd => "monetdb", :port => 50000, :language => "sql", :host => "localhost", :database => "ruby_test", :auth_type => "SHA1" })
-
-# set type_cast=true to enable MonetDB to Ruby type mapping
-#res = db.query("select * from tables, tables, tables;")
-
-#db.query("DROP TABLE tests2 ")
-#db.query(" CREATE TABLE tests2 ( col1  varchar(255), col2 varchar(255)) " )
-
-#puts "Number of rows returned: " + res.num_rows.to_s
-#puts "Number of fields: " + res.num_fields.to_s
-
-# Get the columns' name
-# print res.name_fields
-
-###### Fetch all rows and store them
-
-#puts res.fetch_all
-
-
-# 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
-
-
-###### Get all records and hash them by column name
-#row = res.fetch_all_hash()
-
-#puts col_names[0] + "\t\t" + col_names[1]
-#0.upto(res.num_rows) { |i|
-#  puts row['id'][i]
-#}
-
-
-###### Iterator over columns (on cell at a time)
-
-#while row = res.fetch_hash do
-#  printf "%s\n",  row["id"]
-#end
-
-# SQL TRANSACTIONS and SAVE POINTS
-
-
-
-db.query('DROP TABLE tests2')
-db.auto_commit(false)
-puts db.auto_commit?
-# create a savepoint
-db.save
-db.query("CREATE TABLE tests2 (col1 VARCHAR(255), col2 VARCHAR(255))")
-res = db.query("SAVEPOINT #{db.transactions} ;")
-res = db.query("INSERT INTO \"tests2\" VALUES ('€¿®µ¶¹', '€¿®µ¶¹')")
-res = db.query("INSERT INTO \"tests2\" VALUES ('€¿®µ¶¹', '€¿®µ¶¹')")
-#res = db.query("INSERT INTO \"tests2\" VALUES ('€¿®µ¶¹', '€¿®µ¶¹')")
-#res = db.query("INSERT INTO \"tests2\" VALUES ('€¿®µ¶¹', '€¿®µ¶¹')")
-#res = db.query("INSERT INTO \"tests2\" VALUES ('€¿®µ¶¹', '€¿®µ¶¹')")
-#res = db.query("INSERT INTO \"tests2\" VALUES ('€¿®µ¶¹', '€¿®µ¶¹')")
-#res = db.query("INSERT INTO \"tests2\" VALUES ('€¿®µ¶¹', '€¿®µ¶¹')")
-#res = db.query("INSERT INTO \"tests2\" VALUES ('€¿®µ¶¹', '€¿®µ¶¹')")
-db.query("COMMIT")
-db.release
-
-db.save
-res = db.query("SAVEPOINT #{db.transactions} ;")
-res = db.query("INSERT INTO \"tests2\" VALUES('NAME4', 'SURNAME4')")
-
-res = db.query("ROLLBACK TO SAVEPOINT #{db.transactions};")
-db.release
-
-db.auto_commit(true)
-puts db.auto_commit?
-res = db.query('SELECT * from tests2')
-while row = res.fetch do
-  printf "%s \n", row
-end
-
-res.free
-
-db.close
diff --git a/lib/hasher.rb b/lib/hasher.rb
deleted file mode 100644
index 2501266dc54e34bdc0f5bee433b8f821a675f7db..0000000000000000000000000000000000000000
--- a/lib/hasher.rb
+++ /dev/null
@@ -1,56 +0,0 @@
-# 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.
-
-require 'digest/md5'
-require 'digest/sha1'
-require 'digest/sha2' 
-
-class Hasher
-	# Constructor
-	# method = "SHA1" or "MD5"
-	# pwd = Password
-	def initialize(method, pwd)
-          if (method.upcase == "SHA1")
-                  @hashfunc = Digest::SHA1.new
-                  @hashname = method.upcase
-          elsif (method.upcase == "SHA256") 
-            @hashfunc = Digest::SHA256.new
-            @hashname = method.upcase
-          elsif (method.upcase == "SHA384")
-            @hashfunc = Digest::SHA384.new
-            @hashname = method.upcase
-          elsif (method.upcase == "SHA512")
-            @hashfunc = Digest::SHA512.new
-            @hashname = method.upcase
-          else
-            # default to MD5
-                  @hashfunc = Digest::MD5.new
-                  @hashname = "MD5"
-          end
-          @pwd = pwd
-  end
-  
-
-	def hashname
-		@hashname
-	end
-
-	# Compute hash code
-	def hashsum
-		return @hashfunc.hexdigest(@pwd)
-	end
-end
diff --git a/lib/test/test_capabilities.rb b/lib/test/test_capabilities.rb
deleted file mode 100644
index fc2146b2d715795ca9fed5be7d081c1b7b38df90..0000000000000000000000000000000000000000
--- a/lib/test/test_capabilities.rb
+++ /dev/null
@@ -1,310 +0,0 @@
-# unit test suite for monetdb.
-# connects to the 'ruby_test' database and runs test on the server capabilities and SQL language.
-# Create first a database with the command:
-# $ monetdb create ruby_test
-# $ monetdb start ruby_start
-#
-# Tests examples have been taken from the python and java internfaces and mysql driver.
-
-require 'MonetDB'
-require 'test/unit'
-
-require 'time'
-require 'date'
-
-
-class TC_MonetDBCapabilities < Test::Unit::TestCase
-  # ruby rand function does not support MIN..MAX bounds.
-  # This alias adds that feature.
-  alias original_rand rand
-  def rand(arg1=nil, arg2=nil) 
-    if !arg1.kind_of?(Enumerable) && arg2 == nil 
-      original_rand(arg1)
-    elsif arg1.kind_of? Enumerable
-      as_array = arg1.to_a
-      as_array[original_rand(as_array.length)]
-    elsif arg1 != nil
-      arg1 + original_rand(arg2)
-    end
-  end
-  
-  # check the existance of a table
-  def table_exists?(table='test_ruby')    
-    begin
-      res = @db.query("select * from #{table} where 1=0")
-      return true
-    rescue
-      return false
-    end
-  end
-  
-  def drop_table(table='test_ruby')
-    res = @db.query("DROP TABLE #{table}")
-  end
-  
-  def setup
-    @db = MonetDB.new
-    @db.connect(user = "monetdb", passwd = "monetdb", lang = "sql", host="localhost", port = 50000, db_name = "ruby_test", auth_type = "SHA1")
-    
-  end
-
-  def teardown
-    @db.close
-  end
-  
-  # CREATE TABLE test
-  def test_create_table(table='test_ruby', cols = [ "First_Name varchar(255)", "Second_Name varchar(255)"])
-    
-    if table_exists?(table)
-      drop_table(table)
-    end
-    
-    colsdef =  ""
-    cols.each do |c| colsdef += c + ',' end
-      
-    colsdef = colsdef.chop # remove last ',' character
-    
-    
-    res = @db.query('CREATE TABLE ' + table + ' (' + colsdef + ')') 
-  end
-  
-  
-  # perform an inserstion of 'data' into 'table' and check the resulting 
-  # length
-  def test_data_integrity(table='test_ruby', data=["Gabriele", "MODENA"])
-    test_create_table
-        
-    values = ""
-    data.each do |d| values += '\'' + d.to_s + '\'' + ',' end
-    values = values.chop # remove last ',' character
-    
-    insert = 'INSERT INTO ' + table +  ' VALUES ('  + values + ' )' 
-    
-    @db.query(insert)
-    
-    res = @db.query("SELECT * FROM #{table}")
-    rows = res.fetch_all
-    
-    assert_equal(res.num_rows, rows.size)
-  end
-  
-  # test TRANSACTION, COMMIT, ROLLBACK and SAVEPOINT in auto_commit=off mode
-  def test_transactions(table="test_monetdb_transactions",  columndefs=['col1 INT', 'col2 VARCHAR(255)'])
-    test_create_table(table, columndefs)
-     
-    data = [1, 'aa'] 
-    values = ""
-     
-    data.each do |d| values += '\'' + d.to_s + '\'' + ',' end
-    values = values.chop # remove last ',' character 
-     
-    insert = "INSERT INTO " + table + " VALUES " + " ( " + values +  " )"
-     
-    @db.query('START TRANSACTION')
-    @db.auto_commit(flag=false) # if @db.auto_commit?
-    @db.query(insert)
-
-    @db.query("COMMIT")     
-     
-    res = @db.query('SELECT * FROM ' + table)
-    rows_committed = res.fetch_all
-    res.free
-     
-    # create a save point
-    @db.save
-    @db.query("SAVEPOINT #{@db.transactions} ;")
-     
-    @db.query(insert)
-     
-    # rollback to savepoint
-    @db.query("ROLLBACK TO SAVEPOINT #{@db.transactions};")
-    @db.release
-     
-    res = @db.query('SELECT * FROM ' + table)
-    rows_rolled_back = res.fetch_all
-    res.free
-          
-    assert_equal(rows_committed, rows_rolled_back)
-    
-    # restore autocommit for remaining tests
-    @db.auto_commit(flag=true)    
-  end
-  
-  # tests on datatypes conversion
-  def test_char(table="test_monetdb_char", coldefs=["char_field CHAR(1)"])
-      test_create_table(table, coldefs)
-      char = 'a'
-
-      @db.query("INSERT INTO " + table  + " VALUES ( '" + char  +"' ) ")
-
-      res = @db.query("SELECT char_field FROM " + table + " where char_field = '" + char +"'")
-      stored_string = res.fetch_hash
-            
-      assert_equal(char, stored_string['char_field'])      
-  end
-  
-  def test_smallint(table="test_monetdb_smallint", coldefs=["int_field SMALLINT"])   
-      test_create_table(table, coldefs)
-       
-      original_num = rand(-32768, 32767)
-      num = original_num.to_s
-            
-      @db.query("INSERT INTO " + table  + " VALUES ('" + num  +"') ")
-
-      res = @db.query("SELECT int_field FROM " + table + " where int_field = '" + num +"'")
-
-      stored_string = res.fetch_hash
-      
-      assert_equal(num.to_i, stored_string['int_field'].getInt)      
-  end
- 
-  def test_int(table="test_monetdb_int", coldefs=["int_field INT"])
-      test_create_table(table, coldefs)
-      
-      original_num = rand((2 ** 31 -1))
-      num = original_num.to_s
-
-      @db.query("INSERT INTO " + table  + " VALUES ('" + num  +"') ")
-
-      res = @db.query("SELECT int_field FROM " + table + " where int_field = '" + num +"'")
-
-      stored_string = res.fetch_hash
-      
-      assert_equal(original_num, stored_string['int_field'].getInt)      
-  end
-
-  def test_bigint(table="test_monetdb_bigint", coldefs=["int_field BIGINT"])
-      test_create_table(table, coldefs)
-      
-      original_num = rand((2 ** 63 -1))
-      num = original_num.to_s
-     
-      @db.query("INSERT INTO " + table  + " VALUES ('" + num  +"') ")
-
-      res = @db.query("SELECT int_field FROM " + table + " where int_field = '" + num +"'")
-
-      stored_string = res.fetch_hash
-
-      assert_equal(original_num, stored_string['int_field'].getInt)      
-   end
-
-   def test_real(table="test_monetdb_real", coldefs=["float_field REAL"])
-     test_create_table(table, coldefs)
-     
-     original_num = 1.6065851e+20    
-     num = original_num.to_s
-
-     @db.query("INSERT INTO " + table  + " VALUES ('" + num  +"') ")
-
-     res = @db.query("SELECT float_field FROM " + table + " where float_field = '" + num +"'")
-
-     stored_string = res.fetch_hash
-
-     assert_equal(original_num, stored_string['float_field'].getFloat)       
-   end
-
-   def test_double(table="test_monetdb_double", coldefs=["float_field DOUBLE"])
-     test_create_table(table, coldefs)
-     
-     original_num = 1.6065851e+22     
-     num = original_num.to_s
-
-     @db.query("INSERT INTO " + table  + " VALUES ('" + num  +"') ")
-
-     res = @db.query("SELECT float_field FROM " + table + " where float_field = '" + num +"'")
-
-     stored_string = res.fetch_hash
-
-     assert_equal(original_num, stored_string['float_field'].getFloat)       
-   end
-
-   def test_boolean(table="test_monetdb_boolean", coldefs=["bool_field BOOLEAN"] )
-     test_create_table(table, coldefs)
-     
-     original_bool = false
-     bool = original_bool.to_s
-          
-     @db.query("INSERT INTO " + table  + " VALUES ('" + bool  +"') ")
-
-     res = @db.query("SELECT bool_field FROM " + table + " where bool_field = #{bool}")
-     stored_string = res.fetch_hash
-     assert_equal(original_bool, stored_string['bool_field'].getBool)     
-   end
-   
-   def test_datetime(table="test_monetdb_datetime", coldefs=["dt_field TIMESTAMP"])
-     test_create_table(table, coldefs)
-     
-     timestamp = "2009-07-01 15:34:33"
-     
-     date = timestamp.split(' ')[0].split('-')
-     time = timestamp.split(' ')[1].split(':')
-
-     dt = Time.gm(date[0], date[1], date[2], time[0], time[1], time[2])     
-     
-     @db.query("INSERT INTO " + table  + " VALUES ('" + timestamp  +"') ")
-
-     res = @db.query("SELECT dt_field FROM " + table + " where dt_field = '" + timestamp +"'")
-     stored_string = res.fetch_hash
-     assert_equal(dt, stored_string['dt_field'].getDateTime)      
-   end
-   
-   def test_date(table="test_monetdb_date", coldefs=["dt_field DATE"])
-     test_create_table(table, coldefs)
-     
-     timestamp = "2009-07-01"
-    
-     @db.query("INSERT INTO " + table  + " VALUES ('" + timestamp  +"') ")
-
-     res = @db.query("SELECT dt_field FROM " + table + " where dt_field = '" + timestamp +"'")
-     stored_string = res.fetch_hash
-     assert_equal(timestamp, stored_string['dt_field'].getDate)          
-   end
-    
-   def test_time(table="test_monetdb_time", coldefs=["dt_field TIME"])
-     test_create_table(table, coldefs)
-     
-     timestamp = "15:34:33"
-     
-     @db.query("INSERT INTO " + table  + " VALUES ('" + timestamp  +"') ")
-
-     res = @db.query("SELECT dt_field FROM " + table + " where dt_field = '" + timestamp +"'")
-     stored_string = res.fetch_hash
-     assert_equal(timestamp, stored_string['dt_field'].getTime)     
-   end
-   
-  def test_blob(table="test_monetdb_blob",  coldefs = ["blob_field BLOB"])
-    test_create_table(table, coldefs) 
-    
-    blob = '0000000A146F777BB46B8FBD46AD503A54629C51'
-
-    @db.query("INSERT INTO " + table  + " VALUES ('" + blob + "') ")
-     
-    res = @db.query("SELECT blob_field FROM " + table + " where blob_field = '#{blob}'")
-
-    stored_string = res.fetch_hash
-    assert_equal(blob, stored_string['blob_field'])    
-  end 
-   
-  def test_utf8(table="test_monetdb_utf8", coldefs=["utf8_field varchar(100000)"])
-    test_create_table(table, coldefs)
-    
-    utf8_string = "€¿®µ¶¹€¿®µ¶¹€¿®µ¶¹"
-    
-    @db.query("INSERT INTO " + table  + " VALUES ( '#{utf8_string}' ) ")
-        
-    res = @db.query("SELECT utf8_field FROM #{table} where utf8_field = '#{utf8_string}' ")
-    stored_string = res.fetch_hash
-  
-    assert_equal(utf8_string, stored_string['utf8_field'])    
-  end   
-  
-  # test MonetDB::conn() named parameters connection method.
-  def test_conn_with_named_parameters    
-    db = MonetDB.new()
-        
-    db.conn({ :user => "monetdb", :passwd => "monetdb", :port => 50000, :host => "localhost", :database => "ruby_test"})
-    assert_equal(true, db.is_connected?)
-    db.close
-  end
-  
-end
diff --git a/ruby-monetdb-sql-0.1.gemspec b/ruby-monetdb-sql-0.1.gemspec
deleted file mode 100644
index e773f0738fc2abb00c259f2a18acc5a9534ab703..0000000000000000000000000000000000000000
--- a/ruby-monetdb-sql-0.1.gemspec
+++ /dev/null
@@ -1,17 +0,0 @@
-
-Gem::Specification.new do |s|
-   s.required_ruby_version = '>= 2.1.0'
-   s.name = %q{ruby-monetdb-sql}
-   s.version = "0.2"
-   s.date = %q{2009-04-27}
-   s.authors = ["G Modena"]
-   s.email = %q{gm@cwi.nl}
-   s.summary = %q{Pure Ruby database driver for MonetDB/SQL}
-   s.homepage = %q{http://monetdb.cwi.nl/}
-   s.description = %q{Pure Ruby database driver for the MonetDB/SQL columnar database management system}
-   s.files = ["README", "lib/MonetDB.rb", "lib/MonetDBConnection.rb", "lib/MonetDBData.rb", "lib/MonetDBExceptions.rb", "lib/hasher.rb"]
-   s.has_rdoc = true
-   s.require_path = './lib'
-   # placeholder project to avoid warning about not having a rubyforge_project
-   s.rubyforge_project = "nowarning"
-end