Mirrors
/
mariadb
mirror of https://github.com/MariaDB/server
3
0
Fork 0
Code Releases Activity
Browse Source

MDEV-14212 Add Field_row for SP ROW variables

bb-10.2-ext2
Alexander Barkov 8 years ago
parent
5dd5253f7e
commit
667e4b97aa
13 changed files with 113 additions and 92 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 32
      sql/field.cc
  2. 32
      sql/field.h
  3. 8
      sql/item.cc
  4. 44
      sql/item.h
  5. 2
      sql/item_xmlfunc.cc
  6. 8
      sql/sp_head.cc
  7. 2
      sql/sp_head.h
  8. 2
      sql/sp_pcontext.h
  9. 23
      sql/sp_rcontext.cc
  10. 27
      sql/sql_lex.cc
  11. 11
      sql/sql_type.cc
  12. 12
      sql/sql_type.h
  13. 2
      sql/sql_yacc.yy

32
sql/field.cc
View File

@ -2271,6 +2271,16 @@ void Field_null::sql_type(String &res) const
}
/****************************************************************************
Field_row, e.g. for ROW-type SP variables
****************************************************************************/
Field_row::~Field_row()
{
delete m_table;
}
/****************************************************************************
Functions for the Field_decimal class
This is an number stored as a pre-space (or pre-zero) string
@ -10096,6 +10106,21 @@ Field *make_field(TABLE_SHARE *share,
uchar *UNINIT_VAR(bit_ptr);
uchar UNINIT_VAR(bit_offset);
DBUG_PRINT("debug", ("field_type: %s, field_length: %u, interval: %p, pack_flag: %s%s%s%s%s",
handler->name().ptr(), field_length, interval,
FLAGSTR(pack_flag, FIELDFLAG_BINARY),
FLAGSTR(pack_flag, FIELDFLAG_INTERVAL),
FLAGSTR(pack_flag, FIELDFLAG_NUMBER),
FLAGSTR(pack_flag, FIELDFLAG_PACK),
FLAGSTR(pack_flag, FIELDFLAG_BLOB)));
if (handler == &type_handler_row)
{
DBUG_ASSERT(field_length == 0);
DBUG_ASSERT(f_maybe_null(pack_flag));
return new (mem_root) Field_row(ptr, field_name);
}
if (handler->real_field_type() == MYSQL_TYPE_BIT && !f_bit_as_char(pack_flag))
{
bit_ptr= null_pos;
@ -10117,13 +10142,6 @@ Field *make_field(TABLE_SHARE *share,
null_bit= ((uchar) 1) << null_bit;
}
DBUG_PRINT("debug", ("field_type: %s, field_length: %u, interval: %p, pack_flag: %s%s%s%s%s",
handler->name().ptr(), field_length, interval,
FLAGSTR(pack_flag, FIELDFLAG_BINARY),
FLAGSTR(pack_flag, FIELDFLAG_INTERVAL),
FLAGSTR(pack_flag, FIELDFLAG_NUMBER),
FLAGSTR(pack_flag, FIELDFLAG_PACK),
FLAGSTR(pack_flag, FIELDFLAG_BLOB)));
if (f_is_alpha(pack_flag))
{

32
sql/field.h
View File

@ -44,6 +44,7 @@ class Column_statistics_collected;
class Item_func;
class Item_bool_func;
class Item_equal;
class Virtual_tmp_table;
enum enum_check_fields
{
@ -1510,6 +1511,11 @@ public:
/* Mark field in read map. Updates also virtual fields */
void register_field_in_read_map();
virtual Virtual_tmp_table **virtual_tmp_table_addr()
{
return NULL;
}
friend int cre_myisam(char * name, register TABLE *form, uint options,
ulonglong auto_increment_value);
friend class Copy_field;
@ -3814,6 +3820,19 @@ public:
};
class Field_row: public Field_null
{
class Virtual_tmp_table *m_table;
public:
Field_row(uchar *ptr_arg, const LEX_CSTRING *field_name_arg)
:Field_null(ptr_arg, 0, Field::NONE, field_name_arg, &my_charset_bin),
m_table(NULL)
{}
~Field_row();
Virtual_tmp_table **virtual_tmp_table_addr() { return &m_table; }
};
extern const LEX_CSTRING null_clex_str;
Field *make_field(TABLE_SHARE *share, MEM_ROOT *mem_root,
@ -4164,9 +4183,7 @@ public:
{ }
const Type_handler *type_handler() const
{
return is_row() || is_table_rowtype_ref() || is_cursor_rowtype_ref() ?
&type_handler_row :
Type_handler_hybrid_field_type::type_handler();
return Type_handler_hybrid_field_type::type_handler();
}
bool is_column_type_ref() const { return m_column_type_ref != 0; }
bool is_table_rowtype_ref() const { return m_table_rowtype_ref != 0; }
@ -4186,6 +4203,8 @@ public:
}
void set_table_rowtype_ref(class Table_ident *ref)
{
DBUG_ASSERT(ref);
set_handler(&type_handler_row);
m_table_rowtype_ref= ref;
}
@ -4193,9 +4212,10 @@ public:
{
return m_cursor_rowtype_offset;
}
void set_cursor_rowtype_ref(bool ref, uint offset)
void set_cursor_rowtype_ref(uint offset)
{
m_cursor_rowtype_ref= ref;
set_handler(&type_handler_row);
m_cursor_rowtype_ref= true;
m_cursor_rowtype_offset= offset;
}
@ -4224,6 +4244,8 @@ public:
}
void set_row_field_definitions(Row_definition_list *list)
{
DBUG_ASSERT(list);
set_handler(&type_handler_row);
m_row_field_definitions= list;
}

8
sql/item.cc
View File

@ -1753,17 +1753,15 @@ void Item_sp_variable::make_field(THD *thd, Send_field *field)
Item_splocal::Item_splocal(THD *thd, const LEX_CSTRING *sp_var_name,
uint sp_var_idx,
enum_field_types sp_var_type,
const Type_handler *handler,
uint pos_in_q, uint len_in_q):
Item_sp_variable(thd, sp_var_name),
Rewritable_query_parameter(pos_in_q, len_in_q),
Type_handler_hybrid_field_type(handler),
m_var_idx(sp_var_idx)
{
maybe_null= TRUE;
sp_var_type= real_type_to_type(sp_var_type);
m_type= sp_map_item_type(sp_var_type);
set_handler_by_field_type(sp_var_type);
m_type= sp_map_item_type(handler);
}

44
sql/item.h
View File

@ -2093,17 +2093,6 @@ public:
};
class Item_spvar_args: public Item_args
{
Virtual_tmp_table *m_table;
public:
Item_spvar_args():Item_args(), m_table(NULL) { }
~Item_spvar_args();
bool row_create_items(THD *thd, List<Spvar_definition> *list);
Field *get_row_field(uint i) const;
};
/*
Class to be used to enumerate all field references in an item tree. This
includes references to outside but not fields of the tables within a
@ -2337,7 +2326,7 @@ protected:
bool append_value_for_log(THD *thd, String *str);
public:
Item_splocal(THD *thd, const LEX_CSTRING *sp_var_name, uint sp_var_idx,
enum_field_types sp_var_type,
const Type_handler *handler,
uint pos_in_q= 0, uint len_in_q= 0);
bool fix_fields(THD *, Item **);
@ -2390,20 +2379,6 @@ public:
};
class Item_splocal_row: public Item_splocal
{
public:
Item_splocal_row(THD *thd, const LEX_CSTRING *sp_var_name,
uint sp_var_idx, uint pos_in_q, uint len_in_q)
:Item_splocal(thd, sp_var_name, sp_var_idx, MYSQL_TYPE_NULL,
pos_in_q, len_in_q)
{
set_handler(&type_handler_row);
}
enum Type type() const { return ROW_ITEM; }
};
/**
An Item_splocal variant whose data type becomes known only at
sp_rcontext creation time, e.g. "DECLARE var1 t1.col1%TYPE".
@ -2415,7 +2390,7 @@ public:
const LEX_CSTRING *sp_var_name,
uint sp_var_idx,
uint pos_in_q, uint len_in_q)
:Item_splocal(thd, sp_var_name, sp_var_idx, MYSQL_TYPE_NULL,
:Item_splocal(thd, sp_var_name, sp_var_idx, &type_handler_null,
pos_in_q, len_in_q)
{ }
};
@ -2437,9 +2412,9 @@ public:
const LEX_CSTRING *sp_var_name,
const LEX_CSTRING *sp_field_name,
uint sp_var_idx, uint sp_field_idx,
enum_field_types sp_var_type,
const Type_handler *handler,
uint pos_in_q= 0, uint len_in_q= 0)
:Item_splocal(thd, sp_var_name, sp_var_idx, sp_var_type,
:Item_splocal(thd, sp_var_name, sp_var_idx, handler,
pos_in_q, len_in_q),
m_field_name(*sp_field_name),
m_field_idx(sp_field_idx)
@ -2461,11 +2436,11 @@ public:
const LEX_CSTRING *sp_var_name,
const LEX_CSTRING *sp_field_name,
uint sp_var_idx,
enum_field_types sp_var_type,
const Type_handler *handler,
uint pos_in_q= 0, uint len_in_q= 0)
:Item_splocal_row_field(thd, sp_var_name, sp_field_name,
sp_var_idx, 0 /* field index will be set later */,
sp_var_type, pos_in_q, len_in_q)
handler, pos_in_q, len_in_q)
{ }
bool fix_fields(THD *thd, Item **it);
void print(String *str, enum_query_type query_type);
@ -2930,14 +2905,13 @@ public:
Item_field for the ROW data type
*/
class Item_field_row: public Item_field,
public Item_spvar_args
public Item_args
{
public:
Item_field_row(THD *thd, Field *field)
:Item_field(thd, field),
Item_spvar_args()
Item_args()
{ }
Item *get_copy(THD *thd, MEM_ROOT *mem_root)
{ return get_item_copy<Item_field_row>(thd, mem_root, this); }
@ -2955,6 +2929,8 @@ public:
}
return false;
}
bool row_create_items(THD *thd, List<Spvar_definition> *list);
Field *get_row_field(uint i) const;
};

2
sql/item_xmlfunc.cc
View File

@ -2621,7 +2621,7 @@ my_xpath_parse_VariableReference(MY_XPATH *xpath)
(spv= spc->find_variable(&name, false)))
{
Item_splocal *splocal= new (thd->mem_root)
Item_splocal(thd, &name, spv->offset, spv->sql_type(), 0);
Item_splocal(thd, &name, spv->offset, spv->type_handler(), 0);
#ifndef DBUG_OFF
if (splocal)
splocal->m_sp= lex->sphead;

8
sql/sp_head.cc
View File

@ -70,8 +70,12 @@ static void reset_start_time_for_sp(THD *thd)
Item::Type
sp_map_item_type(enum enum_field_types type)
sp_map_item_type(const Type_handler *handler)
{
if (handler == &type_handler_row)
return Item::ROW_ITEM;
enum_field_types type= real_type_to_type(handler->real_field_type());
switch (type) {
case MYSQL_TYPE_BIT:
case MYSQL_TYPE_TINY:
@ -4757,11 +4761,11 @@ bool sp_head::spvar_fill_row(THD *thd,
sp_variable *spvar,
Row_definition_list *defs)
{
spvar->field_def.set_row_field_definitions(defs);
spvar->field_def.field_name= spvar->name;
if (fill_spvar_definition(thd, &spvar->field_def))
return true;
row_fill_field_definitions(thd, defs);
spvar->field_def.set_row_field_definitions(defs);
return false;
}

2
sql/sp_head.h
View File

@ -41,7 +41,7 @@
*/
Item::Type
sp_map_item_type(enum enum_field_types type);
sp_map_item_type(const Type_handler *handler);
uint
sp_get_flags_for_command(LEX *lex);

2
sql/sp_pcontext.h
View File

@ -60,8 +60,6 @@ public:
Spvar_definition field_def;
/// Field-type of the SP-variable.
enum_field_types sql_type() const { return field_def.real_field_type(); }
const Type_handler *type_handler() const { return field_def.type_handler(); }
public:

23
sql/sp_rcontext.cc
View File

@ -358,10 +358,13 @@ bool sp_rcontext::init_var_items(THD *thd,
}
bool Item_spvar_args::row_create_items(THD *thd, List<Spvar_definition> *list)
bool Item_field_row::row_create_items(THD *thd, List<Spvar_definition> *list)
{
DBUG_ASSERT(list);
if (!(m_table= create_virtual_tmp_table(thd, *list)))
DBUG_ASSERT(field);
Virtual_tmp_table **ptable= field->virtual_tmp_table_addr();
DBUG_ASSERT(ptable);
if (!(ptable[0]= create_virtual_tmp_table(thd, *list)))
return true;
if (alloc_arguments(thd, list->elements))
@ -372,23 +375,19 @@ bool Item_spvar_args::row_create_items(THD *thd, List<Spvar_definition> *list)
for (arg_count= 0; (def= it++); arg_count++)
{
if (!(args[arg_count]= new (thd->mem_root)
Item_field(thd, m_table->field[arg_count])))
Item_field(thd, ptable[0]->field[arg_count])))
return true;
}
return false;
}
Field *Item_spvar_args::get_row_field(uint i) const
Field *Item_field_row::get_row_field(uint i) const
{
DBUG_ASSERT(m_table);
return m_table->field[i];
}
Item_spvar_args::~Item_spvar_args()
{
delete m_table;
DBUG_ASSERT(field);
Virtual_tmp_table **ptable= field->virtual_tmp_table_addr();
DBUG_ASSERT(ptable);
return ptable[0]->field[i];
}

27
sql/sql_lex.cc
View File

@ -5294,7 +5294,11 @@ LEX::sp_variable_declarations_copy_type_finalize(THD *thd, int nvars,
{
sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
spvar->field_def.set_type(ref);
spvar->field_def.set_row_field_definitions(fields);
if (fields)
{
DBUG_ASSERT(ref.type_handler() == &type_handler_row);
spvar->field_def.set_row_field_definitions(fields);
}
spvar->field_def.field_name= spvar->name;
}
if (sp_variable_declarations_set_default(thd, nvars, default_value))
@ -5340,9 +5344,9 @@ bool LEX::sp_variable_declarations_row_finalize(THD *thd, int nvars,
for (uint i= 0 ; i < (uint) nvars ; i++)
{
sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
spvar->field_def.set_row_field_definitions(row);
if (sphead->fill_spvar_definition(thd, &spvar->field_def, &spvar->name))
return true;
spvar->field_def.set_row_field_definitions(row);
}
if (sp_variable_declarations_set_default(thd, nvars, dflt_value_item))
@ -5428,7 +5432,7 @@ LEX::sp_variable_declarations_cursor_rowtype_finalize(THD *thd, int nvars,
{
sp_variable *spvar= spcont->get_last_context_variable((uint) nvars - 1 - i);
spvar->field_def.set_cursor_rowtype_ref(true, offset);
spvar->field_def.set_cursor_rowtype_ref(offset);
sp_instr_cursor_copy_struct *instr=
new (thd->mem_root) sp_instr_cursor_copy_struct(sphead->instructions(),
spcont, pcursor->lex(),
@ -5592,7 +5596,7 @@ LEX::sp_add_for_loop_cursor_variable(THD *thd,
if (!(spvar->default_value= new (thd->mem_root) Item_null(thd)))
return NULL;
spvar->field_def.set_cursor_rowtype_ref(true, coffset);
spvar->field_def.set_cursor_rowtype_ref(coffset);
if (sphead->add_for_loop_open_cursor(thd, spcont, spvar, pcursor, coffset,
param_lex, parameters))
@ -5616,7 +5620,7 @@ bool LEX::sp_for_loop_condition(THD *thd, const Lex_for_loop_st &loop)
{
sp_variable *src= i == 0 ? loop.m_index : loop.m_upper_bound;
args[i]= new (thd->mem_root)
Item_splocal(thd, &src->name, src->offset, src->sql_type());
Item_splocal(thd, &src->name, src->offset, src->type_handler());
if (args[i] == NULL)
return true;
#ifndef DBUG_OFF
@ -5750,7 +5754,7 @@ bool LEX::sp_for_loop_increment(THD *thd, const Lex_for_loop_st &loop)
{
Item_splocal *splocal= new (thd->mem_root)
Item_splocal(thd, &loop.m_index->name, loop.m_index->offset,
loop.m_index->sql_type());
loop.m_index->type_handler());
if (splocal == NULL)
return true;
#ifndef DBUG_OFF
@ -6521,7 +6525,7 @@ Item_splocal *LEX::create_item_spvar_row_field(THD *thd,
{
if (!(item= new (thd->mem_root)
Item_splocal_row_field_by_name(thd, a, b, spv->offset,
MYSQL_TYPE_NULL,
&type_handler_null,
pos.pos(), pos.length())))
return NULL;
}
@ -6535,7 +6539,7 @@ Item_splocal *LEX::create_item_spvar_row_field(THD *thd,
if (!(item= new (thd->mem_root)
Item_splocal_row_field(thd, a, b,
spv->offset, row_field_offset,
def->real_field_type(),
def->type_handler(),
pos.pos(), pos.length())))
return NULL;
}
@ -6704,7 +6708,7 @@ Item *LEX::create_item_limit(THD *thd,
Query_fragment pos(thd, sphead, start, end);
Item_splocal *item;
if (!(item= new (thd->mem_root) Item_splocal(thd, a,
spv->offset, spv->sql_type(),
spv->offset, spv->type_handler(),
pos.pos(), pos.length())))
return NULL;
#ifndef DBUG_OFF
@ -6823,11 +6827,8 @@ Item *LEX::create_item_ident_sp(THD *thd, LEX_CSTRING *name,
spv->offset,
pos.pos(),
pos.length()) :
spv->field_def.is_row() || spv->field_def.is_table_rowtype_ref() ?
new (thd->mem_root) Item_splocal_row(thd, name, spv->offset,
pos.pos(), pos.length()) :
new (thd->mem_root) Item_splocal(thd, name,
spv->offset, spv->sql_type(),
spv->offset, spv->type_handler(),
pos.pos(), pos.length());
if (splocal == NULL)
return NULL;

11
sql/sql_type.cc
View File

@ -1589,6 +1589,17 @@ bool Type_handler_null::
return false;
}
bool Type_handler_row::
Column_definition_prepare_stage1(THD *thd,
MEM_ROOT *mem_root,
Column_definition *def,
handler *file,
ulonglong table_flags) const
{
def->create_length_to_internal_length_null();
return false;
}
bool Type_handler_newdecimal::
Column_definition_prepare_stage1(THD *thd,
MEM_ROOT *mem_root,

12
sql/sql_type.h
View File

@ -1046,18 +1046,13 @@ public:
}
bool Column_definition_fix_attributes(Column_definition *c) const
{
DBUG_ASSERT(0);
return true;
return false;
}
bool Column_definition_prepare_stage1(THD *thd,
MEM_ROOT *mem_root,
Column_definition *c,
handler *file,
ulonglong table_flags) const
{
DBUG_ASSERT(0);
return true;
}
ulonglong table_flags) const;
bool Column_definition_redefine_stage1(Column_definition *def,
const Column_definition *dup,
const handler *file,
@ -1071,8 +1066,7 @@ public:
handler *file,
ulonglong table_flags) const
{
DBUG_ASSERT(0);
return true;
return false;
}
Field *make_table_field(const LEX_CSTRING *name,
const Record_addr &addr,

2
sql/sql_yacc.yy
View File

@ -396,7 +396,7 @@ LEX::create_item_for_sp_var(LEX_CSTRING *name, sp_variable *spvar,
len_in_q= (uint)(end_in_q - start_in_q);
item= new (thd->mem_root)
Item_splocal(thd, name, spvar->offset, spvar->sql_type(),
Item_splocal(thd, name, spvar->offset, spvar->type_handler(),
pos_in_q, len_in_q);
#ifndef DBUG_OFF

Write Preview
Loading…
Cancel
Save