imparcial 0.0.1 → 0.0.2

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

@@ -0,0 +1,103 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Column
+        
+        private        
+        
+        # Generate SQL statement for getting columns information.
+        # We need name, type and size.
+                
+        def sql_for_getting_columns_information ( options )
+                   
+          %{SELECT 
+              column_name, 
+              data_type, 
+              character_maximum_length
+            FROM INFORMATION_SCHEMA.columns
+            WHERE table_name = #{quote_value(options[:table_name])}
+           }
+          
+        end  
+        
+        # Generate SQL statement for getting column information.
+        # We need name, type and size. Quite similar to above, except, 
+        # it's a more narrow SQL.       
+        
+        def sql_for_getting_column_information ( options )
+          
+          %{SELECT 
+              column_name, 
+              data_type, 
+              character_maximum_length
+            FROM INFORMATION_SCHEMA.columns
+            WHERE table_name = #{quote_value(options[:table_name])} AND
+            column_name = #{quote_value(options[:field_name])}
+           }
+          
+        end   
+        
+        # Generate SQL statement for adding some columns.
+        # Alter table will do the job for us.
+        
+        def sql_for_adding_columns ( options )
+
+          syntax = ''
+        
+          syntax += 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+ 
+          parse_fields options[:fields] do |field|
+            
+            syntax += "ADD COLUMN " + field_to_column_sql(field) + ","
+
+          end
+          
+          syntax.chop!
+            
+          syntax
+        
+        end
+       
+        # Generate SQL statement for dropping some columns.
+        # Alter table will do the job for us.       
+       
+        def sql_for_dropping_columns ( options )
+
+          syntax = ''
+        
+          syntax += 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+ 
+          options[:fields].each do |field_name|
+                        
+            syntax += 'DROP ' + field_name + ','
+            
+          end
+          
+          syntax.chop!
+            
+          syntax
+        
+        end        
+
+        # Generate SQL statement for renaming a column.
+        # Must be overriden.
+        
+        def sql_for_renaming_column ( options )
+          
+          raise FeatureNotFound
+          
+        end
+        
+        # Generate SQL statement for modifying a column.
+        # Must be overriden.        
+
+        def sql_for_modifying_columns ( options )
+          
+          raise FeatureNotFound
+          
+        end
+       
+      end
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Constraint
+        
+        private
+        
+        def sql_for_adding_primary_key ( options )
+        
+          syntax  = 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+          syntax += 'ADD PRIMARY KEY ('
+          
+          for field_name in options[:fields]
+          
+            syntax += quote(field_name) + ','
+          
+          end
+        
+          syntax.chop!
+          syntax += ')'        
+          
+          syntax
+          
+        end
+        
+        def sql_for_adding_column ( options )
+          
+          raise FeatureNotFound
+          
+        end
+        
+        def sql_for_adding_default_value ( options )
+          
+          raise FeatureNotFound
+          
+        end
+        
+        
+      end
+    end
+  end
+end

data/lib/imparcial/driver/{base → abstract}/sql/delete.rb

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module SQLBase
+    module AbstractSQL
       module Delete
         
         private

data/lib/imparcial/driver/{base → abstract}/sql/index.rb

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module SQLBase
+    module AbstractSQL
       module Index
         
         private
@@ -32,20 +32,12 @@ module Imparcial
         
         # Subclasses need to override this method.
         
-        def sql_for_retrieving_indexes
+        def sql_for_getting_indexes
           
           raise FeatureNotFound
           
         end
-        
-        # Subclasses need to override this method.
-        
-        def sql_for_retrieving_indexes_for_table ( options )
-          
-          raise FeatureNotFound
-          
-        end
-        
+                
       end
     end
   end

data/lib/imparcial/driver/{base → abstract}/sql/insert.rb

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module SQLBase
+    module AbstractSQL
       module Insert
         
         private

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

@@ -0,0 +1,19 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Record
+                
+        private
+        
+        # Execute SQL statement for couting records of a table.
+        
+        def sql_for_couting_records ( options )
+          
+          'SELECT COUNT(*) FROM ' + quote(options[:table_name]) 
+          
+        end        
+        
+      end
+    end
+  end
+end

data/lib/imparcial/driver/{base → abstract}/sql/select.rb

@@ -1,10 +1,10 @@
 module Imparcial
   module Driver
-    module SQLBase
+    module AbstractSQL
       module Select
         
         private
-        
+               
         def get_key ( name, table_metadata )
           
           key_name = ('key_for_' + name.to_s).to_sym

data/lib/imparcial/driver/{base → abstract}/sql/sequence.rb

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module SQLBase
+    module AbstractSQL
       module Sequence
         
         private
@@ -43,7 +43,7 @@ module Imparcial
         # Generate SQL statement for retrieving sequences.
         # Subclasses must override this method.
         
-        def sql_for_retrieving_sequences
+        def sql_for_getting_sequences
           
           raise FeatureNotFound
           

data/lib/imparcial/driver/{base/sql/table_operation.rb → abstract/sql/table.rb}

@@ -1,12 +1,11 @@
 module Imparcial
   module Driver
-    module SQLBase
-      module TableOperation
+    module AbstractSQL
+      module Table
         
         private
         
         # Generate SQL statement for dropping table.
-        # This will probably work for every database.
       
         def sql_for_dropping_table ( options )
            
@@ -14,36 +13,30 @@ module Imparcial
                 
         end        
         
-        # Generate SQL statement for creating table.
-        # This will probably work for every database.        
+        # Generate SQL statement for creating table. 
       
         def sql_for_creating_table ( options )
 
           columns = []
-          keys    = []
 
           # Let's parse some columns in order to provide default options.
 
           parse_fields options[:fields] do |field|
-          
-            # Convert a regular field into SQL's one.
-          
-            columns << build_column( field )
-            keys    << quote(field[:name]) if field[:pk]
+
+            columns << field_to_column_sql(field)
         
           end                 
                
           syntax  = 'CREATE TABLE ' + quote( options[:table_name] )
           syntax += '('
           syntax += columns.join(',')
-          syntax += ', PRIMARY KEY(' + keys.join(',') + ')' if keys.length > 0
           syntax += ')'
 
           syntax
    
-        end        
-        
-      end      
+        end                        
+          
+      end
     end
   end
 end

data/lib/imparcial/driver/{base → abstract}/sql/transaction.rb

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module SQLBase
+    module AbstractSQL
       module Transaction
         
         private
@@ -23,17 +23,17 @@ module Imparcial
         
         # Generate SQL statement for rolling back a transaction.
         
-        def sql_for_rolling_back ( name = nil )
+        def sql_for_rolling_back ( options )
           
-          name == nil ? 'ROLLBACK' : 'ROLLBACK TO ' + name
+          options[:savepoint_name] == nil ? 'ROLLBACK' : 'ROLLBACK TO ' + options[:savepoint_name].to_s
           
         end
         
         # Generate SQL statement for placing a saving point.
                 
-        def sql_for_saving_point ( name )
+        def sql_for_saving_point ( options )
           
-          'SAVEPOINT ' + name
+          'SAVEPOINT ' + options[:savepoint_name].to_s
           
         end        
         

data/lib/imparcial/driver/{base → abstract}/sql/update.rb

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module SQLBase
+    module AbstractSQL
       module Update
         
         private

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/{base → abstract}/typemap.rb

@@ -1,9 +1,10 @@
 module Imparcial
   module Driver    
-    module TypemapBase 
+    module AbstractTypemap
     
       public
-    
+      
+      # === Description
       # Those are types shared among all databases.
       # Of course they are not enough. Feel free to override them
       # if necessary.
@@ -24,7 +25,8 @@ module Imparcial
         
       end
       
-      # The opposite of above.
+      # === Description
+      # The opposite of regular_types.
       
       def sql_types
       
@@ -32,6 +34,7 @@ module Imparcial
         
       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.
       
@@ -46,7 +49,8 @@ module Imparcial
           
       public
     
-      # Transform regular user defined hash fields into a proper one.
+      # === Description
+      # Validate a field.
 
       def parse_field ( field )
       
@@ -70,31 +74,16 @@ module Imparcial
 
         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
+        regular_types[field[:type]].length == 0 rescue raise OptionError.new("#{field[:type]} cannot be found")
         
-        # 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
+        # Set default size if nothing has been supplied.
         
-        field[:indexed] ||= false        
+        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.
@@ -115,9 +104,12 @@ module Imparcial
               
       end
      
-      # Transform a regular SQL column into RDBAL's hash.
+      # === Description
+      # Transform a regular SQL column into Imparcial's hash.
+
+      def column_to_field ( column = {} )
 
-      def parse_column ( column )
+        field = {}
 
         # Apply the appropriate type.
 
@@ -129,86 +121,48 @@ module Imparcial
           
         end
 
-        column[:type] = type
+        field[:name] = column[:name]
+        field[: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
+          field[:size] = unquote_value(column[:size])
         
         end
+      
+        field
         
-        # Is primary key?
-    
-        if column[:pk] == 't' || column[:pk] == 1
-
-          column[:pk] = true
-        
-        else  
+      end
+      
+      # === Description
+      # Make an Imparcial's hash into SQl's
+      
+      def field_to_column ( field = {} )
         
-          column[:pk] = false
-          
-        end
- 
-        # Is automagically incremented?
-
-        if column[:auto_increment] == 1
-
-          column[:auto_increment] = true
+        column = {}
         
-        else
+        column[:name] = quote(field[:name])
+        column[:type] = regular_types[field[:type]]
+        column[:size] = field[:size]
 
-          column[:auto_increment] = false          
-          
-        end
+        column
         
-        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 )
+      # === Description
+      # Transform a regular field into SQL syntax.
       
-        raise OptionError.new unless columns
-        raise OptionError.new if columns.length < 1
+      def field_to_column_sql ( field = {} )
         
-        for column in columns
+        column = field_to_column field
+        
+        syntax  = "#{column[:name]} #{column[:type]}"
+        syntax += "(#{column[:size]})" if column[:size]
+        
+        syntax
         
-          parse_column column
-          yield column
-          
-        end      
-      
       end
-
+      
     end
   end
 end

data/lib/imparcial/driver/{base → abstract}/util.rb

@@ -1,8 +1,9 @@
 module Imparcial
   module Driver
-    module UtilBase
+    module AbstractUtil
     
-      # This method possibly will work for many databases.
+      # === Description
+      # Apply default database value quoting system.
     
       def quote_value ( val )
       
@@ -18,17 +19,28 @@ module Imparcial
       
       end
       
-      # This method possibly will work for many databases.      
+      # === Description
+      # Apply default database value unquoting system.      
       
       def unquote_value ( val )
         
+        return nil if val == nil
         return 0 if val == '0'
         
-        val.to_i == 0 ? val : val.to_i
+        if val.match(/[0-9]\.[0-9]*/)
+          
+          val.to_f
+          
+        else
+        
+          val.to_i == 0 ? val : val.to_i
+          
+        end
         
       end
       
-      # Subclasses need to override it.
+      # === Description
+      # Apply default database quoting system.
       
       def quote ( val )