�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fsql%2F'>sql</a>/</p><hr><h3>✏️ Editing: create_options.cc</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Copyright (C) 2010, 2020, 2021, MariaDB Corporation.

   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 Street, Fifth Floor, Boston, MA 02110-1335 USA */

/**
  @file

  Engine defined options of tables/fields/keys in CREATE/ALTER TABLE.
*/

#include &quot;mariadb.h&quot;
#include &quot;create_options.h&quot;
#include &quot;partition_info.h&quot;
#include &lt;my_getopt.h&gt;
#include &quot;set_var.h&quot;

#define FRM_QUOTED_VALUE 0x8000U

static const char *bools=&quot;NO,OFF,0,YES,ON,1&quot;;

/**
  Links this item to the given list end

  @param start           The list beginning or NULL
  @param end             The list last element or does not matter
*/

void engine_option_value::link(engine_option_value **start,
                               engine_option_value **end)
{
  DBUG_ENTER(&quot;engine_option_value::link&quot;);
  DBUG_PRINT(&quot;enter&quot;, (&quot;name: &#039;%s&#039; (%u)  value: &#039;%s&#039; (%u)&quot;,
                       name.str, (uint) name.length,
                       value.str, (uint) value.length));
  engine_option_value *opt;
  /* check duplicates to avoid writing them to frm*/
  for(opt= *start;
      opt &amp;&amp; ((opt-&gt;parsed &amp;&amp; !opt-&gt;value.str) || !name.streq(opt-&gt;name));
      opt= opt-&gt;next) /* no-op */;
  if (opt)
  {
    opt-&gt;value= Value(); /* remove previous value */
    opt-&gt;parsed= TRUE;   /* and don&#039;t issue warnings for it anymore */
  }
  /*
    Add this option to the end of the list

    @note: We add even if it is opt-&gt;value.str == NULL because it can be
    ALTER TABLE to remove the option.
  */
  if (*start)
  {
    (*end)-&gt;next= this;
    *end= this;
  }
  else
  {
    /*
      note that is *start == 0, the value of *end does not matter,
      it can be uninitialized.
    */
    *start= *end= this;
  }
  DBUG_VOID_RETURN;
}

static bool report_wrong_value(THD *thd, const char *name, const char *val,
                               bool suppress_warning)
{
  if (suppress_warning)
    return 0;

  if (!(thd-&gt;variables.sql_mode &amp; MODE_IGNORE_BAD_TABLE_OPTIONS) &amp;&amp;
      !thd-&gt;slave_thread)
  {
    my_error(ER_BAD_OPTION_VALUE, MYF(0), val, name);
    return 1;
  }

  push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN, ER_BAD_OPTION_VALUE,
                      ER_THD(thd, ER_BAD_OPTION_VALUE), val, name);
  return 0;
}

static bool report_unknown_option(THD *thd, engine_option_value *val,
                                  bool suppress_warning)
{
  DBUG_ENTER(&quot;report_unknown_option&quot;);

  if (val-&gt;parsed || suppress_warning || thd-&gt;slave_thread)
  {
    DBUG_PRINT(&quot;info&quot;, (&quot;parsed =&gt; exiting&quot;));
    DBUG_RETURN(FALSE);
  }

  if (!(thd-&gt;variables.sql_mode &amp; MODE_IGNORE_BAD_TABLE_OPTIONS))
  {
    my_error(ER_UNKNOWN_OPTION, MYF(0), val-&gt;name.str);
    DBUG_RETURN(TRUE);
  }

  push_warning_printf(thd, Sql_condition::WARN_LEVEL_WARN,
                      ER_UNKNOWN_OPTION, ER_THD(thd, ER_UNKNOWN_OPTION),
                      val-&gt;name.str);
  DBUG_RETURN(FALSE);
}

#define value_ptr(STRUCT,OPT)    ((char*)(STRUCT) + (OPT)-&gt;offset)

static bool set_one_value(ha_create_table_option *opt, THD *thd,
                          const engine_option_value::Value *value, void *base,
                          bool suppress_warning, MEM_ROOT *root)
{
  DBUG_ENTER(&quot;set_one_value&quot;);
  DBUG_PRINT(&quot;enter&quot;, (&quot;opt: %p type: %u name &#039;%s&#039; value: &#039;%s&#039;&quot;,
                       opt, opt-&gt;type, opt-&gt;name,
                       (value-&gt;str ? value-&gt;str : &quot;&lt;DEFAULT&gt;&quot;)));
  switch (opt-&gt;type)
  {
  case HA_OPTION_TYPE_SYSVAR:
    // HA_OPTION_TYPE_SYSVAR&#039;s are replaced in resolve_sysvars()
    break; // to DBUG_ASSERT(0)
  case HA_OPTION_TYPE_ULL:
    {
      ulonglong *val= (ulonglong*)value_ptr(base, opt);
      if (!value-&gt;str)
      {
        *val= opt-&gt;def_value;
        DBUG_RETURN(0);
      }

      my_option optp= { opt-&gt;name, 1, 0, (uchar **)val, 0, 0, GET_ULL,
          REQUIRED_ARG, (longlong)opt-&gt;def_value, (longlong)opt-&gt;min_value,
          opt-&gt;max_value, 0, (long) opt-&gt;block_size, 0 };

      ulonglong orig_val= strtoull(value-&gt;str, NULL, 10);
      my_bool unused;
      *val= orig_val;
      *val= getopt_ull_limit_value(*val, &amp;optp, &amp;unused);
      if (*val == orig_val)
        DBUG_RETURN(0);

      DBUG_RETURN(report_wrong_value(thd, opt-&gt;name, value-&gt;str,
                                     suppress_warning));
    }
  case HA_OPTION_TYPE_STRING:
    {
      char **val= (char **)value_ptr(base, opt);
      if (!value-&gt;str)
      {
        *val= 0;
        DBUG_RETURN(0);
      }

      if (!(*val= strmake_root(root, value-&gt;str, value-&gt;length)))
        DBUG_RETURN(1);
      DBUG_RETURN(0);
    }
  case HA_OPTION_TYPE_ENUM:
    {
      uint *val= (uint *)value_ptr(base, opt);

      *val= (uint) opt-&gt;def_value;
      if (!value-&gt;str)
        DBUG_RETURN(0);

      uint num= value-&gt;find_in_list(opt-&gt;values);
      if (num != UINT_MAX)
      {
        *val= num;
        DBUG_RETURN(0);
      }

      DBUG_RETURN(report_wrong_value(thd, opt-&gt;name, value-&gt;str,
                                     suppress_warning));
    }
  case HA_OPTION_TYPE_BOOL:
    {
      bool *val= (bool *)value_ptr(base, opt);
      *val= opt-&gt;def_value;

      if (!value-&gt;str)
        DBUG_RETURN(0);

      uint num= value-&gt;find_in_list(bools);
      if (num != UINT_MAX)
      {
        *val= num &gt; 2;
        DBUG_RETURN(0);
      }

      DBUG_RETURN(report_wrong_value(thd, opt-&gt;name, value-&gt;str,
                                     suppress_warning));
    }
  }
  DBUG_ASSERT(0);
  my_error(ER_UNKNOWN_ERROR, MYF(0));
  DBUG_RETURN(1);
}

static const size_t ha_option_type_sizeof[]=
{ sizeof(ulonglong), sizeof(char *), sizeof(uint), sizeof(bool)};

/**
  Appends values of sysvar-based options if needed

  @param thd              thread handler
  @param option_list      list of options given by user
  @param rules            list of option description by engine
  @param root             MEM_ROOT where allocate memory

  @retval TRUE  Error
  @retval FALSE OK
*/

bool extend_option_list(THD* thd, st_plugin_int *plugin, bool create,
                       engine_option_value **option_list,
                       ha_create_table_option *rules)
{
  DBUG_ENTER(&quot;extend_option_list&quot;);
  MEM_ROOT *root= thd-&gt;mem_root;
  bool extended= false;

  for (ha_create_table_option *opt= rules; rules &amp;&amp; opt-&gt;name; opt++)
  {
    if (opt-&gt;var)
    {
      engine_option_value *found= NULL, *last;
      for (engine_option_value *val= *option_list; val; val= val-&gt;next)
      {
        last= val;
        if (val-&gt;name.streq(Lex_cstring(opt-&gt;name, opt-&gt;name_length)))
          found= val; // find the last matching
      }
      if (found ? !found-&gt;value.str : create)
      {
        /* add the current value of the corresponding sysvar to the list */
        sys_var *sysvar= find_plugin_sysvar(plugin, opt-&gt;var);
        DBUG_ASSERT(sysvar);

        if (!sysvar-&gt;session_is_default(thd))
        {
          StringBuffer&lt;256&gt; sbuf(system_charset_info);
          String *str= sysvar-&gt;val_str(&amp;sbuf, thd, OPT_SESSION, &amp;null_clex_str);
          DBUG_ASSERT(str);
          engine_option_value::Name name(opt-&gt;name, opt-&gt;name_length);
          engine_option_value::Value value;
          value.str= strmake_root(root, str-&gt;ptr(), str-&gt;length());
          value.length= str-&gt;length();
          if (found)
            found-&gt;value= value;
          else
          {
            engine_option_value *val= new (root) engine_option_value(name,
                                        value, opt-&gt;type != HA_OPTION_TYPE_ULL);
            if (!extended)
            {
              if (*option_list)
                thd-&gt;register_item_tree_change((Item**)&amp;(last-&gt;next));
              extended= true;
            }
            val-&gt;link(option_list, &amp;last);
          }
        }
      }
    }
  }
  DBUG_RETURN(FALSE);
}


/**
  Creates option structure and parses list of options in it

  @param thd              thread handler
  @param option_struct    where to store pointer on the option struct
  @param option_list      list of options given by user
  @param rules            list of option description by engine
  @param suppress_warning second parse so we do not need warnings
  @param root             MEM_ROOT where allocate memory

  @retval TRUE  Error
  @retval FALSE OK
*/

bool parse_option_list(THD* thd, void *option_struct_arg,
                       engine_option_value **option_list,
                       ha_create_table_option *rules,
                       bool suppress_warning, MEM_ROOT *root)
{
  ha_create_table_option *opt;
  size_t option_struct_size= 0;
  engine_option_value *val, *last;
  void **option_struct= (void**)option_struct_arg;
  engine_option_value::Value default_value;
  DBUG_ENTER(&quot;parse_option_list&quot;);
  DBUG_PRINT(&quot;enter&quot;,
             (&quot;struct: %p list: %p rules: %p suppress_warning: %u root: %p&quot;,
              *option_struct, *option_list, rules,
              (uint) suppress_warning, root));

  if (rules)
  {
    for (opt= rules; opt-&gt;name; opt++)
      set_if_bigger(option_struct_size, opt-&gt;offset +
                    ha_option_type_sizeof[opt-&gt;type]);

    *option_struct= alloc_root(root, option_struct_size);
  }

  for (opt= rules; rules &amp;&amp; opt-&gt;name; opt++)
  {
    bool seen=false;
    for (val= *option_list; val; val= val-&gt;next)
    {
      last= val;
      if (!val-&gt;name.streq(Lex_cstring(opt-&gt;name, opt-&gt;name_length)))
        continue;

      /* skip duplicates (see engine_option_value constructor above) */
      if (val-&gt;parsed &amp;&amp; !val-&gt;value.str)
        continue;

      if (set_one_value(opt, thd, &amp;val-&gt;value,
                        *option_struct, suppress_warning || val-&gt;parsed, root))
        DBUG_RETURN(TRUE);
      val-&gt;parsed= true;
      seen=true;
      break;
    }
    if (!seen || (opt-&gt;var &amp;&amp; !last-&gt;value.str))
      set_one_value(opt, thd, &amp;default_value, *option_struct,
                    suppress_warning, root);
  }

  for (val= *option_list; val; val= val-&gt;next)
  {
    if (report_unknown_option(thd, val, suppress_warning))
      DBUG_RETURN(TRUE);
    val-&gt;parsed= true;
  }

  DBUG_RETURN(FALSE);
}


/**
  Resolves all HA_OPTION_TYPE_SYSVAR elements.

  This is done when an engine is loaded.
*/
bool resolve_sysvar_table_options(ha_create_table_option *rules)
{
  for (ha_create_table_option *opt= rules; rules &amp;&amp; opt-&gt;name; opt++)
  {
    if (opt-&gt;type == HA_OPTION_TYPE_SYSVAR)
    {
      struct my_option optp;
      plugin_opt_set_limits(&amp;optp, opt-&gt;var);
      switch(optp.var_type) {
      case GET_ULL:
      case GET_ULONG:
      case GET_UINT:
        opt-&gt;type= HA_OPTION_TYPE_ULL;
        opt-&gt;def_value= (ulonglong)optp.def_value;
        opt-&gt;min_value= (ulonglong)optp.min_value;
        opt-&gt;max_value= (ulonglong)optp.max_value;
        opt-&gt;block_size= (ulonglong)optp.block_size;
        break;
      case GET_STR:
      case GET_STR_ALLOC:
        opt-&gt;type= HA_OPTION_TYPE_STRING;
        break;
      case GET_BOOL:
        opt-&gt;type= HA_OPTION_TYPE_BOOL;
        opt-&gt;def_value= optp.def_value;
        break;
      case GET_ENUM:
      {
        opt-&gt;type= HA_OPTION_TYPE_ENUM;
        opt-&gt;def_value= optp.def_value;

        char buf[256];
        String str(buf, sizeof(buf), system_charset_info);
        str.length(0);
        for (const char **s= optp.typelib-&gt;type_names; *s; s++)
        {
          if (str.append(*s, strlen(*s)) || str.append(&#039;,&#039;))
            return 1;
        }
        DBUG_ASSERT(str.length());
        opt-&gt;values= my_strndup(PSI_INSTRUMENT_ME, str.ptr(), str.length()-1, MYF(MY_WME));
        if (!opt-&gt;values)
          return 1;
        break;
      }
      default:
        DBUG_ASSERT(0);
      }
    }
  }
  return 0;
}

/*
  Restore HA_OPTION_TYPE_SYSVAR options back as they were
  before resolve_sysvars().

  This is done when the engine is unloaded, so that we could
  call resolve_sysvars() if the engine is installed again.
*/
void free_sysvar_table_options(ha_create_table_option *rules)
{
  for (ha_create_table_option *opt= rules; rules &amp;&amp; opt-&gt;name; opt++)
  {
    if (opt-&gt;var)
    {
      my_free(const_cast&lt;char*&gt;(opt-&gt;values));
      opt-&gt;type= HA_OPTION_TYPE_SYSVAR;
      opt-&gt;def_value= 0;
      opt-&gt;min_value= 0;
      opt-&gt;max_value= 0;
      opt-&gt;block_size= 0;
      opt-&gt;values= 0;
    }
  }
}

/**
  Parses all table/fields/keys options

  @param thd             thread handler
  @param file            handler of the table
  @parem share           descriptor of the table

  @retval TRUE  Error
  @retval FALSE OK
*/

bool parse_engine_table_options(THD *thd, handlerton *ht, TABLE_SHARE *share)
{
  MEM_ROOT *root= &amp;share-&gt;mem_root;
  DBUG_ENTER(&quot;parse_engine_table_options&quot;);

  if (parse_option_list(thd, &amp;share-&gt;option_struct, &amp; share-&gt;option_list,
                        ht-&gt;table_options, TRUE, root))
    DBUG_RETURN(TRUE);

  for (Field **field= share-&gt;field; *field; field++)
  {
    if (parse_option_list(thd, &amp;(*field)-&gt;option_struct,
                          &amp; (*field)-&gt;option_list,
                          ht-&gt;field_options, TRUE, root))
      DBUG_RETURN(TRUE);
  }

  for (uint index= 0; index &lt; share-&gt;keys; index ++)
  {
    if (parse_option_list(thd, &amp;share-&gt;key_info[index].option_struct,
                          &amp; share-&gt;key_info[index].option_list,
                          ht-&gt;index_options, TRUE, root))
      DBUG_RETURN(TRUE);
  }

  DBUG_RETURN(FALSE);
}

#ifdef WITH_PARTITION_STORAGE_ENGINE
/**
  Parses engine-defined partition options

  @param [in] thd   thread handler
  @parem [in] table table with part_info

  @retval TRUE  Error
  @retval FALSE OK

  In the case of ALTER TABLE statements, table-&gt;part_info is set up
  by mysql_unpack_partition(). So, one should not call the present
  function before the call of mysql_unpack_partition().
*/
bool parse_engine_part_options(THD *thd, TABLE *table)
{
  MEM_ROOT *root= &amp;table-&gt;mem_root;
  TABLE_SHARE *share= table-&gt;s;
  partition_info *part_info= table-&gt;part_info;
  engine_option_value *tmp_option_list;
  handlerton *ht;
  DBUG_ENTER(&quot;parse_engine_part_options&quot;);

  if (!part_info)
    DBUG_RETURN(FALSE);

  List_iterator&lt;partition_element&gt; it(part_info-&gt;partitions);
  while (partition_element *part_elem= it++)
  {
    if (merge_engine_options(share-&gt;option_list, part_elem-&gt;option_list,
                             &amp;tmp_option_list, root))
      DBUG_RETURN(TRUE);

    if (!part_info-&gt;is_sub_partitioned())
    {
      ht= part_elem-&gt;engine_type;
      if (parse_option_list(thd, &amp;part_elem-&gt;option_struct,
                            &amp;tmp_option_list, ht-&gt;table_options, TRUE, root))
        DBUG_RETURN(TRUE);
    }
    else
    {
      List_iterator&lt;partition_element&gt; sub_it(part_elem-&gt;subpartitions);
      while (partition_element *sub_part_elem= sub_it++)
      {
        ht= sub_part_elem-&gt;engine_type;
        if (parse_option_list(thd, &amp;sub_part_elem-&gt;option_struct,
                              &amp;tmp_option_list, ht-&gt;table_options, TRUE, root))
          DBUG_RETURN(TRUE);
      }
    }
  }
  DBUG_RETURN(FALSE);
}
#endif

bool engine_options_differ(void *old_struct, void *new_struct,
                           ha_create_table_option *rules)
{
  ha_create_table_option *opt;
  for (opt= rules; rules &amp;&amp; opt-&gt;name; opt++)
  {
    char **old_val= (char**)value_ptr(old_struct, opt);
    char **new_val= (char**)value_ptr(new_struct, opt);
    int neq;
    if (opt-&gt;type == HA_OPTION_TYPE_STRING)
      neq= (*old_val &amp;&amp; *new_val) ? strcmp(*old_val, *new_val) :  *old_val != *new_val;
    else
      neq= memcmp(old_val, new_val, ha_option_type_sizeof[opt-&gt;type]);
    if (neq)
      return true;
  }
  return false;
}


/**
  Returns representation length of key and value in the frm file
*/

uint engine_option_value::frm_length()
{
  /*
    1 byte  - name length
    2 bytes - value length

    if value.str is NULL, this option is not written to frm (=DEFAULT)
  */
  return value.str ? (uint)(1 + name.length + 2 + value.length) : 0;
}


/**
  Returns length of representation of option list in the frm file
*/

static uint option_list_frm_length(engine_option_value *opt)
{
  uint res= 0;

  for (; opt; opt= opt-&gt;next)
    res+= opt-&gt;frm_length();

  return res;
}


/**
  Calculates length of options image in the .frm

  @param table_option_list list of table options
  @param create_fields     field descriptors list
  @param keys              number of keys
  @param key_info          array of key descriptors

  @returns length of image in frm
*/

uint engine_table_options_frm_length(engine_option_value *table_option_list,
                                     List&lt;Create_field&gt; &amp;create_fields,
                                     uint keys, KEY *key_info)
{
  List_iterator&lt;Create_field&gt; it(create_fields);
  Create_field *field;
  uint res, index;
  DBUG_ENTER(&quot;engine_table_options_frm_length&quot;);

  res= option_list_frm_length(table_option_list);

  while ((field= it++))
    res+= option_list_frm_length(field-&gt;option_list);

  for (index= 0; index &lt; keys; index++, key_info++)
    res+= option_list_frm_length(key_info-&gt;option_list);

  /*
    if there&#039;s at least one option somewhere (res &gt; 0)
    we write option lists for all fields and keys, zero-terminated.
    If there&#039;re no options we write nothing at all (backward compatibility)
  */
  DBUG_RETURN(res ? res + 1 + create_fields.elements + keys : 0);
}


/**
  Writes image of the key and value to the frm image buffer

  @param buff            pointer to the buffer free space beginning

  @returns pointer to byte after last recorded in the buffer
*/

uchar *engine_option_value::frm_image(uchar *buff)
{
  if (value.str)
  {
    DBUG_ASSERT(name.length &lt;= 0xff);
    *buff++= (uchar)name.length;
    memcpy(buff, name.str, name.length);
    buff+= name.length;
    int2store(buff, value.length | (quoted_value ? FRM_QUOTED_VALUE : 0));
    buff+= 2;
    memcpy(buff, (const uchar *) value.str, value.length);
    buff+= value.length;
  }
  return buff;
}

/**
  Writes image of the key and value to the frm image buffer

  @param buff            pointer to the buffer to store the options in
  @param opt             list of options;

  @returns pointer to the end of the stored data in the buffer
*/
static uchar *option_list_frm_image(uchar *buff, engine_option_value *opt)
{
  for (; opt; opt= opt-&gt;next)
    buff= opt-&gt;frm_image(buff);

  *buff++= 0;
  return buff;
}


/**
  Writes options image in the .frm buffer

  @param buff              pointer to the buffer
  @param table_option_list list of table options
  @param create_fields     field descriptors list
  @param keys              number of keys
  @param key_info          array of key descriptors

  @returns pointer to byte after last recorded in the buffer
*/

uchar *engine_table_options_frm_image(uchar *buff,
                                      engine_option_value *table_option_list,
                                      List&lt;Create_field&gt; &amp;create_fields,
                                      uint keys, KEY *key_info)
{
  List_iterator&lt;Create_field&gt; it(create_fields);
  Create_field *field;
  KEY *key_info_end= key_info + keys;
  DBUG_ENTER(&quot;engine_table_options_frm_image&quot;);

  buff= option_list_frm_image(buff, table_option_list);

  while ((field= it++))
    buff= option_list_frm_image(buff, field-&gt;option_list);

  while (key_info &lt; key_info_end)
    buff= option_list_frm_image(buff, (key_info++)-&gt;option_list);

  DBUG_RETURN(buff);
}

/**
  Reads name and value from buffer, then link it in the list

  @param buff            the buffer to read from
  @param start           The list beginning or NULL
  @param end             The list last element or does not matter
  @param root            MEM_ROOT for allocating

  @returns pointer to byte after last recorded in the buffer
*/
uchar *engine_option_value::frm_read(const uchar *buff, const uchar *buff_end,
                                     engine_option_value **start,
                                     engine_option_value **end, MEM_ROOT *root)
{
  LEX_CSTRING name, value;
  uint len;
#define need_buff(N)  if (buff + (N) &gt;= buff_end) return NULL

  need_buff(3);
  name.length= buff[0];
  buff++;
  need_buff(name.length + 2);
  if (!(name.str= strmake_root(root, (const char*)buff, name.length)))
    return NULL;
  buff+= name.length;
  len= uint2korr(buff);
  value.length= len &amp; ~FRM_QUOTED_VALUE;
  buff+= 2;
  need_buff(value.length);
  if (!(value.str= strmake_root(root, (const char*)buff, value.length)))
    return NULL;
  buff+= value.length;

  engine_option_value *ptr=
      new (root) engine_option_value(engine_option_value::Name(name),
                                     engine_option_value::Value(value),
                                     len &amp; FRM_QUOTED_VALUE);
  if (!ptr)
    return NULL;
  ptr-&gt;link(start, end);

  return (uchar *)buff;
}


/**
  Reads options from this buffer

  @param buff            the buffer to read from
  @param length          buffer length
  @param share           table descriptor
  @param root            MEM_ROOT for allocating

  @retval TRUE  Error
  @retval FALSE OK
*/

bool engine_table_options_frm_read(const uchar *buff, size_t length,
                                   TABLE_SHARE *share)
{
  const uchar *buff_end= buff + length;
  engine_option_value *UNINIT_VAR(end);
  MEM_ROOT *root= &amp;share-&gt;mem_root;
  uint count;
  DBUG_ENTER(&quot;engine_table_options_frm_read&quot;);

  while (buff &lt; buff_end &amp;&amp; *buff)
  {
    if (!(buff= engine_option_value::frm_read(buff, buff_end,
                                              &amp;share-&gt;option_list, &amp;end, root)))
      DBUG_RETURN(TRUE);
  }
  buff++;

  for (count=0; count &lt; share-&gt;fields; count++)
  {
    while (buff &lt; buff_end &amp;&amp; *buff)
    {
      if (!(buff= engine_option_value::frm_read(buff, buff_end,
                                                &amp;share-&gt;field[count]-&gt;option_list,
                                                &amp;end, root)))
        DBUG_RETURN(TRUE);
    }
    buff++;
  }

  for (count=0; count &lt; share-&gt;total_keys; count++)
  {
    while (buff &lt; buff_end &amp;&amp; *buff)
    {
      if (!(buff= engine_option_value::frm_read(buff, buff_end,
                                                &amp;share-&gt;key_info[count].option_list,
                                                &amp;end, root)))
        DBUG_RETURN(TRUE);
    }
    buff++;
  }

  if (buff &lt; buff_end)
    sql_print_warning(&quot;Table &#039;%s&#039; was created in a later MariaDB version - &quot;
                      &quot;unknown table attributes were ignored&quot;,
                      share-&gt;table_name.str);

  DBUG_RETURN(buff &gt; buff_end);
}

/**
  Merges two lists of engine_option_value&#039;s with duplicate removal.

  @param [in] source  option list
  @param [in] changes option list whose options overwrite source&#039;s
  @param [out] out    new option list created by merging given two
  @param [in] root    MEM_ROOT for allocating memory

  @retval TRUE  Error
  @retval FALSE OK
*/
bool merge_engine_options(engine_option_value *source,
                          engine_option_value *changes,
                          engine_option_value **out, MEM_ROOT *root)
{
  engine_option_value *UNINIT_VAR(end), *opt, *opt_copy;
  *out= 0;
  DBUG_ENTER(&quot;merge_engine_options&quot;);

  /* Create copy of source list */
  for (opt= source; opt; opt= opt-&gt;next)
  {
    opt_copy= new (root) engine_option_value(opt);
    if (!opt_copy)
      DBUG_RETURN(TRUE);
    opt_copy-&gt;link(out, &amp;end);
  }

  for (opt= changes; opt; opt= opt-&gt;next)
  {
    opt_copy= new (root) engine_option_value(opt);
    if (!opt_copy)
      DBUG_RETURN(TRUE);
    opt_copy-&gt;link(out, &amp;end);
  }
  DBUG_RETURN(FALSE);
}

bool is_engine_option_known(engine_option_value *opt,
                            ha_create_table_option *rules)
{
  if (!rules)
    return false;

  for (; rules-&gt;name; rules++)
  {
      if (opt-&gt;name.streq(Lex_cstring(rules-&gt;name, rules-&gt;name_length)))
        return true;
  }
  return false;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fsql'>🔙 Back</a></p>