mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-05-17 20:37:12 +02:00
Code Issues Projects Releases Packages Wiki Activity

Merge branch '11.1' into 11.2

Browse source
This commit is contained in:
Sergei Golubchik 2024-05-13 10:00:26 +02:00
commit bf5da43e50
859 changed files with 19953 additions and 6532 deletions
Download patch file Download diff file Expand all files Collapse all files

358
storage/mroonga/ha_mroonga.cpp
View file

@ -4352,9 +4352,9 @@ int ha_mroonga::wrapper_open(const char *name, int mode, uint open_options)
// 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);
error = wrapper_disable_indexes_mroonga(key_map(table->s->keys), false);
if (!error) {
error = wrapper_enable_indexes_mroonga(HA_KEY_SWITCH_ALL);
error = wrapper_enable_indexes_mroonga(key_map(table->s->keys), false);
}
}
}
@ -13678,197 +13678,184 @@ int ha_mroonga::generic_disable_index(int i, KEY *key_info)
DBUG_RETURN(error);
}
int ha_mroonga::wrapper_disable_indexes_mroonga(uint mode)
int ha_mroonga::wrapper_disable_indexes_mroonga(key_map map, bool persist)
{
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);
}
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;
}
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;
}
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 ha_mroonga::wrapper_disable_indexes(key_map map, bool persist)
{
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);
error = wrap_handler->ha_disable_indexes(map, persist);
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);
error = wrapper_disable_indexes_mroonga(map, persist);
}
DBUG_RETURN(error);
}
int ha_mroonga::storage_disable_indexes(uint mode)
int ha_mroonga::storage_disable_indexes(key_map map, bool persist)
{
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);
}
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 (map.is_set(i)) {
continue;
}
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;
}
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 ha_mroonga::disable_indexes(key_map map, bool persist)
{
int error = 0;
MRN_DBUG_ENTER_METHOD();
if (share->wrapper_mode)
{
error = wrapper_disable_indexes(mode);
error = wrapper_disable_indexes(map, persist);
} else {
error = storage_disable_indexes(mode);
error = storage_disable_indexes(map, persist);
}
DBUG_RETURN(error);
}
int ha_mroonga::wrapper_enable_indexes_mroonga(uint mode)
int ha_mroonga::wrapper_enable_indexes_mroonga(key_map map, bool persist)
{
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;
}
uint i, j;
for (i = 0; i < table_share->keys; i++) {
if (i == table->s->primary_key) {
continue;
}
if (i == table_share->keys) {
DBUG_PRINT("info", ("mroonga: keys are enabled already"));
DBUG_RETURN(0);
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;
}
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)
if ((error = mrn_add_index_param(share, &key_info[i], i)))
{
error = wrapper_fill_indexes(ha_thd(), table->key_info, index_columns,
n_keys);
break;
}
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;
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);
DBUG_RETURN(error);
}
int ha_mroonga::wrapper_enable_indexes(uint mode)
int ha_mroonga::wrapper_enable_indexes(key_map map, bool persist)
{
int error = 0;
MRN_DBUG_ENTER_METHOD();
int mroonga_error = wrapper_enable_indexes_mroonga(mode);
int mroonga_error = wrapper_enable_indexes_mroonga(map, persist);
MRN_SET_WRAP_SHARE_KEY(share, table->s);
MRN_SET_WRAP_TABLE_KEY(this, table);
error = wrap_handler->ha_enable_indexes(mode);
error = wrap_handler->ha_enable_indexes(map, persist);
MRN_SET_BASE_SHARE_KEY(share, table->s);
MRN_SET_BASE_TABLE_KEY(this, table);
if (error == HA_ERR_WRONG_COMMAND) {
@ -13877,95 +13864,86 @@ int ha_mroonga::wrapper_enable_indexes(uint mode)
DBUG_RETURN(error);
}
int ha_mroonga::storage_enable_indexes(uint mode)
int ha_mroonga::storage_enable_indexes(key_map map, bool persist)
{
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;
}
uint i;
for (i = 0; i < n_keys; i++) {
if (i == table->s->primary_key) {
continue;
}
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);
if (!grn_index_columns[i]) {
break;
}
}
if (i == n_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 < n_keys; i++) {
if (!map.is_set(i)) {
continue;
}
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)))
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;
}
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 (
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);
}
if (!error && have_multiple_column_index)
{
bool skip_unique_key= !table->s->keys_in_use.is_clear_all();
error = storage_add_index_multiple_columns(key_info, n_keys,
index_tables,
index_columns,
skip_unique_key);
}
bitmap_set_all(table->read_set);
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 ha_mroonga::enable_indexes(key_map map, bool persist)
{
int error = 0;
MRN_DBUG_ENTER_METHOD();
share->disable_keys = false;
if (share->wrapper_mode)
{
error = wrapper_enable_indexes(mode);
error = wrapper_enable_indexes(map, persist);
} else {
error = storage_enable_indexes(mode);
error = storage_enable_indexes(map, persist);
}
DBUG_RETURN(error);
}

16
storage/mroonga/ha_mroonga.hpp
View file

@ -544,8 +544,8 @@ public:
bool is_crashed() const mrn_override;
bool auto_repair(int error) const mrn_override;
bool auto_repair() const;
int disable_indexes(uint mode) mrn_override;
int enable_indexes(uint mode) mrn_override;
int disable_indexes(key_map map, bool persist) mrn_override;
int enable_indexes(key_map map, bool persist) mrn_override;
int check(THD* thd, HA_CHECK_OPT* check_opt) mrn_override;
int repair(THD* thd, HA_CHECK_OPT* check_opt) mrn_override;
bool check_and_repair(THD *thd) mrn_override;
@ -1146,12 +1146,12 @@ private:
bool wrapper_auto_repair(int error) const;
bool storage_auto_repair(int error) const;
int generic_disable_index(int i, KEY *key_info);
int wrapper_disable_indexes_mroonga(uint mode);
int wrapper_disable_indexes(uint mode);
int storage_disable_indexes(uint mode);
int wrapper_enable_indexes_mroonga(uint mode);
int wrapper_enable_indexes(uint mode);
int storage_enable_indexes(uint mode);
int wrapper_disable_indexes_mroonga(key_map map, bool persist);
int wrapper_disable_indexes(key_map map, bool persist);
int storage_disable_indexes(key_map map, bool persist);
int wrapper_enable_indexes_mroonga(key_map map, bool persist);
int wrapper_enable_indexes(key_map map, bool persist);
int storage_enable_indexes(key_map map, bool persist);
int wrapper_check(THD* thd, HA_CHECK_OPT* check_opt);
int storage_check(THD* thd, HA_CHECK_OPT* check_opt);
int wrapper_fill_indexes(THD *thd, KEY *key_info,

1
storage/mroonga/vendor/groonga/CMakeLists.txt vendored
View file

@ -200,6 +200,7 @@ endif()
include_directories(
BEFORE
${CMAKE_SOURCE_DIR}/include
${CMAKE_CURRENT_BINARY_DIR}
${CMAKE_CURRENT_SOURCE_DIR}/include
${CMAKE_CURRENT_SOURCE_DIR}/lib

18
storage/mroonga/vendor/groonga/lib/db.c vendored
View file

@ -38,6 +38,7 @@
#include "grn_util.h"
#include "grn_cache.h"
#include "grn_window_functions.h"
#include <my_attribute.h>
#include <string.h>
#include <math.h>
@ -1060,6 +1061,8 @@ grn_table_create_validate(grn_ctx *ctx, const char *name, unsigned int name_size
return ctx->rc;
}
PRAGMA_DISABLE_CHECK_STACK_FRAME
static grn_obj *
grn_table_create_with_max_n_subrecs(grn_ctx *ctx, const char *name,
unsigned int name_size, const char *path,
@ -1238,6 +1241,7 @@ grn_table_create_with_max_n_subrecs(grn_ctx *ctx, const char *name,
}
return res;
}
PRAGMA_REENABLE_CHECK_STACK_FRAME
grn_obj *
grn_table_create(grn_ctx *ctx, const char *name, unsigned int name_size,
@ -4776,6 +4780,9 @@ _grn_table_key(grn_ctx *ctx, grn_obj *table, grn_id id, uint32_t *key_size)
/* column */
PRAGMA_DISABLE_CHECK_STACK_FRAME
grn_obj *
grn_column_create(grn_ctx *ctx, grn_obj *table,
const char *name, unsigned int name_size,
@ -4978,6 +4985,7 @@ exit :
if (!res && id) { grn_obj_delete_by_id(ctx, db, id, GRN_TRUE); }
GRN_API_RETURN(res);
}
PRAGMA_REENABLE_CHECK_STACK_FRAME
grn_obj *
grn_column_open(grn_ctx *ctx, grn_obj *table,
@ -8540,6 +8548,8 @@ grn_obj_spec_save(grn_ctx *ctx, grn_db_obj *obj)
grn_obj_close(ctx, &v);
}
PRAGMA_DISABLE_CHECK_STACK_FRAME
inline static void
grn_obj_set_info_source_invalid_lexicon_error(grn_ctx *ctx,
const char *message,
@ -8590,6 +8600,8 @@ grn_obj_set_info_source_invalid_lexicon_error(grn_ctx *ctx,
source_name_size, source_name);
}
PRAGMA_REENABLE_CHECK_STACK_FRAME
inline static grn_rc
grn_obj_set_info_source_validate(grn_ctx *ctx, grn_obj *obj, grn_obj *value)
{
@ -8597,7 +8609,7 @@ grn_obj_set_info_source_validate(grn_ctx *ctx, grn_obj *obj, grn_obj *value)
grn_obj *lexicon = NULL;
grn_id lexicon_domain_id;
grn_obj *lexicon_domain = NULL;
grn_bool lexicon_domain_is_table;
grn_bool lexicon_domain_is_table __attribute__((unused));
grn_bool lexicon_have_tokenizer;
grn_id *source_ids;
int i, n_source_ids;
@ -9330,7 +9342,7 @@ remove_reference_tables(grn_ctx *ctx, grn_obj *table, grn_obj *db)
grn_bool is_close_opened_object_mode = GRN_FALSE;
grn_id table_id;
char table_name[GRN_TABLE_MAX_KEY_SIZE];
int table_name_size;
int table_name_size __attribute__((unused));
grn_table_cursor *cursor;
if (grn_thread_get_limit() == 1) {
@ -10317,12 +10329,10 @@ grn_db_spec_unpack(grn_ctx *ctx,
const char *error_message_tag)
{
grn_obj *db;
grn_db *db_raw;
grn_rc rc;
uint32_t spec_size;
db = ctx->impl->db;
db_raw = (grn_db *)db;
rc = grn_vector_decode(ctx,
decoded_spec,

5
storage/mroonga/vendor/groonga/lib/load.c vendored
View file

@ -20,6 +20,9 @@
#include "grn_ctx_impl.h"
#include "grn_db.h"
#include "grn_util.h"
#include <my_attribute.h>
PRAGMA_DISABLE_CHECK_STACK_FRAME
static void
grn_loader_save_error(grn_ctx *ctx, grn_loader *loader)
@ -1228,3 +1231,5 @@ grn_load(grn_ctx *ctx, grn_content_type input_type,
}
GRN_API_RETURN(ctx->rc);
}
PRAGMA_REENABLE_CHECK_STACK_FRAME

5
storage/mroonga/vendor/groonga/lib/operator.c vendored
View file

@ -20,6 +20,7 @@
#include "grn_db.h"
#include "grn_str.h"
#include "grn_normalizer.h"
#include <my_attribute.h>
#include <string.h>
@ -31,6 +32,8 @@
# include <onigmo.h>
#endif
PRAGMA_DISABLE_CHECK_STACK_FRAME
static const char *operator_names[] = {
"push",
"pop",
@ -1360,3 +1363,5 @@ grn_operator_exec_regexp(grn_ctx *ctx, grn_obj *target, grn_obj *pattern)
}
GRN_API_RETURN(matched);
}
PRAGMA_REENABLE_CHECK_STACK_FRAME

4
storage/mroonga/vendor/groonga/lib/proc/proc_object_list.c vendored
View file

@ -18,6 +18,7 @@
#include "../grn_proc.h"
#include "../grn_db.h"
#include <my_attribute.h>
#include <groonga/plugin.h>
@ -73,6 +74,8 @@ command_object_list_dump_flags(grn_ctx *ctx, grn_obj_spec *spec)
GRN_OBJ_FIN(ctx, &flags);
}
PRAGMA_DISABLE_CHECK_STACK_FRAME
static grn_obj *
command_object_list(grn_ctx *ctx,
int nargs,
@ -401,6 +404,7 @@ command_object_list(grn_ctx *ctx,
return NULL;
}
PRAGMA_REENABLE_CHECK_STACK_FRAME
void
grn_proc_init_object_list(grn_ctx *ctx)

9
storage/mroonga/vendor/groonga/lib/proc/proc_schema.c vendored
View file

@ -17,9 +17,8 @@
*/
#include "../grn_proc.h"
#include "../grn_db.h"
#include <my_attribute.h>
#include <groonga/plugin.h>
typedef struct {
@ -572,6 +571,8 @@ command_schema_table_output_token_filters(grn_ctx *ctx, grn_obj *table)
GRN_OBJ_FIN(ctx, &token_filters);
}
PRAGMA_DISABLE_CHECK_STACK_FRAME
static void
command_schema_table_command_collect_arguments(grn_ctx *ctx,
grn_obj *table,
@ -692,6 +693,7 @@ command_schema_table_command_collect_arguments(grn_ctx *ctx,
#undef ADD_OBJECT_NAME
#undef ADD
}
PRAGMA_REENABLE_CHECK_STACK_FRAME
static void
command_schema_table_output_command(grn_ctx *ctx, grn_obj *table)
@ -875,6 +877,8 @@ command_schema_output_indexes(grn_ctx *ctx, grn_obj *object)
}
}
PRAGMA_DISABLE_CHECK_STACK_FRAME
static void
command_schema_column_command_collect_arguments(grn_ctx *ctx,
grn_obj *table,
@ -973,6 +977,7 @@ command_schema_column_command_collect_arguments(grn_ctx *ctx,
#undef ADD_OBJECT_NAME
#undef ADD
}
PRAGMA_REENABLE_CHECK_STACK_FRAME
static void
command_schema_column_output_command(grn_ctx *ctx,

20
storage/mroonga/vendor/groonga/lib/proc/proc_select.c vendored
View file

@ -24,6 +24,7 @@
#include "../grn_util.h"
#include "../grn_cache.h"
#include "../grn_ii.h"
#include <my_attribute.h>
#include "../grn_ts.h"
@ -2912,7 +2913,7 @@ grn_select(grn_ctx *ctx, grn_select_data *data)
uint32_t nhits;
grn_obj *outbuf = ctx->impl->output.buf;
grn_content_type output_type = ctx->impl->output.type;
char cache_key[GRN_CACHE_MAX_KEY_SIZE];
char *cache_key_buffer= 0;
uint32_t cache_key_size;
long long int threshold, original_threshold = 0;
grn_cache *cache_obj = grn_cache_current_get(ctx);
@ -2985,8 +2986,9 @@ grn_select(grn_ctx *ctx, grn_select_data *data)
} GRN_HASH_EACH_END(ctx, cursor);
}
#undef DRILLDOWN_CACHE_SIZE
if (cache_key_size <= GRN_CACHE_MAX_KEY_SIZE) {
char *cp = cache_key;
if (cache_key_size <= GRN_CACHE_MAX_KEY_SIZE &&
(cache_key_buffer= (char*) malloc(cache_key_size+1))) {
char *cp = cache_key_buffer;
#define PUT_CACHE_KEY(string) \
if ((string).value) \
@ -3066,11 +3068,12 @@ grn_select(grn_ctx *ctx, grn_select_data *data)
{
grn_rc rc;
rc = grn_cache_fetch(ctx, cache_obj, cache_key, cache_key_size, outbuf);
rc = grn_cache_fetch(ctx, cache_obj, cache_key_buffer, cache_key_size, outbuf);
if (rc == GRN_SUCCESS) {
GRN_QUERY_LOG(ctx, GRN_QUERY_LOG_CACHE,
":", "cache(%" GRN_FMT_LLD ")",
(long long int)GRN_TEXT_LEN(outbuf));
free(cache_key_buffer);
return ctx->rc;
}
}
@ -3119,7 +3122,7 @@ grn_select(grn_ctx *ctx, grn_select_data *data)
data->cache.length != 2 ||
data->cache.value[0] != 'n' ||
data->cache.value[1] != 'o')) {
grn_cache_update(ctx, cache_obj, cache_key, cache_key_size, outbuf);
grn_cache_update(ctx, cache_obj, cache_key_buffer, cache_key_size, outbuf);
}
goto exit;
}
@ -3186,7 +3189,7 @@ grn_select(grn_ctx *ctx, grn_select_data *data)
data->cache.length != 2 ||
data->cache.value[0] != 'n' ||
data->cache.value[1] != 'o')) {
grn_cache_update(ctx, cache_obj, cache_key, cache_key_size, outbuf);
grn_cache_update(ctx, cache_obj, cache_key_buffer, cache_key_size, outbuf);
}
if (data->taintable > 0) {
grn_db_touch(ctx, DB_OBJ(data->tables.target)->db);
@ -3200,6 +3203,7 @@ exit :
/* GRN_LOG(ctx, GRN_LOG_NONE, "%d", ctx->seqno); */
free(cache_key_buffer);
return ctx->rc;
}
@ -3424,6 +3428,9 @@ grn_select_data_fill_drilldown_columns(grn_ctx *ctx,
strlen(prefix));
}
PRAGMA_DISABLE_CHECK_STACK_FRAME
static grn_bool
grn_select_data_fill_drilldowns(grn_ctx *ctx,
grn_user_data *user_data,
@ -3562,6 +3569,7 @@ grn_select_data_fill_drilldowns(grn_ctx *ctx,
return succeeded;
}
}
PRAGMA_REENABLE_CHECK_STACK_FRAME
static grn_obj *
command_select(grn_ctx *ctx, int nargs, grn_obj **args, grn_user_data *user_data)