sequel 3.23.0 → 3.24.0

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

@@ -1,6 +1,7 @@
 module Sequel
   module Access
     module DatabaseMethods
+      # Access uses type :access as the database_type
       def database_type
         :access
       end
@@ -16,6 +17,7 @@ module Sequel
         from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
       end
 
+      # Access uses type Counter for an autoincrementing keys
       def serial_primary_key_options
         {:primary_key => true, :type=>:Counter}
       end
@@ -34,16 +36,24 @@ module Sequel
     module DatasetMethods
       SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
 
+      # Access doesn't support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
       end
 
       private
 
+      # Access uses TOP for limits
+      def select_limit_sql(sql)
+        sql << " TOP #{@opts[:limit]}" if @opts[:limit]
+      end
+
+      # Access uses [] for quoting identifiers
       def quoted_identifier(v)
         "[#{v}]"
       end
 
+      # Access requires the limit clause come before other clauses
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end

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

@@ -0,0 +1,45 @@
+module Sequel
+  module Informix
+    module DatabaseMethods
+      TEMPORARY = 'TEMP '.freeze
+
+      # Informix uses the :informix database type
+      def database_type
+        :informix
+      end
+
+      private
+
+      # Informix has issues with quoted identifiers, so
+      # turn off database quoting by default.
+      def quote_identifiers_default
+        false
+      end
+
+      # SQL fragment for showing a table is temporary
+      def temporary_table_sql
+        TEMPORARY
+      end
+    end
+    
+    module DatasetMethods
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where having group compounds order')
+
+      private
+
+      # Informix does not support INTERSECT or EXCEPT
+      def supports_intersect_except?
+        false
+      end
+
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
+      end
+
+      def select_limit_sql(sql)
+        sql << " SKIP #{@opts[:offset]}" if @opts[:offset]
+        sql << " FIRST #{@opts[:limit]}" if @opts[:limit]
+      end
+    end
+  end
+end

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

@@ -53,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
@@ -123,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
@@ -145,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)
@@ -231,6 +252,29 @@ module Sequel
         @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
@@ -277,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.
@@ -367,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?
@@ -441,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.
@@ -454,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'
@@ -529,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