imparcial 0.0.1

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

@@ -0,0 +1,33 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module Update
+            
+        private
+        
+        def expected_options_for_updating
+          
+          {:table_name => :required, :values => :required, :conditions => :required}
+          
+        end
+            
+        public                
+        
+        # Update a table.
+    
+        def update ( options )
+      
+          check_options expected_options_for_updating, options
+
+          query sql_for_updating( options )
+          
+        rescue adapter_specific_exception => ex
+        
+          raise UpdateError.new(ex.message)
+        
+        end
+
+      end
+    end    
+  end
+end

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

@@ -0,0 +1,45 @@
+module Imparcial
+  module Driver
+    module ExpressionBase
+      module Util
+        
+        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}          
+          
+        end
+                
+        public
+        
+        # Retrieve the total of records in a table.
+        
+        def total_of_records ( options = {} )
+                    
+          check_options expected_options_for_total_of_records, options
+                              
+          query sql_for_couting_records( options )
+          
+          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/base/expression.rb

@@ -0,0 +1,37 @@
+require 'imparcial/driver/base/expression/base'
+require 'imparcial/driver/base/expression/statement'
+require 'imparcial/driver/base/expression/sequence'
+require 'imparcial/driver/base/expression/table_diff'
+require 'imparcial/driver/base/expression/table_operation'
+require 'imparcial/driver/base/expression/table_metadata'
+require 'imparcial/driver/base/expression/table_evolution'
+require 'imparcial/driver/base/expression/insert'
+require 'imparcial/driver/base/expression/select'
+require 'imparcial/driver/base/expression/delete'
+require 'imparcial/driver/base/expression/update'
+require 'imparcial/driver/base/expression/util'
+require 'imparcial/driver/base/expression/lock'
+require 'imparcial/driver/base/expression/transaction'
+require 'imparcial/driver/base/expression/index'
+
+module Imparcial
+  module Driver
+    module ExpressionBase
+      include Base
+      include Statement
+      include Sequence
+      include TableDiff
+      include TableOperation
+      include TableMetadata
+      include TableEvolution                     
+      include Insert
+      include Select
+      include Delete
+      include Update
+      include Util
+      include Lock
+      include Transaction
+      include Index
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+module Imparcial
+  module Driver
+  
+    # This class will serve as base for adapter specific result class.
+  
+    class ResultBase
+      attr_reader :specific
+    
+      def initialize ( result_specific )
+      
+        @specific = result_specific
+      
+      end
+      
+      # Subclasses need to override this method.
+    
+      def rows
+      
+        raise FeatureNotFound
+      
+      end
+      
+      # Subclasses need to override this method.      
+      
+      def fetch
+        
+        raise FeatureNotFound
+        
+      end
+      
+      # Fetch result in array form.     
+      
+      def fetch_in_array
+        
+        array = []
+        
+        fetch do |*all|
+        
+          array << all
+        
+        end
+        
+        array
+        
+      end
+      
+      # Fetch only the first row
+            
+      def fetch_first_row
+        
+        fetch do |*rows|
+          return *rows
+        end
+        
+      end
+      
+    
+    end
+    
+    # This class wraps a 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::UtilBase 
+    
+      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/base/sql/delete.rb

@@ -0,0 +1,22 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      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/base/sql/index.rb

@@ -0,0 +1,53 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      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_retrieving_indexes
+          
+          raise FeatureNotFound
+          
+        end
+        
+        # Subclasses need to override this method.
+        
+        def sql_for_retrieving_indexes_for_table ( options )
+          
+          raise FeatureNotFound
+          
+        end
+        
+      end
+    end
+  end
+end
+               

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

@@ -0,0 +1,63 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      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/base/sql/select.rb

@@ -0,0 +1,101 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      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/base/sql/sequence.rb

@@ -0,0 +1,55 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      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_retrieving_sequences
+          
+          raise FeatureNotFound
+          
+        end              
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      module TableMetadata
+        
+        private
+        
+        # There's no standard way to retrieve tables.
+        # Subclasses need to override this method.
+        
+        def sql_for_retrieving_tables
+      
+          raise FeatureNotFound
+      
+        end        
+        
+        # There's no standard way to retrieve columns.
+        # Subclasses need to override this method.        
+        
+        def sql_for_retrieving_columns ( options = {} )
+          
+          raise FeatureNotFound
+          
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      module TableOperation
+        
+        private
+        
+        # Generate SQL statement for dropping table.
+        # This will probably work for every database.
+      
+        def sql_for_dropping_table ( options )
+           
+          'DROP TABLE ' + quote( options[:table_name] )
+                
+        end        
+        
+        # Generate SQL statement for creating table.
+        # This will probably work for every database.        
+      
+        def sql_for_creating_table ( options )
+
+          columns = []
+          keys    = []
+
+          # Let's parse some columns in order to provide default options.
+
+          parse_fields options[:fields] do |field|
+          
+            # Convert a regular field into SQL's one.
+          
+            columns << build_column( field )
+            keys    << quote(field[:name]) if field[:pk]
+        
+          end                 
+               
+          syntax  = 'CREATE TABLE ' + quote( options[:table_name] )
+          syntax += '('
+          syntax += columns.join(',')
+          syntax += ', PRIMARY KEY(' + keys.join(',') + ')' if keys.length > 0
+          syntax += ')'
+
+          syntax
+   
+        end        
+        
+      end      
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      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 ( name = nil )
+          
+          name == nil ? 'ROLLBACK' : 'ROLLBACK TO ' + name
+          
+        end
+        
+        # Generate SQL statement for placing a saving point.
+                
+        def sql_for_saving_point ( name )
+          
+          'SAVEPOINT ' + name
+          
+        end        
+        
+      end
+    end
+  end
+end

data/lib/imparcial/driver/base/sql/update.rb

@@ -0,0 +1,29 @@
+module Imparcial
+  module Driver
+    module SQLBase
+      module Update
+        
+        private
+        
+        def sql_for_updating ( options )
+
+          syntax = 'UPDATE ' + quote(options[:table_name]) + ' SET '          
+        
+          options[:values].each do |name, value|
+        
+            syntax += quote(name) + ' = ' + quote_value(value) + ','
+        
+          end
+        
+          syntax.chop!
+        
+          syntax += parse_conditions options[:conditions]         
+          
+          syntax
+          
+        end
+    
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require 'imparcial/driver/base/sql/table_operation'
+require 'imparcial/driver/base/sql/table_metadata'
+require 'imparcial/driver/base/sql/sequence'
+require 'imparcial/driver/base/sql/transaction'
+require 'imparcial/driver/base/sql/index'
+require 'imparcial/driver/base/sql/insert'
+require 'imparcial/driver/base/sql/delete'
+require 'imparcial/driver/base/sql/select'
+require 'imparcial/driver/base/sql/update'
+
+module Imparcial
+  module Driver
+    module SQLBase
+      include TableOperation
+      include TableMetadata
+      include Sequence
+      include Transaction
+      include Index
+      include Insert
+      include Delete
+      include Select
+      include Update
+    end
+  end
+end