sequel 0.3.1 → 0.3.2

data/lib/sequel/dataset.rb

@@ -97,7 +97,7 @@ module Sequel
       new_dataset
     end
     
-    def set_options(opts)
+    def set_options(opts) #:nodoc:
       @opts = opts
       @columns = nil
     end
@@ -152,6 +152,11 @@ module Sequel
     def <<(*args)
       insert(*args)
     end
+  
+    # Updates the dataset with the given values.
+    def set(*args)
+      update(*args)
+    end
     
     # Iterates over the records in the dataset
     def each(opts = nil, &block)
@@ -307,6 +312,7 @@ module Sequel
         end
       end
       update_each_method
+      self
     end
     
     # Applies the value transform for data loaded from the database.
@@ -383,11 +389,11 @@ module Sequel
 
     @@dataset_classes = []
 
-    def self.dataset_classes
+    def self.dataset_classes #:nodoc:
       @@dataset_classes
     end
 
-    def self.inherited(c)
+    def self.inherited(c) #:nodoc:
       @@dataset_classes << c
     end
   end

data/lib/sequel/dataset/convenience.rb

@@ -77,11 +77,11 @@ module Sequel
         end
       end
       
-      # Maps field values for each record in the dataset (if a field name is
+      # Maps column values for each record in the dataset (if a column name is
       # given), or performs the stock mapping functionality of Enumerable.
-      def map(field_name = nil, &block)
-        if field_name
-          super() {|r| r[field_name]}
+      def map(column_name = nil, &block)
+        if column_name
+          super() {|r| r[column_name]}
         else
           super(&block)
         end
@@ -152,24 +152,43 @@ module Sequel
         b - a + 1
       end
 
-      # Returns the minimum value for the given field.
-      def min(field)
-        single_value(:select => [field.MIN.AS(:v)])
+      # Returns the minimum value for the given column.
+      def min(column)
+        single_value(:select => [column.MIN.AS(:v)])
       end
 
-      # Returns the maximum value for the given field.
-      def max(field)
-        single_value(:select => [field.MAX.AS(:v)])
+      # Returns the maximum value for the given column.
+      def max(column)
+        single_value(:select => [column.MAX.AS(:v)])
       end
 
-      # Returns the sum for the given field.
-      def sum(field)
-        single_value(:select => [field.SUM.AS(:v)])
+      # Returns the sum for the given column.
+      def sum(column)
+        single_value(:select => [column.SUM.AS(:v)])
       end
 
-      # Returns the average value for the given field.
-      def avg(field)
-        single_value(:select => [field.AVG.AS(:v)])
+      # Returns the average value for the given column.
+      def avg(column)
+        single_value(:select => [column.AVG.AS(:v)])
+      end
+      
+      # Returns a dataset grouped by the given column with count by group.
+      def group_and_count(column)
+        group(column).select(column, :count[column].AS(:count)).order(:count)
+      end
+      
+      # Returns a Range object made from the minimum and maximum values for the
+      # given column.
+      def range(column)
+        r = select(column.MIN.AS(:v1), column.MAX.AS(:v2)).first
+        r && (r[:v1]..r[:v2])
+      end
+      
+      # Returns the interval between minimum and maximum values for the given 
+      # column.
+      def interval(column)
+        r = select("(max(#{literal(column)}) - min(#{literal(column)})) AS v".lit).first
+        r && r[:v]
       end
 
       # Pretty prints the records in the dataset as plain-text table.
@@ -216,7 +235,7 @@ module Sequel
         end
       end
       
-      module QueryBlockCopy
+      module QueryBlockCopy #:nodoc:
         def each(*args); raise SequelError, "#each cannot be invoked inside a query block."; end
         def insert(*args); raise SequelError, "#insert cannot be invoked inside a query block."; end
         def update(*args); raise SequelError, "#update cannot be invoked inside a query block."; end
@@ -244,7 +263,9 @@ module Sequel
       end
       
       MUTATION_RE = /^(.+)!$/.freeze
-      
+
+      # Provides support for mutation methods (filter!, order!, etc.) and magic
+      # methods.
       def method_missing(m, *args, &block)
         if m.to_s =~ MUTATION_RE
           m = $1.to_sym
@@ -253,10 +274,36 @@ module Sequel
           super if copy.class != self.class
           @opts.merge!(copy.opts)
           self
+        elsif magic_method_missing(m)
+          send(m, *args)
         else
-          super
+           super
         end
       end
+      
+      MAGIC_METHODS = {
+        /^order_by_(.+)$/   => proc {|c| proc {order(c)}},
+        /^first_by_(.+)$/   => proc {|c| proc {order(c).first}},
+        /^last_by_(.+)$/    => proc {|c| proc {order(c).last}},
+        /^filter_by_(.+)$/  => proc {|c| proc {|v| filter(c => v)}},
+        /^all_by_(.+)$/     => proc {|c| proc {|v| filter(c => v).all}},
+        /^find_by_(.+)$/    => proc {|c| proc {|v| filter(c => v).first}},
+        /^group_by_(.+)$/   => proc {|c| proc {group(c)}},
+        /^count_by_(.+)$/   => proc {|c| proc {group_and_count(c)}}
+      }
+
+      # Checks if the given method name represents a magic method and 
+      # defines it. Otherwise, nil is returned.
+      def magic_method_missing(m)
+        method_name = m.to_s
+        MAGIC_METHODS.each_pair do |r, p|
+          if method_name =~ r
+            impl = p[$1.to_sym]
+            return Dataset.class_def(m, &impl)
+          end
+        end
+        nil
+      end
     end
   end
 end

data/lib/sequel/dataset/sequelizer.rb

@@ -154,15 +154,15 @@ class Sequel::Dataset
       end
     end
     
-    def fcall_expr(e, b)
+    def fcall_expr(e, b) #:nodoc:
       ext_expr(e, b)
     end
     
-    def vcall_expr(e, b)
+    def vcall_expr(e, b) #:nodoc:
       eval(e[1].to_s, b)
     end
     
-    def iter_expr(e, b)
+    def iter_expr(e, b) #:nodoc:
       if e[1] == [:fcall, :proc]
         eval_expr(e[3], b) # inline proc
       else
@@ -223,7 +223,7 @@ class Sequel::Dataset
       end
     end
     
-    def pt_expr(e, b)
+    def pt_expr(e, b) #:nodoc:
       case e[0]
       when :not # negation: !x, (x != y), (x !~ y)
         if (e[1][0] == :lit) && (Symbol === e[1][1])

data/lib/sequel/dataset/sql.rb

@@ -3,56 +3,56 @@ module Sequel
     # The Dataset SQL module implements all the dataset methods concerned with
     # generating SQL statements for retrieving and manipulating records.
     module SQL
-      # Returns a valid SQL fieldname as a string. Field names specified as 
+      # Returns a valid SQL column name as a string. Column names specified as 
       # symbols can include double underscores to denote a dot separator, e.g.
       # :posts__id will be converted into posts.id.
-      def field_name(field)
-        case field
+      def column_name(column)
+        case column
         when Symbol, String:
-          quoted_field_name(field.to_field_name)
+          quoted_column_name(column.to_column_name)
         when Hash:
-          field.map {|f,a| "#{field_name(f)} AS #{field_name(a)}"}.join(COMMA_SEPARATOR)
+          column.map {|f,a| "#{column_name(f)} AS #{column_name(a)}"}.join(COMMA_SEPARATOR)
         else
-          field
+          column
         end
       end
 
-      # Adds quoting to field references. This method is just a stub and can
-      # be overriden in adapters in order to provide correct field quoting
+      # Adds quoting to column references. This method is just a stub and can
+      # be overriden in adapters in order to provide correct column quoting
       # behavior.
-      def quoted_field_name(name)
+      def quoted_column_name(name)
         name
       end
       
       ALIASED_REGEXP = /^(.*)\s(.*)$/.freeze
       QUALIFIED_REGEXP = /^(.*)\.(.*)$/.freeze
 
-      # Returns a qualified field name (including a table name) if the field
+      # Returns a qualified column name (including a table name) if the column
       # name isn't already qualified.
-      def qualified_field_name(field, table)
-        field = field_name(field)
-        if field =~ QUALIFIED_REGEXP
-          # field is already qualified
-          field
+      def qualified_column_name(column, table)
+        column = column_name(column)
+        if column =~ QUALIFIED_REGEXP
+          # column is already qualified
+          column
         else 
           # check if the table is aliased
           if table =~ ALIASED_REGEXP
             table = $2
           end
-          "#{table}.#{field}"
+          "#{table}.#{column}"
         end
       end
 
       WILDCARD = '*'.freeze
       COMMA_SEPARATOR = ", ".freeze
 
-      # Converts an array of field names into a comma seperated string of 
-      # field names. If the array is empty, a wildcard (*) is returned.
-      def field_list(fields)
-        if fields.empty?
+      # Converts an array of column names into a comma seperated string of 
+      # column names. If the array is empty, a wildcard (*) is returned.
+      def column_list(columns)
+        if columns.empty?
           WILDCARD
         else
-          fields.map do |i|
+          columns.map do |i|
             i.is_a?(Hash) ? i.map {|kv| "#{literal(kv[0])} AS #{kv[1]}"} : literal(i)
           end.join(COMMA_SEPARATOR)
         end
@@ -87,7 +87,7 @@ module Sequel
       # Returns a literal representation of a value to be used as part
       # of an SQL expression. The stock implementation supports literalization 
       # of String (with proper escaping to prevent SQL injections), numbers,
-      # Symbol (as field references), Array (as a list of literalized values),
+      # Symbol (as column references), Array (as a list of literalized values),
       # Time (as an SQL TIMESTAMP), Date (as an SQL DATE), Dataset (as a 
       # subquery) and nil (AS NULL).
       # 
@@ -105,7 +105,7 @@ module Sequel
         when NilClass: NULL
         when TrueClass: TRUE
         when FalseClass: FALSE
-        when Symbol: quoted_field_name(v.to_field_name)
+        when Symbol: quoted_column_name(v.to_column_name)
         when Array: v.empty? ? NULL : v.map {|i| literal(i)}.join(COMMA_SEPARATOR)
         when Time: v.strftime(TIMESTAMP_FORMAT)
         when Date: v.strftime(DATE_FORMAT)
@@ -146,9 +146,9 @@ module Sequel
         clone_merge(:from => source)
       end
 
-      # Returns a copy of the dataset with the selected fields changed.
-      def select(*fields)
-        clone_merge(:select => fields)
+      # Returns a copy of the dataset with the selected columns changed.
+      def select(*columns)
+        clone_merge(:select => columns)
       end
 
       # Returns a copy of the dataset with the distinct option.
@@ -172,7 +172,7 @@ module Sequel
 
       DESC_ORDER_REGEXP = /(.*)\sDESC/i.freeze
 
-      # Inverts the given order by breaking it into a list of field references
+      # Inverts the given order by breaking it into a list of column references
       # and inverting them.
       #
       #   dataset.invert_order('id DESC') #=> "id"
@@ -190,9 +190,9 @@ module Sequel
       end
 
       # Returns a copy of the dataset with the results grouped by the value of 
-      # the given fields
-      def group(*fields)
-        clone_merge(:group => fields)
+      # the given columns
+      def group(*columns)
+        clone_merge(:group => columns)
       end
       
       alias_method :group_by, :group
@@ -330,8 +330,8 @@ module Sequel
 
         join_conditions = {}
         expr.each do |k, v|
-          k = qualified_field_name(k, table).intern if k.is_a?(Symbol)
-          v = qualified_field_name(v, @opts[:last_joined_table] || @opts[:from].first).intern if v.is_a?(Symbol)
+          k = qualified_column_name(k, table).intern if k.is_a?(Symbol)
+          v = qualified_column_name(v, @opts[:last_joined_table] || @opts[:from].first).intern if v.is_a?(Symbol)
           join_conditions[k] = v
         end
         " #{join_type} #{table} ON #{expression_list(join_conditions)}"
@@ -359,7 +359,6 @@ module Sequel
       # Returns an INNER joined dataset.
       def inner_join(table, expr); join_table(:inner, table, expr); end
       alias join inner_join
-      
 
       # Inserts multiple values. If a block is given it is invoked for each
       # item in the given array before inserting it.
@@ -380,12 +379,12 @@ module Sequel
           return sql
         end
 
-        fields = opts[:select]
-        select_fields = fields ? field_list(fields) : WILDCARD
+        columns = opts[:select]
+        select_columns = columns ? column_list(columns) : WILDCARD
         select_source = source_list(opts[:from])
         sql = opts[:distinct] ? \
-          "SELECT DISTINCT #{select_fields} FROM #{select_source}" : \
-          "SELECT #{select_fields} FROM #{select_source}"
+          "SELECT DISTINCT #{select_columns} FROM #{select_source}" : \
+          "SELECT #{select_columns} FROM #{select_source}"
         
         if join = opts[:join]
           sql << join
@@ -396,11 +395,11 @@ module Sequel
         end
 
         if group = opts[:group]
-          sql << " GROUP BY #{field_list(group)}"
+          sql << " GROUP BY #{column_list(group)}"
         end
 
         if order = opts[:order]
-          sql << " ORDER BY #{field_list(order)}"
+          sql << " ORDER BY #{column_list(order)}"
         end
 
         if having = opts[:having]
@@ -430,7 +429,7 @@ module Sequel
       alias sql select_sql
 
       # Formats an INSERT statement using the given values. If a hash is given,
-      # the resulting statement includes field names. If no values are given, 
+      # the resulting statement includes column names. If no values are given, 
       # the resulting statement includes a DEFAULT VALUES clause.
       #
       #   dataset.insert_sql() #=> 'INSERT INTO items DEFAULT VALUES'
@@ -461,7 +460,7 @@ module Sequel
               "INSERT INTO #{@opts[:from]} DEFAULT VALUES;"
             else
               fl, vl = [], []
-              values.each {|k, v| fl << field_name(k); vl << literal(v)}
+              values.each {|k, v| fl << column_name(k); vl << literal(v)}
               "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)});"
             end
           when Dataset
@@ -489,7 +488,7 @@ module Sequel
           values = values.to_hash
         end
         values = transform_save(values) if @transform
-        set_list = values.map {|k, v| "#{field_name(k)} = #{literal(v)}"}.
+        set_list = values.map {|k, v| "#{column_name(k)} = #{literal(v)}"}.
           join(COMMA_SEPARATOR)
         sql = "UPDATE #{@opts[:from]} SET #{set_list}"
 

data/lib/sequel/db2.rb

@@ -0,0 +1,160 @@
+if !Object.const_defined?('Sequel')
+  require File.join(File.dirname(__FILE__), '../sequel')
+end
+
+require 'db2/db2cli'
+
+module Sequel
+  module DB2
+    class Database < Sequel::Database
+      set_adapter_scheme :db2
+      include DB2CLI
+      
+      # AUTO_INCREMENT = 'IDENTITY(1,1)'.freeze
+      # 
+      # def auto_increment_sql
+      #   AUTO_INCREMENT
+      # end
+      
+      def check_error(rc, msg)
+        case rc
+        when SQL_SUCCESS, SQL_SUCCESS_WITH_INFO: nil
+        else
+          raise SequelError, msg
+        end
+      end
+      
+      rc, @@env = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE)
+      check_error(rc, "Could not allocate DB2 environment")
+
+      def connect
+        rc, dbc = SQLAllocHandle(SQL_HANDLE_DBC, @@env) 
+        check_error(rc, "Could not allocate database connection")
+        
+        rc = SQLConnect(dbc, @opts[:database], @opts[:user], @opts[:password]) 
+        check_error(rc, "Could not connect to database")
+        
+        dbc
+      end
+      
+      def disconnect
+        @pool.disconnect do |conn|
+          rc = SQLDisconnect(conn)
+          check_error(rc, "Could not disconnect from database")
+
+          rc = SQLFreeHandle(SQL_HANDLE_DBC, conn)
+          check_error(rc, "Could not free Database handle")
+        end
+      end
+    
+      def test_connection
+        @pool.hold {|conn|}
+        true
+      end
+
+      def dataset(opts = nil)
+        DB2::Dataset.new(self, opts)
+      end
+      
+      def execute(sql, &block)
+        @logger.info(sql) if @logger
+        @pool.hold do |conn|
+          rc, sth = SQLAllocHandle(SQL_HANDLE_STMT, @handle) 
+          check_error(rc, "Could not allocate statement")
+
+          begin
+            rc = SQLExecDirect(sth, sql) 
+            check_error(rc, "Could not execute statement")
+            
+            block[sth] if block
+
+            rc, rpc = SQLRowCount(sth)
+            check_error(rc, "Could not get RPC") 
+            rpc
+          ensure
+            rc = SQLFreeHandle(SQL_HANDLE_STMT, sth)
+            check_error(rc, "Could not free statement")
+          end
+        end
+      end
+      alias_method :do, :execute
+    end
+    
+    class Dataset < Sequel::Dataset
+      def literal(v)
+        case v
+        when Time: literal(v.iso8601)
+        else
+          super
+        end
+      end
+
+      def fetch_rows(sql, &block)
+        @db.synchronize do
+          @db.execute(sql) do |sth|
+            @column_info = get_column_info(sth)
+            @columns = @column_info.map {|c| c[:name]}
+            while (rc = SQLFetch(@handle)) != SQL_NO_DATA_FOUND
+              @db.check_error(rc, "Could not fetch row")
+              yield hash_row(sth)
+            end
+          end
+        end
+        self
+      end
+      
+      MAX_COL_SIZE = 256
+
+      def get_column_info(sth)
+        rc, column_count = SQLNumResultCols(sth)
+        @db.check_error(rc, "Could not get number of result columns")
+
+        (1..column_count).map do |i| 
+          rc, name, buflen, datatype, size, digits, nullable = SQLDescribeCol(sth, i, MAX_COL_SIZE)
+          @b.check_error(rc, "Could not describe column")
+          
+          {:name => name, :db2_type => datatype, :precision => size}
+        end 
+      end
+      
+      def hash_row(sth)
+        row = {}
+        @column_info.each_with_index do |c, i|
+          rc, v = SQLGetData(sth, i+1, c[:db2_type], c[:precision]) 
+          @db.check_error(rc, "Could not get data")
+          
+          @row[c[:name]] = convert_type(v)
+        end
+        row
+      end
+      
+      def convert_type(v)
+        case v
+        when DB2CLI::Date 
+          DBI::Date.new(v.year, v.month, v.day)
+        when DB2CLI::Time
+          DBI::Time.new(v.hour, v.minute, v.second)
+        when DB2CLI::Timestamp 
+          DBI::Timestamp.new(v.year, v.month, v.day,
+            v.hour, v.minute, v.second, v.fraction)
+        when DB2CLI::Null
+          nil
+        else  
+          v
+        end
+      end
+    
+      def insert(*values)
+        @db.do insert_sql(*values)
+      end
+    
+      def update(values, opts = nil)
+        @db.do update_sql(values, opts)
+      end
+    
+      def delete(opts = nil)
+        @db.do delete_sql(opts)
+      end
+    end
+  end
+end