monetdb 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MDVhN2NmYTg2YWQwZTA5M2ExNTg5NzVhZGMxNWY1YjBlY2U4YjcxOQ==
+  data.tar.gz: !binary |-
+    ZDdmNWE5YWI2NWI0ZjM4NGI1YWU0YTM3M2NkNjdmMzk2N2U3MjQyNg==
+SHA512:
+  metadata.gz: !binary |-
+    M2JjNTcwY2JjOWViMTM2YTVmOTFlZGQ0MWY0NDVlZDNiNjg3NGMyZmMzNmQ2
+    OGJhMjdjN2RlM2FiY2UyNzhjYjc5NDQ0NWRiMzdmMWM1M2VhZjAwNGM0M2Fh
+    OGY2NWVkYWMwYTc5MWRhYWZjYmI3Y2Y0MDFlOTAyY2UwY2UzYmU=
+  data.tar.gz: !binary |-
+    ZjNhMzJjMjUzODZiN2M4N2M1OWYyNjJjMzdjNmU3YzQzZWYyMGUyNjJkZmZk
+    N2Q2NmJiNWU3MDA0YmNhMzg4MjJjMDRkZGExZDhkOWFkYzU2MDhhNzZjZTVl
+    ZDk0MmZmODE5MTUwMmQwYjQxMDI0ZGZiZDM3YzZhNGJhYWFlNmQ=

data/.gitignore

@@ -0,0 +1,8 @@
+.DS_Store
+.bundle
+.yardoc
+.rvmrc
+Gemfile.lock
+doc
+pkg
+test/coverage

data/CHANGELOG.rdoc

@@ -0,0 +1,5 @@
+= MonetDB CHANGELOG
+
+== Version 0.1.0 (August 28, 2014)
+
+* Initial release

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    monetdb (0.1.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    coderay (1.1.0)
+    docile (1.1.5)
+    metaclass (0.0.4)
+    method_source (0.8.2)
+    minitest (5.4.0)
+    mocha (1.1.0)
+      metaclass (~> 0.0.1)
+    multi_json (1.10.1)
+    pry (0.10.0)
+      coderay (~> 1.1.0)
+      method_source (~> 0.8.1)
+      slop (~> 3.4)
+    rake (10.3.2)
+    simplecov (0.9.0)
+      docile (~> 1.1.0)
+      multi_json
+      simplecov-html (~> 0.8.0)
+    simplecov-html (0.8.0)
+    slop (3.6.0)
+    yard (0.8.7.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest
+  mocha
+  monetdb!
+  pry
+  rake
+  simplecov
+  yard

data/LICENSE

@@ -0,0 +1,17 @@
+The contents of this repository 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
+https://www.monetdb.org/Legal/MonetDBLicense
+
+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.

data/README.rdoc

@@ -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/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+task :default => :test
+
+Rake::TestTask.new do |test|
+  test.pattern = "test/**/test_*.rb"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/monetdb.rb

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