imparcial 0.0.1 → 0.0.2

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

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module ExpressionBase
+    module AbstractExpression
       module Statement
     
         private

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

@@ -0,0 +1,416 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Table        
+        
+        ###########################################
+        #                                         #
+        #            Dropping Table               #
+        #                                         #
+        ###########################################        
+        
+        private
+                        
+        def expected_options_for_dropping_table
+          
+          {:table_name => :required}
+          
+        end       
+            
+        public
+        
+        # === Description
+        # Drop a table raising an exception if necessary.
+        #
+        # === Usage
+        # abstract_adapter.drop_table :table_name => 'person'
+        #
+        # === Options
+        # :table_name
+        #
+        # === Returning
+        # nothing
+      
+        def drop_table ( options = {} )                     
+ 
+          check_options expected_options_for_dropping_table, options
+            
+          sql = sql_for_dropping_table( options )
+          
+          logger.warn sql if @table_logging
+          
+          query sql
+            
+        rescue adapter_specific_exception => ex
+          
+          raise TableDropError.new(ex.message)
+
+        end
+      
+        # === Description
+        # Drop a table by not raising any exception.
+        #
+        # === Usage
+        # abstract_adapter.drop_table_if_necessary :table_name => 'person'
+        #
+        # === Option
+        # :table_name
+        #
+        # === Returning
+        # nothing        
+      
+        def drop_table_if_necessary ( options = {} )                       
+
+          drop_table options
+         
+        rescue TableDropError; end
+        
+        # === Description
+        # Drop all tables raising an exception if necessary.
+        #
+        # === Usage
+        # abstract_adapter.drop_all_tables
+        #
+        # === Option
+        # No option
+        #
+        # === Returning
+        # nothing        
+        
+        def drop_all_tables
+        
+          for table_name in get_tables
+          
+            sql = sql_for_dropping_table( {:table_name => table_name} )
+          
+            logger.warn sql if @table_logging
+          
+            query sql            
+          
+          end
+            
+        rescue adapter_specific_exception => ex
+          
+          raise TableDropError.new(ex.message)
+            
+        end
+             
+        ###########################################
+        #                                         #
+        #             Creating Table              #
+        #                                         #
+        ###########################################
+        
+        private
+        
+        def expected_options_for_creating_table
+                    
+          {:table_name => :required, :fields => :required}
+          
+        end
+                                    
+        public
+
+        # === Description
+        # Create a table.
+        #
+        # === Usage
+        # abstract_adapter.create_table :table_name => 'person', :fields => 
+        # [{:name => 'id', :type => :integer},{:name => 'name', :type => :string}]
+        #
+        # === Option
+        # * :table_name
+        # * :fields = Having an array of hashes with information about columns.
+        #
+        # === Returning
+        # nothing
+        #
+        # === Note
+        # Some databases do override this method by adding up more options.
+        # Please, check out the adapter specific's one.
+  
+        def create_table ( options = {} )                 
+
+          check_options expected_options_for_creating_table, options                          
+      
+          sql = sql_for_creating_table( options )
+
+          logger.warn sql if @table_logging
+          
+          query sql          
+            
+        rescue adapter_specific_exception => ex
+          
+          raise TableCreateError.new(ex.message)               
+      
+        end         
+      
+        ###########################################
+        #                                         #
+        #             Table Listing               #
+        #                                         #
+        ###########################################
+      
+        private
+                
+        def expected_options_for_verifying_table_existence
+          
+          {:table_name => :required}
+          
+        end
+                        
+        public
+                    
+        # === Description
+        # Check if a given table exists.
+        #
+        # === Usage
+        # abstract_adapter.table_exists?(:table_name => 'person')
+        #
+        # === Option
+        # No options
+        #
+        # === Returning
+        # true or false     
+      
+        def table_exists? ( options = {} )
+  
+          check_options expected_options_for_verifying_table_existence, options
+    
+          tables = get_tables
+    
+          tables.each do |name|
+    
+            return true if name == options[:table_name]
+    
+          end
+    
+          return false    
+    
+        end 
+            
+        def table_not_exists? ( options = {} )     
+      
+          not table_exists? options
+      
+        end      
+      
+        # === Description
+        # Return all tables avaliable in the current schema by name.
+        #
+        # === Usage
+        # abstract_adapter.get_tables
+        #
+        # === Option
+        # No options
+        #
+        # === Returning
+        # an array ['person','invoice',...]    
+           
+        def get_tables
+    
+          sql = sql_for_getting_tables
+          
+          logger.warn sql if @table_logging
+          
+          query sql          
+                    
+          tables = []
+             
+          result.fetch do |table_name_column|
+        
+            tables << table_name_column.value
+              
+          end
+     
+          tables
+          
+        rescue adapter_specific_exception => ex
+          
+          raise TableRetrieveError.new(ex.message)
+      
+        end      
+      
+        ###########################################
+        #                                         #
+        #             Table Diffing               #
+        #                                         #
+        ###########################################      
+      
+        private
+        
+        def expected_options_for_reporting_tables
+          
+          {:table_name => :required, :fields => :required}
+          
+        end
+        
+        public
+        
+        def diff_columns ( options = {} )
+          
+          modified = report_modified_columns options
+          new      = report_new_columns options
+          old      = report_old_columns options
+          
+          [modified, new, old]
+          
+        end
+                
+        # === Description
+        # Execute a diff by comparing incoming fields with existent ones.
+        #
+        # === Usage
+        # abstract_adapter.report_modified_columns :table_name => 'person',
+        # :fields => [{:name => :id, :type => :bigint}]
+        #
+        # === Option
+        # * :table_name
+        # * :fields => array of hashes
+        #
+        # === Returning
+        # fields affected
+  
+        def report_modified_columns ( options = {} )
+          
+          check_options expected_options_for_reporting_tables, options
+
+          modified_fields  = options[:fields]
+                         
+          modified_columns = []
+          current_fields   = get_columns_information :table_name => options[:table_name]
+    
+          parse_fields modified_fields do |modified_field|
+        
+            current_fields.each do |current_field|
+            
+              if modified_field[:name] == current_field[:name]
+
+                # We gotta check every attribute to see if a modification can occur.
+            
+                if modified_field[:type] != current_field[:type]||modified_field[:size]!=current_field[:size]
+
+                  modified_columns << current_field
+            
+                end
+
+              end
+          
+            end
+        
+          end  #end of parse_fields       
+  
+          modified_columns
+
+        end
+      
+        # === Description
+        # Execute a diff by comparing incoming fields with existent ones.
+        #
+        # === Usage
+        # abstract_adapter.report_new_columns :table_name => 'person',
+        # :fields => [{:name => :new_id, :type => :int}]
+        #
+        # === Option
+        # * :table_name
+        # * :fields => array of hashes
+        #
+        # === Returning
+        # fields affected
+      
+        def report_new_columns ( options = {} )
+      
+          check_options expected_options_for_reporting_tables, options
+          
+          new_fields   = options[:fields]
+      
+          new_columns  = []
+          no_new_field = false
+    
+          current_fields = get_columns_information :table_name => options[:table_name]
+                  
+          parse_fields new_fields do |new_field|
+        
+            current_fields.each do |current_field|
+          
+              if new_field[:name] == current_field[:name]
+            
+                no_new_field = true
+                break
+            
+              end
+          
+            end
+                      
+            if no_new_field
+          
+              no_new_field = false
+              next
+            
+            end
+          
+            new_columns << new_field       
+        
+          end
+        
+          new_columns
+
+        end
+      
+        # === Description
+        # Execute a diff by comparing incoming fields with existent ones.
+        #
+        # === Usage
+        # abstract_adapter.report_old_columns :table_name => 'person',
+        # :fields => [{:name => :new_id, :type => :int}]
+        #
+        # === Option
+        # * :table_name
+        # * :fields => array of hashes
+        #
+        # === Returning
+        # fields affected
+      
+        def report_old_columns ( options = {} )
+             
+          check_options expected_options_for_reporting_tables, options
+          
+          new_fields = options[:fields]
+             
+          legacy_fields = []
+          no_old_field  = false
+              
+          current_fields = get_columns_information :table_name => options[:table_name]
+        
+          current_fields.each do |current_field|
+        
+            parse_fields new_fields do |new_field|
+          
+              if new_field[:name] == current_field[:name]
+            
+                no_old_field = true
+                break
+                
+              end
+                    
+              if no_old_field == true
+          
+                no_old_field = false
+                next
+          
+              end
+              
+              legacy_fields << current_field
+            
+            end #end of parse_fields
+      
+          end
+        
+          legacy_fields
+      
+        end     
+
+      end
+    end
+  end
+end

data/lib/imparcial/driver/abstract/expression/transaction.rb

@@ -0,0 +1,143 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Transaction
+                
+        private                
+
+        def expected_options_for_saving_point
+          
+          {:savepoint_name => :required}
+          
+        end
+                
+        public
+        
+        # === Description
+        # Stablish a savepoint in a given moment during transactions.
+        #
+        # === Usage
+        # abstract_adapter.create_savepoint :savepoint_name => 'here'
+        #
+        # === Options
+        # * :savepoint_name
+        #
+        # === Returning
+        # nothing  
+        
+        def create_savepoint ( options = {} )
+                    
+          check_options expected_options_for_saving_point, options
+                    
+          query sql_for_saving_point( options )
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+        
+        private
+        
+        def expected_options_for_restoring_point
+          
+          {:savepoint_name => :required}
+          
+        end
+        
+        public
+        
+        # === Description
+        # Rollback to a given savepoint.
+        #
+        # === Usage
+        # abstract_adapter.restore_savepoint :savepoint_name => 'here'
+        #
+        # === Options
+        # * :savepoint_name
+        #
+        # === Returning
+        # nothing  
+        
+        def restore_savepoint ( options = {} )
+          
+          check_options expected_options_for_restoring_point, options
+                    
+          query sql_for_rolling_back( options )
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+        
+        # === Description
+        # Initiate a transaction.
+        #
+        # === Usage
+        # abstract_adapter.initialize_transaction
+        #
+        # === Options
+        # no options
+        #
+        # === Returning
+        # nothing  
+        
+        def initialize_transaction
+          
+          query sql_for_initializing_a_transaction
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+        
+        # === Description
+        # Terminate a transaction by commiting.
+        #
+        # === Usage
+        # abstract_adapter.terminate_transaction
+        #
+        # === Options
+        # no options
+        #
+        # === Returning
+        # nothing  
+        
+        def terminate_transaction
+          
+          query sql_for_terminating_a_transaction
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+                
+        # === Description
+        # Rollback a transaction.
+        #
+        # === Usage
+        # abstract_adapter.rollback_transaction
+        #
+        # === Options
+        # no options
+        #
+        # === Returning
+        # nothing 
+         
+        def rollback_transaction
+          
+          query sql_for_rolling_back
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+        
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module ExpressionBase
+    module AbstractExpression
       module Update
             
         private
@@ -13,13 +13,30 @@ module Imparcial
             
         public                
         
-        # Update a table.
+        # === Description
+        # Update some records.
+        #
+        # === Usage
+        # abstract_adapter.update :table_name => 'person', :values => {:salary => 1500},
+        # :conditions => ['id = ?',10]
+        #
+        # === Options
+        # * :table_name
+        # * :values
+        # * :conditions
+        #
+        # === Returning
+        # nothing   
     
         def update ( options )
       
           check_options expected_options_for_updating, options
 
-          query sql_for_updating( options )
+          sql = sql_for_updating( options )
+
+          logger.warn sql if @update_logging
+          
+          query sql
           
         rescue adapter_specific_exception => ex
         

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

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

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

@@ -3,7 +3,7 @@ module Imparcial
   
     # This class will serve as base for adapter specific result class.
   
-    class ResultBase
+    class AbstractResult
       attr_reader :specific
     
       def initialize ( result_specific )
@@ -12,7 +12,8 @@ module Imparcial
       
       end
       
-      # Subclasses need to override this method.
+      # === Description
+      # get number of rows avaliable.
     
       def rows
       
@@ -20,7 +21,8 @@ module Imparcial
       
       end
       
-      # Subclasses need to override this method.      
+      # === Description
+      # fetch the result.  
       
       def fetch
         
@@ -28,23 +30,22 @@ module Imparcial
         
       end
       
-      # Fetch result in array form.     
-      
       def fetch_in_array
         
         array = []
         
-        fetch do |*all|
+        fetch do |*rows|
         
-          array << all
+          array << rows
         
         end
-        
+      
         array
         
       end
       
-      # Fetch only the first row
+      # === Description
+      # Fetch the first row. Ignoring others if avaliable.
             
       def fetch_first_row
         
@@ -57,7 +58,7 @@ module Imparcial
     
     end
     
-    # This class wraps a row.
+    # This class wraps a regular row.
     # Usually, a row will only come with value.
     # Instead, we can also keep the column name. So that, this class
     # can keep track of column name and value.
@@ -69,7 +70,7 @@ module Imparcial
     # -------------------
     
     class Row   
-      include Imparcial::Driver::UtilBase 
+      include Imparcial::Driver::AbstractUtil
     
       attr_accessor :name, :value
       alias_method  :column_name, :name