hatoku_hton.cc 61.5 KB
Newer Older
1
/* -*- mode: C; c-basic-offset: 4 -*- */
Zardosht Kasheff's avatar
Zardosht Kasheff committed
2
#define MYSQL_SERVER 1
3
#include "hatoku_defines.h"
Zardosht Kasheff's avatar
Zardosht Kasheff committed
4
#include <db.h>
Zardosht Kasheff's avatar
Zardosht Kasheff committed
5 6 7 8 9

#include "stdint.h"
#if defined(_WIN32)
#include "misc.h"
#endif
Barry Perlman's avatar
Barry Perlman committed
10
#define __STDC_FORMAT_MACROS
Zardosht Kasheff's avatar
Zardosht Kasheff committed
11
#include <inttypes.h>
Zardosht Kasheff's avatar
Zardosht Kasheff committed
12
#include "toku_os.h"
13
#include "toku_time.h"
Zardosht Kasheff's avatar
Zardosht Kasheff committed
14

Zardosht Kasheff's avatar
Zardosht Kasheff committed
15 16 17 18 19 20 21 22 23 24 25 26 27 28 29
/* We define DTRACE after mysql_priv.h in case it disabled dtrace in the main server */
#ifdef HAVE_DTRACE
#define _DTRACE_VERSION 1
#else
#endif

#include <mysql/plugin.h>
#include "hatoku_hton.h"
#include "ha_tokudb.h"

#undef PACKAGE
#undef VERSION
#undef HAVE_DTRACE
#undef _DTRACE_VERSION

30
#define TOKU_METADB_NAME "tokudb_meta"
Zardosht Kasheff's avatar
Zardosht Kasheff committed
31

32 33 34 35 36 37
typedef struct savepoint_info {
    DB_TXN* txn;
    tokudb_trx_data* trx;
    bool in_sub_stmt;
} *SP_INFO, SP_INFO_T;

Zardosht Kasheff's avatar
Zardosht Kasheff committed
38 39 40 41 42 43
static uchar *tokudb_get_key(TOKUDB_SHARE * share, size_t * length, my_bool not_used __attribute__ ((unused))) {
    *length = share->table_name_length;
    return (uchar *) share->table_name;
}

static handler *tokudb_create_handler(handlerton * hton, TABLE_SHARE * table, MEM_ROOT * mem_root);
44

45 46 47 48 49
static MYSQL_THDVAR_BOOL(commit_sync, 
    PLUGIN_VAR_THDLOCAL, 
    "sync on txn commit",
    /* check */ NULL, 
    /* update */ NULL,
Yoni Fogel's avatar
Yoni Fogel committed
50
    /* default*/ true
51
);
52
static MYSQL_THDVAR_UINT(pk_insert_mode,
53 54 55 56 57 58 59 60 61
    0,
    "set the primary key insert mode",
    NULL, 
    NULL, 
    1, // default
    0, // min?
    2, // max
    1 // blocksize
);
62
static MYSQL_THDVAR_BOOL(load_save_space,
63 64 65 66 67 68
    0,
    "if on, intial loads are slower but take less space",
    NULL, 
    NULL, 
    false
);
69
static MYSQL_THDVAR_BOOL(disable_slow_alter,
70 71 72 73 74 75
    0,
    "if on, alter tables that require copy are disabled",
    NULL, 
    NULL, 
    false
);
76
static MYSQL_THDVAR_BOOL(disable_hot_alter,
77 78 79 80 81 82
    0,
    "if on, hot alter table is disabled",
    NULL, 
    NULL, 
    false
);
83
static MYSQL_THDVAR_BOOL(create_index_online,
84 85 86 87 88 89
    0,
    "if on, create index done online",
    NULL, 
    NULL, 
    true
);
90
static MYSQL_THDVAR_BOOL(disable_prefetching,
91 92 93 94 95 96
    0,
    "if on, prefetching disabled",
    NULL, 
    NULL, 
   false
);
97
static MYSQL_THDVAR_BOOL(prelock_empty,
98 99 100 101 102 103
    0,
    "Tokudb Prelock Empty Table",
    NULL, 
    NULL, 
    true
);
104
static MYSQL_THDVAR_BOOL(log_client_errors,
105 106 107 108 109 110
    0,
    "Tokudb Log Client Errors",
    NULL, 
    NULL, 
    false
);
111
static MYSQL_THDVAR_UINT(block_size,
112 113 114 115 116 117
    0,
    "fractal tree block size",
    NULL, 
    NULL, 
    4<<20, // default
    4096,  // min
118
    ~0U,   // max
119 120
    1      // blocksize???
);
121
static MYSQL_THDVAR_UINT(read_block_size,
122 123 124 125 126 127
    0,
    "fractal tree read block size",
    NULL, 
    NULL, 
    128*1024, // default
    4096,  // min
128
    ~0U,   // max
129 130
    1      // blocksize???
);
131
static MYSQL_THDVAR_UINT(read_buf_size,
132 133 134 135 136 137 138 139 140
    0,
    "fractal tree read block size", //TODO: Is this a typo?
    NULL, 
    NULL, 
    128*1024, // default
    0,  // min
    1*1024*1024,   // max
    1      // blocksize???
);
141

142 143
static void tokudb_checkpoint_lock(THD * thd);
static void tokudb_checkpoint_unlock(THD * thd);
144

145
static void
146 147 148 149 150 151 152
tokudb_checkpoint_lock_update(
    THD* thd,
    struct st_mysql_sys_var* var,
    void* var_ptr,
    const void* save) 
{
    my_bool* val = (my_bool *) var_ptr;
Yoni Fogel's avatar
Yoni Fogel committed
153
    *val= *(my_bool *) save ? true : false;
154 155 156 157 158 159 160 161 162
    if (*val) {
        tokudb_checkpoint_lock(thd);
    }
    else {
        tokudb_checkpoint_unlock(thd);
    }
}
  
static MYSQL_THDVAR_BOOL(checkpoint_lock,
163 164 165 166 167 168
    0,
    "Tokudb Checkpoint Lock",
    NULL, 
    tokudb_checkpoint_lock_update, 
    false
);
169

170 171 172 173 174 175 176
static const char *tokudb_row_format_names[] = {
    "tokudb_uncompressed",
    "tokudb_zlib",
    "tokudb_quicklz",
    "tokudb_lzma",
    "tokudb_fast",
    "tokudb_small",
177
    "tokudb_default",
178 179 180 181 182 183 184 185 186 187
    NullS
};

static TYPELIB tokudb_row_format_typelib = {
    array_elements(tokudb_row_format_names) - 1,
    "tokudb_row_format_typelib",
    tokudb_row_format_names,
    NULL
};

188
static MYSQL_THDVAR_ENUM(row_format, PLUGIN_VAR_OPCMDARG,
189 190
                         "Specifies the compression method for a table during this session. "
                         "Possible values are TOKUDB_UNCOMPRESSED, TOKUDB_ZLIB, TOKUDB_QUICKLZ, "
191 192
                         "TOKUDB_LZMA, TOKUDB_FAST, TOKUDB_SMALL and TOKUDB_DEFAULT",
                         NULL, NULL, SRV_ROW_FORMAT_DEFAULT, &tokudb_row_format_typelib);
193 194 195 196 197 198

srv_row_format_t get_row_format(THD *thd)
{
    return (srv_row_format_t) THDVAR(thd, row_format);
}

Zardosht Kasheff's avatar
Zardosht Kasheff committed
199 200 201 202 203 204 205 206
static void tokudb_print_error(const DB_ENV * db_env, const char *db_errpfx, const char *buffer);
static void tokudb_cleanup_log_files(void);
static int tokudb_end(handlerton * hton, ha_panic_function type);
static bool tokudb_flush_logs(handlerton * hton);
static bool tokudb_show_status(handlerton * hton, THD * thd, stat_print_fn * print, enum ha_stat_type);
static int tokudb_close_connection(handlerton * hton, THD * thd);
static int tokudb_commit(handlerton * hton, THD * thd, bool all);
static int tokudb_rollback(handlerton * hton, THD * thd, bool all);
207
#if TOKU_INCLUDE_XA
208 209 210 211
static int tokudb_xa_prepare(handlerton* hton, THD* thd, bool all);
static int tokudb_xa_recover(handlerton* hton, XID*  xid_list, uint  len);
static int tokudb_commit_by_xid(handlerton* hton, XID* xid);
static int tokudb_rollback_by_xid(handlerton* hton, XID*  xid);
212
#endif
213

214
#if defined(HA_GENERAL_ONLINE) || defined(HA_INPLACE_ADD_INDEX_NO_READ_WRITE)
Zardosht Kasheff's avatar
Zardosht Kasheff committed
215
static uint tokudb_alter_table_flags(uint flags);
216
#endif
Zardosht Kasheff's avatar
Zardosht Kasheff committed
217 218 219
static int tokudb_rollback_to_savepoint(handlerton * hton, THD * thd, void *savepoint);
static int tokudb_savepoint(handlerton * hton, THD * thd, void *savepoint);
static int tokudb_release_savepoint(handlerton * hton, THD * thd, void *savepoint);
220 221
static int tokudb_discover(handlerton *hton, THD* thd, const char *db, const char *name, uchar **frmblob, size_t *frmlen);
static int tokudb_discover2(handlerton *hton, THD* thd, const char *db, const char *name, bool translate_name,uchar **frmblob, size_t *frmlen);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
222 223 224 225 226 227
handlerton *tokudb_hton;

const char *ha_tokudb_ext = ".tokudb";
char *tokudb_data_dir;
ulong tokudb_debug;
DB_ENV *db_env;
228
DB* metadata_db;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
229 230
HASH tokudb_open_tables;
pthread_mutex_t tokudb_mutex;
231
pthread_mutex_t tokudb_meta_mutex;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
232

233
static ulonglong tokudb_lock_timeout;
234 235
static ulong tokudb_cleaner_period;
static ulong tokudb_cleaner_iterations;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
236

237 238 239 240 241
#define ASSERT_MSGLEN 1024

void toku_hton_assert_fail(const char* expr_as_string, const char * fun, const char * file, int line, int caller_errno) {
    char msg[ASSERT_MSGLEN];
    if (db_env) {
242 243
        snprintf(msg, ASSERT_MSGLEN, "Handlerton: %s ", expr_as_string);
        db_env->crash(db_env, msg, fun, file, line,caller_errno);
244 245
    }
    else {
246 247 248
        snprintf(msg, ASSERT_MSGLEN, "Handlerton assertion failed, no env, %s, %d, %s, %s (errno=%d)\n", file, line, fun, expr_as_string, caller_errno);
        perror(msg);
        fflush(stderr);
249 250 251 252
    }
    abort();
}

Yoni Fogel's avatar
Yoni Fogel committed
253 254
//my_bool tokudb_shared_data = false;
static uint32_t tokudb_init_flags = 
Zardosht Kasheff's avatar
Zardosht Kasheff committed
255 256 257 258
    DB_CREATE | DB_THREAD | DB_PRIVATE | 
    DB_INIT_LOCK | 
    DB_INIT_MPOOL |
    DB_INIT_TXN | 
259
    DB_INIT_LOG |
Zardosht Kasheff's avatar
Zardosht Kasheff committed
260
    DB_RECOVER;
Yoni Fogel's avatar
Yoni Fogel committed
261 262
static uint32_t tokudb_env_flags = 0;
// static uint32_t tokudb_lock_type = DB_LOCK_DEFAULT;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
263 264 265
// static ulong tokudb_log_buffer_size = 0;
// static ulong tokudb_log_file_size = 0;
static ulonglong tokudb_cache_size = 0;
266
static ulonglong tokudb_max_lock_memory = 0;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
267
static char *tokudb_home;
268
static char *tokudb_tmp_dir;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
269 270 271 272
static char *tokudb_log_dir;
// static long tokudb_lock_scan_time = 0;
// static ulong tokudb_region_size = 0;
// static ulong tokudb_cache_parts = 1;
273
const char *tokudb_hton_name = "TokuDB";
Yoni Fogel's avatar
Yoni Fogel committed
274 275 276
static uint32_t tokudb_checkpointing_period;
uint32_t tokudb_write_status_frequency;
uint32_t tokudb_read_status_frequency;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
277
#ifdef TOKUDB_VERSION
278
char *tokudb_version = (char*) TOKUDB_VERSION;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
279
#else
280
char *tokudb_version;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
281
#endif
282
static int tokudb_fs_reserve_percent;  // file system reserve as a percentage of total disk space
Zardosht Kasheff's avatar
Zardosht Kasheff committed
283

284
#if defined(_WIN32)
Zardosht Kasheff's avatar
Zardosht Kasheff committed
285 286 287
extern "C" {
#include "ydb.h"
}
288
#endif
Zardosht Kasheff's avatar
Zardosht Kasheff committed
289

290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309
// A flag set if the handlerton is in an initialized, usable state,
// plus a reader-write lock to protect it without serializing reads.
// Since we don't have static initializers for the opaque rwlock type,
// use constructor and destructor functions to create and destroy
// the lock before and after main(), respectively.
static int tokudb_hton_initialized;
static rw_lock_t tokudb_hton_initialized_lock;

static void create_tokudb_hton_intialized_lock(void)  __attribute__((constructor));
static void destroy_tokudb_hton_initialized_lock(void) __attribute__((destructor));

static void create_tokudb_hton_intialized_lock(void)
{
    my_rwlock_init(&tokudb_hton_initialized_lock, 0);
}

static void destroy_tokudb_hton_initialized_lock(void)
{
    rwlock_destroy(&tokudb_hton_initialized_lock);
}
310

Zardosht Kasheff's avatar
Zardosht Kasheff committed
311 312
static int tokudb_init_func(void *p) {
    TOKUDB_DBUG_ENTER("tokudb_init_func");
Zardosht Kasheff's avatar
Zardosht Kasheff committed
313
    int r;
314 315 316 317 318 319 320
#if defined(_WIN64)
        r = toku_ydb_init();
        if (r) {
            printf("got error %d\n", r);
            goto error;
        }
#endif
321 322 323 324 325

    // 3938: lock the handlerton's initialized status flag for writing
    r = rw_wrlock(&tokudb_hton_initialized_lock);
    assert(r == 0);

326 327
    db_env = NULL;
    metadata_db = NULL;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
328 329 330

    tokudb_hton = (handlerton *) p;

331 332
    pthread_mutex_init(&tokudb_mutex, MY_MUTEX_INIT_FAST);
    pthread_mutex_init(&tokudb_meta_mutex, MY_MUTEX_INIT_FAST);
333
    (void) my_hash_init(&tokudb_open_tables, table_alias_charset, 32, 0, 0, (my_hash_get_key) tokudb_get_key, 0, 0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
334 335 336

    tokudb_hton->state = SHOW_OPTION_YES;
    // tokudb_hton->flags= HTON_CAN_RECREATE;  // QQQ this came from skeleton
337
    tokudb_hton->flags = HTON_CLOSE_CURSORS_AT_COMMIT;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
338 339 340 341 342 343 344 345
#ifdef DB_TYPE_TOKUDB
    tokudb_hton->db_type = DB_TYPE_TOKUDB;
#else
    tokudb_hton->db_type = DB_TYPE_UNKNOWN;
#endif

    tokudb_hton->create = tokudb_create_handler;
    tokudb_hton->close_connection = tokudb_close_connection;
346 347

    tokudb_hton->savepoint_offset = sizeof(SP_INFO_T);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
348 349 350
    tokudb_hton->savepoint_set = tokudb_savepoint;
    tokudb_hton->savepoint_rollback = tokudb_rollback_to_savepoint;
    tokudb_hton->savepoint_release = tokudb_release_savepoint;
351

352
    tokudb_hton->discover = tokudb_discover;
353 354 355
#if defined(MYSQL_HANDLERTON_INCLUDE_DISCOVER2)
    tokudb_hton->discover2 = tokudb_discover2;
#endif
Zardosht Kasheff's avatar
Zardosht Kasheff committed
356 357
    tokudb_hton->commit = tokudb_commit;
    tokudb_hton->rollback = tokudb_rollback;
358
#if TOKU_INCLUDE_XA
359 360 361 362
    tokudb_hton->prepare=tokudb_xa_prepare;
    tokudb_hton->recover=tokudb_xa_recover;
    tokudb_hton->commit_by_xid=tokudb_commit_by_xid;
    tokudb_hton->rollback_by_xid=tokudb_rollback_by_xid;
363
#endif
364

Zardosht Kasheff's avatar
Zardosht Kasheff committed
365 366 367
    tokudb_hton->panic = tokudb_end;
    tokudb_hton->flush_logs = tokudb_flush_logs;
    tokudb_hton->show_status = tokudb_show_status;
368
#if defined(HA_GENERAL_ONLINE) || defined(HA_INPLACE_ADD_INDEX_NO_READ_WRITE)
Zardosht Kasheff's avatar
Zardosht Kasheff committed
369
    tokudb_hton->alter_table_flags = tokudb_alter_table_flags;
370
#endif
Zardosht Kasheff's avatar
Zardosht Kasheff committed
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
    if (!tokudb_home)
        tokudb_home = mysql_real_data_home;
    DBUG_PRINT("info", ("tokudb_home: %s", tokudb_home));
#if 0
    if (!tokudb_log_buffer_size) { // QQQ
        tokudb_log_buffer_size = max(table_cache_size * 512, 32 * 1024);
        DBUG_PRINT("info", ("computing tokudb_log_buffer_size %ld\n", tokudb_log_buffer_size));
    }
    tokudb_log_file_size = tokudb_log_buffer_size * 4;
    tokudb_log_file_size = MY_ALIGN(tokudb_log_file_size, 1024 * 1024L);
    tokudb_log_file_size = max(tokudb_log_file_size, 10 * 1024 * 1024L);
    DBUG_PRINT("info", ("computing tokudb_log_file_size: %ld\n", tokudb_log_file_size));
#endif
    if ((r = db_env_create(&db_env, 0))) {
        DBUG_PRINT("info", ("db_env_create %d\n", r));
        goto error;
    }

    DBUG_PRINT("info", ("tokudb_env_flags: 0x%x\n", tokudb_env_flags));
    r = db_env->set_flags(db_env, tokudb_env_flags, 1);
    if (r) { // QQQ
        if (tokudb_debug & TOKUDB_DEBUG_INIT) 
            TOKUDB_TRACE("%s:WARNING: flags=%x r=%d\n", __FUNCTION__, tokudb_env_flags, r); 
        // goto error;
    }

    // config error handling
    db_env->set_errcall(db_env, tokudb_print_error);
    db_env->set_errpfx(db_env, "TokuDB");

401 402 403 404 405 406 407 408 409
    //
    // set default comparison functions
    //
    r = db_env->set_default_bt_compare(db_env, tokudb_cmp_dbt_key);
    if (r) {
        DBUG_PRINT("info", ("set_default_bt_compare%d\n", r));
        goto error; 
    }

Zardosht Kasheff's avatar
Zardosht Kasheff committed
410
    {
411
    char *tmp_dir = tokudb_tmp_dir;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
412
    char *data_dir = tokudb_data_dir;
413
    if (data_dir == 0) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
414
        data_dir = mysql_data_home;
415
    }
416 417
    if (tmp_dir == 0) {
        tmp_dir = data_dir;
418
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
419 420
    DBUG_PRINT("info", ("tokudb_data_dir: %s\n", data_dir));
    db_env->set_data_dir(db_env, data_dir);
421

422 423
    DBUG_PRINT("info", ("tokudb_tmp_dir: %s\n", tmp_dir));
    db_env->set_tmp_dir(db_env, tmp_dir);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
424 425 426 427 428 429 430
    }

    if (tokudb_log_dir) {
        DBUG_PRINT("info", ("tokudb_log_dir: %s\n", tokudb_log_dir));
        db_env->set_lg_dir(db_env, tokudb_log_dir);
    }

431
    // config the cache table size to min(1/2 of physical memory, 1/8 of the process address space)
Zardosht Kasheff's avatar
Zardosht Kasheff committed
432
    if (tokudb_cache_size == 0) {
433 434 435 436 437 438 439 440
        uint64_t physmem, maxdata;
        physmem = toku_os_get_phys_memory_size();
        tokudb_cache_size = physmem / 2;
        r = toku_os_get_max_process_data_size(&maxdata);
        if (r == 0) {
            if (tokudb_cache_size > maxdata / 8)
                tokudb_cache_size = maxdata / 8;
        }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
441 442 443
    }
    if (tokudb_cache_size) {
        DBUG_PRINT("info", ("tokudb_cache_size: %lld\n", tokudb_cache_size));
Yoni Fogel's avatar
Yoni Fogel committed
444
        r = db_env->set_cachesize(db_env, (uint32_t)(tokudb_cache_size >> 30), (uint32_t)(tokudb_cache_size % (1024L * 1024L * 1024L)), 1);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
445 446 447 448 449
        if (r) {
            DBUG_PRINT("info", ("set_cachesize %d\n", r));
            goto error; 
        }
    }
450 451 452 453 454 455 456 457 458 459 460 461
    if (tokudb_max_lock_memory == 0) {
        tokudb_max_lock_memory = tokudb_cache_size/8;
    }
    if (tokudb_max_lock_memory) {
        DBUG_PRINT("info", ("tokudb_max_lock_memory: %lld\n", tokudb_max_lock_memory));
        r = db_env->set_lk_max_memory(db_env, tokudb_max_lock_memory);
        if (r) {
            DBUG_PRINT("info", ("set_lk_max_memory %d\n", r));
            goto error; 
        }
    }
    
Yoni Fogel's avatar
Yoni Fogel committed
462
    uint32_t gbytes, bytes; int parts;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482
    r = db_env->get_cachesize(db_env, &gbytes, &bytes, &parts);
    if (r == 0) 
        if (tokudb_debug & TOKUDB_DEBUG_INIT) 
            TOKUDB_TRACE("%s:tokudb_cache_size=%lld\n", __FUNCTION__, ((unsigned long long) gbytes << 30) + bytes);

#if 0
    // QQQ config the logs
    DBUG_PRINT("info", ("tokudb_log_file_size: %ld\n", tokudb_log_file_size));
    db_env->set_lg_max(db_env, tokudb_log_file_size);
    DBUG_PRINT("info", ("tokudb_log_buffer_size: %ld\n", tokudb_log_buffer_size));
    db_env->set_lg_bsize(db_env, tokudb_log_buffer_size);
    // DBUG_PRINT("info",("tokudb_region_size: %ld\n", tokudb_region_size));
    // db_env->set_lg_regionmax(db_env, tokudb_region_size);
#endif

    // config the locks
#if 0 // QQQ no lock types yet
    DBUG_PRINT("info", ("tokudb_lock_type: 0x%lx\n", tokudb_lock_type));
    db_env->set_lk_detect(db_env, tokudb_lock_type);
#endif
483 484 485 486
    r = db_env->set_lk_max_locks(db_env, 0xffffffff);
    if (r) {
        DBUG_PRINT("info", ("tokudb_set_max_locks %d\n", r));
        goto error;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
487 488
    }

489 490 491 492 493 494
    if (db_env->set_redzone) {
        r = db_env->set_redzone(db_env, tokudb_fs_reserve_percent);
        if (r && (tokudb_debug & TOKUDB_DEBUG_INIT))
            TOKUDB_TRACE("%s:%d r=%d\n", __FUNCTION__, __LINE__, r);
    }

Zardosht Kasheff's avatar
Zardosht Kasheff committed
495 496
    if (tokudb_debug & TOKUDB_DEBUG_INIT) TOKUDB_TRACE("%s:env open:flags=%x\n", __FUNCTION__, tokudb_init_flags);

Zardosht Kasheff's avatar
Zardosht Kasheff committed
497
    r = db_env->set_generate_row_callback_for_put(db_env,generate_row_for_put);
498
    assert(!r);
499 500
    r = db_env->set_generate_row_callback_for_del(db_env,generate_row_for_del);
    assert(!r);
501
    db_env->set_update(db_env, tokudb_update_fun);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
502
    r = db_env->open(db_env, tokudb_home, tokudb_init_flags, S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
503 504 505 506 507 508 509 510

    if (tokudb_debug & TOKUDB_DEBUG_INIT) TOKUDB_TRACE("%s:env opened:return=%d\n", __FUNCTION__, r);

    if (r) {
        DBUG_PRINT("info", ("env->open %d\n", r));
        goto error;
    }

Zardosht Kasheff's avatar
Zardosht Kasheff committed
511 512
    r = db_env->checkpointing_set_period(db_env, tokudb_checkpointing_period);
    assert(!r);
513 514 515 516
    r = db_env->cleaner_set_period(db_env, tokudb_cleaner_period);
    assert(r == 0);
    r = db_env->cleaner_set_iterations(db_env, tokudb_cleaner_iterations);
    assert(r == 0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
517

518
    r = db_env->set_lock_timeout(db_env, tokudb_lock_timeout);
519 520
    assert(r == 0);

521 522 523 524 525 526 527
    r = db_create(&metadata_db, db_env, 0);
    if (r) {
        DBUG_PRINT("info", ("failed to create metadata db %d\n", r));
        goto error;
    }
    

528
    r= metadata_db->open(metadata_db, NULL, TOKU_METADB_NAME, NULL, DB_BTREE, DB_THREAD, 0);
529
    if (r) {
530 531 532 533 534 535
        if (r != ENOENT) {
            sql_print_error("Got error %d when trying to open metadata_db", r);
            goto error;
        }
        r = metadata_db->close(metadata_db,0);
        assert(r == 0);
536 537 538 539 540
        r = db_create(&metadata_db, db_env, 0);
        if (r) {
            DBUG_PRINT("info", ("failed to create metadata db %d\n", r));
            goto error;
        }
541 542

        r= metadata_db->open(metadata_db, NULL, TOKU_METADB_NAME, NULL, DB_BTREE, DB_THREAD | DB_CREATE | DB_EXCL, my_umask);
543 544 545 546 547
        if (r) {
            goto error;
        }
    }

548 549 550
    //3938: succeeded, set the init status flag and unlock
    tokudb_hton_initialized = 1;
    rw_unlock(&tokudb_hton_initialized_lock);
Yoni Fogel's avatar
Yoni Fogel committed
551
    DBUG_RETURN(false);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
552 553

error:
554
    if (metadata_db) {
555 556
        int rr = metadata_db->close(metadata_db, 0);
        assert(rr==0);
557
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
558
    if (db_env) {
559 560
        int rr= db_env->close(db_env, 0);
        assert(rr==0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
561 562
        db_env = 0;
    }
563 564 565 566

    // 3938: failed to initialized, drop the flag and lock
    tokudb_hton_initialized = 0;
    rw_unlock(&tokudb_hton_initialized_lock);
Yoni Fogel's avatar
Yoni Fogel committed
567
    DBUG_RETURN(true);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
568 569 570 571
}

static int tokudb_done_func(void *p) {
    TOKUDB_DBUG_ENTER("tokudb_done_func");
572
    my_hash_free(&tokudb_open_tables);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
573
    pthread_mutex_destroy(&tokudb_mutex);
574
    pthread_mutex_destroy(&tokudb_meta_mutex);
575
#if defined(_WIN64)
576
    toku_ydb_destroy();
577
#endif
Zardosht Kasheff's avatar
Zardosht Kasheff committed
578 579 580 581 582 583 584 585 586 587
    TOKUDB_DBUG_RETURN(0);
}

static handler *tokudb_create_handler(handlerton * hton, TABLE_SHARE * table, MEM_ROOT * mem_root) {
    return new(mem_root) ha_tokudb(hton, table);
}

int tokudb_end(handlerton * hton, ha_panic_function type) {
    TOKUDB_DBUG_ENTER("tokudb_end");
    int error = 0;
588 589 590 591 592 593 594 595
    
    // 3938: if we finalize the storage engine plugin, it is no longer
    // initialized. grab a writer lock for the duration of the
    // call, so we can drop the flag and destroy the mutexes
    // in isolation.
    rw_wrlock(&tokudb_hton_initialized_lock);
    assert(tokudb_hton_initialized);

596
    if (metadata_db) {
597 598
        int r = metadata_db->close(metadata_db, 0);
        assert(r==0);
599
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
600 601 602 603
    if (db_env) {
        if (tokudb_init_flags & DB_INIT_LOG)
            tokudb_cleanup_log_files();
        error = db_env->close(db_env, 0);       // Error is logged
604
        assert(error==0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
605 606
        db_env = NULL;
    }
607 608 609 610 611

    // 3938: drop the initialized flag and unlock
    tokudb_hton_initialized = 0;
    rw_unlock(&tokudb_hton_initialized_lock);

Zardosht Kasheff's avatar
Zardosht Kasheff committed
612 613 614 615
    TOKUDB_DBUG_RETURN(error);
}

static int tokudb_close_connection(handlerton * hton, THD * thd) {
616 617 618 619 620 621 622 623
    int error = 0;
    tokudb_trx_data* trx = NULL;
    trx = (tokudb_trx_data *) thd_data_get(thd, tokudb_hton->slot);
    if (trx && trx->checkpoint_lock_taken) {
        error = db_env->checkpointing_resume(db_env);
    }
    my_free(trx, MYF(0));
    return error;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
624 625 626 627 628 629
}

bool tokudb_flush_logs(handlerton * hton) {
    TOKUDB_DBUG_ENTER("tokudb_flush_logs");
    int error;
    bool result = 0;
Yoni Fogel's avatar
Yoni Fogel committed
630
    uint32_t curr_tokudb_checkpointing_period = 0;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
631 632 633 634 635 636 637 638 639 640 641 642 643

    //
    // get the current checkpointing period
    //
    error = db_env->checkpointing_get_period(
        db_env, 
        &curr_tokudb_checkpointing_period
        );
    if (error) {
        my_error(ER_ERROR_DURING_CHECKPOINT, MYF(0), error);
        result = 1;
        goto exit;
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
644

Zardosht Kasheff's avatar
Zardosht Kasheff committed
645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663
    //
    // if the current period is not the same as the variable, that means
    // the user has changed the period and now we need to update it
    //
    if (tokudb_checkpointing_period != curr_tokudb_checkpointing_period) {
        error = db_env->checkpointing_set_period(
            db_env, 
            tokudb_checkpointing_period
            );
        if (error) {
            my_error(ER_ERROR_DURING_CHECKPOINT, MYF(0), error);
            result = 1;
            goto exit;
        }
    }
    
    //
    // take the checkpoint
    //
Zardosht Kasheff's avatar
Zardosht Kasheff committed
664 665 666 667
    error = db_env->txn_checkpoint(db_env, 0, 0, 0);
    if (error) {
        my_error(ER_ERROR_DURING_CHECKPOINT, MYF(0), error);
        result = 1;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
668
        goto exit;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
669
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
670 671 672

    result = 0;
exit:
Zardosht Kasheff's avatar
Zardosht Kasheff committed
673 674 675
    TOKUDB_DBUG_RETURN(result);
}

676 677 678 679
uint get_pk_insert_mode(THD* thd) {
    return THDVAR(thd, pk_insert_mode);
}

680 681 682 683
bool get_load_save_space(THD* thd) {
    return (THDVAR(thd, load_save_space) != 0);
}

684 685 686 687
bool get_disable_slow_alter(THD* thd) {
    return (THDVAR(thd, disable_slow_alter) != 0);
}

688 689 690 691
bool get_disable_hot_alter(THD* thd) {
    return THDVAR(thd, disable_hot_alter) != 0;
}

692 693 694 695
bool get_create_index_online(THD* thd) {
    return (THDVAR(thd, create_index_online) != 0);
}

696 697 698 699
bool get_disable_prefetching(THD* thd) {
    return (THDVAR(thd, disable_prefetching) != 0);
}

700 701 702
bool get_prelock_empty(THD* thd) {
    return (THDVAR(thd, prelock_empty) != 0);
}
703

704 705 706 707
bool get_log_client_errors(THD* thd) {
    return (THDVAR(thd, log_client_errors) != 0);
}

708 709 710 711
uint get_tokudb_block_size(THD* thd) {
    return THDVAR(thd, block_size);
}

712 713 714 715
uint get_tokudb_read_block_size(THD* thd) {
    return THDVAR(thd, read_block_size);
}

716 717 718 719
uint get_tokudb_read_buf_size(THD* thd) {
    return THDVAR(thd, read_buf_size);
}

720 721 722 723 724 725 726 727 728 729
typedef struct txn_progress_info {
    char status[200];
    THD* thd;
} *TXN_PROGRESS_INFO;


void txn_progress_func(TOKU_TXN_PROGRESS progress, void* extra) {
    TXN_PROGRESS_INFO progress_info = (TXN_PROGRESS_INFO)extra;
    int r;
    if (progress->stalled_on_checkpoint) {
730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
        if (progress->is_commit) {
            r = sprintf(
                progress_info->status, 
                "Writing committed changes to disk, processing commit of transaction, %"PRId64" out of %"PRId64, 
                progress->entries_processed, 
                progress->entries_total
                ); 
            assert(r >= 0);
        }
        else {
            r = sprintf(
                progress_info->status, 
                "Writing committed changes to disk, processing abort of transaction, %"PRId64" out of %"PRId64, 
                progress->entries_processed, 
                progress->entries_total
                ); 
            assert(r >= 0);
        }
748 749
    }
    else {
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
        if (progress->is_commit) {
            r = sprintf(
                progress_info->status, 
                "processing commit of transaction, %"PRId64" out of %"PRId64, 
                progress->entries_processed, 
                progress->entries_total
                ); 
            assert(r >= 0);
        }
        else {
            r = sprintf(
                progress_info->status, 
                "processing abort of transaction, %"PRId64" out of %"PRId64, 
                progress->entries_processed, 
                progress->entries_total
                ); 
            assert(r >= 0);
        }
768 769 770 771 772
    }
    thd_proc_info(progress_info->thd, progress_info->status);
}


Yoni Fogel's avatar
Yoni Fogel committed
773
static void commit_txn_with_progress(DB_TXN* txn, uint32_t flags, THD* thd) {
774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
    int r;
    struct txn_progress_info info;
    info.thd = thd;
    r = txn->commit_with_progress(txn, flags, txn_progress_func, &info);
    if (r != 0) {
        sql_print_error("tried committing transaction %p and got error code %d", txn, r);
    }
    assert(r == 0);
}

static void abort_txn_with_progress(DB_TXN* txn, THD* thd) {
    int r;
    struct txn_progress_info info;
    info.thd = thd;
    r = txn->abort_with_progress(txn, txn_progress_func, &info);
    if (r != 0) {
        sql_print_error("tried aborting transaction %p and got error code %d", txn, r);
    }
    assert(r == 0);
}

Zardosht Kasheff's avatar
Zardosht Kasheff committed
795 796 797
static int tokudb_commit(handlerton * hton, THD * thd, bool all) {
    TOKUDB_DBUG_ENTER("tokudb_commit");
    DBUG_PRINT("trans", ("ending transaction %s", all ? "all" : "stmt"));
Yoni Fogel's avatar
Yoni Fogel committed
798
    uint32_t syncflag = THDVAR(thd, commit_sync) ? 0 : DB_TXN_NOSYNC;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
799 800 801
    tokudb_trx_data *trx = (tokudb_trx_data *) thd_data_get(thd, hton->slot);
    DB_TXN **txn = all ? &trx->all : &trx->stmt;
    if (*txn) {
802
        if (tokudb_debug & TOKUDB_DEBUG_TXN) {
803
            TOKUDB_TRACE("doing txn commit:%d:%p\n", all, *txn);
804
        }
805 806
        // test hook to induce a crash on a debug build
        DBUG_EXECUTE_IF("tokudb_crash_commit_before", DBUG_SUICIDE(););
807
        commit_txn_with_progress(*txn, syncflag, thd);
808 809
        // test hook to induce a crash on a debug build
        DBUG_EXECUTE_IF("tokudb_crash_commit_after", DBUG_SUICIDE(););
810
        if (*txn == trx->sp_level) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
811
            trx->sp_level = 0;
812
        }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
813
        *txn = 0;
814
        trx->sub_sp_level = NULL;
815
        trx->should_abort = false;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
816 817
    } 
    else if (tokudb_debug & TOKUDB_DEBUG_TXN) {
818
        TOKUDB_TRACE("nothing to commit %d\n", all);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
819
    }
820
    reset_stmt_progress(&trx->stmt_progress);
821
    TOKUDB_DBUG_RETURN(0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
822 823 824 825 826 827 828 829
}

static int tokudb_rollback(handlerton * hton, THD * thd, bool all) {
    TOKUDB_DBUG_ENTER("tokudb_rollback");
    DBUG_PRINT("trans", ("aborting transaction %s", all ? "all" : "stmt"));
    tokudb_trx_data *trx = (tokudb_trx_data *) thd_data_get(thd, hton->slot);
    DB_TXN **txn = all ? &trx->all : &trx->stmt;
    if (*txn) {
830
        if (tokudb_debug & TOKUDB_DEBUG_TXN) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
831
            TOKUDB_TRACE("rollback:%p\n", *txn);
832
        }
833
        abort_txn_with_progress(*txn, thd);
834 835 836 837
        if (*txn == trx->sp_level) {
            trx->sp_level = 0;
        }
        *txn = 0;
838
        trx->sub_sp_level = NULL;
839
        trx->should_abort = false;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
840 841 842
    } 
    else {
        if (tokudb_debug & TOKUDB_DEBUG_TXN) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
843
            TOKUDB_TRACE("abort0\n");
Zardosht Kasheff's avatar
Zardosht Kasheff committed
844 845
        }
    }
846
    reset_stmt_progress(&trx->stmt_progress);
847
    TOKUDB_DBUG_RETURN(0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
848 849
}

850 851
#if TOKU_INCLUDE_XA

852 853 854 855 856 857 858 859 860 861 862 863 864
static int tokudb_xa_prepare(handlerton* hton, THD* thd, bool all) {
    TOKUDB_DBUG_ENTER("tokudb_xa_prepare");
    int r = 0;
    DBUG_PRINT("trans", ("preparing transaction %s", all ? "all" : "stmt"));
    tokudb_trx_data *trx = (tokudb_trx_data *) thd_data_get(thd, hton->slot);
    DB_TXN* txn = all ? trx->all : trx->stmt;
    if (txn) {
        if (tokudb_debug & TOKUDB_DEBUG_TXN) {
            TOKUDB_TRACE("doing txn prepare:%d:%p\n", all, txn);
        }
        // a TOKU_XA_XID is identical to a MYSQL_XID
        TOKU_XA_XID thd_xid;
        thd_get_xid(thd, (MYSQL_XID*) &thd_xid);
865 866
        // test hook to induce a crash on a debug build
        DBUG_EXECUTE_IF("tokudb_crash_prepare_before", DBUG_SUICIDE(););
867
        r = txn->xa_prepare(txn, &thd_xid);
868 869
        // test hook to induce a crash on a debug build
        DBUG_EXECUTE_IF("tokudb_crash_prepare_after", DBUG_SUICIDE(););
870 871 872 873 874 875
    } 
    else if (tokudb_debug & TOKUDB_DEBUG_TXN) {
        TOKUDB_TRACE("nothing to prepare %d\n", all);
    }
    TOKUDB_DBUG_RETURN(r);
}
876

877 878 879 880
static int tokudb_xa_recover(handlerton* hton, XID*  xid_list, uint  len) {
    TOKUDB_DBUG_ENTER("tokudb_xa_recover");
    int r = 0;
    if (len == 0 || xid_list == NULL) {
881
        TOKUDB_DBUG_RETURN(0);
882 883 884 885 886 887 888 889 890
    }
    long num_returned = 0;
    r = db_env->txn_xa_recover(
        db_env,
        (TOKU_XA_XID*)xid_list,
        len,
        &num_returned,
        DB_NEXT
        );
891
    assert(r == 0);
892 893
    TOKUDB_DBUG_RETURN((int)num_returned);
}
894

895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
static int tokudb_commit_by_xid(handlerton* hton, XID* xid) {
    TOKUDB_DBUG_ENTER("tokudb_commit_by_xid");
    int r = 0;
    DB_TXN* txn = NULL;
    TOKU_XA_XID* toku_xid = (TOKU_XA_XID*)xid;

    r = db_env->get_txn_from_xid(db_env, toku_xid, &txn);
    if (r) { goto cleanup; }

    r = txn->commit(txn, 0);
    if (r) { goto cleanup; }

    r = 0;
cleanup:
    TOKUDB_DBUG_RETURN(r);
}
911

912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927
static int tokudb_rollback_by_xid(handlerton* hton, XID*  xid) {
    TOKUDB_DBUG_ENTER("tokudb_rollback_by_xid");
    int r = 0;
    DB_TXN* txn = NULL;
    TOKU_XA_XID* toku_xid = (TOKU_XA_XID*)xid;

    r = db_env->get_txn_from_xid(db_env, toku_xid, &txn);
    if (r) { goto cleanup; }

    r = txn->abort(txn);
    if (r) { goto cleanup; }

    r = 0;
cleanup:
    TOKUDB_DBUG_RETURN(r);
}
Zardosht Kasheff's avatar
Zardosht Kasheff committed
928

929 930
#endif

Zardosht Kasheff's avatar
Zardosht Kasheff committed
931 932 933
static int tokudb_savepoint(handlerton * hton, THD * thd, void *savepoint) {
    TOKUDB_DBUG_ENTER("tokudb_savepoint");
    int error;
934
    SP_INFO save_info = (SP_INFO)savepoint;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
935
    tokudb_trx_data *trx = (tokudb_trx_data *) thd_data_get(thd, hton->slot);
936 937
    if (thd->in_sub_stmt) {
        assert(trx->stmt);
938
        error = db_env->txn_begin(db_env, trx->sub_sp_level, &(save_info->txn), DB_INHERIT_ISOLATION);
939 940 941 942 943
        if (error) {
            goto cleanup;
        }
        trx->sub_sp_level = save_info->txn;
        save_info->in_sub_stmt = true;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
944
    }
945
    else {
946
        error = db_env->txn_begin(db_env, trx->sp_level, &(save_info->txn), DB_INHERIT_ISOLATION);
947 948 949 950 951 952 953 954 955
        if (error) {
            goto cleanup;
        }
        trx->sp_level = save_info->txn;
        save_info->in_sub_stmt = false;
    }
    save_info->trx = trx;
    error = 0;
cleanup:
Zardosht Kasheff's avatar
Zardosht Kasheff committed
956 957 958 959 960 961
    TOKUDB_DBUG_RETURN(error);
}

static int tokudb_rollback_to_savepoint(handlerton * hton, THD * thd, void *savepoint) {
    TOKUDB_DBUG_ENTER("tokudb_rollback_to_savepoint");
    int error;
962 963 964 965
    SP_INFO save_info = (SP_INFO)savepoint;
    DB_TXN* parent = NULL;
    DB_TXN* txn_to_rollback = save_info->txn;

Zardosht Kasheff's avatar
Zardosht Kasheff committed
966
    tokudb_trx_data *trx = (tokudb_trx_data *) thd_data_get(thd, hton->slot);
967 968 969 970 971 972 973 974
    parent = txn_to_rollback->parent;
    if (!(error = txn_to_rollback->abort(txn_to_rollback))) {
        if (save_info->in_sub_stmt) {
            trx->sub_sp_level = parent;
        }
        else {
            trx->sp_level = parent;
        }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
975 976 977 978 979 980 981 982
        error = tokudb_savepoint(hton, thd, savepoint);
    }
    TOKUDB_DBUG_RETURN(error);
}

static int tokudb_release_savepoint(handlerton * hton, THD * thd, void *savepoint) {
    TOKUDB_DBUG_ENTER("tokudb_release_savepoint");
    int error;
983 984 985 986 987

    SP_INFO save_info = (SP_INFO)savepoint;
    DB_TXN* parent = NULL;
    DB_TXN* txn_to_commit = save_info->txn;

Zardosht Kasheff's avatar
Zardosht Kasheff committed
988
    tokudb_trx_data *trx = (tokudb_trx_data *) thd_data_get(thd, hton->slot);
989 990 991 992 993 994 995 996 997
    parent = txn_to_commit->parent;
    if (!(error = txn_to_commit->commit(txn_to_commit, 0))) {
        if (save_info->in_sub_stmt) {
            trx->sub_sp_level = parent;
        }
        else {
            trx->sp_level = parent;
        }
        save_info->txn = NULL;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
998 999 1000 1001
    }
    TOKUDB_DBUG_RETURN(error);
}

1002 1003 1004 1005 1006 1007
static int tokudb_discover(handlerton *hton, THD* thd, const char *db, const char *name, uchar **frmblob, size_t *frmlen) {
    return tokudb_discover2(hton, thd, db, name, true, frmblob, frmlen);
}

static int tokudb_discover2(handlerton *hton, THD* thd, const char *db, const char *name, bool translate_name,
                            uchar **frmblob, size_t *frmlen) {
1008 1009 1010 1011 1012 1013
    TOKUDB_DBUG_ENTER("tokudb_discover");
    int error;
    DB* status_db = NULL;
    DB_TXN* txn = NULL;
    char path[FN_REFLEN + 1];
    HA_METADATA_KEY curr_key = hatoku_frm_data;
1014
    DBT key, value;    
1015 1016
    memset(&key, 0, sizeof(key));
    memset(&value, 0, sizeof(&value));
1017
    
1018 1019 1020
    error = db_env->txn_begin(db_env, 0, &txn, 0);
    if (error) { goto cleanup; }

1021
    build_table_filename(path, sizeof(path) - 1, db, name, "", translate_name ? 0 : FN_IS_TMP);
1022 1023 1024 1025 1026
    error = open_status_dictionary(&status_db, path, txn);
    if (error) { goto cleanup; }

    key.data = &curr_key;
    key.size = sizeof(curr_key);
1027 1028

    error = status_db->getf_set(
1029
        status_db, 
1030 1031
        txn,
        0,
1032
        &key, 
1033 1034
        smart_dbt_callback_verify_frm,
        &value
1035 1036 1037 1038 1039
        );
    if (error) {
        goto cleanup;
    }

1040
    *frmblob = (uchar *)value.data;
1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052
    *frmlen = value.size;

    error = 0;
cleanup:
    if (status_db) {
        status_db->close(status_db,0);
    }
    if (txn) {
        commit_txn(txn, 0);
    }
    TOKUDB_DBUG_RETURN(error);    
}
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1053

Yoni Fogel's avatar
Yoni Fogel committed
1054
static int store_dbname_tablename_size(TABLE *table, char *name, uint64_t size, THD *thd) {
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
    char *tp = strrchr(name, '/');
    assert(tp);
    char *tablename = tp + 1;
    size_t tablename_length = strlen(tablename);

    char *dp = strchr(name, '/');
    char *dbname;
    size_t dbname_length;
    if (dp == tp) {
        dbname = name;
        dbname_length = tp - dbname;
    } else {
        dbname = dp + 1;
        dbname_length = tp - dbname;
    }

    table->field[0]->store(dbname, dbname_length, system_charset_info);
    table->field[1]->store(tablename, tablename_length, system_charset_info);
    table->field[2]->store(size, false);
    int error = schema_table_store_record(thd, table);
    return error;
}

1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128
static int tokudb_dictionary_info(TABLE *table, THD *thd) {
    int error;
    DB_TXN* txn = NULL;
    DBC* tmp_cursor = NULL;
    DBT curr_key;
    DBT curr_val;
    memset(&curr_key, 0, sizeof curr_key); 
    memset(&curr_val, 0, sizeof curr_val);
    error = db_env->txn_begin(db_env, 0, &txn, DB_READ_UNCOMMITTED);
    if (error) {
        goto cleanup;
    }
    error = db_env->get_cursor_for_directory(db_env, txn, &tmp_cursor);
    if (error) {
        goto cleanup;
    }
    while (error == 0) {
        error = tmp_cursor->c_get(
            tmp_cursor, 
            &curr_key, 
            &curr_val, 
            DB_NEXT
            );
        if (!error) {
            table->field[0]->store(
                (char *)curr_key.data,
                curr_key.size,
                system_charset_info
                );
            table->field[1]->store(
                (char *)curr_val.data,
                curr_val.size,
                system_charset_info
                );
            error = schema_table_store_record(thd, table);
        }
    }
    if (error == DB_NOTFOUND) {
        error = 0;
    }
cleanup:
    if (tmp_cursor) {
        int r = tmp_cursor->c_close(tmp_cursor);
        assert(r==0);
    }
    if (txn) {
        commit_txn(txn, 0);
    }
    return error;
}

1129
static int tokudb_get_user_data_size(TABLE *table, THD *thd, bool exact) {
1130 1131 1132 1133
    int error;
    DB* curr_db = NULL;
    DB_TXN* txn = NULL;
    DBC* tmp_cursor = NULL;
1134
    DBC* tmp_table_cursor = NULL;
1135 1136
    DBT curr_key;
    DBT curr_val;
1137
    DB_TXN* tmp_txn = NULL;
1138 1139 1140 1141
    memset(&curr_key, 0, sizeof curr_key); 
    memset(&curr_val, 0, sizeof curr_val);
    pthread_mutex_lock(&tokudb_meta_mutex);

1142
    error = db_env->txn_begin(db_env, 0, &txn, DB_READ_UNCOMMITTED);
1143 1144 1145 1146 1147 1148 1149 1150
    if (error) {
        goto cleanup;
    }
    error = metadata_db->cursor(metadata_db, txn, &tmp_cursor, 0);
    if (error) {
        goto cleanup;
    }
    while (error == 0) {
1151
        tmp_txn = NULL;
1152 1153 1154 1155 1156 1157 1158
        //
        // here, and in other places, check if process has been killed
        // if so, get out of function so user is not stalled
        //
        if (thd->killed) {
            break;
        }
1159 1160 1161 1162 1163
        error = db_env->txn_begin(db_env, 0, &tmp_txn, DB_READ_UNCOMMITTED);
        if (error) {
            goto cleanup;
        }

1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174
        //
        // do not need this to be super fast, so use old simple API
        //
        error = tmp_cursor->c_get(
            tmp_cursor, 
            &curr_key, 
            &curr_val, 
            DB_NEXT
            );
        if (!error) {
            char* name = (char *)curr_key.data;
1175
            char* newname;
Yoni Fogel's avatar
Yoni Fogel committed
1176
            uint64_t curr_num_bytes = 0;
1177 1178
            DB_BTREE_STAT64 dict_stats;

1179 1180 1181
            error = db_create(&curr_db, db_env, 0);
            if (error) { goto cleanup; }

1182 1183
            newname = (char *)my_malloc(
                get_max_dict_name_path_length(name),
1184
                MYF(MY_WME|MY_ZEROFILL|MY_FAE));
1185 1186 1187

            make_name(newname, name, "main");
            
1188
            error = curr_db->open(curr_db, tmp_txn, newname, NULL, DB_BTREE, DB_THREAD, 0);
1189 1190 1191

            my_free(newname, MYF(0));

1192
            if (error == ENOENT) { error = 0; continue; }
1193 1194
            if (error) { goto cleanup; }

1195 1196 1197 1198 1199
            if (exact) {
                //
                // flatten if exact is required
                //
                uint curr_num_items = 0;                
1200
                error = curr_db->cursor(curr_db, tmp_txn, &tmp_table_cursor, 0);
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216
                if (error) {
                    tmp_table_cursor = NULL;
                    goto cleanup;
                }
                while (error != DB_NOTFOUND) {
                    error = tmp_table_cursor->c_getf_next(tmp_table_cursor, 0, smart_dbt_do_nothing, NULL);
                    if (error && error != DB_NOTFOUND) {
                        goto cleanup;
                    }
                    curr_num_items++;
                    //
                    // allow early exit if command has been killed
                    //
                    if ( (curr_num_items % 1000) == 0 && thd->killed) {
                        goto cleanup;
                    }
1217 1218 1219
                }
                error = tmp_table_cursor->c_close(tmp_table_cursor);
                assert(error==0);
1220 1221 1222
                tmp_table_cursor = NULL;
            }

1223 1224
            error = curr_db->stat64(
                curr_db, 
1225
                tmp_txn, 
1226 1227 1228 1229 1230 1231 1232 1233 1234 1235
                &dict_stats
                );
            if (error) { goto cleanup; }

            curr_num_bytes = dict_stats.bt_dsize;
            if (*(uchar *)curr_val.data) {
                //
                // in this case, we have a hidden primary key, do not
                // want to report space taken up by the hidden primary key to the user
                //
Yoni Fogel's avatar
Yoni Fogel committed
1236
                uint64_t hpk_space = TOKUDB_HIDDEN_PRIMARY_KEY_LENGTH*dict_stats.bt_ndata;
1237 1238 1239
                curr_num_bytes = (hpk_space > curr_num_bytes) ? 0 : curr_num_bytes - hpk_space;
            }
            else {
1240 1241 1242
                //
                // one infinity byte per key needs to be subtracted
                //
Yoni Fogel's avatar
Yoni Fogel committed
1243
                uint64_t inf_byte_space = dict_stats.bt_ndata;
1244 1245 1246
                curr_num_bytes = (inf_byte_space > curr_num_bytes) ? 0 : curr_num_bytes - inf_byte_space;
            }

1247
            error = store_dbname_tablename_size(table, name, curr_num_bytes, thd);
1248
            if (error) goto cleanup;
1249

1250 1251 1252 1253 1254
            {
                int r = curr_db->close(curr_db, 0);
                assert(r==0);
                curr_db = NULL;
            }
1255
        }
1256 1257 1258 1259 1260

        if (tmp_txn) {
            commit_txn(tmp_txn, 0);
            tmp_txn = NULL;
        }
1261 1262 1263 1264 1265 1266
    }

    error = 0;

cleanup:
    if (tmp_cursor) {
1267 1268
        int r = tmp_cursor->c_close(tmp_cursor);
        assert(r==0);
1269
    }
1270
    if (tmp_table_cursor) {
1271
        int r = tmp_table_cursor->c_close(tmp_table_cursor);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1272
        assert(r==0);
1273
    }
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1274 1275 1276 1277
    if (curr_db) {
        int r = curr_db->close(curr_db, 0);
        assert(r==0);
    }
1278 1279 1280
    if (tmp_txn) {
        commit_txn(tmp_txn, 0);
    }
1281
    if (txn) {
1282
        commit_txn(txn, 0);
1283 1284
    }
    if (error) {
1285
        sql_print_error("got an error %d in show_data_size\n", error);
1286 1287
    }
    pthread_mutex_unlock(&tokudb_meta_mutex);
1288 1289 1290
    return error;
}

1291
#define STATPRINT(legend, val) if (legend != NULL && val != NULL) stat_print(thd,   \
1292
                                          tokudb_hton_name, \
1293
                                          strlen(tokudb_hton_name), \
1294 1295 1296 1297 1298
                                          legend, \
                                          strlen(legend), \
                                          val, \
                                          strlen(val))

1299 1300
extern sys_var *intern_find_sys_var(const char *str, uint length, bool no_error);

1301 1302 1303
static bool tokudb_show_engine_status(THD * thd, stat_print_fn * stat_print) {
    TOKUDB_DBUG_ENTER("tokudb_show_engine_status");
    int error;
1304 1305 1306 1307 1308
    uint64_t panic;
    const int panic_string_len = 1024;
    char panic_string[panic_string_len] = {'\0'};
    uint64_t num_rows;
    fs_redzone_state redzone_state;
1309
    const int bufsiz = 1024;
1310
    char buf[bufsiz];
1311

1312
#if MYSQL_VERSION_ID < 50500
1313
    {
1314 1315 1316
        sys_var * version = intern_find_sys_var("version", 0, false);
        snprintf(buf, bufsiz, "%s", version->value_ptr(thd, (enum_var_type)0, (LEX_STRING*)NULL));
        STATPRINT("Version", buf);
1317
    }
1318
#endif
1319 1320 1321 1322 1323
    error = db_env->get_engine_status_num_rows (db_env, &num_rows);
    TOKU_ENGINE_STATUS_ROW_S mystat[num_rows];
    error = db_env->get_engine_status (db_env, mystat, num_rows, &redzone_state, &panic, panic_string, panic_string_len);

    if (strlen(panic_string)) {
1324
        STATPRINT("Environment panic string", panic_string);
1325
    }
1326
    if (error == 0) {
1327 1328 1329 1330
        if (panic) {
            snprintf(buf, bufsiz, "%" PRIu64, panic);
            STATPRINT("Environment panic", buf);
        }
1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362
        
        if(redzone_state == FS_BLOCKED) {
            STATPRINT("*** URGENT WARNING ***", "FILE SYSTEM IS COMPLETELY FULL");
            snprintf(buf, bufsiz, "FILE SYSTEM IS COMPLETELY FULL");
        }
        else if (redzone_state == FS_GREEN) {
            snprintf(buf, bufsiz, "more than %d percent of total file system space", 2*tokudb_fs_reserve_percent);
        }
        else if (redzone_state == FS_YELLOW) {
            snprintf(buf, bufsiz, "*** WARNING *** FILE SYSTEM IS GETTING FULL (less than %d percent free)", 2*tokudb_fs_reserve_percent);
        } 
        else if (redzone_state == FS_RED){
            snprintf(buf, bufsiz, "*** WARNING *** FILE SYSTEM IS GETTING VERY FULL (less than %d percent free): INSERTS ARE PROHIBITED", tokudb_fs_reserve_percent);
        }
        else {
            snprintf(buf, bufsiz, "information unavailable, unknown redzone state %d", redzone_state);
        }
        STATPRINT ("disk free space", buf);

        for (uint64_t row = 0; row < num_rows; row++) {
            switch (mystat[row].type) {
            case FS_STATE:
                snprintf(buf, bufsiz, "%"PRIu64"", mystat[row].value.num);
                break;
            case UINT64:
                snprintf(buf, bufsiz, "%"PRIu64"", mystat[row].value.num);
                break;
            case CHARSTR:
                snprintf(buf, bufsiz, "%s", mystat[row].value.str);
                break;
            case UNIXTIME:
                {
1363
                    time_t t = mystat[row].value.num;
1364
                    char tbuf[26];
1365
                    snprintf(buf, bufsiz, "%.24s\n", ctime_r(&t, tbuf));
1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
                }
                break;
            case TOKUTIME:
                {
                    double t = tokutime_to_seconds(mystat[row].value.num);
                    snprintf(buf, bufsiz, "%.6f\n", t);
                }
                break;
            default:
                snprintf(buf, bufsiz, "UNKNOWN STATUS TYPE: %d\n", mystat[row].type);
                break;                
            }
            STATPRINT(mystat[row].legend, buf);
        }  
    }  
1381 1382 1383 1384
    if (error) { my_errno = error; }
    TOKUDB_DBUG_RETURN(error);
}

1385
static void tokudb_checkpoint_lock(THD * thd) {
1386 1387
    int error;
    tokudb_trx_data* trx = NULL;
1388
    char status_msg[200]; //buffer of 200 should be a good upper bound.
1389 1390
    trx = (tokudb_trx_data *) thd_data_get(thd, tokudb_hton->slot);
    if (!trx) {
1391
        error = create_tokudb_trx_data_instance(&trx);
1392 1393 1394 1395
        //
        // can only fail due to memory allocation, so ok to assert
        //
        assert(!error);
1396 1397 1398 1399 1400 1401
        thd_data_set(thd, tokudb_hton->slot, trx);
    }
    
    if (trx->checkpoint_lock_taken) {
        goto cleanup;
    }
1402 1403 1404 1405
    //
    // This can only fail if environment is not created, which is not possible
    // in handlerton
    //
1406 1407
    sprintf(status_msg, "Trying to grab checkpointing lock.");
    thd_proc_info(thd, status_msg);
1408
    error = db_env->checkpointing_postpone(db_env);
1409
    assert(!error);
1410 1411 1412

    trx->checkpoint_lock_taken = true;
cleanup:
1413
    return;
1414 1415
}

1416
static void tokudb_checkpoint_unlock(THD * thd) {
1417
    int error;
1418
    char status_msg[200]; //buffer of 200 should be a good upper bound.
1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431
    tokudb_trx_data* trx = NULL;
    trx = (tokudb_trx_data *) thd_data_get(thd, tokudb_hton->slot);
    if (!trx) {
        error = 0;
        goto  cleanup;
    }
    if (!trx->checkpoint_lock_taken) {
        error = 0;
        goto  cleanup;
    }
    //
    // at this point, we know the checkpoint lock has been taken
    //
1432 1433
    sprintf(status_msg, "Trying to release checkpointing lock.");
    thd_proc_info(thd, status_msg);
1434
    error = db_env->checkpointing_resume(db_env);
1435
    assert(!error);
1436 1437 1438 1439

    trx->checkpoint_lock_taken = false;
    
cleanup:
1440
    return;
1441 1442
}

1443
static bool tokudb_show_status(handlerton * hton, THD * thd, stat_print_fn * stat_print, enum ha_stat_type stat_type) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1444
    switch (stat_type) {
1445 1446 1447
    case HA_ENGINE_STATUS:
        return tokudb_show_engine_status(thd, stat_print);
        break;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1448
    default:
1449
        break;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1450
    }
Yoni Fogel's avatar
Yoni Fogel committed
1451
    return false;
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1452 1453 1454 1455 1456 1457
}

static void tokudb_print_error(const DB_ENV * db_env, const char *db_errpfx, const char *buffer) {
    sql_print_error("%s:  %s", db_errpfx, buffer);
}

1458
static void tokudb_cleanup_log_files(void) {
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482
    TOKUDB_DBUG_ENTER("tokudb_cleanup_log_files");
    char **names;
    int error;

    if ((error = db_env->txn_checkpoint(db_env, 0, 0, 0)))
        my_error(ER_ERROR_DURING_CHECKPOINT, MYF(0), error);

    if ((error = db_env->log_archive(db_env, &names, 0)) != 0) {
        DBUG_PRINT("error", ("log_archive failed (error %d)", error));
        db_env->err(db_env, error, "log_archive");
        DBUG_VOID_RETURN;
    }

    if (names) {
        char **np;
        for (np = names; *np; ++np) {
#if 1
            if (tokudb_debug)
                TOKUDB_TRACE("%s:cleanup:%s\n", __FUNCTION__, *np);
#else
            my_delete(*np, MYF(MY_WME));
#endif
        }

1483
        free(names);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1484 1485 1486 1487 1488
    }

    DBUG_VOID_RETURN;
}

1489
#if defined(HA_GENERAL_ONLINE)
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1490 1491 1492 1493 1494 1495 1496 1497 1498
//
// *******NOTE*****
// If the flags HA_ONLINE_DROP_INDEX and HA_ONLINE_DROP_UNIQUE_INDEX
// are ever added, prepare_drop_index and final_drop_index will need to be modified
// so that the actual deletion of DB's is done in final_drop_index and not prepare_drop_index
//
static uint tokudb_alter_table_flags(uint flags)
{
    return (HA_ONLINE_ADD_INDEX_NO_WRITES| HA_ONLINE_DROP_INDEX_NO_WRITES |
1499
            HA_ONLINE_ADD_UNIQUE_INDEX_NO_WRITES| HA_ONLINE_DROP_UNIQUE_INDEX_NO_WRITES|HA_GENERAL_ONLINE);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1500 1501

}
1502 1503 1504 1505
#elif defined(HA_INPLACE_ADD_INDEX_NO_READ_WRITE)
static uint tokudb_alter_table_flags(uint flags) {
    return HA_INPLACE_ADD_INDEX_NO_READ_WRITE
        |  HA_INPLACE_ADD_INDEX_NO_WRITE
1506
        |  HA_INPLACE_DROP_INDEX_NO_READ_WRITE
1507 1508 1509 1510
        |  HA_INPLACE_ADD_UNIQUE_INDEX_NO_READ_WRITE
        |  HA_INPLACE_ADD_UNIQUE_INDEX_NO_WRITE
        |  HA_INPLACE_DROP_UNIQUE_INDEX_NO_READ_WRITE;
}
1511
#endif
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526


// options flags
//   PLUGIN_VAR_THDLOCAL  Variable is per-connection
//   PLUGIN_VAR_READONLY  Server variable is read only
//   PLUGIN_VAR_NOSYSVAR  Not a server variable
//   PLUGIN_VAR_NOCMDOPT  Not a command line option
//   PLUGIN_VAR_NOCMDARG  No argument for cmd line
//   PLUGIN_VAR_RQCMDARG  Argument required for cmd line
//   PLUGIN_VAR_OPCMDARG  Argument optional for cmd line
//   PLUGIN_VAR_MEMALLOC  String needs memory allocated


// system variables

1527 1528 1529 1530 1531 1532 1533
static void tokudb_lock_timeout_update(THD * thd,
        struct st_mysql_sys_var * sys_var, 
        void * var, const void * save)
{
    ulonglong * timeout = (ulonglong *) var;

    *timeout = *(const ulonglong *) save;
1534
    db_env->set_lock_timeout(db_env, *timeout);
1535
}
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1536

1537
#define DEFAULT_LOCK_TIMEOUT_MSEC 4000
1538

1539 1540
static MYSQL_SYSVAR_ULONGLONG(lock_timeout, tokudb_lock_timeout,
        0, "TokuDB lock timeout", 
1541
        NULL, tokudb_lock_timeout_update, DEFAULT_LOCK_TIMEOUT_MSEC,
1542
        0, ~0ULL, 0);
1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559

static void tokudb_cleaner_period_update(THD * thd,
        struct st_mysql_sys_var * sys_var, 
        void * var, const void * save)
{
    ulong * cleaner_period = (ulong *) var;

    *cleaner_period = *(const ulong *) save;
    int r = db_env->cleaner_set_period(db_env, *cleaner_period);
    assert(r==0);
}

#define DEFAULT_CLEANER_PERIOD 1

static MYSQL_SYSVAR_ULONG(cleaner_period, tokudb_cleaner_period,
        0, "TokuDB cleaner_period", 
        NULL, tokudb_cleaner_period_update, DEFAULT_CLEANER_PERIOD,
1560
        0, ~0UL, 0);
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572

static void tokudb_cleaner_iterations_update(THD * thd,
        struct st_mysql_sys_var * sys_var, 
        void * var, const void * save)
{
    ulong * cleaner_iterations = (ulong *) var;

    *cleaner_iterations = *(const ulong *) save;
    int r = db_env->cleaner_set_iterations(db_env, *cleaner_iterations);
    assert(r==0);
}

1573
#define DEFAULT_CLEANER_ITERATIONS 5
1574 1575 1576 1577

static MYSQL_SYSVAR_ULONG(cleaner_iterations, tokudb_cleaner_iterations,
        0, "TokuDB cleaner_iterations", 
        NULL, tokudb_cleaner_iterations_update, DEFAULT_CLEANER_ITERATIONS,
1578
        0, ~0UL, 0);
1579

1580 1581
static MYSQL_SYSVAR_ULONGLONG(cache_size, tokudb_cache_size,
        PLUGIN_VAR_READONLY, "TokuDB cache table size", NULL, NULL, 0,
1582 1583 1584
        0, ~0ULL, 0);
static MYSQL_SYSVAR_ULONGLONG(max_lock_memory, tokudb_max_lock_memory, PLUGIN_VAR_READONLY, "TokuDB max memory for locks", NULL, NULL, 0, 0, ~0ULL, 0);
static MYSQL_SYSVAR_ULONG(debug, tokudb_debug, 0, "TokuDB Debug", NULL, NULL, 0, 0, ~0UL, 0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1585 1586 1587 1588 1589 1590 1591

static MYSQL_SYSVAR_STR(log_dir, tokudb_log_dir, PLUGIN_VAR_READONLY, "TokuDB Log Directory", NULL, NULL, NULL);

static MYSQL_SYSVAR_STR(data_dir, tokudb_data_dir, PLUGIN_VAR_READONLY, "TokuDB Data Directory", NULL, NULL, NULL);

static MYSQL_SYSVAR_STR(version, tokudb_version, PLUGIN_VAR_READONLY, "TokuDB Version", NULL, NULL, NULL);

1592
static MYSQL_SYSVAR_UINT(init_flags, tokudb_init_flags, PLUGIN_VAR_READONLY, "Sets TokuDB DB_ENV->open flags", NULL, NULL, tokudb_init_flags, 0, ~0U, 0);
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1593

1594 1595 1596
static MYSQL_SYSVAR_UINT(checkpointing_period, tokudb_checkpointing_period, 0, "TokuDB Checkpointing period", NULL, NULL, 60, 0, ~0U, 0);
static MYSQL_SYSVAR_UINT(write_status_frequency, tokudb_write_status_frequency, 0, "TokuDB frequency that show processlist updates status of writes", NULL, NULL, 1000, 0, ~0U, 0);
static MYSQL_SYSVAR_UINT(read_status_frequency, tokudb_read_status_frequency, 0, "TokuDB frequency that show processlist updates status of reads", NULL, NULL, 10000, 0, ~0U, 0);
1597
static MYSQL_SYSVAR_INT(fs_reserve_percent, tokudb_fs_reserve_percent, PLUGIN_VAR_READONLY, "TokuDB file system space reserve (percent free required)", NULL, NULL, 5, 0, 100, 0);
1598
static MYSQL_SYSVAR_STR(tmp_dir, tokudb_tmp_dir, PLUGIN_VAR_READONLY, "Tokudb Tmp Dir", NULL, NULL, NULL);
1599

Zardosht Kasheff's avatar
Zardosht Kasheff committed
1600 1601
static struct st_mysql_sys_var *tokudb_system_variables[] = {
    MYSQL_SYSVAR(cache_size),
1602
    MYSQL_SYSVAR(max_lock_memory),
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1603 1604 1605 1606
    MYSQL_SYSVAR(data_dir),
    MYSQL_SYSVAR(log_dir),
    MYSQL_SYSVAR(debug),
    MYSQL_SYSVAR(commit_sync),
1607
    MYSQL_SYSVAR(lock_timeout),
1608 1609
    MYSQL_SYSVAR(cleaner_period),
    MYSQL_SYSVAR(cleaner_iterations),
1610
    MYSQL_SYSVAR(pk_insert_mode),
1611
    MYSQL_SYSVAR(load_save_space),
1612
    MYSQL_SYSVAR(disable_slow_alter),
1613
    MYSQL_SYSVAR(disable_hot_alter),
1614
    MYSQL_SYSVAR(create_index_online),
1615
    MYSQL_SYSVAR(disable_prefetching),
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1616 1617
    MYSQL_SYSVAR(version),
    MYSQL_SYSVAR(init_flags),
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1618
    MYSQL_SYSVAR(checkpointing_period),
1619
    MYSQL_SYSVAR(prelock_empty),
1620
    MYSQL_SYSVAR(log_client_errors),
1621
    MYSQL_SYSVAR(checkpoint_lock),
1622 1623
    MYSQL_SYSVAR(write_status_frequency),
    MYSQL_SYSVAR(read_status_frequency),
1624
    MYSQL_SYSVAR(fs_reserve_percent),
1625
    MYSQL_SYSVAR(tmp_dir),
1626
    MYSQL_SYSVAR(block_size),
1627
    MYSQL_SYSVAR(read_block_size),
1628
    MYSQL_SYSVAR(read_buf_size),
1629
    MYSQL_SYSVAR(row_format),
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1630 1631 1632
    NULL
};

1633 1634 1635
struct st_mysql_storage_engine tokudb_storage_engine = { MYSQL_HANDLERTON_INTERFACE_VERSION };

static ST_FIELD_INFO tokudb_user_data_field_info[] = {
1636 1637 1638
    {"database_name", 256, MYSQL_TYPE_STRING, 0, 0, NULL, SKIP_OPEN_TABLE },
    {"table_name", 256, MYSQL_TYPE_STRING, 0, 0, NULL, SKIP_OPEN_TABLE },
    {"data_size", 0, MYSQL_TYPE_LONGLONG, 0, 0, NULL, SKIP_OPEN_TABLE },
1639
    {NULL, 0, MYSQL_TYPE_NULL, 0, 0, NULL, SKIP_OPEN_TABLE}
1640 1641
};

1642 1643 1644
#if MYSQL_VERSION_ID >= 50600
static int tokudb_user_data_fill_table(THD *thd, TABLE_LIST *tables, Item *cond) {
#else
1645
static int tokudb_user_data_fill_table(THD *thd, TABLE_LIST *tables, COND *cond) {
1646
#endif
1647 1648
    int error;
    TABLE *table = tables->table;
1649 1650 1651 1652 1653 1654
    
    // 3938: Get a read lock on the status flag, since we must
    // read it before safely proceeding
    rw_rdlock(&tokudb_hton_initialized_lock);

    if (!tokudb_hton_initialized) {
1655 1656 1657
        my_error(ER_PLUGIN_IS_NOT_LOADED, MYF(0), "TokuDB");
        error = -1;
    } else {
1658
        error = tokudb_get_user_data_size(table, thd, false);
1659
    }
1660 1661 1662

    // 3938: unlock the status flag lock
    rw_unlock(&tokudb_hton_initialized_lock);
1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676
    return error;
}

static int tokudb_user_data_init(void *p) {
    ST_SCHEMA_TABLE *schema = (ST_SCHEMA_TABLE *) p;
    schema->fields_info = tokudb_user_data_field_info;
    schema->fill_table = tokudb_user_data_fill_table;
    return 0;
}

static int tokudb_user_data_done(void *p) {
    return 0;
}

1677
static struct st_mysql_information_schema tokudb_user_data_information_schema = { MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION };
1678 1679

static ST_FIELD_INFO tokudb_user_data_exact_field_info[] = {
1680 1681 1682
    {"database_name", 256, MYSQL_TYPE_STRING, 0, 0, NULL, SKIP_OPEN_TABLE },
    {"table_name", 256, MYSQL_TYPE_STRING, 0, 0, NULL, SKIP_OPEN_TABLE },
    {"data_size", 0, MYSQL_TYPE_LONGLONG, 0, 0, NULL, SKIP_OPEN_TABLE },
1683
    {NULL, 0, MYSQL_TYPE_NULL, 0, 0, NULL, SKIP_OPEN_TABLE}
1684 1685
};

1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716
static ST_FIELD_INFO tokudb_dictionary_field_info[] = {
    {"dictionary_name", 512, MYSQL_TYPE_BLOB, 0, 0, NULL, SKIP_OPEN_TABLE },
    {"internal_file_name", 512, MYSQL_TYPE_BLOB, 0, 0, NULL, SKIP_OPEN_TABLE },
    {NULL, 0, MYSQL_TYPE_NULL, 0, 0, NULL, SKIP_OPEN_TABLE}
};


#if MYSQL_VERSION_ID >= 50600
static int tokudb_dictionary_info_fill_table(THD *thd, TABLE_LIST *tables, Item *cond) {
#else
static int tokudb_dictionary_info_fill_table(THD *thd, TABLE_LIST *tables, COND *cond) {
#endif
    int error;
    TABLE *table = tables->table;

    // 3938: Get a read lock on the status flag, since we must
    // read it before safely proceeding
    rw_rdlock(&tokudb_hton_initialized_lock);

    if (!tokudb_hton_initialized) {
        my_error(ER_PLUGIN_IS_NOT_LOADED, MYF(0), "TokuDB");
        error = -1;
    } else {
        error = tokudb_dictionary_info(table, thd);
    }

    //3938: unlock the status flag lock
    rw_unlock(&tokudb_hton_initialized_lock);
    return error;
}

1717 1718 1719
#if MYSQL_VERSION_ID >= 50600
static int tokudb_user_data_exact_fill_table(THD *thd, TABLE_LIST *tables, Item *cond) {
#else
1720
static int tokudb_user_data_exact_fill_table(THD *thd, TABLE_LIST *tables, COND *cond) {
1721
#endif
1722 1723
    int error;
    TABLE *table = tables->table;
1724 1725 1726 1727 1728 1729

    // 3938: Get a read lock on the status flag, since we must
    // read it before safely proceeding
    rw_rdlock(&tokudb_hton_initialized_lock);

    if (!tokudb_hton_initialized) {
1730 1731 1732
        my_error(ER_PLUGIN_IS_NOT_LOADED, MYF(0), "TokuDB");
        error = -1;
    } else {
1733
        error = tokudb_get_user_data_size(table, thd, true);
1734
    }
1735 1736 1737

    //3938: unlock the status flag lock
    rw_unlock(&tokudb_hton_initialized_lock);
1738 1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751
    return error;
}

static int tokudb_user_data_exact_init(void *p) {
    ST_SCHEMA_TABLE *schema = (ST_SCHEMA_TABLE *) p;
    schema->fields_info = tokudb_user_data_exact_field_info;
    schema->fill_table = tokudb_user_data_exact_fill_table;
    return 0;
}

static int tokudb_user_data_exact_done(void *p) {
    return 0;
}

1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
static int tokudb_dictionary_info_init(void *p) {
    ST_SCHEMA_TABLE *schema = (ST_SCHEMA_TABLE *) p;
    schema->fields_info = tokudb_dictionary_field_info;
    schema->fill_table = tokudb_dictionary_info_fill_table;
    return 0;
}

static int tokudb_dictionary_info_done(void *p) {
    return 0;
}

1763
static struct st_mysql_information_schema tokudb_user_data_exact_information_schema = { MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION };
1764 1765

enum { TOKUDB_PLUGIN_VERSION = 0x0400 };
1766
#define TOKUDB_PLUGIN_VERSION_STR "1024"
1767 1768 1769

mysql_declare_plugin(tokudb) 
{
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1770
    MYSQL_STORAGE_ENGINE_PLUGIN, 
1771
    &tokudb_storage_engine, 
1772
    tokudb_hton_name, 
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1773
    "Tokutek Inc", 
1774
    "Tokutek TokuDB Storage Engine with Fractal Tree(tm) Technology",
1775
    PLUGIN_LICENSE_PROPRIETARY,
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1776 1777
    tokudb_init_func,          /* plugin init */
    tokudb_done_func,          /* plugin deinit */
1778
    TOKUDB_PLUGIN_VERSION,     /* 4.0.0 */
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1779 1780
    NULL,                      /* status variables */
    tokudb_system_variables,   /* system variables */
1781 1782 1783 1784
    NULL,                      /* config options */
#if MYSQL_VERSION_ID >= 50521
    0,                         /* flags */
#endif
1785 1786 1787 1788 1789 1790 1791
},
{
    MYSQL_INFORMATION_SCHEMA_PLUGIN, 
    &tokudb_user_data_information_schema, 
    "TokuDB_user_data", 
    "Tokutek Inc", 
    "Tokutek TokuDB Storage Engine with Fractal Tree(tm) Technology",
1792
    PLUGIN_LICENSE_PROPRIETARY,
1793 1794 1795 1796 1797
    tokudb_user_data_init,     /* plugin init */
    tokudb_user_data_done,     /* plugin deinit */
    TOKUDB_PLUGIN_VERSION,     /* 4.0.0 */
    NULL,                      /* status variables */
    NULL,                      /* system variables */
1798 1799 1800 1801
    NULL,                      /* config options */
#if MYSQL_VERSION_ID >= 50521
    0,                         /* flags */
#endif
1802 1803 1804 1805 1806 1807 1808
},
{
    MYSQL_INFORMATION_SCHEMA_PLUGIN, 
    &tokudb_user_data_exact_information_schema, 
    "TokuDB_user_data_exact", 
    "Tokutek Inc", 
    "Tokutek TokuDB Storage Engine with Fractal Tree(tm) Technology",
1809
    PLUGIN_LICENSE_PROPRIETARY,
1810 1811 1812 1813 1814
    tokudb_user_data_exact_init,     /* plugin init */
    tokudb_user_data_exact_done,     /* plugin deinit */
    TOKUDB_PLUGIN_VERSION,     /* 4.0.0 */
    NULL,                      /* status variables */
    NULL,                      /* system variables */
1815 1816 1817 1818
    NULL,                      /* config options */
#if MYSQL_VERSION_ID >= 50521
    0,                         /* flags */
#endif
1819 1820 1821 1822
},
{
    MYSQL_INFORMATION_SCHEMA_PLUGIN, 
    &tokudb_user_data_exact_information_schema, 
1823
    "TokuDB_file_map", 
1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835
    "Tokutek Inc", 
    "Tokutek TokuDB Storage Engine with Fractal Tree(tm) Technology",
    PLUGIN_LICENSE_PROPRIETARY,
    tokudb_dictionary_info_init,     /* plugin init */
    tokudb_dictionary_info_done,     /* plugin deinit */
    TOKUDB_PLUGIN_VERSION,     /* 4.0.0 */
    NULL,                      /* status variables */
    NULL,                      /* system variables */
    NULL,                      /* config options */
#if MYSQL_VERSION_ID >= 50521
    0,                         /* flags */
#endif
Zardosht Kasheff's avatar
Zardosht Kasheff committed
1836 1837 1838
}
mysql_declare_plugin_end;

1839 1840 1841 1842 1843 1844
#ifdef MARIA_PLUGIN_INTERFACE_VERSION

maria_declare_plugin(tokudb) 
{
    MYSQL_STORAGE_ENGINE_PLUGIN, 
    &tokudb_storage_engine, 
1845
    tokudb_hton_name, 
1846 1847
    "Tokutek Inc", 
    "Tokutek TokuDB Storage Engine with Fractal Tree(tm) Technology",
1848
    PLUGIN_LICENSE_PROPRIETARY,
1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862
    tokudb_init_func,          /* plugin init */
    tokudb_done_func,          /* plugin deinit */
    TOKUDB_PLUGIN_VERSION,     /* 4.0.0 */
    NULL,                      /* status variables */
    tokudb_system_variables,   /* system variables */
    TOKUDB_PLUGIN_VERSION_STR, /* string version */
    MariaDB_PLUGIN_MATURITY_STABLE /* maturity */
},
{
    MYSQL_INFORMATION_SCHEMA_PLUGIN, 
    &tokudb_user_data_information_schema, 
    "TokuDB_user_data", 
    "Tokutek Inc", 
    "Tokutek TokuDB Storage Engine with Fractal Tree(tm) Technology",
1863
    PLUGIN_LICENSE_PROPRIETARY,
1864 1865 1866 1867 1868 1869 1870 1871 1872 1873 1874 1875 1876 1877
    tokudb_user_data_init,     /* plugin init */
    tokudb_user_data_done,     /* plugin deinit */
    TOKUDB_PLUGIN_VERSION,     /* 4.0.0 */
    NULL,                      /* status variables */
    NULL,                      /* system variables */
    TOKUDB_PLUGIN_VERSION_STR, /* string version */
    MariaDB_PLUGIN_MATURITY_STABLE /* maturity */
},
{
    MYSQL_INFORMATION_SCHEMA_PLUGIN, 
    &tokudb_user_data_exact_information_schema, 
    "TokuDB_user_data_exact", 
    "Tokutek Inc", 
    "Tokutek TokuDB Storage Engine with Fractal Tree(tm) Technology",
1878
    PLUGIN_LICENSE_PROPRIETARY,
1879 1880 1881 1882 1883 1884 1885
    tokudb_user_data_exact_init,     /* plugin init */
    tokudb_user_data_exact_done,     /* plugin deinit */
    TOKUDB_PLUGIN_VERSION,     /* 4.0.0 */
    NULL,                      /* status variables */
    NULL,                      /* system variables */
    TOKUDB_PLUGIN_VERSION_STR, /* string version */
    MariaDB_PLUGIN_MATURITY_STABLE /* maturity */
1886 1887 1888 1889
},
{
    MYSQL_INFORMATION_SCHEMA_PLUGIN, 
    &tokudb_user_data_exact_information_schema, 
1890
    "TokuDB_file_map", 
1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
    "Tokutek Inc", 
    "Tokutek TokuDB Storage Engine with Fractal Tree(tm) Technology",
    PLUGIN_LICENSE_PROPRIETARY,
    tokudb_dictionary_info_init,     /* plugin init */
    tokudb_dictionary_info_done,     /* plugin deinit */
    TOKUDB_PLUGIN_VERSION,     /* 4.0.0 */
    NULL,                      /* status variables */
    NULL,                      /* system variables */
    TOKUDB_PLUGIN_VERSION_STR, /* string version */
    MariaDB_PLUGIN_MATURITY_STABLE /* maturity */
1901 1902 1903 1904
}
maria_declare_plugin_end;

#endif