sequel 3.21.0 → 3.24.0

data/lib/sequel/adapters/shared/mssql.rb

@@ -11,10 +11,16 @@ module Sequel
       SQL_ROLLBACK_TO_SAVEPOINT = 'IF @@TRANCOUNT > 0 ROLLBACK TRANSACTION autopoint_%d'.freeze
       SQL_SAVEPOINT = 'SAVE TRANSACTION autopoint_%d'.freeze
       
+      # Whether to use N'' to quote strings, which allows unicode characters inside the
+      # strings.  True by default for compatibility, can be set to false for a possible
+      # performance increase.  This sets the default for all datasets created from this
+      # Database object.
+      attr_accessor :mssql_unicode_strings
+
       # The types to check for 0 scale to transform :decimal types
       # to :integer.
       DECIMAL_TYPE_RE = /number|numeric|decimal/io
-      
+
       # Microsoft SQL Server uses the :mssql type.
       def database_type
         :mssql
@@ -47,11 +53,13 @@ module Sequel
       # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
       # information on tables.
       def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.from(:information_schema__tables___t).
-          select(:table_name).
-          filter(:table_type=>'BASE TABLE', :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
-          map{|x| m.call(x[:table_name])}
+        information_schema_tables('BASE TABLE', opts)
+      end
+
+      # Microsoft SQL Server supports using the INFORMATION_SCHEMA to get
+      # information on views.
+      def views(opts={})
+        information_schema_tables('VIEW', opts)
       end
 
       private
@@ -117,6 +125,15 @@ module Sequel
         "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
       end
       
+      # Backbone of the tables and views support.
+      def information_schema_tables(type, opts)
+        m = output_identifier_meth
+        metadata_dataset.from(:information_schema__tables___t).
+          select(:table_name).
+          filter(:table_type=>type, :table_schema=>(opts[:schema]||default_schema||'dbo').to_s).
+          map{|x| m.call(x[:table_name])}
+      end
+
       # Always quote identifiers in the metadata_dataset, so schema parsing works.
       def metadata_dataset
         ds = super
@@ -139,6 +156,16 @@ module Sequel
         SQL_ROLLBACK
       end
       
+      # The closest MSSQL equivalent of a boolean datatype is the bit type.
+      def schema_column_type(db_type)
+        case db_type
+        when /\A(bit)\z/io
+          :boolean
+        else
+          super
+        end
+      end
+
       # MSSQL uses the INFORMATION_SCHEMA to hold column information.  This method does
       # not support the parsing of primary key information.
       def schema_parse_table(table_name, opts)
@@ -163,6 +190,11 @@ module Sequel
           [m.call(row.delete(:column)), row]
         end
       end
+
+      # Set the mssql_unicode_strings settings from the given options.
+      def set_mssql_unicode_strings
+        @mssql_unicode_strings = typecast_value_boolean(@opts.fetch(:mssql_unicode_strings, true))
+      end
       
       # MSSQL has both datetime and timestamp classes, most people are going
       # to want datetime
@@ -211,6 +243,38 @@ module Sequel
       WILDCARD = LiteralString.new('*').freeze
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}
 
+      # Allow overriding of the mssql_unicode_strings option at the dataset level.
+      attr_accessor :mssql_unicode_strings
+
+      # Copy the mssql_unicode_strings option from the +db+ object.
+      def initialize(db, opts={})
+        super
+        @mssql_unicode_strings = db.mssql_unicode_strings
+      end
+
+      # Ugly hack.  While MSSQL supports TRUE and FALSE values, you can't
+      # actually specify them directly in SQL.  Unfortunately, you also cannot
+      # use an integer value when a boolean is required.  Also unforunately, you
+      # cannot use an expression that yields a boolean type in cases where in an
+      # integer type is needed, such as inserting into a bit field (the closest thing
+      # MSSQL has to a boolean).
+      #
+      # In filters, SQL::BooleanConstants are used more, while in other places
+      # the ruby true/false values are used more, so use expressions that return booleans
+      # for SQL::BooleanConstants, and 1/0 for other places.
+      # The correct fix for this would require separate literalization paths for
+      # filters compared to other values, but that's more work than I want to do right now.
+      def boolean_constant_sql(constant)
+        case constant
+        when true
+          '(1 = 1)'
+        when false
+          '(1 = 0)'
+        else
+          super
+        end
+      end
+
       # MSSQL uses + for string concatenation, and LIKE is case insensitive by default.
       def complex_expression_sql(op, args)
         case op
@@ -257,8 +321,8 @@ module Sequel
 
       # Use the OUTPUT clause to get the value of all columns for the newly inserted record.
       def insert_select(*values)
-        return unless supports_output_clause?
-        naked.clone(default_server_opts(:sql=>output(nil, [:inserted.*]).insert_sql(*values))).single_record unless opts[:disable_insert_output]
+        return unless supports_insert_select?
+        naked.clone(default_server_opts(:sql=>output(nil, [SQL::ColumnAll.new(:inserted)]).insert_sql(*values))).single_record
       end
 
       # Specify a table for a SELECT ... INTO query.
@@ -347,6 +411,11 @@ module Sequel
         db.server_version(@opts[:server])
       end
 
+      # MSSQL supports insert_select via the OUTPUT clause.
+      def supports_insert_select?
+        supports_output_clause? && !opts[:disable_insert_output]
+      end
+
       # MSSQL 2005+ supports INTERSECT and EXCEPT
       def supports_intersect_except?
         is_2005_or_later?
@@ -421,6 +490,22 @@ module Sequel
       alias insert_with_sql delete_with_sql
       alias update_with_sql delete_with_sql
       
+      # Special case when true or false is provided directly to filter.
+      def filter_expr(expr)
+        if block_given?
+          super
+        else
+          case expr
+          when true
+            Sequel::TRUE
+          when false
+            Sequel::FALSE
+          else
+            super
+          end
+        end
+      end
+      
       # MSSQL raises an error if you try to provide more than 3 decimal places
       # for a fractional timestamp.  This probably doesn't work for smalldatetime
       # fields.
@@ -434,6 +519,16 @@ module Sequel
         INSERT_CLAUSE_METHODS
       end
 
+      # Use OUTPUT INSERTED.* to return all columns of the inserted row,
+      # for use with the prepared statement code.
+      def insert_output_sql(sql)
+        if @opts.has_key?(:returning)
+          sql << " OUTPUT INSERTED.*"
+        else
+          output_sql(sql)
+        end
+      end
+
       # MSSQL uses a literal hexidecimal number for blob strings
       def literal_blob(v)
         blob = '0x'
@@ -441,9 +536,10 @@ module Sequel
         blob
       end
       
-      # Use unicode string syntax for all strings. Don't double backslashes.
+      # Optionally use unicode string syntax for all strings. Don't double
+      # backslashes.
       def literal_string(v)
-        "N'#{v.gsub(/'/, "''")}'"
+        "#{'N' if mssql_unicode_strings}'#{v.gsub(/'/, "''")}'"
       end
       
       # Use 0 for false on MSSQL
@@ -508,7 +604,6 @@ module Sequel
       end
       alias delete_output_sql output_sql
       alias update_output_sql output_sql
-      alias insert_output_sql output_sql
 
       # MSSQL supports the OUTPUT clause for UPDATE statements.
       # It also allows prepending a WITH clause.

data/lib/sequel/adapters/shared/mysql.rb

@@ -83,13 +83,9 @@ module Sequel
         @server_version ||= (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
       end
       
-      # Return an array of symbols specifying table names in the current database.
-      #
-      # Options:
-      # * :server - Set the server to use
-      def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.with_sql('SHOW TABLES').server(opts[:server]).map{|r| m.call(r.values.first)}
+      # MySQL supports CREATE TABLE IF NOT EXISTS syntax.
+      def supports_create_table_if_not_exists?
+        true
       end
       
       # MySQL supports prepared transactions (two-phase commit) using XA
@@ -107,6 +103,14 @@ module Sequel
         true
       end
 
+      # Return an array of symbols specifying table names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use
+      def tables(opts={})
+        full_tables('BASE TABLE', opts)
+      end
+      
       # Changes the database in use by issuing a USE statement.  I would be
       # very careful if I used this.
       def use(db_name)
@@ -116,6 +120,14 @@ module Sequel
         self
       end
       
+      # Return an array of symbols specifying view names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use
+      def views(opts={})
+        full_tables('VIEW', opts)
+      end
+      
       private
       
       # Use MySQL specific syntax for rename column, set column type, and
@@ -205,6 +217,12 @@ module Sequel
         "#{super}#{" ENGINE=#{engine}" if engine}#{" DEFAULT CHARSET=#{charset}" if charset}#{" DEFAULT COLLATE=#{collate}" if collate}"
       end
 
+      # Backbone of the tables and views support using SHOW FULL TABLES.
+      def full_tables(type, opts)
+        m = output_identifier_meth
+        metadata_dataset.with_sql('SHOW FULL TABLES').server(opts[:server]).map{|r| m.call(r.values.first) if r.delete(:Table_type) == type}.compact
+      end
+
       # MySQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
       def identifier_input_method_default
         nil

data/lib/sequel/adapters/shared/postgres.rb

@@ -387,11 +387,17 @@ module Sequel
       # Options:
       # * :schema - The schema to search (default_schema by default)
       # * :server - The server to use
-      def tables(opts={})
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>'r').select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
-        ds = filter_schema(ds, opts)
-        m = output_identifier_meth
-        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+      def tables(opts={}, &block)
+        pg_class_relname('r', opts, &block)
+      end
+
+      # Array of symbols specifying view names in the current database.
+      #
+      # Options:
+      # * :schema - The schema to search (default_schema by default)
+      # * :server - The server to use
+      def views(opts={})
+        pg_class_relname('v', opts)
       end
 
       private
@@ -540,6 +546,14 @@ module Sequel
         conn.execute(sql)
       end
       
+      # Backbone of the tables and views support.
+      def pg_class_relname(type, opts)
+        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).exclude(SQL::StringExpression.like(:relname, SYSTEM_TABLE_REGEXP)).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace) 
+        ds = filter_schema(ds, opts)
+        m = output_identifier_meth
+        block_given? ? yield(ds) : ds.map{|r| m.call(r[:relname])}
+      end
+
       # Use a dollar sign instead of question mark for the argument
       # placeholder.
       def prepared_arg_placeholder
@@ -632,6 +646,7 @@ module Sequel
       EXPLAIN = 'EXPLAIN '.freeze
       EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
       FOR_SHARE = ' FOR SHARE'.freeze
+      INSERT_CLAUSE_METHODS = Dataset.clause_methods(:insert, %w'into columns values returning_select')
       LOCK = 'LOCK TABLE %s IN %s MODE'.freeze
       NULL = LiteralString.new('NULL').freeze
       PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
@@ -726,7 +741,7 @@ module Sequel
 
       # Insert a record returning the record inserted
       def insert_select(*values)
-        return if opts[:disable_insert_returning] || server_version < 80200
+        return unless supports_insert_select?
         naked.clone(default_server_opts(:sql=>insert_returning_sql(nil, *values))).single_record
       end
 
@@ -757,6 +772,11 @@ module Sequel
         true
       end
       
+      # PostgreSQL support insert_select using the RETURNING clause.
+      def supports_insert_select?
+        server_version >= 80200 && !opts[:disable_insert_returning]
+      end
+
       # PostgreSQL supports modifying joined datasets
       def supports_modifying_joins?
         true
@@ -794,11 +814,24 @@ module Sequel
         join_from_sql(:USING, sql)
       end
 
+      # PostgreSQL allows a RETURNING clause.
+      def insert_clause_methods
+        INSERT_CLAUSE_METHODS
+      end
+
       # Use the RETURNING clause to return the primary key of the inserted record, if it exists
       def insert_returning_pk_sql(*values)
         pk = db.primary_key(opts[:from].first) if opts[:from] && !opts[:from].empty?
         insert_returning_sql(pk ? Sequel::SQL::Identifier.new(pk) : NULL, *values)
       end
+
+      # Add a RETURNING clause if it is set and the database supports it and
+      # this dataset hasn't disabled it.
+      def insert_returning_select_sql(sql)
+        if supports_insert_select? && opts.has_key?(:returning)
+          sql << " RETURNING #{column_list(Array(opts[:returning]))}"
+        end
+      end
       
       # For multiple table support, PostgreSQL requires at least
       # two from tables, with joins allowed.

data/lib/sequel/adapters/shared/sqlite.rb

@@ -7,8 +7,9 @@ module Sequel
       AUTO_VACUUM = [:none, :full, :incremental].freeze
       PRIMARY_KEY_INDEX_RE = /\Asqlite_autoindex_/.freeze
       SYNCHRONOUS = [:off, :normal, :full].freeze
-      TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'"
+      TABLES_FILTER = "type = 'table' AND NOT name = 'sqlite_sequence'".freeze
       TEMP_STORE = [:default, :file, :memory].freeze
+      VIEWS_FILTER = "type = 'view'".freeze
       
       # Run all alter_table commands in a transaction.  This is technically only
       # needed for drop column.
@@ -96,6 +97,11 @@ module Sequel
         end
       end
       
+      # SQLite supports CREATE TABLE IF NOT EXISTS syntax since 3.3.0.
+      def supports_create_table_if_not_exists?
+        sqlite_version >= 30300
+      end
+      
       # SQLite 3.6.8+ supports savepoints. 
       def supports_savepoints?
         sqlite_version >= 30608
@@ -118,8 +124,7 @@ module Sequel
       # Options:
       # * :server - Set the server to use.
       def tables(opts={})
-        m = output_identifier_meth
-        metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(TABLES_FILTER).map{|r| m.call(r[:name])}
+        tables_and_views(TABLES_FILTER, opts)
       end
       
       # A symbol signifying the value of the temp_store PRAGMA.
@@ -134,6 +139,14 @@ module Sequel
         pragma_set(:temp_store, value)
       end
       
+      # Array of symbols specifying the view names in the current database.
+      #
+      # Options:
+      # * :server - Set the server to use.
+      def views(opts={})
+        tables_and_views(VIEWS_FILTER, opts)
+      end
+
       private
 
       # SQLite supports limited table modification.  You can add a column
@@ -306,6 +319,12 @@ module Sequel
         end
       end
       
+      # Backbone of the tables and views support.
+      def tables_and_views(filter, opts)
+        m = output_identifier_meth
+        metadata_dataset.from(:sqlite_master).server(opts[:server]).filter(filter).map{|r| m.call(r[:name])}
+      end
+      
       # SQLite uses the integer data type even for bignums.  This is because they
       # are both stored internally as text, and converted when returned from
       # the database.  Using an integer type instead of bigint makes it more likely
@@ -320,7 +339,24 @@ module Sequel
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'distinct columns from join where group having compounds order limit')
       COMMA_SEPARATOR = ', '.freeze
       CONSTANT_MAP = {:CURRENT_DATE=>"date(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIMESTAMP=>"datetime(CURRENT_TIMESTAMP, 'localtime')".freeze, :CURRENT_TIME=>"time(CURRENT_TIMESTAMP, 'localtime')".freeze}
-    
+
+      # Ugly hack.  Really, SQLite uses 0 for false and 1 for true
+      # but then you can't differentiate between integers and booleans.
+      # In filters, SQL::BooleanConstants are used more, while in other places
+      # the ruby true/false values are used more, so use 1/0 for SQL::BooleanConstants.
+      # The correct fix for this would require separate literalization paths for
+      # filters compared to other values, but that's more work than I want to do right now.
+      def boolean_constant_sql(constant)
+        case constant
+        when true
+          '1'
+        when false
+          '0'
+        else
+          super
+        end
+      end
+
       # SQLite does not support pattern matching via regular expressions.
       # SQLite is case insensitive (depending on pragma), so use LIKE for
       # ILIKE.
@@ -395,6 +431,22 @@ module Sequel
         "#{expression} AS #{literal(aliaz.to_s)}"
       end
       
+      # Special case when true or false is provided directly to filter.
+      def filter_expr(expr)
+        if block_given?
+          super
+        else
+          case expr
+          when true
+            1
+          when false
+            0
+          else
+            super
+          end
+        end
+      end
+      
       # SQL fragment specifying a list of identifiers
       def identifier_list(columns)
         columns.map{|i| quote_identifier(i)}.join(COMMA_SEPARATOR)
@@ -406,7 +458,7 @@ module Sequel
         v.each_byte{|x| blob << sprintf('%02x', x)}
         "X'#{blob}'"
       end
-      
+
       # SQLite does not support the SQL WITH clause
       def select_clause_methods
         SELECT_CLAUSE_METHODS

data/lib/sequel/adapters/sqlite.rb

@@ -173,7 +173,7 @@ module Sequel
           end
         end
         unless cps
-          cps = conn.prepare(sql)
+          cps = log_yield("Preparing #{name}: #{sql}"){conn.prepare(sql)}
           conn.prepared_statements[name] = [cps, sql]
         end
         if block
@@ -217,7 +217,7 @@ module Sequel
         # but with the keys converted to strings.
         def map_to_prepared_args(hash)
           args = {}
-          hash.each{|k,v| args[k.to_s] = v}
+          hash.each{|k,v| args[k.to_s.gsub('.', '__')] = v}
           args
         end
         
@@ -226,7 +226,12 @@ module Sequel
         # SQLite uses a : before the name of the argument for named
         # arguments.
         def prepared_arg(k)
-          LiteralString.new("#{prepared_arg_placeholder}#{k}")
+          LiteralString.new("#{prepared_arg_placeholder}#{k.to_s.gsub('.', '__')}")
+        end
+
+        # Always assume a prepared argument.
+        def prepared_arg?(k)
+          true
         end
       end
       

data/lib/sequel/adapters/swift/mysql.rb

@@ -25,6 +25,15 @@ module Sequel
         def schema_column_type(db_type)
           db_type == 'tinyint(1)' ? :boolean : super
         end
+      
+        # By default, MySQL 'where id is null' selects the last inserted id.
+        # Turn that off unless explicitly enabled.
+        def setup_connection(conn)
+          super
+          sql = "SET SQL_AUTO_IS_NULL=0"
+          log_yield(sql){conn.execute(sql)} unless opts[:auto_is_null]
+          conn
+        end
       end
       
       # Dataset class for MySQL datasets accessed via Swift.

data/lib/sequel/adapters/tinytds.rb

@@ -13,6 +13,7 @@ module Sequel
         opts = server_opts(server)
         opts[:dataserver] = opts[:host]
         opts[:username] = opts[:user]
+        set_mssql_unicode_strings
         TinyTds::Client.new(opts)
       end
       
@@ -38,7 +39,7 @@ module Sequel
             end
             yield(r) if block_given?
           rescue TinyTds::Error => e
-            raise_error(e)
+            raise_error(e, :disconnect=>(c.closed? || (c.respond_to?(:dead?) && c.dead?)))
           ensure
            r.cancel if r && c.sqlsent?
           end
@@ -107,7 +108,7 @@ module Sequel
                 yield r
               end
             else
-              result.each(each_opts, &block)
+              result.each(each_opts, &Proc.new)
             end
           end
         end
@@ -118,7 +119,7 @@ module Sequel
       
       # Properly escape the given string +v+.
       def literal_string(v)
-        db.synchronize{|c| "N'#{c.escape(v)}'"}
+        s = db.synchronize{|c| "#{'N' if mssql_unicode_strings}'#{c.escape(v)}'"}
       end
     end
   end