momomoto 0.1.0

data/lib/momomoto/database.rb

@@ -0,0 +1,179 @@
+
+begin
+  require 'rubygems'
+  require_gem 'ruby-postgres', '>= 0.7.1.2006.04.06'
+rescue LoadError
+  require 'postgres'
+end
+
+require 'singleton'
+
+require 'momomoto/information_schema/columns'
+require 'momomoto/information_schema/table_constraints'
+require 'momomoto/information_schema/key_column_usage'
+require 'momomoto/information_schema/routines'
+require 'momomoto/information_schema/fetch_procedure_columns'
+require 'momomoto/information_schema/fetch_procedure_parameters'
+
+## Momomoto is a database abstraction layer
+module Momomoto
+
+  ## Momomoto Connection class
+  class Database
+    include Singleton
+
+    # establish connection to the database
+    # expects a hash with the following keys: host, port, database,
+    # username, password, pgoptions and pgtty
+    def config( config )
+      config ||= {}
+      # we also accept String keys in the config hash
+      config.each do | key, value |
+        config[key.to_sym] = value unless key.kind_of?( Symbol )
+        config[key.to_sym] = value.to_s if value.kind_of?(Symbol)
+      end
+      @config = config
+    end
+
+    def self.config( conf )
+      instance.config( conf )
+    end
+
+    def initialize # :nodoc:
+      @config = {}
+      @connection = nil
+    end
+
+    def connect
+      @connection.close if @connection
+      @transaction_active = false
+      PGconn.translate_results = true
+      @connection = PGconn.connect( @config[:host], @config[:port], @config[:pgoptions],
+                      @config[:pgtty], @config[:database], @config[:username],
+                      @config[:password])
+    rescue => e
+      raise CriticalError, "Connection to database failed: #{e}"
+    end
+
+    def self.connect
+      instance.connect
+    end
+
+    # terminate this connection
+    def disconnect
+      @connection.close
+      @connection = nil
+      @transaction_active = true
+    end
+
+    # execute a query
+    def execute( sql ) # :nodoc:
+      puts sql if Momomoto.debug
+      @connection.query( sql )
+     rescue => e
+      raise CriticalError, "#{e}: #{sql}"
+    end
+
+    # fetch columns which are primary key columns
+    # should work with any SQL2003 compliant DBMS
+    def fetch_primary_keys( table_name, schema_name = nil ) # :nodoc:
+      pkeys = []
+      conditions = {:table_name=>table_name, :constraint_type => 'PRIMARY KEY'}
+      conditions[:table_schema] = schema_name if schema_name
+      keys = Momomoto::Information_schema::Table_constraints.select( conditions )
+      if keys.length != 0
+        cols = Momomoto::Information_schema::Key_column_usage.select(
+            { :table_name => keys[0].table_name,
+              :table_schema => keys[0].table_schema,
+              :constraint_name => keys[0].constraint_name,
+              :constraint_schema => keys[0].constraint_schema } )
+        cols.each do | key |
+          pkeys << key.column_name.to_sym
+        end
+      end
+      pkeys
+    end
+
+    # fetch column definitions from database
+    # should work with any SQL2003 compliant DBMS
+    def fetch_table_columns( table_name, schema_name = nil ) # :nodoc:
+      columns = {}
+      conditions = { :table_name => table_name }
+      conditions[:table_schema] = schema_name if schema_name
+      cols = Momomoto::Information_schema::Columns.select( conditions )
+      raise CriticalError, "Table without columns" if cols.length < 1
+      cols.each do  | col |
+        columns[col.column_name.to_sym] = Momomoto::Datatype.const_get(col.data_type.gsub(' ','_').capitalize).new( col )
+      end
+      columns
+    end
+
+    # fetches the parameter of a stored procedure
+    def fetch_procedure_parameters( procedure_name, schema_name = nil ) # :nodoc:
+      p = []
+      conditions = { :procedure_name => procedure_name }
+      params = Momomoto::Information_schema::Fetch_procedure_parameters.call( conditions )
+      params.each do  | param |
+        p << { param.parameter_name.to_sym => Momomoto::Datatype.const_get(param.data_type.gsub(' ','_').capitalize).new }
+      end
+      p
+    end
+
+    # fetches the resultset columns of a stored procedure
+    def fetch_procedure_columns( procedure_name, schema_name = nil ) # :nodoc:
+      c = {}
+      conditions = { :procedure_name => procedure_name }
+      cols = Momomoto::Information_schema::Fetch_procedure_columns.call( conditions )
+      cols.each do  | col |
+        c[col.column_name.to_sym] = Momomoto::Datatype.const_get(col.data_type.gsub(' ','_').capitalize).new
+      end
+      c
+    end
+
+
+    # begin a transaction
+    def begin
+      execute( "BEGIN;" )
+      @transaction_active = true
+    end
+
+    # executes the block and commits the transaction if a block is given
+    # otherwise simply starts a new transaction
+    def transaction
+      raise Error, "Transaction active" if @transaction_active
+      self.begin
+      begin
+        yield
+      rescue => e
+        rollback
+        raise e
+      end
+      commit
+    end
+
+    # commit the current transaction
+    def commit
+      raise Error if not @transaction_active
+      execute( "COMMIT;" )
+      @transaction_active = false
+    end
+
+    # roll the transaction back
+    def rollback
+      raise Error if not @transaction_active
+      execute( "ROLLBACK;" )
+      @transaction_active = false
+    end
+
+    def self.escape_string( input )
+      PGconn.escape( input )
+    end
+
+    def self.escape_bytea( input )
+      PGconn.escape_bytea( input )
+    end
+
+  end
+
+end
+

data/lib/momomoto/datatype.rb

@@ -0,0 +1,20 @@
+
+require 'momomoto/datatype/base'
+require 'momomoto/datatype/boolean'
+require 'momomoto/datatype/integer'
+require 'momomoto/datatype/smallint'
+require 'momomoto/datatype/bigint'
+require 'momomoto/datatype/text'
+require 'momomoto/datatype/character'
+require 'momomoto/datatype/character_varying'
+require 'momomoto/datatype/numeric'
+require 'momomoto/datatype/real'
+require 'momomoto/datatype/bytea'
+require 'momomoto/datatype/date'
+require 'momomoto/datatype/time_without_time_zone'
+require 'momomoto/datatype/interval'
+require 'momomoto/datatype/time_with_time_zone'
+require 'momomoto/datatype/timestamp_without_time_zone'
+require 'momomoto/datatype/timestamp_with_time_zone'
+require 'momomoto/datatype/inet'
+

data/lib/momomoto/datatype/base.rb

@@ -0,0 +1,78 @@
+
+module Momomoto
+
+  module Datatype
+    # base class for all datatypes
+    class Base
+      # get the default value for this column
+      # returns false if none exists
+      def default
+        @default
+      end
+
+      # is this column a not null column
+      def not_null?
+        @not_null
+      end
+
+      def initialize( row = nil )
+        @not_null = row.respond_to?(:is_nullable) && row.is_nullable == "NO"
+        @default = row.respond_to?( :column_default) && row.column_default
+      end
+
+      # values are filtered by this function when being set
+      def filter_set( value ) # :nodoc:
+        value
+      end
+
+      def escape( input )
+        input.nil? ? "NULL" : "'" + Database.escape_string( input.to_s ) + "'"
+      end
+
+      # this functions is used for compiling the where clause
+      def compile_rule( field_name, value ) # :nodoc:
+        case value
+          when nil then
+            raise Error, "nil values not allowed for #{field_name}"
+          when Array then
+            raise Error, "empty array conditions are not allowed for #{field_name}" if value.empty?
+            raise Error, "nil values not allowed in compile_rule for #{field_name}" if value.member?( nil )
+            field_name.to_s + ' IN (' + value.map{ | v | escape(filter_set(v)) }.join(',') + ')'
+          when Hash then
+            raise Error, "empty hash conditions are not allowed for #{field_name}" if value.empty?
+            rules = []
+            value.each do | op, v |
+              raise Error, "nil values not allowed in compile_rule for #{field_name}" if v == nil
+              v = [v] if not v.kind_of?( Array )
+              if op == :eq # use IN if comparing for equality
+                rules << compile_rule( field_name, v )
+              else
+                v.each do | v2 |
+                  rules << field_name.to_s + ' ' + self.class.operator_sign(op) + ' ' + escape(filter_set(v2))
+                end
+              end
+            end
+            rules.join( " AND " )
+          else
+            field_name.to_s + ' = ' + escape(filter_set(value))
+        end
+      end
+
+      def self.operator_sign( op )
+        case op
+          when :le then '<='
+          when :lt then '<'
+          when :ge then '>='
+          when :gt then '>'
+          when :eq then '='
+          when :ne then '<>'
+          else
+            raise CriticalError, "unsupported operator"
+        end
+      end
+
+    end
+
+  end
+end
+

data/lib/momomoto/datatype/bigint.rb

@@ -0,0 +1,9 @@
+module Momomoto
+  module Datatype
+
+    class Bigint < Integer
+    
+    end
+
+  end
+end

data/lib/momomoto/datatype/boolean.rb

@@ -0,0 +1,23 @@
+module Momomoto
+  module Datatype
+    class Boolean < Base
+
+      def filter_set( value )
+        case value
+          when true, 1, 't', 'true', 'on' then true
+          when false, 0, 'f', 'false', 'off' then false
+          else not_null? ? false : nil
+        end
+      end
+
+      def escape( input )
+        case input
+          when true, 1, 't', 'true', 'on' then "'t'"
+          when false, 0, 'f', 'false', 'off' then "'f'"
+          else "NULL"
+        end
+      end
+
+    end
+  end
+end

data/lib/momomoto/datatype/bytea.rb

@@ -0,0 +1,13 @@
+
+module Momomoto
+  module Datatype
+    class Bytea < Base
+
+      def escape( input )
+        input.nil? ? "NULL" : "'" + Database.escape_bytea( input ) + "'"
+      end
+
+    end
+  end
+end
+

data/lib/momomoto/datatype/character.rb

@@ -0,0 +1,7 @@
+module Momomoto
+  module Datatype
+    class Character < Text
+    
+    end
+  end
+end

data/lib/momomoto/datatype/character_varying.rb

@@ -0,0 +1,7 @@
+module Momomoto
+  module Datatype
+    class Character_varying < Text
+    
+    end
+  end
+end

data/lib/momomoto/datatype/date.rb

@@ -0,0 +1,22 @@
+
+require 'date'
+
+module Momomoto
+  module Datatype
+    class Date < Base
+
+      def filter_set( value )
+        case value
+          when nil,'' then nil
+          when ::Date then value
+          when String then ::Date.parse( value, '%Y-%m-%d' )
+          else raise Error
+        end
+       rescue => e 
+        raise ConversionError, "parse Error in Date #{e}"
+      end
+    
+    end
+  end
+end
+

data/lib/momomoto/datatype/inet.rb

@@ -0,0 +1,14 @@
+module Momomoto
+  module Datatype
+    class Inet < Text
+
+      def filter_set( value )
+        case value
+          when nil, '' then nil
+          else value
+        end
+      end
+    
+    end
+  end
+end

data/lib/momomoto/datatype/integer.rb

@@ -0,0 +1,16 @@
+module Momomoto
+  module Datatype
+    class Integer < Base
+
+      def filter_set( value )
+        case value
+          when nil, '' then nil
+          else Integer( value )
+        end
+       rescue => e
+        raise ConversionError, e.to_s
+      end
+
+    end
+  end
+end

data/lib/momomoto/datatype/interval.rb

@@ -0,0 +1,30 @@
+module Momomoto
+  module Datatype
+    class Interval < Time_without_time_zone
+
+      def escape( value )
+        case value
+          when nil then 'NULL'
+          when String then "'#{Database.escape_string(value)}'"
+          else "'#{Database.escape_string(value.strftime('%H:%M:%S'))}'"
+        end
+      end
+
+      def filter_get( value )
+        case value
+          when nil, '' then nil
+          when ::Time then value
+          when String then ::Time.parse( value )
+          else raise Error
+        end
+       rescue => e
+        raise ConversionError, 'Error while parsing time'
+      end
+
+      def filter_set( value )
+        filter_get( value )
+      end
+
+    end
+  end
+end

data/lib/momomoto/datatype/numeric.rb

@@ -0,0 +1,17 @@
+
+module Momomoto
+  module Datatype
+    class Numeric < Base
+
+      def filter_set( value )
+        case value
+          when nil, '' then nil
+          else Float( value )
+        end
+      rescue => e
+        raise ConversionError, e.to_s
+      end
+
+    end
+  end
+end