�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%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fmaria%2F'>maria</a>/</p><hr><h3>✏️ Editing: ma_unique.c</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/* Copyright (C) 2006 MySQL AB &amp; MySQL Finland AB &amp; TCX DataKonsult AB
   Copyright (c) 2020, 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 */

/* Functions to check if a row is unique */

#include &quot;maria_def.h&quot;
#include &lt;m_ctype.h&gt;

/**
  Check if there exist a row with the same hash

  @notes
  This function is not versioning safe. For the moment this is not a problem
  as it&#039;s only used for internal temporary tables in MySQL for which there
  isn&#039;t any versioning information.
*/

my_bool _ma_check_unique(MARIA_HA *info, MARIA_UNIQUEDEF *def,
                         const uchar *record,
                         ha_checksum unique_hash, my_off_t disk_pos)
{
  my_off_t lastpos=info-&gt;cur_row.lastpos;
  MARIA_KEYDEF *keyinfo= &amp;info-&gt;s-&gt;keyinfo[def-&gt;key];
  uchar *key_buff= info-&gt;lastkey_buff2;
  MARIA_KEY key;
  int error= 0;
  DBUG_ENTER(&quot;_ma_check_unique&quot;);
  DBUG_PRINT(&quot;enter&quot;,(&quot;unique_hash: %lu&quot;, (ulong) unique_hash));

  /* We need to store the hash value as a key in the record, breaking const */
  maria_unique_store(record+keyinfo-&gt;seg-&gt;start, unique_hash);
  /* Can&#039;t be spatial so it&#039;s ok to call _ma_make_key directly here */
  _ma_make_key(info, &amp;key, def-&gt;key, key_buff, record, 0, 0);

  /* The above changed info-&gt;lastkey_buff2. Inform maria_rnext_same(). */
  info-&gt;update&amp;= ~HA_STATE_RNEXT_SAME;

  /* Setup that unique key is active key */
  info-&gt;last_key.keyinfo= keyinfo;

  /* any key pointer in data is destroyed */
  info-&gt;lastinx= ~0;

  DBUG_ASSERT(key.data_length == MARIA_UNIQUE_HASH_LENGTH);
  if (_ma_search(info, &amp;key, SEARCH_FIND | SEARCH_SAVE_BUFF,
                 info-&gt;s-&gt;state.key_root[def-&gt;key]))
  {
    info-&gt;page_changed=1;			/* Can&#039;t optimize read next */
    info-&gt;cur_row.lastpos= lastpos;
    goto end;
  }

  for (;;)
  {
    if (info-&gt;cur_row.lastpos != disk_pos &amp;&amp;
	!(*info-&gt;s-&gt;compare_unique)(info,def,record,info-&gt;cur_row.lastpos))
    {
      my_errno=HA_ERR_FOUND_DUPP_UNIQUE;
      info-&gt;errkey= (int) def-&gt;key;
      info-&gt;dup_key_pos= info-&gt;cur_row.lastpos;
      info-&gt;page_changed= 1;			/* Can&#039;t optimize read next */
      info-&gt;cur_row.lastpos= lastpos;
      DBUG_PRINT(&quot;info&quot;,(&quot;Found duplicate&quot;));
      error= 1;                                 /* Found identical  */
      goto end;
    }
    DBUG_ASSERT(info-&gt;last_key.data_length == MARIA_UNIQUE_HASH_LENGTH);
    if (_ma_search_next(info, &amp;info-&gt;last_key, SEARCH_BIGGER,
			info-&gt;s-&gt;state.key_root[def-&gt;key]) ||
	bcmp(info-&gt;last_key.data, key_buff, MARIA_UNIQUE_HASH_LENGTH))
    {
      info-&gt;page_changed= 1;			/* Can&#039;t optimize read next */
      info-&gt;cur_row.lastpos= lastpos;
      break;                                    /* end of tree */
    }
  }

end:
  DBUG_RETURN(error);
}


/*
  Calculate a hash for a row

  TODO
    Add support for bit fields
*/

ha_checksum _ma_unique_hash(MARIA_UNIQUEDEF *def, const uchar *record)
{
  const uchar *pos, *end;
  ha_checksum crc= 0;
  ulong seed1=0, seed2= 4;
  HA_KEYSEG *keyseg;

  for (keyseg=def-&gt;seg ; keyseg &lt; def-&gt;end ; keyseg++)
  {
    enum ha_base_keytype type=(enum ha_base_keytype) keyseg-&gt;type;
    uint length=keyseg-&gt;length;

    if (keyseg-&gt;null_bit)
    {
      if (record[keyseg-&gt;null_pos] &amp; keyseg-&gt;null_bit)
      {
	/*
	  Change crc in a way different from an empty string or 0.
	  (This is an optimisation;  The code will work even if this isn&#039;t
	  done)
	*/
	crc=((crc &lt;&lt; 8) + 511+
	     (crc &gt;&gt; (8*sizeof(ha_checksum)-8)));
	continue;
      }
    }
    pos= record+keyseg-&gt;start;
    if (keyseg-&gt;flag &amp; HA_VAR_LENGTH_PART)
    {
      uint pack_length=  keyseg-&gt;bit_start;
      uint tmp_length= (pack_length == 1 ? (uint) *pos :
                        uint2korr(pos));
      pos+= pack_length;			/* Skip VARCHAR length */
      set_if_smaller(length,tmp_length);
    }
    else if (keyseg-&gt;flag &amp; HA_BLOB_PART)
    {
      uint tmp_length= _ma_calc_blob_length(keyseg-&gt;bit_start,pos);
      memcpy((void*) &amp;pos,pos+keyseg-&gt;bit_start,sizeof(char*));
      if (!length || length &gt; tmp_length)
	length=tmp_length;			/* The whole blob */
    }
    end= pos+length;
    if (type == HA_KEYTYPE_TEXT || type == HA_KEYTYPE_VARTEXT1 ||
        type == HA_KEYTYPE_VARTEXT2)
    {
      my_ci_hash_sort(keyseg-&gt;charset,
                      (const uchar*) pos, length,
                      &amp;seed1, &amp;seed2);
      crc+= seed1;
    }
    else
    {
      my_hash_sort_bin((CHARSET_INFO*) 0, pos, (size_t) (end-pos),
                       &amp;seed1, &amp;seed2);
      crc+= seed1;
    }
  }
  return crc;
}


/*
  compare unique key for two rows

  TODO
    Add support for bit fields

  RETURN
    0   if both rows have equal unique value
    1   Rows are different
*/

my_bool _ma_unique_comp(MARIA_UNIQUEDEF *def, const uchar *a, const uchar *b,
                        my_bool null_are_equal)
{
  const uchar *pos_a, *pos_b, *end;
  HA_KEYSEG *keyseg;

  for (keyseg=def-&gt;seg ; keyseg &lt; def-&gt;end ; keyseg++)
  {
    enum ha_base_keytype type=(enum ha_base_keytype) keyseg-&gt;type;
    uint a_length, b_length;
    a_length= b_length= keyseg-&gt;length;

    /* If part is NULL it&#039;s regarded as different */
    if (keyseg-&gt;null_bit)
    {
      uint tmp;
      if ((tmp=(a[keyseg-&gt;null_pos] &amp; keyseg-&gt;null_bit)) !=
	  (uint) (b[keyseg-&gt;null_pos] &amp; keyseg-&gt;null_bit))
	return 1;
      if (tmp)
      {
	if (!null_are_equal)
	  return 1;
	continue;
      }
    }
    pos_a= a+keyseg-&gt;start;
    pos_b= b+keyseg-&gt;start;
    if (keyseg-&gt;flag &amp; HA_VAR_LENGTH_PART)
    {
      uint pack_length= keyseg-&gt;bit_start;
      if (pack_length == 1)
      {
        a_length= (uint) *pos_a++;
        b_length= (uint) *pos_b++;
      }
      else
      {
        a_length= uint2korr(pos_a);
        b_length= uint2korr(pos_b);
        pos_a+= 2;				/* Skip VARCHAR length */
        pos_b+= 2;
      }
      set_if_smaller(a_length, keyseg-&gt;length); /* Safety */
      set_if_smaller(b_length, keyseg-&gt;length); /* safety */
    }
    else if (keyseg-&gt;flag &amp; HA_BLOB_PART)
    {
      /* Only compare &#039;length&#039; characters if length != 0 */
      a_length= _ma_calc_blob_length(keyseg-&gt;bit_start,pos_a);
      b_length= _ma_calc_blob_length(keyseg-&gt;bit_start,pos_b);
      /* Check that a and b are of equal length */
      if (keyseg-&gt;length)
      {
        /*
          This is used in some cases when we are not interested in comparing
          the whole length of the blob.
        */
        set_if_smaller(a_length, keyseg-&gt;length);
        set_if_smaller(b_length, keyseg-&gt;length);
      }
      memcpy((void*) &amp;pos_a, pos_a+keyseg-&gt;bit_start, sizeof(char*));
      memcpy((void*) &amp;pos_b, pos_b+keyseg-&gt;bit_start, sizeof(char*));
    }
    if (type == HA_KEYTYPE_TEXT/* the CHAR data type*/)
    {
      if (ha_compare_char_fixed(keyseg-&gt;charset,
                                pos_a, a_length,
                                pos_b, b_length,
                                keyseg-&gt;length / keyseg-&gt;charset-&gt;mbmaxlen,
                                FALSE/*b_is_prefix*/))
        return 1;
    }
    else if (type == HA_KEYTYPE_VARTEXT1 ||
             type == HA_KEYTYPE_VARTEXT2)
    {
      if (ha_compare_char_varying(keyseg-&gt;charset,
                                  pos_a, a_length,
                                  pos_b, b_length,
                                  FALSE/*b_is_prefix*/))
        return 1;
    }
    else
    {
      if (a_length != b_length)
        return 1;
      end= pos_a+a_length;
      while (pos_a != end)
      {
	if (*pos_a++ != *pos_b++)
	  return 1;
      }
    }
  }
  return 0;
}
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fmaria'>🔙 Back</a></p>