From acefe2092a1e85893be2ff5459a80eddbb8f43d1 Mon Sep 17 00:00:00 2001 From: unknown Date: Mon, 9 May 2005 10:30:25 +0200 Subject: [PATCH] After review fixes --- sql/ha_ndbcluster.cc | 1 - sql/handler.h | 65 ++++++++++++++++++++++++++++++++++++++++++-- sql/sql_delete.cc | 12 ++++---- sql/sql_update.cc | 31 ++++++++++----------- 4 files changed, 83 insertions(+), 26 deletions(-) diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc index 92a8271be74..b61dbd1792c 100644 --- a/sql/ha_ndbcluster.cc +++ b/sql/ha_ndbcluster.cc @@ -4212,7 +4212,6 @@ ha_ndbcluster::ha_ndbcluster(TABLE *table_arg): m_table_info(NULL), m_table_flags(HA_REC_NOT_IN_SEQ | HA_NULL_IN_KEY | - HA_CAN_SCAN_UPDATED_INDEX | HA_AUTO_PART_KEY | HA_NO_PREFIX_CHAR_KEYS | HA_NEED_READ_RANGE_BUFFER | diff --git a/sql/handler.h b/sql/handler.h index 25b07da90a1..b5fc5503556 100644 --- a/sql/handler.h +++ b/sql/handler.h @@ -87,7 +87,6 @@ #define HA_NO_VARCHAR (1 << 27) #define HA_CAN_BIT_FIELD (1 << 28) /* supports bit fields */ #define HA_NEED_READ_RANGE_BUFFER (1 << 29) /* for read_multi_range */ -#define HA_CAN_SCAN_UPDATED_INDEX (1 << 31) /* bits in index_flags(index_number) for what you can do with index */ @@ -568,20 +567,80 @@ public: { return HA_ERR_WRONG_COMMAND; } virtual int delete_row(const byte * buf) { return HA_ERR_WRONG_COMMAND; } - virtual bool start_bulk_update() { return FALSE; } - virtual bool start_bulk_delete() { return FALSE; } + /* + SYNOPSIS + start_bulk_update() + RETURN + 0 Bulk update used by handler + 1 Bulk update not used, normal operation used + */ + virtual bool start_bulk_update() { return 1; } + /* + SYNOPSIS + start_bulk_delete() + RETURN + 0 Bulk delete used by handler + 1 Bulk delete not used, normal operation used + */ + virtual bool start_bulk_delete() { return 1; } + /* + SYNOPSIS + This method is similar to update_row, however the handler doesn't need + to execute the updates at this point in time. The handler can be certain + that another call to bulk_update_row will occur OR a call to + exec_bulk_update before the set of updates in this query is concluded. + + bulk_update_row() + old_data Old record + new_data New record + dup_key_found Number of duplicate keys found + RETURN + 0 Bulk delete used by handler + 1 Bulk delete not used, normal operation used + */ virtual int bulk_update_row(const byte *old_data, byte *new_data, uint *dup_key_found) { DBUG_ASSERT(FALSE); return HA_ERR_WRONG_COMMAND; } + /* + SYNOPSIS + After this call all outstanding updates must be performed. The number + of duplicate key errors are reported in the duplicate key parameter. + It is allowed to continue to the batched update after this call, the + handler has to wait until end_bulk_update with changing state. + + exec_bulk_update() + dup_key_found Number of duplicate keys found + RETURN + 0 Success + >0 Error code + */ virtual int exec_bulk_update(uint *dup_key_found) { DBUG_ASSERT(FALSE); return HA_ERR_WRONG_COMMAND; } + /* + SYNOPSIS + Perform any needed clean-up, no outstanding updates are there at the + moment. + + end_bulk_update() + RETURN + Nothing + */ virtual void end_bulk_update() { return; } + /* + SYNOPSIS + Execute all outstanding deletes and close down the bulk delete. + + end_bulk_delete() + RETURN + 0 Success + >0 Error code + */ virtual int end_bulk_delete() { DBUG_ASSERT(FALSE); diff --git a/sql/sql_delete.cc b/sql/sql_delete.cc index 358fee615d7..313d49797e4 100644 --- a/sql/sql_delete.cc +++ b/sql/sql_delete.cc @@ -172,7 +172,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, deleted=0L; init_ftfuncs(thd, select_lex, 1); thd->proc_info="updating"; - will_batch= table->file->start_bulk_delete(); + will_batch= !table->file->start_bulk_delete(); while (!(error=info.read_record(&info)) && !thd->killed && !thd->net.report_error) { @@ -184,7 +184,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, table->triggers->process_triggers(thd, TRG_EVENT_DELETE, TRG_ACTION_BEFORE); - if (!(error=table->file->delete_row(table->record[0]))) + if (!(error= table->file->delete_row(table->record[0]))) { deleted++; if (!--limit && using_limit) @@ -223,7 +223,7 @@ bool mysql_delete(THD *thd, TABLE_LIST *table_list, COND *conds, table->file->print_error(loc_error,MYF(0)); error=1; } - thd->proc_info="end"; + thd->proc_info= "end"; end_read_record(&info); free_io_cache(table); // Will not do any harm if (options & OPTION_QUICK) @@ -623,17 +623,17 @@ int multi_delete::do_deletes(bool from_send_error) been deleted by foreign key handling */ info.ignore_not_found_rows= 1; - will_batch= table->file->start_bulk_delete(); + will_batch= !table->file->start_bulk_delete(); while (!(local_error=info.read_record(&info)) && !thd->killed) { - if ((local_error=table->file->delete_row(table->record[0]))) + if ((local_error= table->file->delete_row(table->record[0]))) { table->file->print_error(local_error,MYF(0)); break; } deleted++; } - if (will_batch && (error=table->file->end_bulk_delete())) + if (will_batch && (error= table->file->end_bulk_delete())) { if (!local_error) { diff --git a/sql/sql_update.cc b/sql/sql_update.cc index 37ecdd2b8bd..d9f61ec4c42 100644 --- a/sql/sql_update.cc +++ b/sql/sql_update.cc @@ -262,8 +262,7 @@ int mysql_update(THD *thd, else used_key_is_modified=0; - if ((used_key_is_modified && - !(table->file->table_flags() & HA_CAN_SCAN_UPDATED_INDEX)) || order) + if (used_key_is_modified || order) { /* We can't update table directly; We must first search after all @@ -393,7 +392,7 @@ int mysql_update(THD *thd, (thd->variables.sql_mode & (MODE_STRICT_TRANS_TABLES | MODE_STRICT_ALL_TABLES))); - will_batch= table->file->start_bulk_update(); + will_batch= !table->file->start_bulk_update(); while (!(error=info.read_record(&info)) && !thd->killed) { if (!(select && select->skip_record())) @@ -450,17 +449,17 @@ int mysql_update(THD *thd, call then it should be included in the count of dup_key_found and error should be set to 0 (only if these errors are ignored). */ - error=table->file->bulk_update_row(table->record[0], - table->record[1], - &dup_key_found); + error= table->file->bulk_update_row(table->record[0], + table->record[1], + &dup_key_found); limit+= dup_key_found; - updated-=dup_key_found; + updated-= dup_key_found; } else { /* Non-batched update */ - error=table->file->update_row((byte*) table->record[1], - (byte*) table->record[0]); + error= table->file->update_row((byte*) table->record[1], + (byte*) table->record[0]); } if (!error) { @@ -501,7 +500,7 @@ int mysql_update(THD *thd, are ignored. This is a requirement on batching handlers. */ table->file->print_error(error,MYF(0)); - error=1; + error= 1; break; } /* @@ -509,8 +508,8 @@ int mysql_update(THD *thd, were duplicate keys found. In both cases we need to correct the counters and continue the loop. */ - limit=dup_key_found; //limit is 0 when we get here so need to + - updated-=dup_key_found; + limit= dup_key_found; //limit is 0 when we get here so need to + + updated-= dup_key_found; } else { @@ -523,7 +522,7 @@ int mysql_update(THD *thd, table->file->unlock_row(); thd->row_count++; } - dup_key_found=0; + dup_key_found= 0; if (thd->killed && !error) error= 1; // Aborted else if (will_batch && @@ -539,16 +538,16 @@ int mysql_update(THD *thd, { thd->fatal_error(); table->file->print_error(loc_error,MYF(0)); - error=1; + error= 1; } else - updated-=dup_key_found; + updated-= dup_key_found; if (will_batch) table->file->end_bulk_update(); end_read_record(&info); free_io_cache(table); // If ORDER BY delete select; - thd->proc_info="end"; + thd->proc_info= "end"; VOID(table->file->extra(HA_EXTRA_NO_IGNORE_DUP_KEY)); /*