+${CMAKE_BINARY_DIR}/pcre

+${CMAKE_SOURCE_DIR}/pcre

+ sql_explain.h sql_explain.cc

+ rpl_gtid.cc rpl_parallel.cc

+ ${CMAKE_CURRENT_BINARY_DIR}/sql_builtin.cc

+ mysys mysys_ssl dbug strings vio pcre ${LIBJEMALLOC}

+ ${LIBWRAP} ${LIBCRYPT} ${LIBDL} ${CMAKE_THREAD_LIBS_INIT}

+ Active people in the MariaDB are listed first, active people in MySQL

+ then, not active last.

+ /* Active people on MariaDB */

+ "Architect, Full-text search, precision math, plugin framework, merges etc" },

+ { "Timour Katchaounov", "Sofia , Bulgaria", "Optimizer"},

+ "Replication, Async client prototocol, General buildbot stuff" },

+ "Unicode and character sets" },

+ { "Alexey Botchkov (Holyfoot)", "Izhevsk, Russia",

+ "GIS extensions, embedded server, precision math"},

+ { "Daniel Bartholomew", "Raleigh, USA", "MariaDB documentation"},

+ { "Colin Charles", "Selangor, Malesia", "MariaDB documentation, talks at a LOT of conferences"},

+ { "Sergey Vojtovich", "Izhevsk, Russia",

+ "initial implementation of plugin architecture, maintained native storage engines (MyISAM, MEMORY, ARCHIVE, etc), rewrite of table cache"},

+ { "Vladislav Vaintroub", "Mannheim, Germany", "MariaDB Java connector, new thread pool, Windows optimizations"},

+ { "Elena Stepanova", "Sankt Petersburg, Russia", "QA, test cases"},

+ { "Georg Richter", "Heidelberg, Germany", "New LGPL C connector, PHP connector"},

+ { "Jan Lindström", "Ylämylly, Finland", "Working on InnoDB"},

+ { "Lixun Peng", "Hangzhou, China", "Multi Source replication" },

+ { "Percona", "CA, USA", "XtraDB, microslow patches, extensions to slow log"},

+

+ /* People working on MySQL code base (not NDB) */

+ { "Andrei Elkin", "Espoo, Finland", "Replication" },

+ { "Marc Alff", "Denver, CO, USA", "Signal, Resignal, Performance schema" },

+ { "Mikael Ronström", "Stockholm, Sweden",

+ "NDB Cluster, Partitioning, online alter table" },

+ { "Ingo Strüwing", "Berlin, Germany",

+ "Bug fixing in MyISAM, Merge tables etc" },

+ {"Marko Mäkelä", "Helsinki, Finland", "InnoDB core developer"},

+

+ /* People not active anymore */

+ { "David Axmark", "London, England",

+ "MySQL founder; Small stuff long time ago, Monty ripped it out!" },

+ { "Brian (Krow) Aker", "Seattle, WA, USA",

+ "Architecture, archive, blackhole, federated, bunch of little stuff :)" },

+ { "Konstantin Osipov", "Moscow, Russia",

+ "Prepared statements (4.1), Cursors (5.0)" },

+ { "Venu Anuganti", "", "Client/server protocol (4.1)" },

+ { "Tõnu Samuel", "Estonia",

+ CLIENT_PLUGIN_AUTH | \

+ CLIENT_CONNECT_ATTRS)

+ /* MariaDB foundation members, in contribution size order */

+ {"Booking.com", "http://www.booking.com", "Founding member of the MariaDB foundation"},

+ {"SkySQL Ab", "http://www.skysql.com", "Founding member of the MariaDB foundation"},

+ {"Parallels", "http://www.parallels.com/products/plesk", "Founding member of the MariaDB foundation"},

+

+ /* Smaller sponsors, newer per year */

+ {"Jelastic.com", "Russia", "Sponsor of the MariaDB foundation"},

+ {"Planetta.net", "Finland", "Sponsor of the MariaDB foundation"},

+ {"Open query", "Australia", "Sponsor of the MariaDB foundation"},

+

+ /* Individual contributors, names in historical order, newer first */

+#define value_ptr(STRUCT,OPT) ((char*)(STRUCT) + (OPT)->offset)

+

+ ulonglong *val= (ulonglong*)value_ptr(base, opt);

+ char **val= (char **)value_ptr(base, opt);

+ uint *val= (uint *)value_ptr(base, opt), num;

+ bool *val= (bool *)value_ptr(base, opt);

+ for (opt= rules; rules && opt->name; opt++)

+ for (ha_create_table_option *opt= rules; rules && opt->name; opt++)

+ for (ha_create_table_option *opt= rules; rules && opt->name; opt++)

+bool engine_options_differ(void *old_struct, void *new_struct,

+ ha_create_table_option *rules)

+{

+ ha_create_table_option *opt;

+ for (opt= rules; rules && opt->name; opt++)

+ {

+ char **old_val= (char**)value_ptr(old_struct, opt);

+ char **new_val= (char**)value_ptr(new_struct, opt);

+ int neq;

+ if (opt->type == HA_OPTION_TYPE_STRING)

+ neq= (*old_val && *new_val) ? strcmp(*old_val, *new_val) : *old_val != *new_val;

+ else

+ neq= memcmp(old_val, new_val, ha_option_type_sizeof[opt->type]);

+ if (neq)

+ return true;

+ }

+ return false;

+}

+

+

+

+bool engine_options_differ(void *old_struct, void *new_struct,

+ ha_create_table_option *rules);

+static int read_string(File file, uchar**to, size_t length)

+{

+ DBUG_ENTER("read_string");

+

+ my_free(*to);

+ if (!(*to= (uchar*) my_malloc(length+1,MYF(MY_WME))) ||

+ mysql_file_read(file, *to, length, MYF(MY_NABP)))

+ {

+ my_free(*to);

+ *to= 0;

+ DBUG_RETURN(1);

+ }

+ *((char*) *to+length)= '\0'; // C-style safety

+ DBUG_RETURN (0);

+}

+

+ frm_type_enum type= FRMTYPE_ERROR;

+ goto err;

+ {

+ type= FRMTYPE_VIEW;

+ goto err;

+ }

+

+ type= FRMTYPE_TABLE;

+ goto err;

+ if (*dbt >= DB_TYPE_FIRST_DYNAMIC) /* read the true engine name */

+ {

+ MY_STAT state;

+ uchar *frm_image= 0;

+ uint n_length;

+

+ if (mysql_file_fstat(file, &state, MYF(MY_WME)))

+ goto err;

+

+ if (mysql_file_seek(file, 0, SEEK_SET, MYF(MY_WME)))

+ goto err;

+

+ if (read_string(file, &frm_image, state.st_size))

+ goto err;

+

+ if ((n_length= uint4korr(frm_image+55)))

+ {

+ uint record_offset= uint2korr(frm_image+6)+

+ ((uint2korr(frm_image+14) == 0xffff ?

+ uint4korr(frm_image+47) : uint2korr(frm_image+14)));

+ uint reclength= uint2korr(frm_image+16);

+

+ uchar *next_chunk= frm_image + record_offset + reclength;

+ uchar *buff_end= next_chunk + n_length;

+ uint connect_string_length= uint2korr(next_chunk);

+ next_chunk+= connect_string_length + 2;

+ if (next_chunk + 2 < buff_end)

+ {

+ uint str_db_type_length= uint2korr(next_chunk);

+ LEX_STRING name;

+ name.str= (char*) next_chunk + 2;

+ name.length= str_db_type_length;

+ plugin_ref tmp_plugin= ha_resolve_by_name(thd, &name);

+ if (tmp_plugin)

+ *dbt= plugin_data(tmp_plugin, handlerton *)->db_type;

+ else

+ *dbt= DB_TYPE_UNKNOWN;

+ }

+ }

+

+ my_free(frm_image);

+ }

+

+err:

+ mysql_file_close(file, MYF(MY_WME));

+ DBUG_RETURN(type);

+/* Copyright (c) 2009, 2013, Oracle and/or its affiliates.

+ mysql_cond_t *old_cond= NULL;

+ mysql_reset_thd_for_next_command(thd);

+int wsrep_create_event_query(THD *thd, uchar** buf, size_t* buf_len)

+ Copyright (c) 2000, 2013, Oracle and/or its affiliates.

+ Copyright (c) 2008, 2013, Monty Program Ab.

+ ErrConvString errmsg(from, length, charset_arg);

+ ErrConvString errmsg(from, length, charset_arg);

+ field_charset->coll->strnxfrm(field_charset,

+ to, length,

+ char_length() *

+ field_charset->strxfrm_multiply,

+ ptr, field_length,

+ MY_STRXFRM_PAD_WITH_SPACE |

+ MY_STRXFRM_PAD_TO_MAXLEN);

+ tot_length= field_charset->coll->strnxfrm(field_charset,

+ to, length,

+ char_length() *

+ field_charset->strxfrm_multiply,

+ ptr + length_bytes, tot_length,

+ MY_STRXFRM_PAD_WITH_SPACE |

+ MY_STRXFRM_PAD_TO_MAXLEN);

+ bmove(ptr + packlength, &from, sizeof(char*));

+ blob_length= field_charset->coll->strnxfrm(field_charset,

+ to, length, length,

+ blob, blob_length,

+ MY_STRXFRM_PAD_WITH_SPACE |

+ MY_STRXFRM_PAD_TO_MAXLEN);

+ bmove(ptr + packlength, &from, sizeof(char*));

+static inline enum enum_mysql_timestamp_type

+mysql_type_to_time_type(enum enum_field_types mysql_type)

+{

+ switch(mysql_type) {

+ case MYSQL_TYPE_TIME2:

+ case MYSQL_TYPE_TIME: return MYSQL_TIMESTAMP_TIME;

+ case MYSQL_TYPE_TIMESTAMP2:

+ case MYSQL_TYPE_TIMESTAMP:

+ case MYSQL_TYPE_DATETIME2:

+ case MYSQL_TYPE_DATETIME: return MYSQL_TIMESTAMP_DATETIME;

+ case MYSQL_TYPE_NEWDATE:

+ case MYSQL_TYPE_DATE: return MYSQL_TIMESTAMP_DATE;

+ default: return MYSQL_TIMESTAMP_ERROR;

+ }

+}

+

+

+/**

+ Tests if field type is temporal, i.e. represents

+ DATE, TIME, DATETIME or TIMESTAMP types in SQL.

+

+ @param type Field type, as returned by field->type().

+ @retval true If field type is temporal

+ @retval false If field type is not temporal

+*/

+inline bool is_temporal_type(enum_field_types type)

+{

+ return mysql_type_to_time_type(type) != MYSQL_TIMESTAMP_ERROR;

+}

+

+ virtual uint row_pack_length() const { return 0; }

+ uint row_pack_length() const { return pack_length(); }

+ uint row_pack_length() const { return pack_length(); }

+ uint row_pack_length() const { return pack_length(); }

+ uint row_pack_length() const { return pack_length(); }

+ uint row_pack_length() const { return pack_length(); }

+ uint row_pack_length() const { return pack_length(); }

+ uint row_pack_length() const { return pack_length(); }

+ uint row_pack_length() const { return field_length; }

+ uint row_pack_length() const { return field_length; }

+ uint row_pack_length() const { return pack_length_no_ptr(); }

+ uint row_pack_length() const { return pack_length(); }

+ uint row_pack_length() const

+ tmp_length= cs->coll->strnxfrm(cs, to, sort_field->length,

+ item->max_char_length() *

+ cs->strxfrm_multiply,

+ (uchar*) from, length,

+ MY_STRXFRM_PAD_WITH_SPACE |

+ MY_STRXFRM_PAD_TO_MAXLEN);

+ m_pkey_is_clustered= clone_arg->primary_key_is_clustered();

+

+ DBUG_EXECUTE_IF("unstable_db_type", {

+ static int i= (int) DB_TYPE_FIRST_DYNAMIC;

+ hton->db_type= (enum legacy_db_type)++i;

+ });

+

+ DBUG_PRINT("info",("thd: %p option_bits: %lu all: %d",

+ thd, (ulong) thd->variables.option_bits, all));

+ DBUG_PRINT("info", ("is_real_trans: %d rw_trans: %d rw_ha_count: %d",

+ is_real_trans, rw_trans, rw_ha_count));

+ int res;

+ if (is_real_trans && (res= thd->wait_for_prior_commit()))

+ DBUG_RETURN(res);

+ res= commit_one_phase_2(thd, all, trans, is_real_trans);

+ {

+ thd->wakeup_subsequent_commits(error);

+ thd->transaction.cleanup();

+ }

+

+ {

+ thd->wakeup_subsequent_commits(error);

+ thd->transaction.cleanup();

+ }

+ }

+ }

+ }

+

+ if (table->s->incompatible_version)

+ return HA_ADMIN_NEEDS_ALTER;

+

+ const LEX_STRING *wild_arg) :

+ thd(thd_arg), with_temps(false), tables(tables_arg)

+ /*

+ TODO Check with_temps and filter out temp tables.

+ Implement the check, when we'll have at least one affected engine (with

+ custom discover_table_names() method, that calls add_table() directly).

+ Note: avoid comparing the same name twice (here and in add_file).

+ */

+ bool is_temp= strncmp(fname, STRING_WITH_LEN(tmp_file_prefix)) == 0;

+

+ if (is_temp && !with_temps)

+ return 0;

+

+ size_t tlen= filename_to_tablename(fname, tname, sizeof(tname), is_temp);

+/**

+ Return the list of tables

+

+ @param thd

+ @param db database to look into

+ @param dirp list of files in this database (as returned by my_dir())

+ @param result the object to return the list of files in

+ @param reusable if true, on return, 'dirp' will be a valid list of all

+ non-table files. If false, discovery will work much faster,

+ but it will leave 'dirp' corrupted and completely unusable,

+ only good for my_dirend().

+

+ Normally, reusable=false for SHOW and INFORMATION_SCHEMA, and reusable=true

+ for DROP DATABASE (as it needs to know and delete non-table files).

+*/

+

+ DB_TYPE_TOKUDB=43,

+ DB_TYPE_FIRST_DYNAMIC=44,

+ SCH_ALL_PLUGINS,

+ SCH_APPLICABLE_ROLES,

+ SCH_CHARSETS,

+ SCH_ENABLED_ROLES,

+#define HA_IOPTION_BOOL(name, field, def) \

+ HA_xOPTION_BOOL(name, ha_index_option_struct, field, def)

+#define HTON_EXTENDED_KEYS (1 <<10) //supports extended keys

+ virtual int prepare_index_key_scan_map(const uchar * key, key_part_map keypart_map)

+ {

+ uint key_len= calculate_key_len(table, active_index, key, keypart_map);

+ return prepare_index_key_scan(key, key_len);

+ }

+ virtual int prepare_index_key_scan( const uchar * key, uint key_len )

+ { return 0; }

+ virtual int prepare_range_scan(const key_range *start_key, const key_range *end_key)

+ { return 0; }

+

+ TABLE_SHARE* get_table_share() { return table_share; }

+bool key_uses_partial_cols(TABLE_SHARE *table, uint keyno);

+ bool with_temps; // whether to include temp tables in the result

+ Discovered_table_list(THD *thd_arg, Dynamic_array<LEX_STRING*> *tables_arg)

+ : thd(thd_arg), wild(NULL), with_temps(true), tables(tables_arg) {}

+String *Item::val_str(String *str, String *converter, CHARSET_INFO *cs)

+{

+ String *res= val_str(str);

+ if (null_value)

+ return (String *) 0;

+

+ if (!cs)

+ return res;

+

+ uint errors;

+ if ((null_value= converter->copy(res->ptr(), res->length(),

+ collation.collation, cs, &errors)))

+ return (String *) 0;

+

+ return converter;

+}

+

+

+ if (get_date(&ltime, field_type() == MYSQL_TYPE_TIME

+ ? TIME_TIME_ONLY

+ : sql_mode_for_dates(current_thd)) ||

+uint Item::temporal_precision(enum_field_types type)

+{

+ if (const_item() && result_type() == STRING_RESULT &&

+ !is_temporal_type(field_type()))

+ {

+ MYSQL_TIME ltime;

+ String buf, *tmp;

+ MYSQL_TIME_STATUS status;

+ DBUG_ASSERT(fixed);

+ if ((tmp= val_str(&buf)) &&

+ (type == MYSQL_TYPE_TIME ?

+ str_to_time(tmp->charset(), tmp->ptr(), tmp->length(),

+ &ltime, TIME_TIME_ONLY, &status) :

+ str_to_datetime(tmp->charset(), tmp->ptr(), tmp->length(),

+ &ltime, TIME_FUZZY_DATES, &status)) >

+ MYSQL_TIMESTAMP_ERROR)

+ return MY_MIN(status.precision, TIME_SECOND_PART_DIGITS);

+ }

+ return MY_MIN(decimals, TIME_SECOND_PART_DIGITS);

+}

+

+

+ if (thd->lex->in_sum_func &&

+ thd->lex->in_sum_func->nest_level ==

+ thd->lex->current_select->nest_level)

+ set_if_bigger(thd->lex->in_sum_func->max_arg_level,

+ thd->lex->current_select->nest_level);

+void Item_ref::update_used_tables()

+ Returns the val_str() value converted to the given character set.

+ */

+ String *val_str(String *str, String *converter, CHARSET_INFO *to);

+ /*

+ /**

+ TIME or DATETIME precision of the item: 0..6

+ */

+ uint temporal_precision(enum_field_types type);

+ virtual bool count_sargable_conds(uchar *arg) { return 0; }

+ maybe_null= 0;

+

+ DBUG_ENTER("Item_in_optimizer::fix_left");

+ DBUG_RETURN(1);

+ DBUG_PRINT("info", ("actual fix fields"));

+ DBUG_RETURN(1);

+ {

+ ((Item_cache *)cache->element_index(i))->

+ set_used_tables(OUTER_REF_TABLE_BIT);

+ cache->set_used_tables(OUTER_REF_TABLE_BIT);

+ }

+ DBUG_RETURN(0);

+ maybe_null=null_value=0;

+ not_null_consts&= el->const_item() && !el->is_null();

+ maybe_null= 0;

+bool Item_func_between::count_sargable_conds(uchar *arg)

+{

+ SELECT_LEX *sel= (SELECT_LEX *) arg;

+ sel->cond_count++;

+ sel->between_count++;

+ return 0;

+}

+

+

+ agg_result_type(&cached_result_type, args, 2);

+ cached_field_type= agg_field_type(args, 2);

+ if (cached_result_type == DECIMAL_RESULT || cached_result_type == INT_RESULT)

+ switch (cached_result_type) {

+ if (count_string_result_length(cached_field_type, args, arg_count))

+bool Item_func_ifnull::date_op(MYSQL_TIME *ltime, uint fuzzydate)

+{

+ DBUG_ASSERT(fixed == 1);

+ if (!args[0]->get_date(ltime, fuzzydate & ~TIME_FUZZY_DATES))

+ return (null_value= false);

+ if (!args[1]->get_date(ltime, fuzzydate & ~TIME_FUZZY_DATES))

+ return (null_value= false);

+ bzero((char*) ltime,sizeof(*ltime));

+ return null_value= !(fuzzydate & TIME_FUZZY_DATES);

+}

+

+

+ cached_field_type= agg_field_type(args + 1, 2);

+ count_string_result_length(cached_field_type, args + 1, 2);

+ return;

+Item_func_if::real_op()

+Item_func_if::int_op()

+Item_func_if::str_op(String *str)

+Item_func_if::decimal_op(my_decimal *decimal_value)

+bool Item_func_if::date_op(MYSQL_TIME *ltime, uint fuzzydate)

+{

+ DBUG_ASSERT(fixed == 1);

+ Item *arg= args[0]->val_bool() ? args[1] : args[2];

+ return (null_value= arg->get_date(ltime, fuzzydate));

+}

+

+

+ maybe_null=1;

+String *Item_func_case::str_op(String *str)

+longlong Item_func_case::int_op()

+double Item_func_case::real_op()

+my_decimal *Item_func_case::decimal_op(my_decimal *decimal_value)

+bool Item_func_case::date_op(MYSQL_TIME *ltime, uint fuzzydate)

+{

+ DBUG_ASSERT(fixed == 1);

+ char buff[MAX_FIELD_WIDTH];

+ String dummy_str(buff, sizeof(buff), default_charset());

+ Item *item= find_item(&dummy_str);

+ if (!item)

+ return (null_value= true);

+ return (null_value= item->get_date(ltime, fuzzydate));

+}

+

+

+

+ if (else_expr_num == -1 || args[else_expr_num]->maybe_null)

+ maybe_null= 1;

+

+ cached_field_type= agg_field_type(agg, nagg);

+

+ if (count_string_result_length(cached_field_type, agg, nagg))

+ {

+ max_length=0;

+ decimals=0;

+ unsigned_flag= TRUE;

+ for (uint i= 0; i < ncases; i+= 2)

+ agg_num_lengths(args[i + 1]);

+ if (else_expr_num != -1)

+ agg_num_lengths(args[else_expr_num]);

+ max_length= my_decimal_precision_to_length_no_truncation(max_length +

+ decimals, decimals,

+ unsigned_flag);

+ }

+ Aggregate first expression and all WHEN expression types

+bool Item_func_coalesce::date_op(MYSQL_TIME *ltime,uint fuzzydate)

+ bool res= args[i]->get_date(ltime, fuzzydate & ~TIME_FUZZY_DATES);

+ bzero((char*) ltime,sizeof(*ltime));

+ return null_value|= !(fuzzydate & TIME_FUZZY_DATES);

+ agg_result_type(&cached_result_type, args, arg_count);

+ switch (cached_result_type) {

+ if (count_string_result_length(cached_field_type, args, arg_count))

+ return;

+ count_only_length(args, arg_count);

+ {

+ if (!item->is_expensive() && !cond_has_datetime_is_null(item) &&

+ item->val_int() == 0)

+ {

+ /*

+ This is "... OR false_cond OR ..."

+ In this case, false_cond has no effect on cond_or->not_null_tables()

+ */

+ }

+ else

+ {

+ /*

+ This is "... OR const_cond OR ..."

+ In this case, cond_or->not_null_tables()=0, because the condition

+ const_cond might evaluate to true (regardless of whether some tables

+ were NULL-complemented).

+ */

+ and_tables_cache= (table_map) 0;

+ }

+ }

+

+ {

+ if (!item->is_expensive() && !cond_has_datetime_is_null(item) &&

+ item->val_int() == 0)

+ {

+ /*

+ This is "... OR false_cond OR ..."

+ In this case, false_cond has no effect on cond_or->not_null_tables()

+ */

+ }

+ else

+ {

+ /*

+ This is "... OR const_cond OR ..."

+ In this case, cond_or->not_null_tables()=0, because the condition

+ some_cond_or might be true regardless of what tables are

+ NULL-complemented.

+ */

+ and_tables_cache= (table_map) 0;

+ }

+ }

+ if (const_item() && !args[0]->maybe_null)

+ return 0;

+

+ if (const_item() && !args[0]->maybe_null)

+ DBUG_RETURN(1);

+ else

+ args[0]->update_used_tables();

+

+

+/**

+ Convert string to lib_charset, if needed.

+*/

+String *Regexp_processor_pcre::convert_if_needed(String *str, String *converter)

+{

+ if (m_conversion_is_needed)

+ {

+ uint dummy_errors;

+ if (converter->copy(str->ptr(), str->length(), str->charset(),

+ m_library_charset, &dummy_errors))

+ return NULL;

+ str= converter;

+ }

+ return str;

+}

+

+

+ @param[in] pattern the pattern to compile from.

+ @retval false success.

+ @retval true error occurred.

+bool Regexp_processor_pcre::compile(String *pattern, bool send_error)

+ const char *pcreErrorStr;

+ int pcreErrorOffset;

+ if (is_compiled())

+ if (!stringcmp(pattern, &m_prev_pattern))

+ return false;

+ m_prev_pattern.copy(*pattern);

+ pcre_free(m_pcre);

+ m_pcre= NULL;

+ if (!(pattern= convert_if_needed(pattern, &pattern_converter)))

+ return true;

+ m_pcre= pcre_compile(pattern->c_ptr_safe(), m_library_flags,

+ &pcreErrorStr, &pcreErrorOffset, NULL);

+

+ if (m_pcre == NULL)

+ char buff[MAX_FIELD_WIDTH];

+ my_snprintf(buff, sizeof(buff), "%s at offset %d", pcreErrorStr, pcreErrorOffset);

+ return true;

+ return false;

+bool Regexp_processor_pcre::compile(Item *item, bool send_error)

+ char buff[MAX_FIELD_WIDTH];

+ String tmp(buff, sizeof(buff), &my_charset_bin);

+ String *pattern= item->val_str(&tmp);

+ if (item->null_value || compile(pattern, send_error))

+ return true;

+ return false;

+}

+bool Regexp_processor_pcre::exec(const char *str, int length, int offset)

+{

+ m_pcre_exec_rc= pcre_exec(m_pcre, NULL, str, length,

+ offset, 0, m_SubStrVec, m_subpatterns_needed * 3);

+ return false;

+}

+

+bool Regexp_processor_pcre::exec(String *str, int offset,

+ uint n_result_offsets_to_convert)

+{

+ if (!(str= convert_if_needed(str, &subject_converter)))

+ return true;

+ m_pcre_exec_rc= pcre_exec(m_pcre, NULL, str->c_ptr_safe(), str->length(),

+ offset, 0, m_SubStrVec, m_subpatterns_needed * 3);

+ if (m_pcre_exec_rc > 0)

+ {

+ uint i;

+ for (i= 0; i < n_result_offsets_to_convert; i++)

+ {

+ /*

+ Convert byte offset into character offset.

+ */

+ m_SubStrVec[i]= (int) str->charset()->cset->numchars(str->charset(),

+ str->ptr(),

+ str->ptr() +

+ m_SubStrVec[i]);

+ return false;

+bool Regexp_processor_pcre::exec(Item *item, int offset,

+ uint n_result_offsets_to_convert)

+ String *res= item->val_str(&tmp);

+ if (item->null_value)

+ return true;

+ return exec(res, offset, n_result_offsets_to_convert);

+}

+void Regexp_processor_pcre::fix_owner(Item_func *owner,

+ Item *subject_arg,

+ Item *pattern_arg)

+{

+ if (!is_compiled() && pattern_arg->const_item())

+ if (compile(pattern_arg, true))

+ owner->maybe_null= 1; // Will always return NULL

+ return;

+ set_const(true);

+ owner->maybe_null= subject_arg->maybe_null;

+ else

+ owner->maybe_null= 1;

+void

+Item_func_regex::fix_length_and_dec()

+ Item_bool_func::fix_length_and_dec();

+

+ if (agg_arg_charsets_for_comparison(cmp_collation, args, 2))

+ return;

+

+ re.init(cmp_collation.collation, 0, 0);

+ re.fix_owner(this, args[0], args[1]);

+}

+

+

+longlong Item_func_regex::val_int()

+{

+ DBUG_ASSERT(fixed == 1);

+ if ((null_value= re.recompile(args[1])))

+ return 0;

+

+ if ((null_value= re.exec(args[0], 0, 0)))

+ return 0;

+

+ return re.match();

+}

+

+

+void

+Item_func_regexp_instr::fix_length_and_dec()

+{

+ if (agg_arg_charsets_for_comparison(cmp_collation, args, 2))

+ return;

+

+ re.init(cmp_collation.collation, 0, 1);

+ re.fix_owner(this, args[0], args[1]);

+}

+

+

+longlong Item_func_regexp_instr::val_int()

+{

+ DBUG_ASSERT(fixed == 1);

+ if ((null_value= re.recompile(args[1])))

+ return 0;

+

+ if ((null_value= re.exec(args[0], 0, 1)))

+ return 0;

+

+ return re.match() ? re.subpattern_start(0) + 1 : 0;

+ upper_levels= NULL;

+ sargable= TRUE;

+ sargable= TRUE;

+ /*

+ TODO: also support the case where Item_equal becomes singular with

+ this->is_cond_true()=1. When I attempted to mark the item as constant,

+ the optimizer attempted to remove it, however it is still referenced from

+ COND_EQUAL and I got a crash.

+ */

+ @param item multiple equality whose members are to be merged

+ @param save_merged keep the list of equalities in 'item' intact

+ (e.g. for other merges)

+ If the Item_equal 'item' happens to have some elements of the list

+ The method 'merge_into_with_check' really merges two lists of equal items if

+ they have common members.

+bool Item_equal::merge_with_check(Item_equal *item, bool save_merged)

+ Item_equal_fields_iterator_slow fi(*item);

+

+ if (contains(fi.get_curr_field()))

+ if (!save_merged)

+ fi.remove();

+ {

+ if (!save_merged)

+ merge(item);

+ else

+ {

+ Item *c= item->get_const();

+ if (c)

+ add_const(c);

+ if (!cond_false)

+ {

+ Item *item;

+ fi.rewind();

+ while ((item= fi++))

+ {

+ if (!contains(fi.get_curr_field()))

+ add(item);

+ }

+ }

+ }

+ }

+ @param list the list of Item_equal objects to merge into

+ @param save_merged keep the list of equalities in 'this' intact

+ (e.g. for other merges)

+ @param only_intersected do not merge if there are no common members

+ in any of Item_equal objects from the list

+ and this Item_equal

+ Item equal that replaces e1,...,ek in the 'list'. Otherwise, in the case

+ when the value of the parameter only_if_intersected is false, this

+void Item_equal::merge_into_list(List<Item_equal> *list,

+ bool save_merged,

+ bool only_intersected)

+ if (item->merge_with_check(this, save_merged))

+ if (merge_into->merge_with_check(item, false))

+ if (!only_intersected && !merge_into)

+ if (equal_items.elements > 1)

+ bubble_sort<Item>(&equal_items, compare, arg);

+ /*

+ TODO: also support the case where Item_equal becomes singular with

+ this->is_cond_true()=1. When I attempted to mark the item as constant,

+ the optimizer attempted to remove it, however it is still referenced from

+ COND_EQUAL and I got a crash.

+ */

+bool Item_equal::count_sargable_conds(uchar *arg)

+{

+ SELECT_LEX *sel= (SELECT_LEX *) arg;

+ uint m= equal_items.elements;

+ sel->cond_count+= m*(m-1);

+ return 0;

+}

+

+ if (is_cond_true())

+ return 1;

+ if (!item)

+ {

+ DBUG_ASSERT(is_cond_true()); // it should be the only constant

+ item= equal_items.head();

+ }

+ mariadb_dyncol_exists_num(&col, (uint) num) :