imparcial 0.0.4 → 0.0.5

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

@@ -0,0 +1,128 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Statement
+    
+        private
+            
+        def parse_conditions ( conditions )
+
+          # No condition? no evaluation!
+
+          return '' unless conditions
+        
+          ref = ' WHERE '        
+    
+          # ['id = ?', 1]
+          #     ^      ^
+          #     |      |
+          #  syntax  values
+  
+          syntax = conditions[0]
+          values = conditions[1..-1]
+            
+          # Extract all args.
+          # 
+          # for example:
+          # 
+          # 'id = ? AND name = ?'
+          # 
+          # It has two args:
+          # id = ?
+          # name = ?
+          
+          ops = '=|!=|>|<|>=|<=|<>|IN|NOT IN'
+          aps = "\"\'"
+          log = "AND|OR"
+    
+          args  = syntax.scan(/([\w|\.]+) ?(#{ops}) ?(\?|[#{aps}]?[\w|\d]+[#{aps}]?) ?(#{log})?/)
+          index = -1
+
+          args.each do |arg|
+
+            name, operator, value, logical = arg
+
+            if value != '?'
+      
+              column = quote(name) + ' ' + operator + ' ' + value
+              column += ' ' + logical + ' ' if logical
+              ref += column
+              next
+      
+            end
+          
+            index += 1                       
+  
+            if values[index].class == Array
+          
+              raise ConditionError if values[index].length == 0                                      
+            
+              op = 'IN' if operator == '='
+              op = 'NOT IN' if operator == '!='
+              column = quote(name) + " #{op} ("
+            
+              for i in 0..values[index].length-1
+                values[index][i] = quote_value(values[index][i])
+              end
+            
+              column += values[index].join(',')
+              
+              column += ')'
+              column += ' ' + logical + ' ' if logical
+
+              ref += column
+          
+            else
+          
+              value = values[index] || 'NULL'
+              value = quote_value(value)
+            
+              column  = quote(name) + ' ' + operator + ' ' + value
+              column += ' ' + logical + ' ' if logical
+              
+              ref += column
+          
+            end
+          
+          end #end of args.each
+        
+          ref
+                     
+        end # end of parse_condition
+      
+        def parse_limit ( limit )
+    
+          # No limit? no evaluation!
+  
+          return '' unless limit
+    
+          if limit.class != Range
+    
+            ' LIMIT ' + limit.to_s
+      
+          else
+    
+            ' LIMIT ' + limit.first.to_i.to_s + ',' + limit.last.to_i.to_s
+    
+          end
+  
+        end
+  
+        def parse_order ( options )
+
+          # No order? no evaluation!
+  
+          return '' if !options[:order_desc] && !options[:order_asc]
+    
+          syntax  = ' ORDER BY '
+          syntax += quote( options[:order_desc] || options[:order_asc])
+          syntax += options[:order_desc] ? ' DESC' : ' ASC'
+    
+          syntax
+  
+        end
+        
+      end
+    end 
+  end
+end

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