• Michael Widenius's avatar
    Added versioning of Maria index · 52cb0c24
    Michael Widenius authored
    Store max_trid in index file as state.create_trid. This is used to pack all transids in the index pages relative to max possible transid for file.
    Enable versioning for transactional tables with index. Tables with an auto-increment key, rtree or fulltext keys are not versioned.
    Changed info->lastkey to type MARIA_KEY. Removed info->lastkey_length as this is now part of info->lastkey
    Renamed old info->lastkey to info->lastkey_buff
    Use exact key lenghts for keys, not USE_WHOLE_KEY
    For partial key searches, use SEARCH_PART_KEY
    When searching to insert new key on page, use SEARCH_INSERT to mark that key has rowid
    
    Changes done in a lot of files:
    - Modified functions to use MARIA_KEY instead of key pointer and key length
    - Use keyinfo->root_lock instead of share->key_root_lock[keynr]
    - Simplify code by using local variable keyinfo instead if share->keyinfo[i]
    - Added #fdef EXTERNAL_LOCKING around removed state elements
    - HA_MAX_KEY_BUFF -> MARIA_MAX_KEY_BUFF (to reserve space for transid)
    - Changed type of 'nextflag' to uint32 to ensure all SEARCH_xxx flags fits into it
    
    .bzrignore:
      Added missing temporary directory
    extra/Makefile.am:
      comp_err is now deleted on make distclean
    include/maria.h:
      Added structure MARIA_KEY, which is used for intern key objects in Maria.
      Changed functions to take MARIA_KEY as an argument instead of pointer to packed key.
      Changed some functions that always return true or false to my_bool.
      Added virtual function make_key() to avoid if in _ma_make_key()
      Moved rw_lock_t for locking trees from share->key_root_lock to MARIA_KEYDEF. This makes usage of the locks simpler and faster
    include/my_base.h:
      Added HA_RTREE_INDEX flag to mark rtree index. Used for easier checks in ma_check()
      Added SEARCH_INSERT to be used when inserting new keys
      Added SEARCH_PART_KEY for partial searches
      Added SEARCH_USER_KEY_HAS_TRANSID to be used when key we use for searching in btree has a TRANSID
      Added SEARCH_PAGE_KEY_HAS_TRANSID to be used when key we found in btree has a transid
    include/my_handler.h:
      Make next_flag 32 bit to make sure we can handle all SEARCH_ bits
    mysql-test/include/maria_empty_logs.inc:
      Read and restore current database; Don't assume we are using mysqltest.
      Don't log use databasename to log. Using this include should not cause any result changes.
    mysql-test/r/maria-gis-rtree-dynamic.result:
      Updated results after adding some check table commands to help pinpoint errors
    mysql-test/r/maria-mvcc.result:
      New tests
    mysql-test/r/maria-purge.result:
      New result after adding removal of logs
    mysql-test/r/maria-recovery-big.result:
      maria_empty_logs doesn't log 'use mysqltest' anymore
    mysql-test/r/maria-recovery-bitmap.result:
      maria_empty_logs doesn't log 'use mysqltest' anymore
    mysql-test/r/maria-recovery-rtree-ft.result:
      maria_empty_logs doesn't log 'use mysqltest' anymore
    mysql-test/r/maria-recovery.result:
      maria_empty_logs doesn't log 'use mysqltest' anymore
    mysql-test/r/maria.result:
      New tests
    mysql-test/r/variables-big.result:
      Don't log id as it's not predictable
    mysql-test/suite/rpl_ndb/r/rpl_truncate_7ndb_2.result:
      Updated results to new binlog results. (Test has not been run in a long time as it requires --big)
    mysql-test/suite/rpl_ndb/t/rpl_truncate_7ndb_2-master.opt:
      Moved file to ndb replication test directory
    mysql-test/suite/rpl_ndb/t/rpl_truncate_7ndb_2.test:
      Fixed wrong path to included tests
    mysql-test/t/maria-gis-rtree-dynamic.test:
      Added some check table commands to help pinpoint errors
    mysql-test/t/maria-mvcc.test:
      New tests
    mysql-test/t/maria-purge.test:
      Remove logs to make test results predictable
    mysql-test/t/maria.test:
      New tests for some possible problems
    mysql-test/t/variables-big.test:
      Don't log id as it's not predictable
    mysys/my_handler.c:
      Updated function comment to reflect old code
      Changed nextflag to be uint32 to ensure we can have flags > 16 bit
      Changed checking if we are in insert with NULL keys as next_flag can now include additional bits that have to be ignored.
      Added SEARCH_INSERT flag to be used when inserting new keys in btree. This flag tells us the that the keys includes row position and it's thus safe to remove SEARCH_FIND
      Added comparision of transid. This is only done if the keys actually have a transid, which is indicated by nextflag
    mysys/my_lock.c:
      Fixed wrong test (Found by Guilhem)
    scripts/Makefile.am:
      Ensure that test programs are deleted by make clean
    sql/rpl_rli.cc:
      Moved assignment order to fix compiler warning
    storage/heap/hp_write.c:
      Add SEARCH_INSERT to signal ha_key_cmp that we we should also compare rowid for keys
    storage/maria/Makefile.am:
      Remove also maria log files when doing make distclean
    storage/maria/ha_maria.cc:
      Use 'file->start_state' as default state for transactional tables without versioning
      At table unlock, set file->state to point to live state. (Needed for information schema to pick up right number of rows)
      In ha_maria::implicit_commit() move all locked (ie open) tables to new transaction. This is needed to ensure ha_maria->info doesn't point to a deleted history event.
      Disable concurrent inserts for insert ... select and table changes with subqueries if statement based replication as this would cause wrong results on slave
    storage/maria/ma_blockrec.c:
      Updated comment
    storage/maria/ma_check.c:
      Compact key pages (removes transid) when doing --zerofill
      Check that 'page_flag' on key pages contains KEYPAGE_FLAG_HAS_TRANSID if there is a single key on the page with a transid
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Use new interface to _ma_rec_pos(), _ma_dpointer(), _ma_ft_del(), ma_update_state_lsn()
      Removed not needed argument from get_record_for_key()
      Fixed that we check doesn't give errors for RTREE; We now treath these like SPATIAL
      Remove some SPATIAL specific code where the virtual functions can handle this in a general manner
      Use info->lastkey_buff instead of info->lastkey
      _ma_dpos() -> _ma_row_pos_from_key()
      _ma_make_key() -> keyinfo->make_key()
      _ma_print_key() -> _ma_print_keydata()
      _ma_move_key() -> ma_copy_copy()
      Add SEARCH_INSERT to signal ha_key_cmp that we we should also compare rowid for keys
      Ensure that data on page doesn't overwrite page checksum position
      Use DBUG_DUMP_KEY instead of DBUG_DUMP
      Use exact key lengths instead of USE_WHOLE_KEY to ha_key_cmp()
      Fixed check if rowid points outside of BLOCK_RECORD data file
      Use info->lastkey_buff instead of key on stack in some safe places
      Added #fdef EXTERNAL_LOCKING around removed state elements
    storage/maria/ma_close.c:
      Use keyinfo->root_lock instead of share->key_root_lock[keynr]
    storage/maria/ma_create.c:
      Removed assert that is already checked in maria_init()
      Force transactinal tables to be of type BLOCK_RECORD
      Fixed wrong usage of HA_PACK_RECORD (should be HA_OPTION_PACK_RECORD)
      Mark keys that uses HA_KEY_ALG_RTREE with HA_RTREE_INDEX for easier handling of these in ma_check
      Store max_trid in index file as state.create_trid. This is used to pack all transids in the index pages relative to max possible transid for file.
    storage/maria/ma_dbug.c:
      Changed _ma_print_key() to use MARIA_KEY
    storage/maria/ma_delete.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      info->lastkey2-> info->lastkey_buff2
      Added SEARCH_INSERT to signal ha_key_cmp that we we should also compare rowid for keys
      Use new interface for get_key(), _ma_get_last_key() and others
      _ma_dpos() -> ma_row_pos_from_key()
      Simplify setting of prev_key in del()
      Ensure that KEYPAGE_FLAG_HAS_TRANSID is set in page_flag if key page has transid
      Treath key pages that may have a transid as if keys would be of variable length
    storage/maria/ma_delete_all.c:
      Reset history state if maria_delete_all_rows() are called
      Update parameters to _ma_update_state_lsns() call
    storage/maria/ma_extra.c:
      Store and restore info->lastkey
    storage/maria/ma_ft_boolean_search.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_ft_nlq_search.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Use lastkey_buff2 instead of info->lastkey+info->s->base.max_key_length (same thing)
    storage/maria/ma_ft_update.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_ftdefs.h:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_fulltext.h:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_init.c:
      Check if blocksize is legal
      (Moved test here from ma_open())
    storage/maria/ma_key.c:
      Added functions for storing/reading of transid 
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Moved _ma_sp_make_key() out of _ma_make_key() as we now use keyinfo->make_key to create keys
      Add transid to keys if table is versioned
      Added _ma_copy_key()
    storage/maria/ma_key_recover.c:
      Add logging of page_flag (holds information if there are keys with transid on page)
      Changed DBUG_PRINT("info" -> DBUG_PRINT("redo" as the redo logging can be quite extensive
      Added lots of DBUG_PRINT()
      Added support for index page operations: KEY_OP_SET_PAGEFLAG and KEY_OP_COMPACT_PAGE
    storage/maria/ma_key_recover.h:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_locking.c:
      Added new arguments to _ma_update_state_lsns_sub()
    storage/maria/ma_loghandler.c:
      Fixed all logging of LSN to look similar in DBUG log
      Changed if (left != 0) to if (left) as the later is used also later in the code
    storage/maria/ma_loghandler.h:
      Added new index page operations
    storage/maria/ma_open.c:
      Removed allocated "state_dummy" and instead use share->state.common for transactional tables that are not versioned
      This is needed to not get double increments of state.records (one in ma_write.c and on when log is written)
      Changed info->lastkey to MARIA_KEY type
      Removed resetting of MARIA_HA variables that have 0 as default value (as info is zerofilled)
      Enable versioning for transactional tables with index. Tables with an auto-increment key, rtree or fulltext keys are not versioned.
      Check on open that state.create_trid is correct
      Extend share->base.max_key_length in case of transactional table so that it can hold transid
      Removed 4.0 compatible fulltext key mode as this is not relevant for Maria
      Removed old and wrong #ifdef ENABLE_WHEN_WE_HAVE_TRANS_ROW_ID code block
      Initialize all new virtual function pointers
      Removed storing of state->unique, state->process and store state->create_trid instead
    storage/maria/ma_page.c:
      Added comment to describe key page structure
      Added functions to compact key page and log the compact operation
    storage/maria/ma_range.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Use SEARCH_PART_KEY indicator instead of USE_WHOLE_KEY to detect if we are doing a part key search
      Added handling of pages with transid
    storage/maria/ma_recovery.c:
      Don't assert if table we opened are not transactional. This may be a table which has been changed from transactional to not transactinal
      Added new arguments to _ma_update_state_lsns()
    storage/maria/ma_rename.c:
      Added new arguments to _ma_update_state_lsns()
    storage/maria/ma_rkey.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Don't use USE_WHOLE_KEY, use real length of key
      Use share->row_is_visible() to test if row is visible
      Moved search_flag == HA_READ_KEY_EXACT out of 'read-next-row' loop as this only need to be tested once
      Removed test if last_used_keyseg != 0 as this is always true
    storage/maria/ma_rnext.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Simplify code by using local variable keyinfo instead if share->keyinfo[i]
      Use share->row_is_visible() to test if row is visible
    storage/maria/ma_rnext_same.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      lastkey2 -> lastkey_buff2
    storage/maria/ma_rprev.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Simplify code by using local variable keyinfo instead if share->keyinfo[i]
      Use share->row_is_visible() to test if row is visible
    storage/maria/ma_rsame.c:
      Updated comment
      Simplify code by using local variable keyinfo instead if share->keyinfo[i]
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_rsamepos.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_rt_index.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Use better variable names
      Removed not needed casts
      _ma_dpos() -> _ma_row_pos_from_key()
      Use info->last_rtree_keypos to save position to key instead of info->int_keypos
      Simplify err: condition
      Changed return type for maria_rtree_insert() to my_bool as we are only intressed in ok/fail from this function
    storage/maria/ma_rt_index.h:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_rt_key.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Simplify maria_rtree_add_key by combining idenitcal code and removing added_len
    storage/maria/ma_rt_key.h:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_rt_mbr.c:
      Changed type of 'nextflag' to uint32
      Added 'to' argument to RT_PAGE_MBR_XXX functions to more clearly see which variables changes value
    storage/maria/ma_rt_mbr.h:
      Changed type of 'nextflag' to uint32
    storage/maria/ma_rt_split.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      key_length -> key_data_length to catch possible errors
    storage/maria/ma_rt_test.c:
      Fixed wrong comment
      Reset recinfo to avoid valgrind varnings
      Fixed wrong argument to create_record() that caused test to fail
    storage/maria/ma_search.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Added support of keys with optional trid
      Test for SEARCH_PART_KEY instead of USE_WHOLE_KEY to detect part key reads
      _ma_dpos() -> _ma_row_pos_from_key()
      If there may be keys with transid on the page, have _ma_bin_search() call _ma_seq_search()
      Add _ma_skip_xxx() functions to quickly step over keys (faster than calling get_key() in most cases as we don't have to copy key data)
      Combine similar code at end of _ma_get_binary_pack_key()
      Removed not used function _ma_move_key()
      In _ma_search_next() don't call _ma_search() if we aren't on a nod page.
      Update info->cur_row.trid with trid for found key
      
      
      
      Removed some not needed casts
      Added _ma_trid_from_key()
      Use MARIA_SHARE instead of MARIA_HA as arguments to _ma_rec_pos(), _ma_dpointer() and _ma_xxx_keypos_to_recpos() to make functions faster and smaller
    storage/maria/ma_sort.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_sp_defs.h:
      _ma_sp_make_key() now fills in and returns (MARIA_KEY *) value
    storage/maria/ma_sp_key.c:
      _ma_sp_make_key() now fills in and returns (MARIA_KEY *) value
      Don't test sizeof(double), test against 8 as we are using float8store()
      Use mi_float8store() instead of doing swap of value (same thing but faster)
    storage/maria/ma_state.c:
      maria_versioning() now only calls _ma_block_get_status() if table supports versioning
      Added _ma_row_visible_xxx() functions for different occasions
      When emptying history, set info->state to point to the first history event.
    storage/maria/ma_state.h:
      Added _ma_row_visible_xxx() prototypes
    storage/maria/ma_static.c:
      Indentation changes
    storage/maria/ma_statrec.c:
      Fixed arguments to _ma_dpointer() and _ma_rec_pos()
    storage/maria/ma_test1.c:
      Call init_thr_lock() if we have versioning
    storage/maria/ma_test2.c:
      Call init_thr_lock() if we have versioning
    storage/maria/ma_unique.c:
      Modified functions to use MARIA_KEY
    storage/maria/ma_update.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
    storage/maria/ma_write.c:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Simplify code by using local variable keyinfo instead if share->keyinfo[i]
      In _ma_enlarge_root(), mark in page_flag if new key has transid
      _ma_dpos() -> _ma_row_pos_from_key()
      Changed return type of _ma_ck_write_tree() to my_bool as we are only testing if result is true or not
      Moved 'reversed' to outside block as area was used later
    storage/maria/maria_chk.c:
      Added error if trying to sort with HA_BINARY_PACK_KEY
      Use new interface to get_key() and _ma_dpointer()
      _ma_dpos() -> _ma_row_pos_from_key()
    storage/maria/maria_def.h:
      Modified functions to use MARIA_KEY instead of key pointer and key length
      Added 'common' to MARIA_SHARE->state for storing state for transactional tables without versioning
      Added create_trid to MARIA_SHARE
      Removed not used state variables 'process' and 'unique'
      Added defines for handling TRID's in index pages
      Changed to use MARIA_SHARE instead of MARIA_HA for some functions
      Added 'have_versioning' flag if table supports versioning
      Moved key_root_lock from MARIA_SHARE to MARIA_KEYDEF
      Changed last_key to be of type MARIA_KEY. Removed lastkey_length
      lastkey -> lastkey_buff, lastkey2 -> lastkey_buff2
      Added _ma_get_used_and_nod_with_flag() for faster access to page data when page_flag is read
      Added DBUG_DUMP_KEY for easier DBUG_DUMP of a key
      Changed 'nextflag' and assocaited variables to uint32
    storage/maria/maria_ftdump.c:
      lastkey -> lastkey_buff
    storage/maria/trnman.c:
      Fixed wrong initialization of min_read_from and max_commit_trid
      Added trnman_get_min_safe_trid()
    storage/maria/unittest/ma_test_all-t:
      Added --start-from
    storage/myisam/mi_check.c:
      Added SEARCH_INSERT, as ha_key_cmp() needs it when doing key comparision for inserting key on page in rowid order
    storage/myisam/mi_delete.c:
      Added SEARCH_INSERT, as ha_key_cmp() needs it when doing key comparision for inserting key on page in rowid order
    storage/myisam/mi_range.c:
      Updated comment
    storage/myisam/mi_write.c:
      Added SEARCH_INSERT, as ha_key_cmp() needs it when doing key comparision for inserting key on page in rowid order
    storage/myisam/rt_index.c:
      Fixed wrong parameter to rtree_get_req() which could cause crash
    52cb0c24
ma_rt_test.c 16.2 KB
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
/* Copyright (C) 2006 MySQL AB & MySQL Finland AB & TCX DataKonsult AB

   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */

/* Testing of the basic functions of a MARIA rtree table         */
/* Written by Alex Barkov who has a shared copyright to this code */


#include "maria_def.h"
#include "ma_control_file.h"
#include "ma_loghandler.h"
#include "ma_checkpoint.h"
#include "trnman.h"
#include <my_getopt.h>

#ifdef HAVE_RTREE_KEYS

#include "ma_rt_index.h"

#define MAX_REC_LENGTH 1024
#define ndims 2
#define KEYALG HA_KEY_ALG_RTREE

static int read_with_pos(MARIA_HA * file);
static void create_record(uchar *record,uint rownr);
static void create_record1(uchar *record,uint rownr);
static void print_record(uchar * record,my_off_t offs,const char * tail);
static  int run_test(const char *filename);
static void get_options(int argc, char *argv[]);
static void usage();

static double rt_data[]=
{
  /*1*/  0,10,0,10,
  /*2*/  5,15,0,10,
  /*3*/  0,10,5,15,
  /*4*/  10,20,10,20,
  /*5*/  0,10,0,10,
  /*6*/  5,15,0,10,
  /*7*/  0,10,5,15,
  /*8*/  10,20,10,20,
  /*9*/  0,10,0,10,
  /*10*/  5,15,0,10,
  /*11*/  0,10,5,15,
  /*12*/  10,20,10,20,
  /*13*/  0,10,0,10,
  /*14*/  5,15,0,10,
  /*15*/  0,10,5,15,
  /*16*/  10,20,10,20,
  /*17*/  5,15,0,10,
  /*18*/  0,10,5,15,
  /*19*/  10,20,10,20,
  /*20*/  0,10,0,10,

  /*1*/  100,110,0,10,
  /*2*/  105,115,0,10,
  /*3*/  100,110,5,15,
  /*4*/  110,120,10,20,
  /*5*/  100,110,0,10,
  /*6*/  105,115,0,10,
  /*7*/  100,110,5,15,
  /*8*/  110,120,10,20,
  /*9*/  100,110,0,10,
  /*10*/  105,115,0,10,
  /*11*/  100,110,5,15,
  /*12*/  110,120,10,20,
  /*13*/  100,110,0,10,
  /*14*/  105,115,0,10,
  /*15*/  100,110,5,15,
  /*16*/  110,120,10,20,
  /*17*/  105,115,0,10,
  /*18*/  100,110,5,15,
  /*19*/  110,120,10,20,
  /*20*/  100,110,0,10,
  -1
};

static int silent= 0, testflag= 0, transactional= 0,
  die_in_middle_of_transaction= 0, checkpoint= 0, create_flag= 0;
static enum data_file_type record_type= DYNAMIC_RECORD;

int main(int argc, char *argv[])
{
  MY_INIT(argv[0]);
  get_options(argc, argv);
  maria_data_root= (char *)".";
  /* Maria requires that we always have a page cache */
  if (maria_init() ||
      (init_pagecache(maria_pagecache, maria_block_size * 16, 0, 0,
                      maria_block_size, MY_WME) == 0) ||
      ma_control_file_open(TRUE, TRUE) ||
      (init_pagecache(maria_log_pagecache,
                      TRANSLOG_PAGECACHE_SIZE, 0, 0,
                      TRANSLOG_PAGE_SIZE, MY_WME) == 0) ||
      translog_init(maria_data_root, TRANSLOG_FILE_SIZE,
                    0, 0, maria_log_pagecache,
                    TRANSLOG_DEFAULT_FLAGS, 0) ||
      (transactional && (trnman_init(0) || ma_checkpoint_init(0))))
  {
    fprintf(stderr, "Error in initialization\n");
    exit(1);
  }

  exit(run_test("rt_test"));
}


static int run_test(const char *filename)
{
  MARIA_HA        *file;
  MARIA_UNIQUEDEF   uniquedef;
  MARIA_CREATE_INFO create_info;
  MARIA_COLUMNDEF   recinfo[20];
  MARIA_KEYDEF      keyinfo[20];
  HA_KEYSEG      keyseg[20];
  key_range	range;

  int opt_unique=0;
  int key_type=HA_KEYTYPE_DOUBLE;
  int key_length=8;
  int null_fields=0;
  int nrecords=sizeof(rt_data)/(sizeof(double)*4);/* 40 */
  int rec_length=0;
  int uniques=0;
  int i, max_i;
  int error;
  int row_count=0;
  uchar record[MAX_REC_LENGTH];
  uchar read_record[MAX_REC_LENGTH];
  int upd= 10;
  ha_rows hrows;

  bzero((char*) recinfo,sizeof(recinfo));

  /* Define a column for NULLs and DEL markers*/

  recinfo[0].type=FIELD_NORMAL;
  recinfo[0].length=1; /* For NULL bits */
  rec_length=1;

  /* Define 2*ndims columns for coordinates*/

  for (i=1; i<=2*ndims ;i++)
  {
    recinfo[i].type=FIELD_NORMAL;
    recinfo[i].length=key_length;
    rec_length+=key_length;
  }

  /* Define a key with 2*ndims segments */

  keyinfo[0].seg=keyseg;
  keyinfo[0].keysegs=2*ndims;
  keyinfo[0].flag=0;
  keyinfo[0].key_alg=KEYALG;

  for (i=0; i<2*ndims; i++)
  {
    keyinfo[0].seg[i].type= key_type;
    keyinfo[0].seg[i].flag=0;          /* Things like HA_REVERSE_SORT */
    keyinfo[0].seg[i].start= (key_length*i)+1;
    keyinfo[0].seg[i].length=key_length;
    keyinfo[0].seg[i].null_bit= null_fields ? 2 : 0;
    keyinfo[0].seg[i].null_pos=0;
    keyinfo[0].seg[i].language=default_charset_info->number;
  }

  if (!silent)
    printf("- Creating isam-file\n");

  bzero((char*) &create_info,sizeof(create_info));
  create_info.max_rows=10000000;
  create_info.transactional= transactional;

  if (maria_create(filename,
                   record_type,
                   1,            /*  keys   */
                   keyinfo,
                   1+2*ndims+opt_unique, /* columns */
                   recinfo,uniques,&uniquedef,&create_info,create_flag))
    goto err;

  if (!silent)
    printf("- Open isam-file\n");

  if (!(file=maria_open(filename,2,HA_OPEN_ABORT_IF_LOCKED)))
    goto err;
  maria_begin(file);
  if (testflag == 1)
    goto end;
  if (checkpoint == 1 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
    goto err;
  if (!silent)
    printf("- Writing key:s\n");

  for (i=0; i<nrecords; i++ )
  {
    create_record(record,i);
    error=maria_write(file,record);
    print_record(record,maria_position(file),"\n");
    if (!error)
    {
      row_count++;
    }
    else
    {
      printf("maria_write: %d\n", error);
      goto err;
    }
  }

  if ((error=read_with_pos(file)))
    goto err;

  if (!silent)
    printf("- Reading rows with key\n");

  for (i=0 ; i < nrecords ; i++)
  {
    my_errno=0;
    create_record(record,i);

    bzero((char*) read_record,MAX_REC_LENGTH);
    error=maria_rkey(file,read_record,0,record+1,HA_WHOLE_KEY,HA_READ_MBR_EQUAL);

    if (error && error!=HA_ERR_KEY_NOT_FOUND)
    {
      printf("     maria_rkey: %3d  errno: %3d\n",error,my_errno);
      goto err;
    }
    if (error == HA_ERR_KEY_NOT_FOUND)
    {
      print_record(record,maria_position(file),"  NOT FOUND\n");
      continue;
    }
    print_record(read_record,maria_position(file),"\n");
  }

  if (checkpoint == 2 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
    goto err;

  if (testflag == 2)
    goto end;

  if (!silent)
    printf("- Deleting rows\n");
  if (maria_scan_init(file))
  {
    fprintf(stderr, "maria_scan_init failed\n");
    goto err;
  }

  for (i=0; i < nrecords/4; i++)
  {
    my_errno=0;
    bzero((char*) read_record,MAX_REC_LENGTH);
    error=maria_scan(file,read_record);
    if (error)
    {
      printf("pos: %2d  maria_rrnd: %3d  errno: %3d\n",i,error,my_errno);
      goto err;
    }
    print_record(read_record,maria_position(file),"\n");

    error=maria_delete(file,read_record);
    if (error)
    {
      printf("pos: %2d maria_delete: %3d errno: %3d\n",i,error,my_errno);
      goto err;
    }
  }
  maria_scan_end(file);

  if (testflag == 3)
    goto end;
  if (checkpoint == 3 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
    goto err;

  if (!silent)
    printf("- Updating rows with position\n");
  if (maria_scan_init(file))
  {
    fprintf(stderr, "maria_scan_init failed\n");
    goto err;
  }

  /* We are looking for nrecords-necords/2 non-deleted records */
  for (i=0, max_i= nrecords - nrecords/2; i < max_i ; i++)
  {
    my_errno=0;
    bzero((char*) read_record,MAX_REC_LENGTH);
    error=maria_scan(file,read_record);
    if (error)
    {
      if (error==HA_ERR_RECORD_DELETED)
      {
        printf("found deleted record\n");
        /*
          In BLOCK_RECORD format, maria_scan() never returns deleted records,
          while in DYNAMIC format it can. Don't count such record:
        */
        max_i++;
        continue;
      }
      printf("pos: %2d  maria_rrnd: %3d  errno: %3d\n",i,error,my_errno);
      goto err;
    }
    print_record(read_record,maria_position(file),"");
    create_record1(record,i+nrecords*upd);
    printf("\t-> ");
    print_record(record,maria_position(file),"\n");
    error=maria_update(file,read_record,record);
    if (error)
    {
      printf("pos: %2d  maria_update: %3d  errno: %3d\n",i,error,my_errno);
      goto err;
    }
  }

  if (testflag == 4)
    goto end;
  if (checkpoint == 4 && ma_checkpoint_execute(CHECKPOINT_MEDIUM, FALSE))
    goto err;

  if (maria_scan_init(file))
  {
    fprintf(stderr, "maria_scan_init failed\n");
    goto err;
  }
  if ((error=read_with_pos(file)))
    goto err;
  maria_scan_end(file);

  if (!silent)
    printf("- Test maria_rkey then a sequence of maria_rnext_same\n");

  create_record(record, nrecords*4/5);
  print_record(record,0,"  search for\n");

  if ((error=maria_rkey(file,read_record,0,record+1,HA_WHOLE_KEY,
                        HA_READ_MBR_INTERSECT)))
  {
    printf("maria_rkey: %3d  errno: %3d\n",error,my_errno);
    goto err;
  }
  print_record(read_record,maria_position(file),"  maria_rkey\n");
  row_count=1;

  for (;;)
  {
    if ((error=maria_rnext_same(file,read_record)))
    {
      if (error==HA_ERR_END_OF_FILE)
        break;
      printf("maria_next: %3d  errno: %3d\n",error,my_errno);
      goto err;
    }
    print_record(read_record,maria_position(file),"  maria_rnext_same\n");
      row_count++;
  }
  printf("     %d rows\n",row_count);

  if (!silent)
    printf("- Test maria_rfirst then a sequence of maria_rnext\n");

  error=maria_rfirst(file,read_record,0);
  if (error)
  {
    printf("maria_rfirst: %3d  errno: %3d\n",error,my_errno);
    goto err;
  }
  row_count=1;
  print_record(read_record,maria_position(file),"  maria_frirst\n");

  for (i=0;i<nrecords;i++)
  {
    if ((error=maria_rnext(file,read_record,0)))
    {
      if (error==HA_ERR_END_OF_FILE)
        break;
      printf("maria_next: %3d  errno: %3d\n",error,my_errno);
      goto err;
    }
    print_record(read_record,maria_position(file),"  maria_rnext\n");
    row_count++;
  }
  printf("     %d rows\n",row_count);

  if (!silent)
    printf("- Test maria_records_in_range()\n");

  create_record1(record, nrecords*4/5);
  print_record(record,0,"\n");

  range.key= record+1;
  range.length= 1000;                           /* Big enough */
  range.flag= HA_READ_MBR_INTERSECT;
  hrows= maria_records_in_range(file,0, &range, (key_range*) 0);
  printf("     %ld rows\n", (long) hrows);

end:
  maria_scan_end(file);
  if (die_in_middle_of_transaction)
  {
    /* see similar code in ma_test2.c for comments */
    switch (die_in_middle_of_transaction) {
    case 1:
      _ma_flush_table_files(file, MARIA_FLUSH_DATA | MARIA_FLUSH_INDEX,
                            FLUSH_RELEASE, FLUSH_RELEASE);
      break;
    case 2:
      if (translog_flush(file->trn->undo_lsn))
        goto err;
      break;
    case 3:
      break;
    case 4:
      _ma_flush_table_files(file, MARIA_FLUSH_DATA, FLUSH_RELEASE,
                            FLUSH_RELEASE);
      if (translog_flush(file->trn->undo_lsn))
        goto err;
      break;
    }
    printf("Dying on request without maria_commit()/maria_close()\n");
    exit(0);
  }
  if (maria_commit(file))
    goto err;
  if (maria_close(file)) goto err;
  maria_end();
  my_end(MY_CHECK_ERROR);

  return 0;

err:
  printf("got error: %3d when using maria-database\n",my_errno);
  return 1;           /* skip warning */
}



static int read_with_pos (MARIA_HA * file)
{
  int error;
  int i;
  uchar read_record[MAX_REC_LENGTH];

  if (!silent)
    printf("- Reading rows with position\n");
  for (i=0;;i++)
  {
    my_errno=0;
    bzero((char*) read_record,MAX_REC_LENGTH);
    error=maria_scan(file,read_record);
    if (error)
    {
      if (error==HA_ERR_END_OF_FILE)
        break;
      if (error==HA_ERR_RECORD_DELETED)
        continue;
      printf("pos: %2d  maria_rrnd: %3d  errno: %3d\n",i,error,my_errno);
      return error;
    }
    print_record(read_record,maria_position(file),"\n");
  }
  return 0;
}


#ifdef NOT_USED
static void bprint_record(char * record,
			  my_off_t offs __attribute__((unused)),
			  const char * tail)
{
  int i;
  char * pos;
  i=(unsigned char)record[0];
  printf("%02X ",i);

  for( pos=record+1, i=0; i<32; i++,pos++){
    int b=(unsigned char)*pos;
    printf("%02X",b);
  }
  printf("%s",tail);
}
#endif


static void print_record(uchar *record,
			 my_off_t offs __attribute__((unused)),
			 const char * tail)
{
  int i;
  uchar *pos;
  double c;

  printf("     rec=(%d)",(unsigned char)record[0]);
  for ( pos=record+1, i=0; i<2*ndims; i++)
   {
      memcpy(&c,pos,sizeof(c));
      float8get(c,pos);
      printf(" %.14g ",c);
      pos+=sizeof(c);
   }
   printf("pos=%ld",(long int)offs);
   printf("%s",tail);
}



static void create_record1(uchar *record, uint rownr)
{
   int i;
   uchar *pos;
   double c=rownr+10;

   bzero((char*) record,MAX_REC_LENGTH);
   record[0]=0x01; /* DEL marker */

   for ( pos=record+1, i=0; i<2*ndims; i++)
   {
      memcpy(pos,&c,sizeof(c));
      float8store(pos,c);
      pos+=sizeof(c);
   }
}

#ifdef NOT_USED

static void create_record0(char *record,uint rownr)
{
   int i;
   char * pos;
   double c=rownr+10;
   double c0=0;

   bzero((char*) record,MAX_REC_LENGTH);
   record[0]=0x01; /* DEL marker */

   for ( pos=record+1, i=0; i<ndims; i++)
   {
      memcpy(pos,&c0,sizeof(c0));
      float8store(pos,c0);
      pos+=sizeof(c0);
      memcpy(pos,&c,sizeof(c));
      float8store(pos,c);
      pos+=sizeof(c);
   }
}

#endif

static void create_record(uchar *record, uint rownr)
{
   int i;
   uchar *pos;
   double *data= rt_data+rownr*4;
   record[0]=0x01; /* DEL marker */
   for ( pos=record+1, i=0; i<ndims*2; i++)
   {
      float8store(pos,data[i]);
      pos+=8;
   }
}


static struct my_option my_long_options[] =
{
  {"checkpoint", 'H', "Checkpoint at specified stage", (uchar**) &checkpoint,
   (uchar**) &checkpoint, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"checksum", 'c', "Undocumented",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
#ifndef DBUG_OFF
  {"debug", '#', "Undocumented",
   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
#endif
  {"help", '?', "Display help and exit",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"row-fixed-size", 'S', "Fixed size records",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"rows-in-block", 'M', "Store rows in block format",
   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
  {"silent", 's', "Undocumented",
   (uchar**) &silent, (uchar**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0,
   0, 0},
  {"testflag", 't', "Stop test at specified stage", (uchar**) &testflag,
   (uchar**) &testflag, 0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"test-undo", 'A',
   "Abort hard. Used for testing recovery with undo",
   (uchar**) &die_in_middle_of_transaction,
   (uchar**) &die_in_middle_of_transaction,
   0, GET_INT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
  {"transactional", 'T',
   "Test in transactional mode. (Only works with block format)",
   (uchar**) &transactional, (uchar**) &transactional, 0, GET_BOOL, NO_ARG,
   0, 0, 0, 0, 0, 0},
  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
};


static my_bool
get_one_option(int optid, const struct my_option *opt __attribute__((unused)),
	       char *argument __attribute__((unused)))
{
  switch(optid) {
  case 'c':
    create_flag|= HA_CREATE_CHECKSUM | HA_CREATE_PAGE_CHECKSUM;
    break;
  case 'M':
    record_type= BLOCK_RECORD;
    break;
  case 'S':
    record_type= STATIC_RECORD;
    break;
  case '#':
    DBUG_PUSH(argument);
    break;
  case '?':
    usage();
    exit(1);
  }
  return 0;
}


/* Read options */

static void get_options(int argc, char *argv[])
{
  int ho_error;

  if ((ho_error=handle_options(&argc, &argv, my_long_options, get_one_option)))
    exit(ho_error);

  return;
} /* get options */


static void usage()
{
  printf("Usage: %s [options]\n\n", my_progname);
  my_print_help(my_long_options);
  my_print_variables(my_long_options);
}

#else
int main(int argc __attribute__((unused)),char *argv[] __attribute__((unused)))
{
  exit(0);
}
#endif /*HAVE_RTREE_KEYS*/