← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/myisam/ha_myisam.cc

  • Committer: Brian Aker
  • Date: 2009-11-12 16:13:04 UTC
  • mfrom: (1211.1.7 staging)
  • Revision ID: brian@gaz-20091112161304-opamiauv36fg0n6u
Rollup of Brian, Padraig, and Stewart patches.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/myisam/ha_myisam.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
 
17
 
 
18
 
#include "config.h"
19
 
#include "drizzled/internal/my_bit.h"
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
 
15
 
 
16
 
 
17
 
 
18
#include <drizzled/server_includes.h>
 
19
#include <mysys/my_bit.h>
20
20
#include "myisampack.h"
21
21
#include "ha_myisam.h"
22
22
#include "myisam_priv.h"
23
 
#include "drizzled/option.h"
24
 
#include "drizzled/internal/my_bit.h"
25
 
#include "drizzled/internal/m_string.h"
 
23
#include "mysys/my_bit.h"
26
24
#include "drizzled/util/test.h"
27
25
#include "drizzled/error.h"
28
26
#include "drizzled/errmsg_print.h"
29
27
#include "drizzled/gettext.h"
30
28
#include "drizzled/session.h"
31
 
#include "drizzled/plugin.h"
32
29
#include "drizzled/plugin/client.h"
33
30
#include "drizzled/table.h"
 
31
#include "drizzled/field/timestamp.h"
34
32
#include "drizzled/memory/multi_malloc.h"
35
 
#include "drizzled/plugin/daemon.h"
36
 
 
37
 
#include <drizzled/plugin/storage_engine.h>
38
 
 
39
 
#include <boost/algorithm/string.hpp>
40
 
#include <boost/scoped_ptr.hpp>
41
33
 
42
34
#include <string>
43
 
#include <sstream>
44
35
#include <map>
45
36
#include <algorithm>
46
 
#include <memory>
47
 
#include <boost/program_options.hpp>
48
 
#include <drizzled/module/option_map.h>
49
 
 
50
 
namespace po= boost::program_options;
51
37
 
52
38
using namespace std;
53
 
using namespace drizzled;
54
39
 
55
40
static const string engine_name("MyISAM");
56
41
 
57
 
boost::mutex THR_LOCK_myisam;
 
42
pthread_mutex_t THR_LOCK_myisam= PTHREAD_MUTEX_INITIALIZER;
58
43
 
59
 
static uint32_t myisam_key_cache_block_size= KEY_CACHE_BLOCK_SIZE;
60
 
static uint32_t myisam_key_cache_size;
61
 
static uint32_t myisam_key_cache_division_limit;
62
 
static uint32_t myisam_key_cache_age_threshold;
 
44
static uint32_t repair_threads;
 
45
static uint32_t block_size;
63
46
static uint64_t max_sort_file_size;
64
 
typedef constrained_check<size_t, SIZE_MAX, 1024, 1024> sort_buffer_constraint;
65
 
static sort_buffer_constraint sort_buffer_size;
66
 
 
67
 
void st_mi_isam_share::setKeyCache()
68
 
{
69
 
  (void)init_key_cache(&key_cache,
70
 
                       myisam_key_cache_block_size,
71
 
                       myisam_key_cache_size,
72
 
                       myisam_key_cache_division_limit, 
73
 
                       myisam_key_cache_age_threshold);
74
 
}
 
47
static uint64_t sort_buffer_size;
75
48
 
76
49
/*****************************************************************************
77
50
** MyISAM tables
83
56
  NULL
84
57
};
85
58
 
86
 
class MyisamEngine : public plugin::StorageEngine
 
59
class MyisamEngine : public drizzled::plugin::StorageEngine
87
60
{
88
 
  MyisamEngine();
89
 
  MyisamEngine(const MyisamEngine&);
90
 
  MyisamEngine& operator=(const MyisamEngine&);
91
61
public:
92
 
  explicit MyisamEngine(string name_arg) :
93
 
    plugin::StorageEngine(name_arg,
94
 
                          HTON_CAN_INDEX_BLOBS |
95
 
                          HTON_STATS_RECORDS_IS_EXACT |
96
 
                          HTON_TEMPORARY_ONLY |
97
 
                          HTON_NULL_IN_KEY |
98
 
                          HTON_HAS_RECORDS |
99
 
                          HTON_DUPLICATE_POS |
100
 
                          HTON_AUTO_PART_KEY |
101
 
                          HTON_SKIP_STORE_LOCK)
102
 
  {
103
 
  }
104
 
 
105
 
  virtual ~MyisamEngine()
106
 
  { 
107
 
    mi_panic(HA_PANIC_CLOSE);
108
 
  }
109
 
 
110
 
  virtual Cursor *create(Table &table)
111
 
  {
112
 
    return new ha_myisam(*this, table);
 
62
  MyisamEngine(string name_arg)
 
63
   : drizzled::plugin::StorageEngine(name_arg, 
 
64
                                     HTON_HAS_DATA_DICTIONARY |
 
65
                                     HTON_TEMPORARY_ONLY | 
 
66
                                     HTON_FILE_BASED ) {}
 
67
 
 
68
  ~MyisamEngine()
 
69
  { }
 
70
 
 
71
  virtual Cursor *create(TableShare &table,
 
72
                          MEM_ROOT *mem_root)
 
73
  {
 
74
    return new (mem_root) ha_myisam(*this, table);
113
75
  }
114
76
 
115
77
  const char **bas_ext() const {
116
78
    return ha_myisam_exts;
117
79
  }
118
80
 
119
 
  int doCreateTable(Session&,
 
81
  int doCreateTable(Session *, const char *table_name,
120
82
                    Table& table_arg,
121
 
                    const identifier::Table &identifier,
122
 
                    message::Table&);
123
 
 
124
 
  int doRenameTable(Session&, const identifier::Table &from, const identifier::Table &to);
125
 
 
126
 
  int doDropTable(Session&, const identifier::Table &identifier);
 
83
                    HA_CREATE_INFO& ha_create_info,
 
84
                    drizzled::message::Table&);
 
85
 
 
86
  int doRenameTable(Session*, const char *from, const char *to);
 
87
 
 
88
  int doDropTable(Session&, const string table_name);
127
89
 
128
90
  int doGetTableDefinition(Session& session,
129
 
                           const identifier::Table &identifier,
130
 
                           message::Table &table_message);
131
 
 
132
 
  uint32_t max_supported_keys()          const { return MI_MAX_KEY; }
133
 
  uint32_t max_supported_key_length()    const { return MI_MAX_KEY_LENGTH; }
134
 
  uint32_t max_supported_key_part_length() const { return MI_MAX_KEY_LENGTH; }
135
 
 
136
 
  uint32_t index_flags(enum  ha_key_alg) const
137
 
  {
138
 
    return (HA_READ_NEXT |
139
 
            HA_READ_PREV |
140
 
            HA_READ_RANGE |
141
 
            HA_READ_ORDER |
142
 
            HA_KEYREAD_ONLY);
143
 
  }
144
 
  bool doDoesTableExist(Session& session, const identifier::Table &identifier);
145
 
 
146
 
  void doGetTableIdentifiers(drizzled::CachedDirectory &directory,
147
 
                             const drizzled::identifier::Schema &schema_identifier,
148
 
                             drizzled::identifier::Table::vector &set_of_identifiers);
149
 
  bool validateCreateTableOption(const std::string &key, const std::string &state)
150
 
  {
151
 
    (void)state;
152
 
    if (boost::iequals(key, "ROW_FORMAT"))
153
 
    {
154
 
      return true;
155
 
    }
156
 
 
157
 
    return false;
158
 
  }
 
91
                           const char* path,
 
92
                           const char *db,
 
93
                           const char *table_name,
 
94
                           const bool is_tmp,
 
95
                           drizzled::message::Table *table_proto);
 
96
 
 
97
  /* Temp only engine, so do not return values. */
 
98
  void doGetTableNames(CachedDirectory &, string& , set<string>&) { };
 
99
 
159
100
};
160
101
 
161
 
void MyisamEngine::doGetTableIdentifiers(drizzled::CachedDirectory&,
162
 
                                         const drizzled::identifier::Schema&,
163
 
                                         drizzled::identifier::Table::vector&)
164
 
{
165
 
}
166
 
 
167
 
bool MyisamEngine::doDoesTableExist(Session &session, const identifier::Table &identifier)
168
 
{
169
 
  return session.getMessageCache().doesTableMessageExist(identifier);
170
 
}
171
 
 
172
 
int MyisamEngine::doGetTableDefinition(Session &session,
173
 
                                       const identifier::Table &identifier,
174
 
                                       message::Table &table_message)
175
 
{
176
 
  if (session.getMessageCache().getTableMessage(identifier, table_message))
177
 
    return EEXIST;
178
 
  return ENOENT;
 
102
int MyisamEngine::doGetTableDefinition(Session&,
 
103
                                       const char* path,
 
104
                                       const char *,
 
105
                                       const char *,
 
106
                                       const bool,
 
107
                                       drizzled::message::Table *table_proto)
 
108
{
 
109
  int error= 1;
 
110
  ProtoCache::iterator iter;
 
111
 
 
112
  pthread_mutex_lock(&proto_cache_mutex);
 
113
  iter= proto_cache.find(path);
 
114
 
 
115
  if (iter!= proto_cache.end())
 
116
  {
 
117
    if (table_proto)
 
118
      table_proto->CopyFrom(((*iter).second));
 
119
    error= EEXIST;
 
120
  }
 
121
  pthread_mutex_unlock(&proto_cache_mutex);
 
122
 
 
123
  return error;
179
124
}
180
125
 
181
126
/* 
218
163
  uint32_t i, j, recpos, minpos, fieldpos, temp_length, length;
219
164
  enum ha_base_keytype type= HA_KEYTYPE_BINARY;
220
165
  unsigned char *record;
 
166
  KEY *pos;
221
167
  MI_KEYDEF *keydef;
222
168
  MI_COLUMNDEF *recinfo, *recinfo_pos;
223
169
  HA_KEYSEG *keyseg;
224
 
  TableShare *share= table_arg->getMutableShare();
 
170
  TableShare *share= table_arg->s;
225
171
  uint32_t options= share->db_options_in_use;
226
 
  if (!(memory::multi_malloc(false,
227
 
          recinfo_out, (share->sizeFields() * 2 + 2) * sizeof(MI_COLUMNDEF),
228
 
          keydef_out, share->sizeKeys() * sizeof(MI_KEYDEF),
229
 
          &keyseg, (share->key_parts + share->sizeKeys()) * sizeof(HA_KEYSEG),
 
172
  if (!(drizzled::memory::multi_malloc(false,
 
173
          recinfo_out, (share->fields * 2 + 2) * sizeof(MI_COLUMNDEF),
 
174
          keydef_out, share->keys * sizeof(MI_KEYDEF),
 
175
          &keyseg, (share->key_parts + share->keys) * sizeof(HA_KEYSEG),
230
176
          NULL)))
231
177
    return(HA_ERR_OUT_OF_MEM);
232
178
  keydef= *keydef_out;
233
179
  recinfo= *recinfo_out;
234
 
  for (i= 0; i < share->sizeKeys(); i++)
 
180
  pos= table_arg->key_info;
 
181
  for (i= 0; i < share->keys; i++, pos++)
235
182
  {
236
 
    KeyInfo *pos= &table_arg->key_info[i];
237
183
    keydef[i].flag= ((uint16_t) pos->flags & (HA_NOSAME));
238
184
    keydef[i].key_alg= HA_KEY_ALG_BTREE;
239
185
    keydef[i].block_length= pos->block_size;
274
220
      {
275
221
        keydef[i].seg[j].null_bit= field->null_bit;
276
222
        keydef[i].seg[j].null_pos= (uint) (field->null_ptr-
277
 
                                           (unsigned char*) table_arg->getInsertRecord());
 
223
                                           (unsigned char*) table_arg->record[0]);
278
224
      }
279
225
      else
280
226
      {
286
232
        keydef[i].seg[j].flag|= HA_BLOB_PART;
287
233
        /* save number of bytes used to pack length */
288
234
        keydef[i].seg[j].bit_start= (uint) (field->pack_length() -
289
 
                                            share->sizeBlobPtr());
 
235
                                            share->blob_ptr_size);
290
236
      }
291
237
    }
292
238
    keyseg+= pos->key_parts;
293
239
  }
294
240
  if (table_arg->found_next_number_field)
295
241
    keydef[share->next_number_index].flag|= HA_AUTO_KEY;
296
 
  record= table_arg->getInsertRecord();
 
242
  record= table_arg->record[0];
297
243
  recpos= 0;
298
244
  recinfo_pos= recinfo;
299
 
 
300
 
  while (recpos < (uint) share->sizeStoredRecord())
 
245
  while (recpos < (uint) share->stored_rec_length)
301
246
  {
302
247
    Field **field, *found= 0;
303
 
    minpos= share->getRecordLength();
 
248
    minpos= share->reclength;
304
249
    length= 0;
305
250
 
306
 
    for (field= table_arg->getFields(); *field; field++)
 
251
    for (field= table_arg->field; *field; field++)
307
252
    {
308
253
      if ((fieldpos= (*field)->offset(record)) >= recpos &&
309
254
          fieldpos <= minpos)
311
256
        /* skip null fields */
312
257
        if (!(temp_length= (*field)->pack_length_in_rec()))
313
258
          continue; /* Skip null-fields */
314
 
 
315
259
        if (! found || fieldpos < minpos ||
316
260
            (fieldpos == minpos && temp_length < length))
317
261
        {
344
288
    {
345
289
      recinfo_pos->null_bit= found->null_bit;
346
290
      recinfo_pos->null_pos= (uint) (found->null_ptr -
347
 
                                     (unsigned char*) table_arg->getInsertRecord());
 
291
                                     (unsigned char*) table_arg->record[0]);
348
292
    }
349
293
    else
350
294
    {
479
423
}
480
424
 
481
425
 
 
426
extern "C" {
 
427
 
482
428
volatile int *killed_ptr(MI_CHECK *param)
483
429
{
484
430
  /* In theory Unsafe conversion, but should be ok for now */
485
 
  return (int*) (((Session *)(param->session))->getKilledPtr());
 
431
  return (int*) &(((Session *)(param->session))->killed);
486
432
}
487
433
 
488
434
void mi_check_print_error(MI_CHECK *param, const char *fmt,...)
532
478
                        const char *sfile, uint32_t sline)
533
479
{
534
480
  Session *cur_session;
 
481
  pthread_mutex_lock(&file->s->intern_lock);
535
482
  if ((cur_session= file->in_use))
536
 
  {
537
 
    errmsg_printf(error::ERROR, _("Got an error from thread_id=%"PRIu64", %s:%d"),
 
483
    errmsg_printf(ERRMSG_LVL_ERROR, _("Got an error from thread_id=%"PRIu64", %s:%d"),
538
484
                    cur_session->thread_id,
539
485
                    sfile, sline);
540
 
  }
541
486
  else
542
 
  {
543
 
    errmsg_printf(error::ERROR, _("Got an error from unknown thread, %s:%d"), sfile, sline);
544
 
  }
545
 
 
 
487
    errmsg_printf(ERRMSG_LVL_ERROR, _("Got an error from unknown thread, %s:%d"), sfile, sline);
546
488
  if (message)
547
 
    errmsg_printf(error::ERROR, "%s", message);
548
 
 
 
489
    errmsg_printf(ERRMSG_LVL_ERROR, "%s", message);
549
490
  list<Session *>::iterator it= file->s->in_use->begin();
550
491
  while (it != file->s->in_use->end())
551
492
  {
552
 
    errmsg_printf(error::ERROR, "%s", _("Unknown thread accessing table"));
 
493
    errmsg_printf(ERRMSG_LVL_ERROR, "%s", _("Unknown thread accessing table"));
553
494
    ++it;
554
495
  }
555
 
}
556
 
 
557
 
ha_myisam::ha_myisam(plugin::StorageEngine &engine_arg,
558
 
                     Table &table_arg)
 
496
  pthread_mutex_unlock(&file->s->intern_lock);
 
497
}
 
498
 
 
499
}
 
500
 
 
501
ha_myisam::ha_myisam(drizzled::plugin::StorageEngine &engine_arg,
 
502
                     TableShare &table_arg)
559
503
  : Cursor(engine_arg, table_arg),
560
 
  file(0),
561
 
  can_enable_indexes(true),
562
 
  is_ordered(true)
563
 
{ }
 
504
    file(0),
 
505
    int_table_flags(HA_NULL_IN_KEY |
 
506
                    HA_DUPLICATE_POS |
 
507
                    HA_CAN_INDEX_BLOBS |
 
508
                    HA_AUTO_PART_KEY |
 
509
                    HA_NO_TRANSACTIONS |
 
510
                    HA_HAS_RECORDS |
 
511
                    HA_STATS_RECORDS_IS_EXACT |
 
512
                    HA_NEED_READ_RANGE_BUFFER |
 
513
                    HA_MRR_CANT_SORT),
 
514
     can_enable_indexes(1)
 
515
{}
564
516
 
565
 
Cursor *ha_myisam::clone(memory::Root *mem_root)
 
517
Cursor *ha_myisam::clone(MEM_ROOT *mem_root)
566
518
{
567
519
  ha_myisam *new_handler= static_cast <ha_myisam *>(Cursor::clone(mem_root));
568
520
  if (new_handler)
576
528
}
577
529
 
578
530
/* Name is here without an extension */
579
 
int ha_myisam::doOpen(const drizzled::identifier::Table &identifier, int mode, uint32_t test_if_locked)
 
531
int ha_myisam::open(const char *name, int mode, uint32_t test_if_locked)
580
532
{
581
533
  MI_KEYDEF *keyinfo;
582
534
  MI_COLUMNDEF *recinfo= 0;
598
550
    open of a table that is in use by other threads already (if the
599
551
    MyISAM share exists already).
600
552
  */
601
 
  if (!(file= mi_open(identifier, mode, test_if_locked)))
602
 
    return (errno ? errno : -1);
 
553
  if (!(file=mi_open(name, mode, test_if_locked)))
 
554
    return (my_errno ? my_errno : -1);
603
555
 
604
 
  if (!getTable()->getShare()->getType()) /* No need to perform a check for tmp table */
 
556
  if (!table->s->tmp_table) /* No need to perform a check for tmp table */
605
557
  {
606
 
    if ((errno= table2myisam(getTable(), &keyinfo, &recinfo, &recs)))
 
558
    if ((my_errno= table2myisam(table, &keyinfo, &recinfo, &recs)))
607
559
    {
608
560
      goto err;
609
561
    }
610
 
    if (check_definition(keyinfo, recinfo, getTable()->getShare()->sizeKeys(), recs,
 
562
    if (check_definition(keyinfo, recinfo, table->s->keys, recs,
611
563
                         file->s->keyinfo, file->s->rec,
612
564
                         file->s->base.keys, file->s->base.fields, true))
613
565
    {
614
 
      errno= HA_ERR_CRASHED;
 
566
      my_errno= HA_ERR_CRASHED;
615
567
      goto err;
616
568
    }
617
569
  }
618
570
 
619
 
  assert(test_if_locked);
620
571
  if (test_if_locked & (HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_TMP_TABLE))
621
572
    mi_extra(file, HA_EXTRA_NO_WAIT_LOCK, 0);
622
573
 
623
574
  info(HA_STATUS_NO_LOCK | HA_STATUS_VARIABLE | HA_STATUS_CONST);
624
575
  if (!(test_if_locked & HA_OPEN_WAIT_IF_LOCKED))
625
576
    mi_extra(file, HA_EXTRA_WAIT_LOCK, 0);
626
 
  if (!getTable()->getShare()->db_record_offset)
627
 
    is_ordered= false;
628
 
 
 
577
  if (!table->s->db_record_offset)
 
578
    int_table_flags|=HA_REC_NOT_IN_SEQ;
629
579
 
630
580
  keys_with_parts.reset();
631
 
  for (i= 0; i < getTable()->getShare()->sizeKeys(); i++)
 
581
  for (i= 0; i < table->s->keys; i++)
632
582
  {
633
 
    getTable()->key_info[i].block_size= file->s->keyinfo[i].block_length;
 
583
    table->key_info[i].block_size= file->s->keyinfo[i].block_length;
634
584
 
635
 
    KeyPartInfo *kp= getTable()->key_info[i].key_part;
636
 
    KeyPartInfo *kp_end= kp + getTable()->key_info[i].key_parts;
 
585
    KEY_PART_INFO *kp= table->key_info[i].key_part;
 
586
    KEY_PART_INFO *kp_end= kp + table->key_info[i].key_parts;
637
587
    for (; kp != kp_end; kp++)
638
588
    {
639
589
      if (!kp->field->part_of_key.test(i))
643
593
      }
644
594
    }
645
595
  }
646
 
  errno= 0;
 
596
  my_errno= 0;
647
597
  goto end;
648
598
 err:
649
599
  this->close();
654
604
  */
655
605
  if (recinfo)
656
606
    free((unsigned char*) recinfo);
657
 
  return errno;
 
607
  return my_errno;
658
608
}
659
609
 
660
610
int ha_myisam::close(void)
664
614
  return mi_close(tmp);
665
615
}
666
616
 
667
 
int ha_myisam::doInsertRecord(unsigned char *buf)
 
617
int ha_myisam::write_row(unsigned char *buf)
668
618
{
 
619
  ha_statistic_increment(&SSV::ha_write_count);
 
620
 
669
621
  /*
670
622
    If we have an auto_increment column and we are writing a changed row
671
623
    or a new row, then update the auto_increment value in the record.
672
624
  */
673
 
  if (getTable()->next_number_field && buf == getTable()->getInsertRecord())
 
625
  if (table->next_number_field && buf == table->record[0])
674
626
  {
675
627
    int error;
676
628
    if ((error= update_auto_increment()))
700
652
  */
701
653
  if (file->dfile == -1)
702
654
  {
703
 
    errmsg_printf(error::INFO, "Retrying repair of: '%s' failed. "
704
 
                  "Please try REPAIR EXTENDED or myisamchk",
705
 
                  getTable()->getShare()->getPath());
 
655
    errmsg_printf(ERRMSG_LVL_INFO, "Retrying repair of: '%s' failed. "
 
656
                          "Please try REPAIR EXTENDED or myisamchk",
 
657
                          table->s->path.str);
706
658
    return(HA_ADMIN_FAILED);
707
659
  }
708
660
 
709
 
  param.db_name=    getTable()->getShare()->getSchemaName();
710
 
  param.table_name= getTable()->getAlias();
 
661
  param.db_name=    table->s->db.str;
 
662
  param.table_name= table->alias;
711
663
  param.tmpfile_createflag = O_RDWR | O_TRUNC;
712
664
  param.using_global_keycache = 1;
713
665
  param.session= session;
714
666
  param.out_flag= 0;
715
 
  param.sort_buffer_length= static_cast<size_t>(sort_buffer_size);
 
667
  param.sort_buffer_length= (size_t)sort_buffer_size;
716
668
  strcpy(fixed_name,file->filename);
717
669
 
718
670
  // Don't lock tables if we have used LOCK Table
719
 
  if (mi_lock_database(file, getTable()->getShare()->getType() ? F_EXTRA_LCK : F_WRLCK))
 
671
  if (mi_lock_database(file, table->s->tmp_table ? F_EXTRA_LCK : F_WRLCK))
720
672
  {
721
 
    mi_check_print_error(&param,ER(ER_CANT_LOCK),errno);
 
673
    mi_check_print_error(&param,ER(ER_CANT_LOCK),my_errno);
722
674
    return(HA_ADMIN_FAILED);
723
675
  }
724
676
 
737
689
      local_testflag|= T_STATISTICS;
738
690
      param.testflag|= T_STATISTICS;            // We get this for free
739
691
      statistics_done=1;
 
692
      if (repair_threads > 1)
 
693
      {
 
694
        char buf[40];
 
695
        /* TODO: respect myisam_repair_threads variable */
 
696
        snprintf(buf, 40, "Repair with %d threads", my_count_bits(key_map));
 
697
        session->set_proc_info(buf);
 
698
        error = mi_repair_parallel(&param, file, fixed_name,
 
699
            param.testflag & T_QUICK);
 
700
        session->set_proc_info("Repair done"); // to reset proc_info, as
 
701
                                      // it was pointing to local buffer
 
702
      }
 
703
      else
740
704
      {
741
705
        session->set_proc_info("Repair by sorting");
742
706
        error = mi_repair_by_sort(&param, file, fixed_name,
802
766
    {
803
767
      char llbuff[22],llbuff2[22];
804
768
      mi_check_print_warning(&param,"Number of rows changed from %s to %s",
805
 
                             internal::llstr(rows,llbuff),
806
 
                             internal::llstr(file->state->records,llbuff2));
 
769
                             llstr(rows,llbuff),
 
770
                             llstr(file->state->records,llbuff2));
807
771
    }
808
772
  }
809
773
  else
913
877
  }
914
878
  else if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE)
915
879
  {
916
 
    Session *session= getTable()->in_use;
917
 
    boost::scoped_ptr<MI_CHECK> param_ap(new MI_CHECK);
918
 
    MI_CHECK &param= *param_ap.get();
 
880
    Session *session=current_session;
 
881
    MI_CHECK param;
919
882
    const char *save_proc_info= session->get_proc_info();
920
883
    session->set_proc_info("Creating index");
921
884
    myisamchk_init(&param);
923
886
    param.testflag= (T_SILENT | T_REP_BY_SORT | T_QUICK |
924
887
                     T_CREATE_MISSING_KEYS);
925
888
    param.myf_rw&= ~MY_WAIT_IF_FULL;
926
 
    param.sort_buffer_length=  static_cast<size_t>(sort_buffer_size);
 
889
    param.sort_buffer_length=  (size_t)sort_buffer_size;
927
890
    param.stats_method= MI_STATS_METHOD_NULLS_NOT_EQUAL;
928
891
    if ((error= (repair(session,param,0) != HA_ADMIN_OK)) && param.retry_repair)
929
892
    {
930
 
      errmsg_printf(error::WARN, "Warning: Enabling keys got errno %d on %s.%s, retrying",
931
 
                        errno, param.db_name, param.table_name);
 
893
      errmsg_printf(ERRMSG_LVL_WARN, "Warning: Enabling keys got errno %d on %s.%s, retrying",
 
894
                        my_errno, param.db_name, param.table_name);
932
895
      /* Repairing by sort failed. Now try standard repair method. */
933
896
      param.testflag&= ~(T_REP_BY_SORT | T_QUICK);
934
897
      error= (repair(session,param,0) != HA_ADMIN_OK);
937
900
        might have been set by the first repair. They can still be seen
938
901
        with SHOW WARNINGS then.
939
902
      */
940
 
      if (not error)
 
903
      if (! error)
941
904
        session->clear_error();
942
905
    }
943
906
    info(HA_STATUS_CONST);
990
953
 
991
954
void ha_myisam::start_bulk_insert(ha_rows rows)
992
955
{
993
 
  Session *session= getTable()->in_use;
 
956
  Session *session= current_session;
994
957
  ulong size= session->variables.read_buff_size;
995
958
 
996
959
  /* don't enable row cache if too few rows */
1042
1005
 
1043
1006
 
1044
1007
 
1045
 
int ha_myisam::doUpdateRecord(const unsigned char *old_data, unsigned char *new_data)
 
1008
int ha_myisam::update_row(const unsigned char *old_data, unsigned char *new_data)
1046
1009
{
 
1010
  ha_statistic_increment(&SSV::ha_update_count);
 
1011
  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
 
1012
    table->timestamp_field->set_time();
1047
1013
  return mi_update(file,old_data,new_data);
1048
1014
}
1049
1015
 
1050
 
int ha_myisam::doDeleteRecord(const unsigned char *buf)
 
1016
int ha_myisam::delete_row(const unsigned char *buf)
1051
1017
{
 
1018
  ha_statistic_increment(&SSV::ha_delete_count);
1052
1019
  return mi_delete(file,buf);
1053
1020
}
1054
1021
 
1055
1022
 
1056
 
int ha_myisam::doStartIndexScan(uint32_t idx, bool )
 
1023
int ha_myisam::index_init(uint32_t idx, bool )
1057
1024
{
1058
1025
  active_index=idx;
1059
1026
  //in_range_read= false;
1061
1028
}
1062
1029
 
1063
1030
 
1064
 
int ha_myisam::doEndIndexScan()
 
1031
int ha_myisam::index_end()
1065
1032
{
1066
1033
  active_index=MAX_KEY;
1067
1034
  return 0;
1068
1035
}
1069
1036
 
1070
1037
 
 
1038
uint32_t ha_myisam::index_flags(uint32_t inx, uint32_t, bool) const
 
1039
{
 
1040
  return ((table_share->key_info[inx].algorithm == HA_KEY_ALG_FULLTEXT) ?
 
1041
          0 : HA_READ_NEXT | HA_READ_PREV | HA_READ_RANGE |
 
1042
          HA_READ_ORDER | HA_KEYREAD_ONLY |
 
1043
          (keys_with_parts.test(inx)?0:HA_DO_INDEX_COND_PUSHDOWN));
 
1044
}
 
1045
 
 
1046
 
1071
1047
int ha_myisam::index_read_map(unsigned char *buf, const unsigned char *key,
1072
1048
                              key_part_map keypart_map,
1073
1049
                              enum ha_rkey_function find_flag)
1074
1050
{
1075
1051
  assert(inited==INDEX);
1076
 
  ha_statistic_increment(&system_status_var::ha_read_key_count);
 
1052
  ha_statistic_increment(&SSV::ha_read_key_count);
1077
1053
  int error=mi_rkey(file, buf, active_index, key, keypart_map, find_flag);
1078
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1054
  table->status=error ? STATUS_NOT_FOUND: 0;
1079
1055
  return error;
1080
1056
}
1081
1057
 
1083
1059
                                  key_part_map keypart_map,
1084
1060
                                  enum ha_rkey_function find_flag)
1085
1061
{
1086
 
  ha_statistic_increment(&system_status_var::ha_read_key_count);
 
1062
  ha_statistic_increment(&SSV::ha_read_key_count);
1087
1063
  int error=mi_rkey(file, buf, index, key, keypart_map, find_flag);
1088
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1064
  table->status=error ? STATUS_NOT_FOUND: 0;
1089
1065
  return error;
1090
1066
}
1091
1067
 
1093
1069
                                   key_part_map keypart_map)
1094
1070
{
1095
1071
  assert(inited==INDEX);
1096
 
  ha_statistic_increment(&system_status_var::ha_read_key_count);
 
1072
  ha_statistic_increment(&SSV::ha_read_key_count);
1097
1073
  int error=mi_rkey(file, buf, active_index, key, keypart_map,
1098
1074
                    HA_READ_PREFIX_LAST);
1099
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1075
  table->status=error ? STATUS_NOT_FOUND: 0;
1100
1076
  return(error);
1101
1077
}
1102
1078
 
1103
1079
int ha_myisam::index_next(unsigned char *buf)
1104
1080
{
1105
1081
  assert(inited==INDEX);
1106
 
  ha_statistic_increment(&system_status_var::ha_read_next_count);
 
1082
  ha_statistic_increment(&SSV::ha_read_next_count);
1107
1083
  int error=mi_rnext(file,buf,active_index);
1108
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1084
  table->status=error ? STATUS_NOT_FOUND: 0;
1109
1085
  return error;
1110
1086
}
1111
1087
 
1112
1088
int ha_myisam::index_prev(unsigned char *buf)
1113
1089
{
1114
1090
  assert(inited==INDEX);
1115
 
  ha_statistic_increment(&system_status_var::ha_read_prev_count);
 
1091
  ha_statistic_increment(&SSV::ha_read_prev_count);
1116
1092
  int error=mi_rprev(file,buf, active_index);
1117
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1093
  table->status=error ? STATUS_NOT_FOUND: 0;
1118
1094
  return error;
1119
1095
}
1120
1096
 
1121
1097
int ha_myisam::index_first(unsigned char *buf)
1122
1098
{
1123
1099
  assert(inited==INDEX);
1124
 
  ha_statistic_increment(&system_status_var::ha_read_first_count);
 
1100
  ha_statistic_increment(&SSV::ha_read_first_count);
1125
1101
  int error=mi_rfirst(file, buf, active_index);
1126
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1102
  table->status=error ? STATUS_NOT_FOUND: 0;
1127
1103
  return error;
1128
1104
}
1129
1105
 
1130
1106
int ha_myisam::index_last(unsigned char *buf)
1131
1107
{
1132
1108
  assert(inited==INDEX);
1133
 
  ha_statistic_increment(&system_status_var::ha_read_last_count);
 
1109
  ha_statistic_increment(&SSV::ha_read_last_count);
1134
1110
  int error=mi_rlast(file, buf, active_index);
1135
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1111
  table->status=error ? STATUS_NOT_FOUND: 0;
1136
1112
  return error;
1137
1113
}
1138
1114
 
1142
1118
{
1143
1119
  int error;
1144
1120
  assert(inited==INDEX);
1145
 
  ha_statistic_increment(&system_status_var::ha_read_next_count);
 
1121
  ha_statistic_increment(&SSV::ha_read_next_count);
1146
1122
  do
1147
1123
  {
1148
1124
    error= mi_rnext_same(file,buf);
1149
1125
  } while (error == HA_ERR_RECORD_DELETED);
1150
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1126
  table->status=error ? STATUS_NOT_FOUND: 0;
1151
1127
  return error;
1152
1128
}
1153
1129
 
1177
1153
}
1178
1154
 
1179
1155
 
1180
 
int ha_myisam::doStartTableScan(bool scan)
 
1156
int ha_myisam::rnd_init(bool scan)
1181
1157
{
1182
1158
  if (scan)
1183
1159
    return mi_scan_init(file);
1186
1162
 
1187
1163
int ha_myisam::rnd_next(unsigned char *buf)
1188
1164
{
1189
 
  ha_statistic_increment(&system_status_var::ha_read_rnd_next_count);
 
1165
  ha_statistic_increment(&SSV::ha_read_rnd_next_count);
1190
1166
  int error=mi_scan(file, buf);
1191
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1167
  table->status=error ? STATUS_NOT_FOUND: 0;
1192
1168
  return error;
1193
1169
}
1194
1170
 
 
1171
int ha_myisam::restart_rnd_next(unsigned char *buf, unsigned char *pos)
 
1172
{
 
1173
  return rnd_pos(buf,pos);
 
1174
}
 
1175
 
1195
1176
int ha_myisam::rnd_pos(unsigned char *buf, unsigned char *pos)
1196
1177
{
1197
 
  ha_statistic_increment(&system_status_var::ha_read_rnd_count);
1198
 
  int error=mi_rrnd(file, buf, internal::my_get_ptr(pos,ref_length));
1199
 
  getTable()->status=error ? STATUS_NOT_FOUND: 0;
 
1178
  ha_statistic_increment(&SSV::ha_read_rnd_count);
 
1179
  int error=mi_rrnd(file, buf, my_get_ptr(pos,ref_length));
 
1180
  table->status=error ? STATUS_NOT_FOUND: 0;
1200
1181
  return error;
1201
1182
}
1202
1183
 
1203
1184
 
1204
1185
void ha_myisam::position(const unsigned char *)
1205
1186
{
1206
 
  internal::my_off_t row_position= mi_position(file);
1207
 
  internal::my_store_ptr(ref, ref_length, row_position);
 
1187
  my_off_t row_position= mi_position(file);
 
1188
  my_store_ptr(ref, ref_length, row_position);
1208
1189
}
1209
1190
 
1210
1191
int ha_myisam::info(uint32_t flag)
1225
1206
  }
1226
1207
  if (flag & HA_STATUS_CONST)
1227
1208
  {
1228
 
    TableShare *share= getTable()->getMutableShare();
 
1209
    TableShare *share= table->s;
1229
1210
    stats.max_data_file_length=  misam_info.max_data_file_length;
1230
1211
    stats.max_index_file_length= misam_info.max_index_file_length;
1231
1212
    stats.create_time= misam_info.create_time;
1232
1213
    ref_length= misam_info.reflength;
1233
1214
    share->db_options_in_use= misam_info.options;
1234
 
    stats.block_size= myisam_key_cache_block_size;        /* record block size */
 
1215
    stats.block_size= block_size;        /* record block size */
1235
1216
 
1236
 
    set_prefix(share->keys_in_use, share->sizeKeys());
 
1217
    /* Update share */
 
1218
    if (share->tmp_table == NO_TMP_TABLE)
 
1219
      pthread_mutex_lock(&share->mutex);
 
1220
    set_prefix(share->keys_in_use, share->keys);
1237
1221
    /*
1238
1222
     * Due to bug 394932 (32-bit solaris build failure), we need
1239
1223
     * to convert the uint64_t key_map member of the misam_info
1282
1266
    share->keys_for_keyread&= share->keys_in_use;
1283
1267
    share->db_record_offset= misam_info.record_offset;
1284
1268
    if (share->key_parts)
1285
 
      memcpy(getTable()->key_info[0].rec_per_key,
 
1269
      memcpy(table->key_info[0].rec_per_key,
1286
1270
             misam_info.rec_per_key,
1287
 
             sizeof(getTable()->key_info[0].rec_per_key)*share->key_parts);
1288
 
    assert(share->getType() != message::Table::STANDARD);
 
1271
             sizeof(table->key_info[0].rec_per_key)*share->key_parts);
 
1272
    if (share->tmp_table == NO_TMP_TABLE)
 
1273
      pthread_mutex_unlock(&share->mutex);
1289
1274
 
1290
1275
   /*
1291
1276
     Set data_file_name and index_file_name to point at the symlink value
1292
1277
     if table is symlinked (Ie;  Real name is not same as generated name)
1293
1278
   */
1294
1279
    data_file_name= index_file_name= 0;
1295
 
    internal::fn_format(name_buff, file->filename, "", MI_NAME_DEXT,
 
1280
    fn_format(name_buff, file->filename, "", MI_NAME_DEXT,
1296
1281
              MY_APPEND_EXT | MY_UNPACK_FILENAME);
1297
1282
    if (strcmp(name_buff, misam_info.data_file_name))
1298
1283
      data_file_name=misam_info.data_file_name;
1299
 
    internal::fn_format(name_buff, file->filename, "", MI_NAME_IEXT,
 
1284
    fn_format(name_buff, file->filename, "", MI_NAME_IEXT,
1300
1285
              MY_APPEND_EXT | MY_UNPACK_FILENAME);
1301
1286
    if (strcmp(name_buff, misam_info.index_file_name))
1302
1287
      index_file_name=misam_info.index_file_name;
1304
1289
  if (flag & HA_STATUS_ERRKEY)
1305
1290
  {
1306
1291
    errkey  = misam_info.errkey;
1307
 
    internal::my_store_ptr(dup_ref, ref_length, misam_info.dupp_key_pos);
 
1292
    my_store_ptr(dup_ref, ref_length, misam_info.dupp_key_pos);
1308
1293
  }
1309
1294
  if (flag & HA_STATUS_TIME)
1310
1295
    stats.update_time = misam_info.update_time;
1337
1322
  return mi_delete_all_rows(file);
1338
1323
}
1339
1324
 
1340
 
int MyisamEngine::doDropTable(Session &session,
1341
 
                              const identifier::Table &identifier)
 
1325
int MyisamEngine::doDropTable(Session&, const string table_path)
1342
1326
{
1343
 
  session.getMessageCache().removeTableMessage(identifier);
1344
 
 
1345
 
  return mi_delete_table(identifier.getPath().c_str());
 
1327
  ProtoCache::iterator iter;
 
1328
 
 
1329
  pthread_mutex_lock(&proto_cache_mutex);
 
1330
  iter= proto_cache.find(table_path.c_str());
 
1331
 
 
1332
  if (iter!= proto_cache.end())
 
1333
    proto_cache.erase(iter);
 
1334
 
 
1335
  pthread_mutex_unlock(&proto_cache_mutex);
 
1336
 
 
1337
  return mi_delete_table(table_path.c_str());
1346
1338
}
1347
1339
 
1348
1340
 
1349
1341
int ha_myisam::external_lock(Session *session, int lock_type)
1350
1342
{
1351
1343
  file->in_use= session;
1352
 
  return mi_lock_database(file, !getTable()->getShare()->getType() ?
 
1344
  return mi_lock_database(file, !table->s->tmp_table ?
1353
1345
                          lock_type : ((lock_type == F_UNLCK) ?
1354
1346
                                       F_UNLCK : F_EXTRA_LCK));
1355
1347
}
1356
1348
 
1357
 
int MyisamEngine::doCreateTable(Session &session,
 
1349
THR_LOCK_DATA **ha_myisam::store_lock(Session *,
 
1350
                                      THR_LOCK_DATA **to,
 
1351
                                      enum thr_lock_type lock_type)
 
1352
{
 
1353
  if (lock_type != TL_IGNORE && file->lock.type == TL_UNLOCK)
 
1354
    file->lock.type=lock_type;
 
1355
  *to++= &file->lock;
 
1356
 
 
1357
  return to;
 
1358
}
 
1359
 
 
1360
int MyisamEngine::doCreateTable(Session *, const char *table_name,
1358
1361
                                Table& table_arg,
1359
 
                                const identifier::Table &identifier,
1360
 
                                message::Table& create_proto)
 
1362
                                HA_CREATE_INFO& ha_create_info,
 
1363
                                drizzled::message::Table& create_proto)
1361
1364
{
1362
1365
  int error;
1363
1366
  uint32_t create_flags= 0, create_records;
1365
1368
  MI_KEYDEF *keydef;
1366
1369
  MI_COLUMNDEF *recinfo;
1367
1370
  MI_CREATE_INFO create_info;
1368
 
  TableShare *share= table_arg.getMutableShare();
 
1371
  TableShare *share= table_arg.s;
1369
1372
  uint32_t options= share->db_options_in_use;
1370
1373
  if ((error= table2myisam(&table_arg, &keydef, &recinfo, &create_records)))
1371
1374
    return(error);
1373
1376
  create_info.max_rows= create_proto.options().max_rows();
1374
1377
  create_info.reloc_rows= create_proto.options().min_rows();
1375
1378
  create_info.with_auto_increment= share->next_number_key_offset == 0;
1376
 
  create_info.auto_increment= (create_proto.options().has_auto_increment_value() ?
1377
 
                               create_proto.options().auto_increment_value() -1 :
 
1379
  create_info.auto_increment= (ha_create_info.auto_increment_value ?
 
1380
                               ha_create_info.auto_increment_value -1 :
1378
1381
                               (uint64_t) 0);
1379
1382
  create_info.data_file_length= (create_proto.options().max_rows() *
1380
1383
                                 create_proto.options().avg_row_length());
1382
1385
  create_info.index_file_name=  NULL;
1383
1386
  create_info.language= share->table_charset->number;
1384
1387
 
1385
 
  if (create_proto.type() == message::Table::TEMPORARY)
 
1388
  if (ha_create_info.options & HA_LEX_CREATE_TMP_TABLE)
1386
1389
    create_flags|= HA_CREATE_TMP_TABLE;
 
1390
  if (ha_create_info.options & HA_CREATE_KEEP_FILES)
 
1391
    create_flags|= HA_CREATE_KEEP_FILES;
1387
1392
  if (options & HA_OPTION_PACK_RECORD)
1388
1393
    create_flags|= HA_PACK_RECORD;
1389
1394
 
1390
 
  /* TODO: Check that the following internal::fn_format is really needed */
1391
 
  error= mi_create(internal::fn_format(buff, identifier.getPath().c_str(), "", "",
1392
 
                                       MY_UNPACK_FILENAME|MY_APPEND_EXT),
1393
 
                   share->sizeKeys(), keydef,
 
1395
  /* TODO: Check that the following fn_format is really needed */
 
1396
  error= mi_create(fn_format(buff, table_name, "", "",
 
1397
                             MY_UNPACK_FILENAME|MY_APPEND_EXT),
 
1398
                   share->keys, keydef,
1394
1399
                   create_records, recinfo,
1395
1400
                   0, (MI_UNIQUEDEF*) 0,
1396
1401
                   &create_info, create_flags);
1397
1402
  free((unsigned char*) recinfo);
1398
1403
 
1399
 
  session.getMessageCache().storeTableMessage(identifier, create_proto);
 
1404
  pthread_mutex_lock(&proto_cache_mutex);
 
1405
  proto_cache.insert(make_pair(table_name, create_proto));
 
1406
  pthread_mutex_unlock(&proto_cache_mutex);
1400
1407
 
1401
1408
  return error;
1402
1409
}
1403
1410
 
1404
1411
 
1405
 
int MyisamEngine::doRenameTable(Session &session, const identifier::Table &from, const identifier::Table &to)
 
1412
int MyisamEngine::doRenameTable(Session*,
 
1413
                                const char *from, const char *to)
1406
1414
{
1407
 
  session.getMessageCache().renameTableMessage(from, to);
1408
 
 
1409
 
  return mi_rename(from.getPath().c_str(), to.getPath().c_str());
 
1415
  return mi_rename(from,to);
1410
1416
}
1411
1417
 
1412
1418
 
1420
1426
  int error;
1421
1427
  unsigned char key[MI_MAX_KEY_LENGTH];
1422
1428
 
1423
 
  if (!getTable()->getShare()->next_number_key_offset)
 
1429
  if (!table->s->next_number_key_offset)
1424
1430
  {                                             // Autoincrement at key-start
1425
1431
    ha_myisam::info(HA_STATUS_AUTO);
1426
1432
    *first_value= stats.auto_increment_value;
1430
1436
  }
1431
1437
 
1432
1438
  /* it's safe to call the following if bulk_insert isn't on */
1433
 
  mi_flush_bulk_insert(file, getTable()->getShare()->next_number_index);
 
1439
  mi_flush_bulk_insert(file, table->s->next_number_index);
1434
1440
 
1435
1441
  (void) extra(HA_EXTRA_KEYREAD);
1436
 
  key_copy(key, getTable()->getInsertRecord(),
1437
 
           &getTable()->key_info[getTable()->getShare()->next_number_index],
1438
 
           getTable()->getShare()->next_number_key_offset);
1439
 
  error= mi_rkey(file, getTable()->getUpdateRecord(), (int) getTable()->getShare()->next_number_index,
1440
 
                 key, make_prev_keypart_map(getTable()->getShare()->next_number_keypart),
 
1442
  key_copy(key, table->record[0],
 
1443
           table->key_info + table->s->next_number_index,
 
1444
           table->s->next_number_key_offset);
 
1445
  error= mi_rkey(file, table->record[1], (int) table->s->next_number_index,
 
1446
                 key, make_prev_keypart_map(table->s->next_number_keypart),
1441
1447
                 HA_READ_PREFIX_LAST);
1442
1448
  if (error)
1443
1449
    nr= 1;
1444
1450
  else
1445
1451
  {
1446
 
    /* Get data from getUpdateRecord() */
1447
 
    nr= ((uint64_t) getTable()->next_number_field->
1448
 
         val_int_offset(getTable()->getShare()->rec_buff_length)+1);
 
1452
    /* Get data from record[1] */
 
1453
    nr= ((uint64_t) table->next_number_field->
 
1454
         val_int_offset(table->s->rec_buff_length)+1);
1449
1455
  }
1450
1456
  extra(HA_EXTRA_NO_KEYREAD);
1451
1457
  *first_value= nr;
1496
1502
  return (uint)file->state->checksum;
1497
1503
}
1498
1504
 
1499
 
static int myisam_init(module::Context &context)
1500
 
{ 
1501
 
  context.add(new MyisamEngine(engine_name));
1502
 
  context.registerVariable(new sys_var_constrained_value<size_t>("sort-buffer-size",
1503
 
                                                                 sort_buffer_size));
1504
 
  context.registerVariable(new sys_var_uint64_t_ptr("max_sort_file_size",
1505
 
                                                    &max_sort_file_size,
1506
 
                                                    context.getOptions()["max-sort-file-size"].as<uint64_t>()));
 
1505
static MyisamEngine *engine= NULL;
 
1506
 
 
1507
static int myisam_init(drizzled::plugin::Registry &registry)
 
1508
{
 
1509
  int error;
 
1510
  engine= new MyisamEngine(engine_name);
 
1511
  registry.add(engine);
 
1512
 
 
1513
  pthread_mutex_init(&THR_LOCK_myisam,MY_MUTEX_INIT_FAST);
 
1514
 
 
1515
  /* call ha_init_key_cache() on all key caches to init them */
 
1516
  error= init_key_cache(dflt_key_cache,
 
1517
                        (uint32_t) dflt_key_cache->param_block_size,
 
1518
                        (uint32_t) dflt_key_cache->param_buff_size,
 
1519
                        dflt_key_cache->param_division_limit, 
 
1520
                        dflt_key_cache->param_age_threshold);
 
1521
 
 
1522
  if (error == 0)
 
1523
    exit(1); /* Memory Allocation Failure */
1507
1524
 
1508
1525
  return 0;
1509
1526
}
1510
1527
 
1511
 
 
1512
 
static void init_options(drizzled::module::option_context &context)
 
1528
static int myisam_deinit(drizzled::plugin::Registry &registry)
1513
1529
{
1514
 
  context("max-sort-file-size",
1515
 
          po::value<uint64_t>(&max_sort_file_size)->default_value(INT32_MAX),
1516
 
          _("Don't use the fast sort index method to created index if the temporary file would get bigger than this."));
1517
 
  context("sort-buffer-size",
1518
 
          po::value<sort_buffer_constraint>(&sort_buffer_size)->default_value(8192*1024),
1519
 
          _("The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE."));
 
1530
  registry.remove(engine);
 
1531
  delete engine;
 
1532
 
 
1533
  pthread_mutex_destroy(&THR_LOCK_myisam);
 
1534
  end_key_cache(dflt_key_cache, 1);             // Can never fail
 
1535
 
 
1536
  return mi_panic(HA_PANIC_CLOSE);
1520
1537
}
1521
1538
 
1522
 
 
1523
 
DRIZZLE_DECLARE_PLUGIN
 
1539
static DRIZZLE_SYSVAR_UINT(block_size, block_size,
 
1540
                           PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
 
1541
                           N_("Block size to be used for MyISAM index pages."),
 
1542
                           NULL, NULL, MI_KEY_BLOCK_LENGTH, MI_MIN_KEY_BLOCK_LENGTH, 
 
1543
                           MI_MAX_KEY_BLOCK_LENGTH, 0);
 
1544
 
 
1545
static DRIZZLE_SYSVAR_UINT(repair_threads, repair_threads,
 
1546
                           PLUGIN_VAR_RQCMDARG,
 
1547
                           N_("Number of threads to use when repairing MyISAM tables. The value of "
 
1548
                              "1 disables parallel repair."),
 
1549
                           NULL, NULL, 1, 1, UINT32_MAX, 0);
 
1550
 
 
1551
static DRIZZLE_SYSVAR_ULONGLONG(max_sort_file_size, max_sort_file_size,
 
1552
                                PLUGIN_VAR_RQCMDARG,
 
1553
                                N_("Don't use the fast sort index method to created index if the temporary file would get bigger than this."),
 
1554
                                NULL, NULL, INT32_MAX, 0, UINT64_MAX, 0);
 
1555
 
 
1556
static DRIZZLE_SYSVAR_ULONGLONG(sort_buffer_size, sort_buffer_size,
 
1557
                                PLUGIN_VAR_RQCMDARG,
 
1558
                                N_("The buffer that is allocated when sorting the index when doing a REPAIR or when creating indexes with CREATE INDEX or ALTER TABLE."),
 
1559
                                NULL, NULL, 8192*1024, 1024, SIZE_MAX, 0);
 
1560
 
 
1561
extern uint32_t data_pointer_size;
 
1562
static DRIZZLE_SYSVAR_UINT(data_pointer_size, data_pointer_size,
 
1563
                           PLUGIN_VAR_RQCMDARG,
 
1564
                           N_("Default pointer size to be used for MyISAM tables."),
 
1565
                           NULL, NULL, 6, 2, 7, 0);
 
1566
 
 
1567
static struct st_mysql_sys_var* system_variables[]= {
 
1568
  DRIZZLE_SYSVAR(block_size),
 
1569
  DRIZZLE_SYSVAR(repair_threads),
 
1570
  DRIZZLE_SYSVAR(max_sort_file_size),
 
1571
  DRIZZLE_SYSVAR(sort_buffer_size),
 
1572
  DRIZZLE_SYSVAR(data_pointer_size),
 
1573
  NULL
 
1574
};
 
1575
 
 
1576
 
 
1577
drizzle_declare_plugin(myisam)
1524
1578
{
1525
 
  DRIZZLE_VERSION_ID,
1526
1579
  "MyISAM",
1527
 
  "2.0",
 
1580
  "1.0",
1528
1581
  "MySQL AB",
1529
1582
  "Default engine as of MySQL 3.23 with great performance",
1530
1583
  PLUGIN_LICENSE_GPL,
1531
1584
  myisam_init, /* Plugin Init */
1532
 
  NULL,           /* depends */
1533
 
  init_options                        /* config options                  */
 
1585
  myisam_deinit, /* Plugin Deinit */
 
1586
  NULL,                       /* status variables                */
 
1587
  system_variables,           /* system variables */
 
1588
  NULL                        /* config options                  */
1534
1589
}
1535
 
DRIZZLE_DECLARE_PLUGIN_END;
 
1590
drizzle_declare_plugin_end;