Adding upstream version 1:10.11.6.upstream/1%10.11.6upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 206 insertions, 0 deletions

diff --git a/storage/heap/_check.c b/storage/heap/_check.c
new file mode 100644
index 00000000..1a640fa1
--- /dev/null
+++ b/storage/heap/_check.c
@@ -0,0 +1,206 @@
+/* Copyright (c) 2000, 2002-2007 MySQL AB
+   Use is subject to license terms
+
+   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 */
+
+/* Check that heap-structure is ok */
+
+#include "heapdef.h"
+
+static int check_one_key(HP_KEYDEF *, uint, ulong, ulong, my_bool);
+static int check_one_rb_key(const HP_INFO *, uint, ulong, my_bool);
+
+
+/*
+  Check if keys and rows are ok in a heap table
+
+  SYNOPSIS
+    heap_check_heap()
+    info		Table handler
+    print_status	Prints some extra status
+
+  NOTES
+    Doesn't change the state of the table handler
+
+  RETURN VALUES
+    0	ok
+    1 error
+*/
+
+int heap_check_heap(const HP_INFO *info, my_bool print_status)
+{
+  int error;
+  uint key;
+  ulong records=0, deleted=0, pos, next_block;
+  HP_SHARE *share=info->s;
+  uchar *current_ptr= info->current_ptr;
+  DBUG_ENTER("heap_check_heap");
+
+  for (error=key= 0 ; key < share->keys ; key++)
+  {
+    if (share->keydef[key].algorithm == HA_KEY_ALG_BTREE)
+      error|= check_one_rb_key(info, key, share->records, print_status);
+    else
+      error|= check_one_key(share->keydef + key, key, share->records,
+			    share->blength, print_status);
+  }
+  /*
+    This is basicly the same code as in hp_scan, but we repeat it here to
+    get shorter DBUG log file.
+  */
+  for (pos=next_block= 0 ; ; pos++)
+  {
+    if (pos < next_block)
+    {
+      current_ptr+= share->block.recbuffer;
+    }
+    else
+    {
+      next_block+= share->block.records_in_block;
+      if (next_block >= share->records+share->deleted)
+      {
+	next_block= share->records+share->deleted;
+	if (pos >= next_block)
+	  break;				/* End of file */
+      }
+    }
+    current_ptr= hp_find_block(&share->block, pos);
+
+    if (!current_ptr[share->visible])
+      deleted++;
+    else
+      records++;
+  }
+
+  if (records != share->records || deleted != share->deleted)
+  {
+    DBUG_PRINT("error",("Found rows: %lu (%lu)  deleted %lu (%lu)",
+			records, (ulong) share->records,
+                        deleted, (ulong) share->deleted));
+    error= 1;
+  }
+  DBUG_RETURN(error);
+}
+
+
+static int check_one_key(HP_KEYDEF *keydef, uint keynr, ulong records,
+			 ulong blength, my_bool print_status)
+{
+  int error;
+  ulong i,found,max_links,seek,links;
+  ulong rec_link;				/* Only used with debugging */
+  ulong hash_buckets_found;
+  HASH_INFO *hash_info;
+
+  error=0;
+  hash_buckets_found= 0;
+  for (i=found=max_links=seek=0 ; i < records ; i++)
+  {
+    hash_info=hp_find_hash(&keydef->block,i);
+    if (hash_info->hash_of_key != hp_rec_hashnr(keydef, hash_info->ptr_to_rec))
+    {
+      DBUG_PRINT("error",
+                 ("Found row with wrong hash_of_key at position %lu", i));
+      error= 1;
+    }
+    if (hp_mask(hash_info->hash_of_key, blength, records) == i)
+    {
+      found++;
+      seek++;
+      links=1;
+      while ((hash_info=hash_info->next_key) && found < records + 1)
+      {
+	seek+= ++links;
+	if ((rec_link= hp_mask(hash_info->hash_of_key, blength, records)) != i)
+	{
+	  DBUG_PRINT("error",
+                     ("Record in wrong link: Link %lu  Record: %p  Record-link %lu",
+                      i, hash_info->ptr_to_rec, rec_link));
+	  error=1;
+	}
+	else
+	  found++;
+      }
+      if (links > max_links) max_links=links;
+      hash_buckets_found++;
+    }
+  }
+  if (found != records)
+  {
+    DBUG_PRINT("error",("Found %ld of %ld records", found, records));
+    error=1;
+  }
+  if (keydef->hash_buckets != hash_buckets_found)
+  {
+    DBUG_PRINT("error",("Found %ld buckets, stats shows %ld buckets",
+                        hash_buckets_found, (long) keydef->hash_buckets));
+    error=1;
+  }
+  DBUG_PRINT("info",
+	     ("key: %u  records: %ld  seeks: %lu  max links: %lu  "
+              "hitrate: %.2f  buckets: %lu",
+	      keynr, records,seek,max_links,
+	      (float) seek / (float) (records ? records : 1), 
+              hash_buckets_found));
+  if (print_status)
+    printf("Key: %u  records: %ld  seeks: %lu  max links: %lu  "
+           "hitrate: %.2f  buckets: %lu\n",
+	   keynr, records, seek, max_links,
+	   (float) seek / (float) (records ? records : 1), 
+           hash_buckets_found);
+  return error;
+}
+
+static int check_one_rb_key(const HP_INFO *info, uint keynr, ulong records,
+			    my_bool print_status)
+{
+  HP_KEYDEF *keydef= info->s->keydef + keynr;
+  int error= 0;
+  ulong found= 0;
+  uchar *key, *recpos;
+  uint key_length;
+  uint not_used[2];
+  TREE_ELEMENT **last_pos;
+  TREE_ELEMENT *parents[MAX_TREE_HEIGHT+1];
+  
+  if ((key= tree_search_edge(&keydef->rb_tree, parents,
+			     &last_pos, offsetof(TREE_ELEMENT, left))))
+  {
+    do
+    {
+      memcpy(&recpos, key + (*keydef->get_key_length)(keydef,key), sizeof(uchar*));
+      key_length= hp_rb_make_key(keydef, info->recbuf, recpos, 0);
+      if (ha_key_cmp(keydef->seg, (uchar*) info->recbuf, (uchar*) key,
+		     key_length, SEARCH_FIND | SEARCH_SAME, not_used))
+      {
+	error= 1;
+	DBUG_PRINT("error",("Record in wrong link:  key: %u  Record: %p\n", 
+			    keynr, recpos));
+      }
+      else
+	found++;
+      key= tree_search_next(&keydef->rb_tree, &last_pos,
+			    offsetof(TREE_ELEMENT, left), 
+			    offsetof(TREE_ELEMENT, right));
+    } while (key);
+  }
+  if (found != records)
+  {
+    DBUG_PRINT("error",("Found %lu of %lu records", found, records));
+    error= 1;
+  }
+  if (print_status)
+    printf("Key: %d  records: %ld\n", keynr, records);
+  return error;
+}