class Sequel::Postgres::JSONBOp

def -(other)
  self.class.new(super)
end

def [](key)
  if is_array?(key)
    super
  else
    case @value
    when Symbol, SQL::Identifier, SQL::QualifiedIdentifier, JSONBSubscriptOp
      # Only use subscripts for identifiers.  In other cases, switching from
      # the -> operator to [] for subscripts causes SQL syntax issues.  You
      # only need the [] for subscripting when doing assignment, and
      # assignment is generally done on identifiers.
      self.class.new(JSONBSubscriptOp.new(self, key))
    else
      super
    end
  end
end

def _path_function(func, path, vars, silent)
  args = []
  if vars
    if vars.is_a?(Hash)
      vars = vars.to_json
    end
    args << vars
    unless silent.nil?
      args << silent
    end
  end
  SQL::Function.new(func, self, path, *args)
end

def bool_op(str, other)
  Sequel::SQL::BooleanExpression.new(:NOOP, Sequel::SQL::PlaceholderLiteralString.new(str, [value, other]))
end

def concat(other)
  json_op(CONCAT, wrap_input_jsonb(other))
end

def contain_all(other)
  bool_op(CONTAIN_ALL, wrap_input_array(other))
end

def contain_any(other)
  bool_op(CONTAIN_ANY, wrap_input_array(other))
end

def contained_by(other)
  bool_op(CONTAINED_BY, wrap_input_jsonb(other))
end

def contains(other)
  bool_op(CONTAINS, wrap_input_jsonb(other))
end

def delete_path(other)
  json_op(DELETE_PATH, wrap_input_array(other))
end

def function_name(name)
  "jsonb_#{name}"
end

def has_key?(key)
  bool_op(HAS_KEY, key)
end

def insert(path, other, insert_after=false)
  self.class.new(function(:insert, wrap_input_array(path), wrap_input_jsonb(other), insert_after))
end

def path_exists(path)
  bool_op(PATH_EXISTS, path)
end

def path_exists!(path, vars=nil, silent=nil)
  Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists, path, vars, silent))
end

def path_exists_tz!(path, vars=nil, silent=nil)
  Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_exists_tz, path, vars, silent))
end

def path_match(path)
  bool_op(PATH_MATCH, path)
end

def path_match!(path, vars=nil, silent=nil)
  Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match, path, vars, silent))
end

def path_match_tz!(path, vars=nil, silent=nil)
  Sequel::SQL::BooleanExpression.new(:NOOP, _path_function(:jsonb_path_match_tz, path, vars, silent))
end

def path_query(path, vars=nil, silent=nil)
  _path_function(:jsonb_path_query, path, vars, silent)
end

def path_query_array(path, vars=nil, silent=nil)
  JSONBOp.new(_path_function(:jsonb_path_query_array, path, vars, silent))
end

def path_query_array_tz(path, vars=nil, silent=nil)
  JSONBOp.new(_path_function(:jsonb_path_query_array_tz, path, vars, silent))
end

def path_query_first(path, vars=nil, silent=nil)
  JSONBOp.new(_path_function(:jsonb_path_query_first, path, vars, silent))
end

def path_query_first_tz(path, vars=nil, silent=nil)
  JSONBOp.new(_path_function(:jsonb_path_query_first_tz, path, vars, silent))
end

def path_query_tz(path, vars=nil, silent=nil)
  _path_function(:jsonb_path_query_tz, path, vars, silent)
end

def pg_jsonb
  self
end

def pretty
  Sequel::SQL::StringExpression.new(:NOOP, function(:pretty))
end

def set(path, other, create_missing=true)
  self.class.new(function(:set, wrap_input_array(path), wrap_input_jsonb(other), create_missing))
end

def set_lax(path, other, create_missing=true, null_value_treatment='use_json_null')
  self.class.new(function(:set_lax, wrap_input_array(path), wrap_input_jsonb(other), create_missing, null_value_treatment))
end

def wrap_input_array(obj)
  if obj.is_a?(Array) && Sequel.respond_to?(:pg_array) 
    Sequel.pg_array(obj)
  else
    obj
  end
end

def wrap_input_jsonb(obj)
  if Sequel.respond_to?(:pg_jsonb) && (obj.is_a?(Array) || obj.is_a?(Hash))
    Sequel.pg_jsonb(obj)
  else
    obj
  end
end