imparcial 0.0.1 → 0.0.2

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

@@ -0,0 +1,53 @@
+module Imparcial
+  module Driver
+    module PostgreSQL
+      module Column
+
+        private
+
+        def sql_for_renaming_column ( options )
+
+          syntax = ''
+        
+          syntax += 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+ 
+          options[:field].each do |old_name, new_name|
+                        
+            syntax += "RENAME COLUMN #{old_name} TO #{new_name}"
+            
+          end
+                      
+          logger.warn(syntax) if @table_logging
+
+          syntax
+        
+        end
+  
+        def sql_for_modifying_columns ( options )
+
+          syntax = ''
+        
+          syntax += 'ALTER TABLE ' + quote(options[:table_name]) + ' '
+ 
+          options[:fields].each do |field|
+            
+            column = field_to_column field
+                        
+            syntax += "ALTER COLUMN #{column[:name]} TYPE #{column[:type]}"
+            syntax += "(#{column[:size]})" if column[:size]
+            syntax += ","
+            
+          end
+          
+          syntax.chop!
+                      
+          logger.warn(syntax) if @table_logging
+
+          syntax
+        
+        end 
+      
+      end
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+module Imparcial
+  module Driver
+    module PostgreSQL
+      module Constraint
+
+        private
+
+        def sql_for_adding_auto_increment ( options )
+                   
+          seq_name = 'seq_' + options[:table_name].to_s + '_' + options[:field].to_s 
+          drop_sequence_if_necessary :sequence_name => seq_name
+          create_sequence :sequence_name => seq_name          
+          sql_for_adding_default_value :table_name => options[:table_name], :fields => {options[:field] => "nextval('#{seq_name}')"}
+          
+        end        
+        
+        def sql_for_adding_default_value ( options )
+                   
+          syntax  = 'ALTER TABLE ' + quote(options[:table_name]) + ' '   
+          
+          for field, value in options[:fields]
+          
+            value = quote_value(value) if not value.to_s.match('nextval')
+            syntax += "ALTER COLUMN #{quote(field)} SET DEFAULT #{value},"
+            
+          end
+          
+          syntax.chop!
+                             
+          syntax                  
+          
+        end        
+        
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module SQLPostgre   
+    module PostgreSQL   
       module Index
         
         private
@@ -9,19 +9,28 @@ module Imparcial
 
         def sql_for_index_exists? ( options )
           
-          %{
-            SELECT 1 FROM pg_class WHERE relkind = 'i' AND
-            relname = #{quote_value(options[:index_name])}
-          }
+          %{SELECT 
+              c2.relname as "table",
+              (select attname from pg_attribute where attrelid = i.indexrelid AND attnum > 0) as "column" ,
+              c.relname as "index"             
+            FROM pg_class c
+            JOIN pg_roles r ON r.oid = c.relowner
+            LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
+            LEFT JOIN pg_index i ON i.indexrelid = c.oid
+            LEFT JOIN pg_class c2 ON i.indrelid = c2.oid
+            WHERE c.relkind = 'i'
+            AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND
+            c2.relname = #{quote_value(options[:table_name])} AND
+            c.relname = #{quote_value(options[:index_name])}
+           }
           
         end        
 
         # Generate SQL statement for retrieving all indexes.
         
-        def sql_for_retrieving_indexes
+        def sql_for_getting_indexes ( options )
           
-          %{
-            SELECT 
+          %{SELECT 
               c2.relname as "table",
               (select attname from pg_attribute where attrelid = i.indexrelid AND attnum > 0) as "column" ,
               c.relname as "index"             
@@ -30,22 +39,13 @@ module Imparcial
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
             LEFT JOIN pg_index i ON i.indexrelid = c.oid
             LEFT JOIN pg_class c2 ON i.indrelid = c2.oid
-            WHERE c.relkind IN ('i','')
-            AND n.nspname NOT IN ('pg_catalog', 'pg_toast')
-          }
+            WHERE c.relkind = 'i'
+            AND n.nspname NOT IN ('pg_catalog', 'pg_toast') AND
+            c2.relname = #{quote_value(options[:table_name])}
+           }
           
         end
         
-        # Generate SQL statement for retrieving indexes for a specific table.
-        
-        def sql_for_retrieving_indexes_for_table ( options )
-          
-          sql_for_retrieving_indexes + %{
-              AND c2.relname = #{quote_value(options[:table_name])}
-          }          
-          
-        end
-               
     
       end
     end

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

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module SQLPostgre
+    module PostgreSQL
       module Sequence
       
         private
@@ -10,15 +10,17 @@ module Imparcial
           %{
             SELECT 1 FROM pg_class WHERE relkind = 'S' AND
             relname = #{quote_value(options[:sequence_name])}
-          } 
+           } 
                   
         end     
                 
         # Generate SQL statement for retrieving sequences.
       
-        def sql_for_retrieving_sequences
+        def sql_for_getting_sequences
       
-          "SELECT relname FROM pg_class WHERE relkind = 'S'"
+          %{
+            SELECT relname FROM pg_class WHERE relkind = 'S'
+           }
       
         end                       
         

data/lib/imparcial/driver/postgre/sql/{table_metadata.rb → table.rb}

@@ -1,27 +1,27 @@
 module Imparcial
   module Driver
-    module SQLPostgre
-      module TableMetadata
+    module PostgreSQL
+      module Table
         
         private
                  
         # Generate SQL statement for retrieving tables.
         
-        def sql_for_retrieving_tables
+        def sql_for_getting_tables
         
           %{
             SELECT table_name FROM information_schema.tables 
             WHERE table_schema = 'public'
-          } 
+           } 
           
         end
                 
         # Generate SQL statement for retrieving columns.
-        
+=begin        
         def sql_for_retrieving_columns ( options )
         
           %{
-          SELECT 
+            SELECT 
             A.column_name, A.data_type, A.character_maximum_length,
             (A.is_nullable = 'YES') as allow_null,
             (A.column_name = B.column_name) as pk, 
@@ -36,10 +36,10 @@ module Imparcial
             FROM information_schema.columns A 
               LEFT JOIN information_schema.key_column_usage B ON  A.table_name = B.table_name 
             WHERE A.table_name = #{quote_value(options[:table_name])};
-          }
+           }
         
         end          
-        
+=end        
       end
     end
   end

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

@@ -1,15 +1,15 @@
-require 'imparcial/driver/postgre/sql/table_operation'
-require 'imparcial/driver/postgre/sql/table_metadata'
-require 'imparcial/driver/postgre/sql/sequence'
-require 'imparcial/driver/postgre/sql/index'
+FileList[File.dirname(__FILE__)  + '/sql/*.rb'].each do |f|
+  require f
+end
 
 module Imparcial
   module Driver
-    module SQLPostgre
-      include TableOperation
-      include TableMetadata
+    module PostgreSQL
+      include Table
       include Sequence
       include Index
+      include Constraint
+      include Column
     end
   end
 end

data/lib/imparcial/driver/postgre/typemap.rb

@@ -1,10 +1,10 @@
 module Imparcial
   module Driver
-    module TypemapPostgre
+    module PostgreTypemap
 
       def sql_types
       
-        super.dup.merge!('CHARACTER VARYING' => :string) 
+        super.dup.merge!('CHARACTER VARYING' => :string, 'DOUBLE PRECISION' => :float) 
         
       end
       

data/lib/imparcial/driver/postgre/util.rb

@@ -1,6 +1,6 @@
 module Imparcial
   module Driver
-    module UtilPostgre
+    module PostgreUtil
     
       def quote_value ( val )
       

data/lib/imparcial/driver/postgre.rb

@@ -1,28 +1,29 @@
 require 'postgres'
+
 require 'imparcial/driver/postgre/util'
-require 'imparcial/driver/postgre/typemap'
 require 'imparcial/driver/postgre/result'
+require 'imparcial/driver/postgre/typemap'
 require 'imparcial/driver/postgre/sql'
 require 'imparcial/driver/postgre/expression'
 
 module Imparcial
   module Driver    
-    class AdapterPostgre < AdapterBase
+    class PostgreAdapter < AbstractAdapter
     
+      include PostgreUtil
+      include PostgreTypemap
+      include PostgreSQL
+      include PostgreExpression
+      
       def adapter_specific_exception
       
         PGError
         
       end
     
-      include UtilPostgre
-      include TypemapPostgre
-      include SQLPostgre
-      include ExpressionPostgre
-    
       def connect
 
-        @conn = PGconn.connect @host, @port, '', '', @database, @user, @pass
+        @conn = PGconn.connect @host, @port, '', '', @database, @username, @password
         
       rescue adapter_specific_exception => ex
            
@@ -33,11 +34,10 @@ module Imparcial
       def query ( sql )
         
         result  = conn.exec sql
-        @result = ResultPostgre.new result
+        @result = PostgreResult.new result
         
       end
-
-    
+        
     end    
   end
 end

data/lib/imparcial/driver.rb

@@ -1 +1 @@
-require 'imparcial/driver/base'
+require 'imparcial/driver/abstract'

data/lib/imparcial/exception.rb

@@ -6,31 +6,37 @@ module Imparcial
   
     # Adapter
   
-    class AdapterError < ImparcialError; end
-    class AdapterNotFound < AdapterError; end
-    class AdapterConfigError < AdapterError; end
+    class AdapterError           < ImparcialError; end
+    class AdapterNotFound        < AdapterError; end
     class AdapterConnectionError < AdapterError; end
-  
-    # Result
-  
-    class ResultError < ImparcialError; end
     
     # Expression
     
     class ExpressionError < ImparcialError; end
 
     class FeatureNotFound < ExpressionError; end  
+    class ConditionError  < ExpressionError; end
+    class OptionError     < ExpressionError; end         
+    class ResultError     < ExpressionError; end      
 
     # Table
 
-    class TableError < ExpressionError; end
+    class TableError       < ExpressionError; end
     class TableCreateError < TableError; end
-    class TableDropError < TableError; end
-    class TableRetrieveError < TableError; end
-  
-    class ConditionError < ExpressionError; end
-    class OptionError < ExpressionError; end      
-
+    class TableDropError   < TableError; end
+    class TableListError   < TableError; end
+    class TableUpdateError < TableError; end
+    
+    # Column  
+      
+    class ColumnError           < ExpressionError; end
+    class ColumnListError       < ColumnError; end
+    class ColumnUpdateError     < ColumnError; end
+    class ColumnCreateError     < ColumnError; end
+    class ColumnDropError       < ColumnError; end
+    class ColumnConstraintError < ColumnError; end
+    class ColumnRenameError     < ColumnError; end
+    
     # Crud
 
     class SelectError < ExpressionError; end  
@@ -40,9 +46,11 @@ module Imparcial
 
     # Sequence
   
-    class SequenceError < ExpressionError; end
+    class SequenceError       < ExpressionError; end
     class SequenceCreateError < SequenceError; end
-    class SequenceDropError < SequenceError; end
+    class SequenceDropError   < SequenceError; end
+    class SequenceListError   < SequenceError; end
+    class SequenceUpdateError < SequenceError; end
   
     # Transaction
   
@@ -54,8 +62,10 @@ module Imparcial
   
     # Index
 
-    class IndexError < ExpressionError; end
+    class IndexError       < ExpressionError; end
     class IndexCreateError < IndexError; end
-    class IndexDropError < IndexError; end
+    class IndexDropError   < IndexError; end
+    class IndexListError   < IndexError; end
+    class IndexUpdateError < IndexError; end
     
 end

data/lib/imparcial/initializer.rb

@@ -0,0 +1,62 @@
+module Imparcial
+
+  # This is what happens in a nutshell:
+  # Firstly, we get some configs about the selected adapter. Things
+  # like user, pass and database.
+  # Secondly and not less important, based on those configs, we load
+  # the appropriate adapter.
+  # Finally, we copy those configs into new adapter object.    
+  # Now, those configs will also be avaliable in the adapter's instance.
+  
+  class Initializer
+
+    attr_accessor :host, :username, :password, :database, :socket, :adapter, :logger, :port
+
+    # Factory method.
+                                            
+    def self.run 
+    
+      instance = new
+    
+      yield instance
+      
+      instance.setup_adapter
+      
+    end     
+    
+    def host
+      
+      @host || 'localhost'
+      
+    end
+      
+    # Load adapter and copy instance vars.
+      
+    def setup_adapter
+      
+      require 'imparcial/driver/' + @adapter
+                    
+      # Get an adapter const.  
+                
+      adapter_const = ('Imparcial::Driver::' + @adapter.camelize + 'Adapter').to_const
+
+      adapter = adapter_const.new
+      
+      # Copy these instance variables into new adapter.
+      
+      instance_variables.each do |v|
+        
+        adapter.instance_variable_set(v,send(v.gsub('@','')))
+        
+      end
+
+      adapter
+      
+    rescue LoadError
+  
+      raise AdapterNotFound.new(driver + ' cannot be found')
+        
+    end 
+      
+  end
+end

data/lib/imparcial.rb

@@ -6,77 +6,4 @@ require 'facets/core/symbol/to_const'
 
 require 'imparcial/exception'
 require 'imparcial/driver'
-
-module Imparcial
-  class Initializer
-    
-    attr_accessor :host, :driver, :port, :user, :pass, :socket, :database
-
-    alias_method :adapter=, :driver=
-    alias_method :username=, :user=
-    alias_method :password=, :pass=
-    alias_method :sock=, :socket=
-    alias_method :db=, :database=     
-    alias_method :hostname=, :host= 
-      
-    alias_method :adapter, :driver
-    alias_method :username, :user
-    alias_method :password, :pass
-    alias_method :sock, :socket
-    alias_method :db, :database
-    alias_method :hostname, :host
-      
-    # Default is localhost.
-      
-    def host
-      
-      @host || 'localhost'
-      
-    end
-      
-    # Default is Mysql
-      
-    def driver
-      
-      @driver || 'mysql'
-        
-    end
-      
-    # Default is STDOUT
-      
-    def logger
-        
-      @logger || Logger.new( STDERR )
-        
-    end
-                  
-    def self.run 
-    
-      instance = new
-    
-      yield instance
-      
-      instance.start_me
-      
-    end     
-      
-    def start_me
-                                             
-      require 'imparcial/driver/' + driver
-                
-      # Get an adapter const.  
-                
-      adapter_const = ('Imparcial::Driver::Adapter' + driver.camelize).to_const
-
-      adapter = adapter_const.new self 
- 
-      adapter
-      
-    rescue LoadError
-  
-      raise AdapterNotFound.new(driver + ' cannot be found')
-        
-    end               
-        
-  end
-end
+require 'imparcial/initializer'