From 35ff08c2af7c6fd61d28e7da35ee5c3b6d26c06d Mon Sep 17 00:00:00 2001 From: "monty@mashka.mysql.fi" <> Date: Fri, 6 Dec 2002 21:11:27 +0200 Subject: After merge fixes Added THD to add_to_xxx_list() functions for faster parsing. --- sql/sql_select.cc | 132 +++++++++++++++++++++++++++++------------------------- 1 file changed, 71 insertions(+), 61 deletions(-) (limited to 'sql/sql_select.cc') diff --git a/sql/sql_select.cc b/sql/sql_select.cc index a5c69763863..3437ae875b9 100644 --- a/sql/sql_select.cc +++ b/sql/sql_select.cc @@ -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 &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 &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 &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 &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 &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, -- cgit v1.2.1