← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/mi_check.cc

  • Committer: Padraig O'Sullivan
  • Date: 2009-09-13 00:53:34 UTC
  • mto: (1126.9.2 captain-20090915-01)
  • mto: This revision was merged to the branch mainline in revision 1133.
  • Revision ID: osullivan.padraig@gmail.com-20090913005334-6wio2sbjugskfbm3
Added calls to the connection start/end dtrace probes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/mi_check.cc
40
40
  only. And it is sufficient to calculate the checksum once only.
41
41
*/
42
42
 
43
 
#include "myisam_priv.h"
44
 
#include "drizzled/internal/m_string.h"
 
43
#include "myisamdef.h"
 
44
#include <mystrings/m_string.h>
45
45
#include <stdarg.h>
46
 
#include "drizzled/option.h"
 
46
#include <mysys/my_getopt.h>
47
47
#ifdef HAVE_SYS_VADVISE_H
48
48
#include <sys/vadvise.h>
49
49
#endif
54
54
#include <sys/mman.h>
55
55
#endif
56
56
#include <drizzled/util/test.h>
57
 
#include "drizzled/error.h"
58
57
 
59
58
#include <algorithm>
60
59
 
61
60
using namespace std;
62
 
using namespace drizzled;
63
 
using namespace drizzled::internal;
64
 
 
65
 
 
66
 
#define my_off_t2double(A)  ((double) (my_off_t) (A))
 
61
 
67
62
 
68
63
/* Functions defined in this file */
69
64
 
75
70
static ha_checksum calc_checksum(ha_rows count);
76
71
static int writekeys(MI_SORT_PARAM *sort_param);
77
72
static int sort_one_index(MI_CHECK *param, MI_INFO *info,MI_KEYDEF *keyinfo,
78
 
                          my_off_t pagepos, int new_file);
79
 
int sort_key_read(MI_SORT_PARAM *sort_param,void *key);
80
 
int sort_get_next_record(MI_SORT_PARAM *sort_param);
81
 
int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,const void *b);
82
 
int sort_key_write(MI_SORT_PARAM *sort_param, const void *a);
83
 
my_off_t get_record_for_key(MI_INFO *info,MI_KEYDEF *keyinfo,
84
 
                            unsigned char *key);
85
 
int sort_insert_key(MI_SORT_PARAM  *sort_param,
86
 
                    register SORT_KEY_BLOCKS *key_block,
87
 
                    unsigned char *key, my_off_t prev_block);
88
 
int sort_delete_record(MI_SORT_PARAM *sort_param);
89
 
 
 
73
                          my_off_t pagepos, File new_file);
 
74
extern "C"
 
75
{
 
76
  int sort_key_read(MI_SORT_PARAM *sort_param,void *key);
 
77
  int sort_get_next_record(MI_SORT_PARAM *sort_param);
 
78
  int sort_key_cmp(MI_SORT_PARAM *sort_param, const void *a,const void *b);
 
79
  int sort_key_write(MI_SORT_PARAM *sort_param, const void *a);
 
80
  my_off_t get_record_for_key(MI_INFO *info,MI_KEYDEF *keyinfo,
 
81
                              unsigned char *key);
 
82
  int sort_insert_key(MI_SORT_PARAM  *sort_param,
 
83
                      register SORT_KEY_BLOCKS *key_block,
 
84
                      unsigned char *key, my_off_t prev_block);
 
85
  int sort_delete_record(MI_SORT_PARAM *sort_param);
 
86
}
90
87
/*static int flush_pending_blocks(MI_CHECK *param);*/
91
88
static SORT_KEY_BLOCKS  *alloc_key_blocks(MI_CHECK *param, uint32_t blocks,
92
89
                                          uint32_t buffer_length);
259
256
  unsigned char *buff;
260
257
 
261
258
  if (param->testflag & T_VERBOSE)
262
 
    printf("block_size %4u:", block_size);
 
259
    printf("block_size %4u:", block_size); /* purecov: tested */
263
260
 
264
261
  next_link=info->s->state.key_del[nr];
265
262
  records= (ha_rows) (info->state->key_file_length / block_size);
273
270
    /* Key blocks must lay within the key file length entirely. */
274
271
    if (next_link + block_size > info->state->key_file_length)
275
272
    {
 
273
      /* purecov: begin tested */
276
274
      mi_check_print_error(param, "Invalid key block position: %s  "
277
275
                           "key block size: %u  file_length: %s",
278
276
                           llstr(next_link, llbuff), block_size,
279
277
                           llstr(info->state->key_file_length, llbuff2));
280
278
      return(1);
 
279
      /* purecov: end */
281
280
    }
282
281
 
283
282
    /* Key blocks must be aligned at MI_MIN_KEY_BLOCK_LENGTH. */
284
283
    if (next_link & (MI_MIN_KEY_BLOCK_LENGTH - 1))
285
284
    {
 
285
      /* purecov: begin tested */
286
286
      mi_check_print_error(param, "Mis-aligned key block: %s  "
287
287
                           "minimum key block length: %u",
288
288
                           llstr(next_link, llbuff), MI_MIN_KEY_BLOCK_LENGTH);
289
289
      return(1);
 
290
      /* purecov: end */
290
291
    }
291
292
 
292
293
    /*
299
300
                              (unsigned char*) info->buff, MI_MIN_KEY_BLOCK_LENGTH,
300
301
                              MI_MIN_KEY_BLOCK_LENGTH, 1)))
301
302
    {
 
303
      /* purecov: begin tested */
302
304
      mi_check_print_error(param, "key cache read error for block: %s",
303
305
                           llstr(next_link,llbuff));
304
306
      return(1);
 
307
      /* purecov: end */
305
308
    }
306
309
    next_link=mi_sizekorr(buff);
307
310
    records--;
586
589
  /* Key blocks must lay within the key file length entirely. */
587
590
  if (page + keyinfo->block_length > info->state->key_file_length)
588
591
  {
 
592
    /* purecov: begin tested */
589
593
    /* Give it a chance to fit in the real file size. */
590
594
    my_off_t max_length= lseek(info->s->kfile, 0, SEEK_END);
591
595
    mi_check_print_error(param, "Invalid key block position: %s  "
597
601
    /* Fix the remebered key file length. */
598
602
    info->state->key_file_length= (max_length &
599
603
                                   ~ (my_off_t) (keyinfo->block_length - 1));
 
604
    /* purecov: end */
600
605
  }
601
606
 
602
607
  /* Key blocks must be aligned at MI_MIN_KEY_BLOCK_LENGTH. */
603
608
  if (page & (MI_MIN_KEY_BLOCK_LENGTH - 1))
604
609
  {
 
610
    /* purecov: begin tested */
605
611
    mi_check_print_error(param, "Mis-aligned key block: %s  "
606
612
                         "minimum key block length: %u",
607
613
                         llstr(page, llbuff), MI_MIN_KEY_BLOCK_LENGTH);
608
614
    goto err;
 
615
    /* purecov: end */
609
616
  }
610
617
 
611
618
  if (!_mi_fetch_keypage(info,keyinfo,page, DFLT_INIT_HITS,buff,0))
620
627
 
621
628
  return(0);
622
629
 
 
630
  /* purecov: begin tested */
623
631
err:
624
632
  return(1);
 
633
  /* purecov: end */
625
634
}
626
635
 
627
636
 
1266
1275
  free(mi_get_rec_buff_ptr(info, record));
1267
1276
  return (error);
1268
1277
 err:
1269
 
  mi_check_print_error(param,"got error: %d when reading datafile at record: %s",errno, llstr(records,llbuff));
 
1278
  mi_check_print_error(param,"got error: %d when reading datafile at record: %s",my_errno, llstr(records,llbuff));
1270
1279
 err2:
1271
1280
  free(mi_get_rec_buff_ptr(info, record));
1272
1281
  param->testflag|=T_RETRY_WITHOUT_QUICK;
1314
1323
 
1315
1324
    However, there is an exception. Sometimes MySQL disables non-unique
1316
1325
    indexes when the table is empty (e.g. when copying a table in
1317
 
    drizzled::alter_table()). When enabling the non-unique indexes, they
 
1326
    mysql_alter_table()). When enabling the non-unique indexes, they
1318
1327
    are still empty. So there is no index block that can be lost. This
1319
1328
    optimization is implemented in this function.
1320
1329
 
1378
1387
  /* Remove all key blocks of this index file from key cache. */
1379
1388
  if ((error= flush_key_blocks(share->key_cache, share->kfile,
1380
1389
                               FLUSH_IGNORE_CHANGED)))
1381
 
    goto end;
 
1390
    goto end; /* purecov: inspected */
1382
1391
 
1383
1392
  /* Clear index root block pointers. */
1384
1393
  for (i= 0; i < share->base.keys; i++)
1407
1416
  int error,got_error;
1408
1417
  ha_rows start_records,new_header_length;
1409
1418
  my_off_t del;
1410
 
  int new_file;
 
1419
  File new_file;
1411
1420
  MYISAM_SHARE *share=info->s;
1412
1421
  char llbuff[22],llbuff2[22];
1413
1422
  SORT_INFO sort_info;
1459
1468
  if (!rep_quick)
1460
1469
  {
1461
1470
    /* Get real path for data file */
1462
 
    if ((new_file=my_create(internal::fn_format(param->temp_filename,
 
1471
    if ((new_file=my_create(fn_format(param->temp_filename,
1463
1472
                                      share->data_file_name, "",
1464
1473
                                      DATA_TMP_EXT, 2+4),
1465
1474
                            0,param->tmpfile_createflag,
1515
1524
  {
1516
1525
    if (writekeys(&sort_param))
1517
1526
    {
1518
 
      if (errno != HA_ERR_FOUND_DUPP_KEY)
 
1527
      if (my_errno != HA_ERR_FOUND_DUPP_KEY)
1519
1528
        goto err;
1520
1529
      mi_check_print_info(param,"Duplicate key %2d for record at %10s against new record at %10s",
1521
1530
                          info->errkey+1,
1550
1559
  {
1551
1560
    mi_check_print_warning(param,
1552
1561
                           "Can't change size of indexfile, error: %d",
1553
 
                           errno);
 
1562
                           my_errno);
1554
1563
    goto err;
1555
1564
  }
1556
1565
 
1576
1585
 
1577
1586
  if (!rep_quick)
1578
1587
  {
1579
 
    internal::my_close(info->dfile,MYF(0));
 
1588
    my_close(info->dfile,MYF(0));
1580
1589
    info->dfile=new_file;
1581
1590
    info->state->data_file_length=sort_param.filepos;
1582
1591
    share->state.version=(ulong) time((time_t*) 0);     /* Force reopen */
1609
1618
    /* Replace the actual file with the temporary file */
1610
1619
    if (new_file >= 0)
1611
1620
    {
1612
 
      internal::my_close(new_file,MYF(0));
 
1621
      my_close(new_file,MYF(0));
1613
1622
      info->dfile=new_file= -1;
1614
1623
      if (change_to_newfile(share->data_file_name,MI_NAME_DEXT,
1615
1624
                            DATA_TMP_EXT, share->base.raid_chunks,
1622
1631
  if (got_error)
1623
1632
  {
1624
1633
    if (! param->error_printed)
1625
 
      mi_check_print_error(param,"%d for record at pos %s",errno,
 
1634
      mi_check_print_error(param,"%d for record at pos %s",my_errno,
1626
1635
                  llstr(sort_param.start_recpos,llbuff));
1627
1636
    if (new_file >= 0)
1628
1637
    {
1629
 
      internal::my_close(new_file,MYF(0));
 
1638
      my_close(new_file,MYF(0));
1630
1639
      my_delete(param->temp_filename, MYF(MY_WME));
1631
1640
      info->rec_cache.file=-1; /* don't flush data to new_file, it's closed */
1632
1641
    }
1684
1693
  return(0);
1685
1694
 
1686
1695
 err:
1687
 
  if (errno == HA_ERR_FOUND_DUPP_KEY)
 
1696
  if (my_errno == HA_ERR_FOUND_DUPP_KEY)
1688
1697
  {
1689
1698
    info->errkey=(int) i;                       /* This key was found */
1690
1699
    while ( i-- > 0 )
1753
1762
 
1754
1763
        /* Tell system that we want all memory for our cache */
1755
1764
 
1756
 
void lock_memory(MI_CHECK *)
 
1765
void lock_memory(MI_CHECK *param)
1757
1766
{
 
1767
#ifdef SUN_OS                           /* Key-cacheing thrases on sun 4.1 */
 
1768
  if (param->opt_lock_memory)
 
1769
  {
 
1770
    int success = mlockall(MCL_CURRENT);        /* or plock(DATLOCK); */
 
1771
    if (geteuid() == 0 && success != 0)
 
1772
      mi_check_print_warning(param,
 
1773
                             "Failed to lock memory. errno %d",my_errno);
 
1774
  }
 
1775
#else
 
1776
  (void)param;
 
1777
#endif
1758
1778
} /* lock_memory */
1759
1779
 
1760
1780
 
1761
1781
        /* Flush all changed blocks to disk */
1762
1782
 
1763
 
int flush_blocks(MI_CHECK *param, KEY_CACHE *key_cache, int file)
 
1783
int flush_blocks(MI_CHECK *param, KEY_CACHE *key_cache, File file)
1764
1784
{
1765
1785
  if (flush_key_blocks(key_cache, file, FLUSH_RELEASE))
1766
1786
  {
1767
 
    mi_check_print_error(param,"%d when trying to write bufferts",errno);
 
1787
    mi_check_print_error(param,"%d when trying to write bufferts",my_errno);
1768
1788
    return(1);
1769
1789
  }
1770
1790
  if (!param->using_global_keycache)
1779
1799
{
1780
1800
  register uint32_t key;
1781
1801
  register MI_KEYDEF *keyinfo;
1782
 
  int new_file;
 
1802
  File new_file;
1783
1803
  my_off_t index_pos[HA_MAX_POSSIBLE_KEY];
1784
1804
  uint32_t r_locks,w_locks;
1785
1805
  int old_lock;
1794
1814
    printf("- Sorting index for MyISAM-table '%s'\n",name);
1795
1815
 
1796
1816
  /* Get real path for index file */
1797
 
  internal::fn_format(param->temp_filename,name,"", MI_NAME_IEXT,2+4+32);
1798
 
  if ((new_file=my_create(internal::fn_format(param->temp_filename,param->temp_filename,
 
1817
  fn_format(param->temp_filename,name,"", MI_NAME_IEXT,2+4+32);
 
1818
  if ((new_file=my_create(fn_format(param->temp_filename,param->temp_filename,
1799
1819
                                    "", INDEX_TMP_EXT,2+4),
1800
1820
                          0,param->tmpfile_createflag,MYF(0))) <= 0)
1801
1821
  {
1837
1857
        /* Put same locks as old file */
1838
1858
  share->r_locks= share->w_locks= share->tot_locks= 0;
1839
1859
  (void) _mi_writeinfo(info,WRITEINFO_UPDATE_KEYFILE);
1840
 
  internal::my_close(share->kfile,MYF(MY_WME));
 
1860
  my_close(share->kfile,MYF(MY_WME));
1841
1861
  share->kfile = -1;
1842
 
  internal::my_close(new_file,MYF(MY_WME));
 
1862
  my_close(new_file,MYF(MY_WME));
1843
1863
  if (change_to_newfile(share->index_file_name,MI_NAME_IEXT,INDEX_TMP_EXT,0,
1844
1864
                        MYF(0)) ||
1845
1865
      mi_open_keyfile(share))
1863
1883
  return(0);
1864
1884
 
1865
1885
err:
1866
 
  internal::my_close(new_file,MYF(MY_WME));
 
1886
  my_close(new_file,MYF(MY_WME));
1867
1887
err2:
1868
1888
  my_delete(param->temp_filename,MYF(MY_WME));
1869
1889
  return(-1);
1873
1893
         /* Sort records recursive using one index */
1874
1894
 
1875
1895
static int sort_one_index(MI_CHECK *param, MI_INFO *info, MI_KEYDEF *keyinfo,
1876
 
                          my_off_t pagepos, int new_file)
 
1896
                          my_off_t pagepos, File new_file)
1877
1897
{
1878
1898
  uint32_t length,nod_flag,used_length, key_length;
1879
1899
  unsigned char *buff,*keypos,*endpos;
1924
1944
  if (my_pwrite(new_file,(unsigned char*) buff,(uint) keyinfo->block_length,
1925
1945
                new_page_pos,MYF(MY_NABP | MY_WAIT_IF_FULL)))
1926
1946
  {
1927
 
    mi_check_print_error(param,"Can't write indexblock, error: %d",errno);
 
1947
    mi_check_print_error(param,"Can't write indexblock, error: %d",my_errno);
1928
1948
    goto err;
1929
1949
  }
1930
1950
  free(buff);
1952
1972
  (void)raid_chunks;
1953
1973
  char old_filename[FN_REFLEN],new_filename[FN_REFLEN];
1954
1974
  /* Get real path to filename */
1955
 
  (void) internal::fn_format(old_filename,filename,"",old_ext,2+4+32);
 
1975
  (void) fn_format(old_filename,filename,"",old_ext,2+4+32);
1956
1976
  return my_redel(old_filename,
1957
 
                  internal::fn_format(new_filename,old_filename,"",new_ext,2+4),
 
1977
                  fn_format(new_filename,old_filename,"",new_ext,2+4),
1958
1978
                  MYF(MY_WME | MY_LINK_WARNING | MyFlags));
1959
1979
} /* change_to_newfile */
1960
1980
 
1962
1982
 
1963
1983
        /* Copy a block between two files */
1964
1984
 
1965
 
int filecopy(MI_CHECK *param, int to,int from,my_off_t start,
 
1985
int filecopy(MI_CHECK *param, File to,File from,my_off_t start,
1966
1986
             my_off_t length, const char *type)
1967
1987
{
1968
1988
  char tmp_buff[IO_SIZE],*buff;
1992
2012
  if (buff != tmp_buff)
1993
2013
    free(buff);
1994
2014
  mi_check_print_error(param,"Can't copy %s to tempfile, error %d",
1995
 
                       type,errno);
 
2015
                       type,my_errno);
1996
2016
  return(1);
1997
2017
}
1998
2018
 
2020
2040
  ulong length;
2021
2041
  ha_rows start_records;
2022
2042
  my_off_t new_header_length,del;
2023
 
  int new_file;
 
2043
  File new_file;
2024
2044
  MI_SORT_PARAM sort_param;
2025
2045
  MYISAM_SHARE *share=info->s;
2026
2046
  HA_KEYSEG *keyseg;
2072
2092
  if (!rep_quick)
2073
2093
  {
2074
2094
    /* Get real path for data file */
2075
 
    if ((new_file=my_create(internal::fn_format(param->temp_filename,
 
2095
    if ((new_file=my_create(fn_format(param->temp_filename,
2076
2096
                                      share->data_file_name, "",
2077
2097
                                      DATA_TMP_EXT, 2+4),
2078
2098
                            0,param->tmpfile_createflag,
2224
2244
        sort_param.filepos;
2225
2245
      /* Only whole records */
2226
2246
      share->state.version=(ulong) time((time_t*) 0);
2227
 
      internal::my_close(info->dfile,MYF(0));
 
2247
      my_close(info->dfile,MYF(0));
2228
2248
      info->dfile=new_file;
2229
2249
      share->data_file_type=sort_info.new_data_file_type;
2230
2250
      share->pack.header_length=(ulong) new_header_length;
2267
2287
      if (ftruncate(info->dfile, skr))
2268
2288
        mi_check_print_warning(param,
2269
2289
                               "Can't change size of datafile,  error: %d",
2270
 
                               errno);
 
2290
                               my_errno);
2271
2291
  }
2272
2292
  if (param->testflag & T_CALC_CHECKSUM)
2273
2293
    info->state->checksum=param->glob_crc;
2275
2295
  if (ftruncate(share->kfile, info->state->key_file_length))
2276
2296
    mi_check_print_warning(param,
2277
2297
                           "Can't change size of indexfile, error: %d",
2278
 
                           errno);
 
2298
                           my_errno);
2279
2299
 
2280
2300
  if (!(param->testflag & T_SILENT))
2281
2301
  {
2299
2319
    /* Replace the actual file with the temporary file */
2300
2320
    if (new_file >= 0)
2301
2321
    {
2302
 
      internal::my_close(new_file,MYF(0));
 
2322
      my_close(new_file,MYF(0));
2303
2323
      info->dfile=new_file= -1;
2304
2324
      if (change_to_newfile(share->data_file_name,MI_NAME_DEXT,
2305
2325
                            DATA_TMP_EXT, share->base.raid_chunks,
2312
2332
  if (got_error)
2313
2333
  {
2314
2334
    if (! param->error_printed)
2315
 
      mi_check_print_error(param,"%d when fixing table",errno);
 
2335
      mi_check_print_error(param,"%d when fixing table",my_errno);
2316
2336
    if (new_file >= 0)
2317
2337
    {
2318
 
      internal::my_close(new_file,MYF(0));
 
2338
      my_close(new_file,MYF(0));
2319
2339
      my_delete(param->temp_filename, MYF(MY_WME));
2320
2340
      if (info->dfile == new_file)
2321
2341
        info->dfile= -1;
2397
2417
  ulong rec_length;
2398
2418
  ha_rows start_records;
2399
2419
  my_off_t new_header_length,del;
2400
 
  int new_file;
 
2420
  File new_file;
2401
2421
  MI_SORT_PARAM *sort_param=0;
2402
2422
  MYISAM_SHARE *share=info->s;
2403
2423
  ulong   *rec_per_key_part;
2481
2501
  if (!rep_quick)
2482
2502
  {
2483
2503
    /* Get real path for data file */
2484
 
    if ((new_file=my_create(internal::fn_format(param->temp_filename,
 
2504
    if ((new_file=my_create(fn_format(param->temp_filename,
2485
2505
                                      share->data_file_name, "",
2486
2506
                                      DATA_TMP_EXT,
2487
2507
                                      2+4),
2733
2753
      Exchange the data file descriptor of the table, so that we use the
2734
2754
      new file from now on.
2735
2755
     */
2736
 
    internal::my_close(info->dfile,MYF(0));
 
2756
    my_close(info->dfile,MYF(0));
2737
2757
    info->dfile=new_file;
2738
2758
 
2739
2759
    share->data_file_type=sort_info.new_data_file_type;
2765
2785
      if (ftruncate(info->dfile, skr))
2766
2786
        mi_check_print_warning(param,
2767
2787
                               "Can't change size of datafile,  error: %d",
2768
 
                               errno);
 
2788
                               my_errno);
2769
2789
  }
2770
2790
  if (param->testflag & T_CALC_CHECKSUM)
2771
2791
    info->state->checksum=param->glob_crc;
2772
2792
 
2773
2793
  if (ftruncate(share->kfile, info->state->key_file_length))
2774
2794
    mi_check_print_warning(param,
2775
 
                           "Can't change size of indexfile, error: %d", errno);
 
2795
                           "Can't change size of indexfile, error: %d", my_errno);
2776
2796
 
2777
2797
  if (!(param->testflag & T_SILENT))
2778
2798
  {
2809
2829
    /* Replace the actual file with the temporary file */
2810
2830
    if (new_file >= 0)
2811
2831
    {
2812
 
      internal::my_close(new_file,MYF(0));
 
2832
      my_close(new_file,MYF(0));
2813
2833
      info->dfile=new_file= -1;
2814
2834
      if (change_to_newfile(share->data_file_name,MI_NAME_DEXT,
2815
2835
                            DATA_TMP_EXT, share->base.raid_chunks,
2822
2842
  if (got_error)
2823
2843
  {
2824
2844
    if (! param->error_printed)
2825
 
      mi_check_print_error(param,"%d when fixing table",errno);
 
2845
      mi_check_print_error(param,"%d when fixing table",my_errno);
2826
2846
    if (new_file >= 0)
2827
2847
    {
2828
 
      internal::my_close(new_file,MYF(0));
 
2848
      my_close(new_file,MYF(0));
2829
2849
      my_delete(param->temp_filename, MYF(MY_WME));
2830
2850
      if (info->dfile == new_file)
2831
2851
        info->dfile= -1;
3202
3222
        {
3203
3223
          mi_check_print_info(param,
3204
3224
                              "Read error for block at: %s (error: %d); Skipped",
3205
 
                              llstr(block_info.filepos,llbuff),errno);
 
3225
                              llstr(block_info.filepos,llbuff),my_errno);
3206
3226
          goto try_next;
3207
3227
        }
3208
3228
        left_length-=block_info.data_len;
3295
3315
      if (my_b_write(&info->rec_cache,sort_param->record,
3296
3316
                     share->base.pack_reclength))
3297
3317
      {
3298
 
        mi_check_print_error(param,"%d when writing to datafile",errno);
 
3318
        mi_check_print_error(param,"%d when writing to datafile",my_errno);
3299
3319
        return(1);
3300
3320
      }
3301
3321
      sort_param->filepos+=share->base.pack_reclength;
3349
3369
                                  sort_param->filepos+block_length,
3350
3370
                                  &from,&reclength,&flag))
3351
3371
        {
3352
 
          mi_check_print_error(param,"%d when writing to datafile",errno);
 
3372
          mi_check_print_error(param,"%d when writing to datafile",my_errno);
3353
3373
          return(1);
3354
3374
        }
3355
3375
        sort_param->filepos+=block_length;
3795
3815
                &create_info,
3796
3816
                HA_DONT_TOUCH_DATA))
3797
3817
  {
3798
 
    mi_check_print_error(param,"Got error %d when trying to recreate indexfile",errno);
 
3818
    mi_check_print_error(param,"Got error %d when trying to recreate indexfile",my_errno);
3799
3819
    goto end;
3800
3820
  }
3801
3821
  *org_info=mi_open(filename,O_RDWR,
3805
3825
  if (!*org_info)
3806
3826
  {
3807
3827
    mi_check_print_error(param,"Got error %d when trying to open re-created indexfile",
3808
 
                errno);
 
3828
                my_errno);
3809
3829
    goto end;
3810
3830
  }
3811
3831
  /* We are modifing */
3847
3867
    if (my_b_write(&info->rec_cache,buff,sizeof(buff)))
3848
3868
    {
3849
3869
      mi_check_print_error(sort_info->param,
3850
 
                           "%d when writing to datafile",errno);
 
3870
                           "%d when writing to datafile",my_errno);
3851
3871
      return 1;
3852
3872
    }
3853
3873
    sort_info->param->read_cache.end_of_file+=sizeof(buff);
3912
3932
      return 0;
3913
3933
  }
3914
3934
err:
3915
 
  mi_check_print_error(param,"%d when updating keyfile",errno);
 
3935
  mi_check_print_error(param,"%d when updating keyfile",my_errno);
3916
3936
  return 1;
3917
3937
}
3918
3938
 
3959
3979
  mi_extra(info,HA_EXTRA_KEYREAD,0);
3960
3980
  if (mi_rlast(info, record, info->s->base.auto_key-1))
3961
3981
  {
3962
 
    if (errno != HA_ERR_END_OF_FILE)
 
3982
    if (my_errno != HA_ERR_END_OF_FILE)
3963
3983
    {
3964
3984
      mi_extra(info,HA_EXTRA_NO_KEYREAD,0);
3965
3985
      free(mi_get_rec_buff_ptr(info, record));
3966
 
      mi_check_print_error(param,"%d when reading last record",errno);
 
3986
      mi_check_print_error(param,"%d when reading last record",my_errno);
3967
3987
      return;
3968
3988
    }
3969
3989
    if (!repair_only)