ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.0.30

Path:root/home/godaofbq/redlightsquared.com/wp-content/plugins/

Name	Size	Perm	Actions
📁 adminify	-	0755	🗑️ 🏷️
📁 adminify-activity-logs	-	0755	🗑️ 🏷️
📁 adminify-pro	-	0755	🗑️ 🏷️
📁 akismet	-	0755	🗑️ 🏷️
📁 all-in-one-wp-migration	-	0755	🗑️ 🏷️
📁 all-in-one-wp-migration-unlimited-extension	-	0755	🗑️ 🏷️
📁 authorizenet-payment-gateway-for-woocommerce	-	0755	🗑️ 🏷️
📁 backuply	-	0755	🗑️ 🏷️
📁 backuply-pro	-	0755	🗑️ 🏷️
📁 cf7-conditional-fields	-	0755	🗑️ 🏷️
📁 classic-editor	-	0755	🗑️ 🏷️
📁 code-snippets	-	0755	🗑️ 🏷️
📁 contact-form-7	-	0755	🗑️ 🏷️
📁 cookieadmin	-	0755	🗑️ 🏷️
📁 cookieadmin-pro	-	0755	🗑️ 🏷️
📁 crisp	-	0755	🗑️ 🏷️
📁 duplicate-page	-	0755	🗑️ 🏷️
📁 duplicator	-	0755	🗑️ 🏷️
📁 export-media-with-selected-content	-	0755	🗑️ 🏷️
📁 google-listings-and-ads	-	0755	🗑️ 🏷️
📁 google-site-kit	-	0755	🗑️ 🏷️
📁 gosmtp	-	0755	🗑️ 🏷️
📁 gosmtp-pro	-	0755	🗑️ 🏷️
📁 header-footer	-	0755	🗑️ 🏷️
📁 litespeed-cache	-	0755	🗑️ 🏷️
📁 loginizer	-	0755	🗑️ 🏷️
📁 loginizer-security	-	0755	🗑️ 🏷️
📁 loginpress	-	0755	🗑️ 🏷️
📁 masterslider	-	0755	🗑️ 🏷️
📁 oxygen	-	0755	🗑️ 🏷️
📁 oxygen-gutenberg	-	0755	🗑️ 🏷️
📁 oxygen-woocommerce	-	0755	🗑️ 🏷️
📁 pagelayer	-	0755	🗑️ 🏷️
📁 pagelayer-pro	-	0755	🗑️ 🏷️
📁 pdf-embedder	-	0755	🗑️ 🏷️
📁 rolemaster-suite	-	0755	🗑️ 🏷️
📁 siteseo	-	0755	🗑️ 🏷️
📁 siteseo-pro	-	0755	🗑️ 🏷️
📁 speedycache	-	0755	🗑️ 🏷️
📁 speedycache-pro	-	0755	🗑️ 🏷️
📁 wc-external-product-new-tab	-	0755	🗑️ 🏷️
📁 woocommerce	-	0755	🗑️ 🏷️
📁 wordpress-seo	-	0755	🗑️ 🏷️
📁 wp-headers-and-footers	-	0755	🗑️ 🏷️
📄 error_log	1184.99 KB	0644	🗑️ 🏷️ ⬇️ ✏️
📄 login.php	6.83 KB	0444	🗑️ 🏷️ ⬇️ ✏️

Edit: sql_type_json.h

#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

📁 ＳＫＹＳＨＥＬＬ ＭＡＮＡＧＥＲ PHP v8.0.30

Edit: sql_type_json.h

📁 ＳＫＹＳＨＥＬＬＭＡＮＡＧＥＲ PHP v8.0.30