sequel 3.21.0 → 3.41.0

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

@@ -1,27 +1,53 @@
 module Sequel
   module Access
     module DatabaseMethods
+      # Access uses type :access as the database_type
       def database_type
         :access
       end
 
-      def dataset(opts = nil)
-        ds = super
-        ds.extend(DatasetMethods)
-        ds
-      end
-
       # Doesn't work, due to security restrictions on MSysObjects
-      def tables
-        from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
+      #def tables
+      #  from(:MSysObjects).filter(:Type=>1, :Flags=>0).select_map(:Name).map{|x| x.to_sym}
+      #end
+      
+      # Access doesn't support renaming tables from an SQL query,
+      # so create a copy of the table and then drop the from table.
+      def rename_table(from_table, to_table)
+        create_table(to_table, :as=>from(from_table))
+        drop_table(from_table)
       end
 
+      # Access uses type Counter for an autoincrementing keys
       def serial_primary_key_options
         {:primary_key => true, :type=>:Counter}
       end
 
       private
 
+      def alter_table_op_sql(table, op)
+        case op[:op]
+        when :set_column_type
+          "ALTER COLUMN #{quote_identifier(op[:name])} #{type_literal(op)}"
+        else
+          super
+        end
+      end
+
+      # Access doesn't support CREATE TABLE AS, it only supports SELECT INTO.
+      # Emulating CREATE TABLE AS using SELECT INTO is only possible if a dataset
+      # is given as the argument, it can't work with a string, so raise an
+      # Error if a string is given.
+      def create_table_as(name, ds, options)
+        raise(Error, "must provide dataset instance as value of create_table :as option on Access") unless ds.is_a?(Sequel::Dataset)
+        run(ds.into(name).sql)
+      end
+    
+      # The SQL to drop an index for the table.
+      def drop_index_sql(table, op)
+        "DROP INDEX #{quote_identifier(op[:name] || default_index_name(table, op[:columns]))} ON #{quote_schema_table(table)}"
+      end
+      
       def identifier_input_method_default
         nil
       end
@@ -29,21 +55,220 @@ module Sequel
       def identifier_output_method_default
         nil
       end
+      
+      # Access doesn't have a 64-bit integer type, so use integer and hope
+      # the user isn't using more than 32 bits.
+      def type_literal_generic_bignum(column)
+        :integer
+      end
+
+      # Access doesn't have a true boolean class, so it uses bit
+      def type_literal_generic_trueclass(column)
+        :bit
+      end
+      
+      # Access uses image type for blobs
+      def type_literal_generic_file(column)
+        :image
+      end
     end
   
     module DatasetMethods
-      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'limit distinct columns from join where group order having compounds')
+      SELECT_CLAUSE_METHODS = Dataset.clause_methods(:select, %w'select distinct limit columns into from join where group order having compounds')
+      DATE_FORMAT = '#%Y-%m-%d#'.freeze
+      TIMESTAMP_FORMAT = '#%Y-%m-%d %H:%M:%S#'.freeze
+      TOP = " TOP ".freeze
+      BRACKET_CLOSE = Dataset::BRACKET_CLOSE
+      BRACKET_OPEN = Dataset::BRACKET_OPEN
+      PAREN_CLOSE = Dataset::PAREN_CLOSE
+      PAREN_OPEN = Dataset::PAREN_OPEN
+      INTO = Dataset::INTO
+      FROM = Dataset::FROM
+      NOT_EQUAL = ' <> '.freeze
+      OPS = {:'%'=>' Mod '.freeze, :'||'=>' & '.freeze}
+      BOOL_FALSE = '0'.freeze
+      BOOL_TRUE = '-1'.freeze
+      DATE_FUNCTION = 'Date()'.freeze
+      NOW_FUNCTION = 'Now()'.freeze
+      TIME_FUNCTION = 'Time()'.freeze
+      CAST_TYPES = {String=>:CStr, Integer=>:CLng, Date=>:CDate, Time=>:CDate, DateTime=>:CDate, Numeric=>:CDec, BigDecimal=>:CDec, File=>:CStr, Float=>:CDbl, TrueClass=>:CBool, FalseClass=>:CBool}
+
+      EXTRACT_MAP = {:year=>"'yyyy'", :month=>"'m'", :day=>"'d'", :hour=>"'h'", :minute=>"'n'", :second=>"'s'"}
+      COMMA = Dataset::COMMA
+      DATEPART_OPEN = "datepart(".freeze
+
+      # Access doesn't support CASE, but it can be emulated with nested
+      # IIF function calls.
+      def case_expression_sql_append(sql, ce)
+        literal_append(sql, ce.with_merged_expression.conditions.reverse.inject(ce.default){|exp,(cond,val)| Sequel::SQL::Function.new(:IIF, cond, val, exp)})
+      end
+
+      # Access doesn't support CAST, it uses separate functions for
+      # type conversion
+      def cast_sql_append(sql, expr, type)
+        sql << CAST_TYPES.fetch(type, type).to_s
+        sql << PAREN_OPEN
+        literal_append(sql, expr)
+        sql << PAREN_CLOSE
+      end
+
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :ILIKE
+          super(sql, :LIKE, args)
+        when :'NOT ILIKE'
+          super(sql, :'NOT LIKE', args)
+        when :'!='
+          sql << PAREN_OPEN
+          literal_append(sql, args.at(0))
+          sql << NOT_EQUAL
+          literal_append(sql, args.at(1))
+          sql << PAREN_CLOSE
+        when :'%', :'||'
+          sql << PAREN_OPEN
+          c = false
+          op_str = OPS[op]
+          args.each do |a|
+            sql << op_str if c
+            literal_append(sql, a)
+            c ||= true
+          end
+          sql << PAREN_CLOSE
+        when :extract
+          part = args.at(0)
+          raise(Sequel::Error, "unsupported extract argument: #{part.inspect}") unless format = EXTRACT_MAP[part]
+          sql << DATEPART_OPEN << format.to_s << COMMA
+          literal_append(sql, args.at(1))
+          sql << PAREN_CLOSE
+        else
+          super
+        end
+      end
+
+      # Use Date() and Now() for CURRENT_DATE and CURRENT_TIMESTAMP
+      def constant_sql_append(sql, constant)
+        case constant
+        when :CURRENT_DATE
+          sql << DATE_FUNCTION
+        when :CURRENT_TIMESTAMP
+          sql << NOW_FUNCTION
+        when :CURRENT_TIME
+          sql << TIME_FUNCTION
+        else
+          super
+        end
+      end
+
+      # Emulate cross join by using multiple tables in the FROM clause.
+      def cross_join(table)
+        clone(:from=>@opts[:from] + [table])
+      end
+
+      def emulated_function_sql_append(sql, f)
+        case f.f
+        when :char_length
+          literal_append(sql, SQL::Function.new(:len, f.args.first))
+        else
+          super
+        end
+      end
+      
+      # Specify a table for a SELECT ... INTO query.
+      def into(table)
+        clone(:into => table)
+      end
 
+      # Access doesn't support INTERSECT or EXCEPT
       def supports_intersect_except?
         false
       end
 
+      # Access does not support IS TRUE
+      def supports_is_true?
+        false
+      end
+      
+      # Access doesn't support JOIN USING
+      def supports_join_using?
+        false
+      end
+
+      # Access does not support multiple columns for the IN/NOT IN operators
+      def supports_multiple_column_in?
+        false
+      end
+
+      # Access doesn't support truncate, so do a delete instead.
+      def truncate
+        delete
+        nil
+      end
+      
       private
 
-      def quoted_identifier(v)
-        "[#{v}]"
+      # Access uses # to quote dates
+      def literal_date(d)
+        d.strftime(DATE_FORMAT)
+      end
+
+      # Access uses # to quote datetimes
+      def literal_datetime(t)
+        t.strftime(TIMESTAMP_FORMAT)
+      end
+      alias literal_time literal_datetime
+
+      # Use 0 for false on MSSQL
+      def literal_false
+        BOOL_FALSE
+      end
+
+      # Use 0 for false on MSSQL
+      def literal_true
+        BOOL_TRUE
+      end
+
+      # Access requires parentheses when joining more than one table
+      def select_from_sql(sql)
+        if f = @opts[:from]
+          sql << FROM
+          if (j = @opts[:join]) && !j.empty?
+            sql << (PAREN_OPEN * j.length)
+          end
+          source_list_append(sql, f)
+        end
+      end
+
+      def select_into_sql(sql)
+        if i = @opts[:into]
+          sql << INTO
+          identifier_append(sql, i)
+        end
+      end
+
+      # Access requires parentheses when joining more than one table
+      def select_join_sql(sql)
+        if js = @opts[:join]
+          js.each do |j|
+            literal_append(sql, j)
+            sql << PAREN_CLOSE
+          end
+        end
+      end
+
+      # Access uses TOP for limits
+      def select_limit_sql(sql)
+        if l = @opts[:limit]
+          sql << TOP
+          literal_append(sql, l)
+        end
+      end
+
+      # Access uses [] for quoting identifiers
+      def quoted_identifier_append(sql, v)
+        sql << BRACKET_OPEN << v.to_s << BRACKET_CLOSE
       end
 
+      # Access requires the limit clause come before other clauses
       def select_clause_methods
         SELECT_CLAUSE_METHODS
       end

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

@@ -0,0 +1,216 @@
+Sequel.require 'adapters/utils/split_alter_table'
+
+module Sequel
+  module Cubrid
+    module DatabaseMethods
+      include Sequel::Database::SplitAlterTable
+
+      AUTOINCREMENT = 'AUTO_INCREMENT'.freeze
+      COLUMN_DEFINITION_ORDER = [:auto_increment, :default, :null, :unique, :primary_key, :references]
+
+      def database_type
+        :cubrid
+      end
+
+      def indexes(table, opts={})
+        m = output_identifier_meth
+        m2 = input_identifier_meth
+        indexes = {}
+        metadata_dataset.
+          from(:db_index___i).
+          join(:db_index_key___k, :index_name=>:index_name, :class_name=>:class_name).
+          where(:i__class_name=>m2.call(table), :is_primary_key=>'NO').
+          order(:k__key_order).
+          select(:i__index_name, :k__key_attr_name___column, :is_unique).
+          each do |row|
+            index = indexes[m.call(row[:index_name])] ||= {:columns=>[], :unique=>row[:is_unique]=='YES'}
+            index[:columns] << m.call(row[:column])
+          end
+        indexes
+      end
+
+      def supports_savepoints?
+        false
+      end
+
+      def schema_parse_table(table_name, opts)
+        m = output_identifier_meth(opts[:dataset])
+        m2 = input_identifier_meth(opts[:dataset])
+
+        pks = metadata_dataset.
+          from(:db_index___i).
+          join(:db_index_key___k, :index_name=>:index_name, :class_name=>:class_name).
+          where(:i__class_name=>m2.call(table_name), :is_primary_key=>'YES').
+          order(:k__key_order).
+          select_map(:k__key_attr_name).
+          map{|c| m.call(c)}
+
+        metadata_dataset.
+          from(:db_attribute).
+          where(:class_name=>m2.call(table_name)).
+          order(:def_order).
+          select(:attr_name, :data_type___db_type, :default_value___default, :is_nullable___allow_null).
+          map do |row|
+            name = m.call(row.delete(:attr_name))
+            row[:allow_null] = row[:allow_null] == 'YES'
+            row[:primary_key] = pks.include?(name)
+            row[:type] = schema_column_type(row[:db_type])
+            [name, row]
+          end
+      end
+
+      def tables(opts={})
+        _tables('CLASS')
+      end
+
+      def views(opts={})
+        _tables('VCLASS')
+      end
+
+      private
+
+      def _tables(type)
+        m = output_identifier_meth
+        metadata_dataset.
+          from(:db_class).
+          where(:is_system_class=>'NO', :class_type=>type).
+          select_map(:class_name).
+          map{|c| m.call(c)}
+      end
+
+      def alter_table_op_sql(table, op)
+        case op[:op]
+        when :rename_column
+          "RENAME COLUMN #{quote_identifier(op[:name])} AS #{quote_identifier(op[:new_name])}"
+        when :set_column_type, :set_column_null, :set_column_default
+          o = op[:op]
+          opts = schema(table).find{|x| x.first == op[:name]}
+          opts = opts ? opts.last.dup : {}
+          opts[:name] = o == :rename_column ? op[:new_name] : op[:name]
+          opts[:type] = o == :set_column_type ? op[:type] : opts[:db_type]
+          opts[:null] = o == :set_column_null ? op[:null] : opts[:allow_null]
+          opts[:default] = o == :set_column_default ? op[:default] : opts[:ruby_default]
+          opts.delete(:default) if opts[:default] == nil
+          "CHANGE COLUMN #{quote_identifier(op[:name])} #{column_definition_sql(op.merge(opts))}"
+        else
+          super
+        end
+      end
+
+      def alter_table_sql(table, op)
+        case op[:op]
+        when :drop_index
+          "ALTER TABLE #{quote_schema_table(table)} #{drop_index_sql(table, op)}"
+        else
+          super
+        end
+      end
+
+      def auto_increment_sql
+        AUTOINCREMENT
+      end
+
+      # CUBRID requires auto increment before primary key
+      def column_definition_order
+        COLUMN_DEFINITION_ORDER
+      end
+
+      # CUBRID requires FOREIGN KEY keywords before a column reference
+      def column_references_sql(column)
+        sql = super
+        sql = " FOREIGN KEY#{sql}" unless column[:columns]
+        sql
+      end
+
+      def connection_execute_method
+        :query
+      end
+
+      # CUBRID is case insensitive, so don't modify identifiers
+      def identifier_input_method_default
+        nil
+      end
+
+      # CUBRID is case insensitive, so don't modify identifiers
+      def identifier_output_method_default
+        nil
+      end
+
+      # CUBRID doesn't support booleans, it recommends using smallint.
+      def type_literal_generic_trueclass(column)
+        :smallint
+      end
+
+      # CUBRID uses clob for text types.
+      def uses_clob_for_text?
+        true
+      end
+    end
+    
+    module DatasetMethods
+      SELECT_CLAUSE_METHODS = Sequel::Dataset.clause_methods(:select, %w'select distinct columns from join where group having compounds order limit')
+      LIMIT = Sequel::Dataset::LIMIT
+      COMMA = Sequel::Dataset::COMMA
+      BOOL_FALSE = '0'.freeze
+      BOOL_TRUE = '1'.freeze
+
+      def complex_expression_sql_append(sql, op, args)
+        case op
+        when :ILIKE
+          super(sql, :LIKE, [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
+        when :"NOT ILIKE"
+          super(sql, :"NOT LIKE", [SQL::Function.new(:upper, args.at(0)), SQL::Function.new(:upper, args.at(1))])
+        else
+          super
+        end
+      end
+
+      def supports_join_using?
+        false
+      end
+
+      def supports_multiple_column_in?
+        false
+      end
+
+      def supports_timestamp_usecs?
+        false
+      end
+
+      # CUBRID supposedly supports TRUNCATE, but it appears not to work in my testing.
+      # Fallback to using DELETE.
+      def truncate
+        delete
+        nil
+      end
+
+      private
+
+      def literal_false
+        BOOL_FALSE
+      end
+
+      def literal_true
+        BOOL_TRUE
+      end
+     
+      # CUBRID doesn't support CTEs or FOR UPDATE.
+      def select_clause_methods
+        SELECT_CLAUSE_METHODS
+      end
+
+      # CUBRID requires a limit to use an offset,
+      # and requires a FROM table if a limit is used.
+      def select_limit_sql(sql)
+        if @opts[:from] && (l = @opts[:limit])
+          sql << LIMIT
+          if o = @opts[:offset]
+            literal_append(sql, o)
+            sql << COMMA
+          end
+          literal_append(sql, l)
+        end
+      end
+    end
+  end
+end