imparcial 0.0.4 → 0.0.5

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

@@ -0,0 +1,88 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Delete
+   
+        private
+        
+        def expected_options_for_deleting
+          
+          {:table_name => :required, :conditions => :required}
+          
+        end
+                   
+        public
+        
+        # === Description
+        # Delete some records. Besides, this function demands deleting
+        # with some conditions.
+        #
+        # === Usage
+        # abstract_adapter.delete :table_name => 'person', :conditions =>
+        # ['id = ?',1]
+        #
+        # === Options
+        # * :table_name
+        # * :conditions
+        #
+        # === Returning
+        # nothing        
+   
+        def delete ( options = {} )
+                  
+          check_options expected_options_for_deleting, options        
+                  
+          sql = sql_for_deleting( options )
+          
+          logger.warn sql if @delete_logging
+          
+          query sql
+          
+        rescue adapter_specific_exception => ex
+        
+          raise DeleteError.new(ex.message)                       
+      
+        end
+        
+        private
+        
+        def expected_options_for_deleting_all
+          
+          {:table_name => :required}
+          
+        end        
+        
+        public
+        
+        # === Description
+        # Delete some records. Besides, this function demands no conditions.
+        #
+        # === Usage
+        # abstract_adapter.delete_all :table_name => 'person'
+        #
+        # === Options
+        # * :table_name
+        #
+        # === Returning
+        # nothing         
+    
+        def delete_all ( options = {} )
+      
+          check_options expected_options_for_deleting_all, options
+               
+          sql = sql_for_deleting( options )
+          
+          logger.warn sql if @delete_logging
+          
+          query sql 
+          
+        rescue adapter_specific_exception => ex
+        
+          raise DeleteError.new(ex.message)
+ 
+        end
+                        
+      end 
+    end
+  end
+end

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

@@ -0,0 +1,206 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Index
+      
+        ###########################################
+        #                                         #
+        #             Index Creation              #
+        #                                         #   
+        ###########################################       
+      
+        private
+        
+        def expected_options_for_creating_index
+          
+          {
+          :index_name => :required, :index_type => :optional, :table_name => :required,
+          :column_name => :required
+          }          
+          
+        end                
+       
+        public
+        
+        # === Description
+        # Create an index.
+        #
+        # === Usage
+        # abstract_adapter.create_index :index_name => 'idx', :table_name = 'person'
+        # ,:column_name => :id
+        #
+        # === Options
+        # * :index_name
+        # * :table_name
+        # * :column_name
+        # * :index_type
+        #
+        # === Returning
+        # nothing    
+        
+        def create_index ( options = {} )
+          
+          check_options expected_options_for_creating_index, options
+           
+          sql = sql_for_creating_index( options )
+            
+          logger.warn sql if @index_logging
+          
+          query sql            
+            
+        rescue adapter_specific_exception => ex
+          
+          raise IndexCreateError.new(ex.message)
+
+        end
+        
+        ###########################################
+        #                                         #
+        #             Index Dropping              #
+        #                                         #   
+        ###########################################
+        
+        private
+        
+        def expected_options_for_dropping_index
+          
+          {:table_name => :required, :index_name => :required}
+          
+        end
+        
+        public
+        
+        def drop_index ( options = {} )
+          
+          check_options expected_options_for_dropping_index, options
+          
+          sql = sql_for_dropping_index( options )
+          
+          logger.warn sql if @index_logging
+          
+          query sql
+          
+        rescue adapter_specific_exception => ex
+        
+          raise IndexDropError.new(ex.message)
+          
+        end
+        
+        def expected_options_for_dropping_all_indexes
+          
+          {:table_name => :required}
+          
+        end        
+        
+        public
+                          
+        def drop_all_indexes ( options = {} )
+
+          check_options expected_options_for_dropping_all_indexes, options
+
+          for index in get_indexes(:table_name => options[:table_name])
+
+            drop_index :table_name => index[:table], :index_name => index[:name]          
+          
+          end
+          
+        end
+         
+        ###########################################
+        #                                         #
+        #             Index Listing               #
+        #                                         #   
+        ###########################################   
+        
+        private
+        
+        def expected_options_for_getting_indexes
+          
+          {:table_name => :required}
+          
+        end
+        
+        public
+        
+        # === Description
+        # Get metadata about all indexes.
+        #
+        # === Usage
+        # abstract_adapter.retrieve_indexes
+        #
+        # === Options
+        # No options
+        #
+        # === Returning
+        # an array with hashes.
+        
+        def get_indexes ( options = {} )
+        
+          check_options expected_options_for_getting_indexes, options
+        
+          sql = sql_for_getting_indexes options
+          
+          logger.warn sql if @index_logging
+          
+          query sql
+          
+          indexes = []
+          
+          result.fetch do |table, column, index|
+            
+            indexes << {:table => table.value,:column => column.value,:name => index.value}
+            
+          end
+          
+          indexes
+          
+        rescue adapter_specific_exception => ex
+        
+          raise IndexListError.new(ex.message)             
+          
+        end
+        
+        private
+        
+        def expected_options_for_verifying_index_existance
+          
+          {:index_name => :required, :table_name => :required}
+          
+        end        
+        
+        public
+        
+        # === Description
+        # Verify if a given index exists.
+        #
+        # === Usage
+        # abstract_adapter.retrieve_indexes
+        #
+        # === Options
+        # No options
+        #
+        # === Returning
+        # true or false.        
+        
+        def index_exists? ( options = {} )
+          
+          check_options expected_options_for_verifying_index_existance, options
+
+          sql = sql_for_index_exists?( options )
+          
+          logger.warn sql if @index_logging
+          
+          query sql
+          
+          result.rows > 0
+          
+        rescue adapter_specific_exception => ex
+        
+          raise IndexDropError.new(ex.message)             
+          
+        end
+        
+      end 
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Insert
+      
+        private
+        
+        def expected_options_for_inserting
+          
+          {:table_name => :required, :values => :required}
+          
+        end
+            
+        public
+
+        # === Description
+        # Insert some records. 
+        #
+        # === Usage
+        # abstract_adapter.insert :table_name => 'person', :values =>
+        # {:id => 1, :name => 'ronaldinho'}
+        #
+        # === Options
+        # * :table_name
+        # * :values
+        #
+        # === Returning
+        # nothing    
+
+        def insert ( options = {} )
+      
+          check_options expected_options_for_inserting, options
+
+          sql = sql_for_inserting( options )
+          
+          logger.warn sql if @insert_logging
+          
+          query sql
+                      
+        rescue adapter_specific_exception => ex
+          
+          raise InsertError.new(ex.message)
+                
+        end
+        
+      end
+    end
+  end
+end      

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

@@ -0,0 +1,11 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Lock
+        
+        # Need implementation.
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,41 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Record
+  
+        private
+        
+        def expected_options_for_total_of_records
+          
+          {:table_name => :required}          
+          
+        end
+                
+        public
+        
+        # Retrieve the total of records in a table.
+        
+        def total_of_records ( options = {} )
+                    
+          check_options expected_options_for_total_of_records, options
+                              
+          sql = sql_for_couting_records( options )
+          
+          logger.warn sql if @record_logging
+          
+          query sql
+          
+          result.fetch_first_row.value
+          
+        rescue adapter_specific_exception => ex
+        
+          raise ExpressionError.new(ex.message)
+          
+        end
+        alias_method :num_of_records, :total_of_records
+        
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Select
+
+        private
+        
+        def expected_options_for_selecting
+          
+          {
+          :table_name => :optional, :joins => :optional, :fields => :optional,
+          :conditions => :optional, :limit => :optional, :order_asc => :optional,
+          :order_desc => :optional
+          }
+          
+        end
+
+
+        public
+
+        def select ( options = {} )
+               
+          sql = sql_for_selecting( options )
+          
+          logger.warn sql if @select_logging
+          
+          query sql
+          
+        rescue adapter_specific_exception => ex
+        
+          raise SelectError.new(ex.message)
+        
+        end
+      
+      end
+    end
+  end
+end

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

@@ -0,0 +1,260 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+        
+      # It's important to be aware that some databases don't support sequences.
+      # Databases like Mysql, need to override those methods.
+    
+      module Sequence
+    
+        private
+        
+        # Set default values.
+  
+        def parse_sequence ( options )                     
+               
+          options[:start_with]   ||= 1
+          options[:min_value]    ||= 1
+          options[:increment_by] ||= 1
+          options[:cycle]        ||= false
+
+        end
+        
+        ###############################################
+        #                                             #
+        #              Creating Sequences             #
+        #                                             #        
+        ###############################################           
+        
+        private
+        
+        def expected_options_for_creating_sequence
+          
+          {
+          :sequence_name => :required, :start_with => :optional, :min_value => :optional,
+          :max_value => :optional, :increment_by => :optional, :cycle => :optional,
+          :cache => :optional
+          }
+          
+        end                 
+        
+        public
+
+        # === Description
+        # Create a sequence.
+        #
+        # === Usage
+        # abstract_adapter.create_sequence :sequence_name => 'seq_id', :increment_by => 2
+        #
+        # === Options
+        # * :sequence_name
+        # * :start_with
+        # * :min_value
+        # * :max_value
+        # * :increment_by
+        # * :cache
+        # * :cycle
+        #
+        # === Returning
+        # nothing  
+          
+        def create_sequence ( options = {} )          
+      
+          check_options expected_options_for_creating_sequence, options
+          
+          parse_sequence options            
+        
+          sql = sql_for_creating_sequence( options )
+          
+          logger.warn sql if @sequence_logging
+          
+          query sql
+            
+        rescue adapter_specific_exception => ex
+          
+          raise SequenceCreateError.new(ex.message)           
+ 
+        end
+        
+        # === Description
+        # Create a sequence without raising any exception.
+        #
+        # === Usage
+        # abstract_adapter.create_sequence_if_necessary :sequence_name => 'seq_id'
+        #
+        # === Options
+        # * :sequence_name
+        # * :start_with
+        # * :min_value
+        # * :max_value
+        # * :increment_by
+        # * :cache
+        # * :cycle
+        #
+        # === Returning
+        # nothing      
+        
+        def create_sequence_if_necessary ( options = {} )
+          
+          create_sequence options
+        
+        rescue SequenceCreateError => ex; end
+      
+        ###############################################
+        #                                             #
+        #              Dropping Sequences             #
+        #                                             #        
+        ###############################################      
+      
+        private
+      
+        def expected_options_for_dropping_sequence
+          
+          {:sequence_name => :required}
+          
+        end
+              
+        public
+      
+        # === Description
+        # Drop a sequence.
+        #
+        # === Usage
+        # abstract_adapter.drop_sequence :sequence_name => 'seq_id'
+        #
+        # === Options
+        # * :sequence_name
+        #
+        # === Returning
+        # nothing   
+      
+        def drop_sequence ( options = {} )
+
+          check_options expected_options_for_dropping_sequence, options
+
+          sql = sql_for_dropping_sequence( options )
+          
+          logger.warn sql if @sequence_logging
+          
+          query sql
+                        
+        rescue adapter_specific_exception => ex
+          
+          raise SequenceDropError.new(ex.message)
+                  
+        end
+      
+        # === Description
+        # Drop a sequence without raising any exception.
+        #
+        # === Usage
+        # abstract_adapter.drop_sequence :sequence_name => 'seq_id'
+        #
+        # === Options
+        # * :sequence_name
+        #
+        # === Returning
+        # nothing  
+      
+        def drop_sequence_if_necessary ( options = {} )           
+      
+          drop_sequence options
+          
+        rescue SequenceDropError; end
+        
+        # === Description
+        # Drop all sequences.
+        #
+        # === Usage
+        # abstract_adapter.drop_all_sequences
+        #
+        # === Options
+        # no options
+        #
+        # === Returning
+        # nothing  
+        
+        def drop_all_sequences
+                    
+          for sequence in get_sequences
+          
+            sql = sql_for_dropping_sequence( :sequence_name => sequence )
+            
+            logger.warn sql if @sequence_logging
+            
+            query sql
+          
+          end
+                    
+        rescue adapter_specific_exception => ex
+        
+          raise SequenceError.new(ex.message)
+          
+        end
+        
+        ###############################################
+        #                                             #
+        #              Sequence Listing               #
+        #                                             #        
+        ###############################################                
+           
+        private              
+              
+        def expected_options_for_verifying_sequence_existance
+          
+          {:sequence_name => :required}
+          
+        end                
+                
+        public
+        
+        # Ask for a sequence returning true or false
+          
+        def sequence_exists? ( options = {} )    
+      
+          check_options expected_options_for_verifying_sequence_existance, options      
+      
+          sql = sql_for_sequence_exists?( options )
+            
+          logger.warn sql if @sequence_logging
+            
+          query sql            
+          
+          result.rows > 0
+          
+        rescue adapter_specific_exception => ex
+          
+          raise SequenceListError.new(ex.message)  
+              
+        end
+        
+        # Retrieve all sequences. Similar to retrive_tables.
+      
+        def get_sequences
+      
+          sql = sql_for_getting_sequences
+            
+          logger.warn sql if @sequence_logging
+            
+          query sql
+          
+          sequences = []
+
+          result.fetch do |name|
+ 
+            sequences << name.value
+
+          end
+        
+          sequences
+          
+        rescue adapter_specific_exception => ex
+          
+          raise SequenceListError.new(ex.message)
+
+        end        
+                
+      end
+    end
+  end
+end