sequel 4.3.0 → 4.4.0

data/lib/sequel/adapters/sqlanywhere.rb

@@ -0,0 +1,177 @@
+require 'sqlanywhere'
+
+Sequel.require %w'shared/sqlanywhere', 'adapters'
+
+module Sequel
+  # Module for holding all SqlAnywhere-related classes and modules for Sequel.
+  module SqlAnywhere
+
+    class SQLAnywhereException < StandardError
+      attr_reader :errno
+      attr_reader :sql
+
+      def initialize(message, errno, sql)
+        super(message)
+        @errno = errno
+        @sql = sql
+      end
+    end
+
+    TYPE_TRANSLATOR = tt = Class.new do
+      def blob(s) ::Sequel::SQL::Blob.new(s) end
+      def boolean(s) s.to_i != 0 end
+      def date(s) ::Date.strptime(s) end
+      def decimal(s) ::BigDecimal.new(s) end
+      def time(s) ::Sequel.string_to_time(s) end
+    end.new
+
+    SQLANYWHERE_TYPES = {}
+    {
+        [0, 484] => tt.method(:decimal),
+        [384] => tt.method(:date),
+        [388] =>  tt.method(:time),
+        [500] => tt.method(:boolean),
+        [524, 528] => tt.method(:blob)
+    }.each do |k,v|
+      k.each{|n| SQLANYWHERE_TYPES[n] = v}
+    end
+
+    # Database class for SQLAnywhere databases used with Sequel.
+    class Database < Sequel::Database
+      include Sequel::SqlAnywhere::DatabaseMethods
+
+      DEFAULT_CONFIG = { :user => 'dba', :password => 'sql' }
+
+      attr_accessor :api
+
+      set_adapter_scheme :sqlanywhere
+
+      def connect(server)
+        opts = server_opts(server)
+        unless conn_string = opts[:conn_string]
+          conn_string = []
+          conn_string << "Host=#{opts[:host]}#{":#{opts[:port]}" if opts[:port]}" if opts[:host]
+          conn_string << "DBN=#{opts[:database]}" if opts[:database]
+          conn_string << "UID=#{opts[:user]}" if opts[:user]
+          conn_string << "Password=#{opts[:password]}" if opts[:password]
+          conn_string << "CommLinks=#{opts[:commlinks]}" if opts[:commlinks]
+          conn_string << "ConnectionName=#{opts[:connection_name]}" if opts[:connection_name]
+          conn_string << "CharSet=#{opts[:encoding]}" if opts[:encoding]
+          conn_string << "Idle=0" # Prevent the server from disconnecting us if we're idle for >240mins (by default)
+          conn_string << nil
+          conn_string = conn_string.join(';')
+        end
+
+        conn = @api.sqlany_new_connection
+        raise LoadError, "Could not connect" unless conn && @api.sqlany_connect(conn, conn_string) == 1
+
+        if Sequel.application_timezone == :utc
+          @api.sqlany_execute_immediate(conn, "SET TEMPORARY OPTION time_zone_adjustment=0")
+        end
+
+        conn
+      end
+
+      # Closes given database connection.
+      def disconnect_connection(c)
+        @api.sqlany_disconnect(c)
+      end
+
+      # Returns number of rows affected
+      def execute_dui(sql, opts=OPTS)
+        synchronize do |conn|
+          _execute(conn, :rows, sql, opts)
+        end
+      end
+
+      def execute(sql, opts=OPTS, &block)
+        synchronize do |conn|
+          _execute(conn, :select, sql, opts, &block)
+        end
+      end
+
+      def execute_insert(sql, opts=OPTS)
+        synchronize do |conn|
+          _execute(conn, :insert, sql, opts)
+        end
+      end
+
+      private
+
+      LAST_INSERT_ID = 'SELECT @@IDENTITY'.freeze
+      def _execute(conn, type, sql, opts)
+        unless rs = log_yield(sql){@api.sqlany_execute_direct(conn, sql)}
+          result, errstr = @api.sqlany_error(conn)
+          raise_error(SQLAnywhereException.new(errstr, result, sql))
+        end
+
+        case type
+        when :select
+          yield rs if block_given?
+        when :rows
+          return @api.sqlany_affected_rows(rs)
+        when :insert
+          _execute(conn, :select, LAST_INSERT_ID, opts){|r| return @api.sqlany_get_column(r, 0)[1] if r && @api.sqlany_fetch_next(r) == 1}
+        end
+      ensure
+        @api.sqlany_commit(conn) unless in_transaction?
+        @api.sqlany_free_stmt(rs) if rs
+      end
+
+      def adapter_initialize
+        @conversion_procs = SQLANYWHERE_TYPES.dup
+        @conversion_procs[392] = method(:to_application_timestamp_sa)
+        @api = SQLAnywhere::SQLAnywhereInterface.new
+        raise LoadError, "Could not load SQLAnywhere DBCAPI library" if SQLAnywhere::API.sqlany_initialize_interface(@api) == 0
+        raise LoadError, "Could not initialize SQLAnywhere DBCAPI library" if @api.sqlany_init == 0
+      end
+
+      def log_connection_execute(conn, sql)
+        _execute(conn, nil, sql, OPTS)
+      end
+    end
+
+    # Dataset class for SqlAnywhere datasets accessed via the native driver.
+    class Dataset < Sequel::Dataset
+      include Sequel::SqlAnywhere::DatasetMethods
+
+      Database::DatasetClass = self
+
+      # Yield all rows matching this dataset.  If the dataset is set to
+      # split multiple statements, yield arrays of hashes one per statement
+      # instead of yielding results for all statements as hashes.
+      def fetch_rows(sql)
+        db = @db
+        cps = db.conversion_procs
+        api = db.api
+        execute(sql) do |rs|
+          convert = (convert_smallint_to_bool and db.convert_smallint_to_bool)
+          col_infos = []
+          api.sqlany_num_cols(rs).times do |i|
+            _, _, name, _, type = api.sqlany_get_column_info(rs, i)
+            cp = if type == 500
+              cps[500] if convert
+            else
+              cps[type]
+            end
+            col_infos << [i, output_identifier(name), cp]
+          end
+
+          @columns = col_infos.map{|a| a[1]}
+
+          if rs
+            while api.sqlany_fetch_next(rs) == 1
+              h = {}
+              col_infos.each do |i, name, cp|
+                _, v = api.sqlany_get_column(rs, i)
+                h[name] = cp && v ? cp[v] : v
+              end
+              yield h
+            end
+          end
+        end
+        self
+      end
+    end
+  end
+end

data/lib/sequel/adapters/utils/emulate_offset_with_row_number.rb

@@ -11,9 +11,12 @@ module Sequel
     def select_sql
       return super unless o = @opts[:offset]
 
-      order = @opts[:order] || default_offset_order
-      if order.nil? || order.empty?
-        raise(Error, "#{db.database_type} requires an order be provided if using an offset")
+      order = @opts[:order]
+      if require_offset_order?
+        order ||= default_offset_order
+        if order.nil? || order.empty?
+          raise(Error, "#{db.database_type} requires an order be provided if using an offset")
+        end
       end
 
       columns = clone(:append_sql=>'').columns
@@ -38,5 +41,10 @@ module Sequel
     def default_offset_order
       clone(:append_sql=>'').columns
     end
+
+    # Whether an order is required when using offset emulation via ROW_NUMBER, true by default.
+    def require_offset_order?
+      true
+    end
   end
 end

data/lib/sequel/core.rb

@@ -17,8 +17,8 @@
 #
 #   Sequel.sqlite('blog.db'){|db| puts db[:users].count} 
 #
-# For a more expanded introduction, see the {README}[link:files/README_rdoc.html].
-# For a quicker introduction, see the {cheat sheet}[link:files/doc/cheat_sheet_rdoc.html].
+# For a more expanded introduction, see the {README}[rdoc-ref:README.rdoc].
+# For a quicker introduction, see the {cheat sheet}[rdoc-ref:doc/cheat_sheet.rdoc].
 module Sequel
   @convert_two_digit_years = true
   @datetime_class = Time
@@ -89,8 +89,8 @@ module Sequel
   #
   #   Sequel.connect('sqlite://blog.db'){|db| puts db[:users].count}  
   # 
-  # For details, see the {"Connecting to a Database" guide}[link:files/doc/opening_databases_rdoc.html].
-  # To set up a master/slave or sharded database connection, see the {"Master/Slave Databases and Sharding" guide}[link:files/doc/sharding_rdoc.html].
+  # For details, see the {"Connecting to a Database" guide}[rdoc-ref:doc/opening_databases.rdoc].
+  # To set up a master/slave or sharded database connection, see the {"Master/Slave Databases and Sharding" guide}[rdoc-ref:doc/sharding.rdoc].
   def self.connect(*args, &block)
     Database.connect(*args, &block)
   end

data/lib/sequel/database/connecting.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     # Array of supported database adapters
-    ADAPTERS = %w'ado amalgalite cubrid db2 dbi do firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlite swift tinytds'.collect{|x| x.to_sym}
+    ADAPTERS = %w'ado amalgalite cubrid db2 dbi do firebird ibmdb informix jdbc mock mysql mysql2 odbc openbase oracle postgres sqlanywhere sqlite swift tinytds'.collect{|x| x.to_sym}
 
     @single_threaded = false
 

data/lib/sequel/database/query.rb

@@ -6,7 +6,7 @@ module Sequel
     # ---------------------
 
     STRING_DEFAULT_RE = /\A'(.*)'\z/
-    CURRENT_TIMESTAMP_RE = /now|CURRENT|getdate|\ADate\(\)\z/io
+    CURRENT_TIMESTAMP_RE = /now|today|CURRENT|getdate|\ADate\(\)\z/io
     COLUMN_SCHEMA_DATETIME_TYPES = [:date, :datetime]
     COLUMN_SCHEMA_STRING_TYPES = [:string, :blob, :date, :datetime, :time, :enum, :set, :interval]
 

data/lib/sequel/database/schema_generator.rb

@@ -13,7 +13,7 @@ module Sequel
     # the column method, which makes for a nicer DSL.
     #
     # For more information on Sequel's support for schema modification, see
-    # the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
+    # the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     class CreateTableGenerator
       # Classes specifying generic types that Sequel will convert to database-specific types.
       GENERIC_TYPES=[String, Integer, Fixnum, Bignum, Float, Numeric, BigDecimal,

data/lib/sequel/database/schema_methods.rb

@@ -71,7 +71,7 @@ module Sequel
     # definitions using <tt>create_table</tt>, and +add_index+ accepts all the options
     # available for index definition.
     #
-    # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[link:files/doc/migration_rdoc.html].
+    # See <tt>Schema::AlterTableGenerator</tt> and the {"Migrations and Schema Modification" guide}[rdoc-ref:doc/migration.rdoc].
     def alter_table(name, generator=nil, &block)
       generator ||= alter_table_generator(&block)
       remove_cached_schema(name)
@@ -159,7 +159,7 @@ module Sequel
     # :inherits :: Inherit from a different tables.  An array can be
     #              specified to inherit from multiple tables.
     #
-    # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[link:files/doc/schema_modification_rdoc.html].
+    # See <tt>Schema::Generator</tt> and the {"Schema Modification" guide}[rdoc-ref:doc/schema_modification.rdoc].
     def create_table(name, options=OPTS, &block)
       remove_cached_schema(name)
       options = {:generator=>options} if options.is_a?(Schema::CreateTableGenerator)

data/lib/sequel/dataset.rb

@@ -21,7 +21,7 @@ module Sequel
   # Datasets are Enumerable objects, so they can be manipulated using any
   # of the Enumerable methods, such as map, inject, etc.
   #
-  # For more information, see the {"Dataset Basics" guide}[link:files/doc/dataset_basics_rdoc.html].
+  # For more information, see the {"Dataset Basics" guide}[rdoc-ref:doc/dataset_basics.rdoc].
   class Dataset
     OPTS = Sequel::OPTS
 

data/lib/sequel/dataset/actions.rb

@@ -271,6 +271,8 @@ module Sequel
     # :commit_every :: Open a new transaction for every given number of records.
     #                  For example, if you provide a value of 50, will commit
     #                  after every 50 records.
+    # :return :: When the :value is :primary_key, returns an array of
+    #            autoincremented primary key values for the rows inserted.
     # :server :: Set the server/shard to use for the transaction and insert
     #            queries.
     # :slice :: Same as :commit_every, :commit_every takes precedence.

data/lib/sequel/dataset/graph.rb

@@ -44,7 +44,7 @@ module Sequel
     #            some metadata about the join that makes it important to use +graph+ instead
     #            of +join_table+.
     # :table_alias :: The alias to use for the table.  If not specified, doesn't
-    #                 alias the table.  You will get an error if the the alias (or table) name is
+    #                 alias the table.  You will get an error if the alias (or table) name is
     #                 used more than once.
     def graph(dataset, join_conditions = nil, options = OPTS, &block)
       # Allow the use of a dataset or symbol as the first argument

data/lib/sequel/dataset/prepared_statements.rb

@@ -3,7 +3,7 @@ module Sequel
     # ---------------------
     # :section: 8 - Methods related to prepared statements or bound variables
     # On some adapters, these use native prepared statements and bound variables, on others
-    # support is emulated.  For details, see the {"Prepared Statements/Bound Variables" guide}[link:files/doc/prepared_statements_rdoc.html].
+    # support is emulated.  For details, see the {"Prepared Statements/Bound Variables" guide}[rdoc-ref:doc/prepared_statements.rdoc].
     # ---------------------
     
     PREPARED_ARG_PLACEHOLDER = LiteralString.new('?').freeze

data/lib/sequel/dataset/query.rb

@@ -36,7 +36,7 @@ module Sequel
     QUERY_METHODS = (<<-METHS).split.map{|x| x.to_sym} + JOIN_METHODS
       add_graph_aliases and distinct except exclude exclude_having exclude_where
       filter for_update from from_self graph grep group group_and_count group_by having intersect invert
-      limit lock_style naked or order order_append order_by order_more order_prepend qualify
+      limit lock_style naked offset or order order_append order_by order_more order_prepend qualify
       reverse reverse_order select select_all select_append select_group select_more server
       set_graph_aliases unfiltered ungraphed ungrouped union
       unlimited unordered where with with_recursive with_sql
@@ -524,6 +524,7 @@ module Sequel
       return from_self.limit(l, o) if @opts[:sql]
 
       if l.is_a?(Range)
+        no_offset = false
         o = l.first
         l = l.last - l.first + (l.exclude_end? ? 0 : 1)
       end
@@ -531,17 +532,10 @@ module Sequel
       if l.is_a?(Integer)
         raise(Error, 'Limits must be greater than or equal to 1') unless l >= 1
       end
-      opts = {:limit => l}
-      if o
-        o = o.to_i if o.is_a?(String) && !o.is_a?(LiteralString)
-        if o.is_a?(Integer)
-          raise(Error, 'Offsets must be greater than or equal to 0') unless o >= 0
-        end
-        opts[:offset] = o
-      elsif !no_offset
-        opts[:offset] = nil
-      end
-      clone(opts)
+
+      ds = clone(:limit=>l)
+      ds = ds.offset(o) unless no_offset
+      ds
     end
     
     # Returns a cloned dataset with the given lock style.  If style is a
@@ -568,6 +562,19 @@ module Sequel
       ds.row_proc = nil
       ds
     end
+
+    # Returns a copy of the dataset with a specified order. Can be safely combined with limit.
+    # If you call limit with an offset, it will override override the offset if you've called
+    # offset first.
+    #
+    #   DB[:items].offset(10) # SELECT * FROM items OFFSET 10
+    def offset(o)
+      o = o.to_i if o.is_a?(String) && !o.is_a?(LiteralString)
+      if o.is_a?(Integer)
+        raise(Error, 'Offsets must be greater than or equal to 0') unless o >= 0
+      end
+      clone(:offset => o)
+    end
     
     # Adds an alternate filter to an existing filter using OR. If no filter 
     # exists an +Error+ is raised.
@@ -842,7 +849,7 @@ module Sequel
     # where also accepts a block, which should return one of the above argument
     # types, and is treated the same way.  This block yields a virtual row object,
     # which is easy to use to create identifiers and functions.  For more details
-    # on the virtual row support, see the {"Virtual Rows" guide}[link:files/doc/virtual_rows_rdoc.html]
+    # on the virtual row support, see the {"Virtual Rows" guide}[rdoc-ref:doc/virtual_rows.rdoc]
     #
     # If both a block and regular argument are provided, they get ANDed together.
     #
@@ -871,7 +878,7 @@ module Sequel
     #   software = dataset.where(:category => 'software').where{price < 100}
     #   # SELECT * FROM items WHERE ((category = 'software') AND (price < 100))
     #
-    # See the the {"Dataset Filtering" guide}[link:files/doc/dataset_filtering_rdoc.html] for more examples and details.
+    # See the {"Dataset Filtering" guide}[rdoc-ref:doc/dataset_filtering.rdoc] for more examples and details.
     def where(*cond, &block)
       _filter(:where, *cond, &block)
     end
@@ -961,10 +968,24 @@ module Sequel
       !(@opts.collect{|k,v| k unless v.nil?}.compact & opts).empty?
     end
 
-    # Whether this dataset is a simple SELECT * FROM table.
+    # Whether this dataset is a simple select from an underlying table, such as:
+    #
+    #   SELECT * FROM table
+    #   SELECT table.* FROM table
     def simple_select_all?
       o = @opts.reject{|k,v| v.nil? || NON_SQL_OPTIONS.include?(k)}
-      o.length == 1 && (f = o[:from]) && f.length == 1 && (f.first.is_a?(Symbol) || f.first.is_a?(SQL::AliasedExpression))
+      if (f = o[:from]) && f.length == 1 && (f.first.is_a?(Symbol) || f.first.is_a?(SQL::AliasedExpression))
+        case o.length
+        when 1
+          true
+        when 2
+          (s = o[:select]) && s.length == 1 && s.first.is_a?(SQL::ColumnAll)
+        else
+          false
+        end
+      else
+        false
+      end
     end
 
     private

data/lib/sequel/extensions/constraint_validations.rb

@@ -401,10 +401,10 @@ module Sequel
       end
 
       ds = from(:sequel_constraint_validations)
-      ds.multi_insert(rows.flatten)
       unless drop_rows.empty?
         ds.where([:table, :constraint_name]=>drop_rows).delete
       end
+      ds.multi_insert(rows.flatten)
     end
 
     # Add the constraint to the generator, including a NOT NULL constraint

data/lib/sequel/extensions/date_arithmetic.rb

@@ -91,9 +91,9 @@ module Sequel
             each_valid_interval_unit(h, MYSQL_DURATION_UNITS) do |value, sql_unit|
               expr = Sequel.function(:DATE_ADD, expr, Sequel.lit(["INTERVAL ", " "], value, sql_unit))
             end
-          when :mssql, :h2, :access
+          when :mssql, :h2, :access, :sqlanywhere
             units = case db_type
-            when :mssql
+            when :mssql, :sqlanywhere
               MSSQL_DURATION_UNITS
             when :h2
               H2_DURATION_UNITS

data/lib/sequel/extensions/migration.rb

@@ -373,7 +373,7 @@ module Sequel
       migrator_class(directory).new(db, directory, opts).is_current?
     end
 
-    # Migrates the supplied database using the migration files in the the specified directory. Options:
+    # Migrates the supplied database using the migration files in the specified directory. Options:
     # :allow_missing_migration_files :: Don't raise an error if there are missing migration files.
     # :column :: The column in the :table argument storing the migration version (default: :version).
     # :current :: The current version of the database.  If not given, it is retrieved from the database