database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-29 05:21:33 +03:00
Code Activity

After merge fixes

Browse Source 
Added THD to add_to_xxx_list() functions for faster parsing.


heap/_check.c:
  After merge fix
mysql-test/r/distinct.result:
  After merge fix
mysql-test/r/multi_update.result:
  Make timestamp test portable
mysql-test/t/multi_update.test:
  Make timestamp test portable
sql/field.cc:
  After merge fix
sql/item_sum.cc:
  After merge fix
sql/log_event.cc:
  Remove compiler warning
sql/mysql_priv.h:
  Added THD to add_to_list (Faster parsing)
sql/sql_derived.cc:
  Fixed parameters to create_tmp_table()
sql/sql_lex.cc:
  Added THD to add_to_list (Faster parsing)
sql/sql_lex.h:
  Added THD to add_to_list (Faster parsing)
sql/sql_parse.cc:
  Added THD to add_to_list (Faster parsing)
sql/sql_select.cc:
  After merge fixes
  Fixed return values from JOIN::optimize()
  Replaced test_function_query with '!tables_list'
  Optimized arguments to create_tmp_table()
sql/sql_select.h:
  Removed test_function_query variable
  Updated prototypes
sql/sql_union.cc:
  Updated argument lists.
sql/sql_update.cc:
  After merge fixes
sql/sql_yacc.yy:
  Added THD to all add_xxx_to_list() functions
sql/table.h:
  After merge fix
This commit is contained in:
unknown
2002-12-06 21:11:27 +02:00
parent 6d33f73416
commit ae4323e0d9
18 changed files with 227 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

132
sql/sql_select.cc
View File

@ -377,7 +377,6 @@ JOIN::prepare(TABLE_LIST *tables_init,
int
JOIN::optimize()
{
ha_rows select_limit;
DBUG_ENTER("JOIN::optimize");
#ifdef HAVE_REF_TO_FIELDS // Not done yet
@ -400,19 +399,17 @@ JOIN::optimize()
#endif
conds= optimize_cond(conds,&cond_value);
if (thd->fatal_error)
if (thd->fatal_error || thd->net.report_error)
{
// quick abort
delete procedure;
error= 0;
DBUG_RETURN(1);
} else if (thd->net.report_error)
// normal error processing & cleanup
DBUG_RETURN(-1);
error= thd->net.report_error ? -1 : 1;
DBUG_RETURN(-1); // Return without cleanup
}
if (cond_value == Item::COND_FALSE ||
(!unit->select_limit_cnt && !(select_options & OPTION_FOUND_ROWS)))
{ /* Impossible cond */
{ /* Impossible cond */
zero_result_cause= "Impossible WHERE";
DBUG_RETURN(0);
}
@ -429,24 +426,21 @@ JOIN::optimize()
DBUG_RETURN(0);
}
zero_result_cause= "Select tables optimized away";
tables_list= 0; // All tables resolved
tables_list= 0; // All tables resolved
}
}
if (!tables_list)
{
test_function_query= 1;
DBUG_RETURN(0);
}
error= -1;
error= -1; // Error is sent to client
sort_by_table= get_sort_by_table(order, group_list, tables_list);
/* Calculate how to do the join */
thd->proc_info= "statistics";
if (make_join_statistics(this, tables_list, conds, &keyuse) ||
thd->fatal_error)
DBUG_RETURN(-1);
DBUG_RETURN(1);
if (select_lex->dependent)
{
@ -460,7 +454,9 @@ JOIN::optimize()
}
thd->proc_info= "preparing";
if (result->initialize_tables(this))
DBUG_RETURN(-1);
{
DBUG_RETURN(1); // error = -1
}
if (const_table_map != found_const_table_map &&
!(select_options & SELECT_DESCRIBE))
{
@ -474,7 +470,7 @@ JOIN::optimize()
{ /* purecov: inspected */
my_message(ER_TOO_BIG_SELECT, ER(ER_TOO_BIG_SELECT), MYF(0));
error= 1; /* purecov: inspected */
DBUG_RETURN(-1);
DBUG_RETURN(1);
}
if (const_tables && !thd->locked_tables &&
!(select_options & SELECT_NO_UNLOCK))
@ -502,9 +498,9 @@ JOIN::optimize()
select=make_select(*table, const_table_map,
const_table_map, conds, &error);
if (error)
{ /* purecov: inspected */
error= -1; /* purecov: inspected */
DBUG_RETURN(-1);
{ /* purecov: inspected */
error= -1; /* purecov: inspected */
DBUG_RETURN(1);
}
if (make_join_select(this, select, conds))
{
@ -543,11 +539,11 @@ JOIN::optimize()
bool all_order_fields_used;
if (order)
skip_sort_order= test_if_skip_sort_order(tab, order, select_limit, 1);
if ((group=create_distinct_group(thd, order, fields_list,
&all_order_fields_used)))
if ((group_list=create_distinct_group(thd, order, fields_list,
&all_order_fields_used)))
{
bool skip_group= (skip_sort_order &&
test_if_skip_sort_order(tab, group, select_limit,
test_if_skip_sort_order(tab, group_list, select_limit,
1) != 0);
if ((skip_group && all_order_fields_used) ||
select_limit == HA_POS_ERROR ||
@ -561,10 +557,10 @@ JOIN::optimize()
group=1; // For end_write_group
}
else
group= 0;
group_list= 0;
}
else if (thd->fatal_error) // End of memory
DBUG_RETURN(-1);
DBUG_RETURN(1);
}
group_list= remove_const(this, group_list, conds, &simple_group);
if (!group_list && group)
@ -648,7 +644,7 @@ JOIN::optimize()
(order && simple_order || group_list && simple_group))
{
if (add_ref_to_table_cond(thd,&join_tab[const_tables]))
DBUG_RETURN(-1);
DBUG_RETURN(1);
}
if (!(select_options & SELECT_BIG_RESULT) &&
@ -712,7 +708,7 @@ JOIN::exec()
DBUG_ENTER("JOIN::exec");
if (test_function_query)
if (!tables_list)
{ // Only test of functions
error=0;
if (select_options & SELECT_DESCRIBE)
@ -790,9 +786,9 @@ JOIN::exec()
group_list : (ORDER*) 0),
group_list ? 0 : select_distinct,
group_list && simple_group,
(order == 0 || skip_sort_order) &&
select_limit != HA_POS_ERROR,
select_options, unit)))
select_options,
(order == 0 || skip_sort_order) ? select_limit :
HA_POS_ERROR)))
DBUG_VOID_RETURN;
if (having_list &&
@ -917,9 +913,8 @@ JOIN::exec()
if (!(tmp_table2 = create_tmp_table(thd, &tmp_table_param, all_fields,
(ORDER*) 0,
select_distinct && !group_list,
1, 0,
select_options, unit)))
DBUG_VOID_RETURN;
1, select_options, HA_POS_ERROR)))
DBUG_VOID_RETURN;
if (group_list)
{
thd->proc_info="Creating sort index";
@ -1122,9 +1117,10 @@ mysql_select(THD *thd, TABLE_LIST *tables, List<Item> &fields, COND *conds,
SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex,
bool fake_select_lex)
{
int err;
bool free_join= 1;
DBUG_ENTER("mysql_select");
bool free_join= 1;
JOIN *join;
if (!fake_select_lex && select_lex->join != 0)
{
@ -1168,13 +1164,13 @@ mysql_select(THD *thd, TABLE_LIST *tables, List<Item> &fields, COND *conds,
}
}
switch (join->optimize())
if ((err= join->optimize()))
{
case 1:
DBUG_RETURN(join->error);
case -1:
goto err;
}
if (err == -1)
DBUG_RETURN(join->error);
DBUG_ASSERT(err == 1);
goto err; // 1
}
if (thd->net.report_error || (free_join && join->global_optimize()))
goto err;
@ -1187,13 +1183,13 @@ err:
thd->limit_found_rows = join->send_records;
thd->examined_row_count = join->examined_rows;
thd->proc_info="end";
int error= (fake_select_lex?join->error:join->cleanup(thd)) ||
thd->net.report_error;
err= (fake_select_lex ? join->error : join->cleanup(thd));
if (thd->net.report_error)
err= -1;
delete join;
DBUG_RETURN(error);
DBUG_RETURN(err);
}
else
DBUG_RETURN(join->error);
DBUG_RETURN(join->error);
}
/*****************************************************************************
@ -3887,8 +3883,7 @@ Field *create_tmp_field(THD *thd, TABLE *table,Item *item, Item::Type type,
TABLE *
create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
ORDER *group, bool distinct, bool save_sum_fields,
bool allow_distinct_limit, ulong select_options,
SELECT_LEX_UNIT *unit)
ulong select_options, ha_rows rows_limit)
{
TABLE *table;
uint i,field_count,reclength,null_count,null_pack_length,
@ -3908,9 +3903,9 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
uint temp_pool_slot=MY_BIT_NONE;
DBUG_ENTER("create_tmp_table");
DBUG_PRINT("enter",("distinct: %d save_sum_fields: %d allow_distinct_limit: %d group: %d",
DBUG_PRINT("enter",("distinct: %d save_sum_fields: %d rows_limit: %lu group: %d",
(int) distinct, (int) save_sum_fields,
(int) allow_distinct_limit,test(group)));
(ulong) rows_limit,test(group)));
statistic_increment(created_tmp_tables, &LOCK_status);
@ -4286,13 +4281,8 @@ create_tmp_table(THD *thd,TMP_TABLE_PARAM *param,List<Item> &fields,
null_pack_length-=hidden_null_pack_length;
keyinfo->key_parts= ((field_count-param->hidden_field_count)+
test(null_pack_length));
if (allow_distinct_limit)
{
set_if_smaller(table->max_rows, unit->select_limit_cnt);
param->end_write_records= unit->select_limit_cnt;
}
else
param->end_write_records= HA_POS_ERROR;
set_if_smaller(table->max_rows, rows_limit);
param->end_write_records= rows_limit;
table->distinct=1;
table->keys=1;
if (blob_count)
@ -5679,7 +5669,7 @@ end_write_group(JOIN *join, JOIN_TAB *join_tab __attribute__((unused)),
{
if ((error=table->file->write_row(table->record[0])))
{
if (create_myisam_from_heap(join.thd, table,
if (create_myisam_from_heap(join->thd, table,
&join->tmp_table_param,
error, 0))
DBUG_RETURN(-1); // Not a table_is_full error
@ -6060,12 +6050,32 @@ test_if_skip_sort_order(JOIN_TAB *tab,ORDER *order,ha_rows select_limit,
}
/*****************************************************************************
/*
If not selecting by given key, create an index how records should be read
return: 0 ok
-1 some fatal error
1 no records
*****************************************************************************/
SYNOPSIS
create_sort_index()
thd Thread handler
tab Table to sort (in join structure)
order How table should be sorted
filesort_limit Max number of rows that needs to be sorted
select_limit Max number of rows in final output
Used to decide if we should use index or not
IMPLEMENTATION
- If there is an index that can be used, 'tab' is modified to use
this index.
- If no index, create with filesort() an index file that can be used to
retrieve rows in order (should be done with 'read_record').
The sorted data is stored in tab->table and will be freed when calling
free_io_cache(tab->table).
RETURN VALUES
0 ok
-1 Some fatal error
1 No records
*/
static int
create_sort_index(THD *thd, JOIN_TAB *tab, ORDER *order,