database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2026-10-23 18:49:29 +03:00
Code Activity
Files
4561ccad91539404f8bddd39d2a68860edd49005
mariadb/sql/field_conv.cc
Dave Gosselin 4561ccad91 MDEV-40620: Allow a nested join as a FULL JOIN operand 
Phase 2 rejected two shapes.  A FULL JOIN whose right operand was a
nested join raised ER_FULL_JOIN_BASE_TABLES_ONLY, and a FULL JOIN on the
inner side of an enclosing LEFT or RIGHT JOIN raised
ER_FULL_JOIN_NOT_ALLOWED_IN_OUTER_JOIN.  Both shapes are allowed now and
neither error is raised any more.

A FULL JOIN emits the rows of one side that never matched with the other
side null complemented.  An enclosing join's condition has to see those
rows complete, which it cannot do while the operand is only a set of
tables spread through the join order.  An operand that is a nested join
is therefore computed into a temporary table before the enclosing join
runs, so one JOIN_TAB stands for the whole operand and carries the FULL
JOIN's own marks.

The chosen plan has to keep such an operand on an unbroken span of the
join order, and that span becomes a run of JOIN_TABs of its own, the way
a materialized semi join already is.  Nothing outside the operand is
positioned while the operand is computed, so a table inside it can carry
no condition that names an outside table, an equality class that spans
the boundary is split at it, and the outer join scope of a join outside
it stops there.  A nest goes on naming a table that table elimination
removed, and an eliminated table is a const table, so the test for
entering the run leaves the eliminated tables out.  The test for
entering a materialized semi join run reads the same way.

The operand keeps a copy of its own ON expression, since simplifying the
join tree merges an inner join's ON into the enclosing outer join's ON,
which is not equivalent for a FULL JOIN because it changes which rows of
the right side never match.  An operand can itself be built from more
than one join, so an ON expression can sit a level or two below the top
of it, and every such expression is recorded on the operand as a whole,
which is the nest that reads them back.  A predicate over the operand is
checked again at the entry standing for it, once the null complementing
has happened.  A FULL JOIN's left side WHERE predicates are deferred to
the table that completes its right side even when that side is a nest.
The enclosing ON contributes no access path for the operand.

Reading a row back restores what a nest table cannot hold on its own,
whether the row was null complemented for a column declared NOT NULL,
and the status that says whether the table holds a usable row at all.

The JOIN_TAB standing for a run covers every table of the nest, the
eliminated ones included.  The plan output therefore skips only a
JOIN_TAB that is a table of the query, since a JOIN_TAB standing for a
run is never eliminated.

The FULL JOIN code moves out of sql_select.cc, sql_base.cc and table.cc
into opt_full_join.cc and opt_full_join.h.  JOIN::full_joins holds a
Full_join_info, declared in opt_full_join_info.h, for each FULL JOIN
that simplify_joins did not rewrite.  It holds the two sides, the WHERE
conjuncts held back for the FULL JOIN, the tab that reads its right
side, the duplicate filter of the right rows that matched, and the next
FULL JOIN whose null complement pass runs from the same tab.  It
replaces fj_dups, fj_first_target and fj_next_target on JOIN_TAB and
fj_left_cond on TABLE_LIST.  The list is built for each JOIN, so a
prepared statement starts every execution with nothing held.

opt_join_runs.cc and opt_join_runs.h hold the runs.
get_best_combination records every run of the chosen join order in a
Join_run_layout before it writes any JOIN_TAB, and the layout gives the
exact number of top level JOIN_TABs.  make_join_select walks the plan
with Join_tab_walk, which keeps the tables a run sets aside on entry
until the walk reaches the run's placeholder.  A FULL JOIN run can be
inside a materialized semi join, so the walk keeps the runs on a stack.

make_join_select decides again which conditions wait for a FULL JOIN's
right partner, on each condition about to be attached to a table.
Distributing the WHERE builds conditions for one table out of
disjunctions that span both sides, and a HAVING predicate moved into
the WHERE can name the left side alone, so the choice made while the
WHERE is rewritten misses both.  That earlier choice stays, since it
keeps the left side out of ref and range analysis.  Whether a condition
reads a table after the partner is decided from the join order
positions of the tables it reads.

An enclosing join's ON supplies no key value for a table on a FULL
JOIN's left side, because the null complement pass is complete only
once every left row has been read.  A key value that reads only tables
of the same left side is still allowed.  An ORDER BY over a FULL JOIN
that simplify_joins kept sorts through a temporary table, because the
null complement pass emits right rows after the scan of the first
table.  EXPLAIN gathers the tables of each run at its own depth, and an
operand nest inside a materialized semi join reports under that semi
join's id.

Sections 22 to 28 cover the new shapes.  The section covering more than
one matching right side row becomes Section 28, which adds a nest operand
to the same case, and the two sections that came with the fixes before
this one are renumbered to follow it.  Sections 35 to 42 cover an ON
expression below the top of an operand, an enclosing ON that keeps the
left side NULLs, operand nests that table elimination shrinks, a
condition offered to a table inside a run, a prepared WHERE that folds
away on a later execution, a FULL JOIN run inside a materialized semi
join, and a left side condition over a table before the partner.
Sections 8, 18 and 27 gain left side predicates that appear only once
the WHERE is rewritten.  The helper that gives every column an index of
its own comes with them, ahead of the axis that turns it on.

Co-Authored-By: Claude Opus 5.5 (1M context) <noreply@anthropic.com>
2026-10-21 08:02:24 -04:00

995 lines
27 KiB
C++
Raw Blame History

/* Copyright (c) 2000, 2016, Oracle and/or its affiliates.
Copyright (c) 2010, 2020, MariaDB Corporation
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; version 2 of the License.
This program 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 General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1335 USA */
/**
@file
@brief
Functions to copy data to or from fields
This could be done with a single short function but opencoding this
gives much more speed.
*/
#include "mariadb.h"
#include "sql_priv.h"
#include "sql_class.h" // THD
#include <m_ctype.h>
void Field::do_field_eq(const Copy_field *copy)
{
memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
}
static void do_field_1(const Copy_field *copy)
{
copy->to_ptr[0]=copy->from_ptr[0];
}
static void do_field_2(const Copy_field *copy)
{
copy->to_ptr[0]=copy->from_ptr[0];
copy->to_ptr[1]=copy->from_ptr[1];
}
static void do_field_3(const Copy_field *copy)
{
copy->to_ptr[0]=copy->from_ptr[0];
copy->to_ptr[1]=copy->from_ptr[1];
copy->to_ptr[2]=copy->from_ptr[2];
}
static void do_field_4(const Copy_field *copy)
{
copy->to_ptr[0]=copy->from_ptr[0];
copy->to_ptr[1]=copy->from_ptr[1];
copy->to_ptr[2]=copy->from_ptr[2];
copy->to_ptr[3]=copy->from_ptr[3];
}
static void do_field_6(const Copy_field *copy)
{ // For blob field
copy->to_ptr[0]=copy->from_ptr[0];
copy->to_ptr[1]=copy->from_ptr[1];
copy->to_ptr[2]=copy->from_ptr[2];
copy->to_ptr[3]=copy->from_ptr[3];
copy->to_ptr[4]=copy->from_ptr[4];
copy->to_ptr[5]=copy->from_ptr[5];
}
static void do_field_8(const Copy_field *copy)
{
copy->to_ptr[0]=copy->from_ptr[0];
copy->to_ptr[1]=copy->from_ptr[1];
copy->to_ptr[2]=copy->from_ptr[2];
copy->to_ptr[3]=copy->from_ptr[3];
copy->to_ptr[4]=copy->from_ptr[4];
copy->to_ptr[5]=copy->from_ptr[5];
copy->to_ptr[6]=copy->from_ptr[6];
copy->to_ptr[7]=copy->from_ptr[7];
}
static void do_field_to_null_str(const Copy_field *copy)
{
if (*copy->from_null_ptr & copy->from_bit)
{
bzero(copy->to_ptr,copy->from_length);
copy->to_null_ptr[0]=1; // Always bit 1
}
else
{
copy->to_null_ptr[0]=0;
memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
}
}
static void do_outer_field_to_null_str(const Copy_field *copy)
{
if (*copy->null_row ||
(copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
{
bzero(copy->to_ptr,copy->from_length);
copy->to_null_ptr[0]=1; // Always bit 1
}
else
{
copy->to_null_ptr[0]=0;
memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
}
}
static int set_bad_null_error(Field *field, int err)
{
switch (field->table->in_use->count_cuted_fields) {
case CHECK_FIELD_WARN:
field->set_warning(Sql_condition::WARN_LEVEL_WARN, err, 1);
/* fall through */
case CHECK_FIELD_IGNORE:
case CHECK_FIELD_EXPRESSION:
return 0;
case CHECK_FIELD_ERROR_FOR_NULL:
if (!field->table->in_use->no_errors)
my_error(err, MYF(0), field->field_name.str);
return -1;
}
DBUG_ASSERT(0); // impossible
return -1;
}
int set_field_to_null(Field *field)
{
if (field->table->null_catch_flags & CHECK_ROW_FOR_NULLS_TO_REJECT)
{
field->table->null_catch_flags|= REJECT_ROW_DUE_TO_NULL_FIELDS;
return -1;
}
if (field->real_maybe_null())
{
field->set_null();
field->reset();
return 0;
}
field->reset();
return set_bad_null_error(field, WARN_DATA_TRUNCATED);
}
/**
Set TIMESTAMP to NOW(), AUTO_INCREMENT to the next number, or report an error
@param field Field to update
@retval
0 Field could take 0 or an automatic conversion was used
@retval
-1 Field could not take NULL and no conversion was used.
If no_conversion was not set, an error message is printed
*/
int convert_null_to_field_value_or_error(Field *field, uint err)
{
if (field->type() == MYSQL_TYPE_TIMESTAMP)
{
field->set_time();
return 0;
}
MY_BITMAP *old_map= dbug_tmp_use_all_columns(field->table, &field->table->write_set);
field->make_empty_rec_reset();
dbug_tmp_restore_column_map(&field->table->write_set, old_map);
if (field == field->table->next_number_field)
{
field->table->auto_increment_field_not_null= FALSE;
return 0; // field is set in fill_record()
}
return set_bad_null_error(field, err);
}
/**
Set field to NULL or TIMESTAMP or to next auto_increment number.
@param field Field to update
@param no_conversions Set to 1 if we should return 1 if field can't
take null values.
If set to 0 we will do store the 'default value'
if the field is a special field. If not we will
give an error.
@retval
0 Field could take 0 or an automatic conversion was used
@retval
-1 Field could not take NULL and no conversion was used.
If no_conversion was not set, an error message is printed
*/
int
set_field_to_null_with_conversions(Field *field, bool no_conversions)
{
if (field->table->null_catch_flags & CHECK_ROW_FOR_NULLS_TO_REJECT)
{
field->table->null_catch_flags|= REJECT_ROW_DUE_TO_NULL_FIELDS;
return -1;
}
if (field->real_maybe_null())
{
field->set_null();
field->reset();
return 0;
}
if (no_conversions)
return -1;
return convert_null_to_field_value_or_error(field, ER_BAD_NULL_ERROR);
}
static void do_skip(const Copy_field *copy __attribute__((unused)))
{
}
/*
Copy: (NULLable field) -> (NULLable field)
note: if the record we're copying from is NULL-complemetned (i.e.
from_field->table->null_row==1), it will also have all NULLable columns to be
set to NULLs, so we don't need to check table->null_row here.
*/
static void do_copy_null(const Copy_field *copy)
{
if (*copy->from_null_ptr & copy->from_bit)
{
*copy->to_null_ptr|=copy->to_bit;
copy->to_field->reset();
}
else
{
*copy->to_null_ptr&= ~copy->to_bit;
(copy->do_copy2)(copy);
}
}
/*
Copy: (not-NULL field in table that can be NULL-complemented) -> (NULLable
field)
*/
static void do_outer_field_null(const Copy_field *copy)
{
if (*copy->null_row ||
(copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
{
*copy->to_null_ptr|=copy->to_bit;
copy->to_field->reset();
}
else
{
*copy->to_null_ptr&= ~copy->to_bit;
(copy->do_copy2)(copy);
}
}
/*
Copy: (not-NULL field in table that can be NULL-complemented) -> (not-NULL
field)
*/
static void do_copy_nullable_row_to_notnull(const Copy_field *copy)
{
if (*copy->null_row ||
(copy->from_null_ptr && (*copy->from_null_ptr & copy->from_bit)))
{
copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, 1);
copy->to_field->reset();
}
else
{
(copy->do_copy2)(copy);
}
}
/* Copy: (NULL-able field) -> (not NULL-able field) */
static void do_copy_not_null(const Copy_field *copy)
{
if (*copy->from_null_ptr & copy->from_bit)
{
copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, 1);
copy->to_field->reset();
}
else
(copy->do_copy2)(copy);
}
/*
Copy: (NULL-able field) -> (not NULL-able field of a row that may be
NULL as a whole)
A field declared NOT NULL holds no null bit, so the only way for it to
read as NULL is TABLE::null_row, which says the whole row is a null
complemented one. A NULL reaching such a field therefore says the row
it came from was null complemented, and restoring that state is what
makes the field read as NULL again. This is the inverse of
do_outer_field_null, which recorded the state in the first place.
*/
static void do_copy_null_to_outer_field(const Copy_field *copy)
{
if (*copy->from_null_ptr & copy->from_bit)
{
copy->to_field->table->null_row= 1;
copy->to_field->reset();
}
else
{
copy->to_field->table->null_row= 0;
(copy->do_copy2)(copy);
}
}
/* Copy: (non-NULLable field) -> (NULLable field) */
static void do_copy_maybe_null(const Copy_field *copy)
{
*copy->to_null_ptr&= ~copy->to_bit;
(copy->do_copy2)(copy);
}
/* timestamp and next_number has special handling in case of NULL values */
static void do_copy_timestamp(const Copy_field *copy)
{
if (*copy->from_null_ptr & copy->from_bit)
{
/* Same as in set_field_to_null_with_conversions() */
copy->to_field->set_time();
}
else
(copy->do_copy2)(copy);
}
static void do_copy_next_number(const Copy_field *copy)
{
if (*copy->from_null_ptr & copy->from_bit)
{
/* Same as in set_field_to_null_with_conversions() */
copy->to_field->table->auto_increment_field_not_null= FALSE;
copy->to_field->reset();
}
else
(copy->do_copy2)(copy);
}
void Field_blob::do_copy_blob(const Copy_field *copy)
{
((Field_blob*) copy->to_field)->copy_value(((Field_blob*) copy->from_field));
}
void Field_blob::do_conv_blob(const Copy_field *copy)
{
copy->from_field->val_str(&copy->tmp);
((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
copy->tmp.length(),
copy->tmp.charset());
}
/** Save blob in copy->tmp for GROUP BY. */
static void do_save_blob(const Copy_field *copy)
{
char buff[MAX_FIELD_WIDTH];
String res(buff,sizeof(buff),copy->tmp.charset());
copy->from_field->val_str(&res);
copy->tmp.copy(res);
((Field_blob *) copy->to_field)->store(copy->tmp.ptr(),
copy->tmp.length(),
copy->tmp.charset());
}
void Field::do_field_string(const Copy_field *copy)
{
char buff[MAX_FIELD_WIDTH];
String res(buff, sizeof(buff), copy->from_field->charset());
res.length(0U);
copy->from_field->val_str(&res);
copy->to_field->store(res.ptr(), res.length(), res.charset());
}
void Field_enum::do_field_enum(const Copy_field *copy)
{
if (copy->from_field->val_int() == 0)
((Field_enum *) copy->to_field)->store_type((ulonglong) 0);
else
do_field_string(copy);
}
static void do_field_varbinary_pre50(const Copy_field *copy)
{
char buff[MAX_FIELD_WIDTH];
copy->tmp.set_buffer_if_not_allocated(buff,sizeof(buff),copy->tmp.charset());
copy->from_field->val_str(&copy->tmp);
/* Use the same function as in 4.1 to trim trailing spaces */
size_t length= my_lengthsp_8bit(&my_charset_bin, copy->tmp.ptr(),
copy->from_field->field_length);
copy->to_field->store(copy->tmp.ptr(), length,
copy->tmp.charset());
}
void Field::do_field_int(const Copy_field *copy)
{
longlong value= copy->from_field->val_int();
copy->to_field->store(value,
MY_TEST(copy->from_field->flags & UNSIGNED_FLAG));
}
void Field::do_field_real(const Copy_field *copy)
{
double value=copy->from_field->val_real();
copy->to_field->store(value);
}
void Field::do_field_decimal(const Copy_field *copy)
{
my_decimal value(copy->from_field);
copy->to_field->store_decimal(&value);
}
void Field::do_field_timestamp(const Copy_field *copy)
{
/* Use general but slow copy function */
copy->from_field->save_in_field(copy->to_field);
}
/* Binary representation of the maximum possible pre-11.5 TIMESTAMP(6) */
const uchar timestamp_old_bytes[7]=
{
0x7f, 0xff, 0xff, 0xff, 0x0f, 0x42, 0x3f
};
void Field::do_field_versioned_timestamp(const Copy_field *copy)
{
memcpy(copy->to_ptr, copy->from_ptr, copy->to_length);
if (!memcmp(copy->to_ptr, timestamp_old_bytes, sizeof(timestamp_old_bytes)))
{
/* Convert row_end to max possible timestamp (2106) */
copy->to_ptr[0]= 0xff;
}
}
void Field::do_field_temporal(const Copy_field *copy, date_mode_t fuzzydate)
{
MYSQL_TIME ltime;
// TODO: we now need to check result
if (copy->from_field->get_date(&ltime, fuzzydate))
copy->to_field->reset();
else
copy->to_field->store_time_dec(&ltime, copy->from_field->decimals());
}
void Field::do_field_datetime(const Copy_field *copy)
{
return do_field_temporal(copy, Datetime::Options(TIME_CONV_NONE, current_thd));
}
void Field::do_field_date(const Copy_field *copy)
{
return do_field_temporal(copy, Date::Options(TIME_CONV_NONE));
}
void Field_time::do_field_time(const Copy_field *copy)
{
return do_field_temporal(copy, Time::Options(current_thd));
}
/**
string copy for single byte characters set when to string is shorter than
from string.
*/
static void do_cut_string(const Copy_field *copy)
{
CHARSET_INFO *cs= copy->from_field->charset();
memcpy(copy->to_ptr,copy->from_ptr,copy->to_length);
/* Check if we loosed any important characters */
if (cs->scan((char*) copy->from_ptr + copy->to_length,
(char*) copy->from_ptr + copy->from_length,
MY_SEQ_SPACES) < copy->from_length - copy->to_length)
{
copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, 1);
}
}
/**
string copy for multi byte characters set when to string is shorter than
from string.
*/
static void do_cut_string_complex(const Copy_field *copy)
{ // Shorter string field
CHARSET_INFO *cs= copy->from_field->charset();
const uchar *from_end= copy->from_ptr + copy->from_length;
Well_formed_prefix prefix(cs,
(char*) copy->from_ptr,
(char*) from_end,
copy->to_length / cs->mbmaxlen);
size_t copy_length= prefix.length();
if (copy->to_length < copy_length)
copy_length= copy->to_length;
memcpy(copy->to_ptr, copy->from_ptr, copy_length);
/* Check if we lost any important characters */
if (unlikely(prefix.well_formed_error_pos() ||
cs->scan((char*) copy->from_ptr + copy_length,
(char*) from_end,
MY_SEQ_SPACES) <
(copy->from_length - copy_length)))
{
copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, 1);
}
if (copy_length < copy->to_length)
cs->fill((char*) copy->to_ptr + copy_length,
copy->to_length - copy_length, ' ');
}
static void do_expand_binary(const Copy_field *copy)
{
CHARSET_INFO *cs= copy->from_field->charset();
memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
cs->fill((char*) copy->to_ptr+copy->from_length,
copy->to_length-copy->from_length, '\0');
}
static void do_expand_string(const Copy_field *copy)
{
CHARSET_INFO *cs= copy->from_field->charset();
memcpy(copy->to_ptr,copy->from_ptr,copy->from_length);
cs->fill((char*) copy->to_ptr+copy->from_length,
copy->to_length-copy->from_length, ' ');
}
/*
Copy from a Field_varstring with length_bytes==1
into another Field_varstring with length_bytes==1
when the target column is not shorter than the source column.
We don't need to calculate the prefix in this case. It works for
- non-compressed and compressed columns
- single byte and multi-byte character sets
*/
static void do_varstring1_no_truncation(const Copy_field *copy)
{
uint length= (uint) *(uchar*) copy->from_ptr;
DBUG_ASSERT(length <= copy->to_length - 1);
*(uchar*) copy->to_ptr= (uchar) length;
memcpy(copy->to_ptr+1, copy->from_ptr + 1, length);
}
/*
Copy from a Field_varstring with length_bytes==2
into another Field_varstring with length_bytes==2
when the target column is not shorter than the source column.
We don't need to calculate the prefix in this case. It works for
- non-compressed and compressed columns
- single byte and multi-byte character sets
*/
static void do_varstring2_no_truncation(const Copy_field *copy)
{
uint length= uint2korr(copy->from_ptr);
DBUG_ASSERT(length <= copy->to_length - HA_KEY_BLOB_LENGTH);
int2store(copy->to_ptr, length);
memcpy(copy->to_ptr + HA_KEY_BLOB_LENGTH,
copy->from_ptr + HA_KEY_BLOB_LENGTH, length);
}
static void do_varstring1(const Copy_field *copy)
{
uint length= (uint) *(uchar*) copy->from_ptr;
if (length > copy->to_length- 1)
{
length=copy->to_length - 1;
if (copy->from_field->table->in_use->count_cuted_fields >
CHECK_FIELD_EXPRESSION &&
copy->to_field)
copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, 1);
}
*(uchar*) copy->to_ptr= (uchar) length;
memcpy(copy->to_ptr+1, copy->from_ptr + 1, length);
}
static void do_varstring1_mb(const Copy_field *copy)
{
CHARSET_INFO *cs= copy->from_field->charset();
uint from_length= (uint) *(uchar*) copy->from_ptr;
const uchar *from_ptr= copy->from_ptr + 1;
uint to_char_length= (copy->to_length - 1) / cs->mbmaxlen;
Well_formed_prefix prefix(cs, (char*) from_ptr, from_length, to_char_length);
if (prefix.length() < from_length)
{
if (current_thd->count_cuted_fields > CHECK_FIELD_EXPRESSION)
copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, 1);
}
*copy->to_ptr= (uchar) prefix.length();
memcpy(copy->to_ptr + 1, from_ptr, prefix.length());
}
static void do_varstring2(const Copy_field *copy)
{
uint length=uint2korr(copy->from_ptr);
if (length > copy->to_length- HA_KEY_BLOB_LENGTH)
{
length=copy->to_length-HA_KEY_BLOB_LENGTH;
if (copy->from_field->table->in_use->count_cuted_fields >
CHECK_FIELD_EXPRESSION &&
copy->to_field)
copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, 1);
}
int2store(copy->to_ptr,length);
memcpy(copy->to_ptr+HA_KEY_BLOB_LENGTH, copy->from_ptr + HA_KEY_BLOB_LENGTH,
length);
}
static void do_varstring2_mb(const Copy_field *copy)
{
CHARSET_INFO *cs= copy->from_field->charset();
uint char_length= (copy->to_length - HA_KEY_BLOB_LENGTH) / cs->mbmaxlen;
uint from_length= uint2korr(copy->from_ptr);
const uchar *from_beg= copy->from_ptr + HA_KEY_BLOB_LENGTH;
Well_formed_prefix prefix(cs, (char*) from_beg, from_length, char_length);
if (prefix.length() < from_length)
{
if (current_thd->count_cuted_fields > CHECK_FIELD_EXPRESSION)
copy->to_field->set_warning(Sql_condition::WARN_LEVEL_WARN,
WARN_DATA_TRUNCATED, 1);
}
int2store(copy->to_ptr, prefix.length());
memcpy(copy->to_ptr+HA_KEY_BLOB_LENGTH, from_beg, prefix.length());
}
/***************************************************************************
** The different functions that fills in a Copy_field class
***************************************************************************/
/**
copy of field to maybe null string.
If field is null then the all bytes are set to 0.
if field is not null then the first byte is set to 1 and the rest of the
string is the field value.
The 'to' buffer should have a size of field->pack_length()+1
*/
void Copy_field::set(uchar *to,Field *from)
{
from_ptr=from->ptr;
to_ptr=to;
from_length=from->pack_length_in_rec();
if (from->maybe_null())
{
from_null_ptr=from->null_ptr;
from_bit= from->null_bit;
to_ptr[0]= 1; // Null as default value
to_null_ptr= (uchar*) to_ptr++;
to_bit= 1;
if (from->table->maybe_null)
{
null_row= &from->table->null_row;
do_copy= do_outer_field_to_null_str;
}
else
do_copy= do_field_to_null_str;
}
else
{
to_null_ptr= 0; // For easy debugging
do_copy= Field::do_field_eq;
}
}
/*
To do:
If 'save' is set to true and the 'from' is a blob field, do_copy is set to
do_save_blob rather than do_conv_blob. The only differences between them
appears to be:
- do_save_blob allocates and uses an intermediate buffer before calling
Field_blob::store. Is this in order to trigger the call to
well_formed_copy_nchars, by changing the pointer copy->tmp.ptr()?
That call will take place anyway in all known cases.
*/
void Copy_field::set(Field *to,Field *from,bool save)
{
if (to->type() == MYSQL_TYPE_NULL)
{
to_null_ptr=0; // For easy debugging
to_ptr=0;
do_copy=do_skip;
return;
}
from_field=from;
to_field=to;
from_ptr=from->ptr;
from_length=from->pack_length_in_rec();
to_ptr= to->ptr;
to_length=to_field->pack_length_in_rec();
// set up null handling
from_null_ptr=to_null_ptr=0;
if (from->maybe_null())
{
from_null_ptr= from->null_ptr;
from_bit= from->null_bit;
if (to_field->real_maybe_null())
{
to_null_ptr= to->null_ptr;
to_bit= to->null_bit;
if (from_null_ptr)
do_copy= do_copy_null;
else
{
null_row= &from->table->null_row;
do_copy= do_outer_field_null;
}
}
else
{
if (to_field->type() == MYSQL_TYPE_TIMESTAMP)
do_copy= do_copy_timestamp; // Automatic timestamp
else if (to_field == to_field->table->next_number_field)
do_copy= do_copy_next_number;
else
{
if (!from_null_ptr)
{
null_row= &from->table->null_row;
do_copy= do_copy_nullable_row_to_notnull;
}
else
do_copy= do_copy_not_null;
}
}
}
else if (to_field->real_maybe_null())
{
to_null_ptr= to->null_ptr;
to_bit= to->null_bit;
do_copy= do_copy_maybe_null;
}
else
do_copy=0;
if ((to->flags & BLOB_FLAG) && save)
do_copy2= do_save_blob;
else
do_copy2= from->get_copy_func_to(to);
if (!do_copy) // Not null
do_copy=do_copy2;
}
/*
Same as set(), except that a NULL arriving at a destination declared
NOT NULL is kept rather than turned into a zero with a truncation
warning. It is kept as TABLE::null_row on the destination's table,
the only place such a field can carry a NULL.
This is for reading a row back out of a temporary table into the fields
it was collected from. A truncation warning would be wrong there, since
no value is being narrowed, and losing the NULL would turn a null
complemented row into a row of zeroes.
*/
void Copy_field::set_restoring_null_row(Field *to, Field *from)
{
set(to, from, FALSE);
if (from->maybe_null() && from->null_ptr && !to->real_maybe_null())
do_copy= do_copy_null_to_outer_field;
}
Field::Copy_func *Field_timestamp::get_copy_func(const Field *from) const
{
Field::Copy_func *copy= Field_temporal::get_copy_func(from);
if (from->type() == MYSQL_TYPE_TIMESTAMP)
{
if (copy == do_field_datetime)
return do_field_timestamp;
if (copy == do_field_eq &&
from->table->file->check_versioned_compatibility() &&
(flags & VERS_ROW_END) && (from->flags & VERS_ROW_END))
return do_field_versioned_timestamp;
}
return copy;
}
Field::Copy_func *Field_date_common::get_copy_func(const Field *from) const
{
Field::Copy_func *copy= Field_temporal::get_copy_func(from);
return copy == do_field_datetime ? do_field_date : copy;
}
Field::Copy_func *Field_temporal::get_copy_func(const Field *from) const
{
/* If types are not 100 % identical then convert trough get_date() */
if (from->cmp_type() == REAL_RESULT)
return do_field_string; // TODO: MDEV-9344
if (from->type() == MYSQL_TYPE_YEAR)
return do_field_string; // TODO: MDEV-9343
if (from->type() == MYSQL_TYPE_BIT)
return do_field_int;
if (!eq_def(from) ||
(table->in_use->variables.sql_mode &
(MODE_NO_ZERO_IN_DATE | MODE_NO_ZERO_DATE)))
return do_field_datetime;
return get_identical_copy_func();
}
Field::Copy_func *Field_varstring::get_copy_func(const Field *from) const
{
if (from->type() == MYSQL_TYPE_BIT)
return do_field_int;
/*
Detect copy from pre 5.0 varbinary to varbinary as of 5.0 and
use special copy function that removes trailing spaces and thus
repairs data.
*/
if (from->type() == MYSQL_TYPE_VAR_STRING && !from->has_charset() &&
!Field_varstring::has_charset())
return do_field_varbinary_pre50;
if (Field_varstring::real_type() != from->real_type() ||
Field_varstring::charset() != from->charset() ||
length_bytes != ((const Field_varstring*) from)->length_bytes ||
!compression_method() != !from->compression_method())
return do_field_string;
if (field_length >= from->field_length)
return length_bytes == 1 ? do_varstring1_no_truncation :
do_varstring2_no_truncation;
if (compression_method())
{
/*
Truncation is going to happen, so we need to calculate prefixes.
Can't calculate prefixes directly on compressed data,
need to go through val_str() to uncompress.
*/
return do_field_string;
}
return length_bytes == 1 ?
(from->charset()->mbmaxlen == 1 ? do_varstring1 : do_varstring1_mb) :
(from->charset()->mbmaxlen == 1 ? do_varstring2 : do_varstring2_mb);
}
Field::Copy_func *Field_string::get_copy_func(const Field *from) const
{
if (from->type() == MYSQL_TYPE_BIT)
return do_field_int;
if (Field_string::type_handler() != from->type_handler() ||
Field_string::charset() != from->charset())
return do_field_string;
if (Field_string::pack_length() < from->pack_length())
return (Field_string::charset()->mbmaxlen == 1 ?
do_cut_string : do_cut_string_complex);
if (Field_string::pack_length() > from->pack_length())
return Field_string::charset() == &my_charset_bin ? do_expand_binary :
do_expand_string;
return get_identical_copy_func();
}
Field::Copy_func *Field::get_identical_copy_func() const
{
/* Identical field types */
switch (pack_length()) {
case 1: return do_field_1;
case 2: return do_field_2;
case 3: return do_field_3;
case 4: return do_field_4;
case 6: return do_field_6;
case 8: return do_field_8;
}
return do_field_eq;
}
bool Field_temporal::memcpy_field_possible(const Field *from) const
{
return real_type() == from->real_type() &&
decimals() == from->decimals() &&
!sql_mode_for_dates(table->in_use);
}
static int field_conv_memcpy(Field *to, Field *from)
{
/*
This may happen if one does 'UPDATE ... SET x=x'
The test is here mostly for valgrind, but can also be relevant
if memcpy() is implemented with prefetch-write
*/
if (to->ptr != from->ptr)
memcpy(to->ptr,from->ptr, to->pack_length());
return 0;
}
/**
Copy value of the field with conversion.
@note Impossibility of simple copy should be checked before this call.
@param to The field to copy to
@retval TRUE ERROR
@retval FALSE OK
*/
static int field_conv_incompatible(Field *to, Field *from)
{
return to->store_field(from);
}
/**
Simple quick field converter that is called on insert, e.g.:
INSERT INTO t1 (field1) SELECT field2 FROM t2;
*/
int field_conv(Field *to,Field *from)
{
return to->memcpy_field_possible(from) ?
field_conv_memcpy(to, from) :
field_conv_incompatible(to, from);
}
fast_field_copier Field::get_fast_field_copier(const Field *from)
{
DBUG_ENTER("Field::get_fast_field_copier");
DBUG_RETURN(memcpy_field_possible(from) ?
&field_conv_memcpy :
&field_conv_incompatible);
}
View Git Blame Copy Permalink