summaryrefslogtreecommitdiffstats
path: root/storage/mroonga/ha_mroonga.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 18:04:16 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-05-04 18:04:16 +0000
commita68fb2d8219f6bccc573009600e9f23e89226a5e (patch)
treed742d35d14ae816e99293d2b01face30e9f3a46b /storage/mroonga/ha_mroonga.cpp
parentInitial commit. (diff)
downloadmariadb-10.6-a68fb2d8219f6bccc573009600e9f23e89226a5e.tar.xz
mariadb-10.6-a68fb2d8219f6bccc573009600e9f23e89226a5e.zip
Adding upstream version 1:10.6.11.upstream/1%10.6.11upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'storage/mroonga/ha_mroonga.cpp')
-rw-r--r--storage/mroonga/ha_mroonga.cpp17086
1 files changed, 17086 insertions, 0 deletions
diff --git a/storage/mroonga/ha_mroonga.cpp b/storage/mroonga/ha_mroonga.cpp
new file mode 100644
index 00000000..baf6de6c
--- /dev/null
+++ b/storage/mroonga/ha_mroonga.cpp
@@ -0,0 +1,17086 @@
+/* -*- c-basic-offset: 2; indent-tabs-mode: nil -*- */
+/*
+ Copyright(C) 2010 Tetsuro IKEDA
+ Copyright(C) 2010-2013 Kentoku SHIBA
+ Copyright(C) 2011-2017 Kouhei Sutou <kou@clear-code.com>
+ Copyright(C) 2013 Kenji Maruyama <mmmaru777@gmail.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"
+#include "mrn_mysql_compat.h"
+
+#ifdef USE_PRAGMA_IMPLEMENTATION
+#pragma implementation
+#endif
+
+#include <sql_plugin.h>
+#include <sql_show.h>
+#include <key.h>
+#include <tztime.h>
+#include <sql_base.h>
+#include <sql_select.h>
+#include <item_sum.h>
+
+#ifdef MRN_HAVE_BINLOG_H
+# include <binlog.h>
+#endif
+
+#ifdef MRN_HAVE_SQL_OPTIMIZER_H
+# include <sql_optimizer.h>
+#endif
+
+#include <ft_global.h>
+#include <spatial.h>
+#include <mysql.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#ifdef WIN32
+# include <math.h>
+# include <direct.h>
+# define MRN_TABLE_SHARE_LOCK_SHARE_PROC "?key_TABLE_SHARE_LOCK_share@@3IA"
+# define MRN_TABLE_SHARE_LOCK_HA_DATA_PROC "?key_TABLE_SHARE_LOCK_ha_data@@3IA"
+# ifdef _WIN64
+# define MRN_BINLOG_FILTER_PROC "?binlog_filter@@3PEAVRpl_filter@@EA"
+# define MRN_MY_TZ_UTC_PROC "?my_tz_UTC@@3PEAVTime_zone@@EA"
+# else
+# define MRN_BINLOG_FILTER_PROC "?binlog_filter@@3PAVRpl_filter@@A"
+# define MRN_MY_TZ_UTC_PROC "?my_tz_UTC@@3PAVTime_zone@@A"
+# endif
+#else
+# include <dirent.h>
+# include <unistd.h>
+#endif
+
+#include "mrn_err.h"
+#include "mrn_table.hpp"
+#include <groonga/plugin.h>
+#include "ha_mroonga.hpp"
+#include <mrn_path_mapper.hpp>
+#include <mrn_index_table_name.hpp>
+#include <mrn_index_column_name.hpp>
+#include <mrn_debug_column_access.hpp>
+#include <mrn_auto_increment_value_lock.hpp>
+#include <mrn_external_lock.hpp>
+#include <mrn_match_escalation_threshold_scope.hpp>
+#include <mrn_multiple_column_key_codec.hpp>
+#include <mrn_field_normalizer.hpp>
+#include <mrn_encoding.hpp>
+#include <mrn_parameters_parser.hpp>
+#include <mrn_lock.hpp>
+#include <mrn_condition_converter.hpp>
+#include <mrn_time_converter.hpp>
+#include <mrn_smart_grn_obj.hpp>
+#include <mrn_database_manager.hpp>
+#include <mrn_context_pool.hpp>
+#include <mrn_grn.hpp>
+#include <mrn_value_decoder.hpp>
+#include <mrn_database_repairer.hpp>
+#include <mrn_operation.hpp>
+#include <mrn_column_name.hpp>
+#include <mrn_count_skip_checker.hpp>
+#include <mrn_variables.hpp>
+#include <mrn_query_parser.hpp>
+#include <mrn_smart_bitmap.hpp>
+#include <mrn_table_fields_offset_mover.hpp>
+
+#ifdef MRN_SUPPORT_FOREIGN_KEYS
+# include <sql_table.h>
+#endif
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+# include <create_options.h>
+#endif
+
+// for debug
+#define MRN_CLASS_NAME "ha_mroonga"
+
+#define MRN_SHORT_TEXT_SIZE (1 << 12) // 4Kbytes
+#define MRN_TEXT_SIZE (1 << 16) // 64Kbytes
+#define MRN_LONG_TEXT_SIZE (1 << 31) // 2Gbytes
+
+#ifdef MRN_HAVE_TDC_LOCK_TABLE_SHARE
+# ifdef MRN_TABLE_SHARE_TDC_IS_POINTER
+# define mrn_open_mutex(share) &((share)->tdc->LOCK_table_share)
+# else
+# define mrn_open_mutex(share) &((share)->tdc.LOCK_table_share)
+# endif
+# define mrn_open_mutex_lock(share) do { \
+ TABLE_SHARE *share_ = share; \
+ if (share_ && share_->tmp_table == NO_TMP_TABLE) { \
+ mysql_mutex_lock(mrn_open_mutex(share_)); \
+ } \
+} while (0)
+# define mrn_open_mutex_unlock(share) do { \
+ TABLE_SHARE *share_ = share; \
+ if (share_ && share_->tmp_table == NO_TMP_TABLE) { \
+ mysql_mutex_unlock(mrn_open_mutex(share_)); \
+ } \
+} while (0)
+#else
+# ifdef DBUG_OFF
+# ifndef _WIN32
+extern mysql_mutex_t LOCK_open;
+# endif
+# endif
+static mysql_mutex_t *mrn_LOCK_open;
+# define mrn_open_mutex_lock(share) mysql_mutex_lock(mrn_LOCK_open)
+# define mrn_open_mutex_unlock(share) mysql_mutex_unlock(mrn_LOCK_open)
+#endif
+
+#if MYSQL_VERSION_ID >= 50600
+# define MRN_NEED_M_LOCK_TYPE_CHECK_FOR_WRAPPER_EXTERNAL_LOCK
+#endif
+
+#ifdef MRN_MARIADB_P
+# if MYSQL_VERSION_ID >= 100200
+# define MRN_ORDER_IS_ASC(order) ((order)->direction == ORDER::ORDER_ASC)
+# else
+# define MRN_ORDER_IS_ASC(order) ((order)->asc)
+# endif
+#else
+# if MYSQL_VERSION_ID >= 50603
+# define MRN_ORDER_IS_ASC(order) ((order)->direction == ORDER::ORDER_ASC)
+# else
+# define MRN_ORDER_IS_ASC(order) ((order)->asc)
+# endif
+#endif
+
+#define MRN_STRINGIFY(macro_or_string) MRN_STRINGIFY_ARG(macro_or_string)
+#define MRN_STRINGIFY_ARG(contents) #contents
+
+#define MRN_PLUGIN_NAME mroonga
+#define MRN_PLUGIN_NAME_STRING "Mroonga"
+#define MRN_STATUS_VARIABLE_NAME_PREFIX_STRING "Mroonga"
+
+#ifdef MRN_MARIADB_P
+# define st_mysql_plugin st_maria_plugin
+# define mrn_declare_plugin(NAME) maria_declare_plugin(NAME)
+# define mrn_declare_plugin_end maria_declare_plugin_end
+# define MRN_PLUGIN_LAST_VALUES MRN_VERSION, MariaDB_PLUGIN_MATURITY_STABLE
+#else
+# define mrn_declare_plugin(NAME) mysql_declare_plugin(NAME)
+# define mrn_declare_plugin_end mysql_declare_plugin_end
+# define MRN_PLUGIN_LAST_VALUES NULL, 0
+#endif
+
+#if MYSQL_VERSION_ID >= 100007 && defined(MRN_MARIADB_P)
+# define MRN_THD_GET_AUTOINC(thd, off, inc) thd_get_autoinc(thd, off, inc)
+# define MRN_GET_ERR_MSG(code) my_get_err_msg(code)
+#else
+# define MRN_THD_GET_AUTOINC(thd, off, inc) \
+ { \
+ *(off) = thd->variables.auto_increment_offset; \
+ *(inc) = thd->variables.auto_increment_increment; \
+ }
+# define MRN_GET_ERR_MSG(code) ER(code)
+#endif
+
+#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P)
+# define MRN_LEX_GET_TABLE_LIST(lex) (lex)->select_lex->table_list.first
+#else
+# define MRN_LEX_GET_TABLE_LIST(lex) (lex)->first_select_lex()->table_list.first
+#endif
+
+#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P)
+# define MRN_KEYTYPE_FOREIGN KEYTYPE_FOREIGN
+#else
+# define MRN_KEYTYPE_FOREIGN Key::FOREIGN_KEY
+#endif
+
+#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P)
+# define mrn_calculate_key_len(table, key_index, buffer, keypart_map) \
+ calculate_key_len(table, key_index, keypart_map)
+#else
+# define mrn_calculate_key_len(table, key_index, buffer, keypart_map) \
+ calculate_key_len(table, key_index, buffer, keypart_map)
+#endif
+
+#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P)
+# define MRN_TABLE_LIST_GET_DERIVED(table_list) NULL
+#else
+# define MRN_TABLE_LIST_GET_DERIVED(table_list) (table_list)->derived
+#endif
+
+#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P)
+# define MRN_GEOMETRY_FREE(geometry)
+#else
+# define MRN_GEOMETRY_FREE(geometry) delete (geometry)
+#endif
+
+Rpl_filter *mrn_binlog_filter;
+Time_zone *mrn_my_tz_UTC;
+#ifdef MRN_HAVE_TABLE_DEF_CACHE
+HASH *mrn_table_def_cache;
+#endif
+
+PSI_memory_key mrn_memory_key;
+
+#ifdef MRN_HAVE_PSI_MEMORY_KEY
+static PSI_memory_info mrn_all_memory_keys[]=
+{
+ {&mrn_memory_key, "Mroonga", 0}
+};
+#endif
+
+static const char *INDEX_COLUMN_NAME = "index";
+static const char *MRN_PLUGIN_AUTHOR = "The Mroonga project";
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef HAVE_PSI_INTERFACE
+# ifdef WIN32
+# ifdef MRN_TABLE_SHARE_HAVE_LOCK_SHARE
+PSI_mutex_key *mrn_table_share_lock_share;
+# endif
+PSI_mutex_key *mrn_table_share_lock_ha_data;
+# endif
+static PSI_mutex_key mrn_open_tables_mutex_key;
+static PSI_mutex_key mrn_long_term_share_mutex_key;
+static PSI_mutex_key mrn_allocated_thds_mutex_key;
+PSI_mutex_key mrn_share_mutex_key;
+PSI_mutex_key mrn_long_term_share_auto_inc_mutex_key;
+static PSI_mutex_key mrn_log_mutex_key;
+static PSI_mutex_key mrn_query_log_mutex_key;
+static PSI_mutex_key mrn_db_manager_mutex_key;
+static PSI_mutex_key mrn_context_pool_mutex_key;
+static PSI_mutex_key mrn_operations_mutex_key;
+
+# if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002)
+# define MRN_MUTEXT_INFO_ENTRY(key, name, flags, volatility) \
+ {key, name, flags, volatility}
+# else
+# define MRN_MUTEXT_INFO_ENTRY(key, name, flags, volatility) \
+ {key, name, flags}
+# endif
+
+static PSI_mutex_info mrn_mutexes[] =
+{
+ MRN_MUTEXT_INFO_ENTRY(&mrn_open_tables_mutex_key,
+ "mrn::open_tables", PSI_FLAG_GLOBAL, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_long_term_share_mutex_key,
+ "mrn::long_term_share", PSI_FLAG_GLOBAL, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_allocated_thds_mutex_key,
+ "mrn::allocated_thds", PSI_FLAG_GLOBAL, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_share_mutex_key,
+ "mrn::share", 0, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_long_term_share_auto_inc_mutex_key,
+ "mrn::long_term_share::auto_inc", 0, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_log_mutex_key,
+ "mrn::log", PSI_FLAG_GLOBAL, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_query_log_mutex_key,
+ "mrn::query_log", PSI_FLAG_GLOBAL, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_db_manager_mutex_key,
+ "mrn::DatabaseManager", PSI_FLAG_GLOBAL, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_context_pool_mutex_key,
+ "mrn::ContextPool", PSI_FLAG_GLOBAL, 0),
+ MRN_MUTEXT_INFO_ENTRY(&mrn_operations_mutex_key,
+ "mrn::Operations", PSI_FLAG_GLOBAL, 0)
+};
+#endif
+
+/* global variables */
+handlerton *mrn_hton_ptr;
+HASH mrn_open_tables;
+mysql_mutex_t mrn_open_tables_mutex;
+HASH mrn_long_term_share;
+mysql_mutex_t mrn_long_term_share_mutex;
+
+HASH mrn_allocated_thds;
+mysql_mutex_t mrn_allocated_thds_mutex;
+
+/* internal variables */
+static grn_ctx mrn_ctx;
+static mysql_mutex_t mrn_log_mutex;
+static mysql_mutex_t mrn_query_log_mutex;
+static grn_obj *mrn_db;
+static grn_ctx mrn_db_manager_ctx;
+static mysql_mutex_t mrn_db_manager_mutex;
+mrn::DatabaseManager *mrn_db_manager = NULL;
+static mysql_mutex_t mrn_context_pool_mutex;
+mrn::ContextPool *mrn_context_pool = NULL;
+static mysql_mutex_t mrn_operations_mutex;
+
+
+#ifdef WIN32
+static inline double round(double x)
+{
+ return (floor(x + 0.5));
+}
+#endif
+
+static void mrn_init_encoding_map()
+{
+ mrn::encoding::init();
+}
+
+static int mrn_change_encoding(grn_ctx *ctx, const CHARSET_INFO *charset)
+{
+ return mrn::encoding::set(ctx, charset);
+}
+
+#if defined DBUG_TRACE && !defined(_lint)
+static const char *mrn_inspect_thr_lock_type(enum thr_lock_type lock_type)
+{
+ const char *inspected = "<unknown>";
+ switch (lock_type) {
+ case TL_IGNORE:
+ inspected = "TL_IGNORE";
+ break;
+ case TL_UNLOCK:
+ inspected = "TL_UNLOCK";
+ break;
+ case TL_READ_DEFAULT:
+ inspected = "TL_READ_DEFAULT";
+ break;
+ case TL_READ:
+ inspected = "TL_READ";
+ break;
+ case TL_READ_WITH_SHARED_LOCKS:
+ inspected = "TL_READ_WITH_SHARED_LOCKS";
+ break;
+ case TL_READ_HIGH_PRIORITY:
+ inspected = "TL_READ_HIGH_PRIORITY";
+ break;
+ case TL_READ_NO_INSERT:
+ inspected = "TL_READ_NO_INSERT";
+ break;
+ case TL_READ_SKIP_LOCKED:
+ inspected = "TL_READ_SKIP_LOCKED";
+ break;
+ case TL_WRITE_ALLOW_WRITE:
+ inspected = "TL_WRITE_ALLOW_WRITE";
+ break;
+#ifdef MRN_HAVE_TL_WRITE_CONCURRENT_DEFAULT
+ case TL_WRITE_CONCURRENT_DEFAULT:
+ inspected = "TL_WRITE_CONCURRENT_DEFAULT";
+ break;
+#endif
+ case TL_WRITE_CONCURRENT_INSERT:
+ inspected = "TL_WRITE_CONCURRENT_INSERT";
+ break;
+#ifdef MRN_HAVE_TL_WRITE_DELAYED
+ case TL_WRITE_DELAYED:
+ inspected = "TL_WRITE_DELAYED";
+ break;
+#endif
+ case TL_WRITE_DEFAULT:
+ inspected = "TL_WRITE_DEFAULT";
+ break;
+ case TL_WRITE_LOW_PRIORITY:
+ inspected = "TL_WRITE_LOW_PRIORITY";
+ break;
+ case TL_WRITE:
+ inspected = "TL_WRITE";
+ break;
+ case TL_WRITE_SKIP_LOCKED:
+ inspected = "TL_WRITE_SKIP_LOCKED";
+ break;
+ case TL_WRITE_ONLY:
+ inspected = "TL_WRITE_ONLY";
+ break;
+ }
+ return inspected;
+}
+
+static const char *mrn_inspect_extra_function(enum ha_extra_function operation)
+{
+ const char *inspected = "<unknown>";
+ switch (operation) {
+ case HA_EXTRA_NORMAL:
+ inspected = "HA_EXTRA_NORMAL";
+ break;
+ case HA_EXTRA_QUICK:
+ inspected = "HA_EXTRA_QUICK";
+ break;
+ case HA_EXTRA_NOT_USED:
+ inspected = "HA_EXTRA_NOT_USED";
+ break;
+ case HA_EXTRA_CACHE:
+ inspected = "HA_EXTRA_CACHE";
+ break;
+ case HA_EXTRA_NO_CACHE:
+ inspected = "HA_EXTRA_NO_CACHE";
+ break;
+ case HA_EXTRA_NO_READCHECK:
+ inspected = "HA_EXTRA_NO_READCHECK";
+ break;
+ case HA_EXTRA_READCHECK:
+ inspected = "HA_EXTRA_READCHECK";
+ break;
+ case HA_EXTRA_KEYREAD:
+ inspected = "HA_EXTRA_KEYREAD";
+ break;
+ case HA_EXTRA_NO_KEYREAD:
+ inspected = "HA_EXTRA_NO_KEYREAD";
+ break;
+ case HA_EXTRA_NO_USER_CHANGE:
+ inspected = "HA_EXTRA_NO_USER_CHANGE";
+ break;
+ case HA_EXTRA_KEY_CACHE:
+ inspected = "HA_EXTRA_KEY_CACHE";
+ break;
+ case HA_EXTRA_NO_KEY_CACHE:
+ inspected = "HA_EXTRA_NO_KEY_CACHE";
+ break;
+ case HA_EXTRA_WAIT_LOCK:
+ inspected = "HA_EXTRA_WAIT_LOCK";
+ break;
+ case HA_EXTRA_NO_WAIT_LOCK:
+ inspected = "HA_EXTRA_NO_WAIT_LOCK";
+ break;
+ case HA_EXTRA_WRITE_CACHE:
+ inspected = "HA_EXTRA_WRITE_CACHE";
+ break;
+ case HA_EXTRA_FLUSH_CACHE:
+ inspected = "HA_EXTRA_FLUSH_CACHE";
+ break;
+ case HA_EXTRA_NO_KEYS:
+ inspected = "HA_EXTRA_NO_KEYS";
+ break;
+ case HA_EXTRA_KEYREAD_CHANGE_POS:
+ inspected = "HA_EXTRA_KEYREAD_CHANGE_POS";
+ break;
+ case HA_EXTRA_REMEMBER_POS:
+ inspected = "HA_EXTRA_REMEMBER_POS";
+ break;
+ case HA_EXTRA_RESTORE_POS:
+ inspected = "HA_EXTRA_RESTORE_POS";
+ break;
+ case HA_EXTRA_REINIT_CACHE:
+ inspected = "HA_EXTRA_REINIT_CACHE";
+ break;
+ case HA_EXTRA_FORCE_REOPEN:
+ inspected = "HA_EXTRA_FORCE_REOPEN";
+ break;
+ case HA_EXTRA_FLUSH:
+ inspected = "HA_EXTRA_FLUSH";
+ break;
+ case HA_EXTRA_NO_ROWS:
+ inspected = "HA_EXTRA_NO_ROWS";
+ break;
+ case HA_EXTRA_RESET_STATE:
+ inspected = "HA_EXTRA_RESET_STATE";
+ break;
+ case HA_EXTRA_IGNORE_DUP_KEY:
+ inspected = "HA_EXTRA_IGNORE_DUP_KEY";
+ break;
+ case HA_EXTRA_NO_IGNORE_DUP_KEY:
+ inspected = "HA_EXTRA_NO_IGNORE_DUP_KEY";
+ break;
+ case HA_EXTRA_PREPARE_FOR_DROP:
+ inspected = "HA_EXTRA_PREPARE_FOR_DROP";
+ break;
+ case HA_EXTRA_PREPARE_FOR_ALTER_TABLE:
+ inspected = "HA_EXTRA_PREPARE_FOR_ALTER_TABLE";
+ break;
+ case HA_EXTRA_PREPARE_FOR_UPDATE:
+ inspected = "HA_EXTRA_PREPARE_FOR_UPDATE";
+ break;
+ case HA_EXTRA_PRELOAD_BUFFER_SIZE:
+ inspected = "HA_EXTRA_PRELOAD_BUFFER_SIZE";
+ break;
+ case HA_EXTRA_CHANGE_KEY_TO_UNIQUE:
+ inspected = "HA_EXTRA_CHANGE_KEY_TO_UNIQUE";
+ break;
+ case HA_EXTRA_CHANGE_KEY_TO_DUP:
+ inspected = "HA_EXTRA_CHANGE_KEY_TO_DUP";
+ break;
+ case HA_EXTRA_KEYREAD_PRESERVE_FIELDS:
+ inspected = "HA_EXTRA_KEYREAD_PRESERVE_FIELDS";
+ break;
+ case HA_EXTRA_MMAP:
+ inspected = "HA_EXTRA_MMAP";
+ break;
+ case HA_EXTRA_IGNORE_NO_KEY:
+ inspected = "HA_EXTRA_IGNORE_NO_KEY";
+ break;
+ case HA_EXTRA_NO_IGNORE_NO_KEY:
+ inspected = "HA_EXTRA_NO_IGNORE_NO_KEY";
+ break;
+ case HA_EXTRA_MARK_AS_LOG_TABLE:
+ inspected = "HA_EXTRA_MARK_AS_LOG_TABLE";
+ break;
+ case HA_EXTRA_WRITE_CAN_REPLACE:
+ inspected = "HA_EXTRA_WRITE_CAN_REPLACE";
+ break;
+ case HA_EXTRA_WRITE_CANNOT_REPLACE:
+ inspected = "HA_EXTRA_WRITE_CANNOT_REPLACE";
+ break;
+ case HA_EXTRA_DELETE_CANNOT_BATCH:
+ inspected = "HA_EXTRA_DELETE_CANNOT_BATCH";
+ break;
+ case HA_EXTRA_UPDATE_CANNOT_BATCH:
+ inspected = "HA_EXTRA_UPDATE_CANNOT_BATCH";
+ break;
+ case HA_EXTRA_INSERT_WITH_UPDATE:
+ inspected = "HA_EXTRA_INSERT_WITH_UPDATE";
+ break;
+ case HA_EXTRA_PREPARE_FOR_RENAME:
+ inspected = "HA_EXTRA_PREPARE_FOR_RENAME";
+ break;
+ case HA_EXTRA_ADD_CHILDREN_LIST:
+ inspected = "HA_EXTRA_ADD_CHILDREN_LIST";
+ break;
+ case HA_EXTRA_ATTACH_CHILDREN:
+ inspected = "HA_EXTRA_ATTACH_CHILDREN";
+ break;
+ case HA_EXTRA_IS_ATTACHED_CHILDREN:
+ inspected = "HA_EXTRA_IS_ATTACHED_CHILDREN";
+ break;
+ case HA_EXTRA_DETACH_CHILDREN:
+ inspected = "HA_EXTRA_DETACH_CHILDREN";
+ break;
+ case HA_EXTRA_STARTING_ORDERED_INDEX_SCAN:
+ inspected = "HA_EXTRA_STARTING_ORDERED_INDEX_SCAN";
+ break;
+ case HA_EXTRA_BEGIN_ALTER_COPY:
+ inspected = "HA_EXTRA_BEGIN_ALTER_COPY";
+ break;
+ case HA_EXTRA_END_ALTER_COPY:
+ inspected = "HA_EXTRA_END_ALTER_COPY";
+ break;
+#ifdef MRN_HAVE_HA_EXTRA_EXPORT
+ case HA_EXTRA_EXPORT:
+ inspected = "HA_EXTRA_EXPORT";
+ break;
+#endif
+#ifdef MRN_HAVE_HA_EXTRA_SECONDARY_SORT_ROWID
+ case HA_EXTRA_SECONDARY_SORT_ROWID:
+ inspected = "HA_EXTRA_SECONDARY_SORT_ROWID";
+ break;
+#endif
+#ifdef MRN_HAVE_HA_EXTRA_DETACH_CHILD
+ case HA_EXTRA_DETACH_CHILD:
+ inspected = "HA_EXTRA_DETACH_CHILD";
+ break;
+#endif
+#ifdef MRN_HAVE_HA_EXTRA_PREPARE_FOR_FORCED_CLOSE
+ case HA_EXTRA_PREPARE_FOR_FORCED_CLOSE:
+ inspected = "HA_EXTRA_PREPARE_FOR_FORCED_CLOSE";
+ break;
+#endif
+#ifdef MRN_HAVE_HA_EXTRA_SKIP_SERIALIZABLE_DD_VIEW
+ case HA_EXTRA_SKIP_SERIALIZABLE_DD_VIEW:
+ inspected = "HA_EXTRA_SKIP_SERIALIZABLE_DD_VIEW";
+ break;
+#endif
+#ifdef MRN_HAVE_HA_EXTRA_BEGIN_ALTER_COPY
+ case HA_EXTRA_BEGIN_ALTER_COPY:
+ inspected = "HA_EXTRA_BEGIN_ALTER_COPY";
+ break;
+#endif
+#ifdef MRN_HAVE_HA_EXTRA_END_ALTER_COPY
+ case HA_EXTRA_END_ALTER_COPY:
+ inspected = "HA_EXTRA_END_ALTER_COPY";
+ break;
+#endif
+#ifdef MRN_HAVE_HA_EXTRA_NO_AUTOINC_LOCKING
+ case HA_EXTRA_NO_AUTOINC_LOCKING:
+ inspected = "HA_EXTRA_NO_AUTOINC_LOCKING";
+ break;
+#endif
+ case HA_EXTRA_IGNORE_INSERT:
+ inspected = "HA_EXTRA_IGNORE_INSERT";
+ break;
+ }
+ return inspected;
+}
+#endif
+
+static uchar *mrn_open_tables_get_key(const uchar *record,
+ size_t *length,
+ my_bool not_used __attribute__ ((unused)))
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ MRN_SHARE *share = reinterpret_cast<MRN_SHARE *>(const_cast<uchar *>(record));
+ *length = share->table_name_length;
+ DBUG_RETURN(reinterpret_cast<uchar *>(share->table_name));
+}
+
+static uchar *mrn_long_term_share_get_key(const uchar *record,
+ size_t *length,
+ my_bool not_used __attribute__ ((unused)))
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ MRN_LONG_TERM_SHARE *long_term_share =
+ reinterpret_cast<MRN_LONG_TERM_SHARE *>(const_cast<uchar *>(record));
+ *length = long_term_share->table_name_length;
+ DBUG_RETURN(reinterpret_cast<uchar *>(long_term_share->table_name));
+}
+
+/* status */
+static long mrn_count_skip = 0;
+static long mrn_fast_order_limit = 0;
+
+/* logging */
+static char *mrn_log_file_path = NULL;
+static FILE *mrn_log_file = NULL;
+static bool mrn_log_file_opened = false;
+static grn_log_level mrn_log_level_default = GRN_LOG_DEFAULT_LEVEL;
+static ulong mrn_log_level = mrn_log_level_default;
+static char *mrn_query_log_file_path = NULL;
+
+char *mrn_default_tokenizer = NULL;
+char *mrn_default_wrapper_engine = NULL;
+static int mrn_lock_timeout = grn_get_lock_timeout();
+static char *mrn_libgroonga_version = const_cast<char *>(grn_get_version());
+static char *mrn_version = const_cast<char *>(MRN_VERSION);
+static char *mrn_vector_column_delimiter = NULL;
+static mrn_bool mrn_libgroonga_support_zlib = false;
+static mrn_bool mrn_libgroonga_support_lz4 = false;
+static mrn_bool mrn_libgroonga_support_zstd = false;
+static mrn_bool mrn_enable_operations_recording = true;
+#ifdef MRN_SUPPORT_THDVAR_SET
+static const char *mrn_boolean_mode_sytnax_flag_names[] = {
+ "DEFAULT",
+ "SYNTAX_QUERY",
+ "SYNTAX_SCRIPT",
+ "ALLOW_COLUMN",
+ "ALLOW_UPDATE",
+ "ALLOW_LEADING_NOT",
+ NullS
+};
+static TYPELIB mrn_boolean_mode_syntax_flags_typelib = {
+ array_elements(mrn_boolean_mode_sytnax_flag_names) - 1,
+ "",
+ mrn_boolean_mode_sytnax_flag_names,
+ NULL
+};
+#endif
+#ifdef MRN_GROONGA_EMBEDDED
+static mrn_bool mrn_libgroonga_embedded = true;
+#else
+static mrn_bool mrn_libgroonga_embedded = false;
+#endif
+
+static mrn::variables::ActionOnError mrn_action_on_fulltext_query_error_default =
+ mrn::variables::ACTION_ON_ERROR_ERROR_AND_LOG;
+
+static void mrn_logger_log(grn_ctx *ctx, grn_log_level level,
+ const char *timestamp, const char *title,
+ const char *message, const char *location,
+ void *user_data)
+{
+ const char level_marks[] = " EACewnid-";
+ if (mrn_log_file_opened) {
+ mrn::Lock lock(&mrn_log_mutex);
+ fprintf(mrn_log_file,
+ "%s|%c|%08x|%s\n",
+ timestamp,
+ level_marks[level],
+ static_cast<uint>((ulong)(pthread_self())),
+ message);
+ fflush(mrn_log_file);
+ }
+}
+
+static grn_logger mrn_logger = {
+ mrn_log_level_default,
+ GRN_LOG_TIME|GRN_LOG_MESSAGE,
+ NULL,
+ mrn_logger_log,
+ NULL,
+ NULL
+};
+
+static uchar *mrn_allocated_thds_get_key(const uchar *record,
+ size_t *length,
+ my_bool not_used __attribute__ ((unused)))
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ *length = sizeof(THD *);
+ DBUG_RETURN(const_cast<uchar *>(record));
+}
+
+/* system functions */
+
+static struct st_mysql_storage_engine storage_engine_structure =
+{ MYSQL_HANDLERTON_INTERFACE_VERSION };
+
+#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P)
+# define MRN_STATUS_VARIABLE_ENTRY(name, value, type, scope) \
+ {name, value, type, scope}
+#else
+# define MRN_STATUS_VARIABLE_ENTRY(name, value, type, scope) \
+ {name, value, type}
+#endif
+
+static struct st_mysql_show_var mrn_status_variables[] =
+{
+ MRN_STATUS_VARIABLE_ENTRY(MRN_STATUS_VARIABLE_NAME_PREFIX_STRING "_count_skip",
+ (char *)&mrn_count_skip,
+ SHOW_LONG,
+ SHOW_SCOPE_GLOBAL),
+ MRN_STATUS_VARIABLE_ENTRY(MRN_STATUS_VARIABLE_NAME_PREFIX_STRING "_fast_order_limit",
+ (char *)&mrn_fast_order_limit,
+ SHOW_LONG,
+ SHOW_SCOPE_GLOBAL),
+ MRN_STATUS_VARIABLE_ENTRY(NullS, NullS, SHOW_LONG, SHOW_SCOPE_GLOBAL)
+};
+
+static const char *mrn_log_level_type_names[] = {
+ "NONE",
+ "EMERG",
+ "ALERT",
+ "CRIT",
+ "ERROR",
+ "WARNING",
+ "NOTICE",
+ "INFO",
+ "DEBUG",
+ "DUMP",
+ NullS
+};
+static TYPELIB mrn_log_level_typelib = {
+ array_elements(mrn_log_level_type_names) - 1,
+ "mrn_log_level_typelib",
+ mrn_log_level_type_names,
+ NULL
+};
+
+static void mrn_log_level_update(THD *thd, struct st_mysql_sys_var *var,
+ void *var_ptr, const void *save)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulong new_value = *static_cast<const ulong *>(save);
+ ulong old_value = mrn_log_level;
+ mrn_log_level = new_value;
+ mrn_logger.max_level = static_cast<grn_log_level>(mrn_log_level);
+ grn_logger_set(&mrn_ctx, &mrn_logger);
+ grn_ctx *ctx = grn_ctx_open(0);
+ mrn_change_encoding(ctx, system_charset_info);
+ GRN_LOG(ctx, GRN_LOG_NOTICE, "log level changed from '%s' to '%s'",
+ mrn_log_level_type_names[old_value],
+ mrn_log_level_type_names[new_value]);
+ grn_ctx_fin(ctx);
+ DBUG_VOID_RETURN;
+}
+
+static MYSQL_SYSVAR_ENUM(log_level, mrn_log_level,
+ PLUGIN_VAR_RQCMDARG,
+ "logging level",
+ NULL,
+ mrn_log_level_update,
+ static_cast<ulong>(mrn_log_level),
+ &mrn_log_level_typelib);
+
+static void mrn_log_file_update(THD *thd, struct st_mysql_sys_var *var,
+ void *var_ptr, const void *save)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ const char *new_value = *((const char **)save);
+ char **old_value_ptr = (char **)var_ptr;
+
+ grn_ctx *ctx = &mrn_ctx;
+ mrn_change_encoding(ctx, system_charset_info);
+
+ const char *new_log_file_name;
+ new_log_file_name = *old_value_ptr;
+
+ if (strcmp(*old_value_ptr, new_value) == 0) {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "log file isn't changed "
+ "because the requested path isn't different: <%s>",
+ new_value);
+ } else {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "log file is changed: <%s> -> <%s>",
+ *old_value_ptr, new_value);
+
+ int log_file_open_errno = 0;
+ {
+ mrn::Lock lock(&mrn_log_mutex);
+ FILE *new_log_file;
+ new_log_file = fopen(new_value, "a");
+ if (new_log_file) {
+ if (mrn_log_file_opened) {
+ fclose(mrn_log_file);
+ }
+ mrn_log_file = new_log_file;
+ mrn_log_file_opened = true;
+ } else {
+ log_file_open_errno = errno;
+ }
+ }
+
+ if (log_file_open_errno == 0) {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "log file is changed: <%s> -> <%s>",
+ *old_value_ptr, new_value);
+ new_log_file_name = new_value;
+ } else {
+ if (mrn_log_file) {
+ GRN_LOG(ctx, GRN_LOG_ERROR,
+ "log file isn't changed "
+ "because the requested path can't be opened: <%s>: <%s>",
+ new_value, strerror(log_file_open_errno));
+ } else {
+ GRN_LOG(ctx, GRN_LOG_ERROR,
+ "log file can't be opened: <%s>: <%s>",
+ new_value, strerror(log_file_open_errno));
+ }
+ }
+ }
+
+#ifdef MRN_NEED_FREE_STRING_MEMALLOC_PLUGIN_VAR
+ char *old_log_file_name = *old_value_ptr;
+ *old_value_ptr = mrn_my_strdup(new_log_file_name, MYF(MY_WME));
+ my_free(old_log_file_name);
+#else
+ *old_value_ptr = mrn_my_strdup(new_log_file_name, MYF(MY_WME));
+#endif
+
+ DBUG_VOID_RETURN;
+}
+
+static MYSQL_SYSVAR_STR(log_file, mrn_log_file_path,
+ PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC,
+ "log file for " MRN_PLUGIN_NAME_STRING,
+ NULL,
+ mrn_log_file_update,
+ MRN_LOG_FILE_PATH);
+
+static void mrn_query_log_file_update(THD *thd, struct st_mysql_sys_var *var,
+ void *var_ptr, const void *save)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ const char *new_value = *((const char **)save);
+ char **old_value_ptr = (char **)var_ptr;
+ const char *normalized_new_value = NULL;
+
+ grn_ctx *ctx = &mrn_ctx;
+ mrn_change_encoding(ctx, system_charset_info);
+
+ const char *new_query_log_file_name;
+ new_query_log_file_name = *old_value_ptr;
+
+ bool need_update = false;
+ if (!*old_value_ptr) {
+ if (new_value && new_value[0] != '\0') {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "query log is enabled: <%s>",
+ new_value);
+ need_update = true;
+ normalized_new_value = new_value;
+ } else {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "query log file is still disabled");
+ }
+ } else {
+ if (!new_value || new_value[0] == '\0') {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "query log file is disabled: <%s>",
+ *old_value_ptr);
+ need_update = true;
+ normalized_new_value = NULL;
+ } else if (strcmp(*old_value_ptr, new_value) == 0) {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "query log file isn't changed "
+ "because the requested path isn't different: <%s>",
+ new_value);
+ } else {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "query log file is changed: <%s> -> <%s>",
+ *old_value_ptr, new_value);
+ need_update = true;
+ normalized_new_value = new_value;
+ }
+ }
+
+ if (need_update) {
+ { // TODO: Remove me when Groonga 7.0.5 is released.
+ mrn::Lock lock(&mrn_query_log_mutex);
+ grn_default_query_logger_set_path(normalized_new_value);
+ }
+ grn_query_logger_reopen(ctx);
+ new_query_log_file_name = normalized_new_value;
+ }
+
+#ifdef MRN_NEED_FREE_STRING_MEMALLOC_PLUGIN_VAR
+ char *old_query_log_file_name = *old_value_ptr;
+#endif
+ if (new_query_log_file_name) {
+ *old_value_ptr = mrn_my_strdup(new_query_log_file_name, MYF(0));
+ } else {
+ *old_value_ptr = NULL;
+ }
+#ifdef MRN_NEED_FREE_STRING_MEMALLOC_PLUGIN_VAR
+ my_free(old_query_log_file_name);
+#endif
+
+ DBUG_VOID_RETURN;
+}
+
+static MYSQL_SYSVAR_STR(query_log_file, mrn_query_log_file_path,
+ PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC,
+ "query log file for " MRN_PLUGIN_NAME_STRING,
+ NULL,
+ mrn_query_log_file_update,
+ NULL);
+
+static void mrn_default_tokenizer_update(THD *thd, struct st_mysql_sys_var *var,
+ void *var_ptr, const void *save)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ const char *new_value = *((const char **)save);
+ char **old_value_ptr = (char **)var_ptr;
+ grn_ctx *ctx = &mrn_ctx;
+
+ mrn_change_encoding(ctx, system_charset_info);
+ if (strcmp(*old_value_ptr, new_value) == 0) {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "default tokenizer for fulltext index isn't changed "
+ "because the requested default tokenizer isn't different: <%s>",
+ new_value);
+ } else {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "default tokenizer for fulltext index is changed: <%s> -> <%s>",
+ *old_value_ptr, new_value);
+ }
+
+#ifdef MRN_NEED_FREE_STRING_MEMALLOC_PLUGIN_VAR
+ my_free(*old_value_ptr);
+ *old_value_ptr = mrn_my_strdup(new_value, MYF(MY_WME));
+#else
+ *old_value_ptr = (char *)new_value;
+#endif
+
+ DBUG_VOID_RETURN;
+}
+
+static MYSQL_SYSVAR_STR(default_parser, mrn_default_tokenizer,
+ PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC,
+ "default fulltext parser "
+ "(Deprecated. Use mroonga_default_tokenizer instead.)",
+ NULL,
+ mrn_default_tokenizer_update,
+ MRN_DEFAULT_TOKENIZER); // since 10.1.6
+
+static MYSQL_SYSVAR_STR(default_tokenizer, mrn_default_tokenizer,
+ PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC,
+ "default tokenizer for fulltext index",
+ NULL,
+ mrn_default_tokenizer_update,
+ MRN_DEFAULT_TOKENIZER);
+
+static MYSQL_THDVAR_BOOL(
+ dry_write, /* name */
+ PLUGIN_VAR_OPCMDARG, /* options */
+ "If dry_write is true, any write operations are ignored.", /* comment */
+ NULL, /* check */
+ NULL, /* update */
+ false /* default */
+);
+
+static MYSQL_THDVAR_BOOL(
+ enable_optimization, /* name */
+ PLUGIN_VAR_OPCMDARG, /* options */
+ "If enable_optimization is true, some optimizations will be applied.", /* comment */
+ NULL, /* check */
+ NULL, /* update */
+ true /* default */
+);
+
+static MYSQL_THDVAR_LONGLONG(match_escalation_threshold,
+ PLUGIN_VAR_RQCMDARG,
+ "The threshold to determin whether search method is escalated",
+ NULL,
+ NULL,
+ grn_get_default_match_escalation_threshold(),
+ -1,
+ INT_MAX64,
+ 0);
+
+static void mrn_vector_column_delimiter_update(THD *thd, struct st_mysql_sys_var *var,
+ void *var_ptr, const void *save)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ const char *new_value = *((const char **)save);
+ char **old_value_ptr = (char **)var_ptr;
+
+#ifdef MRN_NEED_FREE_STRING_MEMALLOC_PLUGIN_VAR
+ my_free(*old_value_ptr);
+ *old_value_ptr = mrn_my_strdup(new_value, MYF(MY_WME));
+#else
+ *old_value_ptr = (char *)new_value;
+#endif
+
+ DBUG_VOID_RETURN;
+}
+
+static MYSQL_SYSVAR_STR(vector_column_delimiter, mrn_vector_column_delimiter,
+ PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC,
+ "The vector column delimiter",
+ NULL,
+ &mrn_vector_column_delimiter_update,
+ " ");
+
+static void mrn_database_path_prefix_update(THD *thd,
+ struct st_mysql_sys_var *var,
+ void *var_ptr, const void *save)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ const char *new_value = *((const char **)save);
+ char **old_value_ptr = (char **)var_ptr;
+#ifdef MRN_NEED_FREE_STRING_MEMALLOC_PLUGIN_VAR
+ if (*old_value_ptr)
+ my_free(*old_value_ptr);
+ if (new_value)
+ *old_value_ptr = mrn_my_strdup(new_value, MYF(MY_WME));
+ else
+ *old_value_ptr = NULL;
+#else
+ *old_value_ptr = (char *)new_value;
+#endif
+ DBUG_VOID_RETURN;
+}
+
+static MYSQL_SYSVAR_STR(database_path_prefix,
+ mrn::PathMapper::default_path_prefix,
+ PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_MEMALLOC,
+ "The database path prefix",
+ NULL,
+ &mrn_database_path_prefix_update,
+ NULL);
+
+static MYSQL_SYSVAR_STR(default_wrapper_engine, mrn_default_wrapper_engine,
+ PLUGIN_VAR_RQCMDARG | PLUGIN_VAR_READONLY,
+ "The default engine for wrapper mode",
+ NULL,
+ NULL,
+ NULL);
+
+static const char *mrn_action_on_error_names[] = {
+ "ERROR",
+ "ERROR_AND_LOG",
+ "IGNORE",
+ "IGNORE_AND_LOG",
+ NullS,
+};
+
+static TYPELIB mrn_action_on_error_typelib =
+{
+ array_elements(mrn_action_on_error_names) - 1,
+ "mrn_action_on_error_typelib",
+ mrn_action_on_error_names,
+ NULL
+};
+
+static MYSQL_THDVAR_ENUM(action_on_fulltext_query_error,
+ PLUGIN_VAR_RQCMDARG,
+ "action on fulltext query error",
+ NULL,
+ NULL,
+ mrn_action_on_fulltext_query_error_default,
+ &mrn_action_on_error_typelib);
+
+static void mrn_lock_timeout_update(THD *thd, struct st_mysql_sys_var *var,
+ void *var_ptr, const void *save)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ const int new_value = *static_cast<const int *>(save);
+ int *old_value_ptr = static_cast<int *>(var_ptr);
+
+ *old_value_ptr = new_value;
+ grn_set_lock_timeout(new_value);
+
+ DBUG_VOID_RETURN;
+}
+
+static MYSQL_SYSVAR_INT(lock_timeout,
+ mrn_lock_timeout,
+ PLUGIN_VAR_RQCMDARG,
+ "lock timeout used in Groonga",
+ NULL,
+ mrn_lock_timeout_update,
+ grn_get_lock_timeout(),
+ -1,
+ INT_MAX,
+ 1);
+
+static MYSQL_SYSVAR_STR(libgroonga_version, mrn_libgroonga_version,
+ PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
+ "The version of libgroonga",
+ NULL,
+ NULL,
+ grn_get_version());
+
+static MYSQL_SYSVAR_STR(version, mrn_version,
+ PLUGIN_VAR_NOCMDOPT | PLUGIN_VAR_READONLY,
+ "The version of mroonga",
+ NULL,
+ NULL,
+ MRN_VERSION);
+
+static mrn_bool grn_check_zlib_support()
+{
+ bool is_zlib_support = false;
+ grn_obj grn_support_p;
+
+ GRN_BOOL_INIT(&grn_support_p, 0);
+ grn_obj_get_info(&mrn_ctx, NULL, GRN_INFO_SUPPORT_ZLIB, &grn_support_p);
+ is_zlib_support = (GRN_BOOL_VALUE(&grn_support_p));
+ grn_obj_unlink(&mrn_ctx, &grn_support_p);
+
+ return is_zlib_support;
+}
+
+static MYSQL_SYSVAR_BOOL(libgroonga_support_zlib, mrn_libgroonga_support_zlib,
+ PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
+ "The status of libgroonga supports zlib",
+ NULL,
+ NULL,
+ grn_check_zlib_support());
+
+static mrn_bool grn_check_lz4_support()
+{
+ bool is_lz4_support = false;
+ grn_obj grn_support_p;
+
+ GRN_BOOL_INIT(&grn_support_p, 0);
+ grn_obj_get_info(&mrn_ctx, NULL, GRN_INFO_SUPPORT_LZ4, &grn_support_p);
+ is_lz4_support = (GRN_BOOL_VALUE(&grn_support_p));
+ grn_obj_unlink(&mrn_ctx, &grn_support_p);
+
+ return is_lz4_support;
+}
+
+static MYSQL_SYSVAR_BOOL(libgroonga_support_lz4, mrn_libgroonga_support_lz4,
+ PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
+ "The status of libgroonga supports LZ4",
+ NULL,
+ NULL,
+ grn_check_lz4_support());
+
+static mrn_bool grn_check_zstd_support()
+{
+ bool is_zstd_support = false;
+ grn_obj grn_support_p;
+
+ GRN_BOOL_INIT(&grn_support_p, 0);
+ grn_obj_get_info(&mrn_ctx, NULL, GRN_INFO_SUPPORT_ZSTD, &grn_support_p);
+ is_zstd_support = (GRN_BOOL_VALUE(&grn_support_p));
+ grn_obj_unlink(&mrn_ctx, &grn_support_p);
+
+ return is_zstd_support;
+}
+
+static MYSQL_SYSVAR_BOOL(libgroonga_support_zstd, mrn_libgroonga_support_zstd,
+ PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
+ "The status of libgroonga supports Zstandard",
+ NULL,
+ NULL,
+ grn_check_zstd_support());
+
+static void mrn_enable_operations_recording_update(THD *thd, struct st_mysql_sys_var *var,
+ void *var_ptr, const void *save)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ const bool new_value = *static_cast<const bool *>(save);
+ bool *old_value_ptr = static_cast<bool *>(var_ptr);
+
+ *old_value_ptr = new_value;
+
+ DBUG_VOID_RETURN;
+}
+
+static MYSQL_SYSVAR_BOOL(enable_operations_recording, mrn_enable_operations_recording,
+ PLUGIN_VAR_RQCMDARG,
+ "Whether recording operations for recovery is enabled or not",
+ NULL,
+ mrn_enable_operations_recording_update,
+ true);
+
+#ifdef MRN_SUPPORT_THDVAR_SET
+static MYSQL_THDVAR_SET(boolean_mode_syntax_flags,
+ PLUGIN_VAR_RQCMDARG,
+ "The flags to custom syntax in BOOLEAN MODE. "
+ "Available flags: "
+ "DEFAULT(=SYNTAX_QUERY,ALLOW_LEADING_NOT), "
+ "SYNTAX_QUERY, SYNTAX_SCRIPT, "
+ "ALLOW_COLUMN, ALLOW_UPDATE and ALLOW_LEADING_NOT",
+ NULL,
+ NULL,
+ mrn::variables::BOOLEAN_MODE_SYNTAX_FLAG_DEFAULT,
+ &mrn_boolean_mode_syntax_flags_typelib);
+#endif
+
+static const int MRN_MAX_N_RECORDS_FOR_ESTIMATE_DEFAULT = 1000;
+
+static MYSQL_THDVAR_INT(max_n_records_for_estimate,
+ PLUGIN_VAR_RQCMDARG,
+ "The max number of records to "
+ "estimate the number of matched records",
+ NULL,
+ NULL,
+ MRN_MAX_N_RECORDS_FOR_ESTIMATE_DEFAULT,
+ -1,
+ INT_MAX,
+ 0);
+
+static MYSQL_SYSVAR_BOOL(libgroonga_embedded, mrn_libgroonga_embedded,
+ PLUGIN_VAR_NOCMDARG | PLUGIN_VAR_READONLY,
+ "Whether libgroonga is embedded or not",
+ NULL,
+ NULL,
+ mrn_libgroonga_embedded);
+
+static struct st_mysql_sys_var *mrn_system_variables[] =
+{
+ MYSQL_SYSVAR(log_level),
+ MYSQL_SYSVAR(log_file),
+ MYSQL_SYSVAR(default_parser),
+ MYSQL_SYSVAR(default_tokenizer),
+ MYSQL_SYSVAR(dry_write),
+ MYSQL_SYSVAR(enable_optimization),
+ MYSQL_SYSVAR(match_escalation_threshold),
+ MYSQL_SYSVAR(database_path_prefix),
+ MYSQL_SYSVAR(default_wrapper_engine),
+ MYSQL_SYSVAR(action_on_fulltext_query_error),
+ MYSQL_SYSVAR(lock_timeout),
+ MYSQL_SYSVAR(libgroonga_version),
+ MYSQL_SYSVAR(version),
+ MYSQL_SYSVAR(vector_column_delimiter),
+ MYSQL_SYSVAR(libgroonga_support_zlib),
+ MYSQL_SYSVAR(libgroonga_support_lz4),
+ MYSQL_SYSVAR(libgroonga_support_zstd),
+#ifdef MRN_SUPPORT_THDVAR_SET
+ MYSQL_SYSVAR(boolean_mode_syntax_flags),
+#endif
+ MYSQL_SYSVAR(max_n_records_for_estimate),
+ MYSQL_SYSVAR(libgroonga_embedded),
+ MYSQL_SYSVAR(query_log_file),
+ MYSQL_SYSVAR(enable_operations_recording),
+ NULL
+};
+
+/* mroonga information schema */
+static struct st_mysql_information_schema i_s_info =
+{
+ MYSQL_INFORMATION_SCHEMA_INTERFACE_VERSION
+};
+
+namespace Show {
+static ST_FIELD_INFO i_s_mrn_stats_fields_info[] =
+{
+ Column("VERSION", Varchar(40), NOT_NULL),
+ Column("rows_written", SLong(), NOT_NULL, "Rows written to Groonga"),
+ Column("rows_read", SLong(), NOT_NULL, "Rows read from Groonga"),
+ CEnd()
+};
+} // namespace Show
+
+static int i_s_mrn_stats_deinit(void* p)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_RETURN(0);
+}
+
+static int i_s_mrn_stats_fill(
+ THD* thd, TABLE_LIST* tables, Item* cond)
+{
+ TABLE* table = (TABLE *) tables->table;
+ int status = 0;
+ MRN_DBUG_ENTER_FUNCTION();
+ table->field[0]->store(grn_get_version(), strlen(grn_get_version()),
+ system_charset_info);
+ table->field[0]->set_notnull();
+ table->field[1]->store(1); /* TODO */
+ table->field[2]->store(2); /* TODO */
+ if (schema_table_store_record(thd, table)) {
+ status = 1;
+ }
+ DBUG_RETURN(status);
+}
+
+static int i_s_mrn_stats_init(void* p)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ST_SCHEMA_TABLE* schema = (ST_SCHEMA_TABLE*) p;
+ schema->fields_info = Show::i_s_mrn_stats_fields_info;
+ schema->fill_table = i_s_mrn_stats_fill;
+ DBUG_RETURN(0);
+}
+
+struct st_mysql_plugin i_s_mrn_stats =
+{
+ MYSQL_INFORMATION_SCHEMA_PLUGIN,
+ &i_s_info,
+ MRN_STATUS_VARIABLE_NAME_PREFIX_STRING "_stats",
+ MRN_PLUGIN_AUTHOR,
+ "Statistics for " MRN_PLUGIN_NAME_STRING,
+ PLUGIN_LICENSE_GPL,
+ i_s_mrn_stats_init,
+#ifdef MRN_ST_MYSQL_PLUGIN_HAVE_CHECK_UNINSTALL
+ NULL,
+#endif
+ i_s_mrn_stats_deinit,
+ MRN_VERSION_IN_HEX,
+ NULL,
+ NULL,
+ MRN_PLUGIN_LAST_VALUES
+};
+/* End of mroonga information schema implementations */
+
+static handler *mrn_handler_create(handlerton *hton,
+ TABLE_SHARE *share,
+#ifdef MRN_HANDLERTON_CREATE_HAVE_PARTITIONED
+ bool partitioned,
+#endif
+ MEM_ROOT *root)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ handler *new_handler = new (root) ha_mroonga(hton, share);
+ DBUG_RETURN(new_handler);
+}
+
+static void mrn_drop_database(handlerton *hton, char *path)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ mrn_db_manager->drop(path);
+ DBUG_VOID_RETURN;
+}
+
+static int mrn_close_connection(handlerton *hton, THD *thd)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ void *p = thd_get_ha_data(thd, mrn_hton_ptr);
+ if (p) {
+ mrn_clear_slot_data(thd);
+ free(p);
+ {
+ mrn::Lock lock(&mrn_allocated_thds_mutex);
+ my_hash_delete(&mrn_allocated_thds, (uchar*) thd);
+ }
+ }
+ DBUG_RETURN(0);
+}
+
+#ifdef MRN_FLUSH_LOGS_HAVE_BINLOG_GROUP_FLUSH
+static bool mrn_flush_logs(handlerton *hton, bool binlog_group_flush)
+#else
+static bool mrn_flush_logs(handlerton *hton)
+#endif
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ bool result = 0;
+ if (mrn_log_file_opened) {
+ mrn::Lock lock(&mrn_log_mutex);
+ fclose(mrn_log_file);
+ mrn_log_file = fopen(mrn_log_file_path, "a");
+ }
+ DBUG_RETURN(result);
+}
+
+static grn_builtin_type mrn_grn_type_from_field(grn_ctx *ctx, Field *field,
+ bool for_index_key)
+{
+ grn_builtin_type type = GRN_DB_VOID;
+ enum_field_types mysql_field_type = field->real_type();
+ switch (mysql_field_type) {
+ case MYSQL_TYPE_DECIMAL: // DECIMAL; <= 65bytes
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ break;
+ case MYSQL_TYPE_TINY: // TINYINT; 1byte
+ if (static_cast<Field_num *>(field)->unsigned_flag) {
+ type = GRN_DB_UINT8; // 1byte
+ } else {
+ type = GRN_DB_INT8; // 1byte
+ }
+ break;
+ case MYSQL_TYPE_SHORT: // SMALLINT; 2bytes
+ if (static_cast<Field_num *>(field)->unsigned_flag) {
+ type = GRN_DB_UINT16; // 2bytes
+ } else {
+ type = GRN_DB_INT16; // 2bytes
+ }
+ break;
+ case MYSQL_TYPE_LONG: // INT; 4bytes
+ if (static_cast<Field_num *>(field)->unsigned_flag) {
+ type = GRN_DB_UINT32; // 4bytes
+ } else {
+ type = GRN_DB_INT32; // 4bytes
+ }
+ break;
+ case MYSQL_TYPE_FLOAT: // FLOAT; 4 or 8bytes
+ case MYSQL_TYPE_DOUBLE: // DOUBLE; 8bytes
+ type = GRN_DB_FLOAT; // 8bytes
+ break;
+ case MYSQL_TYPE_NULL: // NULL; 1byte
+ type = GRN_DB_INT8; // 1byte
+ break;
+ case MYSQL_TYPE_TIMESTAMP: // TIMESTAMP; 4bytes
+ type = GRN_DB_TIME; // 8bytes
+ break;
+ case MYSQL_TYPE_LONGLONG: // BIGINT; 8bytes
+ if (static_cast<Field_num *>(field)->unsigned_flag) {
+ type = GRN_DB_UINT64; // 8bytes
+ } else {
+ type = GRN_DB_INT64; // 8bytes
+ }
+ break;
+ case MYSQL_TYPE_INT24: // MEDIUMINT; 3bytes
+ if (static_cast<Field_num *>(field)->unsigned_flag) {
+ type = GRN_DB_UINT32; // 4bytes
+ } else {
+ type = GRN_DB_INT32; // 4bytes
+ }
+ break;
+ case MYSQL_TYPE_DATE: // DATE; 4bytes
+ case MYSQL_TYPE_TIME: // TIME; 3bytes
+ case MYSQL_TYPE_DATETIME: // DATETIME; 8bytes
+ case MYSQL_TYPE_YEAR: // YEAR; 1byte
+ case MYSQL_TYPE_NEWDATE: // DATE; 3bytes
+ type = GRN_DB_TIME; // 8bytes
+ break;
+ case MYSQL_TYPE_VARCHAR: // VARCHAR; <= 64KB * 4 + 2bytes
+ if (for_index_key) {
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ } else {
+ if (field->field_length <= MRN_SHORT_TEXT_SIZE) {
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ } else if (field->field_length <= MRN_TEXT_SIZE) {
+ type = GRN_DB_TEXT; // 64Kbytes
+ } else {
+ type = GRN_DB_LONG_TEXT; // 2Gbytes
+ }
+ }
+ break;
+ case MYSQL_TYPE_BIT: // BIT; <= 8bytes
+ type = GRN_DB_INT64; // 8bytes
+ break;
+#ifdef MRN_HAVE_MYSQL_TYPE_TIMESTAMP2
+ case MYSQL_TYPE_TIMESTAMP2: // TIMESTAMP; 4bytes
+ type = GRN_DB_TIME; // 8bytes
+ break;
+#endif
+#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2
+ case MYSQL_TYPE_DATETIME2: // DATETIME; 8bytes
+ type = GRN_DB_TIME; // 8bytes
+ break;
+#endif
+#ifdef MRN_HAVE_MYSQL_TYPE_TIME2
+ case MYSQL_TYPE_TIME2: // TIME(FSP); 3 + (FSP + 1) / 2 bytes
+ // 0 <= FSP <= 6; 3-6bytes
+ type = GRN_DB_TIME; // 8bytes
+ break;
+#endif
+ case MYSQL_TYPE_NEWDECIMAL: // DECIMAL; <= 9bytes
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ break;
+ case MYSQL_TYPE_ENUM: // ENUM; <= 2bytes
+ if (field->pack_length() == 1) {
+ type = GRN_DB_UINT8; // 1bytes
+ } else {
+ type = GRN_DB_UINT16; // 2bytes
+ }
+ break;
+ case MYSQL_TYPE_SET: // SET; <= 8bytes
+ switch (field->pack_length()) {
+ case 1:
+ type = GRN_DB_UINT8; // 1byte
+ break;
+ case 2:
+ type = GRN_DB_UINT16; // 2bytes
+ break;
+ case 3:
+ case 4:
+ type = GRN_DB_UINT32; // 3bytes
+ break;
+ case 8:
+ default:
+ type = GRN_DB_UINT64; // 8bytes
+ break;
+ }
+ break;
+ case MYSQL_TYPE_TINY_BLOB: // TINYBLOB; <= 256bytes + 1byte
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ break;
+ case MYSQL_TYPE_MEDIUM_BLOB: // MEDIUMBLOB; <= 16Mbytes + 3bytes
+ if (for_index_key) {
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ } else {
+ type = GRN_DB_LONG_TEXT; // 2Gbytes
+ }
+ break;
+ case MYSQL_TYPE_LONG_BLOB: // LONGBLOB; <= 4Gbytes + 4bytes
+ if (for_index_key) {
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ } else {
+ type = GRN_DB_LONG_TEXT; // 2Gbytes
+ }
+ break;
+ case MYSQL_TYPE_BLOB: // BLOB; <= 64Kbytes + 2bytes
+ if (for_index_key) {
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ } else {
+ type = GRN_DB_LONG_TEXT; // 2Gbytes
+ }
+ break;
+ case MYSQL_TYPE_VAR_STRING: // VARCHAR; <= 255byte * 4 + 1bytes
+ if (for_index_key) {
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ } else {
+ if (field->field_length <= MRN_SHORT_TEXT_SIZE) {
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ } else if (field->field_length <= MRN_TEXT_SIZE) {
+ type = GRN_DB_TEXT; // 64Kbytes
+ } else {
+ type = GRN_DB_LONG_TEXT; // 2Gbytes
+ }
+ }
+ break;
+ case MYSQL_TYPE_STRING: // CHAR; < 1Kbytes =~ (255 * 4)bytes
+ // 4 is the maximum size of a character
+ type = GRN_DB_SHORT_TEXT; // 4Kbytes
+ break;
+ case MYSQL_TYPE_GEOMETRY: // case-by-case
+ type = GRN_DB_WGS84_GEO_POINT; // 8bytes
+ break;
+ case MYSQL_TYPE_VARCHAR_COMPRESSED:
+ case MYSQL_TYPE_BLOB_COMPRESSED:
+ DBUG_ASSERT(0);
+#ifdef MRN_HAVE_MYSQL_TYPE_JSON
+ case MYSQL_TYPE_JSON:
+ type = GRN_DB_TEXT;
+ break;
+#endif
+ }
+ return type;
+}
+
+static bool mrn_parse_grn_column_create_flags(THD *thd,
+ grn_ctx *ctx,
+ const char *flag_names,
+ uint flag_names_length,
+ grn_obj_flags *column_flags)
+{
+ const char *flag_names_end = flag_names + flag_names_length;
+ bool found = false;
+
+ while (flag_names < flag_names_end) {
+ uint rest_length = flag_names_end - flag_names;
+
+ if (*flag_names == '|' || *flag_names == ' ') {
+ flag_names += 1;
+ continue;
+ }
+ if (rest_length >= 13 && !memcmp(flag_names, "COLUMN_SCALAR", 13)) {
+ *column_flags |= GRN_OBJ_COLUMN_SCALAR;
+ flag_names += 13;
+ found = true;
+ } else if (rest_length >= 13 && !memcmp(flag_names, "COLUMN_VECTOR", 13)) {
+ *column_flags |= GRN_OBJ_COLUMN_VECTOR;
+ flag_names += 13;
+ found = true;
+ } else if (rest_length >= 13 && !memcmp(flag_names, "COMPRESS_ZLIB", 13)) {
+ if (mrn_libgroonga_support_zlib) {
+ *column_flags |= GRN_OBJ_COMPRESS_ZLIB;
+ found = true;
+ } else {
+ push_warning_printf(thd, MRN_SEVERITY_WARNING,
+ ER_MRN_UNSUPPORTED_COLUMN_FLAG_NUM,
+ ER_MRN_UNSUPPORTED_COLUMN_FLAG_STR,
+ "COMPRESS_ZLIB");
+ }
+ flag_names += 13;
+ } else if (rest_length >= 12 && !memcmp(flag_names, "COMPRESS_LZ4", 12)) {
+ if (mrn_libgroonga_support_lz4) {
+ *column_flags |= GRN_OBJ_COMPRESS_LZ4;
+ found = true;
+ } else {
+ push_warning_printf(thd, MRN_SEVERITY_WARNING,
+ ER_MRN_UNSUPPORTED_COLUMN_FLAG_NUM,
+ ER_MRN_UNSUPPORTED_COLUMN_FLAG_STR,
+ "COMPRESS_LZ4");
+ }
+ flag_names += 12;
+ } else if (rest_length >= 13 && !memcmp(flag_names, "COMPRESS_ZSTD", 13)) {
+ if (mrn_libgroonga_support_zstd) {
+ *column_flags |= GRN_OBJ_COMPRESS_ZSTD;
+ found = true;
+ } else {
+ push_warning_printf(thd, MRN_SEVERITY_WARNING,
+ ER_MRN_UNSUPPORTED_COLUMN_FLAG_NUM,
+ ER_MRN_UNSUPPORTED_COLUMN_FLAG_STR,
+ "COMPRESS_ZSTD");
+ }
+ flag_names += 13;
+ } else {
+ char invalid_flag_name[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(invalid_flag_name, MRN_MESSAGE_BUFFER_SIZE,
+ "%.*s",
+ static_cast<int>(rest_length),
+ flag_names);
+ push_warning_printf(thd, MRN_SEVERITY_WARNING,
+ ER_MRN_INVALID_COLUMN_FLAG_NUM,
+ ER_MRN_INVALID_COLUMN_FLAG_STR,
+ invalid_flag_name);
+ break;
+ }
+ }
+ return found;
+}
+
+static bool mrn_parse_grn_index_column_flags(THD *thd,
+ grn_ctx *ctx,
+ const char *flag_names,
+ uint flag_names_length,
+ grn_column_flags *index_column_flags)
+{
+ const char *flag_names_end = flag_names + flag_names_length;
+ bool found = false;
+
+ while (flag_names < flag_names_end) {
+ uint rest_length = flag_names_end - flag_names;
+
+ if (*flag_names == '|' || *flag_names == ' ') {
+ flag_names += 1;
+ continue;
+ }
+ if (rest_length >= 4 && !memcmp(flag_names, "NONE", 4)) {
+ flag_names += 4;
+ found = true;
+ } else if (rest_length >= 13 && !memcmp(flag_names, "WITH_POSITION", 13)) {
+ *index_column_flags |= GRN_OBJ_WITH_POSITION;
+ flag_names += 13;
+ found = true;
+ } else if (rest_length >= 12 && !memcmp(flag_names, "WITH_SECTION", 12)) {
+ *index_column_flags |= GRN_OBJ_WITH_SECTION;
+ flag_names += 12;
+ found = true;
+ } else if (rest_length >= 11 && !memcmp(flag_names, "WITH_WEIGHT", 11)) {
+ *index_column_flags |= GRN_OBJ_WITH_WEIGHT;
+ flag_names += 11;
+ found = true;
+ } else if (rest_length >= 11 && !memcmp(flag_names, "INDEX_SMALL", 11)) {
+ *index_column_flags |= GRN_OBJ_INDEX_SMALL;
+ flag_names += 11;
+ found = true;
+ } else if (rest_length >= 12 && !memcmp(flag_names, "INDEX_MEDIUM", 12)) {
+ *index_column_flags |= GRN_OBJ_INDEX_MEDIUM;
+ flag_names += 12;
+ found = true;
+ } else {
+ char invalid_flag_name[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(invalid_flag_name, MRN_MESSAGE_BUFFER_SIZE,
+ "%.*s",
+ static_cast<int>(rest_length),
+ flag_names);
+ push_warning_printf(thd, MRN_SEVERITY_WARNING,
+ ER_MRN_INVALID_INDEX_FLAG_NUM,
+ ER_MRN_INVALID_INDEX_FLAG_STR,
+ invalid_flag_name);
+ }
+ }
+ return found;
+}
+
+#ifdef MRN_HAVE_SPATIAL
+static int mrn_set_geometry(grn_ctx *ctx, grn_obj *buf,
+ const char *wkb, uint wkb_size)
+{
+ int error = 0;
+ Geometry_buffer buffer;
+ Geometry *geometry;
+
+ geometry = Geometry::construct(&buffer, wkb, wkb_size);
+ if (!geometry) {
+ return ER_CANT_CREATE_GEOMETRY_OBJECT;
+ }
+ switch (geometry->get_class_info()->m_type_id) {
+ case Geometry::wkb_point:
+ {
+ Gis_point *point = (Gis_point *)geometry;
+ double latitude = 0.0, longitude = 0.0;
+#ifdef MRN_HAVE_POINT_XY
+ point_xy xy(0.0, 0.0);
+ point->get_xy(&xy);
+ longitude = xy.x;
+ latitude = xy.y;
+#else
+ point->get_xy(&longitude, &latitude);
+#endif
+ grn_obj_reinit(ctx, buf, GRN_DB_WGS84_GEO_POINT, 0);
+ GRN_GEO_POINT_SET(ctx, buf,
+ GRN_GEO_DEGREE2MSEC(latitude),
+ GRN_GEO_DEGREE2MSEC(longitude));
+ break;
+ }
+ default:
+ my_printf_error(ER_MRN_GEOMETRY_NOT_SUPPORT_NUM,
+ ER_MRN_GEOMETRY_NOT_SUPPORT_STR, MYF(0));
+ error = ER_MRN_GEOMETRY_NOT_SUPPORT_NUM;
+ break;
+ }
+ MRN_GEOMETRY_FREE(geometry);
+
+ return error;
+}
+#endif
+
+#ifdef MRN_HAVE_HTON_ALTER_TABLE_FLAGS
+static alter_table_operations mrn_alter_table_flags(alter_table_operations flags)
+{
+ ulonglong alter_flags = 0;
+#ifdef HA_INPLACE_ADD_INDEX_NO_READ_WRITE
+ bool is_inplace_index_change;
+# ifdef MRN_HAVE_ALTER_INFO
+ is_inplace_index_change = (((flags & ALTER_ADD_INDEX) &&
+ (flags & ALTER_DROP_INDEX)) ||
+ (flags & ALTER_CHANGE_COLUMN));
+# else
+ is_inplace_index_change = (((flags & ALTER_ADD_INDEX) &&
+ (flags & ALTER_DROP_INDEX)) ||
+ (flags & ALTER_CHANGE_COLUMN));
+# endif
+ if (!is_inplace_index_change) {
+ alter_flags |=
+ HA_INPLACE_ADD_INDEX_NO_READ_WRITE |
+ HA_INPLACE_DROP_INDEX_NO_READ_WRITE |
+ HA_INPLACE_ADD_UNIQUE_INDEX_NO_READ_WRITE |
+ HA_INPLACE_DROP_UNIQUE_INDEX_NO_READ_WRITE |
+ HA_INPLACE_ADD_INDEX_NO_WRITE |
+ HA_INPLACE_DROP_INDEX_NO_WRITE |
+ HA_INPLACE_ADD_UNIQUE_INDEX_NO_WRITE |
+ HA_INPLACE_DROP_UNIQUE_INDEX_NO_WRITE;
+ }
+#endif
+ return alter_flags;
+}
+#endif
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+static ha_create_table_option mrn_field_options[] =
+{
+ HA_FOPTION_STRING("GROONGA_TYPE", groonga_type),
+ HA_FOPTION_STRING("FLAGS", flags),
+ HA_FOPTION_END
+};
+
+static ha_create_table_option mrn_index_options[] =
+{
+ HA_IOPTION_STRING("TOKENIZER", tokenizer),
+ HA_IOPTION_STRING("NORMALIZER", normalizer),
+ HA_IOPTION_STRING("TOKEN_FILTERS", token_filters),
+ HA_IOPTION_STRING("FLAGS", flags),
+ HA_IOPTION_END
+};
+#endif
+
+static int mrn_init(void *p)
+{
+ // init handlerton
+ grn_ctx *ctx = NULL;
+ handlerton *hton = static_cast<handlerton *>(p);
+ hton->create = mrn_handler_create;
+ hton->flags = HTON_NO_FLAGS;
+#ifndef MRN_SUPPORT_PARTITION
+ hton->flags |= HTON_NO_PARTITION;
+#endif
+ hton->drop_database = mrn_drop_database;
+ hton->close_connection = mrn_close_connection;
+ hton->flush_logs = mrn_flush_logs;
+#ifdef MRN_HAVE_HTON_ALTER_TABLE_FLAGS
+ hton->alter_table_flags = mrn_alter_table_flags;
+#endif
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ hton->field_options = mrn_field_options;
+ hton->index_options = mrn_index_options;
+#endif
+ mrn_hton_ptr = hton;
+
+#ifdef _WIN32
+ HMODULE current_module = GetModuleHandle(NULL);
+ mrn_binlog_filter =
+ *((Rpl_filter **)GetProcAddress(current_module, MRN_BINLOG_FILTER_PROC));
+ mrn_my_tz_UTC =
+ *((Time_zone **)GetProcAddress(current_module, MRN_MY_TZ_UTC_PROC));
+# ifdef MRN_HAVE_TABLE_DEF_CACHE
+ mrn_table_def_cache = (HASH *)GetProcAddress(current_module,
+ "?table_def_cache@@3Ust_hash@@A");
+# endif
+# ifndef MRN_HAVE_TDC_LOCK_TABLE_SHARE
+ mrn_LOCK_open =
+ (mysql_mutex_t *)GetProcAddress(current_module,
+ "?LOCK_open@@3Ust_mysql_mutex@@A");
+# endif
+# ifdef HAVE_PSI_INTERFACE
+# ifdef MRN_TABLE_SHARE_HAVE_LOCK_SHARE
+ mrn_table_share_lock_share =
+ (PSI_mutex_key *)GetProcAddress(current_module,
+ MRN_TABLE_SHARE_LOCK_SHARE_PROC);
+# endif
+ mrn_table_share_lock_ha_data =
+ (PSI_mutex_key *)GetProcAddress(current_module,
+ MRN_TABLE_SHARE_LOCK_HA_DATA_PROC);
+# endif
+#else
+ mrn_binlog_filter = binlog_filter;
+ mrn_my_tz_UTC = my_tz_UTC;
+# ifdef MRN_HAVE_TABLE_DEF_CACHE
+ mrn_table_def_cache = &table_def_cache;
+# endif
+# ifndef MRN_HAVE_TDC_LOCK_TABLE_SHARE
+ mrn_LOCK_open = &LOCK_open;
+# endif
+#endif
+
+#ifdef MRN_HAVE_PSI_SERVER
+ if (PSI_server) {
+ const char *category = "mroonga";
+ int n_mutexes = array_elements(mrn_mutexes);
+ PSI_server->register_mutex(category, mrn_mutexes, n_mutexes);
+ }
+#endif
+
+ grn_default_query_logger_set_path(mrn_query_log_file_path);
+
+ if (grn_init() != GRN_SUCCESS) {
+ goto err_grn_init;
+ }
+
+ grn_set_lock_timeout(mrn_lock_timeout);
+
+ mrn_init_encoding_map();
+
+ grn_ctx_init(&mrn_ctx, 0);
+ ctx = &mrn_ctx;
+ if (mrn_change_encoding(ctx, system_charset_info))
+ goto err_mrn_change_encoding;
+
+#ifdef MRN_HAVE_PSI_MEMORY_KEY
+ {
+ const char *category = "ha_mroonga";
+ int n_keys = array_elements(mrn_all_memory_keys);
+ mysql_memory_register(category, mrn_all_memory_keys, n_keys);
+ }
+#endif
+
+ if (mysql_mutex_init(mrn_log_mutex_key,
+ &mrn_log_mutex,
+ MY_MUTEX_INIT_FAST) != 0) {
+ goto err_log_mutex_init;
+ }
+ if (mysql_mutex_init(mrn_query_log_mutex_key,
+ &mrn_query_log_mutex,
+ MY_MUTEX_INIT_FAST) != 0) {
+ goto err_query_log_mutex_init;
+ }
+
+ mrn_logger.max_level = static_cast<grn_log_level>(mrn_log_level);
+ grn_logger_set(ctx, &mrn_logger);
+ if (!(mrn_log_file = fopen(mrn_log_file_path, "a"))) {
+ goto err_log_file_open;
+ }
+ mrn_log_file_opened = true;
+ GRN_LOG(ctx, GRN_LOG_NOTICE, "%s started.", MRN_PACKAGE_STRING);
+ GRN_LOG(ctx, GRN_LOG_NOTICE, "log level is '%s'",
+ mrn_log_level_type_names[mrn_log_level]);
+
+ // init meta-info database
+ if (!(mrn_db = grn_db_create(ctx, NULL, NULL))) {
+ GRN_LOG(ctx, GRN_LOG_ERROR, "cannot create system database, exiting");
+ goto err_db_create;
+ }
+ grn_ctx_use(ctx, mrn_db);
+
+ grn_ctx_init(&mrn_db_manager_ctx, 0);
+ grn_logger_set(&mrn_db_manager_ctx, &mrn_logger);
+ if (mysql_mutex_init(mrn_db_manager_mutex_key,
+ &mrn_db_manager_mutex,
+ MY_MUTEX_INIT_FAST) != 0) {
+ GRN_LOG(&mrn_db_manager_ctx, GRN_LOG_ERROR,
+ "failed to initialize mutex for database manager");
+ goto err_db_manager_mutex_init;
+ }
+ mrn_db_manager = new mrn::DatabaseManager(&mrn_db_manager_ctx,
+ &mrn_db_manager_mutex);
+ if (!mrn_db_manager->init()) {
+ goto err_db_manager_init;
+ }
+
+ if (mysql_mutex_init(mrn_context_pool_mutex_key,
+ &mrn_context_pool_mutex,
+ MY_MUTEX_INIT_FAST) != 0) {
+ GRN_LOG(ctx, GRN_LOG_ERROR,
+ "failed to initialize mutex for context pool");
+ goto error_context_pool_mutex_init;
+ }
+ mrn_context_pool = new mrn::ContextPool(&mrn_context_pool_mutex);
+
+ if (mysql_mutex_init(mrn_operations_mutex_key,
+ &mrn_operations_mutex,
+ MY_MUTEX_INIT_FAST) != 0) {
+ GRN_LOG(ctx, GRN_LOG_ERROR,
+ "failed to initialize mutex for operations");
+ goto error_operations_mutex_init;
+ }
+
+ if ((mysql_mutex_init(mrn_allocated_thds_mutex_key,
+ &mrn_allocated_thds_mutex,
+ MY_MUTEX_INIT_FAST) != 0)) {
+ goto err_allocated_thds_mutex_init;
+ }
+ if (mrn_my_hash_init(&mrn_allocated_thds, system_charset_info, 32, 0, 0,
+ mrn_allocated_thds_get_key, 0, 0)) {
+ goto error_allocated_thds_hash_init;
+ }
+ if ((mysql_mutex_init(mrn_open_tables_mutex_key,
+ &mrn_open_tables_mutex,
+ MY_MUTEX_INIT_FAST) != 0)) {
+ goto err_allocated_open_tables_mutex_init;
+ }
+ if (mrn_my_hash_init(&mrn_open_tables, system_charset_info, 32, 0, 0,
+ mrn_open_tables_get_key, 0, 0)) {
+ goto error_allocated_open_tables_hash_init;
+ }
+ if ((mysql_mutex_init(mrn_long_term_share_mutex_key,
+ &mrn_long_term_share_mutex,
+ MY_MUTEX_INIT_FAST) != 0)) {
+ goto error_allocated_long_term_share_mutex_init;
+ }
+ if (mrn_my_hash_init(&mrn_long_term_share, system_charset_info, 32, 0, 0,
+ mrn_long_term_share_get_key, 0, 0)) {
+ goto error_allocated_long_term_share_hash_init;
+ }
+
+#ifdef MRN_USE_MYSQL_DATA_HOME
+ mrn::PathMapper::default_mysql_data_home_path = mysql_data_home;
+#endif
+
+ return 0;
+
+error_allocated_long_term_share_hash_init:
+ mysql_mutex_destroy(&mrn_long_term_share_mutex);
+error_allocated_long_term_share_mutex_init:
+ my_hash_free(&mrn_open_tables);
+error_allocated_open_tables_hash_init:
+ mysql_mutex_destroy(&mrn_open_tables_mutex);
+err_allocated_open_tables_mutex_init:
+ my_hash_free(&mrn_allocated_thds);
+error_allocated_thds_hash_init:
+ mysql_mutex_destroy(&mrn_allocated_thds_mutex);
+err_allocated_thds_mutex_init:
+ mysql_mutex_destroy(&mrn_operations_mutex);
+error_operations_mutex_init:
+ delete mrn_context_pool;
+ mysql_mutex_destroy(&mrn_context_pool_mutex);
+error_context_pool_mutex_init:
+err_db_manager_init:
+ delete mrn_db_manager;
+ mysql_mutex_destroy(&mrn_db_manager_mutex);
+err_db_manager_mutex_init:
+ grn_ctx_fin(&mrn_db_manager_ctx);
+ grn_obj_unlink(ctx, mrn_db);
+err_db_create:
+ if (mrn_log_file_opened) {
+ fclose(mrn_log_file);
+ mrn_log_file_opened = false;
+ }
+err_log_file_open:
+ mysql_mutex_destroy(&mrn_query_log_mutex);
+err_query_log_mutex_init:
+ mysql_mutex_destroy(&mrn_log_mutex);
+err_log_mutex_init:
+err_mrn_change_encoding:
+ grn_ctx_fin(ctx);
+ grn_fin();
+err_grn_init:
+ return -1;
+}
+
+static int mrn_deinit(void *p)
+{
+ THD *thd = current_thd, *tmp_thd;
+ grn_ctx *ctx = &mrn_ctx;
+ MRN_LONG_TERM_SHARE *long_term_share;
+
+ GRN_LOG(ctx, GRN_LOG_NOTICE, "%s deinit", MRN_PACKAGE_STRING);
+
+ if (thd && thd_sql_command(thd) == SQLCOM_UNINSTALL_PLUGIN) {
+ mrn::Lock lock(&mrn_allocated_thds_mutex);
+ while ((tmp_thd = (THD *) my_hash_element(&mrn_allocated_thds, 0)))
+ {
+ mrn_clear_slot_data(tmp_thd);
+ void *slot_ptr = mrn_get_slot_data(tmp_thd, false);
+ if (slot_ptr) free(slot_ptr);
+ thd_set_ha_data(tmp_thd, mrn_hton_ptr, 0);
+ my_hash_delete(&mrn_allocated_thds, (uchar *) tmp_thd);
+ }
+ }
+
+ {
+ mrn::Lock lock(&mrn_open_tables_mutex);
+ while ((long_term_share = (MRN_LONG_TERM_SHARE *)
+ my_hash_element(&mrn_long_term_share, 0)))
+ {
+ mrn_free_long_term_share(long_term_share);
+ }
+ }
+
+ my_hash_free(&mrn_long_term_share);
+ mysql_mutex_destroy(&mrn_long_term_share_mutex);
+ my_hash_free(&mrn_open_tables);
+ mysql_mutex_destroy(&mrn_open_tables_mutex);
+ my_hash_free(&mrn_allocated_thds);
+ mysql_mutex_destroy(&mrn_allocated_thds_mutex);
+ mysql_mutex_destroy(&mrn_operations_mutex);
+ delete mrn_context_pool;
+ mysql_mutex_destroy(&mrn_context_pool_mutex);
+ delete mrn_db_manager;
+ mysql_mutex_destroy(&mrn_db_manager_mutex);
+ grn_ctx_fin(&mrn_db_manager_ctx);
+
+ grn_obj_unlink(ctx, mrn_db);
+ grn_ctx_fin(ctx);
+ grn_fin();
+
+ if (mrn_log_file_opened) {
+ fclose(mrn_log_file);
+ mrn_log_file_opened = false;
+ }
+ mysql_mutex_destroy(&mrn_query_log_mutex);
+ mysql_mutex_destroy(&mrn_log_mutex);
+
+ return 0;
+}
+
+mrn_declare_plugin(MRN_PLUGIN_NAME)
+{
+ MYSQL_STORAGE_ENGINE_PLUGIN,
+ &storage_engine_structure,
+ MRN_PLUGIN_NAME_STRING,
+ MRN_PLUGIN_AUTHOR,
+ "CJK-ready fulltext search, column store",
+ PLUGIN_LICENSE_GPL,
+ mrn_init,
+ mrn_deinit,
+ MRN_VERSION_IN_HEX,
+ mrn_status_variables,
+ mrn_system_variables,
+ MRN_PLUGIN_LAST_VALUES
+},
+i_s_mrn_stats
+mrn_declare_plugin_end;
+
+static double mrn_get_score_value(grn_obj *score)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ double score_value;
+ if (score->header.domain == GRN_DB_FLOAT) {
+ score_value = GRN_FLOAT_VALUE(score);
+ } else {
+ score_value = (double)GRN_INT32_VALUE(score);
+ }
+ DBUG_RETURN(score_value);
+}
+
+static void mrn_generic_ft_clear(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_ft_info *info = (st_mrn_ft_info *)handler;
+ if (!info->ctx) {
+ DBUG_VOID_RETURN;
+ }
+
+ if (info->cursor) {
+ grn_obj_unlink(info->ctx, info->cursor);
+ }
+ if (info->id_accessor) {
+ grn_obj_unlink(info->ctx, info->id_accessor);
+ }
+ if (info->key_accessor) {
+ grn_obj_unlink(info->ctx, info->key_accessor);
+ }
+ grn_obj_unlink(info->ctx, info->result);
+ grn_obj_unlink(info->ctx, info->score_column);
+ grn_obj_unlink(info->ctx, &(info->key));
+ grn_obj_unlink(info->ctx, &(info->score));
+
+ info->ctx = NULL;
+
+ DBUG_VOID_RETURN;
+}
+
+static void mrn_generic_ft_close_search(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_ft_info *info = (st_mrn_ft_info *)handler;
+ mrn_generic_ft_clear(handler);
+ delete info;
+ DBUG_VOID_RETURN;
+}
+
+static int mrn_wrapper_ft_read_next(FT_INFO *handler, char *record)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_RETURN(HA_ERR_END_OF_FILE);
+}
+
+static float mrn_wrapper_ft_find_relevance(FT_INFO *handler, uchar *record,
+ uint length)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_ft_info *info = (st_mrn_ft_info *)handler;
+ float score = 0.0;
+ grn_id record_id;
+
+ mrn_change_encoding(info->ctx, NULL);
+ key_copy((uchar *)(GRN_TEXT_VALUE(&(info->key))), record,
+ info->primary_key_info, info->primary_key_info->key_length);
+ record_id = grn_table_get(info->ctx,
+ info->table,
+ GRN_TEXT_VALUE(&(info->key)),
+ GRN_TEXT_LEN(&(info->key)));
+
+ if (record_id != GRN_ID_NIL) {
+ grn_id result_record_id;
+ result_record_id = grn_table_get(info->ctx, info->result,
+ &record_id, sizeof(grn_id));
+ if (result_record_id != GRN_ID_NIL) {
+ GRN_BULK_REWIND(&(info->score));
+ grn_obj_get_value(info->ctx, info->score_column,
+ result_record_id, &(info->score));
+ score = mrn_get_score_value(&(info->score));
+ }
+ }
+
+ DBUG_PRINT("info",
+ ("mroonga: record_id=%d score=%g", record_id, score));
+
+ DBUG_RETURN(score);
+}
+
+static void mrn_wrapper_ft_close_search(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ mrn_generic_ft_close_search(handler);
+ DBUG_VOID_RETURN;
+}
+
+static float mrn_wrapper_ft_get_relevance(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_ft_info *info = (st_mrn_ft_info *)handler;
+ float score = 0.0;
+ grn_id record_id;
+ ha_mroonga *mroonga = info->mroonga;
+ mrn_change_encoding(info->ctx, NULL);
+ record_id = grn_table_get(info->ctx,
+ info->table,
+ GRN_TEXT_VALUE(&(mroonga->key_buffer)),
+ GRN_TEXT_LEN(&(mroonga->key_buffer)));
+
+ if (record_id != GRN_ID_NIL) {
+ grn_id result_record_id;
+ result_record_id = grn_table_get(info->ctx, info->result,
+ &record_id, sizeof(grn_id));
+ if (result_record_id != GRN_ID_NIL) {
+ GRN_BULK_REWIND(&(info->score));
+ grn_obj_get_value(info->ctx, info->score_column,
+ result_record_id, &(info->score));
+ score = mrn_get_score_value(&(info->score));
+ }
+ }
+
+ DBUG_PRINT("info",
+ ("mroonga: record_id=%d score=%g", record_id, score));
+
+ DBUG_RETURN(score);
+}
+
+static void mrn_wrapper_ft_reinit_search(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_VOID_RETURN;
+}
+
+static _ft_vft mrn_wrapper_ft_vft = {
+ mrn_wrapper_ft_read_next,
+ mrn_wrapper_ft_find_relevance,
+ mrn_wrapper_ft_close_search,
+ mrn_wrapper_ft_get_relevance,
+ mrn_wrapper_ft_reinit_search
+};
+
+static int mrn_storage_ft_read_next(FT_INFO *handler, char *record)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_RETURN(HA_ERR_END_OF_FILE);
+}
+
+static float mrn_storage_ft_find_relevance(FT_INFO *handler, uchar *record,
+ uint length)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_ft_info *info = (st_mrn_ft_info *)handler;
+ ha_mroonga *mroonga = info->mroonga;
+ mrn_change_encoding(info->ctx, NULL);
+
+ float score = 0.0;
+ if (mroonga->record_id != GRN_ID_NIL) {
+ grn_id result_record_id;
+ result_record_id = grn_table_get(info->ctx, info->result,
+ &(mroonga->record_id), sizeof(grn_id));
+ if (result_record_id != GRN_ID_NIL) {
+ GRN_BULK_REWIND(&(info->score));
+ grn_obj_get_value(info->ctx, info->score_column,
+ result_record_id, &(info->score));
+ score = mrn_get_score_value(&(info->score));
+ }
+ }
+ DBUG_PRINT("info", ("mroonga: record_id=%d score=%g",
+ mroonga->record_id, score));
+
+ DBUG_RETURN(score);
+}
+
+static void mrn_storage_ft_close_search(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ mrn_generic_ft_close_search(handler);
+ DBUG_VOID_RETURN;
+}
+
+static float mrn_storage_ft_get_relevance(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_ft_info *info = (st_mrn_ft_info *)handler;
+ ha_mroonga *mroonga = info->mroonga;
+ mrn_change_encoding(info->ctx, NULL);
+
+ float score = 0.0;
+ if (mroonga->record_id != GRN_ID_NIL) {
+ grn_id result_record_id;
+ result_record_id = grn_table_get(info->ctx, info->result,
+ &(mroonga->record_id), sizeof(grn_id));
+ if (result_record_id != GRN_ID_NIL) {
+ GRN_BULK_REWIND(&(info->score));
+ grn_obj_get_value(info->ctx, info->score_column,
+ result_record_id, &(info->score));
+ score = mrn_get_score_value(&(info->score));
+ }
+ }
+ DBUG_PRINT("info",
+ ("mroonga: record_id=%d score=%g", mroonga->record_id, score));
+
+ DBUG_RETURN(score);
+}
+
+static void mrn_storage_ft_reinit_search(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_VOID_RETURN;
+}
+
+static _ft_vft mrn_storage_ft_vft = {
+ mrn_storage_ft_read_next,
+ mrn_storage_ft_find_relevance,
+ mrn_storage_ft_close_search,
+ mrn_storage_ft_get_relevance,
+ mrn_storage_ft_reinit_search
+};
+
+static int mrn_no_such_key_ft_read_next(FT_INFO *handler, char *record)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_RETURN(HA_ERR_END_OF_FILE);
+}
+
+static float mrn_no_such_key_ft_find_relevance(FT_INFO *handler, uchar *record,
+ uint length)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_RETURN(0.0);
+}
+
+static void mrn_no_such_key_ft_close_search(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_ft_info *info = (st_mrn_ft_info *)handler;
+ delete info;
+ DBUG_VOID_RETURN;
+}
+
+static float mrn_no_such_key_ft_get_relevance(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_RETURN(0.0);
+}
+
+static void mrn_no_such_key_ft_reinit_search(FT_INFO *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ DBUG_VOID_RETURN;
+}
+
+static _ft_vft mrn_no_such_key_ft_vft = {
+ mrn_no_such_key_ft_read_next,
+ mrn_no_such_key_ft_find_relevance,
+ mrn_no_such_key_ft_close_search,
+ mrn_no_such_key_ft_get_relevance,
+ mrn_no_such_key_ft_reinit_search
+};
+
+#ifdef HA_CAN_FULLTEXT_EXT
+static uint mrn_generic_ft_get_version()
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ // This value is not used in MySQL 5.6.7-rc. So it is
+ // meaningless. It may be used in the future...
+ uint version = 1;
+ DBUG_RETURN(version);
+}
+
+static ulonglong mrn_generic_ft_ext_get_flags()
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ // TODO: Should we support FTS_ORDERED_RESULT?
+ // TODO: Shuold we support FTS_DOCID_IN_RESULT?
+ ulonglong flags = 0;
+ DBUG_RETURN(flags);
+}
+
+// This function is used if we enable FTS_DOCID_IN_RESULT flag and the
+// table has "FTS_DOC_ID" (defined as FTS_DOC_ID_COL_NAME macro)
+// special name column. Should we support "FTS_DOC_ID" special name
+// column?
+// See also sql/sql_optimizer.cc:JOIN::optimize_fts_query().
+static ulonglong mrn_generic_ft_ext_get_docid(FT_INFO_EXT *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong id = GRN_ID_NIL;
+ DBUG_RETURN(id);
+}
+
+static ulonglong mrn_generic_ft_ext_count_matches(FT_INFO_EXT *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ st_mrn_ft_info *info = reinterpret_cast<st_mrn_ft_info *>(handler);
+ ulonglong n_records = grn_table_size(info->ctx, info->result);
+ DBUG_RETURN(n_records);
+}
+
+static uint mrn_wrapper_ft_ext_get_version()
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ uint version = mrn_generic_ft_get_version();
+ DBUG_RETURN(version);
+}
+
+static ulonglong mrn_wrapper_ft_ext_get_flags()
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong flags = mrn_generic_ft_ext_get_flags();
+ DBUG_RETURN(flags);
+}
+
+static ulonglong mrn_wrapper_ft_ext_get_docid(FT_INFO_EXT *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong id = mrn_generic_ft_ext_get_docid(handler);
+ DBUG_RETURN(id);
+}
+
+static ulonglong mrn_wrapper_ft_ext_count_matches(FT_INFO_EXT *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong n_records = mrn_generic_ft_ext_count_matches(handler);
+ DBUG_RETURN(n_records);
+}
+
+static _ft_vft_ext mrn_wrapper_ft_vft_ext = {
+ mrn_wrapper_ft_ext_get_version,
+ mrn_wrapper_ft_ext_get_flags,
+ mrn_wrapper_ft_ext_get_docid,
+ mrn_wrapper_ft_ext_count_matches
+};
+
+static uint mrn_storage_ft_ext_get_version()
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ uint version = mrn_generic_ft_get_version();
+ DBUG_RETURN(version);
+}
+
+static ulonglong mrn_storage_ft_ext_get_flags()
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong flags = mrn_generic_ft_ext_get_flags();
+ DBUG_RETURN(flags);
+}
+
+static ulonglong mrn_storage_ft_ext_get_docid(FT_INFO_EXT *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong id = mrn_generic_ft_ext_get_docid(handler);
+ DBUG_RETURN(id);
+}
+
+static ulonglong mrn_storage_ft_ext_count_matches(FT_INFO_EXT *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong n_records = mrn_generic_ft_ext_count_matches(handler);
+ DBUG_RETURN(n_records);
+}
+
+static _ft_vft_ext mrn_storage_ft_vft_ext = {
+ mrn_storage_ft_ext_get_version,
+ mrn_storage_ft_ext_get_flags,
+ mrn_storage_ft_ext_get_docid,
+ mrn_storage_ft_ext_count_matches
+};
+
+static uint mrn_no_such_key_ft_ext_get_version()
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ uint version = mrn_generic_ft_get_version();
+ DBUG_RETURN(version);
+}
+
+static ulonglong mrn_no_such_key_ft_ext_get_flags()
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong flags = mrn_generic_ft_ext_get_flags();
+ DBUG_RETURN(flags);
+}
+
+static ulonglong mrn_no_such_key_ft_ext_get_docid(FT_INFO_EXT *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong id = GRN_ID_NIL;
+ DBUG_RETURN(id);
+}
+
+static ulonglong mrn_no_such_key_ft_ext_count_matches(FT_INFO_EXT *handler)
+{
+ MRN_DBUG_ENTER_FUNCTION();
+ ulonglong n_records = 0;
+ DBUG_RETURN(n_records);
+}
+
+static _ft_vft_ext mrn_no_such_key_ft_vft_ext = {
+ mrn_no_such_key_ft_ext_get_version,
+ mrn_no_such_key_ft_ext_get_flags,
+ mrn_no_such_key_ft_ext_get_docid,
+ mrn_no_such_key_ft_ext_count_matches
+};
+#endif
+
+/* handler implementation */
+ha_mroonga::ha_mroonga(handlerton *hton, TABLE_SHARE *share_arg)
+ :handler(hton, share_arg),
+ wrap_handler(NULL),
+ is_clone(false),
+ parent_for_clone(NULL),
+ mem_root_for_clone(NULL),
+ record_id(GRN_ID_NIL),
+ key_id(NULL),
+ del_key_id(NULL),
+
+ wrap_ft_init_count(0),
+ share(NULL),
+ wrap_key_info(NULL),
+ base_key_info(NULL),
+
+ analyzed_for_create(false),
+ wrap_handler_for_create(NULL),
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+ hnd_add_index(NULL),
+#endif
+#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER
+ alter_key_info_buffer(NULL),
+#else
+ wrap_alter_key_info(NULL),
+#endif
+ mrn_lock_type(F_UNLCK),
+
+ ctx_entity_(),
+ ctx(&ctx_entity_),
+ grn_table(NULL),
+ grn_columns(NULL),
+ grn_column_ranges(NULL),
+ grn_index_tables(NULL),
+ grn_index_columns(NULL),
+
+ grn_source_column_geo(NULL),
+ cursor_geo(NULL),
+ cursor(NULL),
+ index_table_cursor(NULL),
+ empty_value_records(NULL),
+ empty_value_records_cursor(NULL),
+
+ sorted_result(NULL),
+ matched_record_keys(NULL),
+ blob_buffers(NULL),
+
+ dup_key(0),
+
+ count_skip(false),
+ fast_order_limit(false),
+ fast_order_limit_with_index(false),
+
+ ignoring_duplicated_key(false),
+ inserting_with_update(false),
+ fulltext_searching(false),
+ ignoring_no_key_columns(false),
+ replacing_(false),
+ written_by_row_based_binlog(0),
+ current_ft_item(NULL),
+ operations_(NULL)
+{
+ MRN_DBUG_ENTER_METHOD();
+ grn_ctx_init(ctx, 0);
+ mrn_change_encoding(ctx, system_charset_info);
+ grn_ctx_use(ctx, mrn_db);
+ GRN_WGS84_GEO_POINT_INIT(&top_left_point, 0);
+ GRN_WGS84_GEO_POINT_INIT(&bottom_right_point, 0);
+ GRN_WGS84_GEO_POINT_INIT(&source_point, 0);
+ GRN_TEXT_INIT(&key_buffer, 0);
+ GRN_TEXT_INIT(&encoded_key_buffer, 0);
+ GRN_VOID_INIT(&old_value_buffer);
+ GRN_VOID_INIT(&new_value_buffer);
+ DBUG_VOID_RETURN;
+}
+
+ha_mroonga::~ha_mroonga()
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ delete operations_;
+
+ if (analyzed_for_create) {
+ if (wrap_handler_for_create) {
+ delete wrap_handler_for_create;
+ }
+ if (share_for_create.wrapper_mode) {
+ plugin_unlock(NULL, share_for_create.plugin);
+ }
+ if (share_for_create.table_name) {
+ my_free(share_for_create.table_name);
+ }
+ mrn_free_share_alloc(&share_for_create);
+ free_root(&mem_root_for_create, MYF(0));
+ }
+ if (blob_buffers)
+ {
+ delete [] blob_buffers;
+ }
+ grn_obj_unlink(ctx, &top_left_point);
+ grn_obj_unlink(ctx, &bottom_right_point);
+ grn_obj_unlink(ctx, &source_point);
+ grn_obj_unlink(ctx, &key_buffer);
+ grn_obj_unlink(ctx, &encoded_key_buffer);
+ grn_obj_unlink(ctx, &old_value_buffer);
+ grn_obj_unlink(ctx, &new_value_buffer);
+ grn_ctx_fin(ctx);
+ DBUG_VOID_RETURN;
+}
+
+const char *ha_mroonga::table_type() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(MRN_PLUGIN_NAME_STRING);
+}
+
+const char *ha_mroonga::index_type(uint key_nr)
+{
+ MRN_DBUG_ENTER_METHOD();
+ KEY *key_info = &(table->s->key_info[key_nr]);
+ if (key_info->algorithm == HA_KEY_ALG_FULLTEXT) {
+ DBUG_RETURN("FULLTEXT");
+ } else if (key_info->algorithm == HA_KEY_ALG_HASH) {
+ DBUG_RETURN("HASH");
+ } else {
+ DBUG_RETURN("BTREE");
+ }
+}
+
+static const char *ha_mroonga_exts[] = {
+ NullS
+};
+const char **ha_mroonga::bas_ext() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(ha_mroonga_exts);
+}
+
+uint ha_mroonga::wrapper_max_supported_record_length() const
+{
+ uint res;
+ MRN_DBUG_ENTER_METHOD();
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ res = wrap_handler_for_create->max_supported_record_length();
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->max_supported_record_length();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::storage_max_supported_record_length() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(HA_MAX_REC_LENGTH);
+}
+
+uint ha_mroonga::max_supported_record_length() const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ uint res;
+ if (!share && !analyzed_for_create &&
+ (
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_TABLE ||
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_INDEX ||
+ thd_sql_command(ha_thd()) == SQLCOM_ALTER_TABLE
+ )
+ ) {
+ create_share_for_create();
+ }
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ res = wrapper_max_supported_record_length();
+ } else if (wrap_handler && share && share->wrapper_mode) {
+ res = wrapper_max_supported_record_length();
+ } else {
+ res = storage_max_supported_record_length();
+ }
+
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::wrapper_max_supported_keys() const
+{
+ uint res;
+ MRN_DBUG_ENTER_METHOD();
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ res = wrap_handler_for_create->max_supported_keys();
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->max_supported_keys();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::storage_max_supported_keys() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(HA_MAX_REC_LENGTH);
+}
+
+uint ha_mroonga::max_supported_keys() const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ uint res;
+ if (!share && !analyzed_for_create &&
+ (
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_TABLE ||
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_INDEX ||
+ thd_sql_command(ha_thd()) == SQLCOM_ALTER_TABLE
+ )
+ ) {
+ create_share_for_create();
+ }
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ res = wrapper_max_supported_keys();
+ } else if (wrap_handler && share && share->wrapper_mode) {
+ res = wrapper_max_supported_keys();
+ } else {
+ res = storage_max_supported_keys();
+ }
+
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::wrapper_max_supported_key_length() const
+{
+ uint res;
+ MRN_DBUG_ENTER_METHOD();
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ res = wrap_handler_for_create->max_supported_key_length();
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->max_supported_key_length();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::storage_max_supported_key_length() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(GRN_TABLE_MAX_KEY_SIZE);
+}
+
+uint ha_mroonga::max_supported_key_length() const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ uint res;
+ if (!share && !analyzed_for_create &&
+ (
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_TABLE ||
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_INDEX ||
+ thd_sql_command(ha_thd()) == SQLCOM_ALTER_TABLE
+ )
+ ) {
+ create_share_for_create();
+ }
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ res = wrapper_max_supported_key_length();
+ } else if (wrap_handler && share && share->wrapper_mode) {
+ res = wrapper_max_supported_key_length();
+ } else {
+ res = storage_max_supported_key_length();
+ }
+
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::wrapper_max_supported_key_part_length() const
+{
+ uint res;
+ MRN_DBUG_ENTER_METHOD();
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ res = wrap_handler_for_create->max_supported_key_part_length();
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->max_supported_key_part_length();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::storage_max_supported_key_part_length() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(GRN_TABLE_MAX_KEY_SIZE);
+}
+
+uint ha_mroonga::max_supported_key_part_length() const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ uint res;
+ if (!share && !analyzed_for_create &&
+ (
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_TABLE ||
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_INDEX ||
+ thd_sql_command(ha_thd()) == SQLCOM_ALTER_TABLE
+ )
+ ) {
+ create_share_for_create();
+ }
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ res = wrapper_max_supported_key_part_length();
+ } else if (wrap_handler && share && share->wrapper_mode) {
+ res = wrapper_max_supported_key_part_length();
+ } else {
+ res = storage_max_supported_key_part_length();
+ }
+
+ DBUG_RETURN(res);
+}
+
+ulonglong ha_mroonga::wrapper_table_flags() const
+{
+ ulonglong table_flags;
+ MRN_DBUG_ENTER_METHOD();
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ table_flags = wrap_handler_for_create->ha_table_flags();
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ table_flags = wrap_handler->ha_table_flags();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ table_flags |= HA_CAN_FULLTEXT | HA_PRIMARY_KEY_REQUIRED_FOR_DELETE |
+ HA_CAN_RTREEKEYS | HA_REC_NOT_IN_SEQ;
+#ifdef HA_CAN_REPAIR
+ table_flags |= HA_CAN_REPAIR;
+#endif
+#ifdef HA_CAN_FULLTEXT_EXT
+ table_flags |= HA_CAN_FULLTEXT_EXT;
+#endif
+#ifdef HA_GENERATED_COLUMNS
+ table_flags |= HA_GENERATED_COLUMNS;
+#endif
+#ifdef HA_CAN_VIRTUAL_COLUMNS
+ table_flags |= HA_CAN_VIRTUAL_COLUMNS;
+#endif
+ table_flags |= HA_CAN_HASH_KEYS;
+ DBUG_RETURN(table_flags);
+}
+
+ulonglong ha_mroonga::storage_table_flags() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ ulonglong flags =
+ HA_NO_TRANSACTIONS |
+ HA_PARTIAL_COLUMN_READ |
+ HA_REC_NOT_IN_SEQ |
+ HA_NULL_IN_KEY |
+ HA_CAN_INDEX_BLOBS |
+ HA_STATS_RECORDS_IS_EXACT |
+ HA_CAN_FULLTEXT |
+ HA_BINLOG_FLAGS |
+ HA_CAN_BIT_FIELD |
+ HA_DUPLICATE_POS |
+ HA_CAN_GEOMETRY |
+ HA_CAN_RTREEKEYS;
+ //HA_HAS_RECORDS;
+#ifdef HA_MUST_USE_TABLE_CONDITION_PUSHDOWN
+ flags |= HA_MUST_USE_TABLE_CONDITION_PUSHDOWN;
+#endif
+#ifdef HA_CAN_REPAIR
+ flags |= HA_CAN_REPAIR;
+#endif
+#ifdef HA_CAN_FULLTEXT_EXT
+ flags |= HA_CAN_FULLTEXT_EXT;
+#endif
+#ifdef HA_GENERATED_COLUMNS
+ flags |= HA_GENERATED_COLUMNS;
+#endif
+#ifdef HA_CAN_VIRTUAL_COLUMNS
+ flags |= HA_CAN_VIRTUAL_COLUMNS;
+#endif
+ flags |= HA_CAN_HASH_KEYS;
+ DBUG_RETURN(flags);
+}
+
+ulonglong ha_mroonga::table_flags() const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ ulonglong flags;
+ if (!share && !analyzed_for_create &&
+ (
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_TABLE ||
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_INDEX ||
+ thd_sql_command(ha_thd()) == SQLCOM_ALTER_TABLE
+ )
+ ) {
+ create_share_for_create();
+ }
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ flags = wrapper_table_flags();
+ } else if (wrap_handler && share && share->wrapper_mode) {
+ flags = wrapper_table_flags();
+ } else {
+ flags = storage_table_flags();
+ }
+
+ DBUG_RETURN(flags);
+}
+
+ulong ha_mroonga::wrapper_index_flags(uint idx, uint part, bool all_parts) const
+{
+ ulong index_flags;
+ KEY *key = &(table_share->key_info[idx]);
+ MRN_DBUG_ENTER_METHOD();
+ if (key->algorithm == HA_KEY_ALG_BTREE ||
+ key->algorithm == HA_KEY_ALG_UNDEF) {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ index_flags = wrap_handler->index_flags(idx, part, all_parts);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ } else {
+ index_flags = HA_ONLY_WHOLE_INDEX | HA_KEY_SCAN_NOT_ROR;
+ }
+ DBUG_RETURN(index_flags);
+}
+
+ulong ha_mroonga::storage_index_flags(uint idx, uint part, bool all_parts) const
+{
+ MRN_DBUG_ENTER_METHOD();
+ ulong flags;
+ KEY *key = &(table_share->key_info[idx]);
+ if (key->algorithm == HA_KEY_ALG_BTREE ||
+ key->algorithm == HA_KEY_ALG_UNDEF) {
+ flags = HA_READ_NEXT | HA_READ_PREV | HA_READ_RANGE;
+ bool need_normalize_p = false;
+ // TODO: MariaDB 10.1 passes key->user_defined_key_parts as part
+ // for ORDER BY DESC. We just it fallback to part = 0. We may use
+ // it for optimization in the future.
+ //
+ // See also: test_if_order_by_key() in sql/sql_select.cc.
+ if (KEY_N_KEY_PARTS(key) == part) {
+ part = 0;
+ }
+ Field *field = &(key->key_part[part].field[0]);
+ if (field && (have_custom_normalizer(key) || should_normalize(field))) {
+ need_normalize_p = true;
+ }
+ if (!need_normalize_p) {
+ flags |= HA_KEYREAD_ONLY;
+ }
+ if (KEY_N_KEY_PARTS(key) > 1 || !need_normalize_p) {
+ flags |= HA_READ_ORDER;
+ }
+ } else {
+ flags = HA_ONLY_WHOLE_INDEX | HA_KEY_SCAN_NOT_ROR;
+ }
+ DBUG_RETURN(flags);
+}
+
+ulong ha_mroonga::index_flags(uint idx, uint part, bool all_parts) const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ KEY *key = &(table_share->key_info[idx]);
+ if (key->algorithm == HA_KEY_ALG_FULLTEXT) {
+ DBUG_RETURN(HA_ONLY_WHOLE_INDEX | HA_KEY_SCAN_NOT_ROR);
+ }
+ if (mrn_is_geo_key(key)) {
+ DBUG_RETURN(HA_ONLY_WHOLE_INDEX | HA_KEY_SCAN_NOT_ROR | HA_READ_RANGE);
+ }
+
+ int error = 0;
+ if (wrap_handler && share && share->wrapper_mode)
+ {
+ error = wrapper_index_flags(idx, part, all_parts);
+ } else {
+ error = storage_index_flags(idx, part, all_parts);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::create_share_for_create() const
+{
+ int error;
+ THD *thd = ha_thd();
+ LEX *lex = thd->lex;
+ HA_CREATE_INFO *create_info = &lex->create_info;
+ TABLE_LIST *table_list = MRN_LEX_GET_TABLE_LIST(lex);
+ MRN_DBUG_ENTER_METHOD();
+ wrap_handler_for_create = NULL;
+ table_for_create.reset();
+ table_share_for_create.reset();
+ memset(&share_for_create, 0, sizeof(MRN_SHARE));
+ if (table_share) {
+ table_share_for_create.comment = table_share->comment;
+ table_share_for_create.connect_string = table_share->connect_string;
+ } else {
+#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER
+ if (thd_sql_command(ha_thd()) != SQLCOM_CREATE_INDEX) {
+#endif
+ table_share_for_create.comment = create_info->comment;
+ table_share_for_create.connect_string = create_info->connect_string;
+#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER
+ }
+#endif
+ if (thd_sql_command(ha_thd()) == SQLCOM_ALTER_TABLE ||
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_INDEX) {
+ st_mrn_slot_data *slot_data = mrn_get_slot_data(thd, false);
+ if (slot_data && slot_data->alter_create_info) {
+ create_info = slot_data->alter_create_info;
+ if (slot_data->alter_connect_string) {
+ table_share_for_create.connect_string.str =
+ slot_data->alter_connect_string;
+ table_share_for_create.connect_string.length =
+ strlen(slot_data->alter_connect_string);
+ } else {
+ table_share_for_create.connect_string.str = NULL;
+ table_share_for_create.connect_string.length = 0;
+ }
+ if (slot_data->alter_comment) {
+ table_share_for_create.comment.str =
+ slot_data->alter_comment;
+ table_share_for_create.comment.length =
+ strlen(slot_data->alter_comment);
+ } else {
+ table_share_for_create.comment.str = NULL;
+ table_share_for_create.comment.length = 0;
+ }
+ }
+ }
+ }
+ mrn_init_alloc_root(&mem_root_for_create, 1024, 0, MYF(0));
+ analyzed_for_create = true;
+ if (table_list) {
+ share_for_create.table_name = mrn_my_strndup(table_list->table_name.str,
+ table_list->table_name.length,
+ MYF(MY_WME));
+ share_for_create.table_name_length = table_list->table_name.length;
+ }
+ share_for_create.table_share = &table_share_for_create;
+ table_for_create.s = &table_share_for_create;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+ table_for_create.part_info = NULL;
+#endif
+ if ((error = mrn_parse_table_param(&share_for_create, &table_for_create)))
+ goto error;
+
+ if (share_for_create.wrapper_mode)
+ {
+ wrap_handler_for_create =
+ share_for_create.hton->create(share_for_create.hton, NULL,
+ &mem_root_for_create);
+ if (!wrap_handler_for_create) {
+ error = HA_ERR_OUT_OF_MEM;
+ goto error;
+ }
+ wrap_handler_for_create->init();
+ }
+ DBUG_RETURN(0);
+
+error:
+ if (share_for_create.wrapper_mode) {
+ plugin_unlock(NULL, share_for_create.plugin);
+ }
+ mrn_free_share_alloc(&share_for_create);
+ free_root(&mem_root_for_create, MYF(0));
+ analyzed_for_create = false;
+ thd->clear_error();
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_create(const char *name, TABLE *table,
+ HA_CREATE_INFO *info, MRN_SHARE *tmp_share)
+{
+ int error = 0;
+ handler *hnd;
+ MRN_DBUG_ENTER_METHOD();
+
+ if (table_share->primary_key == MAX_KEY)
+ {
+ my_message(ER_REQUIRES_PRIMARY_KEY,
+ MRN_GET_ERR_MSG(ER_REQUIRES_PRIMARY_KEY), MYF(0));
+ DBUG_RETURN(ER_REQUIRES_PRIMARY_KEY);
+ }
+
+ error = ensure_database_open(name);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = wrapper_create_index(name, table, tmp_share);
+ if (error)
+ DBUG_RETURN(error);
+
+ wrap_key_info = mrn_create_key_info_for_table(tmp_share, table, &error);
+ if (error)
+ DBUG_RETURN(error);
+ base_key_info = table->key_info;
+
+ share = tmp_share;
+ MRN_SET_WRAP_SHARE_KEY(tmp_share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ if (parse_engine_table_options(ha_thd(), tmp_share->hton, table->s)) {
+ MRN_SET_BASE_SHARE_KEY(tmp_share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ share = NULL;
+ if (wrap_key_info)
+ {
+ my_free(wrap_key_info);
+ wrap_key_info = NULL;
+ }
+ base_key_info = NULL;
+ error = MRN_GET_ERROR_NUMBER;
+ DBUG_RETURN(error);
+ }
+#endif
+ hnd = get_new_handler(table->s, current_thd->mem_root, tmp_share->hton);
+ if (!hnd)
+ {
+ MRN_SET_BASE_SHARE_KEY(tmp_share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ share = NULL;
+ if (wrap_key_info)
+ {
+ my_free(wrap_key_info);
+ wrap_key_info = NULL;
+ }
+ base_key_info = NULL;
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+ error = hnd->ha_create(name, table, info);
+ MRN_SET_BASE_SHARE_KEY(tmp_share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ share = NULL;
+ delete hnd;
+
+ if (error) {
+ mrn::PathMapper mapper(name);
+ generic_delete_table(name, mapper.table_name());
+ }
+
+ if (wrap_key_info)
+ {
+ my_free(wrap_key_info);
+ wrap_key_info = NULL;
+ }
+ base_key_info = NULL;
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_create_index_fulltext_validate(KEY *key_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+ uint i;
+ for (i = 0; i < KEY_N_KEY_PARTS(key_info); i++) {
+ Field *field = key_info->key_part[i].field;
+
+ grn_builtin_type gtype = mrn_grn_type_from_field(ctx, field, true);
+ if (gtype != GRN_DB_SHORT_TEXT)
+ {
+ error = ER_CANT_CREATE_TABLE;
+ GRN_LOG(ctx, GRN_LOG_ERROR,
+ "key type must be text: <%d> "
+ "(TODO: We should show type name not type ID.)",
+ field->type());
+ my_message(ER_CANT_CREATE_TABLE,
+ "key type must be text. (TODO: We should show type name.)",
+ MYF(0));
+ DBUG_RETURN(error);
+ }
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_create_index_fulltext(const char *grn_table_name,
+ int i,
+ KEY *key_info,
+ grn_obj **index_tables,
+ grn_obj **index_columns,
+ MRN_SHARE *tmp_share)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ error = wrapper_create_index_fulltext_validate(key_info);
+ if (error) {
+ DBUG_RETURN(error);
+ }
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ grn_obj_flags index_table_flags =
+ GRN_OBJ_TABLE_PAT_KEY |
+ GRN_OBJ_PERSISTENT;
+ grn_obj *index_table;
+
+ grn_column_flags index_column_flags = GRN_OBJ_COLUMN_INDEX | GRN_OBJ_PERSISTENT;
+
+ if (!find_index_column_flags(key_info, &index_column_flags)) {
+ index_column_flags |= GRN_OBJ_WITH_POSITION;
+ if (KEY_N_KEY_PARTS(key_info) > 1) {
+ index_column_flags |= GRN_OBJ_WITH_SECTION;
+ }
+ }
+
+ mrn::SmartGrnObj lexicon_key_type(ctx, GRN_DB_SHORT_TEXT);
+ error = mrn_change_encoding(ctx, key_info->key_part->field->charset());
+ if (error) {
+ DBUG_RETURN(error);
+ }
+ mrn::IndexTableName index_table_name(grn_table_name, key_info->name.str);
+ index_table = grn_table_create(ctx,
+ index_table_name.c_str(),
+ index_table_name.length(),
+ NULL,
+ index_table_flags,
+ lexicon_key_type.get(),
+ 0);
+ if (ctx->rc) {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(ER_CANT_CREATE_TABLE, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ mrn_change_encoding(ctx, system_charset_info);
+ index_tables[i] = index_table;
+
+ grn_obj *tokenizer = find_tokenizer(key_info, tmp_share, i);
+ if (tokenizer) {
+ grn_info_type info_type = GRN_INFO_DEFAULT_TOKENIZER;
+ grn_obj_set_info(ctx, index_table, info_type, tokenizer);
+ grn_obj_unlink(ctx, tokenizer);
+ }
+
+ {
+ grn_obj token_filters;
+ GRN_PTR_INIT(&token_filters, GRN_OBJ_VECTOR, 0);
+ if (find_token_filters(key_info, &token_filters)) {
+ grn_obj_set_info(ctx, index_table,
+ GRN_INFO_TOKEN_FILTERS, &token_filters);
+ }
+ grn_obj_unlink(ctx, &token_filters);
+ }
+
+ if (have_custom_normalizer(key_info) ||
+ should_normalize(&key_info->key_part->field[0])) {
+ grn_info_type info_type = GRN_INFO_NORMALIZER;
+ grn_obj *normalizer = find_normalizer(key_info);
+ if (normalizer) {
+ grn_obj_set_info(ctx, index_table, info_type, normalizer);
+ grn_obj_unlink(ctx, normalizer);
+ }
+ }
+
+ grn_obj *index_column = grn_column_create(ctx, index_table,
+ INDEX_COLUMN_NAME,
+ strlen(INDEX_COLUMN_NAME),
+ NULL,
+ index_column_flags,
+ grn_table);
+ if (ctx->rc) {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ if (index_columns) {
+ index_columns[i] = index_column;
+ } else {
+ grn_obj_unlink(ctx, index_column);
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_create_index_geo(const char *grn_table_name,
+ int i,
+ KEY *key_info,
+ grn_obj **index_tables,
+ grn_obj **index_columns,
+ MRN_SHARE *tmp_share)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ mrn::IndexTableName index_table_name(grn_table_name, key_info->name.str);
+
+ grn_obj_flags index_table_flags =
+ GRN_OBJ_TABLE_PAT_KEY |
+ GRN_OBJ_PERSISTENT;
+ grn_obj *index_table;
+
+ grn_obj_flags index_column_flags =
+ GRN_OBJ_COLUMN_INDEX | GRN_OBJ_PERSISTENT;
+
+ grn_obj *lexicon_key_type = grn_ctx_at(ctx, GRN_DB_WGS84_GEO_POINT);
+ index_table = grn_table_create(ctx,
+ index_table_name.c_str(),
+ index_table_name.length(),
+ NULL,
+ index_table_flags, lexicon_key_type, 0);
+ if (ctx->rc) {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(ER_CANT_CREATE_TABLE, ctx->errbuf, MYF(0));
+ grn_obj_unlink(ctx, lexicon_key_type);
+ DBUG_RETURN(error);
+ }
+ grn_obj_unlink(ctx, lexicon_key_type);
+ index_tables[i] = index_table;
+
+ grn_obj *index_column = grn_column_create(ctx, index_table,
+ INDEX_COLUMN_NAME,
+ strlen(INDEX_COLUMN_NAME),
+ NULL,
+ index_column_flags,
+ grn_table);
+ if (ctx->rc) {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ if (index_columns) {
+ index_columns[i] = index_column;
+ } else {
+ grn_obj_unlink(ctx, index_column);
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_create_index(const char *name, TABLE *table,
+ MRN_SHARE *tmp_share)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ grn_obj *grn_index_table;
+ mrn::PathMapper mapper(name);
+ const char *grn_table_name = mapper.table_name();
+ char *grn_table_path = NULL; // we don't specify path
+ grn_obj *pkey_type = grn_ctx_at(ctx, GRN_DB_SHORT_TEXT);
+ grn_obj *pkey_value_type = NULL; // we don't use this
+ grn_obj_flags grn_table_flags = GRN_OBJ_PERSISTENT | GRN_OBJ_TABLE_HASH_KEY;
+
+ grn_index_table = grn_table_create(ctx, grn_table_name, strlen(grn_table_name),
+ grn_table_path, grn_table_flags,
+ pkey_type, pkey_value_type);
+ if (ctx->rc) {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ if (grn_table) {
+ grn_obj_unlink(ctx, grn_table);
+ }
+ grn_table = grn_index_table;
+
+ uint i;
+ uint n_keys = table->s->keys;
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, n_keys);
+ if (!tmp_share->disable_keys) {
+ for (i = 0; i < n_keys; i++) {
+ index_tables[i] = NULL;
+
+ KEY *key_info = &(table->s->key_info[i]);
+ if (key_info->algorithm == HA_KEY_ALG_FULLTEXT) {
+ error = wrapper_create_index_fulltext(grn_table_name,
+ i, key_info,
+ index_tables, NULL, tmp_share);
+ } else if (mrn_is_geo_key(key_info)) {
+ error = wrapper_create_index_geo(grn_table_name,
+ i, key_info,
+ index_tables, NULL, tmp_share);
+ }
+ }
+
+ if (error) {
+ for (uint j = 0; j < i; j++) {
+ if (index_tables[j]) {
+ grn_obj_remove(ctx, index_tables[j]);
+ }
+ }
+ grn_obj_remove(ctx, grn_table);
+ grn_table = NULL;
+ }
+ }
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_create(const char *name, TABLE *table,
+ HA_CREATE_INFO *info, MRN_SHARE *tmp_share)
+{
+ int error;
+ MRN_LONG_TERM_SHARE *long_term_share = tmp_share->long_term_share;
+ MRN_DBUG_ENTER_METHOD();
+
+ if (info->auto_increment_value) {
+ mrn::Lock lock(&long_term_share->auto_inc_mutex);
+ long_term_share->auto_inc_value = info->auto_increment_value;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ long_term_share->auto_inc_inited = true;
+ }
+
+ error = storage_create_validate_pseudo_column(table);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = storage_create_validate_index(table);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = ensure_database_open(name);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ grn_obj_flags table_flags = GRN_OBJ_PERSISTENT;
+
+ /* primary key must be handled before creating table */
+ grn_obj *pkey_type;
+ uint pkey_nr = table->s->primary_key;
+ if (pkey_nr != MAX_INDEXES) {
+ KEY *key_info = &(table->s->key_info[pkey_nr]);
+ bool is_id;
+
+ int key_parts = KEY_N_KEY_PARTS(key_info);
+ if (key_parts == 1) {
+ Field *pkey_field = key_info->key_part[0].field;
+ const char *column_name = pkey_field->field_name.str;
+ is_id = (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0);
+
+ grn_builtin_type gtype = mrn_grn_type_from_field(ctx, pkey_field, false);
+ pkey_type = grn_ctx_at(ctx, gtype);
+ } else {
+ is_id = false;
+ pkey_type = grn_ctx_at(ctx, GRN_DB_SHORT_TEXT);
+ }
+
+ // default algorithm is BTREE ==> PAT
+ if (!is_id && key_info->algorithm == HA_KEY_ALG_HASH) {
+ table_flags |= GRN_OBJ_TABLE_HASH_KEY;
+ } else if (!is_id) {
+ table_flags |= GRN_OBJ_TABLE_PAT_KEY;
+ } else {
+ // for _id
+ table_flags |= GRN_OBJ_TABLE_NO_KEY;
+ pkey_type = NULL;
+ }
+
+ } else {
+ // primary key doesn't exists
+ table_flags |= GRN_OBJ_TABLE_NO_KEY;
+ pkey_type = NULL;
+ }
+
+ /* create table */
+ grn_obj *table_obj;
+ mrn::PathMapper mapper(name);
+
+ char *table_path = NULL; // we don't specify path
+ grn_obj *pkey_value_type = NULL; // we don't use this
+
+ table_obj = grn_table_create(ctx,
+ mapper.table_name(), strlen(mapper.table_name()),
+ table_path,
+ table_flags, pkey_type, pkey_value_type);
+ if (ctx->rc) {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+
+ if (table_flags == (GRN_OBJ_PERSISTENT | GRN_OBJ_TABLE_PAT_KEY) ||
+ table_flags == (GRN_OBJ_PERSISTENT | GRN_OBJ_TABLE_HASH_KEY)) {
+ KEY *key_info = &(table->s->key_info[pkey_nr]);
+ int key_parts = KEY_N_KEY_PARTS(key_info);
+ if (key_parts == 1) {
+ grn_obj *normalizer = NULL;
+ if (tmp_share->normalizer) {
+ normalizer = grn_ctx_get(ctx,
+ tmp_share->normalizer,
+ tmp_share->normalizer_length);
+ } else {
+ Field *field = &(key_info->key_part->field[0]);
+ if (should_normalize(field)) {
+ normalizer = find_normalizer(key_info);
+ }
+ }
+ if (normalizer) {
+ grn_info_type info_type = GRN_INFO_NORMALIZER;
+ grn_obj_set_info(ctx, table_obj, info_type, normalizer);
+ grn_obj_unlink(ctx, normalizer);
+ }
+ if (tmp_share->default_tokenizer) {
+ grn_obj *default_tokenizer =
+ grn_ctx_get(ctx,
+ tmp_share->default_tokenizer,
+ tmp_share->default_tokenizer_length);
+ if (default_tokenizer) {
+ grn_info_type info_type = GRN_INFO_DEFAULT_TOKENIZER;
+ grn_obj_set_info(ctx, table_obj, info_type, default_tokenizer);
+ grn_obj_unlink(ctx, default_tokenizer);
+ }
+ }
+ if (tmp_share->token_filters) {
+ grn_obj token_filters;
+ GRN_PTR_INIT(&token_filters, GRN_OBJ_VECTOR, 0);
+ if (find_token_filters_fill(&token_filters,
+ tmp_share->token_filters,
+ tmp_share->token_filters_length)) {
+ grn_obj_set_info(ctx, table_obj,
+ GRN_INFO_TOKEN_FILTERS, &token_filters);
+ }
+ grn_obj_unlink(ctx, &token_filters);
+ }
+ }
+ }
+
+ /* create columns */
+ uint n_columns = table->s->fields;
+ for (uint i = 0; i < n_columns; i++) {
+ Field *field = table->s->field[i];
+ mrn::ColumnName column_name(field->field_name);
+
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name.mysql_name()) == 0) {
+ continue;
+ }
+
+#ifdef MRN_SUPPORT_FOREIGN_KEYS
+ if (storage_create_foreign_key(table, mapper.table_name(), field, table_obj,
+ error)) {
+ continue;
+ }
+ if (error) {
+ grn_obj_remove(ctx, table_obj);
+ DBUG_RETURN(error);
+ }
+#endif
+
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ continue;
+ }
+#endif
+
+ grn_obj_flags col_flags = GRN_OBJ_PERSISTENT;
+ if (!find_column_flags(field, tmp_share, i, &col_flags)) {
+ col_flags |= GRN_OBJ_COLUMN_SCALAR;
+ }
+
+ grn_obj *col_type;
+ {
+ int column_type_error_code = ER_CANT_CREATE_TABLE;
+ col_type = find_column_type(field, tmp_share, i, column_type_error_code);
+ if (!col_type) {
+ grn_obj_remove(ctx, table_obj);
+ DBUG_RETURN(column_type_error_code);
+ }
+ }
+ char *col_path = NULL; // we don't specify path
+
+ grn_column_create(ctx, table_obj,
+ column_name.c_str(), column_name.length(),
+ col_path, col_flags, col_type);
+ if (ctx->rc) {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, ctx->errbuf, MYF(0));
+ grn_obj_remove(ctx, table_obj);
+ DBUG_RETURN(error);
+ }
+ }
+
+ error = storage_create_indexes(table, mapper.table_name(), table_obj,
+ tmp_share);
+ if (error) {
+ grn_obj_remove(ctx, table_obj);
+ table_obj = NULL;
+ }
+
+ if (table_obj) {
+ grn_obj_unlink(ctx, table_obj);
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_create_validate_pseudo_column(TABLE *table)
+{
+ int error = 0;
+ uint i, n_columns;
+
+ MRN_DBUG_ENTER_METHOD();
+ n_columns = table->s->fields;
+ for (i = 0; i < n_columns; i++) {
+ Field *field = table->s->field[i];
+ const char *column_name = field->field_name.str;
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
+ switch (field->type()) {
+ case MYSQL_TYPE_TINY :
+ case MYSQL_TYPE_SHORT :
+ case MYSQL_TYPE_INT24 :
+ case MYSQL_TYPE_LONG :
+ case MYSQL_TYPE_LONGLONG :
+ break;
+ default:
+ GRN_LOG(ctx, GRN_LOG_ERROR, "_id must be numeric data type");
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, "_id must be numeric data type", MYF(0));
+ DBUG_RETURN(error);
+ }
+ }
+ }
+
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_SUPPORT_FOREIGN_KEYS
+bool ha_mroonga::storage_create_foreign_key(TABLE *table,
+ const char *grn_table_name,
+ Field *field,
+ grn_obj *table_obj, int &error)
+{
+ MRN_DBUG_ENTER_METHOD();
+ LEX *lex = ha_thd()->lex;
+ Alter_info *alter_info = &lex->alter_info;
+ List_iterator<Key> key_iterator(alter_info->key_list);
+ Key *key;
+ char ref_db_buff[NAME_LEN + 1], ref_table_buff[NAME_LEN + 1];
+ while ((key = key_iterator++))
+ {
+ if (key->type != MRN_KEYTYPE_FOREIGN)
+ {
+ continue;
+ }
+ if (key->columns.elements > 1)
+ {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, "mroonga can't use FOREIGN_KEY with multiple columns",
+ MYF(0));
+ DBUG_RETURN(false);
+ }
+ List_iterator<Key_part_spec> key_part_col_iterator(key->columns);
+ Key_part_spec *key_part_col = key_part_col_iterator++;
+ LEX_CSTRING field_name = key_part_col->field_name;
+ DBUG_PRINT("info", ("mroonga: field_name=%s", field_name.str));
+ DBUG_PRINT("info", ("mroonga: field->field_name=%s", field->field_name.str));
+ if (strcmp(field->field_name.str, field_name.str))
+ {
+ continue;
+ }
+ Foreign_key *fk = (Foreign_key *) key;
+ List_iterator<Key_part_spec> key_part_ref_col_iterator(fk->ref_columns);
+ Key_part_spec *key_part_ref_col = key_part_ref_col_iterator++;
+ LEX_CSTRING ref_field_name = key_part_ref_col->field_name;
+ DBUG_PRINT("info", ("mroonga: ref_field_name=%s", ref_field_name.str));
+#ifdef MRN_FOREIGN_KEY_USE_CONST_STRING
+ LEX_CSTRING ref_db_name = fk->ref_db;
+#else
+ LEX_STRING ref_db_name = fk->ref_db;
+#endif
+ DBUG_PRINT("info", ("mroonga: ref_db_name=%s", ref_db_name.str));
+ if (ref_db_name.str && lower_case_table_names) {
+ strmake(ref_db_buff, ref_db_name.str, sizeof(ref_db_buff) - 1);
+ my_casedn_str(system_charset_info, ref_db_buff);
+ ref_db_name.str = ref_db_buff;
+ DBUG_PRINT("info", ("mroonga: casedn ref_db_name=%s", ref_db_name.str));
+ }
+#ifdef MRN_FOREIGN_KEY_USE_CONST_STRING
+ LEX_CSTRING ref_table_name = fk->ref_table;
+#else
+ LEX_STRING ref_table_name = fk->ref_table;
+#endif
+ DBUG_PRINT("info", ("mroonga: ref_table_name=%s", ref_table_name.str));
+ if (ref_table_name.str && lower_case_table_names) {
+ strmake(ref_table_buff, ref_table_name.str, sizeof(ref_table_buff) - 1);
+ my_casedn_str(system_charset_info, ref_table_buff);
+ ref_table_name.str = ref_table_buff;
+ DBUG_PRINT("info", ("mroonga: casedn ref_table_name=%s", ref_table_name.str));
+ }
+ if (ref_db_name.str && strcmp(table->s->db.str, ref_db_name.str))
+ {
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error,
+ "mroonga can't use FOREIGN_KEY during different database tables",
+ MYF(0));
+ DBUG_RETURN(false);
+ }
+
+ grn_obj *column, *column_ref = NULL, *grn_table_ref = NULL;
+ char ref_path[FN_REFLEN + 1];
+ TABLE_LIST table_list;
+ TABLE_SHARE *tmp_ref_table_share;
+ build_table_filename(ref_path, sizeof(ref_path) - 1,
+ table->s->db.str, ref_table_name.str, "", 0);
+
+ DBUG_PRINT("info", ("mroonga: ref_path=%s", ref_path));
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(false);
+ mrn::PathMapper mapper(ref_path);
+ grn_table_ref = grn_ctx_get(ctx, mapper.table_name(),
+ strlen(mapper.table_name()));
+ if (!grn_table_ref) {
+ error = ER_CANT_CREATE_TABLE;
+ char err_msg[MRN_BUFFER_SIZE];
+ sprintf(err_msg, "reference table [%s.%s] is not mroonga table",
+ table->s->db.str, ref_table_name.str);
+ my_message(error, err_msg, MYF(0));
+ DBUG_RETURN(false);
+ }
+
+ LEX_CSTRING tmp_db_name= { mapper.db_name(), strlen(mapper.db_name()) };
+ LEX_CSTRING tmp_table_name= { mapper.mysql_table_name(), strlen(mapper.mysql_table_name()) };
+ table_list.init_one_table(&tmp_db_name, &tmp_table_name, 0, TL_WRITE);
+ mrn_open_mutex_lock(table->s);
+ tmp_ref_table_share =
+ mrn_create_tmp_table_share(&table_list, ref_path, &error);
+ mrn_open_mutex_unlock(table->s);
+ if (!tmp_ref_table_share) {
+ grn_obj_unlink(ctx, grn_table_ref);
+ error = ER_CANT_CREATE_TABLE;
+ char err_msg[MRN_BUFFER_SIZE];
+ sprintf(err_msg, "reference table [%s.%s] is not found",
+ table->s->db.str, ref_table_name.str);
+ my_message(error, err_msg, MYF(0));
+ DBUG_RETURN(false);
+ }
+ uint ref_pkey_nr = tmp_ref_table_share->primary_key;
+ if (ref_pkey_nr == MAX_KEY) {
+ mrn_open_mutex_lock(table->s);
+ mrn_free_tmp_table_share(tmp_ref_table_share);
+ mrn_open_mutex_unlock(table->s);
+ grn_obj_unlink(ctx, grn_table_ref);
+ error = ER_CANT_CREATE_TABLE;
+ char err_msg[MRN_BUFFER_SIZE];
+ sprintf(err_msg, "reference table [%s.%s] has no primary key",
+ table->s->db.str, ref_table_name.str);
+ my_message(error, err_msg, MYF(0));
+ DBUG_RETURN(false);
+ }
+ KEY *ref_key_info = &tmp_ref_table_share->key_info[ref_pkey_nr];
+ uint ref_key_parts = KEY_N_KEY_PARTS(ref_key_info);
+ if (ref_key_parts > 1) {
+ mrn_open_mutex_lock(table->s);
+ mrn_free_tmp_table_share(tmp_ref_table_share);
+ mrn_open_mutex_unlock(table->s);
+ grn_obj_unlink(ctx, grn_table_ref);
+ error = ER_CANT_CREATE_TABLE;
+ char err_msg[MRN_BUFFER_SIZE];
+ sprintf(err_msg,
+ "reference table [%s.%s] primary key is multiple column",
+ table->s->db.str, ref_table_name.str);
+ my_message(error, err_msg, MYF(0));
+ DBUG_RETURN(false);
+ }
+ Field *ref_field = &ref_key_info->key_part->field[0];
+ if (strcmp(ref_field->field_name.str, ref_field_name.str)) {
+ mrn_open_mutex_lock(table->s);
+ mrn_free_tmp_table_share(tmp_ref_table_share);
+ mrn_open_mutex_unlock(table->s);
+ grn_obj_unlink(ctx, grn_table_ref);
+ error = ER_CANT_CREATE_TABLE;
+ char err_msg[MRN_BUFFER_SIZE];
+ sprintf(err_msg,
+ "reference column [%s.%s.%s] is not used for primary key",
+ table->s->db.str, ref_table_name.str, ref_field_name.str);
+ my_message(error, err_msg, MYF(0));
+ DBUG_RETURN(false);
+ }
+ mrn_open_mutex_lock(table->s);
+ mrn_free_tmp_table_share(tmp_ref_table_share);
+ mrn_open_mutex_unlock(table->s);
+ grn_obj_flags col_flags = GRN_OBJ_PERSISTENT;
+ column = grn_column_create(ctx, table_obj, field->field_name.str,
+ field->field_name.length,
+ NULL, col_flags, grn_table_ref);
+ if (ctx->rc) {
+ grn_obj_unlink(ctx, grn_table_ref);
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(false);
+ }
+
+ mrn::IndexColumnName index_column_name(grn_table_name, field->field_name.str);
+ grn_obj_flags ref_col_flags = GRN_OBJ_COLUMN_INDEX | GRN_OBJ_PERSISTENT;
+ column_ref = grn_column_create(ctx, grn_table_ref,
+ index_column_name.c_str(),
+ index_column_name.length(),
+ NULL, ref_col_flags, table_obj);
+ if (ctx->rc) {
+ grn_obj_unlink(ctx, column);
+ grn_obj_unlink(ctx, grn_table_ref);
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(false);
+ }
+
+ grn_obj source_ids;
+ grn_id source_id = grn_obj_id(ctx, column);
+ GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR);
+ GRN_UINT32_PUT(ctx, &source_ids, source_id);
+ if (error) {
+ grn_obj_unlink(ctx, &source_ids);
+ grn_obj_unlink(ctx, column_ref);
+ grn_obj_unlink(ctx, column);
+ grn_obj_unlink(ctx, grn_table_ref);
+ DBUG_RETURN(false);
+ }
+ grn_obj_set_info(ctx, column_ref, GRN_INFO_SOURCE, &source_ids);
+ grn_obj_unlink(ctx, &source_ids);
+ grn_obj_unlink(ctx, column_ref);
+ grn_obj_unlink(ctx, column);
+ grn_obj_unlink(ctx, grn_table_ref);
+ error = 0;
+ DBUG_RETURN(true);
+ }
+ error = 0;
+ DBUG_RETURN(false);
+}
+#endif
+
+int ha_mroonga::storage_create_validate_index(TABLE *table)
+{
+ int error = 0;
+ uint i;
+
+ MRN_DBUG_ENTER_METHOD();
+ /* checking if index is used for virtual columns */
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ KEY *key_info = &(table->s->key_info[i]);
+ // must be single column key
+ int key_parts = KEY_N_KEY_PARTS(key_info);
+ if (key_parts != 1) {
+ continue;
+ }
+ Field *field = key_info->key_part[0].field;
+ const char *column_name = field->field_name.str;
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
+ if (key_info->algorithm == HA_KEY_ALG_HASH) {
+ continue; // hash index is ok
+ }
+ GRN_LOG(ctx, GRN_LOG_ERROR, "only hash index can be defined for _id");
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, "only hash index can be defined for _id", MYF(0));
+ DBUG_RETURN(error);
+ }
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_create_index_table(TABLE *table,
+ const char *grn_table_name,
+ grn_obj *grn_table,
+ MRN_SHARE *tmp_share,
+ KEY *key_info,
+ grn_obj **index_tables,
+ uint i)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ grn_obj *index_type;
+ grn_obj *index_table;
+ grn_obj_flags index_table_flags = GRN_OBJ_PERSISTENT;
+ bool is_multiple_column_index = KEY_N_KEY_PARTS(key_info) > 1;
+
+ if (tmp_share->index_table && tmp_share->index_table[i]) {
+ index_table = grn_ctx_get(ctx,
+ tmp_share->index_table[i],
+ tmp_share->index_table_length[i]);
+ // TODO: add error check
+ index_tables[i] = index_table;
+ DBUG_RETURN(error);
+ }
+
+ if (is_multiple_column_index) {
+ index_type = grn_ctx_at(ctx, GRN_DB_SHORT_TEXT);
+ } else {
+ Field *field = key_info->key_part[0].field;
+ grn_builtin_type groonga_type = mrn_grn_type_from_field(ctx, field, true);
+ index_type = grn_ctx_at(ctx, groonga_type);
+ }
+ // TODO: Add NULL check for index_type
+
+ int key_alg = key_info->algorithm;
+ if (key_info->flags & HA_FULLTEXT) {
+ index_table_flags |= GRN_OBJ_TABLE_PAT_KEY;
+ error = mrn_change_encoding(ctx, key_info->key_part->field->charset());
+ if (error) {
+ grn_obj_remove(ctx, grn_table);
+ DBUG_RETURN(error);
+ }
+ } else if (key_alg == HA_KEY_ALG_HASH) {
+ index_table_flags |= GRN_OBJ_TABLE_HASH_KEY;
+ } else {
+ index_table_flags |= GRN_OBJ_TABLE_PAT_KEY;
+ }
+
+ {
+ mrn::IndexTableName index_table_name(grn_table_name, key_info->name.str);
+ index_table = grn_table_create(ctx,
+ index_table_name.c_str(),
+ index_table_name.length(),
+ NULL,
+ index_table_flags,
+ index_type,
+ NULL);
+ }
+ if (ctx->rc) {
+ grn_obj_unlink(ctx, index_type);
+ grn_obj_remove(ctx, grn_table);
+ error = ER_CANT_CREATE_TABLE;
+ my_message(ER_CANT_CREATE_TABLE, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+
+ if (key_info->flags & HA_FULLTEXT) {
+ grn_obj *tokenizer = find_tokenizer(key_info, tmp_share, i);
+ if (tokenizer) {
+ grn_info_type info_type = GRN_INFO_DEFAULT_TOKENIZER;
+ grn_obj_set_info(ctx, index_table, info_type, tokenizer);
+ grn_obj_unlink(ctx, tokenizer);
+ }
+
+ {
+ grn_obj token_filters;
+ GRN_PTR_INIT(&token_filters, GRN_OBJ_VECTOR, 0);
+ if (find_token_filters(key_info, &token_filters)) {
+ grn_obj_set_info(ctx, index_table,
+ GRN_INFO_TOKEN_FILTERS, &token_filters);
+ }
+ grn_obj_unlink(ctx, &token_filters);
+ }
+ }
+
+ {
+ grn_obj *normalizer = NULL;
+ Field *field = &(key_info->key_part->field[0]);
+ if (key_info->flags & HA_FULLTEXT) {
+ if (have_custom_normalizer(key_info) ||
+ should_normalize(field)) {
+ normalizer = find_normalizer(key_info);
+ }
+ } else if (key_alg != HA_KEY_ALG_HASH) {
+ if (!is_multiple_column_index &&
+ (have_custom_normalizer(key_info) ||
+ should_normalize(field))) {
+ normalizer = find_normalizer(key_info);
+ }
+ }
+ if (normalizer) {
+ grn_info_type info_type = GRN_INFO_NORMALIZER;
+ grn_obj_set_info(ctx, index_table, info_type, normalizer);
+ grn_obj_unlink(ctx, normalizer);
+ }
+ }
+
+ index_tables[i] = index_table;
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_create_index(TABLE *table, const char *grn_table_name,
+ grn_obj *grn_table, MRN_SHARE *tmp_share,
+ KEY *key_info, grn_obj **index_tables,
+ grn_obj **index_columns, uint i)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ grn_obj *index_column;
+
+ bool is_multiple_column_index = KEY_N_KEY_PARTS(key_info) > 1;
+ if (!is_multiple_column_index) {
+ Field *field = key_info->key_part[0].field;
+ if (strcmp(MRN_COLUMN_NAME_ID, field->field_name.str) == 0) {
+ // skipping _id virtual column
+ DBUG_RETURN(0);
+ }
+
+ if (is_foreign_key_field(table->s->table_name.str,
+ field->field_name.str)) {
+ DBUG_RETURN(0);
+ }
+
+#ifdef HA_CAN_VIRTUAL_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "mroonga: storage: failed to create index: "
+ ER_MRN_KEY_BASED_ON_GENERATED_VIRTUAL_COLUMN_STR,
+ field->field_name.str);
+ error = ER_MRN_KEY_BASED_ON_GENERATED_VIRTUAL_COLUMN_NUM;
+ my_message(error, error_message, MYF(0));
+ DBUG_RETURN(error);
+ }
+ } else {
+ int j, n_key_parts = KEY_N_KEY_PARTS(key_info);
+ for (j = 0; j < n_key_parts; j++) {
+ Field *field = key_info->key_part[j].field;
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "mroonga: storage: failed to create index: "
+ ER_MRN_KEY_BASED_ON_GENERATED_VIRTUAL_COLUMN_STR,
+ field->field_name.str);
+ error = ER_MRN_KEY_BASED_ON_GENERATED_VIRTUAL_COLUMN_NUM;
+ my_message(error, error_message, MYF(0));
+ DBUG_RETURN(error);
+ }
+ }
+#endif
+ }
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = storage_create_index_table(table, grn_table_name,
+ grn_table, tmp_share,
+ key_info, index_tables, i);
+ if (error)
+ DBUG_RETURN(error);
+
+ grn_obj *index_table = index_tables[i];
+
+ grn_column_flags index_column_flags = GRN_OBJ_COLUMN_INDEX | GRN_OBJ_PERSISTENT;
+
+ if (!find_index_column_flags(key_info, &index_column_flags)) {
+ grn_obj *tokenizer = grn_obj_get_info(ctx, index_table,
+ GRN_INFO_DEFAULT_TOKENIZER, NULL);
+ if (tokenizer) {
+ index_column_flags |= GRN_OBJ_WITH_POSITION;
+ }
+ if (is_multiple_column_index && (key_info->flags & HA_FULLTEXT)) {
+ index_column_flags |= GRN_OBJ_WITH_SECTION;
+ }
+ }
+
+ const char *index_column_name;
+ if (tmp_share->index_table && tmp_share->index_table[i]) {
+ index_column_name = key_info->name.str;
+ } else {
+ index_column_name = INDEX_COLUMN_NAME;
+ }
+ index_column = grn_column_create(ctx,
+ index_table,
+ index_column_name,
+ strlen(index_column_name),
+ NULL,
+ index_column_flags,
+ grn_table);
+
+ if (ctx->rc) {
+ grn_obj_remove(ctx, index_table);
+ error = ER_CANT_CREATE_TABLE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+
+ mrn_change_encoding(ctx, system_charset_info);
+ if (is_multiple_column_index) {
+ if (key_info->flags & HA_FULLTEXT) {
+ grn_obj source_ids;
+ GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR);
+
+ int j, n_key_parts = KEY_N_KEY_PARTS(key_info);
+ for (j = 0; j < n_key_parts; j++) {
+ Field *field = key_info->key_part[j].field;
+ mrn::ColumnName column_name(field->field_name);
+ grn_obj *source_column = grn_obj_column(ctx,
+ grn_table,
+ column_name.c_str(),
+ column_name.length());
+ grn_id source_id = grn_obj_id(ctx, source_column);
+ GRN_UINT32_PUT(ctx, &source_ids, source_id);
+ grn_obj_unlink(ctx, source_column);
+ }
+ mrn_change_encoding(ctx, key_info->key_part->field->charset());
+ grn_obj_set_info(ctx, index_column, GRN_INFO_SOURCE, &source_ids);
+ grn_obj_unlink(ctx, &source_ids);
+ }
+ } else {
+ Field *field = key_info->key_part[0].field;
+ mrn::ColumnName column_name(field->field_name);
+ grn_obj *column;
+ column = grn_obj_column(ctx,
+ grn_table,
+ column_name.c_str(),
+ column_name.length());
+ if (column) {
+ grn_obj source_ids;
+ grn_id source_id = grn_obj_id(ctx, column);
+ GRN_UINT32_INIT(&source_ids, GRN_OBJ_VECTOR);
+ GRN_UINT32_PUT(ctx, &source_ids, source_id);
+ mrn_change_encoding(ctx, key_info->key_part->field->charset());
+ grn_obj_set_info(ctx, index_column, GRN_INFO_SOURCE, &source_ids);
+ grn_obj_unlink(ctx, &source_ids);
+ grn_obj_unlink(ctx, column);
+ }
+ }
+ mrn_change_encoding(ctx, system_charset_info);
+
+ if (index_columns) {
+ index_columns[i] = index_column;
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_create_indexes(TABLE *table, const char *grn_table_name,
+ grn_obj *grn_table, MRN_SHARE *tmp_share)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ uint n_keys = table->s->keys;
+ uint i;
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, n_keys);
+ for (i = 0; i < n_keys; i++) {
+ index_tables[i] = NULL;
+ if (i == table->s->primary_key) {
+ continue; // pkey is already handled
+ }
+ KEY *key_info = &table->s->key_info[i];
+ if (tmp_share->disable_keys && !(key_info->flags & HA_NOSAME)) {
+ continue; // key is disabled
+ }
+ if ((error = storage_create_index(table, grn_table_name, grn_table,
+ tmp_share, key_info,
+ index_tables, NULL, i))) {
+ break;
+ }
+ }
+ if (error) {
+ while (true) {
+ if (index_tables[i] &&
+ !(tmp_share->index_table && tmp_share->index_table[i])) {
+ grn_obj_remove(ctx, index_tables[i]);
+ }
+ if (!i)
+ break;
+ i--;
+ }
+ }
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::ensure_database_open(const char *name, mrn::Database **db)
+{
+ int error;
+
+ MRN_DBUG_ENTER_METHOD();
+
+ if (db)
+ *db = NULL;
+
+ mrn::Database *local_db;
+ error = mrn_db_manager->open(name, &local_db);
+ if (error)
+ DBUG_RETURN(error);
+
+ if (db)
+ *db = local_db;
+ grn_ctx_use(ctx, local_db->get());
+
+ delete operations_;
+ operations_ = new mrn::Operations(ctx);
+ if (mrn_enable_operations_recording) {
+ operations_->enable_recording();
+ } else {
+ operations_->disable_recording();
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::ensure_database_remove(const char *name)
+{
+ int error;
+
+ MRN_DBUG_ENTER_METHOD();
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ delete operations_;
+ operations_ = NULL;
+
+ mrn_db_manager->close(name);
+
+ mrn::PathMapper mapper(name);
+ remove_related_files(mapper.db_path());
+
+ DBUG_RETURN(error);
+}
+
+
+int ha_mroonga::create(const char *name,
+ TABLE *table,
+ HA_CREATE_INFO *info
+#ifdef MRN_HANDLER_CREATE_HAVE_TABLE_DEFINITION
+ ,
+ dd::Table *table_def
+#endif
+ )
+{
+ int error = 0;
+ MRN_SHARE *tmp_share;
+ MRN_DBUG_ENTER_METHOD();
+ /* checking data type of virtual columns */
+
+ if (!(tmp_share = mrn_get_share(name, table, &error)))
+ DBUG_RETURN(error);
+
+ st_mrn_slot_data *slot_data = mrn_get_slot_data(ha_thd(), false);
+ if (slot_data && slot_data->disable_keys_create_info == info) {
+ tmp_share->disable_keys = true;
+ }
+
+ if (tmp_share->wrapper_mode)
+ {
+ error = wrapper_create(name, table, info, tmp_share);
+ } else {
+ error = storage_create(name, table, info, tmp_share);
+ }
+
+ if (error) {
+ mrn_free_long_term_share(tmp_share->long_term_share);
+ tmp_share->long_term_share = NULL;
+ } else {
+ error = add_wrap_hton(tmp_share->table_name, tmp_share->hton);
+ }
+ mrn_free_share(tmp_share);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_open(const char *name, int mode, uint open_options)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+
+ mrn::Database *db = NULL;
+ error = ensure_database_open(name, &db);
+ if (error)
+ DBUG_RETURN(error);
+
+ if (!(open_options & HA_OPEN_FOR_REPAIR)) {
+ error = open_table(name);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = wrapper_open_indexes(name);
+ if (error) {
+ grn_obj_unlink(ctx, grn_table);
+ grn_table = NULL;
+ DBUG_RETURN(error);
+ }
+ }
+
+ mrn_init_alloc_root(&mem_root, 1024, 0, MYF(0));
+ wrap_key_info = mrn_create_key_info_for_table(share, table, &error);
+ if (error)
+ DBUG_RETURN(error);
+ base_key_info = table->key_info;
+
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (!is_clone)
+ {
+ wrap_handler = get_new_handler(table->s, &mem_root, share->hton);
+ if (!wrap_handler)
+ {
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ if (wrap_key_info)
+ {
+ my_free(wrap_key_info);
+ wrap_key_info = NULL;
+ }
+ base_key_info = NULL;
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+#ifdef MRN_HANDLER_HAVE_SET_HA_SHARE_REF
+ wrap_handler->set_ha_share_ref(&table->s->ha_share);
+#endif
+ error = wrap_handler->ha_open(table, name, mode, open_options);
+ } else {
+ if (!(wrap_handler = parent_for_clone->wrap_handler->clone(name,
+ mem_root_for_clone)))
+ {
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ if (wrap_key_info)
+ {
+ my_free(wrap_key_info);
+ wrap_key_info = NULL;
+ }
+ base_key_info = NULL;
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+ }
+ ref_length = wrap_handler->ref_length;
+ key_used_on_scan = wrap_handler->key_used_on_scan;
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ init();
+ wrapper_overwrite_index_bits();
+ wrapper_set_keys_in_use();
+
+ pk_keypart_map = make_prev_keypart_map(
+ KEY_N_KEY_PARTS(&(table->key_info[table_share->primary_key])));
+
+ if (!error) {
+ if (open_options & HA_OPEN_FOR_REPAIR) {
+ // TODO: How to check whether is DISABLE KEYS used or not?
+ error = wrapper_recreate_indexes(ha_thd());
+ } else if (db) {
+ mrn::Lock lock(&mrn_operations_mutex);
+ mrn::PathMapper mapper(name);
+ const char *table_name = mapper.table_name();
+ size_t table_name_size = strlen(table_name);
+ if (db->is_broken_table(table_name, table_name_size)) {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "Auto repair is started: <%s>",
+ name);
+ error = operations_->clear(table_name, table_name_size);
+ if (!error) {
+ db->mark_table_repaired(table_name, table_name_size);
+ if (!share->disable_keys) {
+ // TODO: implemented by "reindex" instead of "remove and recreate".
+ // Because "remove and recreate" invalidates opened indexes by
+ // other threads.
+ error = wrapper_disable_indexes_mroonga(HA_KEY_SWITCH_ALL);
+ if (!error) {
+ error = wrapper_enable_indexes_mroonga(HA_KEY_SWITCH_ALL);
+ }
+ }
+ }
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "Auto repair is done: <%s>: %s",
+ name, error == 0 ? "success" : "failure");
+ }
+ }
+ }
+
+ if (error)
+ {
+ grn_obj_unlink(ctx, grn_table);
+ grn_table = NULL;
+ // TODO: free indexes.
+
+ delete wrap_handler;
+ wrap_handler = NULL;
+ if (wrap_key_info)
+ {
+ my_free(wrap_key_info);
+ wrap_key_info = NULL;
+ }
+ base_key_info = NULL;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_open_indexes(const char *name)
+{
+ int error;
+
+ MRN_DBUG_ENTER_METHOD();
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ uint n_keys = table->s->keys;
+ uint n_primary_keys = table->s->primary_key;
+ if (n_keys > 0) {
+ // TODO: reduce allocate memories. We only need just
+ // for HA_KEY_ALG_FULLTEXT keys.
+ grn_index_tables = (grn_obj **)malloc(sizeof(grn_obj *) * n_keys);
+ grn_index_columns = (grn_obj **)malloc(sizeof(grn_obj *) * n_keys);
+ } else {
+ grn_index_tables = grn_index_columns = NULL;
+ }
+
+ mrn::PathMapper mapper(name);
+ uint i = 0;
+ for (i = 0; i < n_keys; i++) {
+ KEY *key_info = &(table->s->key_info[i]);
+
+ grn_index_tables[i] = NULL;
+ grn_index_columns[i] = NULL;
+
+ if (!(wrapper_is_target_index(key_info))) {
+ continue;
+ }
+
+ if (i == n_primary_keys) {
+ continue;
+ }
+
+ mrn::IndexTableName index_table_name(mapper.table_name(), key_info->name.str);
+ grn_index_tables[i] = grn_ctx_get(ctx,
+ index_table_name.c_str(),
+ index_table_name.length());
+ if (ctx->rc == GRN_SUCCESS && !grn_index_tables[i]) {
+ grn_index_tables[i] = grn_ctx_get(ctx,
+ index_table_name.old_c_str(),
+ index_table_name.old_length());
+ }
+ if (ctx->rc) {
+ DBUG_PRINT("info",
+ ("mroonga: sql_command=%u", thd_sql_command(ha_thd())));
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto error;
+ }
+
+ grn_index_columns[i] = grn_obj_column(ctx, grn_index_tables[i],
+ INDEX_COLUMN_NAME,
+ strlen(INDEX_COLUMN_NAME));
+ if (!grn_index_columns[i]) {
+ /* just for backward compatibility before 1.0. */
+ Field *field = key_info->key_part[0].field;
+ grn_index_columns[i] = grn_obj_column(ctx, grn_index_tables[i],
+ field->field_name.str,
+ field->field_name.length);
+ }
+
+ if (ctx->rc) {
+ DBUG_PRINT("info",
+ ("mroonga: sql_command=%u", thd_sql_command(ha_thd())));
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ grn_obj_unlink(ctx, grn_index_tables[i]);
+ goto error;
+ }
+ }
+
+ grn_bulk_space(ctx, &key_buffer, table->key_info->key_length);
+
+error:
+ if (error) {
+ while (i-- > 0) {
+ grn_obj *index_column = grn_index_columns[i];
+ if (index_column) {
+ grn_obj_unlink(ctx, index_column);
+ }
+ grn_obj *index_table = grn_index_tables[i];
+ if (index_table) {
+ grn_obj_unlink(ctx, index_table);
+ }
+ }
+ free(grn_index_columns);
+ free(grn_index_tables);
+ grn_index_columns = NULL;
+ grn_index_tables = NULL;
+ }
+
+ DBUG_RETURN(error);
+}
+
+void ha_mroonga::wrapper_overwrite_index_bits()
+{
+ uint i, j;
+ longlong table_option = table_flags();
+ MRN_DBUG_ENTER_METHOD();
+ table_share->keys_for_keyread.clear_all();
+ for (i = 0; i < table_share->fields; i++)
+ {
+ Field *field = table_share->field[i];
+ field->part_of_key.clear_all();
+#ifdef MRN_HAVE_MYSQL_FIELD_PART_OF_KEY_NOT_CLUSTERED
+ field->part_of_key_not_clustered.clear_all();
+#endif
+ field->part_of_sortkey.clear_all();
+ /*
+ TODO: We may need to update field->part_of_key_not_extended for
+ MySQL >= 5.7.18. If users report "raw InnoDB can use index for
+ this case but Mroonga wrapper mode for InnoDB can't use index
+ for the same case", we'll reconsider it again.
+ */
+ }
+ for (i = 0; i < table_share->keys; i++) {
+ KEY *key_info = &table->s->key_info[i];
+ KEY_PART_INFO *key_part = key_info->key_part;
+ for (j = 0 ; j < KEY_N_KEY_PARTS(key_info); key_part++, j++)
+ {
+ Field *field = key_part->field;
+ if (field->key_length() == key_part->length &&
+ !(field->flags & BLOB_FLAG))
+ {
+ if (index_flags(i, j, 0) & HA_KEYREAD_ONLY)
+ {
+ table_share->keys_for_keyread.set_bit(i);
+ field->part_of_key.set_bit(i);
+#ifdef MRN_HAVE_MYSQL_FIELD_PART_OF_KEY_NOT_CLUSTERED
+ field->part_of_key_not_clustered.set_bit(i);
+#endif
+ }
+ if (index_flags(i, j, 1) & HA_READ_ORDER)
+ field->part_of_sortkey.set_bit(i);
+ }
+ if (i == table_share->primary_key &&
+ (table_option & HA_PRIMARY_KEY_IN_READ_INDEX))
+ {
+ if (field->key_length() == key_part->length &&
+ !(field->flags & BLOB_FLAG))
+ field->part_of_key = table_share->keys_in_use;
+ if (field->part_of_sortkey.is_set(i))
+ field->part_of_sortkey = table_share->keys_in_use;
+ }
+ }
+ }
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::storage_reindex()
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+
+ uint n_keys = table_share->keys;
+ KEY *key_info = table->key_info;
+
+ bool have_multiple_column_index = false;
+ bitmap_clear_all(table->read_set);
+ for (uint i = 0; i < n_keys; ++i) {
+ if (!grn_index_columns[i])
+ continue;
+
+ grn_hash *columns = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
+ GRN_OBJ_TABLE_HASH_KEY);
+ grn_table_columns(ctx, grn_index_tables[i], NULL, 0,
+ reinterpret_cast<grn_obj *>(columns));
+ unsigned int n_columns =
+ grn_table_size(ctx, reinterpret_cast<grn_obj *>(columns));
+ grn_hash_close(ctx, columns);
+
+ bool is_multiple_column_index =
+ (KEY_N_KEY_PARTS(&(key_info[i])) != 1 &&
+ !(key_info[i].flags & HA_FULLTEXT));
+
+ if (n_columns == 1 || is_multiple_column_index) {
+ grn_table_truncate(ctx, grn_index_tables[i]);
+ if (ctx->rc != GRN_SUCCESS) {
+ error = ER_ERROR_ON_WRITE;
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ char index_table_name[GRN_TABLE_MAX_KEY_SIZE];
+ int index_table_name_size;
+ index_table_name_size =
+ grn_obj_name(ctx, grn_index_tables[i],
+ index_table_name, GRN_TABLE_MAX_KEY_SIZE);
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "mroonga: reindex: failed to truncate index table: "
+ "<%.*s>: <%s>(%d)",
+ index_table_name_size, index_table_name,
+ ctx->errbuf, ctx->rc);
+ my_message(error, error_message, MYF(0));
+ break;
+ }
+ }
+
+ if (is_multiple_column_index) {
+ mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
+ have_multiple_column_index = true;
+ } else {
+ grn_obj_reindex(ctx, grn_index_columns[i]);
+ if (ctx->rc != GRN_SUCCESS) {
+ error = ER_ERROR_ON_WRITE;
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ char index_column_name[GRN_TABLE_MAX_KEY_SIZE];
+ int index_column_name_size;
+ index_column_name_size =
+ grn_obj_name(ctx, grn_index_columns[i],
+ index_column_name, GRN_TABLE_MAX_KEY_SIZE);
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "mroonga: reindex: failed to reindex: "
+ "<%.*s>: <%s>(%d)",
+ index_column_name_size, index_column_name,
+ ctx->errbuf, ctx->rc);
+ my_message(error, error_message, MYF(0));
+ break;
+ }
+ }
+ }
+
+ if (!error && have_multiple_column_index)
+ error = storage_add_index_multiple_columns(key_info, n_keys,
+ grn_index_tables,
+ grn_index_columns,
+ false);
+ bitmap_set_all(table->read_set);
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_open(const char *name, int mode, uint open_options)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+
+ mrn::Database *db;
+ error = ensure_database_open(name, &db);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = open_table(name);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = storage_open_columns();
+ if (error) {
+ grn_obj_unlink(ctx, grn_table);
+ grn_table = NULL;
+ DBUG_RETURN(error);
+ }
+
+ if (!(open_options & HA_OPEN_FOR_REPAIR)) {
+ error = storage_open_indexes(name);
+ if (error) {
+ storage_close_columns();
+ grn_obj_unlink(ctx, grn_table);
+ grn_table = NULL;
+ DBUG_RETURN(error);
+ }
+
+ storage_set_keys_in_use();
+
+ {
+ mrn::Lock lock(&mrn_operations_mutex);
+ mrn::PathMapper mapper(name);
+ const char *table_name = mapper.table_name();
+ size_t table_name_size = strlen(table_name);
+ if (db->is_broken_table(table_name, table_name_size)) {
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "Auto repair is started: <%s>",
+ name);
+ error = operations_->repair(table_name, table_name_size);
+ if (!error)
+ db->mark_table_repaired(table_name, table_name_size);
+ if (!share->disable_keys) {
+ if (!error)
+ error = storage_reindex();
+ }
+ GRN_LOG(ctx, GRN_LOG_NOTICE,
+ "Auto repair is done: <%s>: %s",
+ name, error == 0 ? "success" : "failure");
+ }
+ }
+ }
+
+ ref_length = sizeof(grn_id);
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::open_table(const char *name)
+{
+ int error;
+ MRN_DBUG_ENTER_METHOD();
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ mrn::PathMapper mapper(name);
+ grn_table = grn_ctx_get(ctx, mapper.table_name(), strlen(mapper.table_name()));
+ if (ctx->rc) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ if (!grn_table) {
+ error = ER_CANT_OPEN_FILE;
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "mroonga: failed to open table: <%s>",
+ mapper.table_name());
+ my_message(error, error_message, MYF(0));
+ DBUG_RETURN(error);
+ }
+
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::storage_open_columns(void)
+{
+ int error;
+ MRN_DBUG_ENTER_METHOD();
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ int n_columns = table->s->fields;
+ grn_columns = (grn_obj **)malloc(sizeof(grn_obj *) * n_columns);
+ grn_column_ranges = (grn_obj **)malloc(sizeof(grn_obj *) * n_columns);
+ for (int i = 0; i < n_columns; i++) {
+ grn_columns[i] = NULL;
+ grn_column_ranges[i] = NULL;
+ }
+
+ if (table_share->blob_fields)
+ {
+ DBUG_ASSERT(!blob_buffers);
+ if (!(blob_buffers = new (&table->mem_root) String[n_columns]))
+ {
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+ }
+
+ for (int i = 0; i < n_columns; i++) {
+ Field *field = table->field[i];
+ mrn::ColumnName column_name(field->field_name);
+ if (table_share->blob_fields)
+ {
+ blob_buffers[i].set_charset(field->charset());
+ }
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name.mysql_name()) == 0) {
+ continue;
+ }
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ grn_columns[i] = NULL;
+ grn_column_ranges[i] = NULL;
+ continue;
+ }
+#endif
+
+ grn_columns[i] = grn_obj_column(ctx,
+ grn_table,
+ column_name.c_str(),
+ column_name.length());
+ if (!grn_columns[i]) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ break;
+ }
+
+ grn_id range_id = grn_obj_get_range(ctx, grn_columns[i]);
+ grn_column_ranges[i] = grn_ctx_at(ctx, range_id);
+ if (!grn_column_ranges[i]) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ break;
+ }
+ }
+
+ if (error != 0) {
+ storage_close_columns();
+ }
+
+ DBUG_RETURN(error);
+}
+
+void ha_mroonga::storage_close_columns(void)
+{
+ int n_columns = table->s->fields;
+ for (int i = 0; i < n_columns; i++) {
+ grn_obj *column = grn_columns[i];
+ if (column) {
+ grn_obj_unlink(ctx, column);
+ }
+
+ grn_obj *range = grn_column_ranges[i];
+ if (range) {
+ grn_obj_unlink(ctx, range);
+ }
+ }
+
+ free(grn_columns);
+ grn_columns = NULL;
+ free(grn_column_ranges);
+ grn_column_ranges = NULL;
+}
+
+int ha_mroonga::storage_open_indexes(const char *name)
+{
+ int error;
+
+ MRN_DBUG_ENTER_METHOD();
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ uint n_keys = table->s->keys;
+ uint pkey_nr = table->s->primary_key;
+ if (n_keys > 0) {
+ grn_index_tables = (grn_obj **)malloc(sizeof(grn_obj *) * n_keys);
+ grn_index_columns = (grn_obj **)malloc(sizeof(grn_obj *) * n_keys);
+ key_id = (grn_id *)malloc(sizeof(grn_id) * n_keys);
+ del_key_id = (grn_id *)malloc(sizeof(grn_id) * n_keys);
+ } else {
+ grn_index_tables = grn_index_columns = NULL;
+ key_id = NULL;
+ del_key_id = NULL;
+ }
+
+ mrn::PathMapper mapper(name);
+ uint i, j;
+ for (i = 0; i < n_keys; i++) {
+ if (i == pkey_nr) {
+ grn_index_tables[i] = grn_index_columns[i] = NULL;
+ continue;
+ }
+
+ KEY *key_info = &(table->s->key_info[i]);
+ if (KEY_N_KEY_PARTS(key_info) > 1) {
+ KEY_PART_INFO *key_part = key_info->key_part;
+ for (j = 0; j < KEY_N_KEY_PARTS(key_info); j++) {
+ bitmap_set_bit(&multiple_column_key_bitmap,
+ key_part[j].field->field_index);
+ }
+ }
+
+ MRN_SHARE *tmp_share;
+ tmp_share = mrn_get_share(name, table, &error);
+ if (tmp_share->index_table[i]) {
+ grn_index_tables[i] = grn_ctx_get(ctx,
+ tmp_share->index_table[i],
+ tmp_share->index_table_length[i]);
+ if (ctx->rc == GRN_SUCCESS) {
+ grn_index_columns[i] = grn_obj_column(ctx,
+ grn_index_tables[i],
+ key_info->name.str,
+ key_info->name.length);
+ }
+ } else {
+ mrn::IndexTableName index_table_name(mapper.table_name(),
+ key_info->name.str);
+ grn_index_tables[i] = grn_ctx_get(ctx,
+ index_table_name.c_str(),
+ index_table_name.length());
+ if (ctx->rc == GRN_SUCCESS && !grn_index_tables[i]) {
+ grn_index_tables[i] = grn_ctx_get(ctx,
+ index_table_name.old_c_str(),
+ index_table_name.old_length());
+ }
+ if (ctx->rc == GRN_SUCCESS) {
+ grn_index_columns[i] = grn_obj_column(ctx,
+ grn_index_tables[i],
+ INDEX_COLUMN_NAME,
+ strlen(INDEX_COLUMN_NAME));
+ if (!grn_index_columns[i] && ctx->rc == GRN_SUCCESS) {
+ /* just for backward compatibility before 1.0. */
+ Field *field = key_info->key_part[0].field;
+ grn_index_columns[i] = grn_obj_column(ctx, grn_index_tables[i],
+ field->field_name.str,
+ field->field_name.length);
+ }
+ }
+ }
+ mrn_free_share(tmp_share);
+ if (ctx->rc) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto error;
+ }
+
+ if (ctx->rc) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto error;
+ }
+ }
+
+error:
+ if (error) {
+ if (i) {
+ while (true) {
+ grn_obj *index_column = grn_index_columns[i];
+ if (index_column) {
+ grn_obj_unlink(ctx, index_column);
+ }
+ grn_obj *index_table = grn_index_tables[i];
+ if (index_table) {
+ grn_obj_unlink(ctx, index_table);
+ }
+ if (!i)
+ break;
+ i--;
+ }
+ }
+ free(key_id);
+ free(del_key_id);
+ free(grn_index_columns);
+ free(grn_index_tables);
+ key_id = NULL;
+ del_key_id = NULL;
+ grn_index_columns = NULL;
+ grn_index_tables = NULL;
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::open(const char *name,
+ int mode,
+ uint open_options
+#ifdef MRN_HANDLER_OPEN_HAVE_TABLE_DEFINITION
+ ,
+ const dd::Table *table_def
+#endif
+ )
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+
+ if (!(share = mrn_get_share(name, table, &error)))
+ DBUG_RETURN(error);
+ thr_lock_data_init(&share->lock,&thr_lock_data,NULL);
+
+ if (bitmap_init(&multiple_column_key_bitmap, NULL, table->s->fields, false))
+ {
+ mrn_free_share(share);
+ share = NULL;
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+
+ if (share->wrapper_mode)
+ {
+ error = wrapper_open(name, mode, open_options);
+ } else {
+ error = storage_open(name, mode, open_options);
+ }
+
+ if (error)
+ {
+ bitmap_free(&multiple_column_key_bitmap);
+ mrn_free_share(share);
+ share = NULL;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_close()
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+#ifdef MRN_HANDLER_HAVE_HA_CLOSE
+ error = wrap_handler->ha_close();
+#else
+ error = wrap_handler->close();
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ delete wrap_handler;
+ wrap_handler = NULL;
+ if (wrap_key_info)
+ {
+ my_free(wrap_key_info);
+ wrap_key_info = NULL;
+ }
+ base_key_info = NULL;
+ free_root(&mem_root, MYF(0));
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_close()
+{
+ MRN_DBUG_ENTER_METHOD();
+ grn_obj_unlink(ctx, grn_table);
+ // TODO: unlink elements
+ free(grn_columns);
+ // TODO: unlink elements
+ free(grn_column_ranges);
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::close()
+{
+ int error = 0;
+ THD *thd = ha_thd();
+ MRN_DBUG_ENTER_METHOD();
+
+ clear_indexes();
+
+ if (share->wrapper_mode)
+ {
+ error = wrapper_close();
+ } else {
+ error = storage_close();
+ }
+
+ if (error != 0)
+ {
+ DBUG_RETURN(error);
+ }
+
+ if (thd)
+ {
+ error = add_wrap_hton(share->table_name, share->hton);
+ }
+ bitmap_free(&multiple_column_key_bitmap);
+ if (share->use_count == 1) {
+ mrn_free_long_term_share(share->long_term_share);
+ }
+ mrn_free_share(share);
+ share = NULL;
+ is_clone = false;
+
+ if (
+ thd &&
+ thd_sql_command(thd) == SQLCOM_FLUSH
+ ) {
+ /* flush tables */
+ mrn::Lock lock(&mrn_open_tables_mutex);
+ if (!mrn_open_tables.records)
+ {
+ int tmp_error = mrn_db_manager->clear();
+ if (tmp_error)
+ error = tmp_error;
+ }
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_delete_table(const char *name,
+ handlerton *wrap_handlerton,
+ const char *table_name)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(wrap_handlerton->drop_table(wrap_handlerton, name));
+}
+
+int ha_mroonga::generic_delete_table(const char *name, const char *table_name)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+
+ error = ensure_database_open(name);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = drop_indexes(table_name);
+ grn_obj *table_obj = grn_ctx_get(ctx, table_name, strlen(table_name));
+ if (table_obj) {
+ grn_obj_remove(ctx, table_obj);
+ }
+ if (ctx->rc) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::delete_table(const char *name)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+ THD *thd = ha_thd();
+ handlerton *wrap_handlerton = NULL;
+ mrn::PathMapper mapper(name);
+ st_mrn_slot_data *slot_data = mrn_get_slot_data(thd, false);
+ if (slot_data && slot_data->first_wrap_hton)
+ {
+ st_mrn_wrap_hton *wrap_hton, *tmp_wrap_hton;
+ tmp_wrap_hton = NULL;
+ wrap_hton = slot_data->first_wrap_hton;
+ while (wrap_hton)
+ {
+ if (!strcmp(wrap_hton->path, name))
+ {
+ /* found */
+ wrap_handlerton = wrap_hton->hton;
+ if (tmp_wrap_hton)
+ tmp_wrap_hton->next = wrap_hton->next;
+ else
+ slot_data->first_wrap_hton = wrap_hton->next;
+ free(wrap_hton);
+ break;
+ }
+ tmp_wrap_hton = wrap_hton;
+ wrap_hton = wrap_hton->next;
+ }
+ }
+
+ if (!wrap_handlerton) {
+ bool open_table_to_get_wrap_handlerton = true;
+ if (mapper.is_internal_table_name()) {
+ open_table_to_get_wrap_handlerton = false;
+ }
+ if (open_table_to_get_wrap_handlerton) {
+ TABLE_LIST table_list;
+ LEX_CSTRING db_name= { mapper.db_name(), strlen(mapper.db_name()) };
+ LEX_CSTRING table_name= { mapper.mysql_table_name(), strlen(mapper.mysql_table_name()) };
+
+ table_list.init_one_table(&db_name, &table_name, 0, TL_WRITE);
+ mrn_open_mutex_lock(NULL);
+ TABLE_SHARE *tmp_table_share =
+ mrn_create_tmp_table_share(&table_list, name, &error);
+ error = 0;
+ mrn_open_mutex_unlock(NULL);
+ if (tmp_table_share) {
+ TABLE tmp_table;
+ tmp_table.s = tmp_table_share;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+ tmp_table.part_info = NULL;
+#endif
+ MRN_SHARE *tmp_share = mrn_get_share(name, &tmp_table, &error);
+ if (tmp_share) {
+ wrap_handlerton = tmp_share->hton;
+ mrn_free_long_term_share(tmp_share->long_term_share);
+ tmp_share->long_term_share = NULL;
+ mrn_free_share(tmp_share);
+ }
+ mrn_open_mutex_lock(NULL);
+ mrn_free_tmp_table_share(tmp_table_share);
+ mrn_open_mutex_unlock(NULL);
+ if (error) {
+ DBUG_RETURN(error);
+ }
+ }
+ }
+ }
+
+ if (wrap_handlerton)
+ {
+ error = wrapper_delete_table(name, wrap_handlerton, mapper.table_name());
+ }
+
+ if (!error)
+ {
+ error = generic_delete_table(name, mapper.table_name());
+ }
+
+ if (!error) {
+ error = operations_->clear(name, strlen(name));
+ }
+
+ DBUG_RETURN(error);
+}
+
+void ha_mroonga::wrapper_set_keys_in_use()
+{
+ uint i, j;
+ MRN_DBUG_ENTER_METHOD();
+ mrn::AutoIncrementValueLock lock_(table_share);
+ table_share->keys_in_use.set_prefix(table_share->keys);
+ share->disable_keys = false;
+ for (i = 0; i < table_share->keys; i++) {
+ j = share->wrap_key_nr[i];
+ if (j < MAX_KEY) {
+ if (!share->wrap_table_share->keys_in_use.is_set(j)) {
+ /* copy bitmap */
+ table_share->keys_in_use.clear_bit(i);
+ share->disable_keys = true;
+ }
+ } else {
+ if (!grn_index_tables || !grn_index_tables[i]) {
+ /* disabled */
+ table_share->keys_in_use.clear_bit(i);
+ share->disable_keys = true;
+ }
+ }
+ }
+ table_share->keys_for_keyread.set_prefix(table_share->keys);
+ table_share->keys_for_keyread.intersect(table_share->keys_in_use);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_set_keys_in_use()
+{
+ uint i;
+ MRN_DBUG_ENTER_METHOD();
+ mrn::AutoIncrementValueLock lock_(table_share);
+ table_share->keys_in_use.set_prefix(table_share->keys);
+ share->disable_keys = false;
+ for (i = 0; i < table_share->keys; i++) {
+ if (i == table_share->primary_key) {
+ continue;
+ }
+ if (!grn_index_tables[i]) {
+ /* disabled */
+ table_share->keys_in_use.clear_bit(i);
+ DBUG_PRINT("info", ("mroonga: key %u disabled", i));
+ share->disable_keys = true;
+ }
+ }
+ table_share->keys_for_keyread.set_prefix(table_share->keys);
+ table_share->keys_for_keyread.intersect(table_share->keys_in_use);
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::wrapper_info(uint flag)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->info(flag);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ if (flag & HA_STATUS_ERRKEY) {
+ errkey = wrap_handler->errkey;
+ memcpy(dup_ref, wrap_handler->dup_ref, wrap_handler->ref_length);
+ }
+ if (flag & HA_STATUS_TIME) {
+ stats.update_time = wrap_handler->stats.update_time;
+ }
+ if (flag & HA_STATUS_CONST) {
+ stats.max_data_file_length = wrap_handler->stats.max_data_file_length;
+ stats.create_time = wrap_handler->stats.create_time;
+ stats.block_size = wrap_handler->stats.block_size;
+ wrapper_set_keys_in_use();
+ }
+ if (flag & HA_STATUS_VARIABLE) {
+ stats.data_file_length = wrap_handler->stats.data_file_length;
+ stats.index_file_length = wrap_handler->stats.index_file_length;
+ stats.records = wrap_handler->stats.records;
+ stats.mean_rec_length = wrap_handler->stats.mean_rec_length;
+ stats.check_time = wrap_handler->stats.check_time;
+ }
+ if (flag & HA_STATUS_AUTO) {
+ stats.auto_increment_value = wrap_handler->stats.auto_increment_value;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_info(uint flag)
+{
+ MRN_DBUG_ENTER_METHOD();
+ mrn_change_encoding(ctx, NULL);
+
+ if (flag & (HA_STATUS_ERRKEY | HA_STATUS_NO_LOCK)) {
+ errkey = dup_key;
+ }
+
+ if ((flag & HA_STATUS_AUTO) && table->found_next_number_field) {
+ THD *thd = ha_thd();
+ ulonglong nb_reserved_values;
+ bool next_number_field_is_null = !table->next_number_field;
+ mrn::ExternalLock mrn_external_lock(ha_thd(), this,
+ mrn_lock_type == F_UNLCK ?
+ F_RDLCK : F_UNLCK);
+ if (mrn_external_lock.error()) {
+ DBUG_RETURN(mrn_external_lock.error());
+ }
+ if (next_number_field_is_null) {
+ table->next_number_field = table->found_next_number_field;
+ }
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ {
+ mrn::Lock lock(&long_term_share->auto_inc_mutex);
+ unsigned long auto_increment_offset, auto_increment_increment;
+ MRN_THD_GET_AUTOINC(thd, &auto_increment_offset,
+ &auto_increment_increment);
+ storage_get_auto_increment(auto_increment_offset,
+ auto_increment_increment, 1,
+ &stats.auto_increment_value,
+ &nb_reserved_values);
+ }
+ if (next_number_field_is_null) {
+ table->next_number_field = NULL;
+ }
+ }
+
+ if (flag & HA_STATUS_CONST) {
+ storage_set_keys_in_use();
+ }
+
+ if (flag & HA_STATUS_VARIABLE) {
+ storage_info_variable();
+ }
+
+ DBUG_RETURN(0);
+}
+
+void ha_mroonga::storage_info_variable()
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ storage_info_variable_records();
+ storage_info_variable_data_file_length();
+
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_info_variable_records()
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ stats.records = grn_table_size(ctx, grn_table);
+
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_info_variable_data_file_length()
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ stats.data_file_length = 0;
+ stats.data_file_length += file_size(grn_obj_path(ctx, grn_table));
+ grn_hash *columns = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
+ GRN_OBJ_TABLE_HASH_KEY);
+ grn_table_columns(ctx, grn_table, NULL, 0, (grn_obj *)columns);
+ /* grn_id id __attribute__((unused)); */
+ grn_id *column_id;
+ GRN_HASH_EACH(ctx, columns, id, &column_id, NULL, NULL, {
+ grn_obj *column = grn_ctx_at(ctx, *column_id);
+ stats.data_file_length += file_size(grn_obj_path(ctx, column));
+ grn_obj_unlink(ctx, column);
+ });
+ grn_hash_close(ctx, columns);
+
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::info(uint flag)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_info(flag);
+ } else {
+ error = storage_info(flag);
+ }
+ DBUG_RETURN(error);
+}
+
+uint ha_mroonga::wrapper_lock_count() const
+{
+ uint lock_count;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ lock_count = wrap_handler->lock_count();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(lock_count);
+}
+
+uint ha_mroonga::storage_lock_count() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(1);
+}
+
+uint ha_mroonga::lock_count() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_lock_count();
+ } else {
+ error = storage_lock_count();
+ }
+ DBUG_RETURN(error);
+}
+
+THR_LOCK_DATA **ha_mroonga::wrapper_store_lock(THD *thd, THR_LOCK_DATA **to,
+ enum thr_lock_type lock_type)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ to = wrap_handler->store_lock(thd, to, lock_type);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(to);
+}
+
+THR_LOCK_DATA **ha_mroonga::storage_store_lock(THD *thd, THR_LOCK_DATA **to,
+ enum thr_lock_type lock_type)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (lock_type != TL_IGNORE && thr_lock_data.type == TL_UNLOCK) {
+ if (!thd_in_lock_tables(thd)) {
+ if (lock_type == TL_READ_NO_INSERT) {
+ lock_type = TL_READ;
+ } else if (lock_type >= TL_WRITE_CONCURRENT_INSERT &&
+ lock_type <= TL_WRITE && !thd_tablespace_op(thd)) {
+ lock_type = TL_WRITE_ALLOW_WRITE;
+ }
+ }
+
+ thr_lock_data.type = lock_type;
+ }
+ *to++ = &thr_lock_data;
+ DBUG_RETURN(to);
+}
+
+THR_LOCK_DATA **ha_mroonga::store_lock(THD *thd, THR_LOCK_DATA **to,
+ enum thr_lock_type lock_type)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_PRINT("info", ("mroonga: lock_type=%s",
+ mrn_inspect_thr_lock_type(lock_type)));
+ if (share->wrapper_mode)
+ to = wrapper_store_lock(thd, to, lock_type);
+ else
+ to = storage_store_lock(thd, to, lock_type);
+ DBUG_RETURN(to);
+}
+
+int ha_mroonga::wrapper_external_lock(THD *thd, int lock_type)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_external_lock(thd, lock_type);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_external_lock(THD *thd, int lock_type)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::external_lock(THD *thd, int lock_type)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ mrn_lock_type = lock_type;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_external_lock(thd, lock_type);
+ } else {
+ error = storage_external_lock(thd, lock_type);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_rnd_init(bool scan)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_rnd_init(scan);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_rnd_init(bool scan)
+{
+ MRN_DBUG_ENTER_METHOD();
+ mrn_change_encoding(ctx, NULL);
+ cursor = grn_table_cursor_open(ctx, grn_table, NULL, 0, NULL, 0, 0, -1, 0);
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_READ);
+ }
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::rnd_init(bool scan)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_rnd_init(scan);
+ } else {
+ error = storage_rnd_init(scan);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_rnd_end()
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_rnd_end();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_rnd_end()
+{
+ MRN_DBUG_ENTER_METHOD();
+ clear_cursor();
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::rnd_end()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_rnd_end();
+ } else {
+ error = storage_rnd_end();
+ }
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_HANDLER_RECORDS_RETURN_ERROR
+int ha_mroonga::wrapper_records(ha_rows *num_rows)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_records(num_rows);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_records(ha_rows *num_rows)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = handler::records(num_rows);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::records(ha_rows *num_rows)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode) {
+ error = wrapper_records(num_rows);
+ } else {
+ error = storage_records(num_rows);
+ }
+ DBUG_RETURN(error);
+}
+#else
+ha_rows ha_mroonga::wrapper_records()
+{
+ ha_rows num_rows;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ num_rows = wrap_handler->records();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(num_rows);
+}
+
+ha_rows ha_mroonga::storage_records()
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows num_rows = handler::records();
+ DBUG_RETURN(num_rows);
+}
+
+ha_rows ha_mroonga::records()
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows num_rows;
+ if (share->wrapper_mode) {
+ num_rows = wrapper_records();
+ } else {
+ num_rows = storage_records();
+ }
+ DBUG_RETURN(num_rows);
+}
+#endif
+
+int ha_mroonga::wrapper_rnd_next(uchar *buf)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+#ifdef MRN_HANDLER_HAVE_HA_RND_NEXT
+ error = wrap_handler->ha_rnd_next(buf);
+#else
+ error = wrap_handler->rnd_next(buf);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_rnd_next(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = storage_get_next_record(buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::rnd_next(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_rnd_next(buf);
+ } else {
+ error = storage_rnd_next(buf);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_rnd_pos(uchar *buf, uchar *pos)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+#ifdef MRN_HANDLER_HAVE_HA_RND_POS
+ error = wrap_handler->ha_rnd_pos(buf, pos);
+#else
+ error = wrap_handler->rnd_pos(buf, pos);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_rnd_pos(uchar *buf, uchar *pos)
+{
+ MRN_DBUG_ENTER_METHOD();
+ record_id = *((grn_id*) pos);
+ storage_store_fields(buf, record_id);
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::rnd_pos(uchar *buf, uchar *pos)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_rnd_pos(buf, pos);
+ } else {
+ error = storage_rnd_pos(buf, pos);
+ }
+ DBUG_RETURN(error);
+}
+
+void ha_mroonga::wrapper_position(const uchar *record)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->ref = ref;
+ wrap_handler->position(record);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_position(const uchar *record)
+{
+ MRN_DBUG_ENTER_METHOD();
+ memcpy(ref, &record_id, sizeof(grn_id));
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::position(const uchar *record)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ wrapper_position(record);
+ else
+ storage_position(record);
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::generic_extra(enum ha_extra_function operation)
+{
+ MRN_DBUG_ENTER_METHOD();
+ switch (operation) {
+ case HA_EXTRA_IGNORE_DUP_KEY:
+ ignoring_duplicated_key = true;
+ break;
+ case HA_EXTRA_NO_IGNORE_DUP_KEY:
+ ignoring_duplicated_key = false;
+ break;
+ case HA_EXTRA_WRITE_CAN_REPLACE:
+ replacing_ = true;
+ break;
+ case HA_EXTRA_WRITE_CANNOT_REPLACE:
+ replacing_ = false;
+ break;
+ case HA_EXTRA_INSERT_WITH_UPDATE:
+ inserting_with_update = true;
+ break;
+ case HA_EXTRA_KEYREAD:
+ ignoring_no_key_columns = true;
+ break;
+ case HA_EXTRA_NO_KEYREAD:
+ ignoring_no_key_columns = false;
+ break;
+ default:
+ break;
+ }
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::wrapper_extra(enum ha_extra_function operation)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->extra(operation);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_extra(enum ha_extra_function operation)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::extra(enum ha_extra_function operation)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_PRINT("info",
+ ("mroonga: this=%p; extra-operation=%s",
+ this, mrn_inspect_extra_function(operation)));
+ if (share->wrapper_mode) {
+ if ((error = wrapper_extra(operation)))
+ DBUG_RETURN(error);
+ } else {
+ if ((error = storage_extra(operation)))
+ DBUG_RETURN(error);
+ }
+ error = generic_extra(operation);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_extra_opt(enum ha_extra_function operation,
+ ulong cache_size)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->extra_opt(operation, cache_size);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_extra_opt(enum ha_extra_function operation,
+ ulong cache_size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::extra_opt(enum ha_extra_function operation, ulong cache_size)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ if ((error = wrapper_extra_opt(operation, cache_size)))
+ DBUG_RETURN(error);
+ } else {
+ if ((error = storage_extra_opt(operation, cache_size)))
+ DBUG_RETURN(error);
+ }
+ error = generic_extra(operation);
+ DBUG_RETURN(error);
+}
+
+bool ha_mroonga::wrapper_is_target_index(KEY *key_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool target_index =
+ (key_info->algorithm == HA_KEY_ALG_FULLTEXT) || mrn_is_geo_key(key_info);
+ DBUG_PRINT("info", ("mroonga: %s", target_index ? "true" : "false"));
+ DBUG_RETURN(target_index);
+}
+
+bool ha_mroonga::wrapper_have_target_index()
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ bool have_target_index = false;
+
+ uint i;
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ KEY *key_info = &(table->key_info[i]);
+
+ if (wrapper_is_target_index(key_info)) {
+ have_target_index = true;
+ break;
+ }
+ }
+
+ DBUG_PRINT("info", ("mroonga: %s", have_target_index ? "true" : "false"));
+ DBUG_RETURN(have_target_index);
+}
+
+int ha_mroonga::wrapper_write_row(const uchar *buf)
+{
+ int error = 0;
+ THD *thd = ha_thd();
+
+ MRN_DBUG_ENTER_METHOD();
+
+ mrn::Operation operation(operations_,
+ "write",
+ table->s->table_name.str,
+ table->s->table_name.length);
+
+ operation.record_target(record_id);
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ tmp_disable_binlog(thd);
+ error = wrap_handler->ha_write_row(buf);
+ insert_id_for_cur_row = wrap_handler->insert_id_for_cur_row;
+ reenable_binlog(thd);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+
+ if (!error && wrapper_have_target_index()) {
+ error = wrapper_write_row_index(buf);
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_write_row_index(const uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info", ("mroonga: dry write: ha_mroonga::%s", __FUNCTION__));
+ DBUG_RETURN(error);
+ }
+
+ mrn_change_encoding(ctx, NULL);
+ GRN_BULK_REWIND(&key_buffer);
+ grn_bulk_space(ctx, &key_buffer, table->key_info->key_length);
+ key_copy((uchar *)(GRN_TEXT_VALUE(&key_buffer)),
+ buf,
+ &(table->key_info[table_share->primary_key]),
+ table->key_info[table_share->primary_key].key_length);
+
+ int added;
+ grn_id record_id;
+ record_id = grn_table_add(ctx, grn_table,
+ GRN_TEXT_VALUE(&key_buffer),
+ GRN_TEXT_LEN(&key_buffer),
+ &added);
+ if (record_id == GRN_ID_NIL) {
+ DBUG_PRINT("info", ("mroonga: failed to add a new record into groonga"));
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to add a new record into groonga: key=<%.*s>",
+ (int)GRN_TEXT_LEN(&key_buffer),
+ GRN_TEXT_VALUE(&key_buffer));
+ error = ER_ERROR_ON_WRITE;
+ push_warning(ha_thd(), MRN_SEVERITY_WARNING, error,
+ error_message);
+ DBUG_RETURN(0);
+ }
+
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ uint i;
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ KEY *key_info = &(table->key_info[i]);
+
+ if (!(wrapper_is_target_index(key_info))) {
+ continue;
+ }
+
+ grn_obj *index_column = grn_index_columns[i];
+ if (!index_column) {
+ continue;
+ }
+
+ uint j;
+ for (j = 0; j < KEY_N_KEY_PARTS(key_info); j++) {
+ Field *field = key_info->key_part[j].field;
+
+ if (field->is_null())
+ continue;
+
+ error = mrn_change_encoding(ctx, field->charset());
+ if (error)
+ goto err;
+ error = generic_store_bulk(field, &new_value_buffer);
+ if (error) {
+ my_message(error,
+ "mroonga: wrapper: "
+ "failed to get new value for updating index.",
+ MYF(0));
+ goto err;
+ }
+
+ grn_rc rc;
+ rc = grn_column_index_update(ctx, index_column, record_id, j + 1,
+ NULL, &new_value_buffer);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto err;
+ }
+ }
+ }
+err:
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_write_row(const uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool unique_indexes_are_processed = false;
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info", ("mroonga: dry write: ha_mroonga::%s", __FUNCTION__));
+ DBUG_RETURN(error);
+ }
+
+ mrn::Operation operation(operations_,
+ "write",
+ table->s->table_name.str,
+ table->s->table_name.length);
+
+ THD *thd = ha_thd();
+ int i;
+ int n_columns = table->s->fields;
+
+ if (table->next_number_field && buf == table->record[0])
+ {
+ if ((error = update_auto_increment()))
+ DBUG_RETURN(error);
+ }
+
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ for (i = 0; i < n_columns; i++) {
+ Field *field = table->field[i];
+
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ continue;
+ }
+#endif
+
+ if (field->is_null()) continue;
+
+ mrn::ColumnName column_name(field->field_name);
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name.c_str()) == 0) {
+ push_warning_printf(thd, MRN_SEVERITY_WARNING,
+ WARN_DATA_TRUNCATED,
+ MRN_GET_ERR_MSG(WARN_DATA_TRUNCATED),
+ MRN_COLUMN_NAME_ID,
+ MRN_GET_CURRENT_ROW_FOR_WARNING(thd));
+ if (MRN_ABORT_ON_WARNING(thd)) {
+ DBUG_RETURN(ER_DATA_TOO_LONG);
+ }
+ }
+ }
+
+ uint pkey_nr = table->s->primary_key;
+
+ int added = 0;
+ {
+ mrn::Lock lock(&(share->record_mutex), have_unique_index());
+ if ((error = storage_write_row_unique_indexes(buf)))
+ {
+ DBUG_RETURN(error);
+ }
+ unique_indexes_are_processed = true;
+
+ char *pkey;
+ int pkey_size;
+ GRN_BULK_REWIND(&key_buffer);
+ if (pkey_nr == MAX_INDEXES) {
+ pkey = NULL;
+ pkey_size = 0;
+ } else {
+ KEY *key_info = &(table->key_info[pkey_nr]);
+ if (KEY_N_KEY_PARTS(key_info) == 1) {
+ Field *pkey_field = key_info->key_part[0].field;
+ error = mrn_change_encoding(ctx, pkey_field->charset());
+ if (error) {
+ DBUG_RETURN(error);
+ }
+ generic_store_bulk(pkey_field, &key_buffer);
+ pkey = GRN_TEXT_VALUE(&key_buffer);
+ pkey_size = GRN_TEXT_LEN(&key_buffer);
+ } else {
+ mrn_change_encoding(ctx, NULL);
+ uchar key[MRN_MAX_KEY_SIZE];
+ key_copy(key, buf, key_info, key_info->key_length);
+ grn_bulk_reserve(ctx, &key_buffer, MRN_MAX_KEY_SIZE);
+ pkey = GRN_TEXT_VALUE(&key_buffer);
+ storage_encode_multiple_column_key(key_info,
+ key, key_info->key_length,
+ (uchar *)pkey, (uint *)&pkey_size);
+ }
+ }
+
+ if (grn_table->header.type != GRN_TABLE_NO_KEY && pkey_size == 0) {
+ my_message(ER_ERROR_ON_WRITE, "primary key is empty", MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_WRITE);
+ }
+
+ record_id = grn_table_add(ctx, grn_table, pkey, pkey_size, &added);
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_WRITE);
+ }
+ if (!added) {
+ // duplicated error
+ error = HA_ERR_FOUND_DUPP_KEY;
+ memcpy(dup_ref, &record_id, sizeof(grn_id));
+ dup_key = pkey_nr;
+ if (!ignoring_duplicated_key) {
+ GRN_LOG(ctx, GRN_LOG_ERROR,
+ "duplicated id on insert: update primary key: <%.*s>",
+ pkey_size, pkey);
+ }
+ uint j;
+ for (j = 0; j < table->s->keys; j++) {
+ if (j == pkey_nr) {
+ continue;
+ }
+ KEY *key_info = &table->key_info[j];
+ if (key_info->flags & HA_NOSAME) {
+ grn_table_delete_by_id(ctx, grn_index_tables[j], key_id[j]);
+ }
+ }
+ DBUG_RETURN(error);
+ }
+ operation.record_target(record_id);
+ }
+
+ grn_obj colbuf;
+ GRN_VOID_INIT(&colbuf);
+ for (i = 0; i < n_columns; i++) {
+ Field *field = table->field[i];
+
+ if (field->is_null())
+ continue;
+
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ continue;
+ }
+#endif
+
+ mrn::ColumnName column_name(field->field_name);
+
+#ifdef MRN_HAVE_SPATIAL
+ bool is_null_geometry_value =
+ field->real_type() == MYSQL_TYPE_GEOMETRY &&
+ static_cast<Field_blob *>(field)->get_length() == 0;
+ if (is_null_geometry_value) {
+ continue;
+ }
+#endif
+
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name.c_str()) == 0) {
+ continue;
+ }
+
+ error = mrn_change_encoding(ctx, field->charset());
+ if (error) {
+ GRN_OBJ_FIN(ctx, &colbuf);
+ goto err;
+ }
+ error = generic_store_bulk(field, &colbuf);
+ if (error) {
+ GRN_OBJ_FIN(ctx, &colbuf);
+ goto err;
+ }
+
+ grn_obj *column = grn_columns[i];
+ if (is_foreign_key_field(table->s->table_name.str, field->field_name.str)) {
+ grn_obj value;
+ GRN_RECORD_INIT(&value, 0, grn_obj_get_range(ctx, column));
+ grn_rc cast_rc = grn_obj_cast(ctx, &colbuf, &value, GRN_FALSE);
+ if (cast_rc != GRN_SUCCESS) {
+ grn_obj inspected;
+ GRN_TEXT_INIT(&inspected, 0);
+ grn_inspect(ctx, &inspected, &colbuf);
+ error = HA_ERR_NO_REFERENCED_ROW;
+ GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
+ "foreign record doesn't exist: <%s>:<%.*s>",
+ field->field_name.str,
+ static_cast<int>(GRN_TEXT_LEN(&inspected)),
+ GRN_TEXT_VALUE(&inspected));
+ GRN_OBJ_FIN(ctx, &value);
+ GRN_OBJ_FIN(ctx, &colbuf);
+ GRN_OBJ_FIN(ctx, &inspected);
+ goto err;
+ }
+ grn_obj_set_value(ctx, column, record_id, &value, GRN_OBJ_SET);
+ } else {
+ if (added && is_grn_zero_column_value(column, &colbuf)) {
+ // WORKAROUND: groonga can't index newly added '0' value for
+ // fix size column. So we add non-'0' value first then add
+ // real '0' value again. It will be removed when groonga
+ // supports 'null' value.
+ char *bytes = GRN_BULK_HEAD(&colbuf);
+ bytes[0] = '\1';
+ grn_obj_set_value(ctx, column, record_id, &colbuf, GRN_OBJ_SET);
+ bytes[0] = '\0';
+ }
+ grn_obj_set_value(ctx, column, record_id, &colbuf, GRN_OBJ_SET);
+ }
+ if (ctx->rc) {
+ GRN_OBJ_FIN(ctx, &colbuf);
+ my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
+ error = ER_ERROR_ON_WRITE;
+ goto err;
+ }
+ }
+ GRN_OBJ_FIN(ctx, &colbuf);
+
+ error = storage_write_row_multiple_column_indexes(buf, record_id);
+ if (error) {
+ goto err;
+ }
+
+ // for UDF last_insert_grn_id()
+ st_mrn_slot_data *slot_data;
+ slot_data = mrn_get_slot_data(thd, true);
+ if (slot_data == NULL) {
+ error = HA_ERR_OUT_OF_MEM;
+ goto err;
+ }
+ slot_data->last_insert_record_id = record_id;
+
+ grn_db_touch(ctx, grn_ctx_db(ctx));
+
+ if (table->found_next_number_field &&
+ !table->s->next_number_keypart) {
+ Field_num *field = (Field_num *) table->found_next_number_field;
+ if (field->unsigned_flag || field->val_int() > 0) {
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ ulonglong nr = (ulonglong) field->val_int();
+ if (!long_term_share->auto_inc_inited) {
+ storage_info(HA_STATUS_AUTO);
+ }
+ {
+ mrn::Lock lock(&long_term_share->auto_inc_mutex);
+ if (long_term_share->auto_inc_value <= nr) {
+ long_term_share->auto_inc_value = nr + 1;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ }
+ }
+ }
+ }
+ DBUG_RETURN(0);
+
+err:
+ if (unique_indexes_are_processed) {
+ uint j;
+ for (j = 0; j < table->s->keys; j++) {
+ if (j == pkey_nr) {
+ continue;
+ }
+ KEY *key_info = &table->key_info[j];
+ if (key_info->flags & HA_NOSAME) {
+ grn_table_delete_by_id(ctx, grn_index_tables[j], key_id[j]);
+ }
+ }
+ }
+ grn_table_delete_by_id(ctx, grn_table, record_id);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_write_row_multiple_column_index(const uchar *buf,
+ grn_id record_id,
+ KEY *key_info,
+ grn_obj *index_column)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ mrn_change_encoding(ctx, NULL);
+ GRN_BULK_REWIND(&key_buffer);
+ grn_bulk_space(ctx, &key_buffer, key_info->key_length);
+ key_copy((uchar *)(GRN_TEXT_VALUE(&key_buffer)),
+ buf,
+ key_info,
+ key_info->key_length);
+ GRN_BULK_REWIND(&encoded_key_buffer);
+ grn_bulk_reserve(ctx, &encoded_key_buffer, MRN_MAX_KEY_SIZE);
+ uint encoded_key_length;
+ storage_encode_multiple_column_key(key_info,
+ (uchar *)(GRN_TEXT_VALUE(&key_buffer)),
+ key_info->key_length,
+ (uchar *)(GRN_TEXT_VALUE(&encoded_key_buffer)),
+ &encoded_key_length);
+ grn_bulk_space(ctx, &encoded_key_buffer, encoded_key_length);
+ DBUG_PRINT("info", ("mroonga: key_length=%u", key_info->key_length));
+ DBUG_PRINT("info", ("mroonga: encoded_key_length=%u", encoded_key_length));
+
+ grn_rc rc;
+ rc = grn_column_index_update(ctx, index_column, record_id, 1, NULL,
+ &encoded_key_buffer);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_write_row_multiple_column_indexes(const uchar *buf,
+ grn_id record_id)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ uint i;
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &(table->key_info[i]);
+
+ if (KEY_N_KEY_PARTS(key_info) == 1 || (key_info->flags & HA_FULLTEXT)) {
+ continue;
+ }
+
+ grn_obj *index_column = grn_index_columns[i];
+ if (!index_column) {
+ continue;
+ }
+
+ if ((error = storage_write_row_multiple_column_index(buf,
+ record_id,
+ key_info,
+ index_column)))
+ {
+ goto err;
+ }
+ }
+
+err:
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_write_row_unique_index(const uchar *buf,
+ KEY *key_info,
+ grn_obj *index_table,
+ grn_obj *index_column,
+ grn_id *key_id)
+{
+ char *ukey = NULL;
+ int error, ukey_size = 0;
+ MRN_DBUG_ENTER_METHOD();
+ GRN_BULK_REWIND(&key_buffer);
+ if (KEY_N_KEY_PARTS(key_info) == 1) {
+ Field *ukey_field = key_info->key_part[0].field;
+ error = mrn_change_encoding(ctx, ukey_field->charset());
+ if (error) {
+ DBUG_RETURN(error);
+ }
+ generic_store_bulk(ukey_field, &key_buffer);
+ ukey = GRN_TEXT_VALUE(&key_buffer);
+ ukey_size = GRN_TEXT_LEN(&key_buffer);
+ } else {
+ mrn_change_encoding(ctx, NULL);
+ uchar key[MRN_MAX_KEY_SIZE];
+ key_copy(key, buf, key_info, key_info->key_length);
+ grn_bulk_reserve(ctx, &key_buffer, MRN_MAX_KEY_SIZE);
+ ukey = GRN_TEXT_VALUE(&key_buffer);
+ storage_encode_multiple_column_key(key_info,
+ key, key_info->key_length,
+ (uchar *)(ukey), (uint *)&ukey_size);
+ }
+
+ int added;
+ *key_id = grn_table_add(ctx, index_table, ukey, ukey_size, &added);
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_WRITE);
+ }
+ if (!added) {
+ // duplicated error
+ error = HA_ERR_FOUND_DUPP_KEY;
+ grn_id duplicated_record_id = GRN_ID_NIL;
+ {
+ grn_table_cursor *table_cursor;
+ table_cursor = grn_table_cursor_open(ctx, index_table,
+ ukey, ukey_size,
+ ukey, ukey_size,
+ 0, -1, 0);
+ if (table_cursor) {
+ grn_obj *index_cursor;
+ index_cursor = grn_index_cursor_open(ctx, table_cursor, index_column,
+ GRN_ID_NIL, GRN_ID_MAX, 0);
+ if (index_cursor) {
+ grn_posting *posting;
+ posting = grn_index_cursor_next(ctx, index_cursor, NULL);
+ if (posting) {
+ duplicated_record_id = posting->rid;
+ }
+ }
+ grn_obj_unlink(ctx, index_cursor);
+ }
+ grn_table_cursor_close(ctx, table_cursor);
+ }
+ memcpy(dup_ref, &duplicated_record_id, sizeof(grn_id));
+ if (!ignoring_duplicated_key) {
+ GRN_LOG(ctx, GRN_LOG_ERROR,
+ "duplicated id on insert: update unique index: <%.*s>",
+ ukey_size, ukey);
+ }
+ DBUG_RETURN(error);
+ }
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::storage_write_row_unique_indexes(const uchar *buf)
+{
+ int error = 0;
+ uint i;
+ uint n_keys = table->s->keys;
+ MRN_DBUG_ENTER_METHOD();
+
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &table->key_info[i];
+
+ if (!(key_info->flags & HA_NOSAME)) {
+ continue;
+ }
+
+ grn_obj *index_table = grn_index_tables[i];
+ if (!index_table) {
+ continue;
+ }
+ grn_obj *index_column = grn_index_columns[i];
+ if (!index_column) {
+ continue;
+ }
+
+ if ((error = storage_write_row_unique_index(buf, key_info,
+ index_table, index_column,
+ &key_id[i])))
+ {
+ if (error == HA_ERR_FOUND_DUPP_KEY)
+ {
+ dup_key = i;
+ }
+ goto err;
+ }
+ }
+ DBUG_RETURN(0);
+
+err:
+ if (i) {
+ mrn_change_encoding(ctx, NULL);
+ do {
+ i--;
+
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &table->key_info[i];
+ if (!(key_info->flags & HA_NOSAME)) {
+ continue;
+ }
+
+ if (key_info->flags & HA_NOSAME) {
+ grn_table_delete_by_id(ctx, grn_index_tables[i], key_id[i]);
+ }
+ } while (i);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::write_row(const uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_write_row(buf);
+ } else {
+ error = storage_write_row(buf);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_get_record_id(uchar *data, grn_id *record_id,
+ const char *context)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ grn_obj key;
+ GRN_TEXT_INIT(&key, 0);
+
+ mrn_change_encoding(ctx, NULL);
+ grn_bulk_space(ctx, &key, table->key_info->key_length);
+ key_copy((uchar *)(GRN_TEXT_VALUE(&key)),
+ data,
+ &(table->key_info[table_share->primary_key]),
+ table->key_info[table_share->primary_key].key_length);
+
+ *record_id = grn_table_get(ctx, grn_table,
+ GRN_TEXT_VALUE(&key), GRN_TEXT_LEN(&key));
+ if (*record_id == GRN_ID_NIL) {
+ DBUG_PRINT("info", ("mroonga: %s", context));
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "%s: key=<%.*s>",
+ context, (int)GRN_TEXT_LEN(&key), GRN_TEXT_VALUE(&key));
+ error = ER_ERROR_ON_WRITE;
+ push_warning(ha_thd(), MRN_SEVERITY_WARNING, error,
+ error_message);
+ }
+ grn_obj_unlink(ctx, &key);
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_update_row(const uchar *old_data,
+ const uchar *new_data)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+ THD *thd = ha_thd();
+
+ mrn::Operation operation(operations_,
+ "update",
+ table->s->table_name.str,
+ table->s->table_name.length);
+
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ tmp_disable_binlog(thd);
+ error = wrap_handler->ha_update_row(old_data, new_data);
+ reenable_binlog(thd);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+
+ if (!error && wrapper_have_target_index()) {
+ error = wrapper_update_row_index(old_data, new_data);
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_update_row_index(const uchar *old_data,
+ const uchar *new_data)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info", ("mroonga: dry write: ha_mroonga::%s", __FUNCTION__));
+ DBUG_RETURN(error);
+ }
+
+ mrn_change_encoding(ctx, NULL);
+ KEY *key_info = &(table->key_info[table_share->primary_key]);
+ GRN_BULK_REWIND(&key_buffer);
+ key_copy((uchar *)(GRN_TEXT_VALUE(&key_buffer)),
+ new_data,
+ key_info, key_info->key_length);
+ int added;
+ grn_id new_record_id;
+ new_record_id = grn_table_add(ctx, grn_table,
+ GRN_TEXT_VALUE(&key_buffer),
+ table->key_info->key_length,
+ &added);
+ if (new_record_id == GRN_ID_NIL) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to get new record ID for updating from groonga: key=<%.*s>",
+ (int)GRN_TEXT_LEN(&key_buffer), GRN_TEXT_VALUE(&key_buffer));
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, error_message, MYF(0));
+ DBUG_RETURN(error);
+ }
+
+ grn_id old_record_id;
+ my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(old_data, table->record[0]);
+
+ error = wrapper_get_record_id((uchar *)old_data, &old_record_id,
+ "failed to get old record ID "
+ "for updating from groonga");
+ if (error) {
+ DBUG_RETURN(0);
+ }
+
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ uint i;
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ KEY *key_info = &(table->key_info[i]);
+
+ if (!(wrapper_is_target_index(key_info))) {
+ continue;
+ }
+
+ grn_obj *index_column = grn_index_columns[i];
+ if (!index_column) {
+ /* disable keys */
+ continue;
+ }
+
+ uint j;
+ for (j = 0; j < KEY_N_KEY_PARTS(key_info); j++) {
+ Field *field = key_info->key_part[j].field;
+
+ generic_store_bulk(field, &new_value_buffer);
+
+ field->move_field_offset(ptr_diff);
+ generic_store_bulk(field, &old_value_buffer);
+ field->move_field_offset(-ptr_diff);
+
+ grn_rc rc;
+ if (old_record_id == new_record_id) {
+ if (added) {
+ rc = grn_column_index_update(ctx, index_column, old_record_id, j + 1,
+ &old_value_buffer, NULL);
+ if (!rc) {
+ rc = grn_column_index_update(ctx, index_column, new_record_id, j + 1,
+ NULL, &new_value_buffer);
+ }
+ } else {
+ rc = grn_column_index_update(ctx, index_column, old_record_id, j + 1,
+ &old_value_buffer, &new_value_buffer);
+ }
+ } else {
+ rc = grn_column_index_update(ctx, index_column, old_record_id, j + 1,
+ &old_value_buffer, NULL);
+ if (!rc) {
+ rc = grn_column_index_update(ctx, index_column, new_record_id, j + 1,
+ NULL, &new_value_buffer);
+ }
+ if (!rc) {
+ rc = grn_table_delete_by_id(ctx, grn_table, old_record_id);
+ }
+ }
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto err;
+ }
+ }
+ }
+err:
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_update_row(const uchar *old_data,
+ const uchar *new_data)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info", ("mroonga: dry write: ha_mroonga::%s", __FUNCTION__));
+ DBUG_RETURN(error);
+ }
+
+ mrn::Operation operation(operations_,
+ "update",
+ table->s->table_name.str,
+ table->s->table_name.length);
+ operation.record_target(record_id);
+
+ grn_obj colbuf;
+ int i;
+ uint j;
+ int n_columns = table->s->fields;
+ THD *thd = ha_thd();
+
+ for (i = 0; i < n_columns; i++) {
+ Field *field = table->field[i];
+
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ continue;
+ }
+#endif
+
+ if (!bitmap_is_set(table->write_set, field->field_index))
+ continue;
+
+ if (field->is_null())
+ continue;
+
+ {
+ mrn::ColumnName column_name(field->field_name);
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name.c_str()) == 0) {
+ push_warning_printf(thd, MRN_SEVERITY_WARNING,
+ WARN_DATA_TRUNCATED, MRN_GET_ERR_MSG(WARN_DATA_TRUNCATED),
+ MRN_COLUMN_NAME_ID,
+ MRN_GET_CURRENT_ROW_FOR_WARNING(thd));
+ if (MRN_ABORT_ON_WARNING(thd)) {
+ DBUG_RETURN(ER_DATA_TOO_LONG);
+ }
+ }
+ }
+
+ if (!is_foreign_key_field(table->s->table_name.str, field->field_name.str))
+ continue;
+
+ {
+ grn_obj *column = grn_columns[i];
+ grn_obj new_value;
+ GRN_VOID_INIT(&new_value);
+ {
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ generic_store_bulk(field, &new_value);
+ }
+ grn_obj casted_value;
+ GRN_RECORD_INIT(&casted_value, 0, grn_obj_get_range(ctx, column));
+ grn_rc cast_rc = grn_obj_cast(ctx, &new_value, &casted_value, GRN_FALSE);
+ GRN_OBJ_FIN(ctx, &casted_value);
+ if (cast_rc != GRN_SUCCESS) {
+ grn_obj inspected;
+ GRN_TEXT_INIT(&inspected, 0);
+ grn_inspect(ctx, &inspected, &new_value);
+ GRN_OBJ_FIN(ctx, &new_value);
+ error = HA_ERR_NO_REFERENCED_ROW;
+ GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
+ "foreign record doesn't exist: <%s>:<%.*s>",
+ field->field_name.str,
+ static_cast<int>(GRN_TEXT_LEN(&inspected)),
+ GRN_TEXT_VALUE(&inspected));
+ GRN_OBJ_FIN(ctx, &inspected);
+ DBUG_RETURN(error);
+ }
+ GRN_OBJ_FIN(ctx, &new_value);
+ }
+ }
+
+ KEY *pkey_info = NULL;
+ storage_store_fields_for_prep_update(old_data, new_data, record_id);
+ {
+ mrn::Lock lock(&(share->record_mutex), have_unique_index());
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ if ((error = storage_prepare_delete_row_unique_indexes(old_data,
+ record_id))) {
+ DBUG_RETURN(error);
+ }
+ if ((error = storage_update_row_unique_indexes(new_data)))
+ {
+ DBUG_RETURN(error);
+ }
+ }
+
+ if (table->s->primary_key != MAX_INDEXES) {
+ pkey_info = &(table->key_info[table->s->primary_key]);
+ }
+ GRN_VOID_INIT(&colbuf);
+ for (i = 0; i < n_columns; i++) {
+ Field *field = table->field[i];
+
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ continue;
+ }
+#endif
+
+ if (bitmap_is_set(table->write_set, field->field_index)) {
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ DBUG_PRINT("info", ("mroonga: update column %d(%d)",i,field->field_index));
+
+ if (field->is_null()) continue;
+
+ mrn::ColumnName column_name(field->field_name);
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name.c_str()) == 0) {
+ continue;
+ }
+
+ error = mrn_change_encoding(ctx, field->charset());
+ if (error)
+ goto err;
+
+ bool is_pkey = false;
+ bool on_duplicate_key_update =
+ (inserting_with_update && ignoring_duplicated_key);
+ if (pkey_info && !on_duplicate_key_update) {
+ for (j = 0; j < KEY_N_KEY_PARTS(pkey_info); j++) {
+ Field *pkey_field = pkey_info->key_part[j].field;
+ if (strcmp(pkey_field->field_name.str, column_name.c_str()) == 0) {
+ is_pkey = true;
+ break;
+ }
+ }
+ }
+
+ generic_store_bulk(field, &colbuf);
+ if (is_pkey) {
+ bool is_multiple_column_index = KEY_N_KEY_PARTS(pkey_info) > 1;
+ bool is_same_value;
+ if (is_multiple_column_index) {
+ is_same_value = false;
+ } else {
+ grn_id found_record_id = grn_table_get(ctx,
+ grn_table,
+ GRN_BULK_HEAD(&colbuf),
+ GRN_BULK_VSIZE(&colbuf));
+ is_same_value = (record_id == found_record_id);
+ }
+ if (!is_same_value && !replacing_) {
+ char message[MRN_BUFFER_SIZE];
+ snprintf(message, MRN_BUFFER_SIZE,
+ "data truncated for primary key column: <%s>",
+ column_name.c_str());
+ push_warning(thd, MRN_SEVERITY_WARNING,
+ WARN_DATA_TRUNCATED, message);
+ }
+ continue;
+ }
+
+ grn_obj_set_value(ctx, grn_columns[i], record_id, &colbuf, GRN_OBJ_SET);
+ if (ctx->rc) {
+ grn_obj_unlink(ctx, &colbuf);
+ my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
+ error = ER_ERROR_ON_WRITE;
+ goto err;
+ }
+ }
+ }
+ grn_obj_unlink(ctx, &colbuf);
+
+ if ((error = storage_update_row_index(old_data, new_data)))
+ {
+ goto err;
+ }
+
+ if ((error = storage_delete_row_unique_indexes()))
+ {
+ DBUG_RETURN(error);
+ }
+
+ grn_db_touch(ctx, grn_ctx_db(ctx));
+
+ if (table->found_next_number_field &&
+ !table->s->next_number_keypart &&
+ new_data == table->record[0]) {
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ Field_num *field = (Field_num *) table->found_next_number_field;
+ if (field->unsigned_flag || field->val_int() > 0) {
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ ulonglong nr = (ulonglong) field->val_int();
+ if (!long_term_share->auto_inc_inited) {
+ storage_info(HA_STATUS_AUTO);
+ }
+ {
+ mrn::Lock lock(&long_term_share->auto_inc_mutex);
+ if (long_term_share->auto_inc_value <= nr) {
+ long_term_share->auto_inc_value = nr + 1;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ }
+ }
+ }
+ }
+ DBUG_RETURN(0);
+
+err:
+ for (j = 0; j < table->s->keys; j++) {
+ if (j == table->s->primary_key) {
+ continue;
+ }
+ KEY *key_info = &table->key_info[j];
+ if ((key_info->flags & HA_NOSAME) && key_id[j] != GRN_ID_NIL) {
+ grn_table_delete_by_id(ctx, grn_index_tables[j], key_id[j]);
+ }
+ }
+
+ if (!error && thd_sql_command(ha_thd()) == SQLCOM_TRUNCATE) {
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ mrn::Lock lock(&long_term_share->auto_inc_mutex);
+ long_term_share->auto_inc_value = 0;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ long_term_share->auto_inc_inited = false;
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_update_row_index(const uchar *old_data,
+ const uchar *new_data)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ grn_obj old_key, old_encoded_key, new_key, new_encoded_key;
+ GRN_TEXT_INIT(&old_key, 0);
+ GRN_TEXT_INIT(&old_encoded_key, 0);
+ GRN_TEXT_INIT(&new_key, 0);
+ GRN_TEXT_INIT(&new_encoded_key, 0);
+
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ uint i;
+ uint n_keys = table->s->keys;
+ mrn_change_encoding(ctx, NULL);
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &(table->key_info[i]);
+
+ if (KEY_N_KEY_PARTS(key_info) == 1 || (key_info->flags & HA_FULLTEXT)) {
+ continue;
+ }
+
+ grn_obj *index_column = grn_index_columns[i];
+ if (!index_column) {
+ /* disable keys */
+ continue;
+ }
+
+ GRN_BULK_REWIND(&old_key);
+ grn_bulk_space(ctx, &old_key, key_info->key_length);
+ key_copy((uchar *)(GRN_TEXT_VALUE(&old_key)),
+ (uchar *)old_data,
+ key_info,
+ key_info->key_length);
+ GRN_BULK_REWIND(&old_encoded_key);
+ grn_bulk_reserve(ctx, &old_encoded_key, MRN_MAX_KEY_SIZE);
+ uint old_encoded_key_length;
+ storage_encode_multiple_column_key(key_info,
+ (uchar *)(GRN_TEXT_VALUE(&old_key)),
+ key_info->key_length,
+ (uchar *)(GRN_TEXT_VALUE(&old_encoded_key)),
+ &old_encoded_key_length);
+ grn_bulk_space(ctx, &old_encoded_key, old_encoded_key_length);
+
+ GRN_BULK_REWIND(&new_key);
+ grn_bulk_space(ctx, &new_key, key_info->key_length);
+ key_copy((uchar *)(GRN_TEXT_VALUE(&new_key)),
+ (uchar *)new_data,
+ key_info,
+ key_info->key_length);
+ GRN_BULK_REWIND(&new_encoded_key);
+ grn_bulk_reserve(ctx, &new_encoded_key, MRN_MAX_KEY_SIZE);
+ uint new_encoded_key_length;
+ storage_encode_multiple_column_key(key_info,
+ (uchar *)(GRN_TEXT_VALUE(&new_key)),
+ key_info->key_length,
+ (uchar *)(GRN_TEXT_VALUE(&new_encoded_key)),
+ &new_encoded_key_length);
+ grn_bulk_space(ctx, &new_encoded_key, new_encoded_key_length);
+
+ grn_rc rc;
+ rc = grn_column_index_update(ctx, index_column, record_id, 1,
+ &old_encoded_key, &new_encoded_key);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto err;
+ }
+ }
+err:
+ grn_obj_unlink(ctx, &old_key);
+ grn_obj_unlink(ctx, &old_encoded_key);
+ grn_obj_unlink(ctx, &new_key);
+ grn_obj_unlink(ctx, &new_encoded_key);
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_update_row_unique_indexes(const uchar *new_data)
+{
+ int error;
+ uint i;
+ uint n_keys = table->s->keys;
+ MRN_DBUG_ENTER_METHOD();
+
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &table->key_info[i];
+ if (!(key_info->flags & HA_NOSAME)) {
+ continue;
+ }
+
+ grn_obj *index_table = grn_index_tables[i];
+ if (!index_table) {
+ key_id[i] = GRN_ID_NIL;
+ del_key_id[i] = GRN_ID_NIL;
+ continue;
+ }
+
+ grn_obj *index_column = grn_index_columns[i];
+ if (!index_column) {
+ key_id[i] = GRN_ID_NIL;
+ del_key_id[i] = GRN_ID_NIL;
+ continue;
+ }
+
+ if (
+ KEY_N_KEY_PARTS(key_info) == 1 &&
+ !bitmap_is_set(table->write_set,
+ key_info->key_part[0].field->field_index)
+ ) {
+ /* no change */
+ key_id[i] = GRN_ID_NIL;
+ del_key_id[i] = GRN_ID_NIL;
+ continue;
+ }
+
+ if ((error = storage_write_row_unique_index(new_data, key_info,
+ index_table, index_column,
+ &key_id[i])))
+ {
+ if (error == HA_ERR_FOUND_DUPP_KEY)
+ {
+ if (key_id[i] == del_key_id[i]) {
+ /* no change */
+ key_id[i] = GRN_ID_NIL;
+ del_key_id[i] = GRN_ID_NIL;
+ continue;
+ }
+ dup_key = i;
+ DBUG_PRINT("info", ("mroonga: different key ID: %d record ID: %d,%d",
+ i, key_id[i], del_key_id[i]));
+ }
+ goto err;
+ }
+ }
+ DBUG_RETURN(0);
+
+err:
+ if (i) {
+ mrn_change_encoding(ctx, NULL);
+ do {
+ i--;
+ KEY *key_info = &table->key_info[i];
+ if ((key_info->flags & HA_NOSAME) && key_id[i] != GRN_ID_NIL) {
+ grn_table_delete_by_id(ctx, grn_index_tables[i], key_id[i]);
+ }
+ } while (i);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::update_row(const uchar *old_data, const uchar *new_data)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_update_row(old_data, new_data);
+ } else {
+ error = storage_update_row(old_data, new_data);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_delete_row(const uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+ THD *thd= ha_thd();
+
+ mrn::Operation operation(operations_,
+ "delete",
+ table->s->table_name.str,
+ table->s->table_name.length);
+
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ tmp_disable_binlog(thd);
+ error = wrap_handler->ha_delete_row(buf);
+ reenable_binlog(thd);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+
+ if (!error && wrapper_have_target_index()) {
+ error = wrapper_delete_row_index(buf);
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_delete_row_index(const uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info", ("mroonga: dry write: ha_mroonga::%s", __FUNCTION__));
+ DBUG_RETURN(error);
+ }
+
+ mrn_change_encoding(ctx, NULL);
+ grn_id record_id;
+ error = wrapper_get_record_id((uchar *)buf, &record_id,
+ "failed to get record ID "
+ "for deleting from groonga");
+ if (error) {
+ DBUG_RETURN(0);
+ }
+
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ uint i;
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ KEY *key_info = &(table->key_info[i]);
+
+ if (!(wrapper_is_target_index(key_info))) {
+ continue;
+ }
+
+ grn_obj *index_column = grn_index_columns[i];
+ if (!index_column) {
+ /* disable keys */
+ continue;
+ }
+
+ uint j;
+ for (j = 0; j < KEY_N_KEY_PARTS(key_info); j++) {
+ Field *field = key_info->key_part[j].field;
+
+ if (field->is_null())
+ continue;
+
+ generic_store_bulk(field, &old_value_buffer);
+ grn_rc rc;
+ rc = grn_column_index_update(ctx, index_column, record_id, j + 1,
+ &old_value_buffer, NULL);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto err;
+ }
+ }
+ }
+err:
+ grn_table_delete_by_id(ctx, grn_table, record_id);
+ if (ctx->rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_delete_row(const uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info", ("mroonga: dry write: ha_mroonga::%s", __FUNCTION__));
+ DBUG_RETURN(0);
+ }
+
+ mrn::Operation operation(operations_,
+ "delete",
+ table->s->table_name.str,
+ table->s->table_name.length);
+ operation.record_target(record_id);
+
+ {
+ grn_id referencing_child_table_id = GRN_ID_NIL;
+ grn_hash *columns = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
+ GRN_OBJ_TABLE_HASH_KEY|GRN_HASH_TINY);
+ grn_table_columns(ctx, grn_table, "", 0,
+ reinterpret_cast<grn_obj *>(columns));
+ GRN_HASH_EACH_BEGIN(ctx, columns, cursor, id) {
+ void *key;
+ grn_hash_cursor_get_key(ctx, cursor, &key);
+ grn_id column_id = *static_cast<grn_id *>(key);
+ grn_obj *column = grn_ctx_at(ctx, column_id);
+ if (!column)
+ continue;
+
+ if (column->header.type != GRN_COLUMN_INDEX)
+ continue;
+
+ grn_ii_cursor *ii_cursor =
+ grn_ii_cursor_open(ctx,
+ reinterpret_cast<grn_ii *>(column),
+ record_id,
+ GRN_ID_NIL,
+ GRN_ID_MAX,
+ 0,
+ 0);
+ if (!ii_cursor)
+ continue;
+
+ if (grn_ii_cursor_next(ctx, ii_cursor)) {
+ referencing_child_table_id = grn_obj_get_range(ctx, column);
+ }
+
+ grn_ii_cursor_close(ctx, ii_cursor);
+
+ if (referencing_child_table_id != GRN_ID_NIL)
+ break;
+ } GRN_HASH_EACH_END(ctx, cursor);
+ grn_hash_close(ctx, columns);
+
+ if (referencing_child_table_id != GRN_ID_NIL) {
+ grn_obj *referencing_child_table =
+ grn_ctx_at(ctx, referencing_child_table_id);
+ char name[GRN_TABLE_MAX_KEY_SIZE];
+ int name_size;
+ name_size = grn_obj_name(ctx,
+ referencing_child_table,
+ name,
+ GRN_TABLE_MAX_KEY_SIZE);
+ error = HA_ERR_ROW_IS_REFERENCED;
+ GRN_PLUGIN_ERROR(ctx, GRN_INVALID_ARGUMENT,
+ "one or more child rows exist in <%.*s>",
+ name_size,
+ name);
+ DBUG_RETURN(error);
+ }
+ }
+
+ storage_store_fields_for_prep_update(buf, NULL, record_id);
+ {
+ mrn::Lock lock(&(share->record_mutex), have_unique_index());
+ if ((error = storage_prepare_delete_row_unique_indexes(buf, record_id))) {
+ DBUG_RETURN(error);
+ }
+ mrn_change_encoding(ctx, NULL);
+ grn_table_delete_by_id(ctx, grn_table, record_id);
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_WRITE);
+ }
+ if (
+ (error = storage_delete_row_index(buf)) ||
+ (error = storage_delete_row_unique_indexes())
+ ) {
+ DBUG_RETURN(error);
+ }
+ }
+
+ grn_db_touch(ctx, grn_ctx_db(ctx));
+
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::storage_delete_row_index(const uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ grn_obj key, encoded_key;
+ GRN_TEXT_INIT(&key, 0);
+ GRN_TEXT_INIT(&encoded_key, 0);
+
+ mrn::DebugColumnAccess debug_column_access(table, &table->read_set);
+ uint i;
+ uint n_keys = table->s->keys;
+ mrn_change_encoding(ctx, NULL);
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &(table->key_info[i]);
+
+ if (KEY_N_KEY_PARTS(key_info) == 1 || (key_info->flags & HA_FULLTEXT)) {
+ continue;
+ }
+
+ grn_obj *index_column = grn_index_columns[i];
+ if (!index_column) {
+ /* disable keys */
+ continue;
+ }
+
+ GRN_BULK_REWIND(&key);
+ grn_bulk_space(ctx, &key, key_info->key_length);
+ key_copy((uchar *)(GRN_TEXT_VALUE(&key)),
+ (uchar *)buf,
+ key_info,
+ key_info->key_length);
+ GRN_BULK_REWIND(&encoded_key);
+ grn_bulk_reserve(ctx, &encoded_key, MRN_MAX_KEY_SIZE);
+ uint encoded_key_length;
+ storage_encode_multiple_column_key(key_info,
+ (uchar *)(GRN_TEXT_VALUE(&key)),
+ key_info->key_length,
+ (uchar *)(GRN_TEXT_VALUE(&encoded_key)),
+ &encoded_key_length);
+ grn_bulk_space(ctx, &encoded_key, encoded_key_length);
+
+ grn_rc rc;
+ rc = grn_column_index_update(ctx, index_column, record_id, 1,
+ &encoded_key, NULL);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto err;
+ }
+ }
+err:
+ grn_obj_unlink(ctx, &encoded_key);
+ grn_obj_unlink(ctx, &key);
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_delete_row_unique_index(grn_obj *index_table,
+ grn_id del_key_id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ grn_rc rc = grn_table_delete_by_id(ctx, index_table, del_key_id);
+ if (rc) {
+ my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_WRITE);
+ }
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::storage_delete_row_unique_indexes()
+{
+ int error = 0, tmp_error;
+ uint i;
+ uint n_keys = table->s->keys;
+ MRN_DBUG_ENTER_METHOD();
+
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &table->key_info[i];
+ if ((!(key_info->flags & HA_NOSAME)) || del_key_id[i] == GRN_ID_NIL) {
+ continue;
+ }
+
+ grn_obj *index_table = grn_index_tables[i];
+ if ((tmp_error = storage_delete_row_unique_index(index_table,
+ del_key_id[i])))
+ {
+ error = tmp_error;
+ }
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_prepare_delete_row_unique_index(const uchar *buf,
+ grn_id record_id,
+ KEY *key_info,
+ grn_obj *index_table,
+ grn_obj *index_column,
+ grn_id *del_key_id)
+{
+ const void *ukey = NULL;
+ uint32 ukey_size = 0;
+ MRN_DBUG_ENTER_METHOD();
+ if (KEY_N_KEY_PARTS(key_info) == 1) {
+ GRN_BULK_REWIND(&key_buffer);
+ grn_obj_get_value(ctx, index_column, record_id, &key_buffer);
+ ukey = GRN_TEXT_VALUE(&key_buffer);
+ ukey_size = GRN_TEXT_LEN(&key_buffer);
+ } else {
+ mrn_change_encoding(ctx, NULL);
+ uchar key[MRN_MAX_KEY_SIZE];
+ key_copy(key, (uchar *) buf, key_info, key_info->key_length);
+ grn_bulk_reserve(ctx, &key_buffer, MRN_MAX_KEY_SIZE);
+ ukey = GRN_TEXT_VALUE(&key_buffer);
+ storage_encode_multiple_column_key(key_info,
+ key, key_info->key_length,
+ (uchar *)ukey, (uint *)&ukey_size);
+ }
+ *del_key_id = grn_table_get(ctx, index_table, ukey, ukey_size);
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::storage_prepare_delete_row_unique_indexes(const uchar *buf,
+ grn_id record_id)
+{
+ int error = 0, tmp_error;
+ uint i;
+ uint n_keys = table->s->keys;
+ MRN_DBUG_ENTER_METHOD();
+
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &table->key_info[i];
+ if (!(key_info->flags & HA_NOSAME)) {
+ continue;
+ }
+
+ grn_obj *index_table = grn_index_tables[i];
+ if (!index_table) {
+ del_key_id[i] = GRN_ID_NIL;
+ continue;
+ }
+
+ grn_obj *index_column;
+ if (KEY_N_KEY_PARTS(key_info) == 1) {
+ Field *field = key_info->key_part[0].field;
+ mrn_change_encoding(ctx, field->charset());
+ index_column = grn_columns[field->field_index];
+ } else {
+ mrn_change_encoding(ctx, NULL);
+ index_column = grn_index_columns[i];
+ }
+ if ((tmp_error = storage_prepare_delete_row_unique_index(buf, record_id,
+ key_info,
+ index_table,
+ index_column,
+ &del_key_id[i])))
+ {
+ error = tmp_error;
+ }
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::delete_row(const uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_delete_row(buf);
+ } else {
+ error = storage_delete_row(buf);
+ }
+ DBUG_RETURN(error);
+}
+
+uint ha_mroonga::wrapper_max_supported_key_parts() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(MAX_REF_PARTS);
+}
+
+uint ha_mroonga::storage_max_supported_key_parts() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(MAX_REF_PARTS);
+}
+
+uint ha_mroonga::max_supported_key_parts() const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ uint parts;
+ if (!share && !analyzed_for_create &&
+ (
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_TABLE ||
+ thd_sql_command(ha_thd()) == SQLCOM_CREATE_INDEX ||
+ thd_sql_command(ha_thd()) == SQLCOM_ALTER_TABLE
+ )
+ ) {
+ create_share_for_create();
+ }
+ if (analyzed_for_create && share_for_create.wrapper_mode) {
+ parts = wrapper_max_supported_key_parts();
+ } else if (wrap_handler && share && share->wrapper_mode) {
+ parts = wrapper_max_supported_key_parts();
+ } else {
+ parts = storage_max_supported_key_parts();
+ }
+
+ DBUG_RETURN(parts);
+}
+
+ha_rows ha_mroonga::wrapper_records_in_range(uint key_nr,
+ const key_range *range_min,
+ const key_range *range_max,
+ page_range *pages)
+{
+ ha_rows row_count;
+ MRN_DBUG_ENTER_METHOD();
+ KEY *key_info = &(table->s->key_info[key_nr]);
+ if (mrn_is_geo_key(key_info)) {
+ row_count = generic_records_in_range_geo(key_nr, range_min, range_max);
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ row_count = wrap_handler->records_in_range(key_nr, range_min, range_max,
+ pages);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(row_count);
+}
+
+ha_rows ha_mroonga::storage_records_in_range(uint key_nr,
+ const key_range *range_min,
+ const key_range *range_max,
+ page_range *pages)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int flags = 0;
+ uint size_min = 0, size_max = 0;
+ ha_rows row_count = 0;
+ uchar *key_min = NULL, *key_max = NULL;
+ uchar key_min_entity[MRN_MAX_KEY_SIZE];
+ uchar key_max_entity[MRN_MAX_KEY_SIZE];
+ KEY *key_info = &(table->s->key_info[key_nr]);
+ bool is_multiple_column_index = KEY_N_KEY_PARTS(key_info) > 1;
+
+ if (is_multiple_column_index) {
+ mrn_change_encoding(ctx, NULL);
+ if (range_min && range_max &&
+ range_min->length == range_max->length &&
+ memcmp(range_min->key, range_max->key, range_min->length) == 0) {
+ flags |= GRN_CURSOR_PREFIX;
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key(key_info,
+ range_min->key, range_min->length,
+ key_min, &size_min);
+ } else {
+ key_min = key_min_entity;
+ key_max = key_max_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ range_min, range_max,
+ key_min, &size_min,
+ key_max, &size_max);
+ }
+ } else if (mrn_is_geo_key(key_info)) {
+ mrn_change_encoding(ctx, key_info->key_part->field->charset());
+ row_count = generic_records_in_range_geo(key_nr, range_min, range_max);
+ DBUG_RETURN(row_count);
+ } else {
+ Field *field = key_info->key_part[0].field;
+ const char *column_name = field->field_name.str;
+ mrn_change_encoding(ctx, field->charset());
+
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
+ DBUG_RETURN((ha_rows)1);
+ }
+
+ if (range_min) {
+ key_min = key_min_entity;
+ storage_encode_key(field, range_min->key, key_min, &size_min);
+ if (size_min == 0) {
+ DBUG_RETURN(HA_POS_ERROR);
+ }
+ }
+ if (range_max) {
+ key_max = key_max_entity;
+ storage_encode_key(field, range_max->key, key_max, &size_max);
+ if (size_max == 0) {
+ DBUG_RETURN(HA_POS_ERROR);
+ }
+ }
+ }
+
+ if (range_min) {
+ DBUG_PRINT("info", ("mroonga: range_min->flag=%u", range_min->flag));
+ if (range_min->flag == HA_READ_AFTER_KEY) {
+ flags |= GRN_CURSOR_GT;
+ }
+ }
+ if (range_max) {
+ DBUG_PRINT("info", ("mroonga: range_min->flag=%u", range_max->flag));
+ if (range_max->flag == HA_READ_BEFORE_KEY) {
+ flags |= GRN_CURSOR_LT;
+ }
+ }
+
+ int cursor_limit = THDVAR(ha_thd(), max_n_records_for_estimate);
+ uint pkey_nr = table->s->primary_key;
+ if (key_nr == pkey_nr) {
+ DBUG_PRINT("info", ("mroonga: use primary key"));
+ grn_table_cursor *cursor;
+ cursor = grn_table_cursor_open(ctx, grn_table,
+ key_min, size_min,
+ key_max, size_max,
+ 0, cursor_limit, flags);
+ while (grn_table_cursor_next(ctx, cursor) != GRN_ID_NIL) {
+ row_count++;
+ }
+ grn_table_cursor_close(ctx, cursor);
+ } else {
+ if (is_multiple_column_index) {
+ DBUG_PRINT("info", ("mroonga: use multiple column key%u", key_nr));
+ } else {
+ DBUG_PRINT("info", ("mroonga: use key%u", key_nr));
+ }
+
+ grn_table_cursor *cursor;
+ cursor = grn_table_cursor_open(ctx, grn_index_tables[key_nr],
+ key_min, size_min,
+ key_max, size_max,
+ 0, cursor_limit, flags);
+ grn_obj *index_column = grn_index_columns[key_nr];
+ grn_ii *ii = reinterpret_cast<grn_ii *>(index_column);
+ row_count = grn_ii_estimate_size_for_lexicon_cursor(ctx, ii, cursor);
+ grn_table_cursor_close(ctx, cursor);
+
+ unsigned int max_n_lexicon_records =
+ grn_table_size(ctx, grn_index_tables[key_nr]);
+ if (cursor_limit >= 0 &&
+ static_cast<unsigned int>(cursor_limit) < max_n_lexicon_records) {
+ row_count++;
+ }
+ }
+ DBUG_RETURN(row_count);
+}
+
+ha_rows ha_mroonga::generic_records_in_range_geo(uint key_nr,
+ const key_range *range_min,
+ const key_range *range_max)
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows row_count;
+ int error;
+
+ if (!range_min) {
+ DBUG_PRINT("info",
+ ("mroonga: range min is missing for geometry range search"));
+ DBUG_RETURN(HA_POS_ERROR);
+ }
+ if (range_max) {
+ DBUG_PRINT("info",
+ ("mroonga: range max is specified for geometry range search"));
+ DBUG_RETURN(HA_POS_ERROR);
+ }
+ error = mrn_change_encoding(ctx,
+ table->key_info[key_nr].key_part->field->charset());
+ if (error)
+ DBUG_RETURN(error);
+ if (!(range_min->flag & HA_READ_MBR_CONTAIN)) {
+ push_warning_unsupported_spatial_index_search(range_min->flag);
+ row_count = grn_table_size(ctx, grn_table);
+ DBUG_RETURN(row_count);
+ }
+
+ geo_store_rectangle(range_min->key);
+ row_count = grn_geo_estimate_in_rectangle(ctx,
+ grn_index_columns[key_nr],
+ &top_left_point,
+ &bottom_right_point);
+ DBUG_RETURN(row_count);
+}
+
+ha_rows ha_mroonga::records_in_range(uint key_nr, const key_range *range_min,
+ const key_range *range_max,
+ page_range *pages)
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows row_count = 0;
+ if (share->wrapper_mode)
+ {
+ row_count = wrapper_records_in_range(key_nr, range_min, range_max, pages);
+ } else {
+ row_count = storage_records_in_range(key_nr, range_min, range_max, pages);
+ }
+ DBUG_PRINT("info", ("mroonga: row_count=%" MRN_HA_ROWS_FORMAT, row_count));
+ DBUG_RETURN(row_count);
+}
+
+int ha_mroonga::wrapper_index_init(uint idx, bool sorted)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ KEY *key_info = &(table->s->key_info[idx]);
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (!mrn_is_geo_key(key_info) && key_info->algorithm != HA_KEY_ALG_FULLTEXT)
+ {
+ error = wrap_handler->ha_index_init(share->wrap_key_nr[idx], sorted);
+ } else {
+ error = wrap_handler->ha_index_init(share->wrap_primary_key, sorted);
+ }
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_init(uint idx, bool sorted)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::index_init(uint idx, bool sorted)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_PRINT("info", ("mroonga: idx=%u", idx));
+ active_index = idx;
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_init(idx, sorted);
+ } else {
+ error = storage_index_init(idx, sorted);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_index_end()
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_index_or_rnd_end();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_end()
+{
+ MRN_DBUG_ENTER_METHOD();
+ clear_cursor();
+ clear_cursor_geo();
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::index_end()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_end();
+ } else {
+ error = storage_index_end();
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_index_read_map(uchar *buf, const uchar *key,
+ key_part_map keypart_map,
+ enum ha_rkey_function find_flag)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ KEY *key_info = &(table->key_info[active_index]);
+ if (mrn_is_geo_key(key_info)) {
+ clear_cursor_geo();
+ error = generic_geo_open_cursor(key, find_flag);
+ if (!error) {
+ error = wrapper_get_next_geo_record(buf);
+ }
+ DBUG_RETURN(error);
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+#ifdef MRN_HANDLER_HAVE_HA_INDEX_READ_MAP
+ error = wrap_handler->ha_index_read_map(buf, key, keypart_map, find_flag);
+#else
+ error = wrap_handler->index_read_map(buf, key, keypart_map, find_flag);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_read_map(uchar *buf, const uchar *key,
+ key_part_map keypart_map,
+ enum ha_rkey_function find_flag)
+{
+ MRN_DBUG_ENTER_METHOD();
+ check_count_skip(keypart_map);
+
+ int error = 0;
+
+ uint key_nr = active_index;
+ KEY *key_info = &(table->key_info[key_nr]);
+ int flags = 0;
+ uint size_min = 0, size_max = 0;
+ uchar *key_min = NULL, *key_max = NULL;
+ uchar key_min_entity[MRN_MAX_KEY_SIZE];
+ uchar key_max_entity[MRN_MAX_KEY_SIZE];
+
+ clear_cursor();
+ clear_cursor_geo();
+ clear_empty_value_records();
+
+ switch (find_flag) {
+ case HA_READ_BEFORE_KEY:
+ flags |= GRN_CURSOR_LT | GRN_CURSOR_DESCENDING;
+ break;
+ case HA_READ_PREFIX_LAST:
+ flags |= GRN_CURSOR_PREFIX | GRN_CURSOR_DESCENDING;
+ break;
+ case HA_READ_PREFIX_LAST_OR_PREV:
+ flags |= GRN_CURSOR_LE | GRN_CURSOR_DESCENDING;
+ break;
+ case HA_READ_AFTER_KEY:
+ flags |= GRN_CURSOR_GT | GRN_CURSOR_ASCENDING;
+ break;
+ case HA_READ_KEY_OR_NEXT:
+ flags |= GRN_CURSOR_GE | GRN_CURSOR_ASCENDING;
+ break;
+ case HA_READ_KEY_EXACT:
+ flags |= GRN_CURSOR_LE | GRN_CURSOR_GE;
+ break;
+ default:
+ break;
+ }
+
+ bool is_multiple_column_index = KEY_N_KEY_PARTS(key_info) > 1;
+ if (is_multiple_column_index) {
+ mrn_change_encoding(ctx, NULL);
+ uint key_length =
+ mrn_calculate_key_len(table, active_index, key, keypart_map);
+ DBUG_PRINT("info",
+ ("mroonga: multiple column index: "
+ "search key length=<%u>, "
+ "multiple column index key length=<%u>",
+ key_length, key_info->key_length));
+ if (key_length == key_info->key_length) {
+ switch (find_flag) {
+ case HA_READ_BEFORE_KEY:
+ case HA_READ_PREFIX_LAST_OR_PREV:
+ key_max = key_max_entity;
+ storage_encode_multiple_column_key(key_info,
+ key, key_length,
+ key_max, &size_max);
+ break;
+ case HA_READ_PREFIX_LAST:
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key(key_info,
+ key, key_length,
+ key_min, &size_min);
+ break;
+ default:
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key(key_info,
+ key, key_length,
+ key_min, &size_min);
+ if (find_flag == HA_READ_KEY_EXACT) {
+ key_max = key_min;
+ size_max = size_min;
+ }
+ break;
+ }
+ } else {
+ const uchar *prev_key = NULL;
+ uint prev_key_length = 0;
+ if ((keypart_map >> 1) > 0) {
+ prev_key = key;
+ prev_key_length =
+ mrn_calculate_key_len(table, active_index, key, keypart_map >> 1);
+ }
+ switch (find_flag) {
+ case HA_READ_BEFORE_KEY:
+ if (prev_key) {
+ flags |= GRN_CURSOR_GE;
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ prev_key, prev_key_length,
+ NULL, 0,
+ key_min, &size_min,
+ NULL, NULL);
+ }
+ key_max = key_max_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ key, key_length,
+ NULL, 0,
+ key_max, &size_max,
+ NULL, NULL);
+ break;
+ case HA_READ_PREFIX_LAST:
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key(key_info,
+ key, key_length,
+ key_min, &size_min);
+ break;
+ case HA_READ_PREFIX_LAST_OR_PREV:
+ if (prev_key) {
+ flags |= GRN_CURSOR_GE;
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ prev_key, prev_key_length,
+ NULL, 0,
+ key_min, &size_min,
+ NULL, NULL);
+ }
+ key_max = key_max_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ NULL, 0,
+ key, key_length,
+ NULL, NULL,
+ key_max, &size_max);
+ break;
+ case HA_READ_AFTER_KEY:
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ NULL, 0,
+ key, key_length,
+ NULL, NULL,
+ key_min, &size_min);
+ if (prev_key) {
+ flags |= GRN_CURSOR_LE;
+ key_max = key_max_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ NULL, 0,
+ prev_key, prev_key_length,
+ NULL, NULL,
+ key_max, &size_max);
+ }
+ break;
+ case HA_READ_KEY_OR_NEXT:
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ key, key_length,
+ NULL, 0,
+ key_min, &size_min,
+ NULL, NULL);
+ if (prev_key) {
+ flags |= GRN_CURSOR_LE;
+ key_max = key_max_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ NULL, 0,
+ prev_key, prev_key_length,
+ NULL, NULL,
+ key_max, &size_max);
+ }
+ break;
+ case HA_READ_KEY_EXACT:
+ key_min = key_min_entity;
+ key_max = key_max_entity;
+ storage_encode_multiple_column_key_range(key_info,
+ key, key_length,
+ key, key_length,
+ key_min, &size_min,
+ key_max, &size_max);
+ default:
+ break;
+ }
+ }
+ } else if (mrn_is_geo_key(key_info)) {
+ error = mrn_change_encoding(ctx, key_info->key_part->field->charset());
+ if (error)
+ DBUG_RETURN(error);
+ error = generic_geo_open_cursor(key, find_flag);
+ if (!error) {
+ error = storage_get_next_record(buf);
+ }
+ DBUG_RETURN(error);
+ } else {
+ Field *field = key_info->key_part[0].field;
+ error = mrn_change_encoding(ctx, field->charset());
+ if (error)
+ DBUG_RETURN(error);
+
+ if (find_flag == HA_READ_KEY_EXACT) {
+ const char *column_name = field->field_name.str;
+
+ key_min = key_min_entity;
+ key_max = key_min_entity;
+ storage_encode_key(field, key, key_min, &size_min);
+ size_max = size_min;
+ // for _id
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
+ grn_id found_record_id = *((grn_id *)key_min);
+ if (grn_table_at(ctx, grn_table, found_record_id) != GRN_ID_NIL) { // found
+ storage_store_fields(buf, found_record_id);
+ table->status = 0;
+ record_id = found_record_id;
+ DBUG_RETURN(0);
+ } else {
+ table->status = STATUS_NOT_FOUND;
+ DBUG_RETURN(HA_ERR_END_OF_FILE);
+ }
+ }
+ } else if (find_flag == HA_READ_BEFORE_KEY ||
+ find_flag == HA_READ_PREFIX_LAST_OR_PREV) {
+ key_max = key_max_entity;
+ storage_encode_key(field, key, key_max_entity, &size_max);
+ } else {
+ key_min = key_min_entity;
+ storage_encode_key(field, key, key_min_entity, &size_min);
+ }
+ }
+
+ uint pkey_nr = table->s->primary_key;
+ if (key_nr == pkey_nr) {
+ DBUG_PRINT("info", ("mroonga: use primary key"));
+ cursor = grn_table_cursor_open(ctx, grn_table,
+ key_min, size_min,
+ key_max, size_max,
+ 0, -1, flags);
+ } else {
+ bool is_empty_value_records_search = false;
+ if (is_multiple_column_index) {
+ DBUG_PRINT("info", ("mroonga: use multiple column key%u", key_nr));
+ } else if (flags == 0 && size_min == 0 && size_max == 0) {
+ is_empty_value_records_search = true;
+ DBUG_PRINT("info",
+ ("mroonga: use table scan for searching empty value records"));
+ } else {
+ DBUG_PRINT("info", ("mroonga: use key%u", key_nr));
+ }
+ if (is_empty_value_records_search) {
+ grn_obj *expression, *expression_variable;
+ GRN_EXPR_CREATE_FOR_QUERY(ctx, grn_table,
+ expression, expression_variable);
+ grn_obj *target_column =
+ grn_columns[key_info->key_part->field->field_index];
+ grn_expr_append_const(ctx, expression, target_column, GRN_OP_GET_VALUE, 1);
+ grn_obj empty_value;
+ GRN_TEXT_INIT(&empty_value, 0);
+ grn_expr_append_obj(ctx, expression, &empty_value, GRN_OP_PUSH, 1);
+ grn_expr_append_op(ctx, expression, GRN_OP_EQUAL, 2);
+
+ empty_value_records =
+ grn_table_create(ctx, NULL, 0, NULL,
+ GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+ grn_table, 0);
+ grn_table_select(ctx, grn_table, expression, empty_value_records,
+ GRN_OP_OR);
+ grn_obj_unlink(ctx, expression);
+ grn_obj_unlink(ctx, &empty_value);
+
+ empty_value_records_cursor =
+ grn_table_cursor_open(ctx, empty_value_records,
+ NULL, 0, NULL, 0,
+ 0, -1, flags);
+ } else {
+ index_table_cursor = grn_table_cursor_open(ctx, grn_index_tables[key_nr],
+ key_min, size_min,
+ key_max, size_max,
+ 0, -1, flags);
+ cursor = grn_index_cursor_open(ctx, index_table_cursor,
+ grn_index_columns[key_nr],
+ 0, GRN_ID_MAX, 0);
+ }
+ }
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_READ);
+ }
+ error = storage_get_next_record(buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::index_read_map(uchar *buf, const uchar *key,
+ key_part_map keypart_map,
+ enum ha_rkey_function find_flag)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_read_map(buf, key, keypart_map, find_flag);
+ } else {
+ error = storage_index_read_map(buf, key, keypart_map, find_flag);
+ }
+ DBUG_PRINT("info", ("mroonga: error=%d", error));
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_HANDLER_HAVE_INDEX_READ_LAST_MAP
+int ha_mroonga::wrapper_index_read_last_map(uchar *buf, const uchar *key,
+ key_part_map keypart_map)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+# ifdef MRN_HANDLER_HAVE_HA_INDEX_READ_LAST_MAP
+ error = wrap_handler->ha_index_read_last_map(buf, key, keypart_map);
+# else
+ error = wrap_handler->index_read_last_map(buf, key, keypart_map);
+# endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_read_last_map(uchar *buf, const uchar *key,
+ key_part_map keypart_map)
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint key_nr = active_index;
+ KEY *key_info = &(table->key_info[key_nr]);
+
+ int flags = GRN_CURSOR_DESCENDING, error;
+ uint size_min = 0, size_max = 0;
+ uchar *key_min = NULL, *key_max = NULL;
+ uchar key_min_entity[MRN_MAX_KEY_SIZE];
+
+ clear_cursor();
+
+ bool is_multiple_column_index = KEY_N_KEY_PARTS(key_info) > 1;
+ if (is_multiple_column_index) {
+ mrn_change_encoding(ctx, NULL);
+ flags |= GRN_CURSOR_PREFIX;
+ uint key_length =
+ mrn_calculate_key_len(table, active_index, key, keypart_map);
+ key_min = key_min_entity;
+ storage_encode_multiple_column_key(key_info,
+ key, key_length,
+ key_min, &size_min);
+ } else {
+ Field *field = key_info->key_part[0].field;
+ error = mrn_change_encoding(ctx, field->charset());
+ if (error)
+ DBUG_RETURN(error);
+
+ key_min = key_min_entity;
+ key_max = key_min_entity;
+ storage_encode_key(field, key, key_min, &size_min);
+ size_max = size_min;
+ }
+
+ uint pkey_nr = table->s->primary_key;
+ if (key_nr == pkey_nr) {
+ DBUG_PRINT("info", ("mroonga: use primary key"));
+ cursor = grn_table_cursor_open(ctx, grn_table,
+ key_min, size_min, key_max, size_max,
+ 0, -1, flags);
+ } else {
+ if (is_multiple_column_index) {
+ DBUG_PRINT("info", ("mroonga: use multiple column key%u", key_nr));
+ } else {
+ DBUG_PRINT("info", ("mroonga: use key%u", key_nr));
+ }
+ index_table_cursor = grn_table_cursor_open(ctx, grn_index_tables[key_nr],
+ key_min, size_min,
+ key_max, size_max,
+ 0, -1, flags);
+ cursor = grn_index_cursor_open(ctx, index_table_cursor,
+ grn_index_columns[key_nr],
+ 0, GRN_ID_MAX, 0);
+ }
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_READ);
+ }
+ error = storage_get_next_record(buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::index_read_last_map(uchar *buf, const uchar *key,
+ key_part_map keypart_map)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_read_last_map(buf, key, keypart_map);
+ } else {
+ error = storage_index_read_last_map(buf, key, keypart_map);
+ }
+ DBUG_RETURN(error);
+}
+#endif
+
+int ha_mroonga::wrapper_index_next(uchar *buf)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ KEY *key_info = &(table->key_info[active_index]);
+ if (mrn_is_geo_key(key_info)) {
+ error = wrapper_get_next_geo_record(buf);
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+#ifdef MRN_HANDLER_HAVE_HA_INDEX_NEXT
+ error = wrap_handler->ha_index_next(buf);
+#else
+ error = wrap_handler->index_next(buf);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_next(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = storage_get_next_record(buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::index_next(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_next(buf);
+ } else {
+ error = storage_index_next(buf);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_index_prev(uchar *buf)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ KEY *key_info = &(table->key_info[active_index]);
+ if (mrn_is_geo_key(key_info)) {
+ error = wrapper_get_next_geo_record(buf);
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+#ifdef MRN_HANDLER_HAVE_HA_INDEX_NEXT
+ error = wrap_handler->ha_index_prev(buf);
+#else
+ error = wrap_handler->index_prev(buf);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_prev(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = storage_get_next_record(buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::index_prev(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_prev(buf);
+ } else {
+ error = storage_index_prev(buf);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_index_first(uchar *buf)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+#ifdef MRN_HANDLER_HAVE_HA_INDEX_FIRST
+ error = wrap_handler->ha_index_first(buf);
+#else
+ error = wrap_handler->index_first(buf);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_first(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ clear_cursor();
+ int flags = GRN_CURSOR_ASCENDING;
+ uint pkey_nr = table->s->primary_key;
+ mrn_change_encoding(ctx, NULL);
+ if (active_index == pkey_nr) {
+ DBUG_PRINT("info", ("mroonga: use primary key"));
+ cursor = grn_table_cursor_open(ctx, grn_table, NULL, 0, NULL, 0,
+ 0, -1, flags);
+ } else {
+ if (KEY_N_KEY_PARTS(&(table->key_info[active_index])) > 1) {
+ DBUG_PRINT("info", ("mroonga: use multiple column key%u", active_index));
+ } else {
+ DBUG_PRINT("info", ("mroonga: use key%u", active_index));
+ }
+ index_table_cursor = grn_table_cursor_open(ctx,
+ grn_index_tables[active_index],
+ NULL, 0,
+ NULL, 0,
+ 0, -1, flags);
+ cursor = grn_index_cursor_open(ctx, index_table_cursor,
+ grn_index_columns[active_index],
+ 0, GRN_ID_MAX, 0);
+ }
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_READ);
+ }
+ int error = storage_get_next_record(buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::index_first(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_first(buf);
+ } else {
+ error = storage_index_first(buf);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_index_last(uchar *buf)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+#ifdef MRN_HANDLER_HAVE_HA_INDEX_LAST
+ error = wrap_handler->ha_index_last(buf);
+#else
+ error = wrap_handler->index_last(buf);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_last(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ clear_cursor();
+ int flags = GRN_CURSOR_DESCENDING;
+ uint pkey_nr = table->s->primary_key;
+ mrn_change_encoding(ctx, NULL);
+ if (active_index == pkey_nr) {
+ DBUG_PRINT("info", ("mroonga: use primary key"));
+ cursor = grn_table_cursor_open(ctx, grn_table, NULL, 0, NULL, 0,
+ 0, -1, flags);
+ } else {
+ if (KEY_N_KEY_PARTS(&(table->key_info[active_index])) > 1) {
+ DBUG_PRINT("info", ("mroonga: use multiple column key%u", active_index));
+ } else {
+ DBUG_PRINT("info", ("mroonga: use key%u", active_index));
+ }
+ index_table_cursor = grn_table_cursor_open(ctx,
+ grn_index_tables[active_index],
+ NULL, 0,
+ NULL, 0,
+ 0, -1, flags);
+ cursor = grn_index_cursor_open(ctx, index_table_cursor,
+ grn_index_columns[active_index],
+ 0, GRN_ID_MAX, 0);
+ }
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_READ);
+ }
+ int error = storage_get_next_record(buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::index_last(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_last(buf);
+ } else {
+ error = storage_index_last(buf);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_index_next_same(uchar *buf, const uchar *key,
+ uint keylen)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ KEY *key_info = &(table->s->key_info[active_index]);
+ if (mrn_is_geo_key(key_info)) {
+ error = wrapper_get_next_geo_record(buf);
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+#ifdef MRN_HANDLER_HAVE_HA_INDEX_NEXT_SAME
+ error = wrap_handler->ha_index_next_same(buf, key, keylen);
+#else
+ error = wrap_handler->index_next_same(buf, key, keylen);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_index_next_same(uchar *buf, const uchar *key,
+ uint keylen)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = storage_get_next_record(count_skip ? NULL : buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::index_next_same(uchar *buf, const uchar *key, uint keylen)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_index_next_same(buf, key, keylen);
+ } else {
+ error = storage_index_next_same(buf, key, keylen);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_ft_init()
+{
+ MRN_DBUG_ENTER_METHOD();
+ struct st_mrn_ft_info *mrn_ft_info =
+ reinterpret_cast<struct st_mrn_ft_info *>(ft_handler);
+ GRN_CTX_SET_ENCODING(ctx, mrn_ft_info->encoding);
+
+ int error = 0;
+ if (sorted_result) {
+ mrn_ft_info->cursor = grn_table_cursor_open(ctx, sorted_result,
+ NULL, 0, NULL, 0,
+ 0, -1, 0);
+ } else {
+ mrn_ft_info->cursor = grn_table_cursor_open(ctx, mrn_ft_info->result,
+ NULL, 0, NULL, 0,
+ 0, -1, 0);
+ }
+ if (ctx->rc) {
+ error = ER_ERROR_ON_READ;
+ my_message(error, ctx->errbuf, MYF(0));
+ } else {
+ if (sorted_result) {
+ if (grn_table->header.type == GRN_TABLE_NO_KEY) {
+ mrn_ft_info->id_accessor = grn_obj_column(ctx, sorted_result,
+ MRN_COLUMN_NAME_ID,
+ strlen(MRN_COLUMN_NAME_ID));
+ } else {
+ mrn_ft_info->key_accessor = grn_obj_column(ctx, sorted_result,
+ MRN_COLUMN_NAME_KEY,
+ strlen(MRN_COLUMN_NAME_KEY));
+ }
+ } else {
+ mrn_ft_info->key_accessor = grn_obj_column(ctx, mrn_ft_info->result,
+ MRN_COLUMN_NAME_KEY,
+ strlen(MRN_COLUMN_NAME_KEY));
+ }
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_ft_init()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = generic_ft_init();
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_ft_init()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = generic_ft_init();
+ record_id = GRN_ID_NIL;
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::ft_init()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_ft_init();
+ } else {
+ error = storage_ft_init();
+ }
+ DBUG_RETURN(error);
+}
+
+void ha_mroonga::generic_ft_init_ext_add_conditions_fast_order_limit(
+ struct st_mrn_ft_info *info, grn_obj *expression)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ Item *where =
+ MRN_SELECT_LEX_GET_WHERE_COND(table->pos_in_table_list->select_lex);
+
+ bool is_storage_mode = !(share->wrapper_mode);
+ mrn::ConditionConverter converter(info->ctx, grn_table, is_storage_mode);
+ converter.convert(where, expression);
+
+ DBUG_VOID_RETURN;
+}
+
+grn_rc ha_mroonga::generic_ft_init_ext_prepare_expression_in_boolean_mode(
+ struct st_mrn_ft_info *info,
+ String *key,
+ grn_obj *index_column,
+ grn_obj *match_columns,
+ grn_obj *expression)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ mrn::QueryParser query_parser(info->ctx,
+ ha_thd(),
+ expression,
+ index_column,
+ KEY_N_KEY_PARTS(info->key_info),
+ match_columns);
+ grn_rc rc = query_parser.parse(key->ptr(), key->length());
+
+ DBUG_RETURN(rc);
+}
+
+grn_rc ha_mroonga::generic_ft_init_ext_prepare_expression_in_normal_mode(
+ struct st_mrn_ft_info *info,
+ String *key,
+ grn_obj *index_column,
+ grn_obj *match_columns,
+ grn_obj *expression)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ grn_rc rc = GRN_SUCCESS;
+
+ grn_obj query;
+ GRN_TEXT_INIT(&query, GRN_OBJ_DO_SHALLOW_COPY);
+ GRN_TEXT_SET(info->ctx, &query, key->ptr(), key->length());
+ grn_expr_append_obj(info->ctx, match_columns, index_column, GRN_OP_PUSH, 1);
+ grn_expr_append_obj(info->ctx, expression, match_columns, GRN_OP_PUSH, 1);
+ grn_expr_append_const(info->ctx, expression, &query, GRN_OP_PUSH, 1);
+ grn_expr_append_op(info->ctx, expression, GRN_OP_SIMILAR, 2);
+ grn_obj_unlink(info->ctx, &query);
+
+ DBUG_RETURN(rc);
+}
+
+struct st_mrn_ft_info *ha_mroonga::generic_ft_init_ext_select(uint flags,
+ uint key_nr,
+ String *key)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ struct st_mrn_ft_info *info = new st_mrn_ft_info();
+ info->mroonga = this;
+ info->ctx = ctx;
+ mrn_change_encoding(info->ctx,
+ table->key_info[key_nr].key_part->field->charset());
+ info->encoding = GRN_CTX_GET_ENCODING(info->ctx);
+ info->table = grn_table;
+ info->result = grn_table_create(info->ctx, NULL, 0, NULL,
+ GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+ grn_table, 0);
+ if (!info->result) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "[mroonga][ft-init] failed to create a table "
+ "to store matched records for one search: <%s>",
+ ctx->errbuf);
+ my_message(ER_ERROR_ON_READ, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ delete info;
+ DBUG_RETURN(NULL);
+ }
+
+ info->score_column = grn_obj_column(info->ctx, info->result,
+ MRN_COLUMN_NAME_SCORE,
+ strlen(MRN_COLUMN_NAME_SCORE));
+ GRN_TEXT_INIT(&(info->key), 0);
+ grn_bulk_space(info->ctx, &(info->key), table->key_info->key_length);
+ GRN_INT32_INIT(&(info->score), 0);
+ info->active_index = key_nr;
+ info->key_info = &(table->key_info[key_nr]);
+ info->primary_key_info = &(table->key_info[table_share->primary_key]);
+ info->cursor = NULL;
+ info->id_accessor = NULL;
+ info->key_accessor = NULL;
+
+ if (key->length() == 0) {
+ DBUG_RETURN(info);
+ }
+
+ grn_obj *index_column = grn_index_columns[key_nr];
+ grn_obj *match_columns, *match_columns_variable;
+ GRN_EXPR_CREATE_FOR_QUERY(info->ctx, info->table, match_columns,
+ match_columns_variable);
+
+ grn_obj *expression, *expression_variable;
+ GRN_EXPR_CREATE_FOR_QUERY(info->ctx, info->table,
+ expression, expression_variable);
+
+ grn_rc rc = GRN_SUCCESS;
+ if (flags & FT_BOOL) {
+ rc = generic_ft_init_ext_prepare_expression_in_boolean_mode(info,
+ key,
+ index_column,
+ match_columns,
+ expression);
+ } else {
+ rc = generic_ft_init_ext_prepare_expression_in_normal_mode(info,
+ key,
+ index_column,
+ match_columns,
+ expression);
+ }
+
+ if (rc == GRN_SUCCESS) {
+ if (fast_order_limit) {
+ generic_ft_init_ext_add_conditions_fast_order_limit(info, expression);
+ }
+ longlong escalation_threshold = THDVAR(ha_thd(), match_escalation_threshold);
+ mrn::MatchEscalationThresholdScope scope(info->ctx, escalation_threshold);
+ grn_table_select(info->ctx, info->table, expression,
+ info->result, GRN_OP_OR);
+ }
+
+ grn_obj_unlink(info->ctx, expression);
+ grn_obj_unlink(info->ctx, match_columns);
+
+ DBUG_RETURN(info);
+}
+
+FT_INFO *ha_mroonga::generic_ft_init_ext(uint flags, uint key_nr, String *key)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ check_count_skip(0);
+
+ mrn_change_encoding(ctx, system_charset_info);
+ grn_operator operation = GRN_OP_OR;
+ if (!matched_record_keys) {
+ matched_record_keys = grn_table_create(ctx, NULL, 0, NULL,
+ GRN_OBJ_TABLE_HASH_KEY | GRN_OBJ_WITH_SUBREC,
+ grn_table, 0);
+ if (!matched_record_keys) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "[mroonga][ft-init] "
+ "failed to create a table to store all matched records: <%s>",
+ ctx->errbuf);
+ my_message(ER_ERROR_ON_READ, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ DBUG_RETURN(NULL);
+ }
+ }
+
+ grn_table_sort_key *sort_keys = NULL;
+ int n_sort_keys = 0;
+ longlong limit = -1;
+ check_fast_order_limit(&sort_keys, &n_sort_keys, &limit);
+
+ struct st_mrn_ft_info *info = generic_ft_init_ext_select(flags, key_nr, key);
+ if (!info) {
+ DBUG_RETURN(NULL);
+ }
+
+ grn_rc rc;
+ rc = grn_table_setoperation(ctx, matched_record_keys, info->result,
+ matched_record_keys, operation);
+ if (rc) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to merge matched record keys: <%s>",
+ ctx->errbuf);
+ my_message(ER_ERROR_ON_READ, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ }
+ if (fast_order_limit) {
+ if (sorted_result) {
+ grn_obj_close(ctx, sorted_result);
+ }
+ sorted_result = grn_table_create(ctx, NULL,
+ 0, NULL,
+ GRN_OBJ_TABLE_NO_KEY, NULL,
+ matched_record_keys);
+ grn_table_sort(ctx, matched_record_keys, 0, static_cast<int>(limit),
+ sorted_result, sort_keys, n_sort_keys);
+ } else if (flags & FT_SORTED) {
+ grn_table_sort_key score_sort_key;
+ score_sort_key.key = grn_obj_column(ctx,
+ matched_record_keys,
+ MRN_COLUMN_NAME_SCORE,
+ strlen(MRN_COLUMN_NAME_SCORE));
+ score_sort_key.offset = 0;
+ score_sort_key.flags = GRN_TABLE_SORT_DESC;
+ if (sorted_result) {
+ grn_obj_unlink(ctx, sorted_result);
+ }
+ sorted_result = grn_table_create(ctx, NULL,
+ 0, NULL,
+ GRN_OBJ_TABLE_NO_KEY, NULL,
+ matched_record_keys);
+ grn_table_sort(ctx, matched_record_keys, 0, -1,
+ sorted_result, &score_sort_key, 1);
+ grn_obj_unlink(ctx, score_sort_key.key);
+ }
+ if (sort_keys) {
+ for (int i = 0; i < n_sort_keys; i++) {
+ grn_obj_unlink(info->ctx, sort_keys[i].key);
+ }
+ my_free(sort_keys);
+ }
+
+ DBUG_RETURN((FT_INFO *)info);
+}
+
+FT_INFO *ha_mroonga::wrapper_ft_init_ext(uint flags, uint key_nr, String *key)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ FT_INFO *info = generic_ft_init_ext(flags, key_nr, key);
+ if (!info) {
+ DBUG_RETURN(NULL);
+ }
+
+ struct st_mrn_ft_info *mrn_ft_info = (struct st_mrn_ft_info *)info;
+ mrn_ft_info->please = &mrn_wrapper_ft_vft;
+#ifdef HA_CAN_FULLTEXT_EXT
+ mrn_ft_info->could_you = &mrn_wrapper_ft_vft_ext;
+#endif
+ ++wrap_ft_init_count;
+
+ DBUG_RETURN(info);
+}
+
+FT_INFO *ha_mroonga::storage_ft_init_ext(uint flags, uint key_nr, String *key)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ FT_INFO *info = generic_ft_init_ext(flags, key_nr, key);
+ if (!info) {
+ DBUG_RETURN(NULL);
+ }
+
+ struct st_mrn_ft_info *mrn_ft_info = (struct st_mrn_ft_info *)info;
+ mrn_ft_info->please = &mrn_storage_ft_vft;
+#ifdef HA_CAN_FULLTEXT_EXT
+ mrn_ft_info->could_you = &mrn_storage_ft_vft_ext;
+#endif
+ DBUG_RETURN(info);
+}
+
+FT_INFO *ha_mroonga::ft_init_ext(uint flags, uint key_nr, String *key)
+{
+ MRN_DBUG_ENTER_METHOD();
+ fulltext_searching = true;
+ FT_INFO *info;
+ if (key_nr == NO_SUCH_KEY) {
+ struct st_mrn_ft_info *mrn_ft_info = new st_mrn_ft_info();
+ mrn_ft_info->please = &mrn_no_such_key_ft_vft;
+#ifdef HA_CAN_FULLTEXT_EXT
+ mrn_ft_info->could_you = &mrn_no_such_key_ft_vft_ext;
+#endif
+ info = (FT_INFO *)mrn_ft_info;
+ } else {
+ if (share->wrapper_mode)
+ {
+ info = wrapper_ft_init_ext(flags, key_nr, key);
+ } else {
+ info = storage_ft_init_ext(flags, key_nr, key);
+ }
+ }
+ DBUG_RETURN(info);
+}
+
+int ha_mroonga::wrapper_ft_read(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (wrap_ft_init_count)
+ set_pk_bitmap();
+
+ struct st_mrn_ft_info *mrn_ft_info =
+ reinterpret_cast<struct st_mrn_ft_info *>(ft_handler);
+ GRN_CTX_SET_ENCODING(ctx, mrn_ft_info->encoding);
+
+ int error = 0;
+ do {
+ grn_id found_record_id;
+ found_record_id = grn_table_cursor_next(ctx, mrn_ft_info->cursor);
+ if (found_record_id == GRN_ID_NIL) {
+ error = HA_ERR_END_OF_FILE;
+ break;
+ }
+
+ GRN_BULK_REWIND(&key_buffer);
+ if (mrn_ft_info->key_accessor) {
+ grn_obj_get_value(ctx, mrn_ft_info->key_accessor,
+ found_record_id, &key_buffer);
+ } else {
+ void *key;
+ int key_length;
+ key_length = grn_table_cursor_get_key(ctx, mrn_ft_info->cursor, &key);
+ GRN_TEXT_SET(ctx, &key_buffer, key, key_length);
+ }
+ error = wrapper_get_record(buf, (const uchar *)GRN_TEXT_VALUE(&key_buffer));
+ } while (error == HA_ERR_END_OF_FILE || error == HA_ERR_KEY_NOT_FOUND);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_ft_read(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ struct st_mrn_ft_info *mrn_ft_info =
+ reinterpret_cast<struct st_mrn_ft_info *>(ft_handler);
+ GRN_CTX_SET_ENCODING(ctx, mrn_ft_info->encoding);
+
+ grn_id found_record_id;
+ found_record_id = grn_table_cursor_next(ctx, mrn_ft_info->cursor);
+ if (ctx->rc) {
+ my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_READ);
+ }
+
+ if (found_record_id == GRN_ID_NIL) {
+ table->status = STATUS_NOT_FOUND;
+ DBUG_RETURN(HA_ERR_END_OF_FILE);
+ }
+ table->status = 0;
+
+ if (count_skip && record_id != GRN_ID_NIL) {
+ DBUG_RETURN(0);
+ }
+
+ GRN_BULK_REWIND(&key_buffer);
+ if (mrn_ft_info->id_accessor) {
+ grn_obj id_buffer;
+ GRN_RECORD_INIT(&id_buffer, 0, grn_obj_id(ctx, grn_table));
+ grn_obj_get_value(ctx, mrn_ft_info->id_accessor,
+ found_record_id, &id_buffer);
+ record_id = GRN_RECORD_VALUE(&id_buffer);
+ } else if (mrn_ft_info->key_accessor) {
+ grn_obj_get_value(ctx, mrn_ft_info->key_accessor,
+ found_record_id, &key_buffer);
+ record_id = grn_table_get(ctx, grn_table,
+ GRN_TEXT_VALUE(&key_buffer),
+ GRN_TEXT_LEN(&key_buffer));
+ } else {
+ void *key;
+ grn_table_cursor_get_key(ctx, mrn_ft_info->cursor, &key);
+ if (ctx->rc) {
+ record_id = GRN_ID_NIL;
+ my_message(ER_ERROR_ON_READ, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_READ);
+ } else {
+ record_id = *((grn_id *)key);
+ }
+ }
+ storage_store_fields(buf, record_id);
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::ft_read(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_ft_read(buf);
+ } else {
+ error = storage_ft_read(buf);
+ }
+ DBUG_RETURN(error);
+}
+
+const Item *ha_mroonga::wrapper_cond_push(const Item *cond)
+{
+ const Item *reminder_cond;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ reminder_cond = wrap_handler->cond_push(cond);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(reminder_cond);
+}
+
+const Item *ha_mroonga::storage_cond_push(const Item *cond)
+{
+ MRN_DBUG_ENTER_METHOD();
+ const Item *reminder_cond = cond;
+ if (!pushed_cond) {
+ mrn::ConditionConverter converter(ctx, grn_table, true);
+ if (converter.count_match_against(cond) == 1 &&
+ converter.is_convertable(cond)) {
+ reminder_cond = NULL;
+ }
+ }
+ DBUG_RETURN(reminder_cond);
+}
+
+const Item *ha_mroonga::cond_push(const Item *cond)
+{
+ MRN_DBUG_ENTER_METHOD();
+ const Item *reminder_cond;
+ if (share->wrapper_mode)
+ {
+ reminder_cond = wrapper_cond_push(cond);
+ } else {
+ reminder_cond = storage_cond_push(cond);
+ }
+ DBUG_RETURN(reminder_cond);
+}
+
+void ha_mroonga::wrapper_cond_pop()
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->cond_pop();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_cond_pop()
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::cond_pop()
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ wrapper_cond_pop();
+ else
+ storage_cond_pop();
+ DBUG_VOID_RETURN;
+}
+
+bool ha_mroonga::wrapper_get_error_message(int error, String *buf)
+{
+ bool temporary_error;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ temporary_error = wrap_handler->get_error_message(error, buf);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(temporary_error);
+}
+
+bool ha_mroonga::storage_get_error_message(int error, String *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool temporary_error = false;
+ // latest error message
+ buf->copy(ctx->errbuf, (uint) strlen(ctx->errbuf), system_charset_info);
+ DBUG_RETURN(temporary_error);
+}
+
+bool ha_mroonga::get_error_message(int error, String *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool temporary_error;
+ if (share && share->wrapper_mode)
+ {
+ temporary_error = wrapper_get_error_message(error, buf);
+ } else {
+ temporary_error = storage_get_error_message(error, buf);
+ }
+ DBUG_RETURN(temporary_error);
+}
+
+ulonglong ha_mroonga::file_size(const char *path)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ struct stat file_status;
+ if (stat(path, &file_status) == 0) {
+ DBUG_RETURN(file_status.st_size);
+ } else {
+ DBUG_RETURN(0);
+ }
+}
+
+bool ha_mroonga::have_unique_index()
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ uint n_keys = table->s->keys;
+
+ for (uint i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &(table->key_info[i]);
+ if (key_info->flags & HA_NOSAME) {
+ DBUG_RETURN(true);
+ }
+ }
+
+ DBUG_RETURN(false);
+}
+
+bool ha_mroonga::is_foreign_key_field(const char *table_name,
+ const char *field_name)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ grn_obj *table = grn_ctx_get(ctx, table_name, -1);
+ if (!table) {
+ DBUG_RETURN(false);
+ }
+
+ mrn::ColumnName column_name(field_name);
+ grn_obj *column = grn_obj_column(ctx,
+ table,
+ column_name.c_str(),
+ column_name.length());
+ if (!column) {
+ DBUG_RETURN(false);
+ }
+
+ grn_obj *range = grn_ctx_at(ctx, grn_obj_get_range(ctx, column));
+ if (!range) {
+ grn_obj_unlink(ctx, column);
+ DBUG_RETURN(false);
+ }
+
+ if (!mrn::grn::is_table(range)) {
+ grn_obj_unlink(ctx, column);
+ DBUG_RETURN(false);
+ }
+
+ grn_obj *foreign_index_column;
+ mrn::IndexColumnName index_column_name(table_name, field_name);
+ foreign_index_column = grn_obj_column(ctx, range,
+ index_column_name.c_str(),
+ index_column_name.length());
+ if (foreign_index_column) {
+ grn_obj_unlink(ctx, foreign_index_column);
+ DBUG_RETURN(true);
+ }
+
+ grn_obj_unlink(ctx, column);
+ DBUG_RETURN(false);
+}
+
+void ha_mroonga::push_warning_unsupported_spatial_index_search(enum ha_rkey_function flag)
+{
+ char search_name[MRN_BUFFER_SIZE];
+ if (flag == HA_READ_MBR_INTERSECT) {
+ strcpy(search_name, "intersect");
+ } else if (flag == HA_READ_MBR_WITHIN) {
+ strcpy(search_name, "within");
+ } else if (flag & HA_READ_MBR_DISJOINT) {
+ strcpy(search_name, "disjoint");
+ } else if (flag & HA_READ_MBR_EQUAL) {
+ strcpy(search_name, "equal");
+ } else {
+ sprintf(search_name, "unknown: %d", flag);
+ }
+ push_warning_printf(ha_thd(),
+ MRN_SEVERITY_WARNING,
+ ER_UNSUPPORTED_EXTENSION,
+ "spatial index search "
+ "except MBRContains aren't supported: <%s>",
+ search_name);
+}
+
+void ha_mroonga::clear_cursor()
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (cursor) {
+ grn_obj_unlink(ctx, cursor);
+ cursor = NULL;
+ }
+ if (index_table_cursor) {
+ grn_table_cursor_close(ctx, index_table_cursor);
+ index_table_cursor = NULL;
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::clear_cursor_geo()
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (cursor_geo) {
+ grn_obj_unlink(ctx, cursor_geo);
+ cursor_geo = NULL;
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::clear_empty_value_records()
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (empty_value_records_cursor) {
+ grn_table_cursor_close(ctx, empty_value_records_cursor);
+ empty_value_records_cursor = NULL;
+ }
+ if (empty_value_records) {
+ grn_obj_unlink(ctx, empty_value_records);
+ empty_value_records = NULL;
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::clear_search_result()
+{
+ MRN_DBUG_ENTER_METHOD();
+ clear_cursor();
+ if (sorted_result) {
+ grn_obj_unlink(ctx, sorted_result);
+ sorted_result = NULL;
+ }
+ if (matched_record_keys) {
+ grn_obj_unlink(ctx, matched_record_keys);
+ matched_record_keys = NULL;
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::clear_search_result_geo()
+{
+ MRN_DBUG_ENTER_METHOD();
+ clear_cursor_geo();
+ if (grn_source_column_geo) {
+ grn_obj_unlink(ctx, grn_source_column_geo);
+ grn_source_column_geo = NULL;
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::clear_indexes()
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint n_keys = table->s->keys;
+ uint pkey_nr = table->s->primary_key;
+
+ for (uint i = 0; i < n_keys; i++) {
+ if (i != pkey_nr) {
+ if (grn_index_tables) {
+ grn_obj_unlink(ctx, grn_index_tables[i]);
+ }
+ if (grn_index_columns) {
+ grn_obj_unlink(ctx, grn_index_columns[i]);
+ }
+ }
+ }
+
+ if (grn_index_tables) {
+ free(grn_index_tables);
+ grn_index_tables = NULL;
+ }
+
+ if (grn_index_columns) {
+ free(grn_index_columns);
+ grn_index_columns = NULL;
+ }
+
+ if (key_id) {
+ free(key_id);
+ key_id = NULL;
+ }
+
+ if (del_key_id) {
+ free(del_key_id);
+ del_key_id = NULL;
+ }
+
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::add_wrap_hton(const char *path, handlerton *wrap_handlerton)
+{
+ MRN_DBUG_ENTER_METHOD();
+ st_mrn_slot_data *slot_data = mrn_get_slot_data(ha_thd(), true);
+ if (!slot_data)
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ st_mrn_wrap_hton *wrap_hton =
+ (st_mrn_wrap_hton *)malloc(sizeof(st_mrn_wrap_hton));
+ if (!wrap_hton)
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ wrap_hton->next = NULL;
+ strcpy(wrap_hton->path, path);
+ wrap_hton->hton = wrap_handlerton;
+ if (slot_data->first_wrap_hton)
+ {
+ st_mrn_wrap_hton *tmp_wrap_hton = slot_data->first_wrap_hton;
+ while (tmp_wrap_hton->next)
+ tmp_wrap_hton = tmp_wrap_hton->next;
+ tmp_wrap_hton->next = wrap_hton;
+ } else {
+ slot_data->first_wrap_hton = wrap_hton;
+ }
+ DBUG_RETURN(0);
+}
+
+void ha_mroonga::remove_related_files(const char *base_path)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ const char *base_directory_name = ".";
+ size_t base_path_length = strlen(base_path);
+#ifdef WIN32
+ WIN32_FIND_DATA data;
+ HANDLE finder = FindFirstFile(base_directory_name, &data);
+ if (finder != INVALID_HANDLE_VALUE) {
+ do {
+ if (!(data.dwFileAttributes & FILE_ATTRIBUTE_NORMAL)) {
+ continue;
+ }
+ if (strncmp(data.cFileName, base_path, base_path_length) == 0) {
+ unlink(data.cFileName);
+ }
+ } while (FindNextFile(finder, &data) != 0);
+ FindClose(finder);
+ }
+#else
+ DIR *dir = opendir(base_directory_name);
+ if (dir) {
+ while (struct dirent *entry = readdir(dir)) {
+ struct stat file_status;
+ if (stat(entry->d_name, &file_status) != 0) {
+ continue;
+ }
+ if (!((file_status.st_mode & S_IFMT) == S_IFREG)) {
+ continue;
+ }
+ if (strncmp(entry->d_name, base_path, base_path_length) == 0) {
+ unlink(entry->d_name);
+ }
+ }
+ closedir(dir);
+ }
+#endif
+
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::remove_grn_obj_force(const char *name)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ grn_obj *obj = grn_ctx_get(ctx, name, strlen(name));
+ if (obj) {
+ grn_obj_remove(ctx, obj);
+ } else {
+ grn_obj *db = grn_ctx_db(ctx);
+ grn_id id = grn_table_get(ctx, db, name, strlen(name));
+ if (id) {
+ char path[MRN_MAX_PATH_SIZE];
+ grn_obj_delete_by_id(ctx, db, id, GRN_TRUE);
+ if (grn_obj_path_by_id(ctx, db, id, path) == GRN_SUCCESS) {
+ remove_related_files(path);
+ }
+ }
+ }
+
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::drop_index(MRN_SHARE *target_share, uint key_index)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ grn_rc rc = GRN_SUCCESS;
+ char target_name[GRN_TABLE_MAX_KEY_SIZE];
+ int target_name_length;
+
+ KEY *key_info = target_share->table_share->key_info;
+ if (!target_share->wrapper_mode && target_share->index_table[key_index]) {
+ const char *table_name = target_share->index_table[key_index];
+ snprintf(target_name, GRN_TABLE_MAX_KEY_SIZE,
+ "%s.%s", table_name, key_info[key_index].name.str);
+ target_name_length = strlen(target_name);
+ grn_obj *index_column = grn_ctx_get(ctx, target_name, target_name_length);
+ if (index_column) {
+ rc = grn_obj_remove(ctx, index_column);
+ }
+ } else {
+ mrn::PathMapper mapper(target_share->table_name);
+ mrn::IndexTableName index_table_name(mapper.table_name(),
+ key_info[key_index].name.str);
+ grn_obj *index_table = grn_ctx_get(ctx,
+ index_table_name.c_str(),
+ index_table_name.length());
+ if (!index_table) {
+ index_table = grn_ctx_get(ctx,
+ index_table_name.old_c_str(),
+ index_table_name.old_length());
+ }
+ if (index_table) {
+ target_name_length = grn_obj_name(ctx, index_table,
+ target_name, GRN_TABLE_MAX_KEY_SIZE);
+ rc = grn_obj_remove(ctx, index_table);
+ } else {
+ target_name_length = 0;
+ }
+ }
+
+ if (rc != GRN_SUCCESS) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to drop index: <%.*s>: <%s>",
+ target_name_length, target_name,
+ ctx->errbuf);
+ my_message(ER_ERROR_ON_WRITE, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::drop_indexes_normal(const char *table_name, grn_obj *table)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ grn_hash *columns_raw = grn_hash_create(ctx, NULL, sizeof(grn_id), 0,
+ GRN_OBJ_TABLE_HASH_KEY);
+ mrn::SmartGrnObj columns(ctx, reinterpret_cast<grn_obj *>(columns_raw));
+ if (!columns.get()) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to allocate columns buffer: <%s>: <%s>",
+ table_name, ctx->errbuf);
+ error = HA_ERR_OUT_OF_MEM;
+ my_message(ER_ERROR_ON_WRITE, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ DBUG_RETURN(error);
+ }
+
+ grn_table_columns(ctx, table, "", 0, columns.get());
+ grn_table_cursor *cursor = grn_table_cursor_open(ctx,
+ columns.get(),
+ NULL, 0,
+ NULL, 0,
+ 0, -1,
+ 0);
+ if (!cursor) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to allocate columns cursor: <%s>: <%s>",
+ table_name, ctx->errbuf);
+ error = HA_ERR_OUT_OF_MEM;
+ my_message(ER_ERROR_ON_WRITE, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ DBUG_RETURN(error);
+ }
+
+ while (grn_table_cursor_next(ctx, cursor) != GRN_ID_NIL) {
+ void *key;
+ grn_table_cursor_get_key(ctx, cursor, &key);
+ grn_id *id = reinterpret_cast<grn_id *>(key);
+ mrn::SmartGrnObj column(ctx, grn_ctx_at(ctx, *id));
+ if (!column.get()) {
+ continue;
+ }
+
+ grn_operator index_operators[] = {
+ GRN_OP_EQUAL,
+ GRN_OP_MATCH,
+ GRN_OP_LESS,
+ GRN_OP_REGEXP
+ };
+ size_t n_index_operators = sizeof(index_operators) / sizeof(grn_operator);
+ for (size_t i = 0; i < n_index_operators; i++) {
+ grn_index_datum index_datum;
+ while (grn_column_find_index_data(ctx,
+ column.get(),
+ index_operators[i],
+ &index_datum,
+ 1) > 0) {
+ grn_id index_table_id = index_datum.index->header.domain;
+ mrn::SmartGrnObj index_table(ctx, grn_ctx_at(ctx, index_table_id));
+ char index_table_name[GRN_TABLE_MAX_KEY_SIZE];
+ int index_table_name_length;
+ index_table_name_length = grn_obj_name(ctx, index_table.get(),
+ index_table_name,
+ GRN_TABLE_MAX_KEY_SIZE);
+ if (mrn::IndexTableName::is_custom_name(table_name,
+ strlen(table_name),
+ index_table_name,
+ index_table_name_length)) {
+ char index_column_name[GRN_TABLE_MAX_KEY_SIZE];
+ int index_column_name_length;
+ index_column_name_length = grn_obj_name(ctx,
+ index_datum.index,
+ index_column_name,
+ GRN_TABLE_MAX_KEY_SIZE);
+ grn_rc rc = grn_obj_remove(ctx, index_datum.index);
+ if (rc != GRN_SUCCESS) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to drop index column: <%.*s>: <%s>",
+ index_column_name_length, index_column_name,
+ ctx->errbuf);
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ }
+ } else {
+ grn_rc rc = grn_obj_remove(ctx, index_table.get());
+ if (rc == GRN_SUCCESS) {
+ index_table.release();
+ } else {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to drop index table: <%.*s>: <%s>",
+ index_table_name_length, index_table_name,
+ ctx->errbuf);
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ }
+ }
+
+ if (error != 0) {
+ break;
+ }
+ }
+
+ if (error != 0) {
+ break;
+ }
+ }
+
+ if (error != 0) {
+ break;
+ }
+ }
+
+ grn_table_cursor_close(ctx, cursor);
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::drop_indexes_multiple(const char *table_name,
+ grn_obj *table,
+ const char *index_table_name_separator)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ char index_table_name_prefix[GRN_TABLE_MAX_KEY_SIZE];
+ snprintf(index_table_name_prefix, GRN_TABLE_MAX_KEY_SIZE,
+ "%s%s", table_name, index_table_name_separator);
+ grn_table_cursor *cursor =
+ grn_table_cursor_open(ctx,
+ grn_ctx_db(ctx),
+ index_table_name_prefix,
+ strlen(index_table_name_prefix),
+ NULL, 0,
+ 0, -1,
+ GRN_CURSOR_PREFIX);
+ if (!cursor) {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to allocate index tables cursor: <%s>: <%s>",
+ table_name, ctx->errbuf);
+ error = HA_ERR_OUT_OF_MEM;
+ my_message(ER_ERROR_ON_WRITE, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ DBUG_RETURN(error);
+ }
+
+ grn_id table_id = grn_obj_id(ctx, table);
+ grn_id id;
+ while ((id = grn_table_cursor_next(ctx, cursor)) != GRN_ID_NIL) {
+ mrn::SmartGrnObj object(ctx, grn_ctx_at(ctx, id));
+ if (!object.get()) {
+ continue;
+ }
+ if (!grn_obj_is_table(ctx, object.get())) {
+ continue;
+ }
+
+ char multiple_column_index_table_name[GRN_TABLE_MAX_KEY_SIZE];
+ int multiple_column_index_table_name_length;
+ multiple_column_index_table_name_length =
+ grn_obj_name(ctx,
+ object.get(),
+ multiple_column_index_table_name,
+ GRN_TABLE_MAX_KEY_SIZE);
+
+ char multiple_column_index_name[GRN_TABLE_MAX_KEY_SIZE];
+ snprintf(multiple_column_index_name, GRN_TABLE_MAX_KEY_SIZE,
+ "%.*s.%s",
+ multiple_column_index_table_name_length,
+ multiple_column_index_table_name,
+ INDEX_COLUMN_NAME);
+ mrn::SmartGrnObj index_column(ctx, multiple_column_index_name);
+ if (!index_column.get()) {
+ continue;
+ }
+
+ if (grn_obj_get_range(ctx, index_column.get()) != table_id) {
+ continue;
+ }
+
+ grn_rc rc = grn_obj_remove(ctx, object.get());
+ if (rc == GRN_SUCCESS) {
+ object.release();
+ index_column.release();
+ } else {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to drop multiple column index table: <%.*s>: <%s>",
+ multiple_column_index_table_name_length,
+ multiple_column_index_table_name,
+ ctx->errbuf);
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, error_message, MYF(0));
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ break;
+ }
+ }
+
+ grn_table_cursor_close(ctx, cursor);
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::drop_indexes(const char *table_name)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ mrn::SmartGrnObj table(ctx, table_name);
+ if (!table.get()) {
+ DBUG_RETURN(0);
+ }
+
+ error = drop_indexes_normal(table_name, table.get());
+ if (error == 0) {
+ error = drop_indexes_multiple(table_name, table.get(),
+ mrn::IndexTableName::SEPARATOR);
+ }
+ if (error == 0) {
+ error = drop_indexes_multiple(table_name, table.get(),
+ mrn::IndexTableName::OLD_SEPARATOR);
+ }
+
+ DBUG_RETURN(error);
+}
+
+bool ha_mroonga::find_column_flags(Field *field, MRN_SHARE *mrn_share, int i,
+ grn_obj_flags *column_flags)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool found = false;
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ {
+ const char *names = field->option_struct->flags;
+ if (names) {
+ found = mrn_parse_grn_column_create_flags(ha_thd(),
+ ctx,
+ names,
+ strlen(names),
+ column_flags);
+ DBUG_RETURN(found);
+ }
+ }
+#endif
+
+ if (mrn_share->col_flags[i]) {
+ found = mrn_parse_grn_column_create_flags(ha_thd(),
+ ctx,
+ mrn_share->col_flags[i],
+ mrn_share->col_flags_length[i],
+ column_flags);
+ DBUG_RETURN(found);
+ }
+
+ DBUG_RETURN(found);
+}
+
+grn_obj *ha_mroonga::find_column_type(Field *field, MRN_SHARE *mrn_share, int i,
+ int error_code)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ const char *grn_type_name = NULL;
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ grn_type_name = field->option_struct->groonga_type;
+#endif
+ if (!grn_type_name) {
+ grn_type_name = mrn_share->col_type[i];
+ }
+
+ grn_obj *type = NULL;
+ if (grn_type_name) {
+ type = grn_ctx_get(ctx, grn_type_name, -1);
+ if (!type) {
+ char error_message[MRN_BUFFER_SIZE];
+ snprintf(error_message, MRN_BUFFER_SIZE,
+ "unknown custom Groonga type name for <%s> column: <%s>",
+ field->field_name.str, grn_type_name);
+ GRN_LOG(ctx, GRN_LOG_ERROR, "%s", error_message);
+ my_message(error_code, error_message, MYF(0));
+
+ DBUG_RETURN(NULL);
+ }
+ } else {
+ grn_builtin_type grn_type_id = mrn_grn_type_from_field(ctx, field, false);
+ type = grn_ctx_at(ctx, grn_type_id);
+ }
+
+ DBUG_RETURN(type);
+}
+
+grn_obj *ha_mroonga::find_tokenizer(KEY *key, MRN_SHARE *mrn_share, int i)
+{
+ MRN_DBUG_ENTER_METHOD();
+ grn_obj *tokenizer;
+ const char *tokenizer_name = NULL;
+ uint tokenizer_name_length = 0;
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ if (key->option_struct->tokenizer) {
+ tokenizer_name = key->option_struct->tokenizer;
+ tokenizer_name_length = strlen(tokenizer_name);
+ }
+#endif
+ if (!tokenizer_name) {
+ tokenizer_name = mrn_share->key_tokenizer[i];
+ tokenizer_name_length = mrn_share->key_tokenizer_length[i];
+ }
+ tokenizer = find_tokenizer(tokenizer_name, tokenizer_name_length);
+ DBUG_RETURN(tokenizer);
+}
+
+grn_obj *ha_mroonga::find_tokenizer(const char *name, int name_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ if (strncasecmp("off", name, name_length) == 0) {
+ DBUG_RETURN(NULL);
+ }
+
+ grn_obj *tokenizer;
+ mrn_change_encoding(ctx, system_charset_info);
+ tokenizer = grn_ctx_get(ctx, name, name_length);
+ if (!tokenizer) {
+ char message[MRN_BUFFER_SIZE];
+ sprintf(message,
+ "specified tokenizer for fulltext index <%.*s> doesn't exist. "
+ "The default tokenizer for fulltext index <%s> is used instead.",
+ name_length, name,
+ MRN_DEFAULT_TOKENIZER);
+ push_warning(ha_thd(),
+ MRN_SEVERITY_WARNING, ER_UNSUPPORTED_EXTENSION,
+ message);
+ tokenizer = grn_ctx_get(ctx,
+ MRN_DEFAULT_TOKENIZER,
+ strlen(MRN_DEFAULT_TOKENIZER));
+ }
+ if (!tokenizer) {
+ push_warning(ha_thd(),
+ MRN_SEVERITY_WARNING, ER_UNSUPPORTED_EXTENSION,
+ "couldn't find tokenizer for fulltext index. "
+ "Bigram tokenizer is used instead.");
+ tokenizer = grn_ctx_at(ctx, GRN_DB_BIGRAM);
+ }
+ DBUG_RETURN(tokenizer);
+}
+
+bool ha_mroonga::have_custom_normalizer(KEY *key) const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ if (key->option_struct && key->option_struct->normalizer) {
+ DBUG_RETURN(true);
+ }
+#endif
+
+ if (key->comment.length > 0) {
+ mrn::ParametersParser parser(key->comment.str,
+ key->comment.length);
+ parser.parse();
+ DBUG_RETURN(parser["normalizer"] != NULL);
+ }
+
+ DBUG_RETURN(false);
+}
+
+grn_obj *ha_mroonga::find_normalizer(KEY *key)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ if (key->option_struct->normalizer) {
+ grn_obj *normalizer = find_normalizer(key,
+ key->option_struct->normalizer);
+ DBUG_RETURN(normalizer);
+ }
+#endif
+
+ if (key->comment.length > 0) {
+ mrn::ParametersParser parser(key->comment.str,
+ key->comment.length);
+ parser.parse();
+ grn_obj *normalizer = find_normalizer(key, parser["normalizer"]);
+ DBUG_RETURN(normalizer);
+ }
+
+ grn_obj *normalizer = find_normalizer(key, NULL);
+ DBUG_RETURN(normalizer);
+}
+
+grn_obj *ha_mroonga::find_normalizer(KEY *key, const char *name)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ grn_obj *normalizer = NULL;
+ bool use_normalizer = true;
+ if (name) {
+ if (strcmp(name, "none") == 0) {
+ use_normalizer = false;
+ } else {
+ normalizer = grn_ctx_get(ctx, name, -1);
+ }
+ }
+ if (use_normalizer && !normalizer) {
+ Field *field = key->key_part[0].field;
+ mrn::FieldNormalizer field_normalizer(ctx, ha_thd(), field);
+ normalizer = field_normalizer.find_grn_normalizer();
+ }
+
+ DBUG_RETURN(normalizer);
+}
+
+bool ha_mroonga::find_index_column_flags(KEY *key, grn_column_flags *index_column_flags)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool found = false;
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ {
+ const char *names = key->option_struct->flags;
+ if (names) {
+ found = mrn_parse_grn_index_column_flags(ha_thd(),
+ ctx,
+ names,
+ strlen(names),
+ index_column_flags);
+ DBUG_RETURN(found);
+ }
+ }
+#endif
+
+ if (key->comment.length > 0) {
+ mrn::ParametersParser parser(key->comment.str,
+ key->comment.length);
+ parser.parse();
+ const char *names = parser["flags"];
+ if (!names) {
+ // Deprecated. It's for backward compatibility.
+ names = parser["index_flags"];
+ }
+ if (names) {
+ found = mrn_parse_grn_index_column_flags(ha_thd(),
+ ctx,
+ names,
+ strlen(names),
+ index_column_flags);
+ }
+ }
+
+ DBUG_RETURN(found);
+}
+
+bool ha_mroonga::find_token_filters(KEY *key, grn_obj *token_filters)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool found = false;
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ if (key->option_struct->token_filters) {
+ found = find_token_filters_fill(token_filters,
+ key->option_struct->token_filters,
+ strlen(key->option_struct->token_filters));
+ DBUG_RETURN(found);
+ }
+#endif
+
+ if (key->comment.length > 0) {
+ mrn::ParametersParser parser(key->comment.str,
+ key->comment.length);
+ parser.parse();
+ const char *names = parser["token_filters"];
+ if (names) {
+ found = find_token_filters_fill(token_filters, names, strlen(names));
+ }
+ }
+
+ DBUG_RETURN(found);
+}
+
+bool ha_mroonga::find_token_filters_put(grn_obj *token_filters,
+ const char *token_filter_name,
+ int token_filter_name_length)
+{
+ grn_obj *token_filter;
+
+ token_filter = grn_ctx_get(ctx,
+ token_filter_name,
+ token_filter_name_length);
+ if (token_filter) {
+ GRN_PTR_PUT(ctx, token_filters, token_filter);
+ return true;
+ } else {
+ char message[MRN_BUFFER_SIZE];
+ sprintf(message,
+ "nonexistent token filter: <%.*s>",
+ token_filter_name_length, token_filter_name);
+ push_warning(ha_thd(),
+ MRN_SEVERITY_WARNING, ER_UNSUPPORTED_EXTENSION,
+ message);
+ return false;
+ }
+}
+
+bool ha_mroonga::find_token_filters_fill(grn_obj *token_filters,
+ const char *token_filter_names,
+ int token_filter_names_length)
+{
+ const char *start, *current, *end;
+ const char *name_start, *name_end;
+ const char *last_name_end;
+
+ start = token_filter_names;
+ end = start + token_filter_names_length;
+ current = start;
+ name_start = NULL;
+ name_end = NULL;
+ last_name_end = start;
+ while (current < end) {
+ switch (current[0]) {
+ case ' ' :
+ if (name_start && !name_end) {
+ name_end = current;
+ }
+ break;
+ case ',' :
+ if (!name_start) {
+ goto break_loop;
+ }
+ if (!name_end) {
+ name_end = current;
+ }
+ find_token_filters_put(token_filters,
+ name_start,
+ name_end - name_start);
+ last_name_end = name_end + 1;
+ name_start = NULL;
+ name_end = NULL;
+ break;
+ default :
+ if (!name_start) {
+ name_start = current;
+ }
+ break;
+ }
+ current++;
+ }
+
+break_loop:
+ if (!name_start) {
+ char message[MRN_BUFFER_SIZE];
+ sprintf(message,
+ "empty token filter name: "
+ "<%.*s|%.*s|%.*s>",
+ (int)(last_name_end - start), start,
+ (int)(current - last_name_end), last_name_end,
+ (int)(end - current), current);
+ push_warning(ha_thd(),
+ MRN_SEVERITY_WARNING, ER_UNSUPPORTED_EXTENSION,
+ message);
+ return false;
+ }
+
+ if (!name_end) {
+ name_end = current;
+ }
+ find_token_filters_put(token_filters,
+ name_start,
+ name_end - name_start);
+
+ return true;
+}
+
+int ha_mroonga::wrapper_get_record(uchar *buf, const uchar *key)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (wrap_handler->inited == NONE) {
+#ifdef MRN_HANDLER_HAVE_HA_INDEX_READ_IDX_MAP
+ error = wrap_handler->ha_index_read_idx_map(buf,
+ share->wrap_primary_key,
+ key,
+ pk_keypart_map,
+ HA_READ_KEY_EXACT);
+#else
+ error = wrap_handler->index_read_idx_map(buf,
+ share->wrap_primary_key,
+ key,
+ pk_keypart_map,
+ HA_READ_KEY_EXACT);
+#endif
+ } else {
+#ifdef MRN_HANDLER_HAVE_HA_INDEX_READ_MAP
+ error = wrap_handler->ha_index_read_map(buf,
+ key,
+ pk_keypart_map,
+ HA_READ_KEY_EXACT);
+#else
+ error = wrap_handler->index_read_map(buf,
+ key,
+ pk_keypart_map,
+ HA_READ_KEY_EXACT);
+#endif
+ }
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_get_next_geo_record(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ mrn_change_encoding(ctx, NULL);
+ do {
+ GRN_BULK_REWIND(&key_buffer);
+ grn_id found_record_id;
+ grn_posting *posting;
+ posting = grn_geo_cursor_next(ctx, cursor_geo);
+ if (!posting) {
+ error = HA_ERR_END_OF_FILE;
+ clear_cursor_geo();
+ break;
+ }
+ found_record_id = posting->rid;
+ grn_table_get_key(ctx, grn_table, found_record_id,
+ GRN_TEXT_VALUE(&key_buffer),
+ table->key_info->key_length);
+ error = wrapper_get_record(buf, (const uchar *)GRN_TEXT_VALUE(&key_buffer));
+ } while (error == HA_ERR_END_OF_FILE || error == HA_ERR_KEY_NOT_FOUND);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_get_next_record(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (cursor_geo) {
+ grn_posting *posting;
+ posting = grn_geo_cursor_next(ctx, cursor_geo);
+ if (posting) {
+ record_id = posting->rid;
+ } else {
+ record_id = GRN_ID_NIL;
+ }
+ } else if (cursor) {
+ record_id = grn_table_cursor_next(ctx, cursor);
+ } else if (empty_value_records_cursor) {
+ grn_id empty_value_record_id;
+ empty_value_record_id =
+ grn_table_cursor_next(ctx, empty_value_records_cursor);
+ if (empty_value_record_id == GRN_ID_NIL) {
+ record_id = GRN_ID_NIL;
+ } else {
+ grn_table_get_key(ctx, empty_value_records, empty_value_record_id,
+ &record_id, sizeof(grn_id));
+ }
+ } else {
+ record_id = GRN_ID_NIL;
+ }
+ if (ctx->rc) {
+ int error = ER_ERROR_ON_READ;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ if (record_id == GRN_ID_NIL) {
+ DBUG_PRINT("info", ("mroonga: storage_get_next_record: end-of-file"));
+ table->status = STATUS_NOT_FOUND;
+ DBUG_RETURN(HA_ERR_END_OF_FILE);
+ }
+ if (buf) {
+ if (ignoring_no_key_columns)
+ storage_store_fields_by_index(buf);
+ else
+ storage_store_fields(buf, record_id);
+ if (cursor_geo && grn_source_column_geo) {
+ int latitude, longitude;
+ GRN_GEO_POINT_VALUE(&source_point, latitude, longitude);
+ double latitude_in_degree = GRN_GEO_MSEC2DEGREE(latitude);
+ double longitude_in_degree = GRN_GEO_MSEC2DEGREE(longitude);
+ if (!((bottom_right_latitude_in_degree <= latitude_in_degree &&
+ latitude_in_degree <= top_left_latitude_in_degree) &&
+ (top_left_longitude_in_degree <= longitude_in_degree &&
+ longitude_in_degree <= bottom_right_longitude_in_degree))) {
+ DBUG_PRINT("info",
+ ("mroonga: remove not contained geo point: "
+ "<%g,%g>(<%d,%d>); key: <%g,%g>(<%d,%d>), <%g,%g>(<%d,%d>)",
+ latitude_in_degree, longitude_in_degree,
+ latitude, longitude,
+ top_left_latitude_in_degree, top_left_longitude_in_degree,
+ GRN_GEO_DEGREE2MSEC(top_left_latitude_in_degree),
+ GRN_GEO_DEGREE2MSEC(top_left_longitude_in_degree),
+ bottom_right_latitude_in_degree,
+ bottom_right_longitude_in_degree,
+ GRN_GEO_DEGREE2MSEC(bottom_right_latitude_in_degree),
+ GRN_GEO_DEGREE2MSEC(bottom_right_longitude_in_degree)));
+ int error = storage_get_next_record(buf);
+ DBUG_RETURN(error);
+ }
+ }
+ }
+ table->status = 0;
+ DBUG_RETURN(0);
+}
+
+void ha_mroonga::geo_store_rectangle(const uchar *rectangle)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ double locations[4];
+ for (int i = 0; i < 4; i++) {
+ uchar reversed_value[8];
+ for (int j = 0; j < 8; j++) {
+ reversed_value[j] = (rectangle + (8 * i))[7 - j];
+ }
+ mi_float8get(locations[i], reversed_value);
+ }
+ top_left_longitude_in_degree = locations[0];
+ bottom_right_longitude_in_degree = locations[1];
+ bottom_right_latitude_in_degree = locations[2];
+ top_left_latitude_in_degree = locations[3];
+ int top_left_latitude = GRN_GEO_DEGREE2MSEC(top_left_latitude_in_degree);
+ int top_left_longitude = GRN_GEO_DEGREE2MSEC(top_left_longitude_in_degree);
+ int bottom_right_latitude = GRN_GEO_DEGREE2MSEC(bottom_right_latitude_in_degree);
+ int bottom_right_longitude = GRN_GEO_DEGREE2MSEC(bottom_right_longitude_in_degree);
+ GRN_GEO_POINT_SET(ctx, &top_left_point,
+ top_left_latitude, top_left_longitude);
+ GRN_GEO_POINT_SET(ctx, &bottom_right_point,
+ bottom_right_latitude, bottom_right_longitude);
+
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::generic_geo_open_cursor(const uchar *key,
+ enum ha_rkey_function find_flag)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ int flags = 0;
+ if (find_flag & HA_READ_MBR_CONTAIN) {
+ grn_obj *index = grn_index_columns[active_index];
+ geo_store_rectangle(key);
+ cursor_geo = grn_geo_cursor_open_in_rectangle(ctx,
+ index,
+ &top_left_point,
+ &bottom_right_point,
+ 0, -1);
+ if (cursor_geo) {
+ if (grn_source_column_geo) {
+ grn_obj_unlink(ctx, grn_source_column_geo);
+ }
+ grn_obj sources;
+ GRN_OBJ_INIT(&sources, GRN_BULK, 0, GRN_ID_NIL);
+ grn_obj_get_info(ctx, index, GRN_INFO_SOURCE, &sources);
+ grn_source_column_geo = grn_ctx_at(ctx, GRN_RECORD_VALUE(&sources));
+ grn_obj_unlink(ctx, &sources);
+ }
+ } else {
+ push_warning_unsupported_spatial_index_search(find_flag);
+ cursor = grn_table_cursor_open(ctx, grn_table, NULL, 0, NULL, 0,
+ 0, -1, flags);
+ }
+ if (ctx->rc) {
+ error = ER_ERROR_ON_READ;
+ my_message(error, ctx->errbuf, MYF(0));
+ }
+ DBUG_RETURN(error);
+}
+
+bool ha_mroonga::is_dry_write()
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool dry_write_p = THDVAR(ha_thd(), dry_write);
+ DBUG_RETURN(dry_write_p);
+}
+
+bool ha_mroonga::is_enable_optimization()
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool enable_optimization_p = THDVAR(ha_thd(), enable_optimization);
+ DBUG_RETURN(enable_optimization_p);
+}
+
+bool ha_mroonga::should_normalize(Field *field) const
+{
+ MRN_DBUG_ENTER_METHOD();
+ mrn::FieldNormalizer field_normalizer(ctx, ha_thd(), field);
+ bool need_normalize_p = field_normalizer.should_normalize();
+ DBUG_RETURN(need_normalize_p);
+}
+
+void ha_mroonga::check_count_skip(key_part_map target_key_part_map)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ if (!is_enable_optimization()) {
+ GRN_LOG(ctx, GRN_LOG_DEBUG,
+ "[mroonga][count-skip][false] optimization is disabled");
+ count_skip = false;
+ DBUG_VOID_RETURN;
+ }
+
+ if (thd_sql_command(ha_thd()) != SQLCOM_SELECT) {
+ GRN_LOG(ctx, GRN_LOG_DEBUG,
+ "[mroonga][count-skip][false] not SELECT");
+ count_skip = false;
+ DBUG_VOID_RETURN;
+ }
+
+ if (share->wrapper_mode &&
+ !(wrap_handler->ha_table_flags() & HA_NO_TRANSACTIONS)) {
+ GRN_LOG(ctx, GRN_LOG_DEBUG,
+ "[mroonga][count-skip][false] wrapped engine is transactional");
+ count_skip = false;
+ DBUG_VOID_RETURN;
+ }
+
+ st_select_lex *select_lex = table->pos_in_table_list->select_lex;
+ KEY *key_info = NULL;
+ if (active_index != MAX_KEY) {
+ key_info = &(table->key_info[active_index]);
+ }
+ mrn::CountSkipChecker checker(ctx,
+ table,
+ select_lex,
+ key_info,
+ target_key_part_map,
+ !share->wrapper_mode);
+ if (checker.check()) {
+ count_skip = true;
+ mrn_count_skip++;
+ DBUG_VOID_RETURN;
+ } else {
+ count_skip = false;
+ DBUG_VOID_RETURN;
+ }
+}
+
+bool ha_mroonga::is_grn_zero_column_value(grn_obj *column, grn_obj *value)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ if (column->header.type != GRN_COLUMN_FIX_SIZE) {
+ DBUG_RETURN(false);
+ }
+
+ char *bytes = GRN_BULK_HEAD(value);
+ unsigned int size = GRN_BULK_VSIZE(value);
+ for (unsigned int i = 0; i < size; ++i) {
+ if (bytes[i] != '\0') {
+ DBUG_RETURN(false);
+ }
+ }
+
+ DBUG_RETURN(true);
+}
+
+bool ha_mroonga::is_primary_key_field(Field *field) const
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ if (table->s->primary_key == MAX_INDEXES) {
+ DBUG_RETURN(false);
+ }
+
+ KEY *key_info = &(table->s->key_info[table->s->primary_key]);
+ if (KEY_N_KEY_PARTS(key_info) != 1) {
+ DBUG_RETURN(false);
+ }
+
+ if (strcmp(field->field_name.str,
+ key_info->key_part[0].field->field_name.str) == 0) {
+ DBUG_RETURN(true);
+ } else {
+ DBUG_RETURN(false);
+ }
+}
+
+void ha_mroonga::check_fast_order_limit(grn_table_sort_key **sort_keys,
+ int *n_sort_keys,
+ longlong *limit)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ if (!is_enable_optimization()) {
+ DBUG_PRINT("info", ("mroonga: fast order limit: optimization is disabled"));
+ fast_order_limit = false;
+ DBUG_VOID_RETURN;
+ }
+
+ TABLE_LIST *table_list = table->pos_in_table_list;
+ st_select_lex *select_lex = table_list->select_lex;
+ SELECT_LEX_UNIT *unit = MRN_TABLE_LIST_GET_DERIVED(table_list);
+ st_select_lex *first_select_lex;
+ if (unit)
+ {
+ first_select_lex = unit->first_select();
+ } else {
+ first_select_lex = select_lex;
+ }
+ DBUG_PRINT("info",
+ ("mroonga: first_select_lex->options=%llu",
+ first_select_lex ? MRN_SELECT_LEX_GET_ACTIVE_OPTIONS(first_select_lex) : 0));
+
+ if (
+ thd_sql_command(ha_thd()) == SQLCOM_SELECT &&
+ !select_lex->with_sum_func &&
+ !select_lex->group_list.elements &&
+ !MRN_SELECT_LEX_GET_HAVING_COND(select_lex) &&
+ select_lex->table_list.elements == 1 &&
+ select_lex->order_list.elements &&
+ select_lex->limit_params.explicit_limit &&
+ select_lex->limit_params.select_limit &&
+ select_lex->limit_params.select_limit->val_int() > 0
+ ) {
+ if (select_lex->limit_params.offset_limit) {
+ *limit = select_lex->limit_params.offset_limit->val_int();
+ } else {
+ *limit = 0;
+ }
+ *limit += select_lex->limit_params.select_limit->val_int();
+ if (*limit > (longlong)INT_MAX) {
+ DBUG_PRINT("info",
+ ("mroonga: fast_order_limit = false: "
+ "too long limit: %lld <= %d is required",
+ *limit, INT_MAX));
+ fast_order_limit = false;
+ DBUG_VOID_RETURN;
+ }
+ if (first_select_lex &&
+ (MRN_SELECT_LEX_GET_ACTIVE_OPTIONS(first_select_lex) & OPTION_FOUND_ROWS)) {
+ DBUG_PRINT("info",
+ ("mroonga: fast_order_limit = false: "
+ "SQL_CALC_FOUND_ROWS is specified"));
+ fast_order_limit = false;
+ DBUG_VOID_RETURN;
+ }
+ bool is_storage_mode = !(share->wrapper_mode);
+ Item *where = MRN_SELECT_LEX_GET_WHERE_COND(select_lex);
+ const Item_func *match_against = NULL;
+ if (where) {
+ mrn::ConditionConverter converter(ctx, grn_table, is_storage_mode);
+ if (!converter.is_convertable(where)) {
+ DBUG_PRINT("info",
+ ("mroonga: fast_order_limit = false: "
+ "not Groonga layer condition search"));
+ fast_order_limit = false;
+ DBUG_VOID_RETURN;
+ }
+ unsigned int n_match_againsts = converter.count_match_against(where);
+ if (n_match_againsts == 0) {
+ DBUG_PRINT("info",
+ ("mroonga: fast_order_limit = false: "
+ "Groonga layer condition but not fulltext search"));
+ fast_order_limit = false;
+ DBUG_VOID_RETURN;
+ }
+ if (n_match_againsts > 1) {
+ DBUG_PRINT("info",
+ ("mroonga: fast_order_limit = false: "
+ "MATCH AGAINST must be only one"));
+ fast_order_limit = false;
+ DBUG_VOID_RETURN;
+ }
+ }
+ int n_max_sort_keys = select_lex->order_list.elements;
+ *n_sort_keys = 0;
+ size_t sort_keys_size = sizeof(grn_table_sort_key) * n_max_sort_keys;
+ *sort_keys = (grn_table_sort_key *)mrn_my_malloc(sort_keys_size,
+ MYF(MY_WME));
+ memset(*sort_keys, 0, sort_keys_size);
+ ORDER *order;
+ int i;
+ mrn_change_encoding(ctx, system_charset_info);
+ for (order = (ORDER *) select_lex->order_list.first, i = 0;
+ order;
+ order = order->next, i++) {
+ Item *item = *order->item;
+ if (item->type() == Item::FIELD_ITEM)
+ {
+ Field *field = static_cast<Item_field *>(item)->field;
+ mrn::ColumnName column_name(field->field_name);
+
+ if (should_normalize(field))
+ {
+ DBUG_PRINT("info", ("mroonga: fast_order_limit = false: "
+ "sort by collated value isn't supported yet."));
+ fast_order_limit = false;
+ my_free(*sort_keys);
+ *sort_keys = NULL;
+ *n_sort_keys = 0;
+ DBUG_VOID_RETURN;
+ }
+
+ if (is_storage_mode) {
+ (*sort_keys)[i].key = grn_obj_column(ctx, matched_record_keys,
+ column_name.c_str(),
+ column_name.length());
+ } else {
+ if (is_primary_key_field(field)) {
+ (*sort_keys)[i].key = grn_obj_column(ctx, matched_record_keys,
+ MRN_COLUMN_NAME_KEY,
+ strlen(MRN_COLUMN_NAME_KEY));
+ } else {
+ DBUG_PRINT("info", ("mroonga: fast_order_limit = false: "
+ "sort by not primary key value "
+ "isn't supported in wrapper mode."));
+ fast_order_limit = false;
+ my_free(*sort_keys);
+ *sort_keys = NULL;
+ *n_sort_keys = 0;
+ DBUG_VOID_RETURN;
+ }
+ }
+ } else if (!match_against || match_against->eq(item, true)) {
+ (*sort_keys)[i].key = grn_obj_column(ctx, matched_record_keys,
+ MRN_COLUMN_NAME_SCORE,
+ strlen(MRN_COLUMN_NAME_SCORE));
+ } else {
+ DBUG_PRINT("info", ("mroonga: fast_order_limit = false: "
+ "sort by computed value isn't supported."));
+ fast_order_limit = false;
+ my_free(*sort_keys);
+ *sort_keys = NULL;
+ *n_sort_keys = 0;
+ DBUG_VOID_RETURN;
+ }
+ (*sort_keys)[i].offset = 0;
+ if (MRN_ORDER_IS_ASC(order))
+ {
+ (*sort_keys)[i].flags = GRN_TABLE_SORT_ASC;
+ } else {
+ (*sort_keys)[i].flags = GRN_TABLE_SORT_DESC;
+ }
+ (*n_sort_keys)++;
+ }
+ DBUG_PRINT("info", ("mroonga: fast_order_limit = true"));
+ fast_order_limit = true;
+ mrn_fast_order_limit++;
+ DBUG_VOID_RETURN;
+ }
+ DBUG_PRINT("info", ("mroonga: fast_order_limit = false"));
+ fast_order_limit = false;
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::generic_store_bulk_fixed_size_string(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ grn_obj_reinit(ctx, buf, GRN_DB_SHORT_TEXT, 0);
+ GRN_TEXT_SET(ctx, buf, field->ptr, field->field_length);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_variable_size_string(Field *field,
+ grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ String value;
+ field->val_str(NULL, &value);
+ grn_obj_reinit(ctx, buf, GRN_DB_SHORT_TEXT, 0);
+ DBUG_PRINT("info", ("mroonga: length=%" MRN_FORMAT_STRING_LENGTH,
+ value.length()));
+ DBUG_PRINT("info", ("mroonga: value=%s", value.c_ptr_safe()));
+ GRN_TEXT_SET(ctx, buf, value.ptr(), value.length());
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_integer(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ long long value = field->val_int();
+ DBUG_PRINT("info", ("mroonga: value=%lld", value));
+ uint32 size = field->pack_length();
+ DBUG_PRINT("info", ("mroonga: size=%u", size));
+ Field_num *field_num = static_cast<Field_num *>(field);
+ bool is_unsigned = field_num->unsigned_flag;
+ DBUG_PRINT("info", ("mroonga: is_unsigned=%s", is_unsigned ? "true" : "false"));
+ switch (size) {
+ case 1:
+ if (is_unsigned) {
+ grn_obj_reinit(ctx, buf, GRN_DB_UINT8, 0);
+ GRN_UINT8_SET(ctx, buf, value);
+ } else {
+ grn_obj_reinit(ctx, buf, GRN_DB_INT8, 0);
+ GRN_INT8_SET(ctx, buf, value);
+ }
+ break;
+ case 2:
+ if (is_unsigned) {
+ grn_obj_reinit(ctx, buf, GRN_DB_UINT16, 0);
+ GRN_UINT16_SET(ctx, buf, value);
+ } else {
+ grn_obj_reinit(ctx, buf, GRN_DB_INT16, 0);
+ GRN_INT16_SET(ctx, buf, value);
+ }
+ break;
+ case 3:
+ case 4:
+ if (is_unsigned) {
+ grn_obj_reinit(ctx, buf, GRN_DB_UINT32, 0);
+ GRN_UINT32_SET(ctx, buf, value);
+ } else {
+ grn_obj_reinit(ctx, buf, GRN_DB_INT32, 0);
+ GRN_INT32_SET(ctx, buf, value);
+ }
+ break;
+ case 8:
+ if (is_unsigned) {
+ grn_obj_reinit(ctx, buf, GRN_DB_UINT64, 0);
+ GRN_UINT64_SET(ctx, buf, value);
+ } else {
+ grn_obj_reinit(ctx, buf, GRN_DB_INT64, 0);
+ GRN_INT64_SET(ctx, buf, value);
+ }
+ break;
+ default:
+ // Why!?
+ error = HA_ERR_UNSUPPORTED;
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "unknown integer value size: <%u>: "
+ "available sizes: [1, 2, 3, 4, 8]",
+ size);
+ push_warning(ha_thd(), MRN_SEVERITY_WARNING,
+ error, error_message);
+ break;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_unsigned_integer(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ long long signed_value = field->val_int();
+ unsigned long long unsigned_value = *((unsigned long long *)(&signed_value));
+ uint32 size = field->pack_length();
+ switch (size) {
+ case 1:
+ grn_obj_reinit(ctx, buf, GRN_DB_UINT8, 0);
+ GRN_UINT8_SET(ctx, buf, unsigned_value);
+ break;
+ case 2:
+ grn_obj_reinit(ctx, buf, GRN_DB_UINT16, 0);
+ GRN_UINT16_SET(ctx, buf, unsigned_value);
+ break;
+ case 3:
+ case 4:
+ grn_obj_reinit(ctx, buf, GRN_DB_UINT32, 0);
+ GRN_UINT32_SET(ctx, buf, unsigned_value);
+ break;
+ case 8:
+ grn_obj_reinit(ctx, buf, GRN_DB_UINT64, 0);
+ GRN_UINT64_SET(ctx, buf, unsigned_value);
+ break;
+ default:
+ // Why!?
+ error = HA_ERR_UNSUPPORTED;
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "unknown unsigned integer value size: <%u>: "
+ "available sizes: [1, 2, 3, 4, 8]",
+ size);
+ push_warning(ha_thd(), MRN_SEVERITY_WARNING,
+ error, error_message);
+ break;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_float(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ double value = field->val_real();
+ uint32 size = field->pack_length();
+ switch (size) {
+ case 4:
+ case 8:
+ grn_obj_reinit(ctx, buf, GRN_DB_FLOAT, 0);
+ GRN_FLOAT_SET(ctx, buf, value);
+ break;
+ default:
+ // Why!?
+ error = HA_ERR_UNSUPPORTED;
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "unknown float value size: <%u>: "
+ "available sizes: [4, 8]",
+ size);
+ push_warning(ha_thd(), MRN_SEVERITY_WARNING,
+ error, error_message);
+ break;
+ }
+ DBUG_RETURN(error);
+}
+
+long long int ha_mroonga::get_grn_time_from_timestamp_field(Field_timestamp *field)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int grn_time = 0;
+#ifdef MRN_TIMESTAMP_USE_TIMEVAL
+ int warnings = 0;
+ struct timeval time_value;
+ if (field->get_timestamp(&time_value, &warnings)) {
+ // XXX: Should we report warnings or MySQL does?
+ } else {
+ DBUG_PRINT("info", ("mroonga: timeval tv_sec=%ld", time_value.tv_sec));
+ grn_time = GRN_TIME_PACK(time_value.tv_sec, time_value.tv_usec);
+ }
+#elif defined(MRN_TIMESTAMP_USE_MY_TIME_T)
+ unsigned long int micro_seconds;
+ my_time_t seconds = field->get_timestamp(&micro_seconds);
+ DBUG_PRINT("info", ("mroonga: my_time_t seconds=%ld", seconds));
+ grn_time = GRN_TIME_PACK(seconds, micro_seconds);
+#else
+ my_bool is_null_value;
+ long seconds = field->get_timestamp(&is_null_value);
+ DBUG_PRINT("info", ("mroonga: long seconds=%ld", seconds));
+ grn_time = GRN_TIME_PACK(seconds, 0);
+#endif
+ DBUG_RETURN(grn_time);
+}
+
+int ha_mroonga::generic_store_bulk_timestamp(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ Field_timestamp *timestamp_field = (Field_timestamp *)field;
+ long long int time = get_grn_time_from_timestamp_field(timestamp_field);
+ grn_obj_reinit(ctx, buf, GRN_DB_TIME, 0);
+ GRN_TIME_SET(ctx, buf, time);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_date(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ long long int date_value = field->val_int();
+ struct tm date;
+ memset(&date, 0, sizeof(struct tm));
+ date.tm_year = date_value / 10000 % 10000 - mrn::TimeConverter::TM_YEAR_BASE;
+ date.tm_mon = date_value / 100 % 100 - 1;
+ date.tm_mday = date_value % 100;
+ int usec = 0;
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.tm_to_grn_time(&date, usec, &truncated);
+ if (truncated) {
+ field->set_warning(MRN_SEVERITY_WARNING,
+ WARN_DATA_TRUNCATED, 1);
+ }
+ grn_obj_reinit(ctx, buf, GRN_DB_TIME, 0);
+ GRN_TIME_SET(ctx, buf, time);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_time(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ Field_time *time_field = (Field_time *)field;
+ MYSQL_TIME mysql_time;
+ time_field->get_date(&mysql_time, Time::Options(current_thd));
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.mysql_time_to_grn_time(&mysql_time,
+ &truncated);
+ if (truncated) {
+ field->set_warning(MRN_SEVERITY_WARNING,
+ WARN_DATA_TRUNCATED, 1);
+ }
+ grn_obj_reinit(ctx, buf, GRN_DB_TIME, 0);
+ GRN_TIME_SET(ctx, buf, time);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_datetime(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ Field_datetime *datetime_field = (Field_datetime *)field;
+ MYSQL_TIME mysql_time;
+ datetime_field->get_date(&mysql_time, Time::Options(current_thd));
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.mysql_time_to_grn_time(&mysql_time,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ grn_obj_reinit(ctx, buf, GRN_DB_TIME, 0);
+ GRN_TIME_SET(ctx, buf, time);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_year(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+
+ int year;
+ if (field->field_length == 2) {
+ year = static_cast<int>(field->val_int() + 2000);
+ } else {
+ year = static_cast<int>(field->val_int());
+ }
+
+ DBUG_PRINT("info", ("mroonga: year=%d", year));
+ struct tm date;
+ memset(&date, 0, sizeof(struct tm));
+ date.tm_year = year - mrn::TimeConverter::TM_YEAR_BASE;
+ date.tm_mon = 0;
+ date.tm_mday = 1;
+
+ int usec = 0;
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.tm_to_grn_time(&date, usec, &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ grn_obj_reinit(ctx, buf, GRN_DB_TIME, 0);
+ GRN_TIME_SET(ctx, buf, time);
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2
+int ha_mroonga::generic_store_bulk_datetime2(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ Field_datetimef *datetimef_field = (Field_datetimef *)field;
+ MYSQL_TIME mysql_time;
+ datetimef_field->get_date(&mysql_time, Time::Options(current_thd));
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.mysql_time_to_grn_time(&mysql_time,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ grn_obj_reinit(ctx, buf, GRN_DB_TIME, 0);
+ GRN_TIME_SET(ctx, buf, time);
+ DBUG_RETURN(error);
+}
+#endif
+
+#ifdef MRN_HAVE_MYSQL_TYPE_TIME2
+int ha_mroonga::generic_store_bulk_time2(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ MYSQL_TIME mysql_time;
+ field->get_date(&mysql_time, Time::Options(current_thd));
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.mysql_time_to_grn_time(&mysql_time,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ grn_obj_reinit(ctx, buf, GRN_DB_TIME, 0);
+ GRN_TIME_SET(ctx, buf, time);
+ DBUG_RETURN(error);
+}
+#endif
+
+int ha_mroonga::generic_store_bulk_new_date(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ Field_newdate *newdate_field = (Field_newdate *)field;
+ MYSQL_TIME mysql_date;
+ newdate_field->get_date(&mysql_date, Time::Options(current_thd));
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.mysql_time_to_grn_time(&mysql_date,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ grn_obj_reinit(ctx, buf, GRN_DB_TIME, 0);
+ GRN_TIME_SET(ctx, buf, time);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_new_decimal(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ String value;
+ Field_new_decimal *new_decimal_field = (Field_new_decimal *)field;
+ new_decimal_field->val_str(&value, NULL);
+ grn_obj_reinit(ctx, buf, GRN_DB_SHORT_TEXT, 0);
+ GRN_TEXT_SET(ctx, buf, value.ptr(), value.length());
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_blob(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ String buffer;
+ Field_blob *blob = (Field_blob *)field;
+ String *value = blob->val_str(0, &buffer);
+ grn_obj_reinit(ctx, buf, GRN_DB_TEXT, 0);
+ GRN_TEXT_SET(ctx, buf, value->ptr(), value->length());
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_store_bulk_geometry(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+#ifdef MRN_HAVE_SPATIAL
+ String buffer;
+ Field_blob *geometry = (Field_blob *)field;
+ String *value = geometry->val_str(0, &buffer);
+ const char *wkb = value->ptr();
+ int len = value->length();
+ error = mrn_set_geometry(ctx, buf, wkb, len);
+#endif
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_HAVE_MYSQL_TYPE_JSON
+int ha_mroonga::generic_store_bulk_json(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ String buffer;
+ Field_json *json = static_cast<Field_json *>(field);
+ String *value = json->val_str(&buffer, NULL);
+ grn_obj_reinit(ctx, buf, GRN_DB_TEXT, 0);
+ GRN_TEXT_SET(ctx, buf, value->ptr(), value->length());
+ DBUG_RETURN(error);
+}
+#endif
+
+int ha_mroonga::generic_store_bulk(Field *field, grn_obj *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+ error = mrn_change_encoding(ctx, field->charset());
+ if (error)
+ return error;
+ switch (field->real_type()) {
+ case MYSQL_TYPE_DECIMAL:
+ error = generic_store_bulk_variable_size_string(field, buf);
+ break;
+ case MYSQL_TYPE_TINY:
+ case MYSQL_TYPE_SHORT:
+ case MYSQL_TYPE_LONG:
+ error = generic_store_bulk_integer(field, buf);
+ break;
+ case MYSQL_TYPE_FLOAT:
+ case MYSQL_TYPE_DOUBLE:
+ error = generic_store_bulk_float(field, buf);
+ break;
+ case MYSQL_TYPE_NULL:
+ error = generic_store_bulk_unsigned_integer(field, buf);
+ break;
+ case MYSQL_TYPE_TIMESTAMP:
+ error = generic_store_bulk_timestamp(field, buf);
+ break;
+ case MYSQL_TYPE_LONGLONG:
+ case MYSQL_TYPE_INT24:
+ error = generic_store_bulk_integer(field, buf);
+ break;
+ case MYSQL_TYPE_DATE:
+ error = generic_store_bulk_date(field, buf);
+ break;
+ case MYSQL_TYPE_TIME:
+ error = generic_store_bulk_time(field, buf);
+ break;
+ case MYSQL_TYPE_DATETIME:
+ error = generic_store_bulk_datetime(field, buf);
+ break;
+ case MYSQL_TYPE_YEAR:
+ error = generic_store_bulk_year(field, buf);
+ break;
+ case MYSQL_TYPE_NEWDATE:
+ error = generic_store_bulk_new_date(field, buf);
+ break;
+ case MYSQL_TYPE_VARCHAR:
+ error = generic_store_bulk_variable_size_string(field, buf);
+ break;
+ case MYSQL_TYPE_BIT:
+ error = generic_store_bulk_unsigned_integer(field, buf);
+ break;
+#ifdef MRN_HAVE_MYSQL_TYPE_TIMESTAMP2
+ case MYSQL_TYPE_TIMESTAMP2:
+ error = generic_store_bulk_timestamp(field, buf);
+ break;
+#endif
+#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2
+ case MYSQL_TYPE_DATETIME2:
+ error = generic_store_bulk_datetime2(field, buf);
+ break;
+#endif
+#ifdef MRN_HAVE_MYSQL_TYPE_TIME2
+ case MYSQL_TYPE_TIME2:
+ error = generic_store_bulk_time2(field, buf);
+ break;
+#endif
+ case MYSQL_TYPE_NEWDECIMAL:
+ error = generic_store_bulk_new_decimal(field, buf);
+ break;
+ case MYSQL_TYPE_ENUM:
+ error = generic_store_bulk_unsigned_integer(field, buf);
+ break;
+ case MYSQL_TYPE_SET:
+ error = generic_store_bulk_unsigned_integer(field, buf);
+ break;
+ case MYSQL_TYPE_TINY_BLOB:
+ case MYSQL_TYPE_MEDIUM_BLOB:
+ case MYSQL_TYPE_LONG_BLOB:
+ case MYSQL_TYPE_BLOB:
+ error = generic_store_bulk_blob(field, buf);
+ break;
+ case MYSQL_TYPE_VAR_STRING:
+ error = generic_store_bulk_variable_size_string(field, buf);
+ break;
+ case MYSQL_TYPE_STRING:
+ error = generic_store_bulk_fixed_size_string(field, buf);
+ break;
+ case MYSQL_TYPE_GEOMETRY:
+ error = generic_store_bulk_geometry(field, buf);
+ break;
+#ifdef MRN_HAVE_MYSQL_TYPE_JSON
+ case MYSQL_TYPE_JSON:
+ error = generic_store_bulk_json(field, buf);
+ break;
+#endif
+ default:
+ error = HA_ERR_UNSUPPORTED;
+ break;
+ }
+ DBUG_RETURN(error);
+}
+
+void ha_mroonga::storage_store_field_string(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ field->store(value, value_length, field->charset());
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_integer(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ Field_num *field_num = static_cast<Field_num *>(field);
+ bool is_unsigned = field_num->unsigned_flag;
+ switch (value_length) {
+ case 1:
+ {
+ if (is_unsigned) {
+ unsigned char field_value;
+ field_value = *((unsigned char *)value);
+ field->store(field_value, is_unsigned);
+ } else {
+ signed char field_value;
+ field_value = *((signed char *)value);
+ field->store(field_value, is_unsigned);
+ }
+ break;
+ }
+ case 2:
+ {
+ if (is_unsigned) {
+ unsigned short field_value;
+ field_value = *((unsigned short *)value);
+ field->store(field_value, is_unsigned);
+ } else {
+ short field_value;
+ field_value = *((short *)value);
+ field->store(field_value, is_unsigned);
+ }
+ break;
+ }
+ case 4:
+ {
+ if (is_unsigned) {
+ unsigned int field_value;
+ field_value = *((unsigned int *)value);
+ field->store(field_value, is_unsigned);
+ } else {
+ int field_value;
+ field_value = *((int *)value);
+ field->store(field_value, is_unsigned);
+ }
+ break;
+ }
+ case 8:
+ {
+ if (is_unsigned) {
+ unsigned long long int field_value;
+ field_value = *((unsigned long long int *)value);
+ DBUG_PRINT("info", ("mroonga: field_value=%llu", field_value));
+ field->store(field_value, is_unsigned);
+ } else {
+ long long int field_value;
+ field_value = *((long long int *)value);
+ field->store(field_value, is_unsigned);
+ }
+ break;
+ }
+ default:
+ {
+ // Why!?
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "unknown integer value size: <%d>: "
+ "available sizes: [1, 2, 4, 8]",
+ value_length);
+ push_warning(ha_thd(), MRN_SEVERITY_WARNING,
+ HA_ERR_UNSUPPORTED, error_message);
+ storage_store_field_string(field, value, value_length);
+ break;
+ }
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_unsigned_integer(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ switch (value_length) {
+ case 1:
+ {
+ unsigned char field_value;
+ field_value = *((unsigned char *)value);
+ field->store(field_value, true);
+ break;
+ }
+ case 2:
+ {
+ unsigned short field_value;
+ field_value = *((unsigned short *)value);
+ field->store(field_value, true);
+ break;
+ }
+ case 4:
+ {
+ unsigned int field_value;
+ field_value = *((unsigned int *)value);
+ field->store(field_value, true);
+ break;
+ }
+ case 8:
+ {
+ unsigned long long int field_value;
+ field_value = *((unsigned long long int *)value);
+ DBUG_PRINT("info", ("mroonga: field_value=%llu", field_value));
+ field->store(field_value, true);
+ break;
+ }
+ default:
+ {
+ // Why!?
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "unknown integer value size: <%d>: "
+ "available sizes: [1, 2, 4, 8]",
+ value_length);
+ push_warning(ha_thd(), MRN_SEVERITY_WARNING,
+ HA_ERR_UNSUPPORTED, error_message);
+ storage_store_field_string(field, value, value_length);
+ break;
+ }
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_float(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ double field_value;
+ field_value = *((double *)value);
+ field->store(field_value);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_timestamp(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int time = *((long long int *)value);
+ Field_timestamp *timestamp_field = (Field_timestamp *)field;
+#ifdef MRN_TIMESTAMP_USE_TIMEVAL
+ struct timeval time_value;
+ GRN_TIME_UNPACK(time, time_value.tv_sec, time_value.tv_usec);
+ timestamp_field->store_timestamp(&time_value);
+#elif defined(MRN_TIMESTAMP_USE_MY_TIME_T)
+ long long int sec, usec;
+ GRN_TIME_UNPACK(time, sec, usec);
+ timestamp_field->store_TIME(static_cast<int32>(sec),
+ static_cast<int32>(usec));
+#else
+ int32 sec, usec __attribute__((unused));
+ GRN_TIME_UNPACK(time, sec, usec);
+ timestamp_field->store_timestamp(sec);
+#endif
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_date(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int time = *((long long int *)value);
+ long long int sec, usec __attribute__((unused));
+ GRN_TIME_UNPACK(time, sec, usec);
+ struct tm date;
+ time_t sec_t = static_cast<int32>(sec);
+ gmtime_r(&sec_t, &date);
+ long long int date_in_mysql =
+ (date.tm_year + mrn::TimeConverter::TM_YEAR_BASE) * 10000 +
+ (date.tm_mon + 1) * 100 +
+ date.tm_mday;
+ field->store(date_in_mysql, false);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_time(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int time = *((long long int *)value);
+ MYSQL_TIME mysql_time;
+ memset(&mysql_time, 0, sizeof(MYSQL_TIME));
+ mysql_time.time_type = MYSQL_TIMESTAMP_TIME;
+ mrn::TimeConverter time_converter;
+ time_converter.grn_time_to_mysql_time(time, &mysql_time);
+#ifdef MRN_FIELD_STORE_TIME_NEED_TYPE
+ Field_time *time_field = (Field_time *)field;
+ time_field->store_time(&mysql_time, mysql_time.time_type);
+#else
+ field->store_time(&mysql_time);
+#endif
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_datetime(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int time = *((long long int *)value);
+ MYSQL_TIME mysql_datetime;
+ memset(&mysql_datetime, 0, sizeof(MYSQL_TIME));
+ mysql_datetime.time_type = MYSQL_TIMESTAMP_DATETIME;
+ mrn::TimeConverter time_converter;
+ time_converter.grn_time_to_mysql_time(time, &mysql_datetime);
+#ifdef MRN_FIELD_STORE_TIME_NEED_TYPE
+ Field_datetime *datetime_field = (Field_datetime *)field;
+ datetime_field->store_time(&mysql_datetime, mysql_datetime.time_type);
+#else
+ field->store_time(&mysql_datetime);
+#endif
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_year(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int time = *((long long int *)value);
+ MYSQL_TIME mysql_time;
+ memset(&mysql_time, 0, sizeof(MYSQL_TIME));
+ mysql_time.time_type = MYSQL_TIMESTAMP_DATE;
+ mrn::TimeConverter time_converter;
+ time_converter.grn_time_to_mysql_time(time, &mysql_time);
+ DBUG_PRINT("info", ("mroonga: stored %d", mysql_time.year));
+ field->store(mysql_time.year, false);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_new_date(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int time = *((long long int *)value);
+ MYSQL_TIME mysql_date;
+ memset(&mysql_date, 0, sizeof(MYSQL_TIME));
+ mysql_date.time_type = MYSQL_TIMESTAMP_DATE;
+ mrn::TimeConverter time_converter;
+ time_converter.grn_time_to_mysql_time(time, &mysql_date);
+#ifdef MRN_FIELD_STORE_TIME_NEED_TYPE
+ Field_newdate *newdate_field = (Field_newdate *)field;
+ newdate_field->store_time(&mysql_date, MYSQL_TIMESTAMP_DATE);
+#else
+ field->store_time(&mysql_date);
+#endif
+ DBUG_VOID_RETURN;
+}
+
+#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2
+void ha_mroonga::storage_store_field_datetime2(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int time = *((long long int *)value);
+ MYSQL_TIME mysql_datetime;
+ memset(&mysql_datetime, 0, sizeof(MYSQL_TIME));
+ mysql_datetime.time_type = MYSQL_TIMESTAMP_DATETIME;
+ mrn::TimeConverter time_converter;
+ time_converter.grn_time_to_mysql_time(time, &mysql_datetime);
+ field->store_time(&mysql_datetime);
+ DBUG_VOID_RETURN;
+}
+#endif
+
+#ifdef MRN_HAVE_MYSQL_TYPE_TIME2
+void ha_mroonga::storage_store_field_time2(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ long long int time = *((long long int *)value);
+
+ MYSQL_TIME mysql_time;
+ memset(&mysql_time, 0, sizeof(MYSQL_TIME));
+ mysql_time.time_type = MYSQL_TIMESTAMP_TIME;
+ mrn::TimeConverter time_converter;
+ time_converter.grn_time_to_mysql_time(time, &mysql_time);
+ field->store_time(&mysql_time);
+ DBUG_VOID_RETURN;
+}
+#endif
+
+void ha_mroonga::storage_store_field_blob(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ Field_blob *blob = (Field_blob *)field;
+ String *blob_buffer = &blob_buffers[field->field_index];
+ blob_buffer->length(0);
+ blob_buffer->reserve(value_length);
+ blob_buffer->q_append(value, value_length);
+ blob->set_ptr((uint32) value_length, (uchar *) blob_buffer->ptr());
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_field_geometry(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+#ifdef MRN_HAVE_SPATIAL
+ uchar wkb[SRID_SIZE + WKB_HEADER_SIZE + POINT_DATA_SIZE];
+ grn_geo_point *field_value = (grn_geo_point *)value;
+ int latitude, longitude;
+ latitude = field_value->latitude;
+ longitude = field_value->longitude;
+ if (grn_source_column_geo) {
+ GRN_GEO_POINT_SET(ctx, &source_point, latitude, longitude);
+ }
+ memset(wkb, 0, SRID_SIZE);
+ memset(wkb + SRID_SIZE, Geometry::wkb_ndr, 1); // wkb_ndr is meaningless.
+ int4store(wkb + SRID_SIZE + 1, Geometry::wkb_point);
+ double latitude_in_degree, longitude_in_degree;
+ latitude_in_degree = GRN_GEO_MSEC2DEGREE(latitude);
+ longitude_in_degree = GRN_GEO_MSEC2DEGREE(longitude);
+ float8store(wkb + SRID_SIZE + WKB_HEADER_SIZE,
+ longitude_in_degree);
+ float8store(wkb + SRID_SIZE + WKB_HEADER_SIZE + SIZEOF_STORED_DOUBLE,
+ latitude_in_degree);
+ String *geometry_buffer = &blob_buffers[field->field_index];
+ geometry_buffer->length(0);
+ uint wkb_length = sizeof(wkb) / sizeof(*wkb);
+ Field_blob *geometry= (Field_blob *)field;
+ geometry_buffer->reserve(wkb_length);
+ geometry_buffer->q_append((const char *) wkb, wkb_length);
+ geometry->set_ptr((uint32) wkb_length, (uchar *) geometry_buffer->ptr());
+#endif
+ DBUG_VOID_RETURN;
+}
+
+#ifdef MRN_HAVE_MYSQL_TYPE_JSON
+void ha_mroonga::storage_store_field_json(Field *field,
+ const char *value,
+ uint value_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ Field_json *json = static_cast<Field_json *>(field);
+ json->store(value, value_length, field->charset());
+ DBUG_VOID_RETURN;
+}
+#endif
+
+void ha_mroonga::storage_store_field(Field *field,
+ const char *value, uint value_length)
+{
+ field->set_notnull();
+ switch (field->real_type()) {
+ case MYSQL_TYPE_DECIMAL:
+ storage_store_field_string(field, value, value_length);
+ break;
+ case MYSQL_TYPE_TINY:
+ case MYSQL_TYPE_SHORT:
+ case MYSQL_TYPE_LONG:
+ storage_store_field_integer(field, value, value_length);
+ break;
+ case MYSQL_TYPE_FLOAT:
+ case MYSQL_TYPE_DOUBLE:
+ storage_store_field_float(field, value, value_length);
+ break;
+ case MYSQL_TYPE_NULL:
+ storage_store_field_unsigned_integer(field, value, value_length);
+ break;
+ case MYSQL_TYPE_TIMESTAMP:
+ storage_store_field_timestamp(field, value, value_length);
+ break;
+ case MYSQL_TYPE_LONGLONG:
+ case MYSQL_TYPE_INT24:
+ storage_store_field_integer(field, value, value_length);
+ break;
+ case MYSQL_TYPE_DATE:
+ storage_store_field_date(field, value, value_length);
+ break;
+ case MYSQL_TYPE_TIME:
+ storage_store_field_time(field, value, value_length);
+ break;
+ case MYSQL_TYPE_DATETIME:
+ storage_store_field_datetime(field, value, value_length);
+ break;
+ case MYSQL_TYPE_YEAR:
+ storage_store_field_year(field, value, value_length);
+ break;
+ case MYSQL_TYPE_NEWDATE:
+ storage_store_field_new_date(field, value, value_length);
+ break;
+ case MYSQL_TYPE_VARCHAR:
+ storage_store_field_string(field, value, value_length);
+ break;
+ case MYSQL_TYPE_BIT:
+ storage_store_field_unsigned_integer(field, value, value_length);
+ break;
+#ifdef MRN_HAVE_MYSQL_TYPE_TIMESTAMP2
+ case MYSQL_TYPE_TIMESTAMP2:
+ storage_store_field_timestamp(field, value, value_length);
+ break;
+#endif
+#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2
+ case MYSQL_TYPE_DATETIME2:
+ storage_store_field_datetime2(field, value, value_length);
+ break;
+#endif
+#ifdef MRN_HAVE_MYSQL_TYPE_TIME2
+ case MYSQL_TYPE_TIME2:
+ storage_store_field_time2(field, value, value_length);
+ break;
+#endif
+ case MYSQL_TYPE_NEWDECIMAL:
+ storage_store_field_string(field, value, value_length);
+ break;
+ case MYSQL_TYPE_ENUM:
+ case MYSQL_TYPE_SET:
+ storage_store_field_unsigned_integer(field, value, value_length);
+ break;
+ case MYSQL_TYPE_TINY_BLOB:
+ case MYSQL_TYPE_MEDIUM_BLOB:
+ case MYSQL_TYPE_LONG_BLOB:
+ case MYSQL_TYPE_BLOB:
+ storage_store_field_blob(field, value, value_length);
+ break;
+ case MYSQL_TYPE_VAR_STRING:
+ case MYSQL_TYPE_STRING:
+ storage_store_field_string(field, value, value_length);
+ break;
+ case MYSQL_TYPE_GEOMETRY:
+ storage_store_field_geometry(field, value, value_length);
+ break;
+ case MYSQL_TYPE_VARCHAR_COMPRESSED:
+ case MYSQL_TYPE_BLOB_COMPRESSED:
+ DBUG_ASSERT(0);
+#ifdef MRN_HAVE_MYSQL_TYPE_JSON
+ case MYSQL_TYPE_JSON:
+ storage_store_field_json(field, value, value_length);
+ break;
+#endif
+ }
+}
+
+void ha_mroonga::storage_store_field_column(Field *field, bool is_primary_key,
+ int nth_column, grn_id record_id)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ if (!grn_columns[nth_column]) {
+ DBUG_VOID_RETURN;
+ }
+
+ grn_obj *column = grn_columns[nth_column];
+ grn_id range_id = grn_obj_get_range(ctx, column);
+ grn_obj *range = grn_column_ranges[nth_column];
+ grn_obj *value = &new_value_buffer;
+
+ if (mrn::grn::is_table(range)) {
+ if (mrn::grn::is_vector_column(column)) {
+ grn_obj_reinit(ctx, value, range_id, GRN_OBJ_VECTOR);
+ grn_obj_get_value(ctx, column, record_id, value);
+
+ grn_obj unvectored_value;
+ GRN_TEXT_INIT(&unvectored_value, 0);
+ int n_ids = GRN_BULK_VSIZE(value) / sizeof(grn_id);
+ for (int i = 0; i < n_ids; i++) {
+ grn_id id = GRN_RECORD_VALUE_AT(value, i);
+ if (i > 0) {
+ GRN_TEXT_PUTS(ctx, &unvectored_value, mrn_vector_column_delimiter);
+ }
+ char key[GRN_TABLE_MAX_KEY_SIZE];
+ int key_length;
+ key_length = grn_table_get_key(ctx, range, id,
+ &key, GRN_TABLE_MAX_KEY_SIZE);
+ GRN_TEXT_PUT(ctx, &unvectored_value, key, key_length);
+ }
+ storage_store_field(field,
+ GRN_TEXT_VALUE(&unvectored_value),
+ GRN_TEXT_LEN(&unvectored_value));
+ GRN_OBJ_FIN(ctx, &unvectored_value);
+ } else {
+ grn_obj_reinit(ctx, value, range_id, 0);
+ grn_obj_get_value(ctx, column, record_id, value);
+
+ grn_id id = GRN_RECORD_VALUE(value);
+ char key[GRN_TABLE_MAX_KEY_SIZE];
+ int key_length;
+ key_length = grn_table_get_key(ctx, range, id,
+ &key, GRN_TABLE_MAX_KEY_SIZE);
+ storage_store_field(field, key, key_length);
+ }
+ } else {
+ grn_obj_reinit(ctx, value, range_id, 0);
+ grn_obj_get_value(ctx, column, record_id, value);
+ if (is_primary_key && GRN_BULK_VSIZE(value) == 0) {
+ char key[GRN_TABLE_MAX_KEY_SIZE];
+ int key_length;
+ key_length = grn_table_get_key(ctx, grn_table, record_id,
+ &key, GRN_TABLE_MAX_KEY_SIZE);
+ storage_store_field(field, key, key_length);
+ } else {
+ storage_store_field(field, GRN_BULK_HEAD(value), GRN_BULK_VSIZE(value));
+ }
+ }
+
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_fields(uchar *buf, grn_id record_id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_PRINT("info", ("mroonga: stored record ID: %d", record_id));
+
+ my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
+
+ Field *primary_key_field = NULL;
+ if (table->s->primary_key != MAX_INDEXES) {
+ KEY *key_info = &(table->s->key_info[table->s->primary_key]);
+ if (KEY_N_KEY_PARTS(key_info) == 1) {
+ primary_key_field = key_info->key_part[0].field;
+ }
+ }
+
+ int i;
+ int n_columns = table->s->fields;
+ for (i = 0; i < n_columns; i++) {
+ Field *field = table->field[i];
+
+ if (bitmap_is_set(table->read_set, field->field_index) ||
+ bitmap_is_set(table->write_set, field->field_index)) {
+ const char *column_name = field->field_name.str;
+
+ if (ignoring_no_key_columns) {
+ KEY *key_info = &(table->s->key_info[active_index]);
+ if (strcmp(key_info->key_part[0].field->field_name.str, column_name)) {
+ continue;
+ }
+ }
+
+ mrn::DebugColumnAccess debug_column_access(table, &table->write_set);
+ DBUG_PRINT("info", ("mroonga: store column %d(%d)",i,field->field_index));
+ field->move_field_offset(ptr_diff);
+ if (strcmp(MRN_COLUMN_NAME_ID, column_name) == 0) {
+ // for _id column
+ field->set_notnull();
+ field->store((int)record_id);
+ } else if (primary_key_field &&
+ strcmp(primary_key_field->field_name.str, column_name) == 0) {
+ // for primary key column
+ storage_store_field_column(field, true, i, record_id);
+ } else {
+ storage_store_field_column(field, false, i, record_id);
+ }
+ field->move_field_offset(-ptr_diff);
+ }
+ }
+
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_fields_for_prep_update(const uchar *old_data,
+ const uchar *new_data,
+ grn_id record_id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_PRINT("info", ("mroonga: stored record ID: %d", record_id));
+ my_ptrdiff_t ptr_diff_old = PTR_BYTE_DIFF(old_data, table->record[0]);
+ my_ptrdiff_t ptr_diff_new = 0;
+#ifdef MRN_RBR_UPDATE_NEED_ALL_COLUMNS
+ if (!written_by_row_based_binlog) {
+ if (check_written_by_row_based_binlog()) {
+ written_by_row_based_binlog = 2;
+ } else {
+ written_by_row_based_binlog = 1;
+ }
+ }
+ bool need_all_columns =
+ (new_data && written_by_row_based_binlog == 2);
+#endif
+ if (new_data) {
+ ptr_diff_new = PTR_BYTE_DIFF(new_data, table->record[0]);
+ }
+ int i;
+ int n_columns = table->s->fields;
+ for (i = 0; i < n_columns; i++) {
+ Field *field = table->field[i];
+
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ continue;
+ }
+#endif
+ if (
+ !bitmap_is_set(table->read_set, field->field_index) &&
+ !bitmap_is_set(table->write_set, field->field_index) &&
+#ifdef MRN_RBR_UPDATE_NEED_ALL_COLUMNS
+ (
+ need_all_columns ||
+#endif
+ bitmap_is_set(&multiple_column_key_bitmap, field->field_index)
+#ifdef MRN_RBR_UPDATE_NEED_ALL_COLUMNS
+ )
+#endif
+ ) {
+ mrn::DebugColumnAccess debug_column_access(table, &table->write_set);
+ DBUG_PRINT("info", ("mroonga: store column %d(%d)",i,field->field_index));
+ grn_obj value;
+ GRN_OBJ_INIT(&value, GRN_BULK, 0, grn_obj_get_range(ctx, grn_columns[i]));
+ grn_obj_get_value(ctx, grn_columns[i], record_id, &value);
+ // old column
+ field->move_field_offset(ptr_diff_old);
+ storage_store_field(field, GRN_BULK_HEAD(&value), GRN_BULK_VSIZE(&value));
+ field->move_field_offset(-ptr_diff_old);
+ if (new_data) {
+ // new column
+ field->move_field_offset(ptr_diff_new);
+ storage_store_field(field, GRN_BULK_HEAD(&value), GRN_BULK_VSIZE(&value));
+ field->move_field_offset(-ptr_diff_new);
+ }
+ GRN_OBJ_FIN(ctx, &value);
+ }
+ }
+
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_store_fields_by_index(uchar *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint key_length;
+ void *key;
+ KEY *key_info = &table->key_info[active_index];
+ if (table->s->primary_key == active_index)
+ key_length = grn_table_cursor_get_key(ctx, cursor, &key);
+ else
+ key_length = grn_table_cursor_get_key(ctx, index_table_cursor, &key);
+
+ if (KEY_N_KEY_PARTS(key_info) == 1) {
+ my_ptrdiff_t ptr_diff = PTR_BYTE_DIFF(buf, table->record[0]);
+ Field *field = key_info->key_part->field;
+ mrn::DebugColumnAccess debug_column_access(table, &table->write_set);
+ field->move_field_offset(ptr_diff);
+ storage_store_field(field, (const char *)key, key_length);
+ field->move_field_offset(-ptr_diff);
+ } else {
+ uchar enc_buf[MAX_KEY_LENGTH];
+ uint enc_len;
+ mrn::MultipleColumnKeyCodec codec(ctx, ha_thd(), key_info);
+ codec.decode(static_cast<uchar *>(key), key_length, enc_buf, &enc_len);
+ key_restore(buf, enc_buf, key_info, enc_len);
+ }
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::storage_encode_key_normalize_min_sort_chars(Field *field,
+ uchar *buf,
+ uint size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ if (size == 0) {
+ DBUG_RETURN(0);
+ }
+ if (!field->has_charset()) {
+ DBUG_RETURN(0);
+ }
+
+ uint16 raw_min_sort_char =
+ static_cast<uint16>(field->sort_charset()->min_sort_char);
+ if (raw_min_sort_char <= UINT_MAX8) {
+ uchar min_sort_char = static_cast<uchar>(raw_min_sort_char);
+ for (uint i = size - 1; i > 0; --i) {
+ if (buf[i] != min_sort_char) {
+ break;
+ }
+ buf[i] = '\0';
+ }
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_key_fixed_size_string(Field *field,
+ const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ memcpy(buf, key, field->field_length);
+ *size = field->field_length;
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_key_variable_size_string(Field *field,
+ const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ *size = uint2korr(key);
+ memcpy(buf, key + HA_KEY_BLOB_LENGTH, *size);
+ storage_encode_key_normalize_min_sort_chars(field, buf, *size);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_key_timestamp(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ long long int time;
+ MYSQL_TIME mysql_time;
+#ifdef MRN_MARIADB_P
+ if (field->decimals() == 0) {
+ my_time_t my_time = sint4korr(key);
+ mrn_my_tz_UTC->gmt_sec_to_TIME(&mysql_time, my_time);
+ mysql_time.second_part = 0;
+ } else {
+ Field_timestamp_hires *timestamp_hires_field =
+ (Field_timestamp_hires *)field;
+ uchar *ptr_backup = field->ptr;
+ uchar *null_ptr_backup = field->null_ptr;
+ TABLE *table_backup = field->table;
+ field->ptr = (uchar *)key;
+ field->null_ptr = (uchar *)(key - 1);
+ field->table = table;
+ Temporal::Options opt(TIME_CONV_NONE, current_thd);
+ timestamp_hires_field->get_date(&mysql_time, opt);
+ field->ptr = ptr_backup;
+ field->null_ptr = null_ptr_backup;
+ field->table = table_backup;
+ }
+#else
+ my_time_t my_time = uint4korr(key);
+ mrn_my_tz_UTC->gmt_sec_to_TIME(&mysql_time, my_time);
+#endif
+ mrn::TimeConverter time_converter;
+ time = time_converter.mysql_time_to_grn_time(&mysql_time, &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ memcpy(buf, &time, 8);
+ *size = 8;
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_key_time(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ long long int time;
+#ifdef MRN_MARIADB_P
+ MYSQL_TIME mysql_time;
+ bool truncated = false;
+ if (field->decimals() == 0) {
+ long long int packed_time = sint3korr(key);
+ mysql_time.neg = false;
+ if (packed_time < 0) {
+ mysql_time.neg = true;
+ packed_time = -packed_time;
+ }
+ mysql_time.year = 0;
+ mysql_time.month = 0;
+ mysql_time.day = 0;
+ mysql_time.hour = (int)(packed_time / 10000);
+ long long int minute_part = packed_time - mysql_time.hour * 10000;
+ mysql_time.minute = (int)(minute_part / 100);
+ mysql_time.second = (int)(minute_part % 100);
+ mysql_time.second_part = 0;
+ mysql_time.time_type = MYSQL_TIMESTAMP_TIME;
+ } else {
+ Field_time_hires *time_hires_field = (Field_time_hires *)field;
+ uchar *ptr_backup = field->ptr;
+ uchar *null_ptr_backup = field->null_ptr;
+ field->ptr = (uchar *)key;
+ field->null_ptr = (uchar *)(key - 1);
+ Temporal::Options opt(TIME_CONV_NONE, current_thd);
+ time_hires_field->get_date(&mysql_time, opt);
+ field->ptr = ptr_backup;
+ field->null_ptr = null_ptr_backup;
+ }
+ mrn::TimeConverter time_converter;
+ time = time_converter.mysql_time_to_grn_time(&mysql_time, &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+#else
+ int mysql_time = (int)sint3korr(key);
+ int sec =
+ mysql_time / 10000 * 60 * 60 +
+ mysql_time / 100 % 100 * 60 +
+ mysql_time % 60;
+ int usec = 0;
+ time = GRN_TIME_PACK(sec, usec);
+#endif
+ memcpy(buf, &time, 8);
+ *size = 8;
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_key_year(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ int year = (int)key[0];
+
+ struct tm datetime;
+ memset(&datetime, 0, sizeof(struct tm));
+ datetime.tm_year = year;
+ datetime.tm_mon = 0;
+ datetime.tm_mday = 1;
+ int usec = 0;
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.tm_to_grn_time(&datetime, usec,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ memcpy(buf, &time, 8);
+ *size = 8;
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_key_datetime(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+ long long int time;
+#ifdef MRN_MARIADB_P
+ if (field->decimals() > 0) {
+ Field_datetime_hires *datetime_hires_field = (Field_datetime_hires *)field;
+ MYSQL_TIME mysql_time;
+ uchar *ptr_backup = field->ptr;
+ uchar *null_ptr_backup = field->null_ptr;
+ field->ptr = (uchar *)key;
+ field->null_ptr = (uchar *)(key - 1);
+ Temporal::Options opt(TIME_CONV_NONE, current_thd);
+ datetime_hires_field->get_date(&mysql_time, opt);
+ field->ptr = ptr_backup;
+ field->null_ptr = null_ptr_backup;
+ mrn::TimeConverter time_converter;
+ time = time_converter.mysql_time_to_grn_time(&mysql_time, &truncated);
+ } else
+#endif
+ {
+ long long int encoded_datetime = sint8korr(key);
+ uint32 part1 = (uint32)(encoded_datetime / 1000000LL);
+ uint32 part2 = (uint32)(encoded_datetime -
+ (unsigned long long int)part1 * 1000000LL);
+ struct tm date;
+ memset(&date, 0, sizeof(struct tm));
+ date.tm_year = part1 / 10000 - mrn::TimeConverter::TM_YEAR_BASE;
+ date.tm_mon = part1 / 100 % 100 - 1;
+ date.tm_mday = part1 % 100;
+ date.tm_hour = part2 / 10000;
+ date.tm_min = part2 / 100 % 100;
+ date.tm_sec = part2 % 100;
+ int usec = 0;
+ mrn::TimeConverter time_converter;
+ time = time_converter.tm_to_grn_time(&date, usec, &truncated);
+ }
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ memcpy(buf, &time, 8);
+ *size = 8;
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_HAVE_MYSQL_TYPE_TIMESTAMP2
+int ha_mroonga::storage_encode_key_timestamp2(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+
+ Field_timestampf *timestamp2_field = (Field_timestampf *)field;
+ struct timeval tm;
+ my_timestamp_from_binary(&tm, key, timestamp2_field->decimals());
+ MYSQL_TIME mysql_time;
+ mrn_my_tz_UTC->gmt_sec_to_TIME(&mysql_time, (my_time_t)tm.tv_sec);
+ mysql_time.second_part = tm.tv_usec;
+ mrn::TimeConverter time_converter;
+ long long int grn_time = time_converter.mysql_time_to_grn_time(&mysql_time,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ memcpy(buf, &grn_time, 8);
+ *size = 8;
+
+ DBUG_RETURN(error);
+}
+#endif
+
+#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2
+int ha_mroonga::storage_encode_key_datetime2(Field *field, bool is_null,
+ const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+
+ Field_datetimef *datetime2_field = (Field_datetimef *)field;
+ longlong packed_time = is_null ? 0 :
+ my_datetime_packed_from_binary(key, datetime2_field->decimals());
+ MYSQL_TIME mysql_time;
+ TIME_from_longlong_datetime_packed(&mysql_time, packed_time);
+ mrn::TimeConverter time_converter;
+ long long int grn_time = time_converter.mysql_time_to_grn_time(&mysql_time,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ memcpy(buf, &grn_time, 8);
+ *size = 8;
+
+ DBUG_RETURN(error);
+}
+#endif
+
+#ifdef MRN_HAVE_MYSQL_TYPE_TIME2
+int ha_mroonga::storage_encode_key_time2(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ bool truncated = false;
+
+ Field_timef *time2_field = (Field_timef *)field;
+ longlong packed_time =
+ my_time_packed_from_binary(key, time2_field->decimals());
+ MYSQL_TIME mysql_time;
+ TIME_from_longlong_time_packed(&mysql_time, packed_time);
+ mrn::TimeConverter time_converter;
+ long long int grn_time = time_converter.mysql_time_to_grn_time(&mysql_time,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ memcpy(buf, &grn_time, 8);
+ *size = 8;
+
+ DBUG_RETURN(error);
+}
+#endif
+
+int ha_mroonga::storage_encode_key_enum(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (field->pack_length() == 1) {
+ uchar value;
+ value = key[0];
+ *size = 1;
+ memcpy(buf, &value, *size);
+ } else {
+ uint16 value;
+ mrn::value_decoder::decode(&value, key);
+ *size = 2;
+ memcpy(buf, &value, *size);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_key_set(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ Field_set unpacker((uchar *)key, field->field_length, (uchar *)(key - 1),
+ field->null_bit, field->unireg_check,
+ &field->field_name,
+ field->pack_length(),
+ static_cast<Field_set*>(field)->typelib,
+ static_cast<Field_set*>(field)->charset());
+ switch (field->pack_length()) {
+ case 1:
+ {
+ int8 signed_value = (int8)(unpacker.val_int());
+ uint8 unsigned_value = *((uint8 *)&signed_value);
+ *size = 1;
+ memcpy(buf, &unsigned_value, *size);
+ }
+ break;
+ case 2:
+ {
+ int16 signed_value = (int16)(unpacker.val_int());
+ uint16 unsigned_value = *((uint16 *)&signed_value);
+ *size = 2;
+ memcpy(buf, &unsigned_value, *size);
+ }
+ break;
+ case 3:
+ case 4:
+ {
+ int32 signed_value = (int32)(unpacker.val_int());
+ uint32 unsigned_value = *((uint32 *)&signed_value);
+ *size = 4;
+ memcpy(buf, &unsigned_value, *size);
+ }
+ break;
+ case 8:
+ default:
+ {
+ int64 signed_value = (int64)(unpacker.val_int());
+ uint64 unsigned_value = *((uint64 *)&signed_value);
+ *size = 8;
+ memcpy(buf, &unsigned_value, *size);
+ }
+ break;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_key(Field *field, const uchar *key,
+ uchar *buf, uint *size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+ bool truncated = false;
+ bool is_null = false;
+ const uchar *ptr = key;
+
+ error = mrn_change_encoding(ctx, field->charset());
+ if (error)
+ DBUG_RETURN(error);
+
+ if (field->null_bit) {
+ is_null = *ptr;
+ ptr += 1;
+ }
+
+ switch (field->real_type()) {
+ case MYSQL_TYPE_BIT:
+ case MYSQL_TYPE_TINY:
+ {
+ memcpy(buf, ptr, 1);
+ *size = 1;
+ break;
+ }
+ case MYSQL_TYPE_SHORT:
+ {
+ memcpy(buf, ptr, 2);
+ *size = 2;
+ break;
+ }
+ case MYSQL_TYPE_INT24:
+ {
+ memcpy(buf, ptr, 3);
+ buf[3] = 0;
+ *size = 4;
+ break;
+ }
+ case MYSQL_TYPE_LONG:
+ {
+ memcpy(buf, ptr, 4);
+ *size = 4;
+ break;
+ }
+ case MYSQL_TYPE_TIMESTAMP:
+ error = storage_encode_key_timestamp(field, ptr, buf, size);
+ break;
+ case MYSQL_TYPE_LONGLONG:
+ {
+ memcpy(buf, ptr, 8);
+ *size = 8;
+ break;
+ }
+ case MYSQL_TYPE_FLOAT:
+ {
+ float float_value;
+ double double_value;
+ mrn::value_decoder::decode(&float_value, ptr);
+ double_value = float_value;
+ memcpy(buf, &double_value, 8);
+ *size = 8;
+ break;
+ }
+ case MYSQL_TYPE_DOUBLE:
+ {
+ double val;
+ mrn::value_decoder::decode(&val, ptr);
+ memcpy(buf, &val, 8);
+ *size = 8;
+ break;
+ }
+ case MYSQL_TYPE_TIME:
+ error = storage_encode_key_time(field, ptr, buf, size);
+ break;
+ case MYSQL_TYPE_YEAR:
+ error = storage_encode_key_year(field, ptr, buf, size);
+ break;
+ case MYSQL_TYPE_DATETIME:
+ error = storage_encode_key_datetime(field, ptr, buf, size);
+ break;
+ case MYSQL_TYPE_NEWDATE:
+ {
+ uint32 encoded_date = uint3korr(ptr);
+ struct tm date;
+ memset(&date, 0, sizeof(struct tm));
+ date.tm_year = encoded_date / (16 * 32) - mrn::TimeConverter::TM_YEAR_BASE;
+ date.tm_mon = encoded_date / 32 % 16 - 1;
+ date.tm_mday = encoded_date % 32;
+ int usec = 0;
+ mrn::TimeConverter time_converter;
+ long long int time = time_converter.tm_to_grn_time(&date, usec,
+ &truncated);
+ if (truncated) {
+ if (MRN_ABORT_ON_WARNING(ha_thd())) {
+ error = MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd());
+ }
+ field->set_warning(MRN_SEVERITY_WARNING,
+ MRN_ERROR_CODE_DATA_TRUNCATE(ha_thd()),
+ 1);
+ }
+ memcpy(buf, &time, 8);
+ *size = 8;
+ break;
+ }
+#ifdef MRN_HAVE_MYSQL_TYPE_TIMESTAMP2
+ case MYSQL_TYPE_TIMESTAMP2:
+ error = storage_encode_key_timestamp2(field, ptr, buf, size);
+ break;
+#endif
+#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2
+ case MYSQL_TYPE_DATETIME2:
+ error = storage_encode_key_datetime2(field, is_null, ptr, buf, size);
+ break;
+#endif
+#ifdef MRN_HAVE_MYSQL_TYPE_TIME2
+ case MYSQL_TYPE_TIME2:
+ error = storage_encode_key_time2(field, ptr, buf, size);
+ break;
+#endif
+ case MYSQL_TYPE_STRING:
+ error = storage_encode_key_fixed_size_string(field, ptr, buf, size);
+ break;
+ case MYSQL_TYPE_VARCHAR:
+ case MYSQL_TYPE_BLOB:
+ error = storage_encode_key_variable_size_string(field, ptr, buf, size);
+ break;
+ case MYSQL_TYPE_ENUM:
+ error = storage_encode_key_enum(field, ptr, buf, size);
+ break;
+ case MYSQL_TYPE_SET:
+ error = storage_encode_key_set(field, ptr, buf, size);
+ break;
+ default:
+ error = HA_ERR_UNSUPPORTED;
+ break;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_multiple_column_key(KEY *key_info,
+ const uchar *key,
+ uint key_length,
+ uchar *buffer,
+ uint *encoded_length)
+{
+ MRN_DBUG_ENTER_METHOD();
+ mrn::MultipleColumnKeyCodec codec(ctx, ha_thd(), key_info);
+ int error = codec.encode(key, key_length, buffer, encoded_length);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_multiple_column_key_range(KEY *key_info,
+ const uchar *start,
+ uint start_size,
+ const uchar *end,
+ uint end_size,
+ uchar *min_buffer,
+ uint *min_encoded_size,
+ uchar *max_buffer,
+ uint *max_encoded_size)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ mrn::MultipleColumnKeyCodec codec(ctx, ha_thd(), key_info);
+ uint encoded_key_size = codec.size();
+ if (start) {
+ memset(min_buffer, 0, encoded_key_size);
+ error = codec.encode(start, start_size,
+ min_buffer, min_encoded_size);
+ // TODO: handle error?
+ *min_encoded_size = encoded_key_size;
+ }
+ if (end) {
+ memset(max_buffer, 0xff, encoded_key_size);
+ error = codec.encode(end, end_size,
+ max_buffer, max_encoded_size);
+ // TODO: handle error?
+ *max_encoded_size = encoded_key_size;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_encode_multiple_column_key_range(KEY *key_info,
+ const key_range *start,
+ const key_range *end,
+ uchar *min_buffer,
+ uint *min_encoded_size,
+ uchar *max_buffer,
+ uint *max_encoded_size)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ const uchar *start_data = NULL;
+ uint start_size = 0;
+ const uchar *end_data = NULL;
+ uint end_size = 0;
+ if (start) {
+ start_data = start->key;
+ start_size = start->length;
+ }
+ if (end) {
+ end_data = end->key;
+ end_size = end->length;
+ }
+
+ int error = storage_encode_multiple_column_key_range(key_info,
+ start_data, start_size,
+ end_data, end_size,
+ min_buffer,
+ min_encoded_size,
+ max_buffer,
+ max_encoded_size);
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_reset()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ if (thd_sql_command(ha_thd()) != SQLCOM_SELECT) {
+ DBUG_RETURN(error);
+ }
+
+ TABLE_LIST *table_list = table->pos_in_table_list;
+ if (!table_list) {
+ DBUG_RETURN(error);
+ }
+
+ st_select_lex *select_lex = table_list->select_lex;
+ if (!select_lex) {
+ DBUG_RETURN(error);
+ }
+
+ List_iterator<Item_func_match> iterator(*(select_lex->ftfunc_list));
+ Item_func_match *item;
+ while ((item = iterator++)) {
+ if (item->ft_handler) {
+ mrn_generic_ft_clear(item->ft_handler);
+ }
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_reset()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_reset();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER
+ if (alter_key_info_buffer) {
+ my_free(alter_key_info_buffer);
+ alter_key_info_buffer = NULL;
+ }
+#else
+ if (wrap_alter_key_info) {
+ my_free(wrap_alter_key_info);
+ wrap_alter_key_info = NULL;
+ }
+#endif
+ wrap_ft_init_count = 0;
+ int generic_error = generic_reset();
+ if (error == 0) {
+ error = generic_error;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_reset()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+ error = generic_reset();
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::reset()
+{
+ int error = 0;
+ THD *thd = ha_thd();
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_PRINT("info", ("mroonga: this=%p", this));
+ clear_empty_value_records();
+ clear_search_result();
+ clear_search_result_geo();
+ if (share->wrapper_mode)
+ error = wrapper_reset();
+ else
+ error = storage_reset();
+ ignoring_no_key_columns = false;
+ inserting_with_update = false;
+ ignoring_duplicated_key = false;
+ fulltext_searching = false;
+ replacing_ = false;
+ written_by_row_based_binlog = 0;
+ mrn_lock_type = F_UNLCK;
+ mrn_clear_slot_data(thd);
+ current_ft_item = NULL;
+ DBUG_RETURN(error);
+}
+
+handler *ha_mroonga::wrapper_clone(const char *name, MEM_ROOT *mem_root)
+{
+ handler *cloned_handler;
+ MRN_DBUG_ENTER_METHOD();
+ if (!(cloned_handler = get_new_handler(table->s, mem_root,
+ table->s->db_type())))
+ DBUG_RETURN(NULL);
+ ((ha_mroonga *) cloned_handler)->is_clone = true;
+ ((ha_mroonga *) cloned_handler)->parent_for_clone = this;
+ ((ha_mroonga *) cloned_handler)->mem_root_for_clone = mem_root;
+ if (cloned_handler->ha_open(table, table->s->normalized_path.str,
+ table->db_stat, HA_OPEN_IGNORE_IF_LOCKED))
+ {
+ delete cloned_handler;
+ DBUG_RETURN(NULL);
+ }
+ DBUG_RETURN(cloned_handler);
+}
+
+handler *ha_mroonga::storage_clone(const char *name, MEM_ROOT *mem_root)
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler *cloned_handler;
+ cloned_handler = handler::clone(name, mem_root);
+ DBUG_RETURN(cloned_handler);
+}
+
+handler *ha_mroonga::clone(const char *name, MEM_ROOT *mem_root)
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler *cloned_handler;
+ if (share->wrapper_mode)
+ {
+ cloned_handler = wrapper_clone(name, mem_root);
+ } else {
+ cloned_handler = storage_clone(name, mem_root);
+ }
+ DBUG_RETURN(cloned_handler);
+}
+
+uint8 ha_mroonga::wrapper_table_cache_type()
+{
+ uint8 res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->table_cache_type();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+uint8 ha_mroonga::storage_table_cache_type()
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint8 type = handler::table_cache_type();
+ DBUG_RETURN(type);
+}
+
+uint8 ha_mroonga::table_cache_type()
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint8 type;
+ if (share->wrapper_mode)
+ {
+ type = wrapper_table_cache_type();
+ } else {
+ type = storage_table_cache_type();
+ }
+ DBUG_RETURN(type);
+}
+
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ
+ha_rows ha_mroonga::wrapper_multi_range_read_info_const(uint keyno,
+ RANGE_SEQ_IF *seq,
+ void *seq_init_param,
+ uint n_ranges,
+ uint *bufsz,
+ uint *flags,
+ Cost_estimate *cost)
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows rows;
+ KEY *key_info = &(table->key_info[keyno]);
+ if (mrn_is_geo_key(key_info)) {
+ rows = handler::multi_range_read_info_const(keyno, seq, seq_init_param,
+ n_ranges, bufsz, flags, cost);
+ DBUG_RETURN(rows);
+ }
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+ rows = wrap_handler->multi_range_read_info_const(keyno, seq, seq_init_param,
+ n_ranges, bufsz, flags,
+ cost);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(rows);
+}
+
+ha_rows ha_mroonga::storage_multi_range_read_info_const(uint keyno,
+ RANGE_SEQ_IF *seq,
+ void *seq_init_param,
+ uint n_ranges,
+ uint *bufsz,
+ uint *flags,
+ Cost_estimate *cost)
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows rows = handler::multi_range_read_info_const(keyno, seq,
+ seq_init_param,
+ n_ranges, bufsz, flags,
+ cost);
+ DBUG_RETURN(rows);
+}
+
+ha_rows ha_mroonga::multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq,
+ void *seq_init_param,
+ uint n_ranges, uint *bufsz,
+ uint *flags,
+ Cost_estimate *cost)
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows rows;
+ if (share->wrapper_mode)
+ {
+ rows = wrapper_multi_range_read_info_const(keyno, seq, seq_init_param,
+ n_ranges, bufsz,
+ flags, cost);
+ } else {
+ rows = storage_multi_range_read_info_const(keyno, seq, seq_init_param,
+ n_ranges, bufsz,
+ flags, cost);
+ }
+ DBUG_RETURN(rows);
+}
+
+ha_rows ha_mroonga::wrapper_multi_range_read_info(uint keyno, uint n_ranges,
+ uint keys,
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS
+ uint key_parts,
+#endif
+ uint *bufsz,
+ uint *flags,
+ Cost_estimate *cost)
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows rows;
+ KEY *key_info = &(table->key_info[keyno]);
+ if (mrn_is_geo_key(key_info)) {
+ rows = handler::multi_range_read_info(keyno, n_ranges, keys,
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS
+ key_parts,
+#endif
+ bufsz, flags, cost);
+ DBUG_RETURN(rows);
+ }
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+ rows = wrap_handler->multi_range_read_info(keyno, n_ranges, keys,
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS
+ key_parts,
+#endif
+ bufsz, flags, cost);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(rows);
+}
+
+ha_rows ha_mroonga::storage_multi_range_read_info(uint keyno, uint n_ranges,
+ uint keys,
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS
+ uint key_parts,
+#endif
+ uint *bufsz,
+ uint *flags,
+ Cost_estimate *cost)
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows rows = handler::multi_range_read_info(keyno, n_ranges, keys,
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS
+ key_parts,
+#endif
+ bufsz, flags, cost);
+ DBUG_RETURN(rows);
+}
+
+ha_rows ha_mroonga::multi_range_read_info(uint keyno, uint n_ranges, uint keys,
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS
+ uint key_parts,
+#endif
+ uint *bufsz, uint *flags,
+ Cost_estimate *cost)
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows rows;
+ if (share->wrapper_mode)
+ {
+ rows = wrapper_multi_range_read_info(keyno, n_ranges, keys,
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS
+ key_parts,
+#endif
+ bufsz, flags, cost);
+ } else {
+ rows = storage_multi_range_read_info(keyno, n_ranges, keys,
+#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS
+ key_parts,
+#endif
+ bufsz, flags, cost);
+ }
+ DBUG_RETURN(rows);
+}
+
+int ha_mroonga::wrapper_multi_range_read_init(RANGE_SEQ_IF *seq,
+ void *seq_init_param,
+ uint n_ranges, uint mode,
+ HANDLER_BUFFER *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ KEY *key_info = &(table->key_info[active_index]);
+ if (mrn_is_geo_key(key_info)) {
+ error = handler::multi_range_read_init(seq, seq_init_param,
+ n_ranges, mode, buf);
+ DBUG_RETURN(error);
+ }
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+ error = wrap_handler->multi_range_read_init(seq, seq_init_param,
+ n_ranges, mode, buf);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_multi_range_read_init(RANGE_SEQ_IF *seq,
+ void *seq_init_param,
+ uint n_ranges, uint mode,
+ HANDLER_BUFFER *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = handler::multi_range_read_init(seq, seq_init_param,
+ n_ranges, mode, buf);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
+ uint n_ranges, uint mode,
+ HANDLER_BUFFER *buf)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_multi_range_read_init(seq, seq_init_param,
+ n_ranges, mode, buf);
+ } else {
+ error = storage_multi_range_read_init(seq, seq_init_param,
+ n_ranges, mode, buf);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_multi_range_read_next(range_id_t *range_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ KEY *key_info = &(table->key_info[active_index]);
+ if (mrn_is_geo_key(key_info)) {
+ error = handler::multi_range_read_next(range_info);
+ DBUG_RETURN(error);
+ }
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+ error = wrap_handler->multi_range_read_next(range_info);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_multi_range_read_next(range_id_t *range_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = handler::multi_range_read_next(range_info);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::multi_range_read_next(range_id_t *range_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_multi_range_read_next(range_info);
+ } else {
+ error = storage_multi_range_read_next(range_info);
+ }
+ DBUG_RETURN(error);
+}
+#else // MRN_HANDLER_HAVE_MULTI_RANGE_READ
+int ha_mroonga::wrapper_read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
+ KEY_MULTI_RANGE *ranges,
+ uint range_count,
+ bool sorted,
+ HANDLER_BUFFER *buffer)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ KEY *key_info = &(table->key_info[active_index]);
+ if (mrn_is_geo_key(key_info)) {
+ error = handler::read_multi_range_first(found_range_p, ranges,
+ range_count, sorted, buffer);
+ DBUG_RETURN(error);
+ }
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+ error = wrap_handler->read_multi_range_first(found_range_p, ranges,
+ range_count, sorted, buffer);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
+ KEY_MULTI_RANGE *ranges,
+ uint range_count,
+ bool sorted,
+ HANDLER_BUFFER *buffer)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = handler::read_multi_range_first(found_range_p, ranges,
+ range_count, sorted, buffer);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
+ KEY_MULTI_RANGE *ranges,
+ uint range_count,
+ bool sorted,
+ HANDLER_BUFFER *buffer)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_read_multi_range_first(found_range_p, ranges,
+ range_count, sorted, buffer);
+ } else {
+ error = storage_read_multi_range_first(found_range_p, ranges,
+ range_count, sorted, buffer);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_read_multi_range_next(KEY_MULTI_RANGE **found_range_p)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ KEY *key_info = &(table->key_info[active_index]);
+ if (mrn_is_geo_key(key_info)) {
+ error = handler::read_multi_range_next(found_range_p);
+ DBUG_RETURN(error);
+ }
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ if (fulltext_searching)
+ set_pk_bitmap();
+ error = wrap_handler->read_multi_range_next(found_range_p);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_read_multi_range_next(KEY_MULTI_RANGE **found_range_p)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = handler::read_multi_range_next(found_range_p);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::read_multi_range_next(KEY_MULTI_RANGE **found_range_p)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_read_multi_range_next(found_range_p);
+ } else {
+ error = storage_read_multi_range_next(found_range_p);
+ }
+ DBUG_RETURN(error);
+}
+#endif // MRN_HANDLER_HAVE_MULTI_RANGE_READ
+
+#ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS
+void ha_mroonga::wrapper_start_bulk_insert(ha_rows rows, uint flags)
+#else
+void ha_mroonga::wrapper_start_bulk_insert(ha_rows rows)
+#endif
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+#ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS
+ wrap_handler->ha_start_bulk_insert(rows, flags);
+#else
+ wrap_handler->ha_start_bulk_insert(rows);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+#ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS
+void ha_mroonga::storage_start_bulk_insert(ha_rows rows, uint flags)
+#else
+void ha_mroonga::storage_start_bulk_insert(ha_rows rows)
+#endif
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_VOID_RETURN;
+}
+
+#ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS
+void ha_mroonga::start_bulk_insert(ha_rows rows, uint flags)
+#else
+void ha_mroonga::start_bulk_insert(ha_rows rows)
+#endif
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode) {
+#ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS
+ wrapper_start_bulk_insert(rows, flags);
+#else
+ wrapper_start_bulk_insert(rows);
+#endif
+ } else {
+#ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS
+ storage_start_bulk_insert(rows, flags);
+#else
+ storage_start_bulk_insert(rows);
+#endif
+ }
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::wrapper_end_bulk_insert()
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_end_bulk_insert();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_end_bulk_insert()
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::end_bulk_insert()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_end_bulk_insert();
+ } else {
+ error = storage_end_bulk_insert();
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::generic_delete_all_rows(grn_obj *target_grn_table,
+ const char *function_name)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info",
+ ("mroonga: dry write: %s::%s", MRN_CLASS_NAME, function_name));
+ DBUG_RETURN(error);
+ }
+
+ grn_table_cursor *cursor;
+ cursor = grn_table_cursor_open(ctx, target_grn_table,
+ NULL, 0,
+ NULL, 0,
+ 0, -1,
+ 0);
+ if (cursor) {
+ while (grn_table_cursor_next(ctx, cursor) != GRN_ID_NIL) {
+ grn_table_cursor_delete(ctx, cursor);
+ }
+ grn_table_cursor_close(ctx, cursor);
+ } else {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_delete_all_rows()
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_delete_all_rows();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+
+ if (error) {
+ DBUG_RETURN(error);
+ }
+
+ if (!wrapper_have_target_index()) {
+ DBUG_RETURN(error);
+ }
+
+ uint i;
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ KEY *key_info = &(table->key_info[i]);
+
+ if (!(wrapper_is_target_index(key_info))) {
+ continue;
+ }
+
+ if (!grn_index_tables[i]) {
+ /* disable keys */
+ continue;
+ }
+
+ error = generic_delete_all_rows(grn_index_tables[i], __FUNCTION__);
+ if (error) {
+ break;
+ }
+ }
+
+ int grn_table_error;
+ grn_table_error = generic_delete_all_rows(grn_table, __FUNCTION__);
+ if (!error) {
+ error = grn_table_error;
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_delete_all_rows()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = generic_delete_all_rows(grn_table, __FUNCTION__);
+ if (!error) {
+ uint n_keys = table->s->keys;
+ for (uint i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &(table->key_info[i]);
+ if (!(key_info->flags & HA_NOSAME)) {
+ continue;
+ }
+
+ grn_obj *index_table = grn_index_tables[i];
+ if (!index_table) {
+ continue;
+ }
+
+ error = generic_delete_all_rows(index_table, __FUNCTION__);
+ if (error) {
+ break;
+ }
+ }
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::delete_all_rows()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_delete_all_rows();
+ } else {
+ error = storage_delete_all_rows();
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_truncate()
+{
+ int error = 0;
+ MRN_SHARE *tmp_share;
+ MRN_DBUG_ENTER_METHOD();
+
+ if (!(tmp_share = mrn_get_share(table->s->table_name.str, table, &error)))
+ DBUG_RETURN(error);
+
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = parse_engine_table_options(ha_thd(), tmp_share->hton, table->s)
+ ? MRN_GET_ERROR_NUMBER
+ : wrap_handler->ha_truncate();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+
+ mrn_free_share(tmp_share);
+
+ if (!error && wrapper_have_target_index()) {
+ error = wrapper_truncate_index();
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_truncate_index()
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info",
+ ("mroonga: dry write: %s::%s", MRN_CLASS_NAME, __FUNCTION__));
+ DBUG_RETURN(error);
+ }
+
+ grn_rc rc;
+ uint i;
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ KEY *key_info = &(table->key_info[i]);
+
+ if (!(wrapper_is_target_index(key_info))) {
+ continue;
+ }
+
+ if (!grn_index_tables[i]) {
+ /* disable keys */
+ continue;
+ }
+
+ rc = grn_table_truncate(ctx, grn_index_tables[i]);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto err;
+ }
+ }
+err:
+ rc = grn_table_truncate(ctx, grn_table);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_truncate()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ if (is_dry_write()) {
+ DBUG_PRINT("info", ("mroonga: dry write: ha_mroonga::%s", __FUNCTION__));
+ DBUG_RETURN(error);
+ }
+
+ grn_rc rc;
+ rc = grn_table_truncate(ctx, grn_table);
+ if (rc) {
+ my_message(ER_ERROR_ON_WRITE, ctx->errbuf, MYF(0));
+ DBUG_RETURN(ER_ERROR_ON_WRITE);
+ }
+ error = storage_truncate_index();
+
+ if (!error && thd_sql_command(ha_thd()) == SQLCOM_TRUNCATE) {
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ mrn::Lock lock(&long_term_share->auto_inc_mutex);
+ long_term_share->auto_inc_value = 0;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ long_term_share->auto_inc_inited = false;
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_truncate_index()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ grn_rc rc;
+ uint i;
+ uint n_keys = table->s->keys;
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+
+ KEY *key_info = &(table->key_info[i]);
+
+ if (
+ !(key_info->flags & HA_NOSAME) &&
+ (KEY_N_KEY_PARTS(key_info) == 1 || (key_info->flags & HA_FULLTEXT))
+ ) {
+ continue;
+ }
+
+ if (!grn_index_tables[i]) {
+ /* disable keys */
+ continue;
+ }
+
+ rc = grn_table_truncate(ctx, grn_index_tables[i]);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto err;
+ }
+ }
+err:
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::truncate()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_truncate();
+ } else {
+ error = storage_truncate();
+ }
+ if (!error) {
+ operations_->clear(table->s->table_name.str,
+ table->s->table_name.length);
+ }
+ DBUG_RETURN(error);
+}
+
+double ha_mroonga::wrapper_scan_time()
+{
+ double res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->scan_time();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+double ha_mroonga::storage_scan_time()
+{
+ MRN_DBUG_ENTER_METHOD();
+ double time = handler::scan_time();
+ DBUG_RETURN(time);
+}
+
+double ha_mroonga::scan_time()
+{
+ MRN_DBUG_ENTER_METHOD();
+ double time;
+ if (share->wrapper_mode)
+ {
+ time = wrapper_scan_time();
+ } else {
+ time = storage_scan_time();
+ }
+ DBUG_RETURN(time);
+}
+
+double ha_mroonga::wrapper_read_time(uint index, uint ranges, ha_rows rows)
+{
+ double res;
+ MRN_DBUG_ENTER_METHOD();
+ if (index < MAX_KEY) {
+ KEY *key_info = &(table->key_info[index]);
+ if (mrn_is_geo_key(key_info)) {
+ res = handler::read_time(index, ranges, rows);
+ DBUG_RETURN(res);
+ }
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->read_time(share->wrap_key_nr[index], ranges, rows);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ } else {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->read_time(index, ranges, rows);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ DBUG_RETURN(res);
+}
+
+double ha_mroonga::storage_read_time(uint index, uint ranges, ha_rows rows)
+{
+ MRN_DBUG_ENTER_METHOD();
+ double time = handler::read_time(index, ranges, rows);
+ DBUG_RETURN(time);
+}
+
+double ha_mroonga::read_time(uint index, uint ranges, ha_rows rows)
+{
+ MRN_DBUG_ENTER_METHOD();
+ double time;
+ if (share->wrapper_mode)
+ {
+ time = wrapper_read_time(index, ranges, rows);
+ } else {
+ time = storage_read_time(index, ranges, rows);
+ }
+ DBUG_RETURN(time);
+}
+
+#ifdef MRN_HANDLER_HAVE_KEYS_TO_USE_FOR_SCANNING
+const key_map *ha_mroonga::wrapper_keys_to_use_for_scanning()
+{
+ const key_map *res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->keys_to_use_for_scanning();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+const key_map *ha_mroonga::storage_keys_to_use_for_scanning()
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(&key_map_full);
+}
+
+const key_map *ha_mroonga::keys_to_use_for_scanning()
+{
+ MRN_DBUG_ENTER_METHOD();
+ const key_map *key_map;
+ if (share->wrapper_mode)
+ {
+ key_map = wrapper_keys_to_use_for_scanning();
+ } else {
+ key_map = storage_keys_to_use_for_scanning();
+ }
+ DBUG_RETURN(key_map);
+}
+#endif
+
+ha_rows ha_mroonga::wrapper_estimate_rows_upper_bound()
+{
+ ha_rows res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->estimate_rows_upper_bound();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+ha_rows ha_mroonga::storage_estimate_rows_upper_bound()
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows rows = handler::estimate_rows_upper_bound();
+ DBUG_RETURN(rows);
+}
+
+ha_rows ha_mroonga::estimate_rows_upper_bound()
+{
+ MRN_DBUG_ENTER_METHOD();
+ ha_rows rows;
+ if (share->wrapper_mode)
+ {
+ rows = wrapper_estimate_rows_upper_bound();
+ } else {
+ rows = storage_estimate_rows_upper_bound();
+ }
+ DBUG_RETURN(rows);
+}
+
+void ha_mroonga::wrapper_update_create_info(HA_CREATE_INFO* create_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->update_create_info(create_info);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_update_create_info(HA_CREATE_INFO* create_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::update_create_info(create_info);
+ if (!(create_info->used_fields & HA_CREATE_USED_AUTO)) {
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ if (!long_term_share->auto_inc_inited) {
+ storage_info(HA_STATUS_AUTO);
+ }
+ create_info->auto_increment_value = long_term_share->auto_inc_value;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::update_create_info(HA_CREATE_INFO* create_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (!create_info->connect_string.str)
+ {
+ create_info->connect_string.str = table->s->connect_string.str;
+ create_info->connect_string.length = table->s->connect_string.length;
+ }
+ if (share->wrapper_mode)
+ wrapper_update_create_info(create_info);
+ else
+ storage_update_create_info(create_info);
+ st_mrn_slot_data *slot_data = mrn_get_slot_data(ha_thd(), true);
+ if (slot_data) {
+ slot_data->alter_create_info = create_info;
+ if (slot_data->alter_connect_string) {
+ my_free(slot_data->alter_connect_string);
+ slot_data->alter_connect_string = NULL;
+ }
+ if (create_info->connect_string.str) {
+ slot_data->alter_connect_string =
+ mrn_my_strndup(create_info->connect_string.str,
+ create_info->connect_string.length,
+ MYF(MY_WME));
+ }
+ if (slot_data->alter_comment) {
+ my_free(slot_data->alter_comment);
+ slot_data->alter_comment = NULL;
+ }
+ if (create_info->comment.str) {
+ slot_data->alter_comment =
+ mrn_my_strndup(create_info->comment.str,
+ create_info->comment.length,
+ MYF(MY_WME));
+ }
+ if (share && share->disable_keys) {
+ slot_data->disable_keys_create_info = create_info;
+ }
+ }
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::wrapper_rename_table(const char *from, const char *to,
+ MRN_SHARE *tmp_share,
+ const char *from_table_name,
+ const char *to_table_name)
+{
+ int error = 0;
+ handler *hnd;
+ MRN_DBUG_ENTER_METHOD();
+
+ hnd = get_new_handler(tmp_share->table_share,
+ current_thd->mem_root,
+ tmp_share->hton);
+ if (!hnd)
+ {
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+
+ if ((error = hnd->ha_rename_table(from, to)))
+ {
+ delete hnd;
+ DBUG_RETURN(error);
+ }
+
+ error = wrapper_rename_index(from, to, tmp_share,
+ from_table_name, to_table_name);
+
+ delete hnd;
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_rename_index(const char *from, const char *to,
+ MRN_SHARE *tmp_share,
+ const char *from_table_name,
+ const char *to_table_name)
+{
+ int error;
+ grn_rc rc;
+ MRN_DBUG_ENTER_METHOD();
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = ensure_database_open(from);
+ if (error)
+ DBUG_RETURN(error);
+
+ TABLE_SHARE *tmp_table_share = tmp_share->table_share;
+
+ uint i;
+ for (i = 0; i < tmp_table_share->keys; i++) {
+ const char *mysql_index_name = tmp_table_share->key_info[i].name.str;
+ mrn::IndexTableName from_index_table_name(from_table_name, mysql_index_name);
+ mrn::IndexTableName to_index_table_name(to_table_name, mysql_index_name);
+ grn_obj *index_table;
+ index_table = grn_ctx_get(ctx,
+ from_index_table_name.c_str(),
+ from_index_table_name.length());
+ if (!index_table) {
+ index_table = grn_ctx_get(ctx,
+ from_index_table_name.old_c_str(),
+ from_index_table_name.old_length());
+ }
+ if (index_table) {
+ rc = grn_table_rename(ctx, index_table,
+ to_index_table_name.c_str(),
+ to_index_table_name.length());
+ if (rc != GRN_SUCCESS) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ }
+ }
+
+ grn_obj *table = grn_ctx_get(ctx, from_table_name, strlen(from_table_name));
+ if (ctx->rc != GRN_SUCCESS) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ rc = grn_table_rename(ctx, table, to_table_name,
+ strlen(to_table_name));
+ if (rc != GRN_SUCCESS) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::storage_rename_table(const char *from, const char *to,
+ MRN_SHARE *tmp_share,
+ const char *from_table_name,
+ const char *to_table_name)
+{
+ int error;
+ grn_rc rc;
+ TABLE_SHARE *tmp_table_share = tmp_share->table_share;
+ MRN_LONG_TERM_SHARE *from_long_term_share = tmp_share->long_term_share,
+ *to_long_term_share;
+ MRN_DBUG_ENTER_METHOD();
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ error = ensure_database_open(from);
+ if (error)
+ DBUG_RETURN(error);
+
+ if (!(to_long_term_share = mrn_get_long_term_share(to, strlen(to), &error)))
+ DBUG_RETURN(error);
+ to_long_term_share->auto_inc_value = from_long_term_share->auto_inc_value;
+ DBUG_PRINT("info", ("mroonga: to_auto_inc_value=%llu",
+ to_long_term_share->auto_inc_value));
+ to_long_term_share->auto_inc_inited = from_long_term_share->auto_inc_inited;
+
+ uint i;
+ for (i = 0; i < tmp_table_share->keys; i++) {
+ const char *mysql_index_name = tmp_table_share->key_info[i].name.str;
+ mrn::IndexTableName from_index_table_name(from_table_name,
+ mysql_index_name);
+ mrn::IndexTableName to_index_table_name(to_table_name,
+ mysql_index_name);
+ grn_obj *index_table;
+ index_table = grn_ctx_get(ctx,
+ from_index_table_name.c_str(),
+ from_index_table_name.length());
+ if (!index_table) {
+ index_table = grn_ctx_get(ctx,
+ from_index_table_name.old_c_str(),
+ from_index_table_name.old_length());
+ }
+ if (index_table) {
+ rc = grn_table_rename(ctx, index_table,
+ to_index_table_name.c_str(),
+ to_index_table_name.length());
+ if (rc != GRN_SUCCESS) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto error_end;
+ }
+ }
+ }
+#ifdef MRN_SUPPORT_FOREIGN_KEYS
+ error = storage_rename_foreign_key(tmp_share, from_table_name, to_table_name);
+ if (error) {
+ goto error_end;
+ }
+#endif
+ {
+ grn_obj *table_obj = grn_ctx_get(ctx, from_table_name, strlen(from_table_name));
+ if (ctx->rc != GRN_SUCCESS) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto error_end;
+ }
+ rc = grn_table_rename(ctx, table_obj, to_table_name,
+ strlen(to_table_name));
+ if (rc != GRN_SUCCESS) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ goto error_end;
+ }
+ }
+ DBUG_RETURN(0);
+
+error_end:
+ mrn_free_long_term_share(to_long_term_share);
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_SUPPORT_FOREIGN_KEYS
+int ha_mroonga::storage_rename_foreign_key(MRN_SHARE *tmp_share,
+ const char *from_table_name,
+ const char *to_table_name)
+{
+ int error;
+ uint i;
+ grn_obj *column, *ref_column;
+ grn_rc rc;
+ TABLE_SHARE *tmp_table_share = tmp_share->table_share;
+ uint n_columns = tmp_table_share->fields;
+ MRN_DBUG_ENTER_METHOD();
+ for (i = 0; i < n_columns; ++i) {
+ Field *field = tmp_table_share->field[i];
+
+ if (!is_foreign_key_field(from_table_name, field->field_name.str)) {
+ continue;
+ }
+
+ grn_obj *grn_from_table = grn_ctx_get(ctx, from_table_name, -1);
+ mrn::ColumnName column_name(field->field_name);
+ column = grn_obj_column(ctx,
+ grn_from_table,
+ column_name.c_str(),
+ column_name.length());
+ if (!column) {
+ continue;
+ }
+ grn_id ref_table_id = grn_obj_get_range(ctx, column);
+ grn_obj *ref_table = grn_ctx_at(ctx, ref_table_id);
+ mrn::IndexColumnName from_index_column_name(from_table_name,
+ column_name.c_str());
+ ref_column = grn_obj_column(ctx, ref_table,
+ from_index_column_name.c_str(),
+ from_index_column_name.length());
+ if (!ref_column) {
+ continue;
+ }
+ mrn::IndexColumnName to_index_column_name(to_table_name,
+ column_name.c_str());
+ rc = grn_column_rename(ctx, ref_column,
+ to_index_column_name.c_str(),
+ to_index_column_name.length());
+ if (rc != GRN_SUCCESS) {
+ error = ER_CANT_OPEN_FILE;
+ my_message(error, ctx->errbuf, MYF(0));
+ DBUG_RETURN(error);
+ }
+ }
+ DBUG_RETURN(0);
+}
+#endif
+
+int ha_mroonga::rename_table(const char *from, const char *to)
+{
+ int error = 0;
+ TABLE_LIST table_list;
+ TABLE_SHARE *tmp_table_share;
+ TABLE tmp_table;
+ MRN_SHARE *tmp_share;
+ MRN_DBUG_ENTER_METHOD();
+ mrn::PathMapper to_mapper(to);
+ mrn::PathMapper from_mapper(from);
+ if (strcmp(from_mapper.db_name(), to_mapper.db_name()))
+ DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+
+ LEX_CSTRING db_name= { from_mapper.db_name(), strlen(from_mapper.db_name()) };
+ LEX_CSTRING table_name= { from_mapper.mysql_table_name(),
+ strlen(from_mapper.mysql_table_name()) };
+ table_list.init_one_table(&db_name, &table_name, 0,TL_WRITE);
+ mrn_open_mutex_lock(NULL);
+ tmp_table_share = mrn_create_tmp_table_share(&table_list, from, &error);
+ mrn_open_mutex_unlock(NULL);
+ if (!tmp_table_share) {
+ DBUG_RETURN(error);
+ }
+ tmp_table.s = tmp_table_share;
+#ifdef WITH_PARTITION_STORAGE_ENGINE
+ tmp_table.part_info = NULL;
+#endif
+ if (!(tmp_share = mrn_get_share(from, &tmp_table, &error)))
+ {
+ mrn_open_mutex_lock(NULL);
+ mrn_free_tmp_table_share(tmp_table_share);
+ mrn_open_mutex_unlock(NULL);
+ DBUG_RETURN(error);
+ }
+
+ if (tmp_share->wrapper_mode)
+ {
+ error = wrapper_rename_table(from, to, tmp_share,
+ from_mapper.table_name(),
+ to_mapper.table_name());
+ } else {
+ error = storage_rename_table(from, to, tmp_share,
+ from_mapper.table_name(),
+ to_mapper.table_name());
+ }
+
+ if (!error && to_mapper.table_name()[0] == '#') {
+ error = add_wrap_hton(to, tmp_share->hton);
+ } else if (error && from_mapper.table_name()[0] == '#') {
+ add_wrap_hton(from, tmp_share->hton);
+ }
+ if (!error) {
+ mrn_free_long_term_share(tmp_share->long_term_share);
+ tmp_share->long_term_share = NULL;
+ }
+ mrn_free_share(tmp_share);
+ mrn_open_mutex_lock(NULL);
+ mrn_free_tmp_table_share(tmp_table_share);
+ mrn_open_mutex_unlock(NULL);
+
+ DBUG_RETURN(error);
+}
+
+bool ha_mroonga::wrapper_is_crashed() const
+{
+ bool res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->is_crashed();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::storage_is_crashed() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ mrn::DatabaseRepairer repairer(ctx, ha_thd());
+ bool crashed = repairer.is_crashed();
+ DBUG_RETURN(crashed);
+}
+
+bool ha_mroonga::is_crashed() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool crashed;
+ if (share->wrapper_mode)
+ {
+ crashed = wrapper_is_crashed();
+ } else {
+ crashed = storage_is_crashed();
+ }
+ DBUG_RETURN(crashed);
+}
+
+bool ha_mroonga::wrapper_auto_repair(int error) const
+{
+ bool repaired;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+#ifdef MRN_HANDLER_AUTO_REPAIR_HAVE_ERROR
+ repaired = wrap_handler->auto_repair(error);
+#else
+ repaired = wrap_handler->auto_repair();
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(repaired);
+}
+
+bool ha_mroonga::storage_auto_repair(int error) const
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool repaired;
+#ifdef MRN_HANDLER_AUTO_REPAIR_HAVE_ERROR
+ repaired = handler::auto_repair(error);
+#else
+ repaired = handler::auto_repair();
+#endif
+ DBUG_RETURN(repaired);
+}
+
+bool ha_mroonga::auto_repair(int error) const
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool repaired;
+ // TODO: We should consider about creating share for error =
+ // ER_CANT_OPEN_FILE. The following code just ignores the error.
+ if (share && share->wrapper_mode)
+ {
+ repaired = wrapper_auto_repair(error);
+ } else {
+ repaired = storage_auto_repair(error);
+ }
+ DBUG_RETURN(repaired);
+}
+
+bool ha_mroonga::auto_repair() const
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool repaired = auto_repair(HA_ERR_CRASHED_ON_USAGE);
+ DBUG_RETURN(repaired);
+}
+
+int ha_mroonga::generic_disable_index(int i, KEY *key_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+ if (share->index_table[i]) {
+ char index_column_name[GRN_TABLE_MAX_KEY_SIZE];
+ snprintf(index_column_name, GRN_TABLE_MAX_KEY_SIZE - 1,
+ "%s.%s", share->index_table[i], key_info[i].name.str);
+ grn_obj *index_column = grn_ctx_get(ctx,
+ index_column_name,
+ strlen(index_column_name));
+ if (index_column) {
+ grn_obj_remove(ctx, index_column);
+ }
+ } else {
+ mrn::PathMapper mapper(share->table_name);
+ mrn::IndexTableName index_table_name(mapper.table_name(),
+ key_info[i].name.str);
+ grn_obj *index_table = grn_ctx_get(ctx,
+ index_table_name.c_str(),
+ index_table_name.length());
+ if (!index_table) {
+ index_table = grn_ctx_get(ctx,
+ index_table_name.old_c_str(),
+ index_table_name.old_length());
+ }
+ if (index_table) {
+ grn_obj_remove(ctx, index_table);
+ }
+ }
+ if (ctx->rc == GRN_SUCCESS) {
+ grn_index_tables[i] = NULL;
+ grn_index_columns[i] = NULL;
+ } else {
+ // TODO: Implement ctx->rc to error converter and use it.
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ }
+
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_disable_indexes_mroonga(uint mode)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE || mode == HA_KEY_SWITCH_ALL) {
+ uint i;
+ for (i = 0; i < table_share->keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+ if (share->wrap_key_nr[i] < MAX_KEY) {
+ continue;
+ }
+ if (!grn_index_tables[i]) {
+ DBUG_PRINT("info", ("mroonga: keys are disabled already %u", i));
+ DBUG_RETURN(0);
+ }
+ }
+ KEY *key_info = table_share->key_info;
+ for (i = 0; i < table_share->keys; i++) {
+ if (!(key_info[i].flags & HA_FULLTEXT) &&
+ !mrn_is_geo_key(&key_info[i])) {
+ continue;
+ }
+
+ int sub_error = generic_disable_index(i, key_info);
+ if (error != 0 && sub_error != 0) {
+ error = sub_error;
+ }
+ }
+ } else {
+ error = HA_ERR_WRONG_COMMAND;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_disable_indexes(uint mode)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_disable_indexes(mode);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ if (error == HA_ERR_WRONG_COMMAND) {
+ error = 0;
+ }
+ if (!error) {
+ error = wrapper_disable_indexes_mroonga(mode);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_disable_indexes(uint mode)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE || mode == HA_KEY_SWITCH_ALL) {
+ uint i;
+ for (i = 0; i < table_share->keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+ if (!grn_index_tables[i]) {
+ DBUG_PRINT("info", ("mroonga: keys are disabled already %u", i));
+ DBUG_RETURN(0);
+ }
+ }
+ KEY *key_info = table_share->key_info;
+ for (i = 0; i < table_share->keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+ if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE &&
+ (key_info[i].flags & HA_NOSAME)) {
+ continue;
+ }
+
+ int sub_error = generic_disable_index(i, key_info);
+ if (error != 0 && sub_error != 0) {
+ error = sub_error;
+ }
+ }
+ } else {
+ DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::disable_indexes(uint mode)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ error = wrapper_disable_indexes(mode);
+ } else {
+ error = storage_disable_indexes(mode);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_enable_indexes_mroonga(uint mode)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE || mode == HA_KEY_SWITCH_ALL) {
+ uint i, j;
+ for (i = 0; i < table_share->keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+ if (share->wrap_key_nr[i] < MAX_KEY) {
+ continue;
+ }
+ if (!grn_index_columns[i]) {
+ break;
+ }
+ }
+ if (i == table_share->keys) {
+ DBUG_PRINT("info", ("mroonga: keys are enabled already"));
+ DBUG_RETURN(0);
+ }
+ KEY *p_key_info = &table->key_info[table_share->primary_key];
+ KEY *key_info = table_share->key_info;
+ uint n_keys = table_share->keys;
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, n_keys);
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns, n_keys);
+ bitmap_clear_all(table->read_set);
+ mrn_set_bitmap_by_key(table->read_set, p_key_info);
+ mrn::PathMapper mapper(share->table_name);
+ for (i = 0, j = 0; i < n_keys; i++) {
+ if (!(key_info[i].flags & HA_FULLTEXT) &&
+ !mrn_is_geo_key(&key_info[i])) {
+ j++;
+ continue;
+ }
+
+ if ((error = mrn_add_index_param(share, &key_info[i], i)))
+ {
+ break;
+ }
+ index_tables[i] = NULL;
+ index_columns[i] = NULL;
+ if (!grn_index_columns[i]) {
+ if (
+ (key_info[i].flags & HA_FULLTEXT) &&
+ (error = wrapper_create_index_fulltext(mapper.table_name(),
+ i, &key_info[i],
+ index_tables, index_columns,
+ share))
+ ) {
+ break;
+ } else if (
+ mrn_is_geo_key(&key_info[i]) &&
+ (error = wrapper_create_index_geo(mapper.table_name(),
+ i, &key_info[i],
+ index_tables, index_columns,
+ share))
+ ) {
+ break;
+ }
+ grn_index_columns[i] = index_columns[i];
+ }
+ mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
+ }
+ if (!error && i > j)
+ {
+ error = wrapper_fill_indexes(ha_thd(), table->key_info, index_columns,
+ n_keys);
+ }
+ bitmap_set_all(table->read_set);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ } else {
+ error = HA_ERR_WRONG_COMMAND;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_enable_indexes(uint mode)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+
+ int mroonga_error = wrapper_enable_indexes_mroonga(mode);
+
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_enable_indexes(mode);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ if (error == HA_ERR_WRONG_COMMAND) {
+ error = mroonga_error;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_enable_indexes(uint mode)
+{
+ int error = 0;
+ uint n_keys = table_share->keys;
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, n_keys);
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns, n_keys);
+ bool have_multiple_column_index = false;
+ bool skip_unique_key = (mode == HA_KEY_SWITCH_NONUNIQ_SAVE);
+ MRN_DBUG_ENTER_METHOD();
+ if (mode == HA_KEY_SWITCH_NONUNIQ_SAVE || mode == HA_KEY_SWITCH_ALL) {
+ uint i;
+ for (i = 0; i < table_share->keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+ if (!grn_index_columns[i]) {
+ break;
+ }
+ }
+ if (i == table_share->keys) {
+ DBUG_PRINT("info", ("mroonga: keys are enabled already"));
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(0);
+ }
+ KEY *key_info = table->key_info;
+ bitmap_clear_all(table->read_set);
+ mrn::PathMapper mapper(share->table_name);
+ for (i = 0; i < n_keys; i++) {
+ if (i == table->s->primary_key) {
+ continue;
+ }
+ if (skip_unique_key && (key_info[i].flags & HA_NOSAME)) {
+ continue;
+ }
+
+ if ((error = mrn_add_index_param(share, &key_info[i], i)))
+ {
+ break;
+ }
+ index_tables[i] = NULL;
+ if (!grn_index_columns[i]) {
+ if ((error = storage_create_index(table, mapper.table_name(), grn_table,
+ share, &key_info[i], index_tables,
+ index_columns, i)))
+ {
+ break;
+ }
+ if (
+ KEY_N_KEY_PARTS(&(key_info[i])) != 1 &&
+ !(key_info[i].flags & HA_FULLTEXT)
+ ) {
+ mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
+ have_multiple_column_index = true;
+ }
+ grn_index_tables[i] = index_tables[i];
+ grn_index_columns[i] = index_columns[i];
+ } else {
+ index_columns[i] = NULL;
+ }
+ }
+ if (!error && have_multiple_column_index)
+ {
+ error = storage_add_index_multiple_columns(key_info, n_keys,
+ index_tables,
+ index_columns,
+ skip_unique_key);
+ }
+ bitmap_set_all(table->read_set);
+ } else {
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(HA_ERR_WRONG_COMMAND);
+ }
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::enable_indexes(uint mode)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ share->disable_keys = false;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_enable_indexes(mode);
+ } else {
+ error = storage_enable_indexes(mode);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_check(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_check(thd, check_opt);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_check(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ mrn::DatabaseRepairer repairer(ctx, thd);
+ if (repairer.is_corrupt()) {
+ DBUG_RETURN(HA_ADMIN_CORRUPT);
+ } else {
+ DBUG_RETURN(HA_ADMIN_OK);
+ }
+}
+
+int ha_mroonga::check(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_check(thd, check_opt);
+ } else {
+ error = storage_check(thd, check_opt);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_fill_indexes(THD *thd, KEY *key_info,
+ grn_obj **index_columns, uint n_keys)
+{
+ int error = 0;
+ KEY *p_key_info = &table->key_info[table_share->primary_key];
+ KEY *tmp_key_info;
+#ifdef MRN_NEED_M_LOCK_TYPE_CHECK_FOR_WRAPPER_EXTERNAL_LOCK
+ int wrapper_lock_type_backup = wrap_handler->get_lock_type();
+#endif
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_PRINT("info", ("mroonga: n_keys=%u", n_keys));
+
+ grn_bool need_lock = true;
+ if (mrn_lock_type != F_UNLCK) {
+ need_lock = false;
+ }
+#ifdef MRN_NEED_M_LOCK_TYPE_CHECK_FOR_WRAPPER_EXTERNAL_LOCK
+ if (wrapper_lock_type_backup != F_UNLCK) {
+ need_lock = false;
+ }
+#endif
+ if (need_lock) {
+ error = wrapper_external_lock(thd, F_WRLCK);
+ }
+ if (!error) {
+ if (
+ !(error = wrapper_start_stmt(thd, thr_lock_data.type)) &&
+ !(error = wrapper_rnd_init(true))
+ ) {
+ grn_obj key;
+ GRN_TEXT_INIT(&key, 0);
+ grn_bulk_space(ctx, &key, p_key_info->key_length);
+ while (!(error = wrapper_rnd_next(table->record[0])))
+ {
+ key_copy((uchar *)(GRN_TEXT_VALUE(&key)), table->record[0],
+ p_key_info, p_key_info->key_length);
+ int added;
+ grn_id record_id;
+ mrn_change_encoding(ctx, NULL);
+ record_id = grn_table_add(ctx, grn_table,
+ GRN_TEXT_VALUE(&key), p_key_info->key_length,
+ &added);
+ if (record_id == GRN_ID_NIL)
+ {
+ char error_message[MRN_MESSAGE_BUFFER_SIZE];
+ snprintf(error_message, MRN_MESSAGE_BUFFER_SIZE,
+ "failed to add a new record into groonga: key=<%.*s>",
+ (int) p_key_info->key_length, GRN_TEXT_VALUE(&key));
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, error_message, MYF(0));
+ }
+ if (error)
+ break;
+
+ uint k;
+ for (k = 0; k < n_keys; k++) {
+ tmp_key_info = &key_info[k];
+ if (!(tmp_key_info->flags & HA_FULLTEXT) &&
+ !mrn_is_geo_key(tmp_key_info)) {
+ continue;
+ }
+ if (!index_columns[k]) {
+ continue;
+ }
+ DBUG_PRINT("info", ("mroonga: key_num=%u", k));
+
+ uint l;
+ for (l = 0; l < KEY_N_KEY_PARTS(tmp_key_info); l++) {
+ Field *field = tmp_key_info->key_part[l].field;
+
+ if (field->is_null())
+ continue;
+ error = mrn_change_encoding(ctx, field->charset());
+ if (error)
+ break;
+
+ error = generic_store_bulk(field, &new_value_buffer);
+ if (error) {
+ my_message(error,
+ "mroonga: wrapper: "
+ "failed to get new value for updating index.",
+ MYF(0));
+ break;
+ }
+
+ grn_obj *index_column = index_columns[k];
+ grn_rc rc;
+ rc = grn_column_index_update(ctx, index_column, record_id, l + 1,
+ NULL, &new_value_buffer);
+ grn_obj_unlink(ctx, index_column);
+ if (rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ break;
+ }
+ }
+ if (error)
+ break;
+ }
+ if (error)
+ break;
+ }
+ grn_obj_unlink(ctx, &key);
+ if (error != HA_ERR_END_OF_FILE)
+ wrapper_rnd_end();
+ else
+ error = wrapper_rnd_end();
+ }
+ if (need_lock) {
+ wrapper_external_lock(thd, F_UNLCK);
+ }
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_recreate_indexes(THD *thd)
+{
+ int error;
+ uint i, n_keys = table_share->keys;
+ KEY *p_key_info = &table->key_info[table_share->primary_key];
+ KEY *key_info = table->key_info;
+ MRN_DBUG_ENTER_METHOD();
+ mrn::PathMapper mapper(table_share->normalized_path.str);
+ bitmap_clear_all(table->read_set);
+ clear_indexes();
+ remove_grn_obj_force(mapper.table_name());
+ grn_table = NULL;
+ mrn_set_bitmap_by_key(table->read_set, p_key_info);
+ for (i = 0; i < n_keys; i++) {
+ if (!(key_info[i].flags & HA_FULLTEXT) && !mrn_is_geo_key(&key_info[i])) {
+ continue;
+ }
+ mrn::IndexTableName index_table_name(mapper.table_name(),
+ table_share->key_info[i].name.str);
+ char index_column_full_name[MRN_MAX_PATH_SIZE];
+ snprintf(index_column_full_name, MRN_MAX_PATH_SIZE,
+ "%s.%s", index_table_name.c_str(), INDEX_COLUMN_NAME);
+ remove_grn_obj_force(index_column_full_name);
+ remove_grn_obj_force(index_table_name.c_str());
+
+ char index_column_full_old_name[MRN_MAX_PATH_SIZE];
+ snprintf(index_column_full_old_name, MRN_MAX_PATH_SIZE,
+ "%s.%s", index_table_name.old_c_str(), INDEX_COLUMN_NAME);
+ remove_grn_obj_force(index_column_full_old_name);
+ remove_grn_obj_force(index_table_name.old_c_str());
+
+ mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
+ }
+ error = wrapper_create_index(table_share->normalized_path.str, table, share);
+ if (error)
+ DBUG_RETURN(error);
+ error = wrapper_open_indexes(table_share->normalized_path.str);
+ if (error)
+ DBUG_RETURN(error);
+ error = wrapper_fill_indexes(thd, key_info, grn_index_columns, n_keys);
+ bitmap_set_all(table->read_set);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_recreate_indexes(THD *thd)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ if (share->disable_keys)
+ DBUG_RETURN(HA_ADMIN_OK);
+
+ clear_indexes();
+
+ int n_columns = table->s->fields;
+ for (int i = 0; i < n_columns; i++) {
+ grn_obj *column = grn_columns[i];
+
+ if (!column)
+ continue;
+
+ int n_hooks = grn_obj_get_nhooks(ctx, column, GRN_HOOK_SET);
+ for (int j = 0; j < n_hooks; j++) {
+ grn_obj_delete_hook(ctx, column, GRN_HOOK_SET, j);
+ }
+ }
+
+ uint n_keys = table_share->keys;
+ mrn::PathMapper mapper(table_share->normalized_path.str);
+ for (uint i = 0; i < n_keys; i++) {
+ if (share->index_table && share->index_table[i])
+ continue;
+
+ if (i == table_share->primary_key)
+ continue;
+
+ mrn::IndexTableName index_table_name(mapper.table_name(),
+ table_share->key_info[i].name.str);
+ char index_column_full_name[MRN_MAX_PATH_SIZE];
+ snprintf(index_column_full_name, MRN_MAX_PATH_SIZE,
+ "%s.%s", index_table_name.c_str(), INDEX_COLUMN_NAME);
+ remove_grn_obj_force(index_column_full_name);
+ remove_grn_obj_force(index_table_name.c_str());
+
+ char index_column_full_old_name[MRN_MAX_PATH_SIZE];
+ snprintf(index_column_full_old_name, MRN_MAX_PATH_SIZE,
+ "%s.%s", index_table_name.old_c_str(), INDEX_COLUMN_NAME);
+ remove_grn_obj_force(index_column_full_old_name);
+ remove_grn_obj_force(index_table_name.old_c_str());
+ }
+
+ int error;
+ error = storage_create_indexes(table, mapper.table_name(), grn_table, share);
+ if (error)
+ DBUG_RETURN(HA_ADMIN_FAILED);
+
+ error = storage_open_indexes(table_share->normalized_path.str);
+ if (error)
+ DBUG_RETURN(HA_ADMIN_FAILED);
+
+ DBUG_RETURN(HA_ADMIN_OK);
+}
+
+int ha_mroonga::wrapper_repair(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ int error;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_repair(thd, check_opt);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ if (error && error != HA_ADMIN_NOT_IMPLEMENTED)
+ DBUG_RETURN(error);
+ error = wrapper_recreate_indexes(thd);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_repair(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = storage_recreate_indexes(thd);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::repair(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ share->disable_keys = false;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_repair(thd, check_opt);
+ } else {
+ error = storage_repair(thd, check_opt);
+ }
+ DBUG_RETURN(error);
+}
+
+bool ha_mroonga::wrapper_check_and_repair(THD *thd)
+{
+ bool is_error_or_not_supported;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ is_error_or_not_supported = wrap_handler->ha_check_and_repair(thd);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(is_error_or_not_supported);
+}
+
+bool ha_mroonga::storage_check_and_repair(THD *thd)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool is_error = false;
+ mrn::DatabaseRepairer repairer(ctx, thd);
+ is_error = !repairer.repair();
+ DBUG_RETURN(is_error);
+}
+
+bool ha_mroonga::check_and_repair(THD *thd)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool is_error_or_not_supported;
+ if (share->wrapper_mode)
+ {
+ is_error_or_not_supported = wrapper_check_and_repair(thd);
+ } else {
+ is_error_or_not_supported = storage_check_and_repair(thd);
+ }
+ DBUG_RETURN(is_error_or_not_supported);
+}
+
+int ha_mroonga::wrapper_analyze(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->ha_analyze(thd, check_opt);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_analyze(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
+}
+
+int ha_mroonga::analyze(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_analyze(thd, check_opt);
+ } else {
+ error = storage_analyze(thd, check_opt);
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::wrapper_optimize(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(HA_ADMIN_TRY_ALTER);
+}
+
+int ha_mroonga::storage_optimize(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(HA_ADMIN_NOT_IMPLEMENTED);
+}
+
+int ha_mroonga::optimize(THD* thd, HA_CHECK_OPT* check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error = 0;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_optimize(thd, check_opt);
+ } else {
+ error = storage_optimize(thd, check_opt);
+ }
+ DBUG_RETURN(error);
+}
+
+bool ha_mroonga::wrapper_is_fatal_error(int error_num, uint flags)
+{
+ bool res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+#ifdef MRN_HANDLER_IS_FATAL_ERROR_HAVE_FLAGS
+ res = wrap_handler->is_fatal_error(error_num, flags);
+#else
+ res = wrap_handler->is_fatal_error(error_num);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::storage_is_fatal_error(int error_num, uint flags)
+{
+ MRN_DBUG_ENTER_METHOD();
+#ifdef MRN_HANDLER_IS_FATAL_ERROR_HAVE_FLAGS
+ bool is_fatal_error = handler::is_fatal_error(error_num, flags);
+#else
+ bool is_fatal_error = handler::is_fatal_error(error_num);
+#endif
+ DBUG_RETURN(is_fatal_error);
+}
+
+bool ha_mroonga::is_fatal_error(int error_num, uint flags)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool is_fatal_error;
+ if (share->wrapper_mode)
+ {
+ is_fatal_error = wrapper_is_fatal_error(error_num, flags);
+ } else {
+ is_fatal_error = storage_is_fatal_error(error_num, flags);
+ }
+ DBUG_RETURN(is_fatal_error);
+}
+
+bool ha_mroonga::wrapper_check_if_incompatible_data(
+ HA_CREATE_INFO *create_info, uint table_changes)
+{
+ bool res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->check_if_incompatible_data(create_info, table_changes);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::storage_check_if_incompatible_data(
+ HA_CREATE_INFO *create_info, uint table_changes)
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint n = table_share->fields;
+ for (uint i = 0; i < n; i++) {
+ Field *field = table->field[i];
+ if (field->flags & FIELD_IS_RENAMED) {
+ DBUG_RETURN(COMPATIBLE_DATA_NO);
+ }
+ }
+ DBUG_RETURN(COMPATIBLE_DATA_YES);
+}
+
+bool ha_mroonga::check_if_incompatible_data(
+ HA_CREATE_INFO *create_info, uint table_changes)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool res;
+ if (
+ create_info->comment.str != table_share->comment.str ||
+ create_info->connect_string.str != table_share->connect_string.str
+ ) {
+ DBUG_RETURN(COMPATIBLE_DATA_NO);
+ }
+ if (share->wrapper_mode)
+ {
+ res = wrapper_check_if_incompatible_data(create_info, table_changes);
+ } else {
+ res = storage_check_if_incompatible_data(create_info, table_changes);
+ }
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::storage_add_index_multiple_columns(KEY *key_info,
+ uint num_of_keys,
+ grn_obj **index_tables,
+ grn_obj **index_columns,
+ bool skip_unique_key)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ int error = 0;
+
+ if (!(error = storage_rnd_init(true)))
+ {
+ while (!(error = storage_rnd_next(table->record[0])))
+ {
+ for (uint i = 0; i < num_of_keys; i++) {
+ KEY *current_key_info = key_info + i;
+ if (
+ KEY_N_KEY_PARTS(current_key_info) == 1 ||
+ (current_key_info->flags & HA_FULLTEXT)
+ ) {
+ continue;
+ }
+ if (skip_unique_key && (key_info[i].flags & HA_NOSAME)) {
+ continue;
+ }
+ if (!index_columns[i]) {
+ continue;
+ }
+
+ /* fix key_info.key_length */
+ for (uint j = 0; j < KEY_N_KEY_PARTS(current_key_info); j++) {
+ if (
+ !current_key_info->key_part[j].null_bit &&
+ current_key_info->key_part[j].field->null_bit
+ ) {
+ current_key_info->key_length++;
+ current_key_info->key_part[j].null_bit =
+ current_key_info->key_part[j].field->null_bit;
+ }
+ }
+ if (key_info[i].flags & HA_NOSAME) {
+ grn_id key_id;
+ if ((error = storage_write_row_unique_index(table->record[0],
+ current_key_info,
+ index_tables[i],
+ index_columns[i],
+ &key_id)))
+ {
+ if (error == HA_ERR_FOUND_DUPP_KEY)
+ {
+ error = HA_ERR_FOUND_DUPP_UNIQUE;
+ }
+ break;
+ }
+ }
+ if ((error = storage_write_row_multiple_column_index(table->record[0],
+ record_id,
+ current_key_info,
+ index_columns[i])))
+ {
+ break;
+ }
+ }
+ if (error)
+ break;
+ }
+ if (error != HA_ERR_END_OF_FILE) {
+ storage_rnd_end();
+ } else {
+ error = storage_rnd_end();
+ }
+ }
+
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER
+bool ha_mroonga::wrapper_is_comment_changed(TABLE *table1, TABLE *table2)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ if (table1->s->comment.length != table2->s->comment.length) {
+ DBUG_RETURN(true);
+ }
+
+ if (strncmp(table1->s->comment.str,
+ table2->s->comment.str,
+ table1->s->comment.length) == 0) {
+ DBUG_RETURN(false);
+ } else {
+ DBUG_RETURN(true);
+ }
+}
+
+enum_alter_inplace_result ha_mroonga::wrapper_check_if_supported_inplace_alter(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint n_keys;
+ uint i;
+ enum_alter_inplace_result result_mroonga = HA_ALTER_INPLACE_NO_LOCK;
+ DBUG_PRINT("info",
+ ("mroonga: handler_flags=%lu",
+ static_cast<ulong>(ha_alter_info->handler_flags)));
+
+ if (wrapper_is_comment_changed(table, altered_table)) {
+ DBUG_RETURN(HA_ALTER_INPLACE_NOT_SUPPORTED);
+ }
+ if (
+ (ha_alter_info->handler_flags & ALTER_ADD_NON_UNIQUE_NON_PRIM_INDEX) &&
+ (ha_alter_info->handler_flags &
+ (
+ ALTER_ADD_COLUMN |
+ ALTER_DROP_COLUMN |
+ MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_TYPE |
+ MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_ORDER |
+ ALTER_COLUMN_NULLABLE |
+ ALTER_COLUMN_NOT_NULLABLE |
+ ALTER_COLUMN_STORAGE_TYPE |
+ ALTER_ADD_STORED_GENERATED_COLUMN |
+ ALTER_COLUMN_COLUMN_FORMAT
+ )
+ )
+ ) {
+ DBUG_RETURN(HA_ALTER_INPLACE_NOT_SUPPORTED);
+ }
+ if (ha_alter_info->handler_flags & ALTER_RENAME)
+ {
+ DBUG_RETURN(HA_ALTER_INPLACE_NOT_SUPPORTED);
+ }
+
+ DBUG_ASSERT(ha_alter_info->key_count == altered_table->s->keys);
+ alter_key_count = 0;
+ alter_index_drop_count = 0;
+ alter_index_add_count = 0;
+ alter_handler_flags = ha_alter_info->handler_flags;
+ if (!(alter_key_info_buffer = (KEY *)
+ mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+ &alter_key_info_buffer, sizeof(KEY) * ha_alter_info->key_count,
+ &alter_index_drop_buffer, sizeof(KEY) * ha_alter_info->index_drop_count,
+ &alter_index_add_buffer, sizeof(uint) * ha_alter_info->index_add_count,
+ &wrap_altered_table, sizeof(TABLE),
+ &wrap_altered_table_key_info, sizeof(KEY) * altered_table->s->keys,
+ &wrap_altered_table_share, sizeof(TABLE_SHARE),
+ &wrap_altered_table_share_key_info, sizeof(KEY) * altered_table->s->keys,
+ NullS))
+ ) {
+ DBUG_RETURN(HA_ALTER_ERROR);
+ }
+ *wrap_altered_table= *altered_table;
+ *wrap_altered_table_share= *altered_table->s;
+ mrn_init_sql_alloc(ha_thd(), &(wrap_altered_table_share->mem_root));
+
+ n_keys = ha_alter_info->index_drop_count;
+ for (i = 0; i < n_keys; ++i) {
+ const KEY *key = ha_alter_info->index_drop_buffer[i];
+ if (key->flags & HA_FULLTEXT || mrn_is_geo_key(key)) {
+ result_mroonga = HA_ALTER_INPLACE_EXCLUSIVE_LOCK;
+ } else {
+ memcpy(&alter_index_drop_buffer[alter_index_drop_count],
+ ha_alter_info->index_drop_buffer[i], sizeof(KEY));
+ ++alter_index_drop_count;
+ }
+ }
+ if (!alter_index_drop_count) {
+ alter_handler_flags &= ~ALTER_DROP_NON_UNIQUE_NON_PRIM_INDEX;
+ }
+ n_keys = ha_alter_info->index_add_count;
+ for (i = 0; i < n_keys; ++i) {
+ const KEY *key =
+ &altered_table->key_info[ha_alter_info->index_add_buffer[i]];
+ if (key->flags & HA_FULLTEXT || mrn_is_geo_key(key)) {
+ result_mroonga = HA_ALTER_INPLACE_EXCLUSIVE_LOCK;
+ } else {
+ alter_index_add_buffer[alter_index_add_count] =
+ ha_alter_info->index_add_buffer[i];
+ ++alter_index_add_count;
+ }
+ }
+ if (!alter_index_add_count) {
+ alter_handler_flags &= ~ALTER_ADD_NON_UNIQUE_NON_PRIM_INDEX;
+ }
+ uint add_index_pos = 0;
+ n_keys = ha_alter_info->key_count;
+ for (i = 0; i < n_keys; ++i) {
+ const KEY *key = &altered_table->key_info[i];
+ if (!(key->flags & HA_FULLTEXT || mrn_is_geo_key(key))) {
+ memcpy(&alter_key_info_buffer[alter_key_count],
+ &ha_alter_info->key_info_buffer[i], sizeof(KEY));
+ memcpy(&wrap_altered_table_key_info[alter_key_count],
+ &altered_table->key_info[i], sizeof(KEY));
+ memcpy(&wrap_altered_table_share_key_info[alter_key_count],
+ &altered_table->s->key_info[i], sizeof(KEY));
+ if (add_index_pos < alter_index_add_count &&
+ alter_index_add_buffer[add_index_pos] == i) {
+ alter_index_add_buffer[add_index_pos] = alter_key_count;
+ ++add_index_pos;
+ }
+ ++alter_key_count;
+ }
+ }
+ wrap_altered_table->key_info = wrap_altered_table_key_info;
+ wrap_altered_table_share->key_info = wrap_altered_table_share_key_info;
+ wrap_altered_table_share->keys = alter_key_count;
+ wrap_altered_table->s = wrap_altered_table_share;
+
+ if (!alter_handler_flags) {
+ DBUG_RETURN(result_mroonga);
+ }
+ enum_alter_inplace_result result;
+ MRN_SET_WRAP_ALTER_KEY(this, ha_alter_info);
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ result = wrap_handler->check_if_supported_inplace_alter(wrap_altered_table,
+ ha_alter_info);
+ MRN_SET_BASE_ALTER_KEY(this, ha_alter_info);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ if (result_mroonga > result)
+ DBUG_RETURN(result);
+ DBUG_RETURN(result_mroonga);
+}
+
+enum_alter_inplace_result ha_mroonga::storage_check_if_supported_inplace_alter(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ alter_table_operations explicitly_unsupported_flags =
+ ALTER_ADD_FOREIGN_KEY |
+ ALTER_DROP_FOREIGN_KEY;
+ alter_table_operations supported_flags =
+ ALTER_ADD_NON_UNIQUE_NON_PRIM_INDEX |
+ ALTER_DROP_NON_UNIQUE_NON_PRIM_INDEX |
+ ALTER_ADD_UNIQUE_INDEX |
+ ALTER_DROP_UNIQUE_INDEX |
+ MRN_ALTER_INPLACE_INFO_ADD_VIRTUAL_COLUMN |
+ MRN_ALTER_INPLACE_INFO_ADD_STORED_BASE_COLUMN |
+ ALTER_DROP_COLUMN |
+ ALTER_COLUMN_NAME;
+ if (ha_alter_info->handler_flags & explicitly_unsupported_flags) {
+ DBUG_RETURN(HA_ALTER_INPLACE_NOT_SUPPORTED);
+ } else if (ha_alter_info->handler_flags & supported_flags) {
+ DBUG_RETURN(HA_ALTER_INPLACE_EXCLUSIVE_LOCK);
+ } else {
+ DBUG_RETURN(HA_ALTER_INPLACE_NOT_SUPPORTED);
+ }
+}
+
+enum_alter_inplace_result ha_mroonga::check_if_supported_inplace_alter(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ enum_alter_inplace_result result;
+ if (share->wrapper_mode) {
+ result = wrapper_check_if_supported_inplace_alter(altered_table,
+ ha_alter_info);
+ } else {
+ result = storage_check_if_supported_inplace_alter(altered_table,
+ ha_alter_info);
+ }
+ DBUG_RETURN(result);
+}
+
+bool ha_mroonga::wrapper_prepare_inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ bool result;
+ MRN_DBUG_ENTER_METHOD();
+ if (!alter_handler_flags) {
+ DBUG_RETURN(false);
+ }
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ int error = 0;
+ MRN_SHARE *tmp_share;
+ tmp_share = mrn_get_share(altered_table->s->table_name.str,
+ altered_table,
+ &error);
+ if (error != 0) {
+ DBUG_RETURN(true);
+ }
+
+ if (parse_engine_table_options(ha_thd(),
+ tmp_share->hton,
+ wrap_altered_table->s)) {
+ mrn_free_share(tmp_share);
+ DBUG_RETURN(true);
+ }
+#endif
+
+ MRN_SET_WRAP_ALTER_KEY(this, ha_alter_info);
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ result = wrap_handler->ha_prepare_inplace_alter_table(wrap_altered_table,
+ ha_alter_info);
+ MRN_SET_BASE_ALTER_KEY(this, ha_alter_info);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ mrn_free_share(tmp_share);
+#endif
+
+ DBUG_RETURN(result);
+}
+
+bool ha_mroonga::storage_prepare_inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(false);
+}
+
+bool ha_mroonga::prepare_inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool result;
+ if (share->wrapper_mode) {
+ result = wrapper_prepare_inplace_alter_table(altered_table, ha_alter_info);
+ } else {
+ result = storage_prepare_inplace_alter_table(altered_table, ha_alter_info);
+ }
+ DBUG_RETURN(result);
+}
+
+bool ha_mroonga::wrapper_inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ int error;
+ bool result = false;
+ uint n_keys;
+ uint i, j = 0;
+ KEY *key_info = table_share->key_info;
+ MRN_DBUG_ENTER_METHOD();
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(true);
+
+ DBUG_PRINT("info", ("mroonga: table_name=%s", share->table_name));
+ mrn::PathMapper mapper(share->table_name);
+ n_keys = ha_alter_info->index_drop_count;
+ for (i = 0; i < n_keys; ++i) {
+ const KEY *key = ha_alter_info->index_drop_buffer[i];
+ if (!(key->flags & HA_FULLTEXT || mrn_is_geo_key(key))) {
+ continue;
+ }
+ while (strcmp(key_info[j].name.str, key->name.str)) {
+ ++j;
+ }
+ DBUG_PRINT("info", ("mroonga: key_name=%s", key->name.str));
+ error = drop_index(share, j);
+ if (error)
+ DBUG_RETURN(true);
+ grn_index_tables[j] = NULL;
+ grn_index_columns[j] = NULL;
+ }
+
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables,
+ ha_alter_info->key_count);
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns,
+ ha_alter_info->key_count);
+ MRN_SHARE *tmp_share;
+ TABLE_SHARE tmp_table_share;
+ char **key_tokenizer;
+ uint *key_tokenizer_length;
+ KEY *p_key_info = &table->key_info[table_share->primary_key];
+ bool need_fill_index = false;
+ memset(index_tables, 0, sizeof(grn_obj *) * ha_alter_info->key_count);
+ memset(index_columns, 0, sizeof(grn_obj *) * ha_alter_info->key_count);
+ tmp_table_share.keys = ha_alter_info->key_count;
+ tmp_table_share.fields = 0;
+ if (!(tmp_share = (MRN_SHARE *)
+ mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+ &tmp_share, sizeof(*tmp_share),
+ &key_tokenizer, sizeof(char *) * (tmp_table_share.keys),
+ &key_tokenizer_length, sizeof(uint) * (tmp_table_share.keys),
+ NullS))
+ ) {
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(true);
+ }
+ tmp_share->engine = NULL;
+ tmp_share->table_share = &tmp_table_share;
+ tmp_share->index_table = NULL;
+ tmp_share->index_table_length = NULL;
+ tmp_share->key_tokenizer = key_tokenizer;
+ tmp_share->key_tokenizer_length = key_tokenizer_length;
+ bitmap_clear_all(table->read_set);
+ mrn_set_bitmap_by_key(table->read_set, p_key_info);
+ n_keys = ha_alter_info->index_add_count;
+ for (i = 0; i < n_keys; ++i) {
+ uint key_pos = ha_alter_info->index_add_buffer[i];
+ KEY *key = &altered_table->key_info[key_pos];
+ if (!(key->flags & HA_FULLTEXT || mrn_is_geo_key(key))) {
+ continue;
+ }
+ if (share->disable_keys) {
+ continue;
+ }
+ if ((error = mrn_add_index_param(tmp_share, key, key_pos)))
+ {
+ break;
+ }
+ DBUG_PRINT("info", ("mroonga: add key pos=%u", key_pos));
+ if (
+ (key->flags & HA_FULLTEXT) &&
+ (error = wrapper_create_index_fulltext(mapper.table_name(),
+ key_pos,
+ key, index_tables, NULL,
+ tmp_share))
+ ) {
+ break;
+ } else if (
+ mrn_is_geo_key(key) &&
+ (error = wrapper_create_index_geo(mapper.table_name(),
+ key_pos, key,
+ index_tables, NULL, tmp_share))
+ ) {
+ break;
+ }
+ mrn_set_bitmap_by_key(table->read_set, key);
+ index_columns[key_pos] = grn_obj_column(ctx,
+ index_tables[key_pos],
+ INDEX_COLUMN_NAME,
+ strlen(INDEX_COLUMN_NAME));
+ need_fill_index = true;
+ }
+ if (!error && need_fill_index) {
+ mrn::FieldTableChanger changer(altered_table, table);
+ error = wrapper_fill_indexes(ha_thd(), altered_table->key_info,
+ index_columns, ha_alter_info->key_count);
+ }
+ bitmap_set_all(table->read_set);
+
+ if (!error && alter_handler_flags) {
+#ifdef MRN_SUPPORT_CUSTOM_OPTIONS
+ {
+ MRN_SHARE *alter_tmp_share;
+ alter_tmp_share = mrn_get_share(altered_table->s->table_name.str,
+ altered_table,
+ &error);
+ if (alter_tmp_share) {
+ if (parse_engine_table_options(ha_thd(),
+ alter_tmp_share->hton,
+ wrap_altered_table->s)) {
+ error = MRN_GET_ERROR_NUMBER;
+ }
+ mrn_free_share(alter_tmp_share);
+ }
+ }
+#endif
+ if (!error) {
+ MRN_SET_WRAP_ALTER_KEY(this, ha_alter_info);
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ result = wrap_handler->ha_inplace_alter_table(wrap_altered_table,
+ ha_alter_info);
+ MRN_SET_BASE_ALTER_KEY(this, ha_alter_info);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ }
+
+ if (result || error)
+ {
+ n_keys = ha_alter_info->index_add_count;
+ for (i = 0; i < n_keys; ++i) {
+ uint key_pos = ha_alter_info->index_add_buffer[i];
+ KEY *key = &altered_table->key_info[key_pos];
+ if (!(key->flags & HA_FULLTEXT || mrn_is_geo_key(key))) {
+ continue;
+ }
+ if (share->disable_keys) {
+ continue;
+ }
+ if (index_tables[key_pos])
+ {
+ grn_obj_remove(ctx, index_tables[key_pos]);
+ }
+ }
+ result = true;
+ }
+ mrn_free_share_alloc(tmp_share);
+ my_free(tmp_share);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(result);
+}
+
+bool ha_mroonga::storage_inplace_alter_table_add_index(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables,
+ ha_alter_info->key_count);
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns,
+ ha_alter_info->key_count);
+ MRN_SHARE *tmp_share;
+ TABLE_SHARE tmp_table_share;
+ char **index_table, **key_tokenizer, **col_flags, **col_type;
+ uint *index_table_length, *key_tokenizer_length, *col_flags_length, *col_type_length;
+ bool have_multiple_column_index = false;
+ memset(index_tables, 0, sizeof(grn_obj *) * ha_alter_info->key_count);
+ memset(index_columns, 0, sizeof(grn_obj *) * ha_alter_info->key_count);
+ tmp_table_share.keys = ha_alter_info->key_count;
+ tmp_table_share.fields = 0;
+ if (!(tmp_share = (MRN_SHARE *)
+ mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+ &tmp_share, sizeof(*tmp_share),
+ &index_table, sizeof(char *) * tmp_table_share.keys,
+ &index_table_length, sizeof(uint) * tmp_table_share.keys,
+ &key_tokenizer, sizeof(char *) * tmp_table_share.keys,
+ &key_tokenizer_length, sizeof(uint) * tmp_table_share.keys,
+ &col_flags, sizeof(char *) * tmp_table_share.fields,
+ &col_flags_length, sizeof(uint) * tmp_table_share.fields,
+ &col_type, sizeof(char *) * tmp_table_share.fields,
+ &col_type_length, sizeof(uint) * tmp_table_share.fields,
+ NullS))
+ ) {
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(true);
+ }
+ tmp_share->engine = NULL;
+ tmp_share->table_share = &tmp_table_share;
+ tmp_share->index_table = index_table;
+ tmp_share->index_table_length = index_table_length;
+ tmp_share->key_tokenizer = key_tokenizer;
+ tmp_share->key_tokenizer_length = key_tokenizer_length;
+ tmp_share->col_flags = col_flags;
+ tmp_share->col_flags_length = col_flags_length;
+ tmp_share->col_type = col_type;
+ tmp_share->col_type_length = col_type_length;
+ bitmap_clear_all(table->read_set);
+ if (table_share->primary_key != MAX_KEY) {
+ KEY *p_key_info = &table->key_info[table_share->primary_key];
+ mrn_set_bitmap_by_key(table->read_set, p_key_info);
+ }
+ int error = 0;
+ uint n_keys = ha_alter_info->index_add_count;
+ for (uint i = 0; i < n_keys; ++i) {
+ uint key_pos = ha_alter_info->index_add_buffer[i];
+ KEY *key = &altered_table->key_info[key_pos];
+ if (share->disable_keys && !(key->flags & HA_NOSAME)) {
+ continue; // key is disabled
+ }
+ if ((error = mrn_add_index_param(tmp_share, key, key_pos)))
+ {
+ break;
+ }
+ DBUG_PRINT("info", ("mroonga: add key pos=%u", key_pos));
+ mrn::PathMapper mapper(share->table_name);
+ if ((error = storage_create_index(table, mapper.table_name(), grn_table,
+ tmp_share, key, index_tables,
+ index_columns, key_pos)))
+ {
+ break;
+ }
+ if (
+ KEY_N_KEY_PARTS(key) == 1 &&
+ (key->flags & HA_NOSAME) &&
+ grn_table_size(ctx, grn_table) !=
+ grn_table_size(ctx, index_tables[key_pos])
+ ) {
+ error = HA_ERR_FOUND_DUPP_UNIQUE;
+ my_printf_error(ER_DUP_UNIQUE, ER(ER_DUP_UNIQUE), MYF(0),
+ table_share->table_name);
+ ++i;
+ break;
+ }
+ if (
+ KEY_N_KEY_PARTS(key) != 1 &&
+ !(key->flags & HA_FULLTEXT)
+ ) {
+ mrn_set_bitmap_by_key(table->read_set, key);
+ have_multiple_column_index = true;
+ }
+ }
+ if (!error && have_multiple_column_index) {
+ mrn::FieldTableChanger changer(altered_table, table);
+ error = storage_add_index_multiple_columns(altered_table->key_info,
+ ha_alter_info->key_count,
+ index_tables,
+ index_columns, false);
+ if (error == HA_ERR_FOUND_DUPP_UNIQUE) {
+ my_printf_error(ER_DUP_UNIQUE, ER(ER_DUP_UNIQUE), MYF(0),
+ table_share->table_name);
+ } else if (error) {
+ my_message(error, "failed to create multiple column index", MYF(0));
+ }
+ }
+ bitmap_set_all(table->read_set);
+
+ bool have_error = false;
+ if (error)
+ {
+ n_keys = ha_alter_info->index_add_count;
+ for (uint i = 0; i < n_keys; ++i) {
+ uint key_pos = ha_alter_info->index_add_buffer[i];
+ KEY *key =
+ &altered_table->key_info[key_pos];
+ if (share->disable_keys && !(key->flags & HA_NOSAME)) {
+ continue;
+ }
+ if (index_tables[key_pos])
+ {
+ grn_obj_remove(ctx, index_columns[key_pos]);
+ grn_obj_remove(ctx, index_tables[key_pos]);
+ }
+ }
+ have_error = true;
+ }
+ mrn_free_share_alloc(tmp_share);
+ my_free(tmp_share);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+
+ DBUG_RETURN(have_error);
+}
+
+bool ha_mroonga::storage_inplace_alter_table_drop_index(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ bool have_error = false;
+ uint n_keys;
+ uint i, j = 0;
+ KEY *key_info = table_share->key_info;
+ mrn::PathMapper mapper(share->table_name);
+ n_keys = ha_alter_info->index_drop_count;
+ for (i = 0; i < n_keys; ++i) {
+ KEY *key = ha_alter_info->index_drop_buffer[i];
+ while (strcmp(key_info[j].name.str, key->name.str) != 0) {
+ ++j;
+ }
+ int error = drop_index(share, j);
+ if (error != 0)
+ DBUG_RETURN(true);
+ grn_index_tables[j] = NULL;
+ grn_index_columns[j] = NULL;
+ }
+
+ DBUG_RETURN(have_error);
+}
+
+bool ha_mroonga::storage_inplace_alter_table_add_column(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ bool have_error = false;
+
+ MRN_SHARE *tmp_share;
+ TABLE_SHARE tmp_table_share;
+ char **index_table, **key_tokenizer, **col_flags, **col_type;
+ uint *index_table_length, *key_tokenizer_length, *col_flags_length, *col_type_length;
+ tmp_table_share.keys = 0;
+ tmp_table_share.fields = altered_table->s->fields;
+ tmp_share = (MRN_SHARE *)mrn_my_multi_malloc(
+ MYF(MY_WME | MY_ZEROFILL),
+ &tmp_share, sizeof(*tmp_share),
+ &index_table, sizeof(char *) * tmp_table_share.keys,
+ &index_table_length, sizeof(uint) * tmp_table_share.keys,
+ &key_tokenizer, sizeof(char *) * tmp_table_share.keys,
+ &key_tokenizer_length, sizeof(uint) * tmp_table_share.keys,
+ &col_flags, sizeof(char *) * tmp_table_share.fields,
+ &col_flags_length, sizeof(uint) * tmp_table_share.fields,
+ &col_type, sizeof(char *) * tmp_table_share.fields,
+ &col_type_length, sizeof(uint) * tmp_table_share.fields,
+ NullS);
+ if (!tmp_share) {
+ have_error = true;
+ DBUG_RETURN(have_error);
+ }
+ tmp_share->engine = NULL;
+ tmp_share->table_share = &tmp_table_share;
+ tmp_share->index_table = index_table;
+ tmp_share->index_table_length = index_table_length;
+ tmp_share->key_tokenizer = key_tokenizer;
+ tmp_share->key_tokenizer_length = key_tokenizer_length;
+ tmp_share->col_flags = col_flags;
+ tmp_share->col_flags_length = col_flags_length;
+ tmp_share->col_type = col_type;
+ tmp_share->col_type_length = col_type_length;
+
+ mrn::PathMapper mapper(share->table_name);
+ grn_obj *table_obj;
+ table_obj = grn_ctx_get(ctx, mapper.table_name(), strlen(mapper.table_name()));
+
+ Alter_info *alter_info = ha_alter_info->alter_info;
+ List_iterator_fast<Create_field> create_fields(alter_info->create_list);
+ for (uint i = 0; Create_field *create_field = create_fields++; i++) {
+ if (create_field->field) {
+ continue;
+ }
+
+ Field *field = altered_table->s->field[i];
+
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_VIRTUAL(field)) {
+ continue;
+ }
+#endif
+
+ mrn::ColumnName column_name(field->field_name);
+ int error = mrn_add_column_param(tmp_share, field, i);
+ if (error) {
+ have_error = true;
+ break;
+ }
+
+ grn_obj_flags col_flags = GRN_OBJ_PERSISTENT;
+ if (!find_column_flags(field, tmp_share, i, &col_flags)) {
+ col_flags |= GRN_OBJ_COLUMN_SCALAR;
+ }
+
+ grn_obj *col_type;
+ {
+ int column_type_error_code = ER_WRONG_FIELD_SPEC;
+ col_type = find_column_type(field, tmp_share, i, column_type_error_code);
+ if (!col_type) {
+ error = column_type_error_code;
+ have_error = true;
+ break;
+ }
+ }
+ char *col_path = NULL; // we don't specify path
+
+ grn_obj *column_obj =
+ grn_column_create(ctx, table_obj,
+ column_name.c_str(),
+ column_name.length(),
+ col_path, col_flags, col_type);
+ if (ctx->rc) {
+ error = ER_WRONG_COLUMN_NAME;
+ my_message(error, ctx->errbuf, MYF(0));
+ have_error = true;
+ break;
+ }
+
+#ifdef MRN_SUPPORT_GENERATED_COLUMNS
+ if (MRN_GENERATED_COLUMNS_FIELD_IS_STORED(field)) {
+# ifndef MRN_MARIADB_P
+ MY_BITMAP generated_column_bitmap;
+ if (bitmap_init(&generated_column_bitmap, NULL,
+ altered_table->s->fields, false)) {
+ error = HA_ERR_OUT_OF_MEM;
+ my_message(ER_OUTOFMEMORY,
+ "mroonga: storage: "
+ "failed to allocate memory for getting generated value",
+ MYF(0));
+ have_error = true;
+ grn_obj_remove(ctx, column_obj);
+ break;
+ }
+ mrn::SmartBitmap smart_generated_column_bitmap(&generated_column_bitmap);
+ bitmap_set_bit(&generated_column_bitmap, field->field_index);
+# endif
+
+ mrn::FieldTableChanger changer(altered_table, table);
+
+ error = storage_rnd_init(true);
+ if (error) {
+ have_error = true;
+ grn_obj_remove(ctx, column_obj);
+ break;
+ }
+
+ Field *altered_field = altered_table->field[i];
+ grn_obj new_value;
+ GRN_VOID_INIT(&new_value);
+ mrn::SmartGrnObj smart_new_value(ctx, &new_value);
+ while (!have_error) {
+ int next_error = storage_rnd_next(table->record[0]);
+ if (next_error == HA_ERR_END_OF_FILE) {
+ break;
+ } else if (next_error != 0) {
+ error = next_error;
+ have_error = true;
+ grn_obj_remove(ctx, column_obj);
+ break;
+ }
+
+# ifdef MRN_MARIADB_P
+ MRN_GENERATED_COLUMNS_UPDATE_VIRTUAL_FIELD(altered_table, altered_field);
+# else
+ if (update_generated_write_fields(&generated_column_bitmap, altered_table)) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error,
+ "mroonga: storage: "
+ "failed to update generated value for updating column",
+ MYF(0));
+ have_error = true;
+ grn_obj_remove(ctx, column_obj);
+ break;
+ }
+# endif
+
+ error = mrn_change_encoding(ctx, altered_field->charset());
+ if (error) {
+ my_message(error,
+ "mroonga: storage: "
+ "failed to change encoding to store generated value",
+ MYF(0));
+ have_error = true;
+ grn_obj_remove(ctx, column_obj);
+ break;
+ }
+ error = generic_store_bulk(altered_field, &new_value);
+ if (error) {
+ my_message(error,
+ "mroonga: storage: "
+ "failed to get generated value for updating column",
+ MYF(0));
+ have_error = true;
+ grn_obj_remove(ctx, column_obj);
+ break;
+ }
+
+ grn_obj_set_value(ctx, column_obj, record_id, &new_value, GRN_OBJ_SET);
+ if (ctx->rc) {
+ error = ER_ERROR_ON_WRITE;
+ my_message(error, ctx->errbuf, MYF(0));
+ break;
+ }
+ }
+
+ int end_error = storage_rnd_end();
+ if (end_error != 0 && error == 0) {
+ error = end_error;
+ grn_obj_remove(ctx, column_obj);
+ break;
+ }
+ }
+#endif
+ }
+
+ grn_obj_unlink(ctx, table_obj);
+
+ mrn_free_share_alloc(tmp_share);
+ my_free(tmp_share);
+
+ DBUG_RETURN(have_error);
+}
+
+bool ha_mroonga::storage_inplace_alter_table_drop_column(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ bool have_error = false;
+
+ mrn::PathMapper mapper(share->table_name);
+ grn_obj *table_obj;
+ table_obj = grn_ctx_get(ctx, mapper.table_name(), strlen(mapper.table_name()));
+
+ Alter_info *alter_info = ha_alter_info->alter_info;
+
+ uint n_fields = table->s->fields;
+ for (uint i = 0; i < n_fields; i++) {
+ Field *field = table->field[i];
+
+ bool dropped = true;
+ List_iterator_fast<Create_field> create_fields(alter_info->create_list);
+ while (Create_field *create_field = create_fields++) {
+ if (create_field->field == field) {
+ dropped = false;
+ break;
+ }
+ }
+ if (!dropped) {
+ continue;
+ }
+
+ const char *column_name = field->field_name.str;
+ int column_name_size = field->field_name.length;
+
+ grn_obj *column_obj;
+ column_obj = grn_obj_column(ctx, table_obj, column_name, column_name_size);
+ if (column_obj) {
+ grn_obj_remove(ctx, column_obj);
+ }
+ if (ctx->rc) {
+ int error = ER_WRONG_COLUMN_NAME;
+ my_message(error, ctx->errbuf, MYF(0));
+ have_error = true;
+ break;
+ }
+ }
+ grn_obj_unlink(ctx, table_obj);
+
+ DBUG_RETURN(have_error);
+}
+
+bool ha_mroonga::storage_inplace_alter_table_rename_column(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ bool have_error = false;
+
+ mrn::PathMapper mapper(share->table_name);
+ grn_obj *table_obj;
+ table_obj = grn_ctx_get(ctx, mapper.table_name(), strlen(mapper.table_name()));
+
+ Alter_info *alter_info = ha_alter_info->alter_info;
+ uint n_fields = table->s->fields;
+ for (uint i = 0; i < n_fields; i++) {
+ Field *field = table->field[i];
+
+ if (!(field->flags & FIELD_IS_RENAMED)) {
+ continue;
+ }
+
+ LEX_CSTRING new_name;
+ new_name.str= 0;
+ List_iterator_fast<Create_field> create_fields(alter_info->create_list);
+ while (Create_field *create_field = create_fields++) {
+ if (create_field->field == field) {
+ new_name = create_field->field_name;
+ break;
+ }
+ }
+
+ if (!new_name.str) {
+ continue;
+ }
+
+ const char *old_name = field->field_name.str;
+ grn_obj *column_obj;
+ column_obj = grn_obj_column(ctx, table_obj, old_name,
+ field->field_name.length);
+ if (column_obj) {
+ grn_column_rename(ctx, column_obj, new_name.str, new_name.length);
+ if (ctx->rc) {
+ int error = ER_WRONG_COLUMN_NAME;
+ my_message(error, ctx->errbuf, MYF(0));
+ have_error = true;
+ }
+ grn_obj_unlink(ctx, column_obj);
+ }
+
+ if (have_error) {
+ break;
+ }
+ }
+ grn_obj_unlink(ctx, table_obj);
+
+ DBUG_RETURN(have_error);
+}
+
+bool ha_mroonga::storage_inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+
+ bool have_error = false;
+
+ int error = mrn_change_encoding(ctx, system_charset_info);
+ if (error) {
+ have_error = true;
+ }
+
+ alter_table_operations drop_index_related_flags =
+ ALTER_DROP_INDEX |
+ ALTER_DROP_NON_UNIQUE_NON_PRIM_INDEX |
+ ALTER_DROP_UNIQUE_INDEX |
+ ALTER_DROP_PK_INDEX;
+ if (!have_error &&
+ (ha_alter_info->handler_flags & drop_index_related_flags)) {
+ have_error = storage_inplace_alter_table_drop_index(altered_table,
+ ha_alter_info);
+ }
+
+ alter_table_operations add_column_related_flags =
+ ALTER_ADD_COLUMN;
+ if (!have_error &&
+ (ha_alter_info->handler_flags & add_column_related_flags)) {
+ have_error = storage_inplace_alter_table_add_column(altered_table, ha_alter_info);
+ }
+
+ alter_table_operations drop_column_related_flags = ALTER_DROP_COLUMN;
+ if (!have_error &&
+ (ha_alter_info->handler_flags & drop_column_related_flags)) {
+ have_error = storage_inplace_alter_table_drop_column(altered_table, ha_alter_info);
+ }
+
+ alter_table_operations rename_column_related_flags = ALTER_COLUMN_NAME;
+ if (!have_error &&
+ (ha_alter_info->handler_flags & rename_column_related_flags)) {
+ have_error = storage_inplace_alter_table_rename_column(altered_table, ha_alter_info);
+ }
+
+ alter_table_operations add_index_related_flags =
+ ALTER_ADD_INDEX |
+ ALTER_ADD_NON_UNIQUE_NON_PRIM_INDEX |
+ ALTER_ADD_UNIQUE_INDEX |
+ ALTER_ADD_PK_INDEX;
+ if (!have_error &&
+ (ha_alter_info->handler_flags & add_index_related_flags)) {
+ have_error = storage_inplace_alter_table_add_index(altered_table,
+ ha_alter_info);
+ }
+
+ DBUG_RETURN(have_error);
+}
+
+bool ha_mroonga::inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool result;
+ if (share->wrapper_mode) {
+ result = wrapper_inplace_alter_table(altered_table, ha_alter_info);
+ } else {
+ result = storage_inplace_alter_table(altered_table, ha_alter_info);
+ }
+ DBUG_RETURN(result);
+}
+
+bool ha_mroonga::wrapper_commit_inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info,
+ bool commit)
+{
+ bool result;
+ MRN_DBUG_ENTER_METHOD();
+ if (!alter_handler_flags) {
+ free_root(&(wrap_altered_table_share->mem_root), MYF(0));
+ my_free(alter_key_info_buffer);
+ alter_key_info_buffer = NULL;
+ DBUG_RETURN(false);
+ }
+ MRN_SET_WRAP_ALTER_KEY(this, ha_alter_info);
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ result = wrap_handler->ha_commit_inplace_alter_table(wrap_altered_table,
+ ha_alter_info,
+ commit);
+ MRN_SET_BASE_ALTER_KEY(this, ha_alter_info);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ free_root(&(wrap_altered_table_share->mem_root), MYF(0));
+ my_free(alter_key_info_buffer);
+ alter_key_info_buffer = NULL;
+ DBUG_RETURN(result);
+}
+
+bool ha_mroonga::storage_commit_inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info,
+ bool commit)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(false);
+}
+
+bool ha_mroonga::commit_inplace_alter_table(
+ TABLE *altered_table,
+ Alter_inplace_info *ha_alter_info,
+ bool commit)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool result;
+ if (share->wrapper_mode) {
+ result = wrapper_commit_inplace_alter_table(altered_table, ha_alter_info,
+ commit);
+ } else {
+ result = storage_commit_inplace_alter_table(altered_table, ha_alter_info,
+ commit);
+ }
+ DBUG_RETURN(result);
+}
+#else
+alter_table_operations ha_mroonga::wrapper_alter_table_flags(alter_table_operations flags)
+{
+ alter_table_operations res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->alter_table_flags(flags);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+alter_table_operations ha_mroonga::storage_alter_table_flags(alter_table_operations flags)
+{
+ MRN_DBUG_ENTER_METHOD();
+ alter_table_operations res = handler::alter_table_flags(flags);
+ DBUG_RETURN(res);
+}
+
+alter_table_operations ha_mroonga::alter_table_flags(alter_table_operations flags)
+{
+ MRN_DBUG_ENTER_METHOD();
+ alter_table_operations res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_alter_table_flags(flags);
+ } else {
+ res = storage_alter_table_flags(flags);
+ }
+ DBUG_RETURN(res);
+}
+
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+int ha_mroonga::wrapper_add_index(TABLE *table_arg, KEY *key_info,
+ uint num_of_keys, handler_add_index **add)
+#else
+int ha_mroonga::wrapper_add_index(TABLE *table_arg, KEY *key_info,
+ uint num_of_keys)
+#endif
+{
+ int error = 0;
+ uint i, j, k;
+ uint n_keys = table->s->keys;
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, num_of_keys + n_keys);
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns, num_of_keys + n_keys);
+ THD *thd = ha_thd();
+ MRN_SHARE *tmp_share;
+ TABLE_SHARE tmp_table_share;
+ char **key_tokenizer;
+ uint *key_tokenizer_length;
+ MRN_DBUG_ENTER_METHOD();
+ if (!(wrap_alter_key_info = (KEY *) mrn_my_malloc(sizeof(KEY) * num_of_keys,
+ MYF(MY_WME)))) {
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+ KEY *p_key_info = &table->key_info[table_share->primary_key], *tmp_key_info;
+ tmp_table_share.keys = n_keys + num_of_keys;
+ tmp_table_share.fields = 0;
+ if (!(tmp_share = (MRN_SHARE *)
+ mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+ &tmp_share, sizeof(*tmp_share),
+ &key_tokenizer, sizeof(char *) * (n_keys + num_of_keys),
+ &key_tokenizer_length, sizeof(uint) * (n_keys + num_of_keys),
+ NullS))
+ ) {
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+ tmp_share->engine = NULL;
+ tmp_share->table_share = &tmp_table_share;
+ tmp_share->index_table = NULL;
+ tmp_share->index_table_length = NULL;
+ tmp_share->key_tokenizer = key_tokenizer;
+ tmp_share->key_tokenizer_length = key_tokenizer_length;
+ tmp_share->col_flags = NULL;
+ tmp_share->col_type = NULL;
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+ hnd_add_index = NULL;
+#endif
+ bitmap_clear_all(table->read_set);
+ mrn_set_bitmap_by_key(table->read_set, p_key_info);
+ mrn::PathMapper mapper(share->table_name);
+ for (i = 0, j = 0; i < num_of_keys; i++) {
+ if (!(key_info[i].flags & HA_FULLTEXT) && !mrn_is_geo_key(&key_info[i])) {
+ wrap_alter_key_info[j] = key_info[i];
+ j++;
+ continue;
+ }
+ if (share->disable_keys) {
+ continue;
+ }
+ if ((error = mrn_add_index_param(tmp_share, &key_info[i], i + n_keys)))
+ {
+ break;
+ }
+ index_tables[i + n_keys] = NULL;
+ if (
+ (key_info[i].flags & HA_FULLTEXT) &&
+ (error = wrapper_create_index_fulltext(mapper.table_name(),
+ i + n_keys,
+ &key_info[i], index_tables, NULL,
+ tmp_share))
+ ) {
+ break;
+ } else if (
+ mrn_is_geo_key(&key_info[i]) &&
+ (error = wrapper_create_index_geo(mapper.table_name(),
+ i + n_keys, &key_info[i],
+ index_tables, NULL, tmp_share))
+ ) {
+ break;
+ }
+ mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
+ }
+ if (!error && i > j && !share->disable_keys) {
+ for (k = 0; k < num_of_keys; k++) {
+ tmp_key_info = &key_info[k];
+ if (!(tmp_key_info->flags & HA_FULLTEXT) &&
+ !mrn_is_geo_key(tmp_key_info)) {
+ continue;
+ }
+ index_columns[k + n_keys] = grn_obj_column(ctx,
+ index_tables[k + n_keys],
+ INDEX_COLUMN_NAME,
+ strlen(INDEX_COLUMN_NAME));
+ }
+ error = wrapper_fill_indexes(thd, key_info, &index_columns[n_keys],
+ num_of_keys);
+ }
+ bitmap_set_all(table->read_set);
+
+ if (!error && j)
+ {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+ error = wrap_handler->add_index(table_arg, wrap_alter_key_info, j,
+ &hnd_add_index);
+#else
+ error = wrap_handler->add_index(table_arg, wrap_alter_key_info, j);
+#endif
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ if (error)
+ {
+ for (k = 0; k < i; k++) {
+ if (!(key_info[k].flags & HA_FULLTEXT) && !mrn_is_geo_key(&key_info[k]))
+ {
+ continue;
+ }
+ if (index_tables[k + n_keys])
+ {
+ grn_obj_remove(ctx, index_tables[k + n_keys]);
+ }
+ }
+ }
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+ else {
+ *add = new handler_add_index(table_arg, key_info, num_of_keys);
+ }
+#endif
+ mrn_free_share_alloc(tmp_share);
+ my_free(tmp_share);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+int ha_mroonga::storage_add_index(TABLE *table_arg, KEY *key_info,
+ uint num_of_keys, handler_add_index **add)
+#else
+int ha_mroonga::storage_add_index(TABLE *table_arg, KEY *key_info,
+ uint num_of_keys)
+#endif
+{
+ int error = 0;
+ uint i;
+ uint n_keys = table->s->keys;
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_tables, num_of_keys + n_keys);
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(grn_obj *, index_columns, num_of_keys + n_keys);
+ MRN_SHARE *tmp_share;
+ TABLE_SHARE tmp_table_share;
+ char **index_table, **key_tokenizer, **col_flags, **col_type;
+ uint *index_table_length, *key_tokenizer_length, *col_flags_length, *col_type_length;
+ bool have_multiple_column_index = false;
+
+ MRN_DBUG_ENTER_METHOD();
+ tmp_table_share.keys = n_keys + num_of_keys;
+ tmp_table_share.fields = 0;
+ if (!(tmp_share = (MRN_SHARE *)
+ mrn_my_multi_malloc(MYF(MY_WME | MY_ZEROFILL),
+ &tmp_share, sizeof(*tmp_share),
+ &index_table, sizeof(char*) * tmp_table_share.keys,
+ &index_table_length, sizeof(uint) * tmp_table_share.keys,
+ &key_tokenizer, sizeof(char *) * tmp_table_share.keys,
+ &key_tokenizer_length, sizeof(uint) * tmp_table_share.keys,
+ &col_flags, sizeof(char *) * tmp_table_share.fields,
+ &col_flags_length, sizeof(uint) * tmp_table_share.fields,
+ &col_type, sizeof(char *) * tmp_table_share.fields,
+ &col_type_length, sizeof(uint) * tmp_table_share.fields,
+ NullS))
+ ) {
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+ tmp_share->engine = NULL;
+ tmp_share->table_share = &tmp_table_share;
+ tmp_share->index_table = index_table;
+ tmp_share->index_table_length = index_table_length;
+ tmp_share->key_tokenizer = key_tokenizer;
+ tmp_share->key_tokenizer_length = key_tokenizer_length;
+ tmp_share->col_flags = col_flags;
+ tmp_share->col_flags_length = col_flags_length;
+ tmp_share->col_type = col_type;
+ tmp_share->col_type_length = col_type_length;
+ bitmap_clear_all(table->read_set);
+ mrn::PathMapper mapper(share->table_name);
+ for (i = 0; i < num_of_keys; i++) {
+ if (share->disable_keys && !(key_info[i].flags & HA_NOSAME)) {
+ continue; // key is disabled
+ }
+ index_tables[i + n_keys] = NULL;
+ index_columns[i + n_keys] = NULL;
+ if ((error = mrn_add_index_param(tmp_share, &key_info[i], i + n_keys)))
+ {
+ break;
+ }
+ if ((error = storage_create_index(table, mapper.table_name(), grn_table,
+ tmp_share, &key_info[i], index_tables,
+ index_columns, i + n_keys)))
+ {
+ break;
+ }
+ if (
+ KEY_N_KEY_PARTS(&(key_info[i])) == 1 &&
+ (key_info[i].flags & HA_NOSAME) &&
+ grn_table_size(ctx, grn_table) !=
+ grn_table_size(ctx, index_tables[i + n_keys])
+ ) {
+ error = HA_ERR_FOUND_DUPP_UNIQUE;
+ i++;
+ break;
+ }
+ if (
+ KEY_N_KEY_PARTS(&(key_info[i])) != 1 &&
+ !(key_info[i].flags & HA_FULLTEXT)
+ ) {
+ mrn_set_bitmap_by_key(table->read_set, &key_info[i]);
+ have_multiple_column_index = true;
+ }
+ }
+ if (!error && have_multiple_column_index)
+ {
+ error = storage_add_index_multiple_columns(key_info, num_of_keys,
+ index_tables + n_keys,
+ index_columns + n_keys, false);
+ }
+ bitmap_set_all(table->read_set);
+ if (error)
+ {
+ for (uint j = 0; j < i; j++) {
+ if (index_tables[j + n_keys])
+ {
+ grn_obj_remove(ctx, index_columns[j + n_keys]);
+ grn_obj_remove(ctx, index_tables[j + n_keys]);
+ }
+ }
+ }
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+ else {
+ *add = new handler_add_index(table_arg, key_info, num_of_keys);
+ }
+#endif
+ mrn_free_share_alloc(tmp_share);
+ my_free(tmp_share);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_tables);
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(index_columns);
+ DBUG_RETURN(error);
+}
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+int ha_mroonga::add_index(TABLE *table_arg, KEY *key_info,
+ uint num_of_keys, handler_add_index **add)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_add_index(table_arg, key_info, num_of_keys, add);
+ } else {
+ error = storage_add_index(table_arg, key_info, num_of_keys, add);
+ }
+ DBUG_RETURN(error);
+}
+#else
+int ha_mroonga::add_index(TABLE *table_arg, KEY *key_info,
+ uint num_of_keys)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_add_index(table_arg, key_info, num_of_keys);
+ } else {
+ error = storage_add_index(table_arg, key_info, num_of_keys);
+ }
+ DBUG_RETURN(error);
+}
+#endif
+
+#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX
+int ha_mroonga::wrapper_final_add_index(handler_add_index *add, bool commit)
+{
+ int error = 0;
+ MRN_DBUG_ENTER_METHOD();
+ if (hnd_add_index)
+ {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ error = wrap_handler->final_add_index(hnd_add_index, commit);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ if (add)
+ {
+ delete add;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_final_add_index(handler_add_index *add, bool commit)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (add)
+ {
+ delete add;
+ }
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::final_add_index(handler_add_index *add, bool commit)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+ if (share->wrapper_mode)
+ {
+ error = wrapper_final_add_index(add, commit);
+ } else {
+ error = storage_final_add_index(add, commit);
+ }
+ DBUG_RETURN(error);
+}
+#endif
+
+int ha_mroonga::wrapper_prepare_drop_index(TABLE *table_arg, uint *key_num,
+ uint num_of_keys)
+{
+ int res = 0;
+ uint i, j;
+ KEY *key_info = table_share->key_info;
+ MRN_DBUG_ENTER_METHOD();
+ res = mrn_change_encoding(ctx, system_charset_info);
+ if (res)
+ DBUG_RETURN(res);
+
+ MRN_ALLOCATE_VARIABLE_LENGTH_ARRAYS(uint, wrap_key_num, num_of_keys);
+ for (i = 0, j = 0; i < num_of_keys; i++) {
+ uint key_index = key_num[i];
+ if (!(key_info[key_index].flags & HA_FULLTEXT) &&
+ !mrn_is_geo_key(&key_info[key_index])) {
+ wrap_key_num[j] = share->wrap_key_nr[key_index];
+ j++;
+ continue;
+ }
+
+ res = drop_index(share, key_index);
+ if (res)
+ DBUG_RETURN(res);
+ grn_index_tables[key_index] = NULL;
+ grn_index_columns[key_index] = NULL;
+ }
+ if (j)
+ {
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->prepare_drop_index(table_arg, wrap_key_num, j);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ }
+ MRN_FREE_VARIABLE_LENGTH_ARRAYS(wrap_key_num);
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::storage_prepare_drop_index(TABLE *table_arg, uint *key_num,
+ uint num_of_keys)
+{
+ int error;
+ uint i;
+ MRN_DBUG_ENTER_METHOD();
+ error = mrn_change_encoding(ctx, system_charset_info);
+ if (error)
+ DBUG_RETURN(error);
+
+ for (i = 0; i < num_of_keys; i++) {
+ uint key_index = key_num[i];
+ error = drop_index(share, key_index);
+ if (error)
+ break;
+ grn_index_tables[key_index] = NULL;
+ grn_index_columns[key_index] = NULL;
+ }
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::prepare_drop_index(TABLE *table_arg, uint *key_num,
+ uint num_of_keys)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_prepare_drop_index(table_arg, key_num, num_of_keys);
+ } else {
+ res = storage_prepare_drop_index(table_arg, key_num, num_of_keys);
+ }
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::wrapper_final_drop_index(TABLE *table_arg)
+{
+ uint res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->final_drop_index(table_arg);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::storage_final_drop_index(TABLE *table_arg)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::final_drop_index(TABLE *table_arg)
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_final_drop_index(table_arg);
+ } else {
+ res = storage_final_drop_index(table_arg);
+ }
+ DBUG_RETURN(res);
+}
+#endif
+
+int ha_mroonga::wrapper_update_auto_increment()
+{
+ int res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->update_auto_increment();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::storage_update_auto_increment()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res = handler::update_auto_increment();
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ table->next_number_field->val_int()));
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::update_auto_increment()
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_update_auto_increment();
+ } else {
+ res = storage_update_auto_increment();
+ }
+ DBUG_RETURN(res);
+}
+
+void ha_mroonga::wrapper_set_next_insert_id(ulonglong id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->set_next_insert_id(id);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_set_next_insert_id(ulonglong id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::set_next_insert_id(id);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::set_next_insert_id(ulonglong id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ wrapper_set_next_insert_id(id);
+ } else {
+ storage_set_next_insert_id(id);
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::wrapper_get_auto_increment(ulonglong offset,
+ ulonglong increment,
+ ulonglong nb_desired_values,
+ ulonglong *first_value,
+ ulonglong *nb_reserved_values)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->get_auto_increment(offset, increment, nb_desired_values,
+ first_value, nb_reserved_values);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_get_auto_increment(ulonglong offset,
+ ulonglong increment,
+ ulonglong nb_desired_values,
+ ulonglong *first_value,
+ ulonglong *nb_reserved_values)
+{
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ MRN_DBUG_ENTER_METHOD();
+ if (table->found_next_number_field &&
+ !table->s->next_number_keypart) {
+ if (long_term_share->auto_inc_inited) {
+ *first_value = long_term_share->auto_inc_value;
+ DBUG_PRINT("info", ("mroonga: *first_value(auto_inc_value)=%llu",
+ *first_value));
+ *nb_reserved_values = UINT_MAX64;
+ } else {
+ handler::get_auto_increment(offset, increment, nb_desired_values,
+ first_value, nb_reserved_values);
+ long_term_share->auto_inc_value = *first_value;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ long_term_share->auto_inc_inited = true;
+ }
+ } else {
+ handler::get_auto_increment(offset, increment, nb_desired_values,
+ first_value, nb_reserved_values);
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::get_auto_increment(ulonglong offset, ulonglong increment,
+ ulonglong nb_desired_values,
+ ulonglong *first_value,
+ ulonglong *nb_reserved_values)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ wrapper_get_auto_increment(offset, increment, nb_desired_values,
+ first_value, nb_reserved_values);
+ } else {
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ mrn::Lock lock(&long_term_share->auto_inc_mutex);
+ storage_get_auto_increment(offset, increment, nb_desired_values,
+ first_value, nb_reserved_values);
+ long_term_share->auto_inc_value += nb_desired_values * increment;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::wrapper_restore_auto_increment(ulonglong prev_insert_id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->restore_auto_increment(prev_insert_id);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_restore_auto_increment(ulonglong prev_insert_id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::restore_auto_increment(prev_insert_id);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::restore_auto_increment(ulonglong prev_insert_id)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ wrapper_restore_auto_increment(prev_insert_id);
+ } else {
+ storage_restore_auto_increment(prev_insert_id);
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::wrapper_release_auto_increment()
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->ha_release_auto_increment();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_release_auto_increment()
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::release_auto_increment()
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ wrapper_release_auto_increment();
+ } else {
+ storage_release_auto_increment();
+ }
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::wrapper_check_for_upgrade(HA_CHECK_OPT *check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ int error = wrap_handler->ha_check_for_upgrade(check_opt);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(error);
+}
+
+int ha_mroonga::storage_check_for_upgrade(HA_CHECK_OPT *check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ for (uint i = 0; i < table->s->fields; ++i) {
+ grn_obj *column = grn_columns[i];
+ if (!column) {
+ continue;
+ }
+ Field *field = table->field[i];
+ grn_id column_range = grn_obj_get_range(ctx, column);
+ switch (field->real_type()) {
+ case MYSQL_TYPE_ENUM:
+ if (column_range != GRN_DB_UINT16) {
+ DBUG_RETURN(HA_ADMIN_NEEDS_ALTER);
+ }
+ break;
+ case MYSQL_TYPE_SET:
+ if (column_range != GRN_DB_UINT64) {
+ DBUG_RETURN(HA_ADMIN_NEEDS_ALTER);
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ DBUG_RETURN(HA_ADMIN_OK);
+}
+
+int ha_mroonga::check_for_upgrade(HA_CHECK_OPT *check_opt)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int error;
+ if (share->wrapper_mode) {
+ error = wrapper_check_for_upgrade(check_opt);
+ } else {
+ error = storage_check_for_upgrade(check_opt);
+ }
+ DBUG_RETURN(error);
+}
+
+#ifdef MRN_HANDLER_HAVE_RESET_AUTO_INCREMENT
+int ha_mroonga::wrapper_reset_auto_increment(ulonglong value)
+{
+ int res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->ha_reset_auto_increment(value);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::storage_reset_auto_increment(ulonglong value)
+{
+ MRN_LONG_TERM_SHARE *long_term_share = share->long_term_share;
+ MRN_DBUG_ENTER_METHOD();
+ mrn::Lock lock(&long_term_share->auto_inc_mutex);
+ long_term_share->auto_inc_value = value;
+ DBUG_PRINT("info", ("mroonga: auto_inc_value=%llu",
+ long_term_share->auto_inc_value));
+ long_term_share->auto_inc_inited = true;
+ DBUG_RETURN(0);
+}
+
+int ha_mroonga::reset_auto_increment(ulonglong value)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_reset_auto_increment(value);
+ } else {
+ res = storage_reset_auto_increment(value);
+ }
+ DBUG_RETURN(res);
+}
+#endif
+
+void ha_mroonga::set_pk_bitmap()
+{
+ MRN_DBUG_ENTER_METHOD();
+ KEY *key_info = &(table->key_info[table_share->primary_key]);
+ uint j;
+ for (j = 0; j < KEY_N_KEY_PARTS(key_info); j++) {
+ Field *field = key_info->key_part[j].field;
+ bitmap_set_bit(table->read_set, field->field_index);
+ }
+ DBUG_VOID_RETURN;
+}
+
+bool ha_mroonga::wrapper_was_semi_consistent_read()
+{
+ bool res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->was_semi_consistent_read();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::storage_was_semi_consistent_read()
+{
+ bool res;
+ MRN_DBUG_ENTER_METHOD();
+ res = handler::was_semi_consistent_read();
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::was_semi_consistent_read()
+{
+ bool res;
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ res = wrapper_was_semi_consistent_read();
+ } else {
+ res = storage_was_semi_consistent_read();
+ }
+ DBUG_RETURN(res);
+}
+
+void ha_mroonga::wrapper_try_semi_consistent_read(bool yes)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->try_semi_consistent_read(yes);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_try_semi_consistent_read(bool yes)
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::try_semi_consistent_read(yes);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::try_semi_consistent_read(bool yes)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ wrapper_try_semi_consistent_read(yes);
+ } else {
+ storage_try_semi_consistent_read(yes);
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::wrapper_unlock_row()
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->unlock_row();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_unlock_row()
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::unlock_row();
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::unlock_row()
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ wrapper_unlock_row();
+ } else {
+ storage_unlock_row();
+ }
+ DBUG_VOID_RETURN;
+}
+
+int ha_mroonga::wrapper_start_stmt(THD *thd, thr_lock_type lock_type)
+{
+ int res;
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->start_stmt(thd, lock_type);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::storage_start_stmt(THD *thd, thr_lock_type lock_type)
+{
+ int res;
+ MRN_DBUG_ENTER_METHOD();
+ res = handler::start_stmt(thd, lock_type);
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::start_stmt(THD *thd, thr_lock_type lock_type)
+{
+ int res;
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ res = wrapper_start_stmt(thd, lock_type);
+ } else {
+ res = storage_start_stmt(thd, lock_type);
+ }
+ DBUG_RETURN(res);
+}
+
+void ha_mroonga::wrapper_change_table_ptr(TABLE *table_arg,
+ TABLE_SHARE *share_arg)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->change_table_ptr(table_arg, share->wrap_table_share);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_change_table_ptr(TABLE *table_arg,
+ TABLE_SHARE *share_arg)
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::change_table_ptr(TABLE *table_arg, TABLE_SHARE *share_arg)
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::change_table_ptr(table_arg, share_arg);
+ if (share && share->wrapper_mode)
+ {
+ wrapper_change_table_ptr(table_arg, share_arg);
+ } else {
+ storage_change_table_ptr(table_arg, share_arg);
+ }
+ DBUG_VOID_RETURN;
+}
+
+bool ha_mroonga::wrapper_is_fk_defined_on_table_or_index(uint index)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool res;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->is_fk_defined_on_table_or_index(index);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::storage_is_fk_defined_on_table_or_index(uint index)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool res = handler::is_fk_defined_on_table_or_index(index);
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::is_fk_defined_on_table_or_index(uint index)
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_is_fk_defined_on_table_or_index(index);
+ } else {
+ res = storage_is_fk_defined_on_table_or_index(index);
+ }
+ DBUG_RETURN(res);
+}
+
+char *ha_mroonga::wrapper_get_foreign_key_create_info()
+{
+ MRN_DBUG_ENTER_METHOD();
+ char *res;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->get_foreign_key_create_info();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+#ifdef MRN_SUPPORT_FOREIGN_KEYS
+char *ha_mroonga::storage_get_foreign_key_create_info()
+{
+ int error;
+ uint i;
+ grn_obj *column;
+ uint n_columns = table_share->fields;
+ char create_info_buff[2048], *create_info;
+ String create_info_str(create_info_buff, sizeof(create_info_buff),
+ system_charset_info);
+ MRN_DBUG_ENTER_METHOD();
+ create_info_str.length(0);
+ for (i = 0; i < n_columns; ++i) {
+ Field *field = table_share->field[i];
+
+ if (!is_foreign_key_field(table_share->table_name.str,
+ field->field_name.str)) {
+ continue;
+ }
+
+ mrn::ColumnName column_name(field->field_name);
+ column = grn_obj_column(ctx,
+ grn_table,
+ column_name.c_str(),
+ column_name.length());
+ if (!column) {
+ continue;
+ }
+ grn_id ref_table_id = grn_obj_get_range(ctx, column);
+ grn_obj *ref_table = grn_ctx_at(ctx, ref_table_id);
+ char ref_table_buff[NAME_LEN + 1];
+ int ref_table_name_length = grn_obj_name(ctx, ref_table, ref_table_buff,
+ NAME_LEN);
+ ref_table_buff[ref_table_name_length] = '\0';
+
+ if (create_info_str.reserve(15)) {
+ DBUG_RETURN(NULL);
+ }
+ create_info_str.q_append(",\n CONSTRAINT ", 15);
+ append_identifier(ha_thd(),
+ &create_info_str,
+ column_name.c_str(),
+ column_name.length());
+ if (create_info_str.reserve(14)) {
+ DBUG_RETURN(NULL);
+ }
+ create_info_str.q_append(" FOREIGN KEY (", 14);
+ append_identifier(ha_thd(),
+ &create_info_str,
+ column_name.c_str(),
+ column_name.length());
+ if (create_info_str.reserve(13)) {
+ DBUG_RETURN(NULL);
+ }
+ create_info_str.q_append(") REFERENCES ", 13);
+ append_identifier(ha_thd(), &create_info_str, table_share->db.str,
+ table_share->db.length);
+ if (create_info_str.reserve(1)) {
+ DBUG_RETURN(NULL);
+ }
+ create_info_str.q_append(".", 1);
+ append_identifier(ha_thd(), &create_info_str, ref_table_buff,
+ ref_table_name_length);
+ if (create_info_str.reserve(2)) {
+ DBUG_RETURN(NULL);
+ }
+ create_info_str.q_append(" (", 2);
+
+ char ref_path[FN_REFLEN + 1];
+ TABLE_LIST table_list;
+ TABLE_SHARE *tmp_ref_table_share;
+ build_table_filename(ref_path, sizeof(ref_path) - 1,
+ table_share->db.str, ref_table_buff, "", 0);
+ DBUG_PRINT("info", ("mroonga: ref_path=%s", ref_path));
+
+ LEX_CSTRING table_name= { ref_table_buff, (size_t) ref_table_name_length };
+ table_list.init_one_table(&table_share->db, &table_name, 0, TL_WRITE);
+ mrn_open_mutex_lock(table_share);
+ tmp_ref_table_share =
+ mrn_create_tmp_table_share(&table_list, ref_path, &error);
+ mrn_open_mutex_unlock(table_share);
+ if (!tmp_ref_table_share) {
+ DBUG_RETURN(NULL);
+ }
+ uint ref_pkey_nr = tmp_ref_table_share->primary_key;
+ KEY *ref_key_info = &tmp_ref_table_share->key_info[ref_pkey_nr];
+ Field *ref_field = &ref_key_info->key_part->field[0];
+ append_identifier(ha_thd(), &create_info_str, ref_field->field_name.str,
+ ref_field->field_name.length);
+ mrn_open_mutex_lock(table_share);
+ mrn_free_tmp_table_share(tmp_ref_table_share);
+ mrn_open_mutex_unlock(table_share);
+ if (create_info_str.reserve(39)) {
+ DBUG_RETURN(NULL);
+ }
+ create_info_str.q_append(") ON DELETE RESTRICT ON UPDATE RESTRICT", 39);
+ }
+ if (!(create_info = (char *) mrn_my_malloc(create_info_str.length() + 1,
+ MYF(MY_WME)))) {
+ DBUG_RETURN(NULL);
+ }
+ memcpy(create_info, create_info_str.ptr(), create_info_str.length());
+ create_info[create_info_str.length()] = '\0';
+ DBUG_RETURN(create_info);
+}
+#else
+char *ha_mroonga::storage_get_foreign_key_create_info()
+{
+ MRN_DBUG_ENTER_METHOD();
+ char *res = handler::get_foreign_key_create_info();
+ DBUG_RETURN(res);
+}
+#endif
+
+char *ha_mroonga::get_foreign_key_create_info()
+{
+ MRN_DBUG_ENTER_METHOD();
+ char *res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_get_foreign_key_create_info();
+ } else {
+ res = storage_get_foreign_key_create_info();
+ }
+ DBUG_RETURN(res);
+}
+
+#ifdef MRN_HANDLER_HAVE_GET_TABLESPACE_NAME
+char *ha_mroonga::wrapper_get_tablespace_name(THD *thd, char *name,
+ uint name_len)
+{
+ MRN_DBUG_ENTER_METHOD();
+ char *res;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->get_tablespace_name(thd, name, name_len);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+char *ha_mroonga::storage_get_tablespace_name(THD *thd, char *name,
+ uint name_len)
+{
+ MRN_DBUG_ENTER_METHOD();
+ char *res = handler::get_tablespace_name(thd, name, name_len);
+ DBUG_RETURN(res);
+}
+
+char *ha_mroonga::get_tablespace_name(THD *thd, char *name, uint name_len)
+{
+ MRN_DBUG_ENTER_METHOD();
+ char *res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_get_tablespace_name(thd, name, name_len);
+ } else {
+ res = storage_get_tablespace_name(thd, name, name_len);
+ }
+ DBUG_RETURN(res);
+}
+#endif
+
+bool ha_mroonga::wrapper_can_switch_engines()
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool res;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->can_switch_engines();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::storage_can_switch_engines()
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool res = handler::can_switch_engines();
+ DBUG_RETURN(res);
+}
+
+bool ha_mroonga::can_switch_engines()
+{
+ MRN_DBUG_ENTER_METHOD();
+ bool res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_can_switch_engines();
+ } else {
+ res = storage_can_switch_engines();
+ }
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::wrapper_get_foreign_key_list(THD *thd,
+ List<FOREIGN_KEY_INFO> *f_key_list)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->get_foreign_key_list(thd, f_key_list);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+#ifdef MRN_SUPPORT_FOREIGN_KEYS
+int ha_mroonga::storage_get_foreign_key_list(THD *thd,
+ List<FOREIGN_KEY_INFO> *f_key_list)
+{
+ int error;
+ uint i;
+ grn_obj *column;
+ uint n_columns = table_share->fields;
+ MRN_DBUG_ENTER_METHOD();
+ for (i = 0; i < n_columns; ++i) {
+ Field *field = table_share->field[i];
+
+ if (!is_foreign_key_field(table_share->table_name.str,
+ field->field_name.str)) {
+ continue;
+ }
+
+ mrn::ColumnName column_name(field->field_name);
+ column = grn_obj_column(ctx,
+ grn_table,
+ column_name.c_str(),
+ column_name.length());
+ if (!column) {
+ continue;
+ }
+ grn_id ref_table_id = grn_obj_get_range(ctx, column);
+ grn_obj *ref_table = grn_ctx_at(ctx, ref_table_id);
+ FOREIGN_KEY_INFO f_key_info;
+ f_key_info.foreign_id = thd_make_lex_string(thd,
+ NULL,
+ column_name.c_str(),
+ column_name.length(),
+ TRUE);
+ f_key_info.foreign_db = thd_make_lex_string(thd, NULL,
+ table_share->db.str,
+ table_share->db.length,
+ TRUE);
+ f_key_info.foreign_table = thd_make_lex_string(thd, NULL,
+ table_share->table_name.str,
+ table_share->table_name.length,
+ TRUE);
+ f_key_info.referenced_db = f_key_info.foreign_db;
+
+ char ref_table_buff[NAME_LEN + 1];
+ int ref_table_name_length = grn_obj_name(ctx, ref_table, ref_table_buff,
+ NAME_LEN);
+ ref_table_buff[ref_table_name_length] = '\0';
+ DBUG_PRINT("info", ("mroonga: ref_table_buff=%s", ref_table_buff));
+ DBUG_PRINT("info", ("mroonga: ref_table_name_length=%d", ref_table_name_length));
+ f_key_info.referenced_table = thd_make_lex_string(thd, NULL,
+ ref_table_buff,
+ ref_table_name_length,
+ TRUE);
+ f_key_info.update_method = FK_OPTION_RESTRICT;
+ f_key_info.delete_method = FK_OPTION_RESTRICT;
+ f_key_info.referenced_key_name = thd_make_lex_string(thd, NULL, "PRIMARY",
+ 7, TRUE);
+ LEX_CSTRING *field_name = thd_make_lex_string(thd,
+ NULL,
+ column_name.c_str(),
+ column_name.length(),
+ TRUE);
+ f_key_info.foreign_fields.push_back(field_name);
+
+ char ref_path[FN_REFLEN + 1];
+ TABLE_LIST table_list;
+ TABLE_SHARE *tmp_ref_table_share;
+ build_table_filename(ref_path, sizeof(ref_path) - 1,
+ table_share->db.str, ref_table_buff, "", 0);
+ DBUG_PRINT("info", ("mroonga: ref_path=%s", ref_path));
+
+ LEX_CSTRING table_name= { ref_table_buff, (size_t) ref_table_name_length };
+ table_list.init_one_table(&table_share->db, &table_name, 0, TL_WRITE);
+ mrn_open_mutex_lock(table_share);
+ tmp_ref_table_share =
+ mrn_create_tmp_table_share(&table_list, ref_path, &error);
+ mrn_open_mutex_unlock(table_share);
+ if (!tmp_ref_table_share) {
+ DBUG_RETURN(error);
+ }
+ uint ref_pkey_nr = tmp_ref_table_share->primary_key;
+ KEY *ref_key_info = &tmp_ref_table_share->key_info[ref_pkey_nr];
+ Field *ref_field = &ref_key_info->key_part->field[0];
+ LEX_CSTRING *ref_col_name = thd_make_lex_string(thd, NULL,
+ ref_field->field_name.str,
+ ref_field->field_name.length,
+ TRUE);
+ f_key_info.referenced_fields.push_back(ref_col_name);
+ mrn_open_mutex_lock(table_share);
+ mrn_free_tmp_table_share(tmp_ref_table_share);
+ mrn_open_mutex_unlock(table_share);
+ FOREIGN_KEY_INFO *p_f_key_info =
+ (FOREIGN_KEY_INFO *) thd_memdup(thd, &f_key_info,
+ sizeof(FOREIGN_KEY_INFO));
+ if (!p_f_key_info) {
+ DBUG_RETURN(HA_ERR_OUT_OF_MEM);
+ }
+ f_key_list->push_back(p_f_key_info);
+ }
+ DBUG_RETURN(0);
+}
+#else
+int ha_mroonga::storage_get_foreign_key_list(THD *thd,
+ List<FOREIGN_KEY_INFO> *f_key_list)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res = handler::get_foreign_key_list(thd, f_key_list);
+ DBUG_RETURN(res);
+}
+#endif
+
+int ha_mroonga::get_foreign_key_list(THD *thd,
+ List<FOREIGN_KEY_INFO> *f_key_list)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_get_foreign_key_list(thd, f_key_list);
+ } else {
+ res = storage_get_foreign_key_list(thd, f_key_list);
+ }
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::wrapper_get_parent_foreign_key_list(THD *thd,
+ List<FOREIGN_KEY_INFO> *f_key_list)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->get_parent_foreign_key_list(thd, f_key_list);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::storage_get_parent_foreign_key_list(THD *thd,
+ List<FOREIGN_KEY_INFO> *f_key_list)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res = handler::get_parent_foreign_key_list(thd, f_key_list);
+ DBUG_RETURN(res);
+}
+
+int ha_mroonga::get_parent_foreign_key_list(THD *thd,
+ List<FOREIGN_KEY_INFO> *f_key_list)
+{
+ MRN_DBUG_ENTER_METHOD();
+ int res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_get_parent_foreign_key_list(thd, f_key_list);
+ } else {
+ res = storage_get_parent_foreign_key_list(thd, f_key_list);
+ }
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::wrapper_referenced_by_foreign_key()
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint res;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->referenced_by_foreign_key();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::storage_referenced_by_foreign_key()
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint res = handler::referenced_by_foreign_key();
+ DBUG_RETURN(res);
+}
+
+uint ha_mroonga::referenced_by_foreign_key()
+{
+ MRN_DBUG_ENTER_METHOD();
+ uint res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_referenced_by_foreign_key();
+ } else {
+ res = storage_referenced_by_foreign_key();
+ }
+ DBUG_RETURN(res);
+}
+
+void ha_mroonga::wrapper_init_table_handle_for_HANDLER()
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->init_table_handle_for_HANDLER();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_init_table_handle_for_HANDLER()
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::init_table_handle_for_HANDLER();
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::init_table_handle_for_HANDLER()
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ wrapper_init_table_handle_for_HANDLER();
+ } else {
+ storage_init_table_handle_for_HANDLER();
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::wrapper_free_foreign_key_create_info(char* str)
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->free_foreign_key_create_info(str);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+#ifdef MRN_SUPPORT_FOREIGN_KEYS
+void ha_mroonga::storage_free_foreign_key_create_info(char* str)
+{
+ MRN_DBUG_ENTER_METHOD();
+ my_free(str);
+ DBUG_VOID_RETURN;
+}
+#else
+void ha_mroonga::storage_free_foreign_key_create_info(char* str)
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::free_foreign_key_create_info(str);
+ DBUG_VOID_RETURN;
+}
+#endif
+
+void ha_mroonga::free_foreign_key_create_info(char* str)
+{
+ MRN_DBUG_ENTER_METHOD();
+ if (share->wrapper_mode)
+ {
+ wrapper_free_foreign_key_create_info(str);
+ } else {
+ storage_free_foreign_key_create_info(str);
+ }
+ DBUG_VOID_RETURN;
+}
+
+#ifdef MRN_RBR_UPDATE_NEED_ALL_COLUMNS
+bool ha_mroonga::check_written_by_row_based_binlog()
+{
+ MRN_DBUG_ENTER_METHOD();
+ THD *thd = ha_thd();
+
+ int current_stmt_binlog_row;
+#ifdef MRN_ROW_BASED_CHECK_IS_METHOD
+ current_stmt_binlog_row = thd->is_current_stmt_binlog_format_row();
+#else
+ current_stmt_binlog_row = thd->current_stmt_binlog_row_based;
+#endif
+ if (!current_stmt_binlog_row) {
+ DBUG_RETURN(false);
+ }
+
+ if (table->s->tmp_table != NO_TMP_TABLE) {
+ DBUG_RETURN(false);
+ }
+
+ if (!mrn_binlog_filter->db_ok(table->s->db.str)) {
+ DBUG_RETURN(false);
+ }
+
+ if (!thd_test_options(thd, OPTION_BIN_LOG)) {
+ DBUG_RETURN(false);
+ }
+
+ if (!mysql_bin_log.is_open()) {
+ DBUG_RETURN(false);
+ }
+
+ DBUG_RETURN(true);
+}
+#endif
+
+#ifdef MRN_HAVE_HA_REBIND_PSI
+void ha_mroonga::wrapper_unbind_psi()
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->unbind_psi();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_unbind_psi()
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::unbind_psi()
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::unbind_psi();
+ if (share->wrapper_mode)
+ {
+ wrapper_unbind_psi();
+ } else {
+ storage_unbind_psi();
+ }
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::wrapper_rebind()
+{
+ MRN_DBUG_ENTER_METHOD();
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ wrap_handler->rebind_psi();
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::storage_rebind()
+{
+ MRN_DBUG_ENTER_METHOD();
+ DBUG_VOID_RETURN;
+}
+
+void ha_mroonga::rebind_psi()
+{
+ MRN_DBUG_ENTER_METHOD();
+ handler::rebind_psi();
+ if (share->wrapper_mode)
+ {
+ wrapper_rebind();
+ } else {
+ storage_rebind();
+ }
+ DBUG_VOID_RETURN;
+}
+#endif
+
+my_bool ha_mroonga::wrapper_register_query_cache_table(THD *thd,
+ const char *table_key,
+ uint key_length,
+ qc_engine_callback
+ *engine_callback,
+ ulonglong *engine_data)
+{
+ MRN_DBUG_ENTER_METHOD();
+ my_bool res;
+ MRN_SET_WRAP_SHARE_KEY(share, table->s);
+ MRN_SET_WRAP_TABLE_KEY(this, table);
+ res = wrap_handler->register_query_cache_table(thd,
+ table_key,
+ key_length,
+ engine_callback,
+ engine_data);
+ MRN_SET_BASE_SHARE_KEY(share, table->s);
+ MRN_SET_BASE_TABLE_KEY(this, table);
+ DBUG_RETURN(res);
+}
+
+my_bool ha_mroonga::storage_register_query_cache_table(THD *thd,
+ const char *table_key,
+ uint key_length,
+ qc_engine_callback
+ *engine_callback,
+ ulonglong *engine_data)
+{
+ MRN_DBUG_ENTER_METHOD();
+ my_bool res = handler::register_query_cache_table(thd,
+ table_key,
+ key_length,
+ engine_callback,
+ engine_data);
+ DBUG_RETURN(res);
+}
+
+my_bool ha_mroonga::register_query_cache_table(THD *thd,
+ const char *table_key,
+ uint key_length,
+ qc_engine_callback
+ *engine_callback,
+ ulonglong *engine_data)
+{
+ MRN_DBUG_ENTER_METHOD();
+ my_bool res;
+ if (share->wrapper_mode)
+ {
+ res = wrapper_register_query_cache_table(thd,
+ table_key,
+ key_length,
+ engine_callback,
+ engine_data);
+ } else {
+ res = storage_register_query_cache_table(thd,
+ table_key,
+ key_length,
+ engine_callback,
+ engine_data);
+ }
+ DBUG_RETURN(res);
+}
+
+#ifdef __cplusplus
+}
+#endif
+
+namespace mrn {
+ namespace variables {
+ ulonglong get_boolean_mode_syntax_flags(THD *thd) {
+ ulonglong flags = BOOLEAN_MODE_SYNTAX_FLAG_DEFAULT;
+#ifdef MRN_SUPPORT_THDVAR_SET
+ flags = THDVAR(thd, boolean_mode_syntax_flags);
+#endif
+ return flags;
+ }
+
+ ActionOnError get_action_on_fulltext_query_error(THD *thd) {
+ ulong action = THDVAR(thd, action_on_fulltext_query_error);
+ return static_cast<ActionOnError>(action);
+ }
+ }
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-17 12:50:47 +0000