imparcial 0.0.1

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

@@ -0,0 +1,214 @@
+module Imparcial
+  module Driver    
+    module TypemapBase 
+    
+      public
+    
+      # 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
+      
+      # The opposite of above.
+      
+      def sql_types
+      
+        regular_types.invert        
+        
+      end
+      
+      # 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
+    
+      # Transform regular user defined hash fields into a proper one.
+
+      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
+        
+        # Set default size if nothing has been supplied.
+        
+        field[:size] = default_size_for_types[field[:type]] unless field[:size]
+                        
+        # Primary key is set as false.
+        
+        field[:pk] ||= false
+                        
+        # Allow Null is set as true.        
+
+        field[:allow_null] = true if field[:allow_null] == nil
+        
+        # let's verify if everything is okay.
+        
+        if field[:auto_increment] && !field[:pk]        
+        
+          raise OptionError.new("To auto increment field must be primary key") 
+          
+        end
+        
+        field[:indexed] ||= false        
+                
+      end     
+
+      # 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
+     
+      # Transform a regular SQL column into RDBAL's hash.
+
+      def parse_column ( column )
+
+        # 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
+
+        column[:type] = type
+        
+        if column[:size]
+        
+          column[:size] = unquote_value(column[:size])
+        
+        end        
+        
+        # Let's work on default value.
+        
+        if column[:default_value]
+                
+          column[:default_value].gsub!("'",'')      
+        
+        end
+        
+        # Allow null?
+        
+        if column[:allow_null] == 't' || column[:allow_null] == 1
+          
+          column[:allow_null] = true
+          
+        else
+        
+          column[:allow_null] = false
+        
+        end
+        
+        # Is primary key?
+    
+        if column[:pk] == 't' || column[:pk] == 1
+
+          column[:pk] = true
+        
+        else  
+        
+          column[:pk] = false
+          
+        end
+ 
+        # Is automagically incremented?
+
+        if column[:auto_increment] == 1
+
+          column[:auto_increment] = true
+        
+        else
+
+          column[:auto_increment] = false          
+          
+        end
+        
+        if column[:indexed] == 't' || column[:indexed] == 1
+          
+          column[:indexed] = true
+        
+        else
+         
+          column[:indexed] = false
+          
+        end
+      
+      end
+      
+      # Iterate columns by parsing them.
+      
+      def parse_columns ( columns, &block )
+      
+        raise OptionError.new unless columns
+        raise OptionError.new if columns.length < 1
+        
+        for column in columns
+        
+          parse_column column
+          yield column
+          
+        end      
+      
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Imparcial
+  module Driver
+    module UtilBase
+    
+      # This method possibly will work for many databases.
+    
+      def quote_value ( val )
+      
+        if val.class == String || val.class == Symbol
+      
+          "\"#{val}\""
+          
+        else
+        
+          val.to_s
+          
+        end
+      
+      end
+      
+      # This method possibly will work for many databases.      
+      
+      def unquote_value ( val )
+        
+        return 0 if val == '0'
+        
+        val.to_i == 0 ? val : val.to_i
+        
+      end
+      
+      # Subclasses need to override it.
+      
+      def quote ( val )
+      
+        raise FeatureNotFound  
+      
+      end       
+                
+    end
+  end
+end

data/lib/imparcial/driver/base.rb

@@ -0,0 +1,156 @@
+require 'imparcial/driver/base/util'
+require 'imparcial/driver/base/typemap'
+require 'imparcial/driver/base/result'
+require 'imparcial/driver/base/sql'
+require 'imparcial/driver/base/expression'
+
+module Imparcial
+  module Driver
+  
+    # You have seriously to pay attention on this class.
+    # Basically speaking, it servers as base for all new drivers.
+    # The idea behind Imparcial is to keep an abstract interface without
+    # exposing any database-specific-features.
+    # Of course, it's an impossible mission anyhow. There are so many 
+    # databases 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.
+  
+    class AdapterBase
+    
+      # Include SQL syntax generation.
+      # Here where all SQL syntax lies on.
+      
+      include SQLBase
+    
+      # Include the expression mechanism.
+      # Things like create table, drop table, select and so forth.
+      # They all come from this module.
+    
+      include ExpressionBase
+      
+      # Include some util methods.
+      # Things like quoting columns, tables and values.
+      
+      include UtilBase
+      
+      # Include Typemap mechanism.
+      
+      include TypemapBase
+    
+      # Let's keep a track of the initializer. We'll need some info eventually.
+    
+      attr_reader :initializer
+      
+      # Let's also keep a track of the connection.
+      
+      attr_accessor :conn
+      alias_method  :connection, :conn
+      
+      attr_reader   :host, :user, :pass, :database, :socket, :port
+    
+      def initialize ( initializer )
+      
+        # Cannot accept classes different from Initializer.
+      
+        if initializer.class != Imparcial::Initializer
+
+          msg = 'An initializer is needed in order to start a driver'
+          raise AdapterConfigError.new(msg)
+          
+        end
+      
+        @initializer = initializer
+      
+        @host     = initializer.host
+        
+        if not initializer.user
+          
+          raise AdapterConfigError.new('Adapter requires an username')
+          
+        end
+        
+        @user     = initializer.user
+        
+        if not initializer.pass
+          
+          raise AdapterConfigError.new('Adapter requires a password')
+          
+        end
+        
+        @pass     = initializer.pass
+        
+        if not initializer.database
+          
+          raise AdapterConfigErrornew('Adapter requires a database')
+          
+        end        
+        
+        @database = initializer.database
+        @socket   = initializer.socket
+        @port     = initializer.port 
+      
+      end
+
+      #####################################################
+      #                                                   #
+      # Those are methods shared among all databases.     #
+      # Hardly, one will need to override them.           #
+      #                                                   #
+      #####################################################
+
+      def conn
+      
+        raise AdapterConnectionError.new('Have you connected?') unless @conn
+        @conn
+      
+      end
+
+      def close
+      
+        conn.close
+      
+      end
+                        
+      def result
+      
+        raise ResultError.new('Have you made a query?') unless @result
+        @result
+      
+      end
+
+      #####################################################
+      #                                                   #
+      # Subclasses must override those following methods. #
+      # They are driver-specific.                         #
+      #                                                   #
+      #####################################################
+      
+      def connect
+      
+        raise FeatureNotFound
+      
+      end
+            
+      def version
+      
+        raise FeatureNotFound
+      
+      end
+      
+      def query ( sql )
+            
+        raise FeatureNotFound
+      
+      end      
+      
+      def adapter_specific_exception
+        
+        raise FeatureNotFound
+        
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+module Imparcial
+  module Driver
+    module ExpressionMysql
+      module Index
+                
+        public
+
+        def drop_all_indexes          
+          
+          for index in retrieve_indexes
+
+            meta = {:index_name => index[:name], :table_name => index[:table]}
+            query sql_for_dropping_index(meta)
+          
+          end
+
+        rescue adapter_specific_exception => ex
+        
+          raise IndexDropError.new(ex.message)                       
+          
+        end       
+        
+        def drop_all_indexes_for_table ( options = {} )
+          
+          check_options expected_options_for_index_table, options      
+          
+          for index in retrieve_indexes_for_table options
+            
+            meta = {:index_name => index[:name], :table_name => options[:table_name]}
+            query sql_for_dropping_index(meta)
+          
+          end
+          
+        rescue adapter_specific_exception => ex
+        
+          raise IndexDropError.new(ex.message)                       
+          
+        end        
+                
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Imparcial
+  module Driver
+    module ExpressionMysql
+      module Table
+        
+        private
+        
+        def expected_options_for_creating_table
+          
+          super.merge :engine => :optional
+          
+        end
+                          
+        def field_to_column ( field )
+
+          column = super
+          column[:auto_increment] = field[:auto_increment] ? ' AUTO_INCREMENT' : ''
+        
+          column
+      
+        end         
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+require 'imparcial/driver/mysql/expression/table'
+require 'imparcial/driver/mysql/expression/index'
+
+module Imparcial
+  module Driver
+    module ExpressionMysql
+      include Table
+      include Index
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Imparcial
+  module Driver
+    class ResultMysql < ResultBase
+    
+      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/index.rb

@@ -0,0 +1,51 @@
+module Imparcial
+  module Driver
+    module SQLMysql   
+      module Index
+        
+        private
+        
+        def sql_for_dropping_index ( options )
+          
+          %{
+            DROP INDEX #{options[:index_name]} ON 
+            #{quote(options[:table_name])}
+          }
+          
+        end
+        
+        # Generate SQL statement for verifying if a given index exists.
+
+        def sql_for_index_exists? ( options )
+          
+          %{
+            SELECT 1 FROM INFORMATION_SCHEMA.statistics
+            WHERE INDEX_NAME = #{quote_value(options[:index_name])}
+          }
+          
+        end            
+        
+        def sql_for_retrieving_indexes
+          
+          %{
+          SELECT 
+            TABLE_NAME AS 'table',
+            COLUMN_NAME AS 'column',
+            INDEX_NAME AS 'index'
+            FROM INFORMATION_SCHEMA.statistics
+          }
+          
+        end
+        
+        def sql_for_retrieving_indexes_for_table ( options )
+          
+          sql_for_retrieving_indexes + %{
+          WHERE TABLE_NAME = #{quote_value(options[:table_name])}
+          }
+          
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Imparcial
+  module Driver
+    module SQLMysql
+      
+      # Mysql doesn't support sequences.
+      # We have to disable all them.
+    
+      module Sequence
+      
+        private
+        
+        def sql_for_creating_sequence ( options )
+      
+          raise FeatureNotFound
+        
+        end
+      
+        def sql_for_dropping_sequence ( options )
+
+          raise FeatureNotFound
+      
+        end
+            
+        def sql_for_sequence_exists? ( options )
+      
+          raise FeatureNotFound
+      
+        end
+            
+        def sql_for_retrieving_sequences
+      
+          raise FeatureNotFound
+      
+        end                        
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Imparcial
+  module Driver
+    module SQLMysql
+      module TableMetadata
+        
+        private
+                 
+        # Generate SQL statement for retrieving tables.
+        
+        def sql_for_retrieving_tables
+      
+          'SHOW TABLES'
+                
+        end  
+                
+        # Generate SQL statement for retrieving columns.
+        
+        def sql_for_retrieving_columns ( options = {} )
+        
+          %{
+            SELECT 
+            A.column_name, A.data_type, A.character_maximum_length as size,
+            (A.is_nullable = 'YES') as allow_null,
+            (A.column_name = B.column_name) as pk, 
+            A.column_default, 
+            A.extra  = 'auto_increment' as auto_inc,
+            A.column_name in (
+              SELECT s.COLUMN_NAME FROM INFORMATION_SCHEMA.statistics s 
+                WHERE s.COLUMN_NAME = A.column_name
+                             ) as indexed     
+                             
+            FROM information_schema.columns A 
+              LEFT JOIN information_schema.key_column_usage B ON  A.table_name = B.table_name 
+            WHERE A.table_name = #{quote_value(options[:table_name])}
+
+          }
+        
+        end          
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module Imparcial
+  module Driver
+    module SQLMysql
+      module TableOperation
+        
+        private
+        
+        def sql_for_creating_table ( options = {} )
+          
+          syntax  = super
+          syntax += 'ENGINE = ' + options[:engine].to_s if options[:engine]
+          
+          syntax
+          
+        end   
+        
+      end      
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+require 'imparcial/driver/mysql/sql/table_operation'
+require 'imparcial/driver/mysql/sql/table_metadata'
+require 'imparcial/driver/mysql/sql/sequence'
+require 'imparcial/driver/mysql/sql/index'
+
+module Imparcial
+  module Driver
+    module SQLMysql
+      include TableOperation
+      include TableMetadata
+      include Sequence
+      include Index
+    end
+  end
+end