#ifndef SQL_TYPE_JSON_INCLUDED
#define SQL_TYPE_JSON_INCLUDED
/*
   Copyright (c) 2019, 2021 MariaDB

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; version 2 of
   the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA
*/

#include "mariadb.h"
#include "sql_type.h"


class Type_handler_json_common
{
public:
  static Virtual_column_info *make_json_valid_expr(THD *thd,
                                            const LEX_CSTRING *field_name);
  static bool make_json_valid_expr_if_needed(THD *thd, Column_definition *c);
  static bool set_format_name(Send_field_extended_metadata *to)
  {
    static const Lex_cstring fmt(STRING_WITH_LEN("json"));
    return to->set_format_name(fmt);
  }
  static const Type_handler *json_type_handler(uint max_octet_length);
  static const Type_handler *json_blob_type_handler_by_length_bytes(uint len);
  static const Type_handler *json_type_handler_sum(const Item_sum *sum);
  static const Type_handler *json_type_handler_from_generic(const Type_handler *th);
  static bool has_json_valid_constraint(const Field *field);
  static const Type_collection *type_collection();
  static bool is_json_type_handler(const Type_handler *handler)
  {
    return handler->type_collection() == type_collection();
  }
};


template <class BASE, const Named_type_handler<BASE> &thbase>
class Type_handler_general_purpose_string_to_json:
                                            public BASE,
                                            public Type_handler_json_common
{
public:
  const Type_handler *type_handler_base() const override
  {
    return &thbase;
  }
  const Type_collection *type_collection() const override
  {
    return Type_handler_json_common::type_collection();
  }
  bool Column_definition_validate_check_constraint(THD *thd,
                                                   Column_definition *c)
                                                   const override
  {
    return make_json_valid_expr_if_needed(thd, c) ||
           BASE::Column_definition_validate_check_constraint(thd, c);
  }
  bool Column_definition_data_type_info_image(Binary_string *to,
                                              const Column_definition &def)
                                              const override
  {
    /*
      Override the inherited method to avoid JSON type handlers writing any
      extended metadata to FRM. JSON type handlers are currently detected
      only by CHECK(JSON_VALID()) constraint. This may change in the future
      to do write extended metadata to FRM, for more reliable detection.
    */
    return false;
  }

  bool Item_append_extended_type_info(Send_field_extended_metadata *to,
                                      const Item *item) const override
  {
    return set_format_name(to); // Send "format=json" in the protocol
  }

  bool Item_hybrid_func_fix_attributes(THD *thd,
                                       const char *name,
                                       Type_handler_hybrid_field_type *hybrid,
                                       Type_all_attributes *attr,
                                       Item **items, uint nitems)
                                       const override
  {
    if (BASE::Item_hybrid_func_fix_attributes(thd, name, hybrid, attr,
                                              items, nitems))
      return true;
    /*
      The above call can change the type handler on "hybrid", e.g.
      choose a proper BLOB type handler according to the calculated max_length.
      Convert general purpose string type handler to its JSON counterpart.
      This makes hybrid functions preserve JSON data types, e.g.:
        COALESCE(json_expr1, json_expr2) -> JSON
    */
    hybrid->set_handler(json_type_handler_from_generic(hybrid->type_handler()));
    return false;
  }
};


class Type_handler_string_json:
  public Type_handler_general_purpose_string_to_json<Type_handler_string,
                                                     type_handler_string>
{ };


class Type_handler_varchar_json:
  public Type_handler_general_purpose_string_to_json<Type_handler_varchar,
                                                     type_handler_varchar>
{ };

class Type_handler_tiny_blob_json:
  public Type_handler_general_purpose_string_to_json<Type_handler_tiny_blob,
                                                     type_handler_tiny_blob>
{ };

class Type_handler_blob_json:
  public Type_handler_general_purpose_string_to_json<Type_handler_blob,
                                                     type_handler_blob>
{ };


class Type_handler_medium_blob_json:
  public Type_handler_general_purpose_string_to_json<Type_handler_medium_blob,
                                                     type_handler_medium_blob>
{ };

class Type_handler_long_blob_json:
  public Type_handler_general_purpose_string_to_json<Type_handler_long_blob,
                                                     type_handler_long_blob>
{ };



extern MYSQL_PLUGIN_IMPORT
  Named_type_handler<Type_handler_string_json> type_handler_string_json;

extern MYSQL_PLUGIN_IMPORT
  Named_type_handler<Type_handler_varchar_json> type_handler_varchar_json;

extern MYSQL_PLUGIN_IMPORT
  Named_type_handler<Type_handler_tiny_blob_json> type_handler_tiny_blob_json;

extern MYSQL_PLUGIN_IMPORT
  Named_type_handler<Type_handler_blob_json> type_handler_blob_json;

extern MYSQL_PLUGIN_IMPORT
  Named_type_handler<Type_handler_medium_blob_json> type_handler_medium_blob_json;

extern MYSQL_PLUGIN_IMPORT
  Named_type_handler<Type_handler_long_blob_json> type_handler_long_blob_json;


#endif // SQL_TYPE_JSON_INCLUDED
