imparcial 0.0.4 → 0.0.5

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

@@ -0,0 +1,50 @@
+module Imparcial
+  module Driver
+    module AbstractExpression
+      module Update
+            
+        private
+        
+        def expected_options_for_updating
+          
+          {:table_name => :required, :values => :required, :conditions => :required}
+          
+        end
+            
+        public                
+        
+        # === Description
+        # Update some records.
+        #
+        # === Usage
+        # abstract_adapter.update :table_name => 'person', :values => {:salary => 1500},
+        # :conditions => ['id = ?',10]
+        #
+        # === Options
+        # * :table_name
+        # * :values
+        # * :conditions
+        #
+        # === Returning
+        # nothing   
+    
+        def update ( options )
+      
+          check_options expected_options_for_updating, options
+
+          sql = sql_for_updating( options )
+
+          logger.warn sql if @update_logging
+          
+          query sql
+          
+        rescue adapter_specific_exception => ex
+        
+          raise UpdateError.new(ex.message)
+        
+        end
+
+      end
+    end    
+  end
+end

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

@@ -0,0 +1,23 @@
+FileList[File.dirname(__FILE__)  + '/expression/*.rb'].each do |f|
+  require f
+end
+
+module Imparcial
+  module Driver
+    module AbstractExpression
+      include Statement
+      include Sequence
+      include Column
+      include Table  
+      include Constraint
+      include Insert
+      include Select
+      include Delete
+      include Update
+      include Record
+      include Lock
+      include Transaction
+      include Index
+    end
+  end
+end

data/lib/imparcial/driver/abstract/result.rb

@@ -0,0 +1,95 @@
+module Imparcial
+  module Driver
+  
+    # This class will serve as base for adapter specific result class.
+  
+    class AbstractResult
+      attr_reader :specific
+    
+      def initialize ( result_specific )
+      
+        @specific = result_specific
+      
+      end
+      
+      # === Description
+      # get number of rows avaliable.
+    
+      def rows
+      
+        raise FeatureNotFound
+      
+      end
+      
+      # === Description
+      # fetch the result.  
+      
+      def fetch
+        
+        raise FeatureNotFound
+        
+      end
+      
+      def fetch_in_array
+        
+        array = []
+        
+        fetch do |*rows|
+        
+          array << rows
+        
+        end
+      
+        array
+        
+      end
+      
+      # === Description
+      # Fetch the first row. Ignoring others if avaliable.
+            
+      def fetch_first_row
+        
+        fetch do |*rows|
+          return *rows
+        end
+        
+      end
+      
+    
+    end
+    
+    # This class wraps a regular row.
+    # Usually, a row will only come with value.
+    # Instead, we can also keep the column name. So that, this class
+    # can keep track of column name and value.
+    #
+    # -------------------
+    # id |  name  | price <- column name
+    #  1 |  apple | 0.99  <- column value
+    #  2 |  lemon | 1.99  <- column value
+    # -------------------
+    
+    class Row   
+      include Imparcial::Driver::AbstractUtil
+    
+      attr_accessor :name, :value
+      alias_method  :column_name, :name
+      alias_method  :column_value, :value
+    
+      def initialize ( column_name, column_value )
+      
+        @name  = column_name
+        @value = unquote_value(column_value)
+      
+      end
+      
+      def to_s
+        
+        @value
+        
+      end
+          
+    end
+    
+  end
+end

data/lib/imparcial/driver/abstract/sql/column.rb

@@ -0,0 +1,103 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Column
+        
+        private        
+        
+        # Generate SQL statement for getting columns information.
+        # We need name, type and size.
+                
+        def sql_for_getting_columns_information ( options )
+                   
+          %{SELECT 
+              column_name, 
+              data_type, 
+              character_maximum_length
+            FROM INFORMATION_SCHEMA.columns
+            WHERE table_name = #{quote_value(options[:table_name])}
+           }
+          
+        end  
+        
+        # Generate SQL statement for getting column information.
+        # We need name, type and size. Quite similar to above, except, 
+        # it's a more narrow SQL.       
+        
+        def sql_for_getting_column_information ( options )
+          
+          %{SELECT 
+              column_name, 
+              data_type, 
+              character_maximum_length
+            FROM INFORMATION_SCHEMA.columns
+            WHERE table_name = #{quote_value(options[:table_name])} AND
+            column_name = #{quote_value(options[:field_name])}
+           }
+          
+        end   
+        
+        # Generate SQL statement for adding some columns.
+        # Alter table will do the job for us.
+        
+        def sql_for_adding_columns ( options )
+
+          syntax = ''
+        
+          syntax += 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+ 
+          parse_fields options[:fields] do |field|
+            
+            syntax += "ADD COLUMN " + field_to_column_sql(field) + ","
+
+          end
+          
+          syntax.chop!
+            
+          syntax
+        
+        end
+       
+        # Generate SQL statement for dropping some columns.
+        # Alter table will do the job for us.       
+       
+        def sql_for_dropping_columns ( options )
+
+          syntax = ''
+        
+          syntax += 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+ 
+          options[:fields].each do |field_name|
+                        
+            syntax += 'DROP ' + field_name + ','
+            
+          end
+          
+          syntax.chop!
+            
+          syntax
+        
+        end        
+
+        # Generate SQL statement for renaming a column.
+        # Must be overriden.
+        
+        def sql_for_renaming_column ( options )
+          
+          raise FeatureNotFound
+          
+        end
+        
+        # Generate SQL statement for modifying a column.
+        # Must be overriden.        
+
+        def sql_for_modifying_columns ( options )
+          
+          raise FeatureNotFound
+          
+        end
+       
+      end
+    end
+  end
+end

data/lib/imparcial/driver/abstract/sql/constraint.rb

@@ -0,0 +1,42 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Constraint
+        
+        private
+        
+        def sql_for_adding_primary_key ( options )
+        
+          syntax  = 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+          syntax += 'ADD PRIMARY KEY ('
+          
+          for field_name in options[:fields]
+          
+            syntax += quote(field_name) + ','
+          
+          end
+        
+          syntax.chop!
+          syntax += ')'        
+          
+          syntax
+          
+        end
+        
+        def sql_for_adding_column ( options )
+          
+          raise FeatureNotFound
+          
+        end
+        
+        def sql_for_adding_default_value ( options )
+          
+          raise FeatureNotFound
+          
+        end
+        
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Delete
+        
+        private
+        
+        # SQL for generating the delete statement.
+        
+        def sql_for_deleting ( options )
+       
+          syntax  = 'DELETE FROM ' + quote(options[:table_name])        
+          syntax += parse_conditions options[:conditions] if options[:conditions]
+        
+          syntax
+          
+        end        
+    
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Index
+        
+        private
+        
+        # Generate SQL statement for creating an index.
+        
+        def sql_for_creating_index ( options )
+          
+          syntax  = 'CREATE '
+          syntax += options[:index_type] + ' ' if options[:index_type]
+          syntax += 'INDEX '
+          syntax += options[:index_name] + ' '
+          syntax += 'ON ' + quote(options[:table_name])
+          syntax += '('
+          syntax += quote(options[:column_name])
+          syntax += ')'
+          
+          syntax
+          
+        end        
+        
+        # Generate SQL statement for dropping an index.
+        
+        def sql_for_dropping_index ( options )
+
+          'DROP INDEX ' + options[:index_name]
+          
+        end
+        
+        # Subclasses need to override this method.
+        
+        def sql_for_getting_indexes
+          
+          raise FeatureNotFound
+          
+        end
+                
+      end
+    end
+  end
+end
+               

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

@@ -0,0 +1,63 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Insert
+        
+        private
+        
+        # Some helpers for inserting method.      
+        # Extract column names from a hash.
+
+        def column_names_for ( values )
+      
+          column_names = []
+          
+          values.each_key do |column_name|
+          
+            column_names << quote(column_name)
+            
+          end
+        
+          column_names
+      
+        end
+      
+        # Extract column values from a hash.
+      
+        def column_values_for ( values )
+      
+          column_values = []
+        
+          values.each_value do |column_value|
+          
+            column_values << quote_value(column_value)
+            
+          end
+        
+          column_values
+      
+        end
+      
+        # Execute the SQL statement for inserting.
+      
+        def sql_for_inserting ( options )
+          
+          syntax  = 'INSERT INTO ' + quote(options[:table_name])
+          syntax += '('
+
+          syntax += column_names_for(options[:values]).join(',')
+        
+          syntax += ') VALUES ('
+        
+          syntax += column_values_for(options[:values]).join(',')
+
+          syntax += ')' 
+          
+          syntax
+          
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      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        
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Select
+        
+        private
+               
+        def get_key ( name, table_metadata )
+          
+          key_name = ('key_for_' + name.to_s).to_sym
+          key      = table_metadata[key_name]
+
+          unless key
+          
+            msg = 'A key has not been defined at '+table_metadata[:name].to_s
+            raise SelectError.new(msg)
+            
+          end
+          
+          key
+          
+        end
+        
+        def get_relkind ( table )
+          
+          table[:relkind].to_s.upcase!.gsub!('_', ' ')
+          
+        end
+
+        def unroll_joins ( table_list, previous_table_metadata )
+            
+          syntax = ''
+
+          # Array
+
+          table_list.each do |list|
+
+            for table_metadata, inner_table_list in list
+                  
+              rel = get_relkind table_metadata
+         
+              syntax += ' ' + rel + ' ' + quote(table_metadata[:name]) + ' ON '
+
+              previous_key = get_key previous_table_metadata[:name], table_metadata
+              previous_id  = quote(table_metadata[:name]) + '.' + previous_key
+
+              current_key  = get_key table_metadata[:name], previous_table_metadata
+              current_id   = quote(previous_table_metadata[:name]) + '.' + current_key
+
+              syntax += previous_id + ' = ' + current_id
+                              
+              next unless inner_table_list                
+              next if inner_table_list.length == 0
+
+              syntax += unroll_joins inner_table_list, table_metadata
+              
+            end
+            
+          end
+          
+          syntax
+            
+        end
+
+        # Enable selection by column name.
+
+        def build_field_selection ( fields )
+          
+          if fields
+            
+            fields.join(',')            
+         
+          else
+            
+            '*'
+            
+          end
+          
+        end
+        
+        def sql_for_selecting ( options )
+          
+          syntax  = 'SELECT '
+          syntax += build_field_selection options[:fields]
+          syntax += ' FROM '
+                    
+          syntax += quote options[:joins] ? options[:joins][0].keys.first[:name] : options[:table_name]
+          syntax += unroll_joins options[:joins][0].values[0], options[:joins][0].keys.first if options[:joins]
+        
+          syntax += parse_conditions options[:conditions]
+          syntax += parse_limit options[:limit]
+          syntax += parse_order options
+
+          syntax
+                    
+        end   
+    
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Sequence
+        
+        private
+               
+        # Generate SQL statement for creating a sequence.
+      
+        def sql_for_creating_sequence ( options = {} )
+                          
+          syntax  = 'CREATE SEQUENCE ' + quote(options[:sequence_name]) + ' '
+          syntax += 'START WITH ' + quote_value(options[:start_with]) + ' '
+          syntax += 'MINVALUE ' + quote_value(options[:min_value]) + ' '
+          syntax += 'MAXVALUE ' + quote_value(options[:max_value]) if options[:max_value]
+          syntax += 'INCREMENT BY ' + quote_value(options[:increment_by]) + ' '
+          syntax += options[:cycle] ? 'CYCLE ' : 'NO CYCLE '
+          syntax += 'CACHE ' + quote_value(options[:cache]) if options[:cache]
+
+          syntax
+      
+        end    
+
+        private
+      
+        # Generate SQL statement for dropping a sequence.
+      
+        def sql_for_dropping_sequence ( options = {} )
+      
+          'DROP SEQUENCE ' + quote(options[:sequence_name])
+              
+        end   
+        
+        # Generate SQL statement for verifying sequences.
+        # Subclasses must override this method.
+        
+        def sql_for_sequence_exists? ( options = {} )
+          
+          raise FeatureNotFound
+          
+        end        
+        
+        # Generate SQL statement for retrieving sequences.
+        # Subclasses must override this method.
+        
+        def sql_for_getting_sequences
+          
+          raise FeatureNotFound
+          
+        end              
+        
+      end
+    end
+  end
+end

data/lib/imparcial/driver/abstract/sql/table.rb

@@ -0,0 +1,42 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Table
+        
+        private
+        
+        # Generate SQL statement for dropping table.
+      
+        def sql_for_dropping_table ( options )
+           
+          'DROP TABLE ' + quote( options[:table_name] )
+                
+        end        
+        
+        # Generate SQL statement for creating table. 
+      
+        def sql_for_creating_table ( options )
+
+          columns = []
+
+          # Let's parse some columns in order to provide default options.
+
+          parse_fields options[:fields] do |field|
+
+            columns << field_to_column_sql(field)
+        
+          end                 
+               
+          syntax  = 'CREATE TABLE ' + quote( options[:table_name] )
+          syntax += '('
+          syntax += columns.join(',')
+          syntax += ')'
+
+          syntax
+   
+        end                        
+          
+      end
+    end
+  end
+end

data/lib/imparcial/driver/abstract/sql/transaction.rb

@@ -0,0 +1,43 @@
+module Imparcial
+  module Driver
+    module AbstractSQL
+      module Transaction
+        
+        private
+        
+        # Generate SQL statement for initializing a transaction.
+        
+        def sql_for_initializing_a_transaction
+          
+          'BEGIN'
+          
+        end
+        
+        # Generate SQL statement for terminating a transaction.
+        
+        def sql_for_terminating_a_transaction
+        
+          'COMMIT'
+          
+        end
+        
+        # Generate SQL statement for rolling back a transaction.
+        
+        def sql_for_rolling_back ( options )
+          
+          options[:savepoint_name] == nil ? 'ROLLBACK' : 'ROLLBACK TO ' + options[:savepoint_name].to_s
+          
+        end
+        
+        # Generate SQL statement for placing a saving point.
+                
+        def sql_for_saving_point ( options )
+          
+          'SAVEPOINT ' + options[:savepoint_name].to_s
+          
+        end        
+        
+      end
+    end
+  end
+end