momomoto 0.1.0

data/lib/momomoto/datatype/real.rb

@@ -0,0 +1,7 @@
+module Momomoto
+  module Datatype
+    class Real < Numeric
+    
+    end
+  end
+end

data/lib/momomoto/datatype/smallint.rb

@@ -0,0 +1,7 @@
+module Momomoto
+  module Datatype
+    class Smallint < Integer
+    
+    end
+  end
+end

data/lib/momomoto/datatype/text.rb

@@ -0,0 +1,24 @@
+module Momomoto
+  module Datatype
+    class Text < Base
+
+      def escape( input )
+        if input.nil? || input.empty?
+          "NULL"
+        else
+          "'" + Database.escape_string( input.to_s ) + "'"
+        end
+      end
+
+      def self.operator_sign( op )
+        case op
+          when :like then 'LIKE'
+          when :ilike then 'ILIKE'
+          else
+            super( op )
+        end
+      end
+
+    end
+  end
+end

data/lib/momomoto/datatype/time_with_time_zone.rb

@@ -0,0 +1,10 @@
+
+require 'date'
+
+module Momomoto
+  module Datatype
+    class Time_with_time_zone < Time_without_time_zone
+    
+    end
+  end
+end

data/lib/momomoto/datatype/time_without_time_zone.rb

@@ -0,0 +1,30 @@
+
+require 'time'
+
+module Momomoto
+  module Datatype
+    class Time_without_time_zone < Base
+
+      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_set( 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
+
+    end
+  end
+end
+

data/lib/momomoto/datatype/timestamp_with_time_zone.rb

@@ -0,0 +1,7 @@
+module Momomoto
+  module Datatype
+    class Timestamp_with_time_zone < Timestamp_without_time_zone
+
+    end
+  end
+end

data/lib/momomoto/datatype/timestamp_without_time_zone.rb

@@ -0,0 +1,29 @@
+
+require 'date'
+
+module Momomoto
+  module Datatype
+    class Timestamp_without_time_zone < Base
+
+      def escape( value )
+        case value
+          when nil then 'NULL'
+          when String then "'#{Database.escape_string(value)}'"
+          else "'#{Database.escape_string(value.strftime('%Y-%m-%d %H:%M:%S'))}'"
+        end
+      end
+
+      def filter_set( 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 Timestamp"
+      end
+
+    end
+  end
+end

data/lib/momomoto/information_schema/columns.rb

@@ -0,0 +1,45 @@
+
+module Momomoto
+  module Information_schema
+    class Columns < Momomoto::Table
+      primary_keys( [] )
+      schema_name( "information_schema" )
+      columns( { :table_catalog             => Momomoto::Datatype::Text.new,
+                 :table_schema              => Momomoto::Datatype::Text.new,
+                 :table_name                => Momomoto::Datatype::Text.new,
+                 :column_name               => Momomoto::Datatype::Text.new,
+                 :ordinal_position          => Momomoto::Datatype::Integer.new,
+                 :column_default            => Momomoto::Datatype::Text.new,
+                 :is_nullable               => Momomoto::Datatype::Text.new,
+                 :data_type                 => Momomoto::Datatype::Text.new,
+                 :character_maximum_length  => Momomoto::Datatype::Integer.new,
+                 :character_octet_length    => Momomoto::Datatype::Integer.new,
+                 :numeric_precision         => Momomoto::Datatype::Integer.new,
+                 :numeric_precision_radix   => Momomoto::Datatype::Integer.new,
+                 :numeric_scale             => Momomoto::Datatype::Integer.new,
+                 :datetime_precision        => Momomoto::Datatype::Integer.new,
+                 :interval_type             => Momomoto::Datatype::Character_varying.new,
+                 :interval_precision        => Momomoto::Datatype::Character_varying.new,
+                 :character_set_catalog     => Momomoto::Datatype::Character_varying.new,
+                 :character_set_schema      => Momomoto::Datatype::Character_varying.new,
+                 :character_set_name        => Momomoto::Datatype::Character_varying.new,
+                 :collation_catalog         => Momomoto::Datatype::Character_varying.new,
+                 :collation_schema          => Momomoto::Datatype::Character_varying.new,
+                 :collation_name            => Momomoto::Datatype::Character_varying.new,
+                 :domain_catalog            => Momomoto::Datatype::Character_varying.new,
+                 :domain_schema             => Momomoto::Datatype::Character_varying.new,
+                 :domain_name               => Momomoto::Datatype::Character_varying.new,
+                 :udt_catalog               => Momomoto::Datatype::Character_varying.new,
+                 :udt_schema                => Momomoto::Datatype::Character_varying.new,
+                 :udt_name                  => Momomoto::Datatype::Character_varying.new,
+                 :scope_catalog             => Momomoto::Datatype::Character_varying.new,
+                 :scope_schema              => Momomoto::Datatype::Character_varying.new,
+                 :scope_name                => Momomoto::Datatype::Character_varying.new,
+                 :maximum_cardinality       => Momomoto::Datatype::Integer.new,
+                 :dtd_identifier            => Momomoto::Datatype::Character_varying.new,
+                 :is_self_referencing       => Momomoto::Datatype::Character_varying.new
+               } )
+    end
+  end
+end
+

data/lib/momomoto/information_schema/fetch_procedure_columns.rb

@@ -0,0 +1,14 @@
+
+module Momomoto
+  module Information_schema
+    class Fetch_procedure_columns < Momomoto::Procedure
+      schema_name( "momomoto" )
+      parameters( :procedure_name => Momomoto::Datatype::Text.new )
+      columns( { 
+                 :column_name               => Momomoto::Datatype::Text.new,
+                 :data_type                 => Momomoto::Datatype::Text.new
+               } )
+    end
+  end
+end
+

data/lib/momomoto/information_schema/fetch_procedure_parameters.rb

@@ -0,0 +1,14 @@
+
+module Momomoto
+  module Information_schema
+    class Fetch_procedure_parameters < Momomoto::Procedure
+      schema_name( "momomoto" )
+      parameters( :procedure_name => Momomoto::Datatype::Text.new )
+      columns( { 
+                 :parameter_name            => Momomoto::Datatype::Text.new,
+                 :data_type                 => Momomoto::Datatype::Text.new
+               } )
+    end
+  end
+end
+

data/lib/momomoto/information_schema/key_column_usage.rb

@@ -0,0 +1,19 @@
+
+module Momomoto
+  module Information_schema
+    class Key_column_usage < Momomoto::Table
+      primary_keys( [] )
+      schema_name( "information_schema" )
+      columns( { :constraint_catalog        => Momomoto::Datatype::Character_varying.new,
+                 :constraint_schema         => Momomoto::Datatype::Character_varying.new,
+                 :constraint_name           => Momomoto::Datatype::Character_varying.new,
+                 :table_catalog             => Momomoto::Datatype::Character_varying.new,
+                 :table_schema              => Momomoto::Datatype::Character_varying.new,
+                 :table_name                => Momomoto::Datatype::Character_varying.new,
+                 :column_name               => Momomoto::Datatype::Character_varying.new,
+                 :ordinal_position          => Momomoto::Datatype::Integer.new
+               } )
+    end
+  end
+end
+

data/lib/momomoto/information_schema/routines.rb

@@ -0,0 +1,12 @@
+
+module Momomoto
+
+  module Information_schema
+
+    class Routines < Momomoto::Table
+
+    end
+
+  end
+
+end

data/lib/momomoto/information_schema/table_constraints.rb

@@ -0,0 +1,19 @@
+
+module Momomoto
+  module Information_schema
+    class Table_constraints < Momomoto::Table
+      primary_keys( [] )
+      schema_name( "information_schema" )
+      columns( { :constraint_catalog        => Momomoto::Datatype::Text.new,
+                 :constraint_schema         => Momomoto::Datatype::Text.new,
+                 :constraint_name           => Momomoto::Datatype::Text.new,
+                 :table_catalog             => Momomoto::Datatype::Text.new,
+                 :table_schema              => Momomoto::Datatype::Text.new,
+                 :table_name                => Momomoto::Datatype::Text.new,
+                 :constraint_type           => Momomoto::Datatype::Text.new,
+                 :is_deferrable             => Momomoto::Datatype::Text.new,
+                 :initially_deferred        => Momomoto::Datatype::Text.new
+               } )
+    end
+  end
+end

data/lib/momomoto/join.rb

@@ -0,0 +1,66 @@
+
+module Momomoto
+
+  # this class implements the join functionality it is an abstract class
+  # it must not be used directly but you should inherit from this class
+  class Join < Base
+
+    attr_reader :base_table, :join_rules
+
+    # constructor of the join class
+    # base_table is the base table of the join
+    # join_rules is an array of Hashes consisting of the table to join as key
+    # and an symbol or an array of symbols on which fields to join the table
+    # Example: Momomoto::Join.new(Event, {Event_Person=>:event_id},{Person=>:person_id})
+    #          results in SELECT * FROM event INNER JOIN event_person USING (event_id) INNER JOIN Person USING(person_id)
+    # if you leave out the eclipit braces to mark the hash you may get
+    # unexpected results because of the undefined order of hashs
+    def initialize( base_table, *join_rules )
+      @base_table = base_table
+      @join_rules = join_rules
+
+      metaclass.instance_eval do
+        define_method( base_table.table_name ) do base_table end
+      end
+      join_rules.each do | rule |
+        rule.keys.each do | table, join_columns |
+          metaclass.instance_eval do
+            define_method( table.table_name ) do table end
+          end
+        end
+      end
+    end
+
+    def metaclass # :nodoc:
+      class << self; self; end
+    end
+
+    def class_variable_set( variable, value ) # :nodoc:
+      self.class.send( :class_variable_set, variable, value )
+    end
+
+    def select( conditions = {}, options = {} )
+      sql = "SELECT " + base_table.columns.keys.map{ | field | "#{base_table.table_name}.\"#{field}\"" }.join( "," )
+      join_rules.each do | rules |
+        rules.each do | table, fields |
+          sql += ','
+          sql += table.columns.keys.map{ | field | "#{table.table_name}.\"#{field}\"" }.join( ',' )
+        end
+      end
+      sql += " FROM "
+      sql += base_table.full_name
+      join_rules.each do | rules |
+        rules.each do | table_name, fields |
+          fields = fields.class === Array ? fields : [fields]
+          sql += " INNER JOIN #{table_name} USING(#{fields.join(', ')})"
+        end
+      end
+      sql += self.class.compile_where( conditions )
+      @data = []
+      self.class.database.execute( sql )
+    end
+
+  end
+
+end
+

data/lib/momomoto/momomoto.rb

@@ -0,0 +1,10 @@
+
+require 'momomoto/base'
+require 'momomoto/table'
+require 'momomoto/join'
+require 'momomoto/procedure'
+require 'momomoto/order'
+require 'momomoto/row'
+require 'momomoto/datatype'
+require 'momomoto/database'
+

data/lib/momomoto/order.rb

@@ -0,0 +1,56 @@
+
+module Momomoto
+
+  class Order
+
+    attr_accessor :fields
+
+    def initialize( *fields )
+      @fields = fields.flatten
+    end
+
+    def to_sql( columns )
+      sql = []
+      fields.each do | field |
+        if field.kind_of?( Momomoto::Order )
+          sql << function( field.to_sql( columns ) )
+        else
+          raise Momomoto::Error, "Unknown field #{field} in order" if not columns.keys.member?( field.to_sym )
+          sql << function( field  )
+        end
+      end
+      sql.join(',')
+    end
+
+    class Lower < Order
+      def initialize( *fields )
+        fields = fields.flatten
+        fields.each do | field |
+          raise Error, "Asc and Desc are only allowed as toplevel order elements" if field.kind_of?( Asc ) or field.kind_of?( Desc )
+        end
+        @fields = fields
+      end
+
+      def function( argument )
+        argument = [ argument ] if not argument.kind_of?( Array )
+        argument = argument.map{|a| "lower(#{a})"}
+        argument.join(',')
+      end
+    end
+
+    class Asc < Order
+      def function( argument )
+        "#{argument} asc"
+      end
+    end
+
+    class Desc < Order
+      def function( argument )
+        "#{argument} desc"
+      end
+    end
+
+  end
+
+end
+

data/lib/momomoto/procedure.rb

@@ -0,0 +1,129 @@
+
+module Momomoto
+
+  # this class implements access to stored procedures
+  # it must not be used directly but you should inherit from this class
+  class Procedure < Base
+
+    class << self
+
+      def initialize_procedure # :nodoc:
+
+        unless class_variables.member?( '@@procedure_name' )
+          procedure_name( construct_procedure_name( self.name ) )
+        end
+
+        unless class_variables.member?( '@@schema_name' )
+          schema_name( construct_schema_name( self.name ) )
+        end
+
+        unless class_variables.member?( '@@parameters' )
+          parameters( database.fetch_procedure_parameters( procedure_name ) )
+          raise CriticalError if not parameters
+        end
+
+        unless class_variables.member?( '@@columns' )
+          columns( database.fetch_procedure_columns( procedure_name ) )
+          raise CriticalError if not columns
+        end
+
+        const_set( :Row, Class.new( Momomoto::Row ) ) if not const_defined?( :Row )
+        initialize_row( const_get( :Row ), self )
+
+        # mark class as initialized
+        class_variable_set( :@@initialized, true)
+
+      end
+
+      # guesses the procedure name of the procedure this class works on
+      def construct_procedure_name( classname ) # :nodoc:
+        classname.split('::').last.downcase.gsub(/[^a-z_0-9]/, '')
+      end
+
+      # set the procedure name
+      def procedure_name=( procedure_name )
+        class_variable_set( :@@procedure_name, procedure_name )
+      end
+
+      # get the procedure name
+      def procedure_name( procedure_name = nil )
+        return self.procedure_name=( procedure_name ) if procedure_name
+        begin
+          class_variable_get( :@@procedure_name )
+        rescue NameError
+          construct_procedure_name( self.name )
+        end
+      end
+
+      # get the full name of the procedure including schema if set
+      def full_name # :nodoc:
+        "#{ schema_name ? schema_name + '.' : ''}#{procedure_name}"
+      end
+
+      # set the parameters this procedures accepts
+      # example: parameters = {:param1=>Momomoto::Datatype::Text.new}
+      # example: parameters = {:param1=>Momomoto::Datatype::Text.new}
+      def parameters=( *p )
+        p = p.flatten
+        class_variable_set( :@@parameters, p )
+      end
+
+      # get the parameters this procedure accepts
+      def parameters( *p )
+        return self.send( :parameters=, *p ) if not p.empty?
+        begin
+          class_variable_get( :@@parameters )
+        rescue NameError
+          initialize_procedure
+          class_variable_get( :@@parameters )
+        end
+      end
+
+      # get the columns of the resultset this procedure returns
+      def columns=( columns )
+        class_variable_set( :@@columns, columns)
+      end
+
+      # get the columns of the resultset this procedure returns
+      def columns( c = nil )
+        return self.columns=( c ) if c
+        begin
+          class_variable_get( :@@columns )
+        rescue NameError
+          initialize_procedure
+          class_variable_get( :@@columns )
+        end
+      end
+
+      def compile_parameter( params ) # :nodoc:
+        args = []
+        parameters.each do | parameter |
+          field_name, datatype = parameter.to_a.first
+          raise Error, "parameter #{field_name} not specified" if not params.member?( field_name )
+          args << datatype.escape( params[field_name] )
+        end
+        args.join(',')
+      end
+
+      # execute the stored procedure
+      def call( params = {}, conditions = {}, options = {} )
+        initialize_procedure unless class_variables.member?('@@initialized')
+        sql = "SELECT #{columns.keys.join(',')} FROM "
+        sql += "#{full_name}(#{compile_parameter(params)})"
+        sql += compile_where( conditions )
+        sql += compile_order( options[:order] ) if options[:order]
+        sql += compile_limit( options[:limit] ) if options[:limit]
+        sql += ';'
+        data = []
+        database.execute( sql ).each do | row |
+          data << const_get(:Row).new( row )
+        end
+        data
+      end
+
+    end
+
+  end
+
+end
+