imparcial 0.0.4 → 0.0.5

data/lib/imparcial/driver/abstract/sql/update.rb

@@ -0,0 +1,29 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Update
+        
+        private
+        
+        def sql_for_updating ( options )
+
+          syntax = 'UPDATE ' + quote(options[:table_name]) + ' SET '          
+        
+          options[:values].each do |name, value|
+        
+            syntax += quote(name) + ' = ' + quote_value(value) + ','
+        
+          end
+        
+          syntax.chop!
+        
+          syntax += parse_conditions options[:conditions]         
+          
+          syntax
+          
+        end
+    
+      end
+    end
+  end
+end

data/lib/imparcial/driver/abstract/sql.rb

@@ -0,0 +1,21 @@
+FileList[File.dirname(__FILE__)  + '/sql/*.rb'].each do |f|
+  require f
+end
+
+module Imparcial
+  module Driver
+    module AbstractSQL
+      include Table
+      include Sequence
+      include Transaction
+      include Index
+      include Insert
+      include Delete
+      include Select
+      include Update
+      include Column
+      include Constraint
+      include Record
+    end
+  end
+end

data/lib/imparcial/driver/abstract/typemap.rb

@@ -0,0 +1,168 @@
+module Imparcial
+  module Driver    
+    module AbstractTypemap
+    
+      public
+      
+      # === Description
+      # Those are types shared among all databases.
+      # Of course they are not enough. Feel free to override them
+      # if necessary.
+    
+      def regular_types
+      
+        {
+        :integer    => 'INTEGER',
+        :string     => 'VARCHAR',
+        :float      => 'FLOAT',
+        :datetime   => 'DATETIME',
+        :time       => 'TIME',
+        :date       => 'DATE',
+        :text       => 'TEXT',
+        :boolean    => 'TINYINT',
+        :serial     => 'SERIAL'
+        }
+        
+      end
+      
+      # === Description
+      # The opposite of regular_types.
+      
+      def sql_types
+      
+        regular_types.invert        
+        
+      end
+      
+      # === Description
+      # Default size can be very handy when users are lazy to supply them
+      # or they expect a given type to be in a default size.
+      
+      def default_size_for_types
+        
+        {
+        :string   => 255,
+        :boolean  => 1
+        }
+        
+      end
+          
+      public
+    
+      # === Description
+      # Validate a field.
+
+      def parse_field ( field )
+      
+        # No name? error!
+        
+        if not field[:name]
+          
+          raise OptionError.new('A name must be supplied')
+          
+        end
+
+        # No type? error!
+        
+        if not field[:type]
+          
+          raise OptionError.new('A type must be supplied')
+        
+        end
+      
+        # Simple conversions.
+
+        field[:name] = field[:name].to_s
+        field[:type] = field[:type].to_sym
+
+        regular_types[field[:type]].length == 0 rescue raise OptionError.new("#{field[:type]} cannot be found")
+        
+        # Set default size if nothing has been supplied.
+        
+        field[:size] = default_size_for_types[field[:type]] unless field[:size]    
+                
+      end     
+
+      # === Description
+      # In order to work with fields in RDBAL, you have to provide
+      # field datas in hashes.
+      # This function is basically evaluate them and pass into a block.
+
+      def parse_fields ( fields = [], &block )
+
+        # At least a field must be supplied.
+
+        raise OptionError.new unless fields
+        raise OptionError.new if fields.length < 1
+
+        for field in fields
+        
+          parse_field field
+          yield field
+                  
+        end
+              
+      end
+     
+      # === Description
+      # Transform a regular SQL column into Imparcial's hash.
+
+      def column_to_field ( column = {} )
+
+        field = {}
+
+        # Apply the appropriate type.
+
+        type = sql_types[column[:type].upcase]
+        
+        if not type
+          
+          raise OptionError.new('Cannot map column type: ' + column[:type].to_s)
+          
+        end
+
+        field[:name] = column[:name]
+        field[:type] = type
+        
+        if column[:size]
+        
+          field[:size] = unquote_value(column[:size])
+        
+        end
+      
+        field
+        
+      end
+      
+      # === Description
+      # Make an Imparcial's hash into SQl's
+      
+      def field_to_column ( field = {} )
+        
+        column = {}
+        
+        column[:name] = quote(field[:name])
+        column[:type] = regular_types[field[:type]]
+        column[:size] = field[:size]
+
+        column
+        
+      end
+      
+      # === Description
+      # Transform a regular field into SQL syntax.
+      
+      def field_to_column_sql ( field = {} )
+        
+        column = field_to_column field
+        
+        syntax  = "#{column[:name]} #{column[:type]}"
+        syntax += "(#{column[:size]})" if column[:size]
+        
+        syntax
+        
+      end
+      
+    end
+  end
+end

data/lib/imparcial/driver/abstract/util.rb

@@ -0,0 +1,53 @@
+module Imparcial
+  module Driver
+    module AbstractUtil
+    
+      # === Description
+      # Apply default database value quoting system.
+    
+      def quote_value ( val )
+      
+        if val.class == String || val.class == Symbol
+      
+          "\"#{val}\""
+          
+        else
+        
+          val.to_s
+          
+        end
+      
+      end
+      
+      # === Description
+      # Apply default database value unquoting system.      
+      
+      def unquote_value ( val )
+        
+        return nil if val == nil
+        return 0 if val == '0'
+        
+        if val.match(/[0-9]\.[0-9]*/)
+          
+          val.to_f
+          
+        else
+        
+          val.to_i == 0 ? val : val.to_i
+          
+        end
+        
+      end
+      
+      # === Description
+      # Apply default database quoting system.
+      
+      def quote ( val )
+      
+        raise FeatureNotFound  
+      
+      end       
+                
+    end
+  end
+end

data/lib/imparcial/driver/abstract.rb

@@ -0,0 +1,255 @@
+require 'logger'
+
+require 'imparcial/driver/abstract/util'
+require 'imparcial/driver/abstract/result'
+require 'imparcial/driver/abstract/typemap'
+require 'imparcial/driver/abstract/sql'
+require 'imparcial/driver/abstract/expression'
+
+module Imparcial
+  module Driver
+  
+    # You have seriously to pay attention on this class.
+    # Basically speaking, it servers as abstraction for all new drivers.
+    # The idea behind Imparcial is to keep an abstract interface without
+    # exposing any dataabstract-specific-features.
+    # Of course, it's an impossible mission anyhow. There are so many 
+    # dataabases out there and there are so many cool features that
+    # make impossible not to expose them.
+    # We recommend you to obey the interface as much as possible.
+    # However you may develop some specific features.
+    # Please, keep an eye on specification(can be found in the website).
+  
+    class AbstractAdapter
+    
+      # Include SQL syntax generation.
+      # Here where all SQL syntax lies on.
+      
+      include AbstractSQL
+    
+      # Include the expression mechanism.
+      # Things like create table, drop table, select and so forth.
+      # They all come from this module.
+    
+      include AbstractExpression
+      
+      # Include some util methods.
+      # Things like quoting, unquoting.
+      
+      include AbstractUtil
+      
+      # Include Typemap mechanism.
+      
+      include AbstractTypemap
+         
+      # Let's also keep a track of the connection.
+      
+      attr_accessor :conn
+      alias_method  :connection, :conn
+      
+      # A logger is also required.
+      
+      attr_accessor :logger
+      
+      attr_accessor :host, :adapter, :port, :username, :password, :socket, :database
+      
+      #####################################################
+      #                                                   #
+      # Those are methods shared among all databases.     #
+      # Hardly, one will need to override them.           #
+      #                                                   #
+      #####################################################
+
+      # === Description
+      # Display connection handle.
+      # 
+      # === Returning
+      # a handle.
+
+      def conn
+      
+        raise AdapterConnectionError.new('Have you connected already?') unless @conn
+        @conn
+      
+      end
+    
+      # === Description
+      # Terminate a connection.
+      # 
+      # === Returning
+      # nothing.    
+
+      def close
+      
+        conn.close
+      
+      end
+    
+      # === Description
+      # After executing a statement, the method query will bring a result.
+      # 
+      # === Returning
+      # result to a query.  
+                        
+      def result
+      
+        raise ResultError.new('Have you made any query?') unless @result
+        @result
+      
+      end
+
+      #####################################################
+      #                                                   #
+      # Subclasses must override those following methods. #
+      # They are driver-specific.                         #
+      #                                                   #
+      #####################################################
+      
+      # === Description
+      # Stablish a connection.
+      # 
+      # === Returning
+      # nothing.    
+      
+      def connect
+      
+        raise FeatureNotFound
+      
+      end
+    
+      # === Description
+      # Execute a statement directly to the adapter.
+      # 
+      # === Returning
+      # The method result will be avaliable.    
+                  
+      def query ( sql )
+            
+        raise FeatureNotFound
+      
+      end     
+  
+      # === Description
+      # get the adapter specific's exception.
+      # 
+      # === Returning
+      # an exception class.     
+      
+      def adapter_specific_exception
+        
+        raise FeatureNotFound
+        
+      end
+      
+      def last_insert_id
+        
+        raise FeatureNotFound
+        
+      end
+      
+      public
+      
+      #####################################################
+      #                                                   #
+      #                Logging mechanism                  #
+      #                                                   #
+      #####################################################   
+
+      def enable_table_logging
+        
+        @table_logging = true
+        
+      end
+      
+      def disable_table_logging
+        
+        @table_logging = false
+        
+      end
+      
+      def enable_column_logging
+        
+        @column_logging = true
+        
+      end
+      
+      def disable_column_logging
+        
+        @column_logging = false
+        
+      end
+      
+      def enable_index_logging
+        
+        @index_logging = true
+        
+      end
+      
+      def disable_index_logging
+        
+        @index_logging = false
+        
+      end      
+      
+      def enable_select_logging
+        
+        @select_logging = true
+        
+      end
+      
+      def disable_select_logging
+        
+        @select_logging = false
+        
+      end 
+      
+      def enable_update_logging
+        
+        @update_logging = true
+        
+      end
+      
+      def disable_update_logging
+        
+        @update_logging = false
+        
+      end
+      
+      def enable_insert_logging
+        
+        @insert_logging = true
+        
+      end
+      
+      def disable_insert_logging
+        
+        @insert_logging = false
+        
+      end      
+      
+      def enable_sequence_logging
+        
+        @sequence_logging = true
+        
+      end
+      
+      def disable_sequence_logging
+        
+        @sequence_logging = false
+        
+      end  
+      
+      def enable_record_logging
+        
+        @record_logging = true
+        
+      end
+      
+      def disable_record_logging
+        
+        @record_logging = false
+        
+      end       
+    end
+  end
+end

data/lib/imparcial/driver/mysql/expression/table.rb

@@ -0,0 +1,17 @@
+module Imparcial
+  module Driver
+    module MysqlExpression
+      module Table
+        
+        private
+        
+        def expected_options_for_creating_table
+          
+          super.merge :engine => :optional
+          
+        end    
+        
+      end
+    end
+  end
+end

data/lib/imparcial/driver/mysql/expression.rb

@@ -0,0 +1,11 @@
+FileList[File.dirname(__FILE__)  + '/expression/*.rb'].each do |f|
+  require f
+end
+
+module Imparcial
+  module Driver
+    module MysqlExpression
+      include Table
+    end
+  end
+end

data/lib/imparcial/driver/mysql/result.rb

@@ -0,0 +1,33 @@
+module Imparcial
+  module Driver
+    class MysqlResult < AbstractResult
+    
+      def rows
+      
+        @specific.num_rows
+      
+      end
+      
+      def fetch
+
+        fields = @specific.fetch_fields
+                
+        @specific.each do |row|
+          
+          v = []
+          
+          row.each_with_index do |r, index|
+           
+            v << Row.new(fields[index].name, r)
+            
+          end
+          
+          yield(*v)
+          
+        end                 
+
+      end      
+    
+    end
+  end
+end

data/lib/imparcial/driver/mysql/sql/column.rb

@@ -0,0 +1,59 @@
+module Imparcial
+  module Driver
+    module MysqlSQL
+      module Column
+        
+        private
+        
+        def sql_for_modifying_columns ( options )
+
+          syntax = ''
+        
+          syntax += 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+ 
+          options[:fields].each do |field|
+            
+            column = field_to_column field
+                         
+            syntax += "MODIFY COLUMN #{column[:name]} #{column[:type]}"
+            syntax += "(#{column[:size]})" if column[:size]
+            
+            syntax += ','
+            
+          end
+          
+          syntax.chop!
+                      
+          syntax
+        
+        end   
+      
+        def sql_for_renaming_column ( options )        
+          
+          old_name = options[:field].keys.first
+          new_name = options[:field].values.first
+          
+          field = get_column_information :table_name => options[:table_name], :field_name => old_name
+
+          column = field_to_column field
+                                        
+          syntax = ''
+        
+          syntax += 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+                        
+          syntax += "CHANGE COLUMN #{column[:name]}"
+          syntax += " #{quote(new_name)}"
+          syntax += " #{column[:type]}" 
+          syntax += "(#{column[:size]})" if column[:size]
+          syntax += ','
+            
+          syntax.chop!
+                      
+          syntax
+          
+        end
+            
+      end
+    end
+  end
+end

data/lib/imparcial/driver/mysql/sql/constraint.rb

@@ -0,0 +1,39 @@
+module Imparcial
+  module Driver
+    module MysqlSQL
+      module Constraint
+
+        private
+
+        def sql_for_adding_auto_increment ( options )
+         
+          syntax  = 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+          
+          syntax += "MODIFY COLUMN #{quote(options[:field])} INTEGER NOT NULL AUTO_INCREMENT"
+
+          syntax          
+          
+        end        
+        
+        def sql_for_adding_default_value ( options )
+          
+          syntax  = 'ALTER TABLE ' + quote(options[:table_name]) + ' '   
+          
+          for field, value in options[:fields]
+          
+            syntax += "ALTER COLUMN #{quote(field)} SET DEFAULT #{quote_value(value)},"
+            
+          end
+          
+          syntax.chop!
+     
+          syntax               
+          
+        end
+        
+     
+        
+      end
+    end
+  end
+end