imparcial 0.0.1

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

@@ -0,0 +1,104 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module Base
+        
+        private
+                
+        # Basically it validates every user's entered option.
+ 
+        def check_options ( expected_options , user_options )
+
+          # Let's iterate over all user options.
+
+          user_options.each do |user_option, content|
+            
+            confirmed = false
+            
+            # Let's iterate over expected options.
+            
+            expected_options.each_key do |name|
+                        
+              if name.to_s == user_option.to_s
+              
+                # Let's verify if content is a collection.
+              
+                if content.class == Array || content.class == Hash
+                  
+                  # If so, we need to check out for content.
+                  
+                  if content.length == 0
+                    
+                    raise OptionError.new('Option ' + name.to_s + ' needs content')
+                    
+                  end
+                  
+                end
+              
+                # Yeah, user option matches with expected option.
+              
+                confirmed = true
+                break
+              
+              end            
+            
+            end
+            
+            # If there's a match, we move forward.
+            
+            if confirmed
+            
+              confirmed = false
+              next
+              
+            end
+            
+            # Opss. user has entered with an unknown option.
+            
+            raise OptionError.new('Cannot find option ' + user_option.to_s)
+            
+          end
+          
+          # Let's iterate over all expected and required options.
+          
+          for name, condition in expected_options
+ 
+            # If this option is not required, we can move forward.
+ 
+            next unless condition == :required
+            confirmed = false            
+                        
+            # Over user's.            
+                        
+            user_options.each_key do |user_option|
+
+              if name.to_s == user_option.to_s
+                
+                confirmed = true
+                break
+                
+              end
+              
+            end
+            
+            # Alright, user has entered with a necessary option.
+            
+            if confirmed
+              
+              confirmed = false
+              next
+              
+            end
+            
+            # Opss... user need to provide a required option.
+            
+            raise OptionError.new('Option ' + name.to_s + ' is necessary')
+                    
+          end        
+              
+        end        
+      
+      end
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module Delete
+   
+        private
+        
+        def expected_options_for_deleting
+          
+          {:table_name => :required, :conditions => :required}
+          
+        end
+        
+        def expected_options_for_deleting_all
+          
+          {:table_name => :required}
+          
+        end
+           
+        public
+        
+        # Delete some records. Except, this function only supports
+        # deleting with conditions. Otherwise an exception shall be
+        # raised.
+   
+        def delete ( options = {} )
+                  
+          check_options expected_options_for_deleting, options        
+                  
+          query sql_for_deleting( options )
+          
+        rescue adapter_specific_exception => ex
+        
+          raise DeleteError.new(ex.message)                       
+      
+        end
+        
+        # Delete all records. This function doesn't support conditions.
+        # If you provide one, an exception shall be raised.
+    
+        def delete_all ( options = {} )
+      
+          check_options expected_options_for_deleting_all, options
+               
+          query sql_for_deleting( options )
+          
+        rescue adapter_specific_exception => ex
+        
+          raise DeleteError.new(ex.message)
+ 
+        end
+        
+        # Delete records without raising any exception.
+        
+        def delete_if_necessary ( options = {} )
+          
+          delete options
+        
+        rescue DeleteError; end
+        
+        # Delete all records without raising any exception.
+        
+        def delete_all_if_necessary ( options = {} )
+          
+          delete_all options
+          
+        rescue DeleteError; end
+                
+      end 
+    end
+  end
+end

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

@@ -0,0 +1,199 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module Index
+      
+        private
+        
+        def expected_options_for_creating_index
+          
+          {
+          :index_name => :required, :index_type => :optional, :table_name => :required,
+          :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              #
+        #                                         #   
+        ###########################################        
+       
+        public
+        
+        # Create an index.
+        
+        def create_index ( options = {} )
+          
+          check_options expected_options_for_creating_index, options
+           
+          query sql_for_creating_index( options )
+            
+        rescue adapter_specific_exception => ex
+          
+          raise IndexCreateError.new(ex.message)
+
+        end
+        
+        ###########################################
+        #                                         #
+        #             Index Dropping              #
+        #                                         #   
+        ###########################################        
+        
+        public
+        
+        # Drop an index by name.
+        
+        def drop_index ( options = {} )
+                    
+          check_options expected_options_for_dropping_index, options
+
+          query sql_for_dropping_index( options )
+            
+        rescue adapter_specific_exception => ex
+          
+          raise IndexDropError.new(ex.message)
+          
+        end
+        
+        # Drop all indexes for a specific table.
+        
+        def drop_all_indexes_for_table ( options = {} )
+          
+          check_options expected_options_for_index_table, options
+          
+          syntax = ''           
+          
+          for index in retrieve_indexes_for_table options
+          
+            syntax += sql_for_dropping_index(:index_name => index[:name]) + ';'
+          
+          end
+          
+          return if syntax.length == 0
+          
+          query syntax
+
+        rescue adapter_specific_exception => ex
+        
+          raise IndexDropError.new(ex.message)                       
+          
+        end
+        
+        # Drop all indexes for all tables.
+        
+        def drop_all_indexes
+          
+          syntax = ''
+          
+          for index in retrieve_indexes
+          
+            meta = {:index_name => index[:name]}
+            syntax += sql_for_dropping_index(meta) + ';'
+          
+          end
+          
+          return if syntax.length == 0
+          
+          query syntax
+        
+        rescue adapter_specific_exception => ex
+        
+          raise IndexDropError.new(ex.message)          
+          
+        end        
+
+        ###########################################
+        #                                         #
+        #             Index Features              #
+        #                                         #   
+        ###########################################   
+        
+        public
+        
+        # Retrieve all indexes avaliable.
+        
+        def retrieve_indexes
+        
+          query sql_for_retrieving_indexes
+          
+          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 IndexError.new(ex.message)             
+          
+        end
+        
+        # Retrieve all indexes for a specific table.
+        
+        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
+          
+          indexes  
+          
+        rescue adapter_specific_exception => ex
+        
+          raise IndexDropError.new(ex.message)             
+          
+        end
+        
+        # Verify if a given index exists.
+        
+        def index_exists? ( options = {} )
+          
+          check_options expected_options_for_verifying_index, options
+
+          query sql_for_index_exists?( options )
+          
+          result.rows > 0
+          
+        rescue adapter_specific_exception => ex
+        
+          raise IndexDropError.new(ex.message)             
+          
+        end
+        
+      end 
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module Insert
+      
+        private
+        
+        def expected_options_for_inserting
+          
+          {:table_name => :required, :values => :required}
+          
+        end
+            
+        public
+
+        # Insert records in a table. Values are must.
+
+        def insert ( options = {} )
+      
+          check_options expected_options_for_inserting, options
+
+          query sql_for_inserting( options )      
+            
+        rescue adapter_specific_exception => ex
+          
+          raise InsertError.new(ex.message)
+                
+        end
+        
+      end
+    end
+  end
+end      

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

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

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

@@ -0,0 +1,36 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      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 = {} )
+      
+          options[:amount] ||= :all
+          
+          query sql_for_selecting( options )
+          
+        rescue adapter_specific_exception => ex
+        
+          raise SelectError.new(ex.message)
+        
+        end
+      
+      end
+    end
+  end
+end

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

@@ -0,0 +1,189 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+        
+      # It's important to be aware that some databases don't support sequences.
+      # Databases like Mysql, need to override those methods.
+    
+      module Sequence
+    
+        private
+  
+        def parse_sequence ( options )                     
+               
+          options[:start_with]   ||= 1
+          options[:min_value]    ||= 1
+          options[:increment_by] ||= 1
+          options[:cycle]        ||= false
+                              
+        end
+        
+        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
+        
+        def expected_options_for_dropping_sequence
+          
+          {:sequence_name => :required}
+          
+        end
+        
+        def expected_options_for_verifying_sequence_existance
+          
+          {:sequence_name => :required}
+          
+        end
+  
+        ###############################################
+        #                                             #
+        #              Creating Sequences             #
+        #                                             #        
+        ###############################################            
+        
+        public
+
+        # Create a sequence with options.
+          
+        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
+          
+            raise SequenceCreateError.new(ex.message)
+          
+          end               
+ 
+        end
+        
+        def create_sequence_if_necessary ( options = {} )
+          
+          create_sequence options
+        
+        rescue SequenceCreateError => ex; end
+      
+        ###############################################
+        #                                             #
+        #              Dropping Sequences             #
+        #                                             #        
+        ###############################################      
+      
+        public
+      
+        # Drop a sequence.
+      
+        def drop_sequence ( options = {} )
+
+          check_options expected_options_for_dropping_sequence, options
+
+          query sql_for_dropping_sequence( options )
+            
+        rescue adapter_specific_exception => ex
+          
+          raise SequenceDropError.new(ex.message)
+                  
+        end
+      
+        # Drop a sequence raising no error.
+      
+        def drop_sequence_if_necessary ( options = {} )           
+      
+          drop_sequence options
+          
+        rescue SequenceDropError; end
+        
+        
+        # Drop all sequences.
+        
+        def drop_all_sequences
+          
+          sequences = retrieve_sequences
+          
+          syntax = ''
+          
+          for sequence in sequences
+          
+            syntax += sql_for_dropping_sequence( :sequence_name => sequence ) + ';'
+          
+          end
+          
+          return if syntax.length == 0
+          
+          query syntax
+                    
+        rescue adapter_specific_exception => ex
+        
+          raise SequenceError.new(ex.message)
+          
+        end
+        
+        ###############################################
+        #                                             #
+        #              Advanced Features              #
+        #                                             #        
+        ###############################################                
+                
+        public
+        
+        # Ask for a sequence returning true or false
+          
+        def sequence_exists? ( options = {} )    
+      
+          check_options expected_options_for_verifying_sequence_existance, options      
+      
+          begin
+      
+            query sql_for_sequence_exists?( options )
+            
+          rescue adapter_specific_exception => ex
+          
+            raise SequenceError.new(ex.message)
+          
+          end
+        
+          result.rows > 0
+              
+        end
+        
+        # Retrieve all sequences. Similar to retrive_tables.
+      
+        def retrieve_sequences
+      
+          begin
+      
+            query sql_for_retrieving_sequences
+            
+          rescue adapter_specific_exception => ex
+          
+            raise SequenceError.new(ex.message)
+          
+          end
+        
+          sequences = []
+
+          result.fetch do |name|
+ 
+            sequences << name.value
+
+          end
+        
+          sequences
+
+        end        
+                
+      end
+    end
+  end
+end