sequel 5.83.0 → 5.84.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 66956ac28806c0389a6c809b0aa70d2746a7aff47fd5b039d238c08f621cdbff
-  data.tar.gz: d2b8d3f88b13432c60e6164fda3577725300e18a0dfa03682871405d074d7ba0
+  metadata.gz: 5677b07054121f55f100f0629d8102cabdd9db454263c5199a8f401bea891992
+  data.tar.gz: ca57e632e3e66c3a4003f988e5240da6a6eed0de9a143ac3985bd0603e0d9073
 SHA512:
-  metadata.gz: 55d45f7c3cb7154f275ddf5ea3649d78a38f147abdb49f1286358d8dbec9f607e3bf43c9ebe1dc31276d28820f455fc82dcce7b4c9808b325288380acf90edf4
-  data.tar.gz: b8301c7880dcb598ca027d225f5be791200ac1f13f4efe5351222d351b218019351a8efa1f485d499a0650cd4213ba0a148c3f10f0a67aa0b3c04f4ee611b074
+  metadata.gz: 2ea8e58679c4ae2455588b584b959b3be691c177823cf336b77fa7b5910e716d9ca88e54024bbef44ec58d3fa8d66070acbf94e8c32a4294126ab2e618f4285e
+  data.tar.gz: acf4e565dd754b16ea0c07a11fe67cd21c9d5833ac1cf70c384a8da2c1b7c9ffd324358dbab9a8196d5a249365cc11870e6c807d07dbc631d359b413977f14ed

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

@@ -349,7 +349,7 @@ module Sequel
         ps
       end
 
-      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options
+      # Support creating STRICT AND/OR WITHOUT ROWID tables via :strict and :without_rowid options, and VIRTUAL tables with :using option.
       def create_table_sql(name, generator, options)
         if options[:strict] && options[:without_rowid]
           "#{super} STRICT, WITHOUT ROWID"
@@ -357,6 +357,8 @@ module Sequel
           "#{super} STRICT"
         elsif options[:without_rowid]
           "#{super} WITHOUT ROWID"
+        elsif options[:using]
+          "CREATE VIRTUAL TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{create_table_table_name_sql(name, options)} USING #{options[:using]}"
         else
           super
         end

data/lib/sequel/database/connecting.rb

@@ -34,7 +34,7 @@ module Sequel
           uri = URI.parse(conn_string)
           scheme = uri.scheme
           c = adapter_class(scheme)
-          opts = c.send(:uri_to_options, uri).merge!(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
+          opts = c.send(:options_from_uri, uri).merge!(opts).merge!(:orig_opts=>opts.dup, :uri=>conn_string, :adapter=>scheme)
         end
       when Hash
         opts = conn_string.merge(opts)

data/lib/sequel/database/misc.rb

@@ -72,18 +72,23 @@ module Sequel
     # Converts a uri to an options hash. These options are then passed
     # to a newly created database object. 
     def self.uri_to_options(uri)
-      uri_options = {
+      {
         :user => uri.user,
         :password => uri.password,
         :port => uri.port,
         :host => uri.hostname,
         :database => (m = /\/(.*)/.match(uri.path)) && (m[1])
       }
+    end
+    private_class_method :uri_to_options
+
+    def self.options_from_uri(uri)
+      uri_options = uri_to_options(uri)
       uri.query.split('&').map{|s| s.split('=')}.each{|k,v| uri_options[k.to_sym] = v if k && !k.empty?} unless uri.query.to_s.strip.empty?
       uri_options.to_a.each{|k,v| uri_options[k] = URI::DEFAULT_PARSER.unescape(v) if v.is_a?(String)}
       uri_options
     end
-    private_class_method :uri_to_options
+    private_class_method :options_from_uri
 
     # The options hash for this database
     attr_reader :opts
@@ -266,7 +271,7 @@ module Sequel
       keys = [:host, :database, :user]
       opts = self.opts
       if !keys.any?{|k| opts[k]} && opts[:uri]
-        opts = self.class.send(:uri_to_options, URI.parse(opts[:uri]))
+        opts = self.class.send(:options_from_uri, URI.parse(opts[:uri]))
       end
 
       keys.each do |key|

data/lib/sequel/database/schema_methods.rb

@@ -191,6 +191,8 @@ module Sequel
     #            The +any+ type is treated like a SQLite column in a non-strict table,
     #            allowing any type of data to be stored. This option is supported on
     #            SQLite 3.37.0+.
+    # :using :: Create a VIRTUAL table with the given USING clause. The value should be
+    #           a string, as it is used directly in the SQL query.
     # :without_rowid :: Create a WITHOUT ROWID table. Every row in SQLite has a special
     #                   'rowid' column, that uniquely identifies that row within the table.
     #                   If this option is used, the 'rowid' column is omitted, which can

data/lib/sequel/extensions/pg_json_ops.rb

@@ -132,6 +132,17 @@
 #   j.is_not_json(type: :array)                # j IS NOT JSON ARRAY
 #   j.is_not_json(unique: true)                # j IS NOT JSON WITH UNIQUE
 #
+# On PostgreSQL 17+, the additional JSON functions are supported (see method documentation
+# for additional options):
+#
+#   j.exists('$.foo')     # json_exists(jsonb_column, '$.foo')
+#   j.value('$.foo')      # json_value(jsonb_column, '$.foo')
+#   j.query('$.foo')      # json_query(jsonb_column, '$.foo')
+#
+#   j.exists('$.foo', passing: {a: 1}) # json_exists(jsonb_column, '$.foo' PASSING 1 AS a)
+#   j.value('$.foo', returning: Time)  # json_value(jsonb_column, '$.foo' RETURNING timestamp)
+#   j.query('$.foo', wrapper: true)    # json_query(jsonb_column, '$.foo' WITH WRAPPER)
+#
 # If you are also using the pg_json extension, you should load it before
 # loading this extension.  Doing so will allow you to use the #op method on
 # JSONHash, JSONHarray, JSONBHash, and JSONBArray, allowing you to perform json/jsonb operations
@@ -224,7 +235,25 @@ module Sequel
         function(:each_text)
       end
 
-      # Returns a json value for the object at the given path.
+      # Return whether the given JSON path yields any items in the receiver.
+      # Options:
+      #
+      # :on_error :: How to handle errors when evaluating the JSON path expression.
+      #              true :: Return true
+      #              false :: Return false (default behavior)
+      #              :null :: Return nil
+      #              :error :: raise a DatabaseError
+      # :passing :: Variables to pass to the JSON path expression.  Keys are variable
+      #             names, values are the values of the variable.
+      # 
+      #   json_op.exists("$.a") # json_exists(json, '$.a')
+      #   json_op.exists("$.a", passing: {a: 1}) # json_exists(json, '$.a' PASSING 1 AS a)
+      #   json_op.exists("$.a", on_error: :error) # json_exists(json, '$.a' ERROR ON ERROR)
+      def exists(path, opts=OPTS)
+        Sequel::SQL::BooleanExpression.new(:NOOP, JSONExistsOp.new(self, path, opts))
+      end
+
+      # Returns a JSON value for the object at the given path.
       #
       #   json_op.extract('a') # json_extract_path(json, 'a')
       #   json_op.extract('a', 'b') # json_extract_path(json, 'a', 'b')
@@ -299,6 +328,35 @@ module Sequel
         SQL::Function.new(function_name(:populate_recordset), arg, self)
       end
 
+      # Return the result of applying the JSON path expression to the receiver, by default
+      # returning results as jsonb.  Options:
+      #
+      # :on_empty :: How to handle case where path expression yields an empty set.
+      #              Uses same values as :on_error option.
+      # :on_error :: How to handle errors when evaluating the JSON path expression:
+      #              :null :: Return nil (default)
+      #              :empty_array :: Return an empty array
+      #              :empty_object :: Return an empty object
+      #              :error :: raise a DatabaseError
+      #              any other value :: used as default value
+      # :passing :: Variables to pass to the JSON path expression.  Keys are variable
+      #             names, values are the values of the variable.
+      # :returning :: The data type to return (jsonb by default)
+      # :wrapper :: How to wrap returned values:
+      #             true, :unconditional :: Always wrap returning values in an array
+      #             :conditional :: Only wrap multiple return values in an array
+      #             :omit_quotes :: Do not wrap scalar strings in quotes
+      # 
+      #   json_op.query("$.a") # json_query(json, '$.a')
+      #   json_op.query("$.a", passing: {a: 1}) # json_query(json, '$.a' PASSING 1 AS a)
+      #   json_op.query("$.a", on_error: :empty_array) # json_query(json, '$.a' EMPTY ARRAY ON ERROR)
+      #   json_op.query("$.a", returning: Time) # json_query(json, '$.a' RETURNING timestamp)
+      #   json_op.query("$.a", on_empty: 2) # json_query(json, '$.a' DEFAULT 2 ON EMPTY)
+      #   json_op.query("$.a", wrapper: true) # json_query(json, '$.a' WITH WRAPPER)
+      def query(path, opts=OPTS)
+        self.class.new(JSONQueryOp.new(self, path, opts))
+      end
+
       # Returns a json value stripped of all internal null values.
       #
       #   json_op.strip_nulls # json_strip_nulls(json)
@@ -329,6 +387,34 @@ module Sequel
         function(:typeof)
       end
 
+      # If called without arguments, operates as SQL::Wrapper#value.  Otherwise, 
+      # return the result of applying the JSON path expression to the receiver, by default
+      # returning results as text.  Options:
+      #
+      # :on_empty :: How to handle case where path expression yields an empty set.
+      #              Uses same values as :on_error option.
+      # :on_error :: How to handle errors when evaluating the JSON path expression.
+      #              :null :: Return nil (default)
+      #              :error :: raise a DatabaseError
+      #              any other value :: used as default value
+      # :passing :: Variables to pass to the JSON path expression.  Keys are variable
+      #             names, values are the values of the variable.
+      # :returning :: The data type to return (text by default)
+      # 
+      #   json_op.value("$.a") # json_value(json, '$.a')
+      #   json_op.value("$.a", passing: {a: 1}) # json_value(json, '$.a' PASSING 1 AS a)
+      #   json_op.value("$.a", on_error: :error) # json_value(json, '$.a' ERROR ON ERROR)
+      #   json_op.value("$.a", returning: Time) # json_value(json, '$.a' RETURNING timestamp)
+      #   json_op.value("$.a", on_empty: 2) # json_value(json, '$.a' DEFAULT 2 ON EMPTY)
+      def value(path=(no_args_given = true), opts=OPTS)
+        if no_args_given
+          # Act as SQL::Wrapper#value
+          super()
+        else
+          Sequel::SQL::StringExpression.new(:NOOP, JSONValueOp.new(self, path, opts))
+        end
+      end
+
       private
 
       # Internals of IS [NOT] JSON support
@@ -705,6 +791,247 @@ module Sequel
       end
     end
 
+    # Object representing json_exists calls
+    class JSONExistsOp < SQL::Expression
+      ON_ERROR_SQL = {
+        true => 'TRUE',
+        false => 'FALSE',
+        :null =>  'UNKNOWN',
+        :error => 'ERROR',
+      }.freeze
+      private_constant :ON_ERROR_SQL
+
+      # Expression (context_item in PostgreSQL terms), usually JSONBaseOp instance
+      attr_reader :expr
+
+      # JSON path expression to apply against the expression
+      attr_reader :path
+
+      # Variables to set in the JSON path expression
+      attr_reader :passing
+
+      # How to handle errors when evaluating the JSON path expression
+      attr_reader :on_error
+
+      # See JSONBaseOp#exists for documentation on the options.
+      def initialize(expr, path, opts=OPTS)
+        @expr = expr
+        @path = path
+        @passing = opts[:passing]
+        @on_error = opts[:on_error]
+        freeze
+      end
+
+      # Append the SQL function call expression to the SQL
+      def to_s_append(ds, sql)
+        to_s_append_function_name(ds, sql)
+        to_s_append_args_passing(ds, sql)
+        to_s_append_on_error(ds, sql)
+        sql << ')'
+      end
+
+      # Support transforming of function call expression
+      def sequel_ast_transform(transformer)
+        opts = {}
+        transform_opts(transformer, opts)
+        self.class.new(transformer.call(@expr), @path, opts)
+      end
+
+      private
+
+      # Set the :passing and :on_error options when doing an
+      # AST transform.
+      def transform_opts(transformer, opts)
+        if @passing
+          passing = opts[:passing] = {}
+          @passing.each do |k, v|
+            passing[k] = transformer.call(v)
+          end
+        end
+
+        opts[:on_error] = @on_error
+      end
+      
+      def to_s_append_function_name(ds, sql)
+        sql << 'json_exists('
+      end
+
+      # Append the expression, path, and optional PASSING fragments
+      def to_s_append_args_passing(ds, sql)
+        ds.literal_append(sql, @expr)
+        sql << ', '
+        ds.literal_append(sql, @path)
+
+        if (passing = @passing) && !passing.empty?
+          sql << ' PASSING '
+          comma = false
+          passing.each do |k, v|
+            if comma
+              sql << ', '
+            else
+              comma = true
+            end
+            ds.literal_append(sql, v)
+            sql << " AS " << k.to_s
+          end
+        end
+      end
+
+      # Append the optional ON ERROR fragments
+      def to_s_append_on_error(ds, sql)
+        unless @on_error.nil?
+          sql << " "
+          to_s_append_on_value(ds, sql, @on_error)
+          sql << " ON ERROR"
+        end
+      end
+
+      # Append the value to use for ON ERROR
+      def to_s_append_on_value(ds, sql, value)
+        sql << ON_ERROR_SQL.fetch(value)
+      end
+    end
+
+    # Object representing json_value calls
+    class JSONValueOp < JSONExistsOp
+      ON_SQL = {
+        :null =>  'NULL',
+        :error => 'ERROR',
+      }.freeze
+      private_constant :ON_SQL
+
+      # The database type to cast returned values to
+      attr_reader :returning
+
+      # How to handle cases where the JSON path expression evaluation yields
+      # an empty set.
+      attr_reader :on_empty
+
+      # See JSONBaseOp#value for documentation of the options.
+      def initialize(expr, path, opts=OPTS)
+        @returning = opts[:returning]
+        @on_empty = opts[:on_empty]
+        super
+      end
+
+      private
+
+      # Also handle transforming the returning and on_empty options.
+      def transform_opts(transformer, opts)
+        super
+        opts[:returning] = @returning
+        on_error = @on_error
+        on_error = transformer.call(on_error) unless on_sql_value(on_error)
+        opts[:on_error] = on_error
+        on_empty = @on_empty
+        on_empty = transformer.call(on_empty) unless on_sql_value(on_empty)
+        opts[:on_empty] = on_empty
+      end
+      
+      def to_s_append_function_name(ds, sql)
+        sql << 'json_value('
+      end
+
+      # Also append the optional RETURNING fragment
+      def to_s_append_args_passing(ds, sql)
+        super
+
+        if @returning
+          sql << ' RETURNING ' << ds.db.cast_type_literal(@returning).to_s
+        end
+      end
+
+      # Also append the optional ON EMPTY fragment
+      def to_s_append_on_error(ds, sql)
+        unless @on_empty.nil?
+          sql << " "
+          to_s_append_on_value(ds, sql, @on_empty)
+          sql << " ON EMPTY"
+        end
+
+        super
+      end
+
+      # Handle DEFAULT values in ON EMPTY/ON ERROR fragments
+      def to_s_append_on_value(ds, sql, value)
+        if v = on_sql_value(value)
+          sql << v
+        else
+          sql << 'DEFAULT '
+          default_literal_append(ds, sql, value)
+        end
+      end
+
+      # Do not auto paramterize default value, as PostgreSQL doesn't allow it.
+      def default_literal_append(ds, sql, v)
+        if sql.respond_to?(:skip_auto_param)
+          sql.skip_auto_param do
+            ds.literal_append(sql, v)
+          end
+        else
+          ds.literal_append(sql, v)
+        end
+      end
+
+      def on_sql_value(value)
+        ON_SQL[value]
+      end
+    end
+
+    # Object representing json_query calls
+    class JSONQueryOp < JSONValueOp
+      ON_SQL = {
+        :null =>  'NULL',
+        :error => 'ERROR',
+        :empty_array => 'EMPTY ARRAY',
+        :empty_object => 'EMPTY OBJECT',
+      }.freeze
+      private_constant :ON_SQL
+
+      WRAPPER = {
+        :conditional => ' WITH CONDITIONAL WRAPPER',
+        :unconditional => ' WITH WRAPPER',
+        :omit_quotes => ' OMIT QUOTES'
+      }
+      WRAPPER[true] = WRAPPER[:unconditional]
+      WRAPPER.freeze
+      private_constant :WRAPPER
+
+      # How to handle wrapping of results
+      attr_reader :wrapper
+
+      # See JSONBaseOp#query for documentation of the options.
+      def initialize(expr, path, opts=OPTS)
+        @wrapper = opts[:wrapper]
+        super
+      end
+
+      private
+      
+      # Also handle transforming the wrapper option
+      def transform_opts(transformer, opts)
+        super
+        opts[:wrapper] = @wrapper
+      end
+      
+      def to_s_append_function_name(ds, sql)
+        sql << 'json_query('
+      end
+
+      # Also append the optional WRAPPER/OMIT QUOTES fragment
+      def to_s_append_args_passing(ds, sql)
+        super
+
+        if @wrapper
+          sql << WRAPPER.fetch(@wrapper)
+        end
+      end
+
+      def on_sql_value(value)
+        ON_SQL[value]
+      end
+    end
+
     module JSONOpMethods
       # Wrap the receiver in an JSONOp so you can easily use the PostgreSQL
       # json functions and operators with it.

data/lib/sequel/sql.rb

@@ -153,13 +153,16 @@ module Sequel
     class ComplexExpression < Expression
       # A hash of the opposite for each operator symbol, used for inverting
       # objects.
-      OPERTATOR_INVERSIONS = {:AND => :OR, :OR => :AND, :< => :>=, :> => :<=,
+      OPERATOR_INVERSIONS = {:AND => :OR, :OR => :AND, :< => :>=, :> => :<=,
         :<= => :>, :>= => :<, :'=' => :'!=' , :'!=' => :'=', :LIKE => :'NOT LIKE',
         :'NOT LIKE' => :LIKE, :~ => :'!~', :'!~' => :~, :IN => :'NOT IN',
         :'NOT IN' => :IN, :IS => :'IS NOT', :'IS NOT' => :IS, :'~*' => :'!~*',
         :'!~*' => :'~*', :NOT => :NOOP, :NOOP => :NOT, :ILIKE => :'NOT ILIKE',
         :'NOT ILIKE'=>:ILIKE}.freeze
 
+      # SEQUEL6: Remove
+      OPERTATOR_INVERSIONS = OPERATOR_INVERSIONS
+
       # Standard mathematical operators used in +NumericMethods+
       MATHEMATICAL_OPERATORS = [:+, :-, :/, :*, :**].freeze
 
@@ -1142,9 +1145,9 @@ module Sequel
         when BooleanExpression
           case op = ce.op
           when :AND, :OR
-            BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
+            BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.map{|a| BooleanExpression.invert(a)})
           when :IN, :"NOT IN"
-            BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+            BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
           else
             if ce.args.length == 2
               case ce.args[1]
@@ -1153,10 +1156,10 @@ module Sequel
                 # can result in incorrect behavior for ANY/SOME/ALL operators.
                 BooleanExpression.new(:NOT, ce)
               else
-                BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+                BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
               end
             else
-              BooleanExpression.new(OPERTATOR_INVERSIONS[op], *ce.args.dup)
+              BooleanExpression.new(OPERATOR_INVERSIONS[op], *ce.args.dup)
             end
           end
         when StringExpression, NumericExpression

data/lib/sequel/version.rb

@@ -6,7 +6,7 @@ module Sequel
 
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 83
+  MINOR = 84
 
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.