summaryrefslogtreecommitdiffstats
path: root/storage/mroonga/mrn_table.cpp
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--storage/mroonga/mrn_table.cpp1198
1 files changed, 1198 insertions, 0 deletions
diff --git a/storage/mroonga/mrn_table.cpp b/storage/mroonga/mrn_table.cpp
new file mode 100644
index 00000000..037a6a59
--- /dev/null
+++ b/storage/mroonga/mrn_table.cpp
@@ -0,0 +1,1198 @@
+/* -*- c-basic-offset: 2 -*- */
+/*
+ Copyright(C) 2011-2013 Kentoku SHIBA
+ Copyright(C) 2011-2017 Kouhei Sutou <kou@clear-code.com>
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA
+*/
+
+#include "mrn_mysql.h"
+
+#if MYSQL_VERSION_ID >= 50500
+# include <sql_servers.h>
+# include <sql_base.h>
+#endif
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+# include <partition_info.h>
+#endif
+#include <sql_plugin.h>
+
+#include "mrn_err.h"
+#include "mrn_table.hpp"
+#include "mrn_mysql_compat.h"
+#include "mrn_variables.hpp"
+#include <mrn_lock.hpp>
+
+#ifdef MRN_MARIADB_P
+# if MYSQL_VERSION_ID >= 100100
+# define MRN_HA_RESOLVE_BY_NAME(name) ha_resolve_by_name(NULL, (name), TRUE)
+# else
+# define MRN_HA_RESOLVE_BY_NAME(name) ha_resolve_by_name(NULL, (name))
+# endif
+#else
+# if MYSQL_VERSION_ID >= 50603
+# define MRN_HA_RESOLVE_BY_NAME(name) ha_resolve_by_name(NULL, (name), TRUE)
+# else
+# define MRN_HA_RESOLVE_BY_NAME(name) ha_resolve_by_name(NULL, (name))
+# endif
+#endif
+
+#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P)
+# define MRN_PLUGIN_DATA(plugin, type) plugin_data<type>(plugin)
+#else
+# define MRN_PLUGIN_DATA(plugin, type) plugin_data(plugin, type)
+#endif
+
+#define LEX_STRING_IS_EMPTY(string) \
+ ((string).length == 0 || !(string).str || (string).str[0] == '\0')
+
+#define MRN_DEFAULT_STR "DEFAULT"
+#define MRN_DEFAULT_LEN (sizeof(MRN_DEFAULT_STR) - 1)
+#define MRN_GROONGA_STR "GROONGA"
+#define MRN_GROONGA_LEN (sizeof(MRN_GROONGA_STR) - 1)
+
+#ifdef MRN_HAVE_TABLE_DEF_CACHE
+extern HASH *mrn_table_def_cache;
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef HAVE_PSI_INTERFACE
+# ifdef WIN32
+# ifdef MRN_TABLE_SHARE_HAVE_LOCK_SHARE
+extern PSI_mutex_key *mrn_table_share_lock_share;
+# endif
+extern PSI_mutex_key *mrn_table_share_lock_ha_data;
+# endif
+extern PSI_mutex_key mrn_share_mutex_key;
+extern PSI_mutex_key mrn_long_term_share_auto_inc_mutex_key;
+#endif
+
+extern HASH mrn_open_tables;
+extern mysql_mutex_t mrn_open_tables_mutex;
+extern HASH mrn_long_term_share;
+extern mysql_mutex_t mrn_long_term_share_mutex;
+extern char *mrn_default_tokenizer;
+extern char *mrn_default_wrapper_engine;
+extern handlerton *mrn_hton_ptr;
+extern HASH mrn_allocated_thds;
+extern mysql_mutex_t mrn_allocated_thds_mutex;
+
+static char *mrn_get_string_between_quote(const char *ptr)
+{
+ const char *start_ptr, *end_ptr, *tmp_ptr, *esc_ptr;
+ bool find_flg = FALSE, esc_flg = FALSE;
+ MRN_DBUG_ENTER_FUNCTION();
+
+ start_ptr = strchr(ptr, '\'');
+ end_ptr = strchr(ptr, '"');
+ if (start_ptr && (!end_ptr || start_ptr < end_ptr))
+ {
+ tmp_ptr = ++start_ptr;
+ while (!find_flg)
+ {
+ if (!(end_ptr = strchr(tmp_ptr, '\'')))
+ DBUG_RETURN(NULL);
+ esc_ptr = tmp_ptr;
+ while (!find_flg)
+ {
+ esc_ptr = strchr(esc_ptr, '\\');
+ if (!esc_ptr || esc_ptr > end_ptr)
+ find_flg = TRUE;
+ else if (esc_ptr == end_ptr - 1)
+ {
+ esc_flg = TRUE;
+ tmp_ptr = end_ptr + 1;
+ break;
+ } else {
+ esc_flg = TRUE;
+ esc_ptr += 2;
+ }
+ }
+ }
+ } else if (end_ptr)
+ {
+ start_ptr = end_ptr;
+ tmp_ptr = ++start_ptr;
+ while (!find_flg)
+ {
+ if (!(end_ptr = strchr(tmp_ptr, '"')))
+ DBUG_RETURN(NULL);
+ esc_ptr = tmp_ptr;
+ while (!find_flg)
+ {
+ esc_ptr = strchr(esc_ptr, '\\');
+ if (!esc_ptr || esc_ptr > end_ptr)
+ find_flg = TRUE;
+ else if (esc_ptr == end_ptr - 1)
+ {
+ esc_flg = TRUE;
+ tmp_ptr = end_ptr + 1;
+ break;
+ } else {
+ esc_flg = TRUE;
+ esc_ptr += 2;
+ }
+ }
+ }
+ } else
+ DBUG_RETURN(NULL);
+
+ size_t length = end_ptr - start_ptr;
+ char *extracted_string = (char *)mrn_my_malloc(length + 1, MYF(MY_WME));
+ if (esc_flg) {
+ size_t extracted_index = 0;
+ const char *current_ptr = start_ptr;
+ while (current_ptr < end_ptr) {
+ if (*current_ptr != '\\') {
+ extracted_string[extracted_index] = *current_ptr;
+ ++extracted_index;
+ current_ptr++;
+ continue;
+ }
+
+ if (current_ptr + 1 == end_ptr) {
+ break;
+ }
+
+ switch (*(current_ptr + 1))
+ {
+ case 'b':
+ extracted_string[extracted_index] = '\b';
+ break;
+ case 'n':
+ extracted_string[extracted_index] = '\n';
+ break;
+ case 'r':
+ extracted_string[extracted_index] = '\r';
+ break;
+ case 't':
+ extracted_string[extracted_index] = '\t';
+ break;
+ default:
+ extracted_string[extracted_index] = *(current_ptr + 1);
+ break;
+ }
+ ++extracted_index;
+ }
+ } else {
+ memcpy(extracted_string, start_ptr, length);
+ extracted_string[length] = '\0';
+ }
+
+ DBUG_RETURN(extracted_string);
+}
+
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+void mrn_get_partition_info(const char *table_name, uint table_name_length,
+ const TABLE *table, partition_element **part_elem,
+ partition_element **sub_elem)
+{
+ partition_info *part_info = table->part_info;
+ partition_element *tmp_part_elem = NULL, *tmp_sub_elem = NULL;
+ bool tmp_flg = FALSE, tmp_find_flg = FALSE;
+ MRN_DBUG_ENTER_FUNCTION();
+ *part_elem = NULL;
+ *sub_elem = NULL;
+ if (!part_info)
+ DBUG_VOID_RETURN;
+
+ if (table_name && !memcmp(table_name + table_name_length - 5, "#TMP#", 5))
+ tmp_flg = TRUE;
+
+ DBUG_PRINT("info", ("mroonga table_name=%s", table_name));
+ List_iterator<partition_element> part_it(part_info->partitions);
+ while ((*part_elem = part_it++))
+ {
+ if ((*part_elem)->subpartitions.elements)
+ {
+ List_iterator<partition_element> sub_it((*part_elem)->subpartitions);
+ while ((*sub_elem = sub_it++))
+ {
+ char subpartition_name[FN_REFLEN + 1];
+ int error = mrn_create_subpartition_name(subpartition_name,
+ sizeof(subpartition_name),
+ table->s->path.str,
+ (*part_elem)->partition_name,
+ (*sub_elem)->partition_name,
+ NORMAL_PART_NAME);
+ if (error != 0)
+ DBUG_VOID_RETURN;
+ DBUG_PRINT("info", ("mroonga subpartition name=%s", subpartition_name));
+ if (table_name &&
+ memcmp(table_name, subpartition_name, table_name_length + 1) == 0)
+ DBUG_VOID_RETURN;
+ if (
+ tmp_flg &&
+ table_name &&
+ *(subpartition_name + table_name_length - 5) == '\0' &&
+ memcmp(table_name, subpartition_name, table_name_length - 5) == 0
+ ) {
+ tmp_part_elem = *part_elem;
+ tmp_sub_elem = *sub_elem;
+ tmp_flg = FALSE;
+ tmp_find_flg = TRUE;
+ }
+ }
+ } else {
+ char partition_name[FN_REFLEN + 1];
+ int error = mrn_create_partition_name(partition_name,
+ sizeof(partition_name),
+ table->s->path.str,
+ (*part_elem)->partition_name,
+ NORMAL_PART_NAME,
+ TRUE);
+ if (error != 0)
+ DBUG_VOID_RETURN;
+ DBUG_PRINT("info", ("mroonga partition name=%s", partition_name));
+ if (table_name &&
+ memcmp(table_name, partition_name, table_name_length + 1) == 0)
+ DBUG_VOID_RETURN;
+ if (
+ tmp_flg &&
+ table_name &&
+ *(partition_name + table_name_length - 5) == '\0' &&
+ memcmp(table_name, partition_name, table_name_length - 5) == 0
+ ) {
+ tmp_part_elem = *part_elem;
+ tmp_flg = FALSE;
+ tmp_find_flg = TRUE;
+ }
+ }
+ }
+ if (tmp_find_flg)
+ {
+ *part_elem = tmp_part_elem;
+ *sub_elem = tmp_sub_elem;
+ DBUG_PRINT("info", ("mroonga tmp find"));
+ DBUG_VOID_RETURN;
+ }
+ *part_elem = NULL;
+ *sub_elem = NULL;
+ DBUG_PRINT("info", ("mroonga no hit"));
+ DBUG_VOID_RETURN;
+}
+#endif
+
+#define MRN_PARAM_STR_LEN(name) name ## _length
+#define MRN_PARAM_STR(title_name, param_name) \
+ if (!strncasecmp(tmp_ptr, title_name, title_length)) \
+ { \
+ DBUG_PRINT("info", ("mroonga " title_name " start")); \
+ if (!share->param_name) \
+ { \
+ if ((share->param_name = mrn_get_string_between_quote( \
+ start_ptr))) \
+ share->MRN_PARAM_STR_LEN(param_name) = strlen(share->param_name); \
+ else { \
+ error = ER_MRN_INVALID_TABLE_PARAM_NUM; \
+ my_printf_error(error, ER_MRN_INVALID_TABLE_PARAM_STR, \
+ MYF(0), tmp_ptr); \
+ goto error; \
+ } \
+ DBUG_PRINT("info", ("mroonga " title_name "=%s", share->param_name)); \
+ } \
+ break; \
+ }
+
+#define MRN_PARAM_STR_LIST(title_name, param_name, param_pos) \
+ if (!strncasecmp(tmp_ptr, title_name, title_length)) \
+ { \
+ DBUG_PRINT("info", ("mroonga " title_name " start")); \
+ if (share->param_name && !share->param_name[param_pos]) \
+ { \
+ if ((share->param_name[param_pos] = mrn_get_string_between_quote( \
+ start_ptr))) \
+ share->MRN_PARAM_STR_LEN(param_name)[param_pos] = \
+ strlen(share->param_name[param_pos]); \
+ else { \
+ error = ER_MRN_INVALID_TABLE_PARAM_NUM; \
+ my_printf_error(error, ER_MRN_INVALID_TABLE_PARAM_STR, \
+ MYF(0), tmp_ptr); \
+ goto error; \
+ } \
+ DBUG_PRINT("info", ("mroonga " title_name "[%d]=%s", param_pos, \
+ share->param_name[param_pos])); \
+ } \
+ break; \
+ }
+
+int mrn_parse_table_param(MRN_SHARE *share, TABLE *table)
+{
+ int i, error = 0;
+ int title_length;
+ const char *sprit_ptr[2];
+ const char *tmp_ptr, *start_ptr;
+ char *params_string = NULL;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+ partition_element *part_elem;
+ partition_element *sub_elem;
+#endif
+ MRN_DBUG_ENTER_FUNCTION();
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+ mrn_get_partition_info(share->table_name, share->table_name_length, table,
+ &part_elem, &sub_elem);
+#endif
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+ for (i = 4; i > 0; i--)
+#else
+ for (i = 2; i > 0; i--)
+#endif
+ {
+ const char *params_string_value = NULL;
+ uint params_string_length = 0;
+ switch (i)
+ {
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+ case 4:
+ if (!sub_elem || !sub_elem->part_comment)
+ continue;
+ DBUG_PRINT("info", ("mroonga create sub comment string"));
+ params_string_value = sub_elem->part_comment;
+ params_string_length = strlen(params_string_value);
+ DBUG_PRINT("info",
+ ("mroonga sub comment string=%s", params_string_value));
+ break;
+ case 3:
+ if (!part_elem || !part_elem->part_comment)
+ continue;
+ DBUG_PRINT("info", ("mroonga create part comment string"));
+ params_string_value = part_elem->part_comment;
+ params_string_length = strlen(params_string_value);
+ DBUG_PRINT("info",
+ ("mroonga part comment string=%s", params_string_value));
+ break;
+#endif
+ case 2:
+ if (LEX_STRING_IS_EMPTY(table->s->comment))
+ continue;
+ DBUG_PRINT("info", ("mroonga create comment string"));
+ params_string_value = table->s->comment.str;
+ params_string_length = table->s->comment.length;
+ DBUG_PRINT("info",
+ ("mroonga comment string=%.*s",
+ params_string_length, params_string_value));
+ break;
+ default:
+ if (LEX_STRING_IS_EMPTY(table->s->connect_string))
+ continue;
+ DBUG_PRINT("info", ("mroonga create connect_string string"));
+ params_string_value = table->s->connect_string.str;
+ params_string_length = table->s->connect_string.length;
+ DBUG_PRINT("info",
+ ("mroonga connect_string=%.*s",
+ params_string_length, params_string_value));
+ break;
+ }
+
+ if (!params_string_value) {
+ continue;
+ }
+
+ {
+ params_string = mrn_my_strndup(params_string_value,
+ params_string_length,
+ MYF(MY_WME));
+ if (!params_string) {
+ error = HA_ERR_OUT_OF_MEM;
+ goto error;
+ }
+
+ sprit_ptr[0] = params_string;
+ while (sprit_ptr[0])
+ {
+ if ((sprit_ptr[1] = strchr(sprit_ptr[0], ',')))
+ {
+ sprit_ptr[1]++;
+ }
+ tmp_ptr = sprit_ptr[0];
+ sprit_ptr[0] = sprit_ptr[1];
+ while (*tmp_ptr == ' ' || *tmp_ptr == '\r' ||
+ *tmp_ptr == '\n' || *tmp_ptr == '\t')
+ tmp_ptr++;
+
+ if (*tmp_ptr == '\0')
+ continue;
+
+ DBUG_PRINT("info", ("mroonga title_str=%s", tmp_ptr));
+ title_length = 0;
+ start_ptr = tmp_ptr;
+ while (*start_ptr != ' ' && *start_ptr != '\'' &&
+ *start_ptr != '"' && *start_ptr != '\0' &&
+ *start_ptr != '\r' && *start_ptr != '\n' &&
+ *start_ptr != '\t' && *start_ptr != ',')
+ {
+ title_length++;
+ start_ptr++;
+ }
+ DBUG_PRINT("info", ("mroonga title_length=%u", title_length));
+
+ switch (title_length)
+ {
+ case 6:
+ MRN_PARAM_STR("engine", engine);
+ break;
+ case 10:
+ MRN_PARAM_STR("normalizer", normalizer);
+ break;
+ case 13:
+ MRN_PARAM_STR("token_filters", token_filters);
+ break;
+ case 17:
+ MRN_PARAM_STR("default_tokenizer", default_tokenizer);
+ break;
+ default:
+ break;
+ }
+ }
+
+ my_free(params_string);
+ params_string = NULL;
+ }
+ }
+
+ if (!share->engine && mrn_default_wrapper_engine)
+ {
+ share->engine_length = strlen(mrn_default_wrapper_engine);
+ if (
+ !(share->engine = mrn_my_strndup(mrn_default_wrapper_engine,
+ share->engine_length,
+ MYF(MY_WME)))
+ ) {
+ error = HA_ERR_OUT_OF_MEM;
+ goto error;
+ }
+ }
+
+ if (share->engine)
+ {
+ LEX_CSTRING engine_name;
+ if (
+ (
+ share->engine_length == MRN_DEFAULT_LEN &&
+ !strncasecmp(share->engine, MRN_DEFAULT_STR, MRN_DEFAULT_LEN)
+ ) ||
+ (
+ share->engine_length == MRN_GROONGA_LEN &&
+ !strncasecmp(share->engine, MRN_GROONGA_STR, MRN_GROONGA_LEN)
+ )
+ ) {
+ my_free(share->engine);
+ share->engine = NULL;
+ share->engine_length = 0;
+ } else {
+ engine_name.str = share->engine;
+ engine_name.length = share->engine_length;
+ if (!(share->plugin = MRN_HA_RESOLVE_BY_NAME(&engine_name)))
+ {
+ my_error(ER_UNKNOWN_STORAGE_ENGINE, MYF(0), share->engine);
+ error = ER_UNKNOWN_STORAGE_ENGINE;
+ goto error;
+ }
+ share->hton = MRN_PLUGIN_DATA(share->plugin, handlerton *);
+ share->wrapper_mode = TRUE;
+ }
+ }
+
+error:
+ if (params_string)
+ my_free(params_string);
+ DBUG_RETURN(error);
+}
+
+bool mrn_is_geo_key(const KEY *key_info)
+{
+ return key_info->algorithm == HA_KEY_ALG_UNDEF &&
+ KEY_N_KEY_PARTS(key_info) == 1 &&
+ key_info->key_part[0].field->type() == MYSQL_TYPE_GEOMETRY;
+}
+
+int mrn_add_index_param(MRN_SHARE *share, KEY *key_info, int i)
+{
+ int error;
+ char *param_string = NULL;
+#if MYSQL_VERSION_ID >= 50500
+ int title_length;
+ char *sprit_ptr[2];
+ char *tmp_ptr, *start_ptr;
+#endif
+ THD *thd = current_thd;
+ MRN_DBUG_ENTER_FUNCTION();
+
+#if MYSQL_VERSION_ID >= 50500
+ if (key_info->comment.length == 0)
+ {
+ if (share->key_tokenizer[i]) {
+ my_free(share->key_tokenizer[i]);
+ }
+ share->key_tokenizer[i] = mrn_my_strdup(mrn_default_tokenizer, MYF(MY_WME));
+ if (!share->key_tokenizer[i]) {
+ error = HA_ERR_OUT_OF_MEM;
+ goto error;
+ }
+ share->key_tokenizer_length[i] = strlen(share->key_tokenizer[i]);
+
+ DBUG_RETURN(0);
+ }
+ DBUG_PRINT("info", ("mroonga create comment string"));
+ if (
+ !(param_string = mrn_my_strndup(key_info->comment.str,
+ key_info->comment.length,
+ MYF(MY_WME)))
+ ) {
+ error = HA_ERR_OUT_OF_MEM;
+ goto error_alloc_param_string;
+ }
+ DBUG_PRINT("info", ("mroonga comment string=%s", param_string));
+
+ sprit_ptr[0] = param_string;
+ while (sprit_ptr[0])
+ {
+ if ((sprit_ptr[1] = strchr(sprit_ptr[0], ',')))
+ {
+ *sprit_ptr[1] = '\0';
+ sprit_ptr[1]++;
+ }
+ tmp_ptr = sprit_ptr[0];
+ sprit_ptr[0] = sprit_ptr[1];
+ while (*tmp_ptr == ' ' || *tmp_ptr == '\r' ||
+ *tmp_ptr == '\n' || *tmp_ptr == '\t')
+ tmp_ptr++;
+
+ if (*tmp_ptr == '\0')
+ continue;
+
+ title_length = 0;
+ start_ptr = tmp_ptr;
+ while (*start_ptr != ' ' && *start_ptr != '\'' &&
+ *start_ptr != '"' && *start_ptr != '\0' &&
+ *start_ptr != '\r' && *start_ptr != '\n' &&
+ *start_ptr != '\t')
+ {
+ title_length++;
+ start_ptr++;
+ }
+
+ switch (title_length)
+ {
+ case 5:
+ MRN_PARAM_STR_LIST("table", index_table, i);
+ break;
+ case 6:
+ push_warning_printf(thd, MRN_SEVERITY_WARNING,
+ ER_WARN_DEPRECATED_SYNTAX,
+ ER(ER_WARN_DEPRECATED_SYNTAX),
+ "parser", "tokenizer");
+ MRN_PARAM_STR_LIST("parser", key_tokenizer, i);
+ break;
+ case 9:
+ MRN_PARAM_STR_LIST("tokenizer", key_tokenizer, i);
+ break;
+ default:
+ break;
+ }
+ }
+#endif
+ if (!share->key_tokenizer[i]) {
+ share->key_tokenizer[i] = mrn_my_strdup(mrn_default_tokenizer, MYF(MY_WME));
+ if (!share->key_tokenizer[i]) {
+ error = HA_ERR_OUT_OF_MEM;
+ goto error;
+ }
+ share->key_tokenizer_length[i] = strlen(share->key_tokenizer[i]);
+ }
+
+ if (param_string)
+ my_free(param_string);
+ DBUG_RETURN(0);
+
+error:
+ if (param_string)
+ my_free(param_string);
+#if MYSQL_VERSION_ID >= 50500
+error_alloc_param_string:
+#endif
+ DBUG_RETURN(error);
+}
+
+int mrn_parse_index_param(MRN_SHARE *share, TABLE *table)
+{
+ int error;
+ MRN_DBUG_ENTER_FUNCTION();
+ for (uint i = 0; i < table->s->keys; i++)
+ {
+ KEY *key_info = &table->s->key_info[i];
+ bool is_wrapper_mode = share->engine != NULL;
+
+ if (is_wrapper_mode) {
+ if (!(key_info->flags & HA_FULLTEXT) && !mrn_is_geo_key(key_info)) {
+ continue;
+ }
+ }
+
+ if ((error = mrn_add_index_param(share, key_info, i)))
+ goto error;
+ }
+ DBUG_RETURN(0);
+
+error:
+ DBUG_RETURN(error);
+}
+
+int mrn_add_column_param(MRN_SHARE *share, Field *field, int i)
+{
+ int error;
+ char *param_string = NULL;
+ int title_length;
+ char *sprit_ptr[2];
+ char *tmp_ptr, *start_ptr;
+
+ MRN_DBUG_ENTER_FUNCTION();
+
+ if (share->wrapper_mode) {
+ DBUG_RETURN(0);
+ }
+
+ DBUG_PRINT("info", ("mroonga create comment string"));
+ if (
+ !(param_string = mrn_my_strndup(field->comment.str,
+ field->comment.length,
+ MYF(MY_WME)))
+ ) {
+ error = HA_ERR_OUT_OF_MEM;
+ goto error_alloc_param_string;
+ }
+ DBUG_PRINT("info", ("mroonga comment string=%s", param_string));
+
+ sprit_ptr[0] = param_string;
+ while (sprit_ptr[0])
+ {
+ if ((sprit_ptr[1] = strchr(sprit_ptr[0], ',')))
+ {
+ *sprit_ptr[1] = '\0';
+ sprit_ptr[1]++;
+ }
+ tmp_ptr = sprit_ptr[0];
+ sprit_ptr[0] = sprit_ptr[1];
+ while (*tmp_ptr == ' ' || *tmp_ptr == '\r' ||
+ *tmp_ptr == '\n' || *tmp_ptr == '\t')
+ tmp_ptr++;
+
+ if (*tmp_ptr == '\0')
+ continue;
+
+ title_length = 0;
+ start_ptr = tmp_ptr;
+ while (*start_ptr != ' ' && *start_ptr != '\'' &&
+ *start_ptr != '"' && *start_ptr != '\0' &&
+ *start_ptr != '\r' && *start_ptr != '\n' &&
+ *start_ptr != '\t')
+ {
+ title_length++;
+ start_ptr++;
+ }
+
+ switch (title_length)
+ {
+ case 4:
+ MRN_PARAM_STR_LIST("type", col_type, i);
+ break;
+ case 5:
+ MRN_PARAM_STR_LIST("flags", col_flags, i);
+ break;
+ case 12:
+ MRN_PARAM_STR_LIST("groonga_type", col_type, i);
+ break;
+ default:
+ break;
+ }
+ }
+
+ if (param_string)
+ my_free(param_string);
+ DBUG_RETURN(0);
+
+error:
+ if (param_string)
+ my_free(param_string);
+error_alloc_param_string:
+ DBUG_RETURN(error);
+}
+
+int mrn_parse_column_param(MRN_SHARE *share, TABLE *table)
+{
+ int error;
+ MRN_DBUG_ENTER_FUNCTION();
+ for (uint i = 0; i < table->s->fields; i++)
+ {
+ Field *field = table->s->field[i];
+
+ if (LEX_STRING_IS_EMPTY(field->comment)) {
+ continue;
+ }
+
+ if ((error = mrn_add_column_param(share, field, i)))
+ goto error;
+ }
+ DBUG_RETURN(0);
+
+error:
+ DBUG_RETURN(error);
+}
+
+int mrn_free_share_alloc(
+ MRN_SHARE *share
+) {
+ uint i;
+ MRN_DBUG_ENTER_FUNCTION();
+ if (share->engine)
+ my_free(share->engine);
+ if (share->default_tokenizer)
+ my_free(share->default_tokenizer);
+ if (share->normalizer)
+ my_free(share->normalizer);
+ if (share->token_filters)
+ my_free(share->token_filters);
+ for (i = 0; i < share->table_share->keys; i++)
+ {
+ if (share->index_table && share->index_table[i])
+ my_free(share->index_table[i]);
+ if (share->key_tokenizer[i])
+ my_free(share->key_tokenizer[i]);
+ }
+ for (i = 0; i < share->table_share->fields; i++)
+ {
+ if (share->col_flags && share->col_flags[i])
+ my_free(share->col_flags[i]);
+ if (share->col_type && share->col_type[i])
+ my_free(share->col_type[i]);
+ }
+ DBUG_RETURN(0);
+}
+
+void mrn_free_long_term_share(MRN_LONG_TERM_SHARE *long_term_share)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ {
+ mrn::Lock lock(&mrn_long_term_share_mutex);
+ my_hash_delete(&mrn_long_term_share, (uchar*) long_term_share);
+ }
+ mysql_mutex_destroy(&long_term_share->auto_inc_mutex);
+ my_free(long_term_share);
+ DBUG_VOID_RETURN;
+}
+
+MRN_LONG_TERM_SHARE *mrn_get_long_term_share(const char *table_name,
+ uint table_name_length,
+ int *error)
+{
+ MRN_LONG_TERM_SHARE *long_term_share;
+ char *tmp_name;
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_PRINT("info", ("mroonga: table_name=%s", table_name));
+ mrn::Lock lock(&mrn_long_term_share_mutex);
+ if (!(long_term_share = (MRN_LONG_TERM_SHARE*)
+ my_hash_search(&mrn_long_term_share, (uchar*) table_name,
+ table_name_length)))
+ {
+ if (!(long_term_share = (MRN_LONG_TERM_SHARE *)
+ mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+ &long_term_share, sizeof(*long_term_share),
+ &tmp_name, table_name_length + 1,
+ NullS))
+ ) {
+ *error = HA_ERR_OUT_OF_MEM;
+ goto error_alloc_long_term_share;
+ }
+ long_term_share->table_name = tmp_name;
+ long_term_share->table_name_length = table_name_length;
+ memcpy(long_term_share->table_name, table_name, table_name_length);
+ if (mysql_mutex_init(mrn_long_term_share_auto_inc_mutex_key,
+ &long_term_share->auto_inc_mutex,
+ MY_MUTEX_INIT_FAST) != 0)
+ {
+ *error = HA_ERR_OUT_OF_MEM;
+ goto error_init_auto_inc_mutex;
+ }
+ if (my_hash_insert(&mrn_long_term_share, (uchar*) long_term_share))
+ {
+ *error = HA_ERR_OUT_OF_MEM;
+ goto error_hash_insert;
+ }
+ }
+ DBUG_RETURN(long_term_share);
+
+error_hash_insert:
+ mysql_mutex_destroy(&long_term_share->auto_inc_mutex);
+error_init_auto_inc_mutex:
+ my_free(long_term_share);
+error_alloc_long_term_share:
+ DBUG_RETURN(NULL);
+}
+
+MRN_SHARE *mrn_get_share(const char *table_name, TABLE *table, int *error)
+{
+ MRN_SHARE *share;
+ char *tmp_name, **index_table, **key_tokenizer, **col_flags, **col_type;
+ uint length, *wrap_key_nr, *index_table_length;
+ uint *key_tokenizer_length, *col_flags_length, *col_type_length, i, j;
+ KEY *wrap_key_info;
+ TABLE_SHARE *wrap_table_share;
+ MRN_DBUG_ENTER_FUNCTION();
+ length = (uint) strlen(table_name);
+ mrn::Lock lock(&mrn_open_tables_mutex);
+ if (!(share = (MRN_SHARE*) my_hash_search(&mrn_open_tables,
+ (uchar*) table_name, length)))
+ {
+ if (!(share = (MRN_SHARE *)
+ mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+ &share, sizeof(*share),
+ &tmp_name, length + 1,
+ &index_table, sizeof(char *) * table->s->keys,
+ &index_table_length, sizeof(uint) * table->s->keys,
+ &key_tokenizer, sizeof(char *) * table->s->keys,
+ &key_tokenizer_length, sizeof(uint) * table->s->keys,
+ &col_flags, sizeof(char *) * table->s->fields,
+ &col_flags_length, sizeof(uint) * table->s->fields,
+ &col_type, sizeof(char *) * table->s->fields,
+ &col_type_length, sizeof(uint) * table->s->fields,
+ &wrap_key_nr, sizeof(*wrap_key_nr) * table->s->keys,
+ &wrap_key_info, sizeof(*wrap_key_info) * table->s->keys,
+ &wrap_table_share, sizeof(*wrap_table_share),
+ NullS))
+ ) {
+ *error = HA_ERR_OUT_OF_MEM;
+ goto error_alloc_share;
+ }
+ share->use_count = 0;
+ share->table_name_length = length;
+ share->table_name = tmp_name;
+ share->index_table = index_table;
+ share->index_table_length = index_table_length;
+ share->key_tokenizer = key_tokenizer;
+ share->key_tokenizer_length = key_tokenizer_length;
+ share->col_flags = col_flags;
+ share->col_flags_length = col_flags_length;
+ share->col_type = col_type;
+ share->col_type_length = col_type_length;
+ mrn_my_stpmov(share->table_name, table_name);
+ share->table_share = table->s;
+
+ if (
+ (*error = mrn_parse_table_param(share, table)) ||
+ (*error = mrn_parse_column_param(share, table)) ||
+ (*error = mrn_parse_index_param(share, table))
+ )
+ goto error_parse_table_param;
+
+ if (share->wrapper_mode)
+ {
+ j = 0;
+ for (i = 0; i < table->s->keys; i++)
+ {
+ if (table->s->key_info[i].algorithm != HA_KEY_ALG_FULLTEXT &&
+ !mrn_is_geo_key(&table->s->key_info[i]))
+ {
+ wrap_key_nr[i] = j;
+ memcpy(&wrap_key_info[j], &table->s->key_info[i],
+ sizeof(*wrap_key_info));
+ j++;
+ } else {
+ wrap_key_nr[i] = MAX_KEY;
+ }
+ }
+ share->wrap_keys = j;
+ share->base_keys = table->s->keys;
+ share->base_key_info = table->s->key_info;
+ share->base_primary_key = table->s->primary_key;
+ if (i)
+ {
+ share->wrap_key_nr = wrap_key_nr;
+ share->wrap_key_info = wrap_key_info;
+ if (table->s->primary_key == MAX_KEY)
+ share->wrap_primary_key = MAX_KEY;
+ else
+ share->wrap_primary_key = wrap_key_nr[table->s->primary_key];
+ } else {
+ share->wrap_key_nr = NULL;
+ share->wrap_key_info = NULL;
+ share->wrap_primary_key = MAX_KEY;
+ }
+ *wrap_table_share= *table->s;
+ mrn_init_sql_alloc(current_thd, &(wrap_table_share->mem_root));
+ wrap_table_share->keys = share->wrap_keys;
+ wrap_table_share->key_info = share->wrap_key_info;
+ wrap_table_share->primary_key = share->wrap_primary_key;
+ wrap_table_share->keys_in_use.init(share->wrap_keys);
+ wrap_table_share->keys_for_keyread.init(share->wrap_keys);
+#ifdef MRN_TABLE_SHARE_HAVE_LOCK_SHARE
+# ifdef WIN32
+ mysql_mutex_init(*mrn_table_share_lock_share,
+ &(wrap_table_share->LOCK_share), MY_MUTEX_INIT_SLOW);
+# else
+ mysql_mutex_init(key_TABLE_SHARE_LOCK_share,
+ &(wrap_table_share->LOCK_share), MY_MUTEX_INIT_SLOW);
+# endif
+#endif
+#ifdef WIN32
+ mysql_mutex_init(*mrn_table_share_lock_ha_data,
+ &(wrap_table_share->LOCK_ha_data), MY_MUTEX_INIT_FAST);
+#else
+ mysql_mutex_init(key_TABLE_SHARE_LOCK_ha_data,
+ &(wrap_table_share->LOCK_ha_data), MY_MUTEX_INIT_FAST);
+#endif
+ share->wrap_table_share = wrap_table_share;
+ }
+
+ if (mysql_mutex_init(mrn_share_mutex_key,
+ &share->record_mutex,
+ MY_MUTEX_INIT_FAST) != 0)
+ {
+ *error = HA_ERR_OUT_OF_MEM;
+ goto error_init_mutex;
+ }
+ thr_lock_init(&share->lock);
+ if (!(share->long_term_share = mrn_get_long_term_share(table_name, length,
+ error)))
+ {
+ goto error_get_long_term_share;
+ }
+ if (my_hash_insert(&mrn_open_tables, (uchar*) share))
+ {
+ *error = HA_ERR_OUT_OF_MEM;
+ goto error_hash_insert;
+ }
+ }
+ share->use_count++;
+ DBUG_RETURN(share);
+
+error_hash_insert:
+error_get_long_term_share:
+ mysql_mutex_destroy(&share->record_mutex);
+error_init_mutex:
+error_parse_table_param:
+ mrn_free_share_alloc(share);
+ my_free(share);
+error_alloc_share:
+ DBUG_RETURN(NULL);
+}
+
+int mrn_free_share(MRN_SHARE *share)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ mrn::Lock lock(&mrn_open_tables_mutex);
+ if (!--share->use_count)
+ {
+ my_hash_delete(&mrn_open_tables, (uchar*) share);
+ if (share->wrapper_mode)
+ plugin_unlock(NULL, share->plugin);
+ mrn_free_share_alloc(share);
+ thr_lock_delete(&share->lock);
+ mysql_mutex_destroy(&share->record_mutex);
+ if (share->wrapper_mode) {
+#ifdef MRN_TABLE_SHARE_HAVE_LOCK_SHARE
+ mysql_mutex_destroy(&(share->wrap_table_share->LOCK_share));
+#endif
+ mysql_mutex_destroy(&(share->wrap_table_share->LOCK_ha_data));
+ free_root(&(share->wrap_table_share->mem_root), MYF(0));
+ }
+ my_free(share);
+ }
+ DBUG_RETURN(0);
+}
+
+TABLE_SHARE *mrn_get_table_share(TABLE_LIST *table_list, int *error)
+{
+ TABLE_SHARE *share;
+ THD *thd = current_thd;
+ MRN_DBUG_ENTER_FUNCTION();
+#if defined(MRN_HAVE_TDC_ACQUIRE_SHARE) && \
+ !defined(MRN_TDC_ACQUIRE_SHARE_REQUIRE_KEY)
+ share = tdc_acquire_share(thd, table_list, GTS_TABLE);
+#else
+ uint key_length;
+# ifdef MRN_HAVE_GET_TABLE_DEF_KEY
+ const char *key;
+ key_length = get_table_def_key(table_list, &key);
+# else
+ char key[MAX_DBKEY_LENGTH];
+ key_length = create_table_def_key(thd, key, table_list, FALSE);
+# endif
+# ifdef MRN_HAVE_TABLE_DEF_CACHE
+ my_hash_value_type hash_value;
+ hash_value = my_calc_hash(mrn_table_def_cache, (uchar*) key, key_length);
+ share = get_table_share(thd, table_list, key, key_length, 0, error,
+ hash_value);
+# elif defined(MRN_HAVE_TDC_ACQUIRE_SHARE)
+ share = tdc_acquire_share(thd, table_list, GTS_TABLE);
+# else
+ share = get_table_share(thd, table_list, key, key_length, 0, error);
+# endif
+#endif
+ DBUG_RETURN(share);
+}
+
+TABLE_SHARE *mrn_create_tmp_table_share(TABLE_LIST *table_list, const char *path,
+ int *error)
+{
+ uint key_length;
+ TABLE_SHARE *share;
+ THD *thd = current_thd;
+
+ MRN_DBUG_ENTER_FUNCTION();
+#ifdef MRN_HAVE_GET_TABLE_DEF_KEY
+ const char *key;
+ key_length = get_table_def_key(table_list, &key);
+#else
+ char key[MAX_DBKEY_LENGTH];
+ key_length = create_table_def_key(thd, key, table_list, FALSE);
+#endif
+#if MYSQL_VERSION_ID >= 100002 && defined(MRN_MARIADB_P)
+ share = alloc_table_share(table_list->db.str, table_list->table_name.str, key,
+ key_length);
+#else
+ share = alloc_table_share(table_list, key, key_length);
+#endif
+ if (!share)
+ {
+ *error = ER_CANT_OPEN_FILE;
+ DBUG_RETURN(NULL);
+ }
+ share->tmp_table = NO_TMP_TABLE; // TODO: is this right?
+ share->path.str = (char *) path;
+ share->path.length = strlen(share->path.str);
+ share->normalized_path.str = mrn_my_strdup(path, MYF(MY_WME));
+ share->normalized_path.length = strlen(share->normalized_path.str);
+ if (open_table_def(thd, share, GTS_TABLE))
+ {
+ *error = ER_CANT_OPEN_FILE;
+ mrn_free_tmp_table_share(share);
+ DBUG_RETURN(NULL);
+ }
+ DBUG_RETURN(share);
+}
+
+void mrn_free_tmp_table_share(TABLE_SHARE *tmp_table_share)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ const char *normalized_path = tmp_table_share->normalized_path.str;
+ free_table_share(tmp_table_share);
+ my_free((char*) normalized_path);
+ DBUG_VOID_RETURN;
+}
+
+KEY *mrn_create_key_info_for_table(MRN_SHARE *share, TABLE *table, int *error)
+{
+ uint *wrap_key_nr = share->wrap_key_nr, i, j;
+ KEY *wrap_key_info;
+ MRN_DBUG_ENTER_FUNCTION();
+ if (share->wrap_keys)
+ {
+ if (!(wrap_key_info = (KEY *)
+ mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+ &wrap_key_info, sizeof(*wrap_key_info) * share->wrap_keys,
+ NullS))
+ ) {
+ *error = HA_ERR_OUT_OF_MEM;
+ DBUG_RETURN(NULL);
+ }
+ for (i = 0; i < table->s->keys; i++)
+ {
+ j = wrap_key_nr[i];
+ if (j < MAX_KEY)
+ {
+ memcpy(&wrap_key_info[j], &table->key_info[i],
+ sizeof(*wrap_key_info));
+ }
+ }
+ } else
+ wrap_key_info = NULL;
+ *error = 0;
+ DBUG_RETURN(wrap_key_info);
+}
+
+void mrn_set_bitmap_by_key(MY_BITMAP *map, KEY *key_info)
+{
+ uint i;
+ MRN_DBUG_ENTER_FUNCTION();
+ for (i = 0; i < KEY_N_KEY_PARTS(key_info); i++)
+ {
+ Field *field = key_info->key_part[i].field;
+ bitmap_set_bit(map, field->field_index);
+ }
+ DBUG_VOID_RETURN;
+}
+
+st_mrn_slot_data *mrn_get_slot_data(THD *thd, bool can_create)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_slot_data *slot_data =
+ (st_mrn_slot_data*) thd_get_ha_data(thd, mrn_hton_ptr);
+ if (slot_data == NULL) {
+ slot_data = (st_mrn_slot_data*) malloc(sizeof(st_mrn_slot_data));
+ slot_data->last_insert_record_id = GRN_ID_NIL;
+ slot_data->first_wrap_hton = NULL;
+ slot_data->alter_create_info = NULL;
+ slot_data->disable_keys_create_info = NULL;
+ slot_data->alter_connect_string = NULL;
+ slot_data->alter_comment = NULL;
+ thd_set_ha_data(thd, mrn_hton_ptr, slot_data);
+ {
+ mrn::Lock lock(&mrn_allocated_thds_mutex);
+ if (my_hash_insert(&mrn_allocated_thds, (uchar*) thd))
+ {
+ free(slot_data);
+ DBUG_RETURN(NULL);
+ }
+ }
+ }
+ DBUG_RETURN(slot_data);
+}
+
+void mrn_clear_slot_data(THD *thd)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_slot_data *slot_data = mrn_get_slot_data(thd, FALSE);
+ if (slot_data) {
+ if (slot_data->first_wrap_hton) {
+ st_mrn_wrap_hton *tmp_wrap_hton;
+ st_mrn_wrap_hton *wrap_hton = slot_data->first_wrap_hton;
+ while (wrap_hton)
+ {
+ tmp_wrap_hton = wrap_hton->next;
+ free(wrap_hton);
+ wrap_hton = tmp_wrap_hton;
+ }
+ slot_data->first_wrap_hton = NULL;
+ }
+ slot_data->alter_create_info = NULL;
+ slot_data->disable_keys_create_info = NULL;
+ if (slot_data->alter_connect_string) {
+ my_free(slot_data->alter_connect_string);
+ slot_data->alter_connect_string = NULL;
+ }
+ if (slot_data->alter_comment) {
+ my_free(slot_data->alter_comment);
+ slot_data->alter_comment = NULL;
+ }
+ }
+ DBUG_VOID_RETURN;
+}
+
+#ifdef __cplusplus
+}
+#endif