Merge chilla.local:/home/mydev/mysql-5.0-bug16218 (a085d098) · Commits · Software / OSDI20 Artifacts / mariadb

sql/field.cc

+11 −17

Original line number	Diff line number	Diff line
		@@ -1536,7 +1536,8 @@ bool Field::optimize_range(uint idx, uint part)
		}


		Field Field::new_field(MEM_ROOT root, struct st_table *new_table)
		Field Field::new_field(MEM_ROOT root, struct st_table *new_table,
		bool keep_type __attribute__((unused)))
		{
		Field *tmp;
		if (!(tmp= (Field) memdup_root(root,(char) this,size_of())))
		@@ -1561,7 +1562,7 @@ Field Field::new_key_field(MEM_ROOT root, struct st_table *new_table,
		uint new_null_bit)
		{
		Field *tmp;
		if ((tmp= new_field(root, new_table)))
		if ((tmp= new_field(root, new_table, table == new_table)))
		{
		tmp->ptr= new_ptr;
		tmp->null_ptr= new_null_ptr;
		@@ -6371,11 +6372,12 @@ uint Field_string::max_packed_col_length(uint max_length)
		}


		Field Field_string::new_field(MEM_ROOT root, struct st_table *new_table)
		Field Field_string::new_field(MEM_ROOT root, struct st_table *new_table,
		bool keep_type)
		{
		Field *field;
		if (type() != MYSQL_TYPE_VAR_STRING \|\| table == new_table)
		return Field::new_field(root, new_table);
		if (type() != MYSQL_TYPE_VAR_STRING \|\| keep_type)
		return Field::new_field(root, new_table, keep_type);

		/*
		Old VARCHAR field which should be modified to a VARCHAR on copy
		@@ -6384,17 +6386,7 @@ Field Field_string::new_field(MEM_ROOT root, struct st_table *new_table)
		*/
		if ((field= new Field_varstring(field_length, maybe_null(), field_name,
		new_table->s, charset())))
		{
		field->init(new_table);
		/*
		delayed_insert::get_local_table() needs a ptr copied from old table.
		This is what other new_field() methods do too. The above method of
		Field_varstring sets ptr to NULL.
		*/
		field->ptr= ptr;
		field->null_ptr= null_ptr;
		field->null_bit= null_bit;
		}
		return field;
		}

		@@ -6896,9 +6888,11 @@ int Field_varstring::cmp_binary(const char a_ptr, const char b_ptr,
		}


		Field Field_varstring::new_field(MEM_ROOT root, struct st_table *new_table)
		Field Field_varstring::new_field(MEM_ROOT root, struct st_table *new_table,
		bool keep_type)
		{
		Field_varstring res= (Field_varstring) Field::new_field(root, new_table);
		Field_varstring res= (Field_varstring) Field::new_field(root, new_table,
		keep_type);
		if (res)
		res->length_bytes= length_bytes;
		return res;

sql/field.h

+4 −3

Original line number	Diff line number	Diff line
		@@ -219,7 +219,8 @@ class Field
		*/
		virtual bool can_be_compared_as_longlong() const { return FALSE; }
		virtual void free() {}
		virtual Field new_field(MEM_ROOT root, struct st_table *new_table);
		virtual Field new_field(MEM_ROOT root, struct st_table *new_table,
		bool keep_type);
		virtual Field new_key_field(MEM_ROOT root, struct st_table *new_table,
		char new_ptr, uchar new_null_ptr,
		uint new_null_bit);
		@@ -1044,7 +1045,7 @@ class Field_string :public Field_longstr {
		enum_field_types real_type() const { return FIELD_TYPE_STRING; }
		bool has_charset(void) const
		{ return charset() == &my_charset_bin ? FALSE : TRUE; }
		Field new_field(MEM_ROOT root, struct st_table *new_table);
		Field new_field(MEM_ROOT root, struct st_table *new_table, bool keep_type);
		};


		@@ -1117,7 +1118,7 @@ class Field_varstring :public Field_longstr {
		enum_field_types real_type() const { return MYSQL_TYPE_VARCHAR; }
		bool has_charset(void) const
		{ return charset() == &my_charset_bin ? FALSE : TRUE; }
		Field new_field(MEM_ROOT root, struct st_table *new_table);
		Field new_field(MEM_ROOT root, struct st_table *new_table, bool keep_type);
		Field new_key_field(MEM_ROOT root, struct st_table *new_table,
		char new_ptr, uchar new_null_ptr,
		uint new_null_bit);

sql/sql_insert.cc

+67 −16

Original line number	Diff line number	Diff line
		@@ -17,6 +17,44 @@

		/* Insert of records */

		/*
		INSERT DELAYED

		Insert delayed is distinguished from a normal insert by lock_type ==
		TL_WRITE_DELAYED instead of TL_WRITE. It first tries to open a
		"delayed" table (delayed_get_table()), but falls back to
		open_and_lock_tables() on error and proceeds as normal insert then.

		Opening a "delayed" table means to find a delayed insert thread that
		has the table open already. If this fails, a new thread is created and
		waited for to open and lock the table.

		If accessing the thread succeeded, in
		delayed_insert::get_local_table() the table of the thread is copied
		for local use. A copy is required because the normal insert logic
		works on a target table, but the other threads table object must not
		be used. The insert logic uses the record buffer to create a record.
		And the delayed insert thread uses the record buffer to pass the
		record to the table handler. So there must be different objects. Also
		the copied table is not included in the lock, so that the statement
		can proceed even if the real table cannot be accessed at this moment.

		Copying a table object is not a trivial operation. Besides the TABLE
		object there are the field pointer array, the field objects and the
		record buffer. After copying the field objects, their pointers into
		the record must be "moved" to point to the new record buffer.

		After this setup the normal insert logic is used. Only that for
		delayed inserts write_delayed() is called instead of write_record().
		It inserts the rows into a queue and signals the delayed insert thread
		instead of writing directly to the table.

		The delayed insert thread awakes from the signal. It locks the table,
		inserts the rows from the queue, unlocks the table, and waits for the
		next signal. It does normally live until a FLUSH TABLES or SHUTDOWN.

		*/

		#include "mysql_priv.h"
		#include "sp_head.h"
		#include "sql_trigger.h"
		@@ -1516,6 +1554,7 @@ TABLE delayed_insert::get_local_table(THD client_thd)
		TABLE *copy;
		TABLE_SHARE *share= table->s;
		byte *bitmap;
		DBUG_ENTER("delayed_insert::get_local_table");

		/* First request insert thread to get a lock */
		status=1;
		@@ -1539,6 +1578,13 @@ TABLE delayed_insert::get_local_table(THD client_thd)
		}
		}

		/*
		Allocate memory for the TABLE object, the field pointers array, and
		one record buffer of reclength size. Normally a table has three
		record buffers of rec_buff_length size, which includes alignment
		bytes. Since the table copy is used for creating one record only,
		the other record buffers and alignment are unnecessary.
		*/
		client_thd->proc_info="allocating local table";
		copy= (TABLE) client_thd->alloc(sizeof(copy)+
		(share->fields+1)sizeof(Field*)+
		@@ -1546,23 +1592,28 @@ TABLE delayed_insert::get_local_table(THD client_thd)
		share->column_bitmap_size*2);
		if (!copy)
		goto error;
		copy= table;

		/* Copy the TABLE object. */
		copy= table;
		/* We don't need to change the file handler here */
		/* Assign the pointers for the field pointers array and the record. */
		field= copy->field= (Field**) (copy + 1);
		bitmap= (byte*) (field + share->fields + 1);
		copy->record[0]= (bitmap + share->column_bitmap_size * 2);
		memcpy((char) copy->record[0], (char) table->record[0], share->reclength);

		/* Make a copy of all fields */

		/*
		Make a copy of all fields.
		The copied fields need to point into the copied record. This is done
		by copying the field objects with their old pointer values and then
		"move" the pointers by the distance between the original and copied
		records. That way we preserve the relative positions in the records.
		*/
		adjust_ptrs= PTR_BYTE_DIFF(copy->record[0], table->record[0]);

		found_next_number_field= table->found_next_number_field;
		for (org_field= table->field; *org_field; org_field++, field++)
		{
		if (!(field= (org_field)->new_field(client_thd->mem_root,copy)))
		return 0;
		if (!(field= (org_field)->new_field(client_thd->mem_root, copy, 1)))
		DBUG_RETURN(0);
		(*field)->orig_table= copy; // Remove connection
		(*field)->move_field_offset(adjust_ptrs); // Point at copy->record[0]
		if (*org_field == found_next_number_field)
		@@ -1595,14 +1646,14 @@ TABLE delayed_insert::get_local_table(THD client_thd)
		copy->read_set= &copy->def_read_set;
		copy->write_set= &copy->def_write_set;

		return copy;
		DBUG_RETURN(copy);

		/* Got fatal error */
		error:
		tables_in_use--;
		status=1;
		pthread_cond_signal(&cond); // Inform thread about abort
		return 0;
		DBUG_RETURN(0);
		}

sql/sql_select.cc

+3 −2

Original line number	Diff line number	Diff line
		@@ -8058,7 +8058,8 @@ Field create_tmp_field_from_field(THD thd, Field *org_field,
		org_field->field_name, table->s,
		org_field->charset());
		else
		new_field= org_field->new_field(thd->mem_root, table);
		new_field= org_field->new_field(thd->mem_root, table,
		table == org_field->table);
		if (new_field)
		{
		new_field->init(table);
		@@ -13166,7 +13167,7 @@ setup_copy_fields(THD thd, TMP_TABLE_PARAM param,
		saved value
		*/
		Field *field= item->field;
		item->result_field=field->new_field(thd->mem_root,field->table);
		item->result_field=field->new_field(thd->mem_root,field->table, 1);
		char tmp=(char) sql_alloc(field->pack_length()+1);
		if (!tmp)
		goto err;

sql/sql_trigger.cc

+2 −1

Original line number	Diff line number	Diff line
		@@ -733,7 +733,8 @@ bool Table_triggers_list::prepare_record1_accessors(TABLE *table)
		QQ: it is supposed that it is ok to use this function for field
		cloning...
		*/
		if (!(old_fld= (fld)->new_field(&table->mem_root, table)))
		if (!(old_fld= (fld)->new_field(&table->mem_root, table,
		table == (*fld)->table)))
		return 1;
		(*old_fld)->move_field_offset((my_ptrdiff_t)(table->record[1] -
		table->record[0]));