imparcial 0.0.1 → 0.0.2

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

@@ -1,8 +1,14 @@
 module Imparcial
   module Driver
-    module ExpressionBase
+    module AbstractExpression
       module Index
       
+        ###########################################
+        #                                         #
+        #             Index Creation              #
+        #                                         #   
+        ###########################################       
+      
         private
         
         def expected_options_for_creating_index
@@ -12,41 +18,35 @@ module Imparcial
           :column_name => :required
           }          
           
-        end
-        
-        def expected_options_for_dropping_index 
-          
-          {:index_name => :required, :table_name => :required}
-          
-        end
-        
-        def expected_options_for_index_table
-          
-          {:table_name => :required}
-          
-        end
-        
-        def expected_options_for_verifying_index
-          
-          {:index_name => :required}
-          
-        end
-              
-        ###########################################
-        #                                         #
-        #             Index Creation              #
-        #                                         #   
-        ###########################################        
+        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
            
-          query sql_for_creating_index( options )
+          sql = sql_for_creating_index( options )
+            
+          logger.warn sql if @index_logging
+          
+          query sql            
             
         rescue adapter_specific_exception => ex
           
@@ -58,84 +58,91 @@ module Imparcial
         #                                         #
         #             Index Dropping              #
         #                                         #   
-        ###########################################        
-        
-        public
+        ###########################################
         
-        # Drop an index by name.
+        private
         
-        def drop_index ( options = {} )
-                    
-          check_options expected_options_for_dropping_index, options
-
-          query sql_for_dropping_index( options )
-            
-        rescue adapter_specific_exception => ex
+        def expected_options_for_dropping_index
           
-          raise IndexDropError.new(ex.message)
+          {:table_name => :required, :index_name => :required}
           
         end
         
-        # Drop all indexes for a specific table.
+        public
         
-        def drop_all_indexes_for_table ( options = {} )
-          
-          check_options expected_options_for_index_table, options
-          
-          syntax = ''           
+        def drop_index ( options = {} )
           
-          for index in retrieve_indexes_for_table options
+          check_options expected_options_for_dropping_index, options
           
-            syntax += sql_for_dropping_index(:index_name => index[:name]) + ';'
+          sql = sql_for_dropping_index( options )
           
-          end
+          logger.warn sql if @index_logging
           
-          return if syntax.length == 0
+          query sql
           
-          query syntax
-
         rescue adapter_specific_exception => ex
         
-          raise IndexDropError.new(ex.message)                       
+          raise IndexDropError.new(ex.message)
           
         end
         
-        # Drop all indexes for all tables.
-        
-        def drop_all_indexes
+        def expected_options_for_dropping_all_indexes
           
-          syntax = ''
-          
-          for index in retrieve_indexes
+          {:table_name => :required}
           
-            meta = {:index_name => index[:name]}
-            syntax += sql_for_dropping_index(meta) + ';'
+        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
           
-          return if syntax.length == 0
-          
-          query syntax
-        
-        rescue adapter_specific_exception => ex
-        
-          raise IndexDropError.new(ex.message)          
-          
-        end        
-
+        end
+         
         ###########################################
         #                                         #
-        #             Index Features              #
+        #             Index Listing               #
         #                                         #   
         ###########################################   
         
+        private
+        
+        def expected_options_for_getting_indexes
+          
+          {:table_name => :required}
+          
+        end
+        
         public
         
-        # Retrieve all indexes avaliable.
+        # === Description
+        # Get metadata about all indexes.
+        #
+        # === Usage
+        # abstract_adapter.retrieve_indexes
+        #
+        # === Options
+        # No options
+        #
+        # === Returning
+        # an array with hashes.
+        
+        def get_indexes ( options = {} )
         
-        def retrieve_indexes
+          check_options expected_options_for_getting_indexes, options
         
-          query sql_for_retrieving_indexes
+          sql = sql_for_getting_indexes options
+          
+          logger.warn sql if @index_logging
+          
+          query sql
           
           indexes = []
           
@@ -149,41 +156,41 @@ module Imparcial
           
         rescue adapter_specific_exception => ex
         
-          raise IndexError.new(ex.message)             
+          raise IndexListError.new(ex.message)             
           
         end
         
-        # Retrieve all indexes for a specific table.
+        private
         
-        def retrieve_indexes_for_table ( options = {} )
-                    
-          check_options expected_options_for_index_table, options                    
-                    
-          query sql_for_retrieving_indexes_for_table( options )
-          
-          indexes = []
-          
-          result.fetch do |table, column, index|
-            
-            indexes << {:table => table.value,:column => column.value,:name => index.value}
-            
-          end
+        def expected_options_for_verifying_index_existance
           
-          indexes  
+          {:index_name => :required, :table_name => :required}
           
-        rescue adapter_specific_exception => ex
+        end        
         
-          raise IndexDropError.new(ex.message)             
-          
-        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, options
+          check_options expected_options_for_verifying_index_existance, options
 
-          query sql_for_index_exists?( options )
+          sql = sql_for_index_exists?( options )
+          
+          logger.warn sql if @index_logging
+          
+          query sql
           
           result.rows > 0
           

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

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module ExpressionBase
+    module AbstractExpression
       module Lock
         
         # Need implementation.

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

@@ -1,18 +1,10 @@
 module Imparcial
   module Driver
-    module ExpressionBase
-      module Util
-        
+    module AbstractExpression
+      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
-        
         def expected_options_for_total_of_records
           
           {:table_name => :required}          
@@ -27,7 +19,11 @@ module Imparcial
                     
           check_options expected_options_for_total_of_records, options
                               
-          query sql_for_couting_records( options )
+          sql = sql_for_couting_records( options )
+          
+          logger.warn sql if @record_logging
+          
+          query sql
           
           result.fetch_first_row.value
           

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

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module ExpressionBase
+    module AbstractExpression
       module Select
 
         private
@@ -19,10 +19,12 @@ module Imparcial
         public
 
         def select ( options = {} )
-      
-          options[:amount] ||= :all
+               
+          sql = sql_for_selecting( options )
+          
+          logger.warn sql if @select_logging
           
-          query sql_for_selecting( options )
+          query sql
           
         rescue adapter_specific_exception => ex
         

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

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module ExpressionBase
+    module AbstractExpression
         
       # It's important to be aware that some databases don't support sequences.
       # Databases like Mysql, need to override those methods.
@@ -8,6 +8,8 @@ module Imparcial
       module Sequence
     
         private
+        
+        # Set default values.
   
         def parse_sequence ( options )                     
                
@@ -15,9 +17,17 @@ module Imparcial
           options[:min_value]    ||= 1
           options[:increment_by] ||= 1
           options[:cycle]        ||= false
-                              
+
         end
         
+        ###############################################
+        #                                             #
+        #              Creating Sequences             #
+        #                                             #        
+        ###############################################           
+        
+        private
+        
         def expected_options_for_creating_sequence
           
           {
@@ -26,48 +36,64 @@ module Imparcial
           :cache => :optional
           }
           
-        end
-        
-        def expected_options_for_dropping_sequence
-          
-          {:sequence_name => :required}
-          
-        end
-        
-        def expected_options_for_verifying_sequence_existance
-          
-          {:sequence_name => :required}
-          
-        end
-  
-        ###############################################
-        #                                             #
-        #              Creating Sequences             #
-        #                                             #        
-        ###############################################            
+        end                 
         
         public
 
-        # Create a sequence with options.
+        # === 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            
-
-          begin
         
-            query sql_for_creating_sequence( options )
-            
-          rescue adapter_specific_exception => ex
+          sql = sql_for_creating_sequence( options )
           
-            raise SequenceCreateError.new(ex.message)
+          logger.warn sql if @sequence_logging
           
-          end               
+          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
@@ -80,23 +106,55 @@ module Imparcial
         #                                             #        
         ###############################################      
       
+        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
 
-          query sql_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
       
-        # Drop a sequence raising no error.
+        # === 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 = {} )           
       
@@ -104,24 +162,29 @@ module Imparcial
           
         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
           
-          sequences = retrieve_sequences
-          
-          syntax = ''
-          
-          for sequence in sequences
-          
-            syntax += sql_for_dropping_sequence( :sequence_name => sequence ) + ';'
+            sql = sql_for_dropping_sequence( :sequence_name => sequence )
+            
+            logger.warn sql if @sequence_logging
+            
+            query sql
           
           end
-          
-          return if syntax.length == 0
-          
-          query syntax
                     
         rescue adapter_specific_exception => ex
         
@@ -131,9 +194,17 @@ module Imparcial
         
         ###############################################
         #                                             #
-        #              Advanced Features              #
+        #              Sequence Listing               #
         #                                             #        
         ###############################################                
+           
+        private              
+              
+        def expected_options_for_verifying_sequence_existance
+          
+          {:sequence_name => :required}
+          
+        end                
                 
         public
         
@@ -143,34 +214,30 @@ module Imparcial
       
           check_options expected_options_for_verifying_sequence_existance, options      
       
-          begin
-      
-            query sql_for_sequence_exists?( options )
+          sql = sql_for_sequence_exists?( options )
             
-          rescue adapter_specific_exception => ex
-          
-            raise SequenceError.new(ex.message)
+          logger.warn sql if @sequence_logging
+            
+          query sql            
           
-          end
-        
           result.rows > 0
+          
+        rescue adapter_specific_exception => ex
+          
+          raise SequenceListError.new(ex.message)  
               
         end
         
         # Retrieve all sequences. Similar to retrive_tables.
       
-        def retrieve_sequences
-      
-          begin
+        def get_sequences
       
-            query sql_for_retrieving_sequences
+          sql = sql_for_getting_sequences
             
-          rescue adapter_specific_exception => ex
-          
-            raise SequenceError.new(ex.message)
+          logger.warn sql if @sequence_logging
+            
+          query sql
           
-          end
-        
           sequences = []
 
           result.fetch do |name|
@@ -180,6 +247,10 @@ module Imparcial
           end
         
           sequences
+          
+        rescue adapter_specific_exception => ex
+          
+          raise SequenceListError.new(ex.message)
 
         end