imparcial 0.0.1

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

@@ -0,0 +1,128 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      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/base/expression/table_diff.rb

@@ -0,0 +1,154 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module TableDiff
+        
+        private
+        
+        def expected_options_for_reporting
+          
+          {: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
+        
+        # Execute a diff by comparing existent fields.
+        # If you eventually try to insert a non-existent field,
+        # an exception shall be raised.
+    
+        def report_modified_columns ( options = {} )
+          
+          check_options expected_options_for_reporting, options
+
+          modified_fields  = options[:fields]
+                         
+          modified_columns = []
+          current_fields   = retrieve_columns :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[:default_value] != current_field[:default_value]\
+                || modified_field[:allow_null] != current_field[:allow_null] || modified_field[:pk] != current_field[:pk]\
+                || modified_field[:sequence]   != current_field[:sequenec]   || modified_field[:size] != current_field[:size]
+
+                  modified_columns << current_field
+            
+                end
+
+              end
+          
+            end
+        
+          end  #end of parse_fields       
+  
+          modified_columns
+
+        end
+      
+        # Execute a diff by comparing new fields.
+        # If you eventually try to insert an existent field,
+        # an exception shall be raised.
+      
+        def report_new_columns ( options = {} )
+      
+          check_options expected_options_for_reporting, options
+          
+          new_fields   = options[:fields]
+      
+          new_columns  = []
+          no_new_field = false
+    
+          current_fields = retrieve_columns :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
+      
+        # Execute a diff by comparing new fields with current ones. 
+        # Legacy fields will be showed.
+        # Shall be raised an exception if trying to compare modifying fields.
+      
+        def report_old_columns ( options )
+             
+          check_options expected_options_for_reporting, options
+          
+          new_fields = options[:fields]
+             
+          legacy_fields = []
+          no_old_field  = false
+              
+          current_fields = retrieve_columns :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/base/expression/table_evolution.rb

@@ -0,0 +1,94 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module TableEvolution
+        
+=begin            
+        # Execute the alter table statement by only insert new fields.
+        # An exception shall be raised if trying to insert modified fields.
+
+        def add_columns ( table_name, fields )
+  
+          # Let's see if it's necessary to alter a table.
+
+          affected_columns = report_new_columns table_name, fields, true
+              
+          syntax = ''
+        
+          if affected_columns.length > 0
+        
+            syntax += 'ALTER TABLE ' + quote_table(table_name) + ' ADD COLUMN'
+            syntax += '('
+          
+            fields_to_columns affected_columns do |column|
+          
+              syntax += column + ','
+            
+            end
+          
+            syntax.chop!
+            
+            syntax += ')'
+
+          end                 
+
+          query syntax
+        
+          syntax      
+      
+        end
+      
+        def drop_columns ( table_name, fields_by_name )
+
+          syntax = ''
+        
+          if fields_by_name.length > 0
+        
+            syntax += 'ALTER TABLE ' + quote_table(table_name)
+          
+            fields_by_name.each do |name|
+          
+              syntax += ' DROP COLUMN ' + quote_column(name) + ','
+            
+            end  
+         
+            syntax.chop!
+        
+          end
+        
+          begin
+        
+            query syntax
+          
+          rescue Object => ex
+        
+            raise TableError.new(ex.message)
+        
+          end
+        
+          syntax
+      
+        end
+      
+        def modify_columns ( table_name, fields )
+          
+          syntax  = 'ALTER TABLE ' + quote_table(table_name) + ' '
+    
+          fields_to_columns fields do |column|
+        
+            syntax += 'MODIFY COLUMN ' + column + ','
+          
+          end
+    
+          syntax.chop!
+        
+          query syntax
+        
+          syntax
+      
+        end
+=end        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module TableMetadata
+        
+        private
+        
+        def expected_options_for_retrieving_columns
+          
+          {:table_name => :required}
+          
+        end
+        
+        def expected_options_for_verifying_existence
+          
+          {:table_name => :required}
+          
+        end
+        
+        ###########################################
+        #                                         #
+        #       Couple of Table features          #
+        #                                         #
+        ###########################################    
+                
+        public
+              
+        # Return all avaliable tables by name in a specific database 
+        # Return is a array of names.
+           
+        def retrieve_tables
+    
+          query sql_for_retrieving_tables
+                    
+          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
+      
+        # Check if a table exists, returning true or false.
+      
+        def table_exists? ( options = {} )
+  
+          check_options expected_options_for_verifying_existence, options
+    
+          tables = retrieve_tables
+    
+          tables.each do |name|
+    
+            return true if name == options[:table_name]
+    
+          end
+    
+          return false    
+    
+        end 
+      
+        # The opposite of above.
+      
+        def table_not_exists? ( options = {} )     
+      
+          not table_exists? options
+      
+        end     
+        
+        public
+    
+        # Return metadata about columns from a specific table.
+        # It Requires a table name as parameter.
+        # If there's no table, it will raise an error.
+    
+        def retrieve_columns ( options = {} )
+
+          check_options expected_options_for_retrieving_columns, options
+
+          query sql_for_retrieving_columns( options )
+            
+          columns = []
+
+          result.fetch do |name, type, size, allow_null, pk, default_value, auto_inc, indexed|
+
+            column = {}
+            column[:name]           = name.value
+            column[:type]           = type.value
+            column[:size]           = size.value
+            column[:allow_null]     = allow_null.value
+            column[:pk]             = pk.value
+            column[:default_value]  = default_value.value
+            column[:auto_increment] = auto_inc.value
+            column[:indexed]        = indexed.value
+          
+            # Transform SQL columns into RDBAL's ones.
+
+            parse_column column
+        
+            columns << column
+          
+          end
+
+          columns
+          
+        rescue adapter_specific_exception => ex
+          
+          raise TableRetrieveError.new(ex.message)
+
+        end                
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module TableOperation
+        
+        private
+        
+        def expected_options_for_creating_table
+                    
+          {:table_name => :required, :fields => :required}
+          
+        end
+        
+        def expected_options_for_dropping_table
+          
+          {:table_name => :required}
+          
+        end
+        
+        ###########################################
+        #                                         #
+        #            Dropping Table               #
+        #                                         #
+        ###########################################
+            
+        public
+        
+        # Drop a table by table_name.
+        # An exception will be raised if nothing is found.
+        # Usage:
+        # drop_table :table_name => 'something'
+      
+        def drop_table ( options = {} )                     
+ 
+          check_options expected_options_for_dropping_table, options
+            
+          query sql_for_dropping_table( options )
+            
+        rescue adapter_specific_exception => ex
+          
+          raise TableDropError.new(ex.message)
+
+        end
+      
+        # Drop a table by name.
+        # An exception shall not be raised independently of what happens.
+      
+        def drop_table_if_necessary ( options = {} )                       
+
+          drop_table options
+         
+        rescue TableDropError; end
+        
+        # Drop all tables.
+        
+        def drop_all_tables
+        
+          for table_name in retrieve_tables
+          
+            query sql_for_dropping_table( {:table_name => table_name} )
+          
+          end
+            
+        rescue adapter_specific_exception => ex
+          
+          raise TableDropError.new(ex.message)
+            
+        end
+        
+        ###########################################
+        #                                         #
+        #             Creating Table              #
+        #                                         #
+        ###########################################        
+
+        private
+
+        def column_format
+          
+          [:name, :type, :size, :allow_null, :auto_increment, :default_value]
+          
+        end
+
+        def build_column ( field )
+      
+          raise OptionError unless field
+        
+          # Fill it up with default values if needed.
+          
+          parse_field field
+          sql_column = field_to_column field
+  
+          syntax = ''
+          
+          for attr in column_format
+          
+            syntax += sql_column[attr] + ' ' if sql_column[attr]
+          
+          end
+
+          syntax
+      
+        end
+        
+        def field_to_column ( field )
+          
+          column = {}
+          column[:name] = quote(field[:name])
+          column[:type] = regular_types[field[:type]]
+          column[:size] = '(' + quote_value(field[:size]) + ')' if field[:size]
+          column[:allow_null] = field[:allow_null] == true ? 'NULL' : 'NOT NULL'
+          column[:default_value] = field[:default_value] != nil ? ' DEFAULT ' + quote_value(field[:default_value]) : ''          
+          
+          column
+          
+        end
+                                    
+        public
+
+        # Create a table.
+  
+        def create_table ( options = {} )                 
+
+          check_options expected_options_for_creating_table, options                          
+                              
+          query sql_for_creating_table( options )
+            
+        rescue adapter_specific_exception => ex
+          
+          raise TableCreateError.new(ex.message)               
+      
+        end                         
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module Transaction
+                
+        public
+        
+        # Create a savepoint for a transaction.
+        
+        def create_savepoint ( name )
+                    
+          query sql_for_saving_point( name )
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+        
+        # Rollback a transaction to the specified savepoint.
+        
+        def restore_savepoint ( name )
+                    
+          query sql_for_rolling_back( name )
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+        
+        # Initialize a transaction.
+        
+        def initialize_transaction
+          
+          query sql_for_initializing_a_transaction
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+        
+        # Finalize a transaction.
+        
+        def terminate_transaction
+          
+          query sql_for_terminating_a_transaction
+          
+        rescue adapter_specific_exception => ex
+        
+          raise TransactionError.new(ex.message)
+          
+        end
+        
+      end
+    end
+  end
+end