BUG#19914 SELECT COUNT(*) sometimes returns MAX_INT on cluster tables

stewart@willster.(none) · stewart@willster.(none) · commit 9d2e6b8d23eb · 2006-08-10T22:55:20.000+08:00
allow handler::info to return an error code (that will be returned to the user)
diff --git a/sql/examples/ha_archive.cc b/sql/examples/ha_archive.cc
@@ -972,15 +972,15 @@ int ha_archive::index_last(byte * buf)
 }
 
 
-void ha_archive::info(uint flag)
+int ha_archive::info(uint flag)
 {
   DBUG_ENTER("ha_archive::info");
 
   /* This is a lie, but you don't want the optimizer to see zero or 1 */
   records= share->rows_recorded;
   deleted= 0;
 
-  DBUG_VOID_RETURN;
+  DBUG_RETURN(0);
 }
 
 int ha_archive::extra(enum ha_extra_function operation)
diff --git a/sql/examples/ha_archive.h b/sql/examples/ha_archive.h
@@ -116,7 +116,7 @@ class ha_archive: public handler
   int read_data_header(gzFile file_to_read);
   int write_data_header(gzFile file_to_write);
   void position(const byte *record);
-  void info(uint);
+  int info(uint);
   int extra(enum ha_extra_function operation);
   int reset(void);
   int external_lock(THD *thd, int lock_type);
diff --git a/sql/examples/ha_example.cc b/sql/examples/ha_example.cc
@@ -486,10 +486,10 @@ int ha_example::rnd_pos(byte * buf, byte *pos)
     sql_update.cc
 
 */
-void ha_example::info(uint flag)
+int ha_example::info(uint flag)
 {
   DBUG_ENTER("ha_example::info");
-  DBUG_VOID_RETURN;
+  DBUG_RETURN(0);
 }
 
 
diff --git a/sql/examples/ha_example.h b/sql/examples/ha_example.h
@@ -138,7 +138,7 @@ class ha_example: public handler
   int rnd_next(byte *buf);                                      //required
   int rnd_pos(byte * buf, byte *pos);                           //required
   void position(const byte *record);                            //required
-  void info(uint);                                              //required
+  int info(uint);                                              //required
 
   int extra(enum ha_extra_function operation);
   int reset(void);
diff --git a/sql/examples/ha_tina.cc b/sql/examples/ha_tina.cc
@@ -683,13 +683,13 @@ int ha_tina::rnd_pos(byte * buf, byte *pos)
   Currently this table handler doesn't implement most of the fields
   really needed. SHOW also makes use of this data
 */
-void ha_tina::info(uint flag)
+int ha_tina::info(uint flag)
 {
   DBUG_ENTER("ha_tina::info");
   /* This is a lie, but you don't want the optimizer to see zero or 1 */
   if (records < 2) 
     records= 2;
-  DBUG_VOID_RETURN;
+  DBUG_RETURN(0);
 }
 
 /*
diff --git a/sql/examples/ha_tina.h b/sql/examples/ha_tina.h
@@ -115,7 +115,7 @@ class ha_tina: public handler
   int rnd_pos(byte * buf, byte *pos);
   int rnd_end();
   void position(const byte *record);
-  void info(uint);
+  int info(uint);
   int extra(enum ha_extra_function operation);
   int reset(void);
   int external_lock(THD *thd, int lock_type);
diff --git a/sql/ha_berkeley.cc b/sql/ha_berkeley.cc
@@ -1715,7 +1715,7 @@ void ha_berkeley::position(const byte *record)
 }
 
 
-void ha_berkeley::info(uint flag)
+int ha_berkeley::info(uint flag)
 {
   DBUG_ENTER("ha_berkeley::info");
   if (flag & HA_STATUS_VARIABLE)
@@ -1735,7 +1735,7 @@ void ha_berkeley::info(uint flag)
   /* Don't return key if we got an error for the internal primary key */
   if (flag & HA_STATUS_ERRKEY && last_dup_key < table->keys)
     errkey= last_dup_key;
-  DBUG_VOID_RETURN;
+  DBUG_RETURN(0);
 }
 
 
diff --git a/sql/ha_berkeley.h b/sql/ha_berkeley.h
@@ -127,7 +127,7 @@ class ha_berkeley: public handler
   int rnd_next(byte *buf);
   int rnd_pos(byte * buf, byte *pos);
   void position(const byte *record);
-  void info(uint);
+  int info(uint);
   int extra(enum ha_extra_function operation);
   int reset(void);
   int external_lock(THD *thd, int lock_type);
diff --git a/sql/ha_heap.cc b/sql/ha_heap.cc
@@ -282,7 +282,7 @@ void ha_heap::position(const byte *record)
   *(HEAP_PTR*) ref= heap_position(file);	// Ref is aligned
 }
 
-void ha_heap::info(uint flag)
+int ha_heap::info(uint flag)
 {
   HEAPINFO info;
   (void) heap_info(file,&info,flag);
@@ -304,6 +304,7 @@ void ha_heap::info(uint flag)
   */
   if (key_stat_version != file->s->key_stat_version)
     update_key_stats();
+  return 0;
 }
 
 int ha_heap::extra(enum ha_extra_function operation)
diff --git a/sql/ha_heap.h b/sql/ha_heap.h
@@ -80,7 +80,7 @@ class ha_heap: public handler
   int rnd_next(byte *buf);
   int rnd_pos(byte * buf, byte *pos);
   void position(const byte *record);
-  void info(uint);
+  int info(uint);
   int extra(enum ha_extra_function operation);
   int external_lock(THD *thd, int lock_type);
   int delete_all_rows(void);
diff --git a/sql/ha_innodb.cc b/sql/ha_innodb.cc
@@ -4570,7 +4570,7 @@ ha_innobase::read_time(
 Returns statistics information of the table to the MySQL interpreter,
 in various fields of the handle object. */
 
-void
+int
 ha_innobase::info(
 /*==============*/
 	uint flag)	/* in: what information MySQL requests */
@@ -4593,7 +4593,7 @@ ha_innobase::info(
 
         if (srv_force_recovery >= SRV_FORCE_NO_IBUF_MERGE) {
 
-                DBUG_VOID_RETURN;
+                DBUG_RETURN(HA_ERR_CRASHED);
         }
 
 	/* We do not know if MySQL can call this function before calling
@@ -4758,7 +4758,7 @@ ha_innobase::info(
 
 	prebuilt->trx->op_info = (char*)"";
 
-  	DBUG_VOID_RETURN;
+  	DBUG_RETURN(0);
 }
 
 /**************************************************************************
diff --git a/sql/ha_innodb.h b/sql/ha_innodb.h
@@ -142,7 +142,7 @@ class ha_innobase: public handler
   	int rnd_pos(byte * buf, byte *pos);
 
   	void position(const byte *record);
-  	void info(uint);
+  	int info(uint);
         int analyze(THD* thd,HA_CHECK_OPT* check_opt);
         int optimize(THD* thd,HA_CHECK_OPT* check_opt);
 	int discard_or_import_tablespace(my_bool discard);
diff --git a/sql/ha_myisam.cc b/sql/ha_myisam.cc
@@ -1214,7 +1214,7 @@ void ha_myisam::position(const byte* record)
   ha_store_ptr(ref, ref_length, position);
 }
 
-void ha_myisam::info(uint flag)
+int ha_myisam::info(uint flag)
 {
   MI_ISAMINFO info;
   char name_buff[FN_REFLEN];
@@ -1273,6 +1273,8 @@ void ha_myisam::info(uint flag)
     update_time = info.update_time;
   if (flag & HA_STATUS_AUTO)
     auto_increment_value= info.auto_increment;
+
+  return 0;
 }
 
 
diff --git a/sql/ha_myisam.h b/sql/ha_myisam.h
@@ -100,7 +100,7 @@ class ha_myisam: public handler
   int rnd_pos(byte * buf, byte *pos);
   int restart_rnd_next(byte *buf, byte *pos);
   void position(const byte *record);
-  void info(uint);
+  int info(uint);
   int extra(enum ha_extra_function operation);
   int extra_opt(enum ha_extra_function operation, ulong cache_size);
   int external_lock(THD *thd, int lock_type);
diff --git a/sql/ha_myisammrg.cc b/sql/ha_myisammrg.cc
@@ -218,7 +218,7 @@ ha_rows ha_myisammrg::records_in_range(uint inx, key_range *min_key,
 }
 
 
-void ha_myisammrg::info(uint flag)
+int ha_myisammrg::info(uint flag)
 {
   MYMERGE_INFO info;
   (void) myrg_status(file,&info,flag);
@@ -253,6 +253,7 @@ void ha_myisammrg::info(uint flag)
 	     (char*) info.rec_per_key,
 	     sizeof(table->key_info[0].rec_per_key)*table->key_parts);
   }
+  return 0;
 }
 
 
diff --git a/sql/ha_myisammrg.h b/sql/ha_myisammrg.h
@@ -71,7 +71,7 @@ class ha_myisammrg: public handler
   int rnd_pos(byte * buf, byte *pos);
   void position(const byte *record);
   ha_rows records_in_range(uint inx, key_range *min_key, key_range *max_key);
-  void info(uint);
+  int info(uint);
   int extra(enum ha_extra_function operation);
   int extra_opt(enum ha_extra_function operation, ulong cache_size);
   int external_lock(THD *thd, int lock_type);
diff --git a/sql/ha_ndbcluster.cc b/sql/ha_ndbcluster.cc
@@ -256,11 +256,13 @@ void ha_ndbcluster::set_rec_per_key()
   DBUG_VOID_RETURN;
 }
 
-void ha_ndbcluster::records_update()
+int ha_ndbcluster::records_update()
 {
   if (m_ha_not_exact_count)
-    return;
+    return 0;
   DBUG_ENTER("ha_ndbcluster::records_update");
+  int result= 0;
+
   struct Ndb_local_table_statistics *info= 
     (struct Ndb_local_table_statistics *)m_table_info;
   DBUG_PRINT("info", ("id=%d, no_uncommitted_rows_count=%d",
@@ -271,7 +273,7 @@ void ha_ndbcluster::records_update()
     Ndb *ndb= get_ndb();
     Uint64 rows;
     ndb->setDatabaseName(m_dbname);
-    if(ndb_get_table_statistics(ndb, m_tabname, &rows, 0) == 0){
+    if((result= ndb_get_table_statistics(ndb, m_tabname, &rows, 0)) == 0){
       info->records= rows;
     }
   }
@@ -281,7 +283,7 @@ void ha_ndbcluster::records_update()
       info->no_uncommitted_rows_count= 0;
   }
   records= info->records+ info->no_uncommitted_rows_count;
-  DBUG_VOID_RETURN;
+  DBUG_RETURN(result);
 }
 
 void ha_ndbcluster::no_uncommitted_rows_execute_failure()
@@ -2858,8 +2860,9 @@ void ha_ndbcluster::position(const byte *record)
 }
 
 
-void ha_ndbcluster::info(uint flag)
+int ha_ndbcluster::info(uint flag)
 {
+  int result= 0;
   DBUG_ENTER("info");
   DBUG_PRINT("enter", ("flag: %d", flag));
   
@@ -2877,17 +2880,17 @@ void ha_ndbcluster::info(uint flag)
       if (m_ha_not_exact_count)
 	records= 100;
       else
-	records_update();
+	result= records_update();
     }
     else
     {
       if ((my_errno= check_ndb_connection()))
-        DBUG_VOID_RETURN;
+        DBUG_RETURN(my_errno);
       Ndb *ndb= get_ndb();
       Uint64 rows= 100;
       ndb->setDatabaseName(m_dbname);
       if (current_thd->variables.ndb_use_exact_count)
-	ndb_get_table_statistics(ndb, m_tabname, &rows, 0);
+	result= ndb_get_table_statistics(ndb, m_tabname, &rows, 0);
       records= rows;
     }
   }
@@ -2912,7 +2915,11 @@ void ha_ndbcluster::info(uint flag)
         ndb->readAutoIncrementValue((const NDBTAB *) m_table);
     }
   }
-  DBUG_VOID_RETURN;
+
+  if(result == -1)
+    result= HA_ERR_NO_CONNECTION;
+
+  DBUG_RETURN(result);
 }
 
 
diff --git a/sql/ha_ndbcluster.h b/sql/ha_ndbcluster.h
@@ -115,7 +115,7 @@ class ha_ndbcluster: public handler
   int read_range_next();
 
   bool get_error_message(int error, String *buf);
-  void info(uint);
+  int info(uint);
   int extra(enum ha_extra_function operation);
   int extra_opt(enum ha_extra_function operation, ulong cache_size);
   int reset();
@@ -256,7 +256,7 @@ class ha_ndbcluster: public handler
 
   Ndb *get_ndb();
   void set_rec_per_key();
-  void records_update();
+  int records_update();
   void no_uncommitted_rows_execute_failure();
   void no_uncommitted_rows_update(int);
   void no_uncommitted_rows_init(THD *);
diff --git a/sql/handler.h b/sql/handler.h
@@ -394,7 +394,7 @@ class handler :public Sql_alloc
                                    key_range *max_key)
     { return (ha_rows) 10; }
   virtual void position(const byte *record)=0;
-  virtual void info(uint)=0;
+  virtual int info(uint)=0;
   virtual int extra(enum ha_extra_function operation)
   { return 0; }
   virtual int extra_opt(enum ha_extra_function operation, ulong cache_size)
diff --git a/sql/opt_sum.cc b/sql/opt_sum.cc
@@ -125,7 +125,12 @@ int opt_sum_query(TABLE_LIST *tables, List<Item> &all_fields,COND *conds)
     }
     else
     {
-      tl->table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
+      error= tl->table->file->info(HA_STATUS_VARIABLE | HA_STATUS_NO_LOCK);
+      if(error)
+      {
+        tl->table->file->print_error(error, MYF(0));
+        return error;
+      }
       count*= tl->table->file->records;
     }
   }
diff --git a/sql/sql_select.cc b/sql/sql_select.cc
@@ -537,6 +537,8 @@ JOIN::optimize()
     {
       if (res > 1)
       {
+        thd->fatal_error();
+        error= res;
 	DBUG_RETURN(1);
       }
       if (res < 0)

Original file line number	Diff line number	Diff line change
`@@ -972,15 +972,15 @@ int ha_archive::index_last(byte * buf)`
`972`	`972`	`}`
`973`	`973`
`974`	`974`
`975`		`-void ha_archive::info(uint flag)`
	`975`	`+int ha_archive::info(uint flag)`
`976`	`976`	`{`
`977`	`977`	`DBUG_ENTER("ha_archive::info");`
`978`	`978`
`979`	`979`	`/* This is a lie, but you don't want the optimizer to see zero or 1 */`
`980`	`980`	`records= share->rows_recorded;`
`981`	`981`	`deleted= 0;`
`982`	`982`
`983`		`- DBUG_VOID_RETURN;`
	`983`	`+ DBUG_RETURN(0);`
`984`	`984`	`}`
`985`	`985`
`986`	`986`	`int ha_archive::extra(enum ha_extra_function operation)`
Original file line number	Diff line number	Diff line change
`@@ -486,10 +486,10 @@ int ha_example::rnd_pos(byte * buf, byte *pos)`
`486`	`486`	`sql_update.cc`
`487`	`487`
`488`	`488`	`*/`
`489`		`-void ha_example::info(uint flag)`
	`489`	`+int ha_example::info(uint flag)`
`490`	`490`	`{`
`491`	`491`	`DBUG_ENTER("ha_example::info");`
`492`		`- DBUG_VOID_RETURN;`
	`492`	`+ DBUG_RETURN(0);`
`493`	`493`	`}`
`494`	`494`
`495`	`495`
Original file line number	Diff line number	Diff line change
`@@ -1715,7 +1715,7 @@ void ha_berkeley::position(const byte *record)`
`1715`	`1715`	`}`
`1716`	`1716`
`1717`	`1717`
`1718`		`-void ha_berkeley::info(uint flag)`
	`1718`	`+int ha_berkeley::info(uint flag)`
`1719`	`1719`	`{`
`1720`	`1720`	`DBUG_ENTER("ha_berkeley::info");`
`1721`	`1721`	`if (flag & HA_STATUS_VARIABLE)`
`@@ -1735,7 +1735,7 @@ void ha_berkeley::info(uint flag)`
`1735`	`1735`	`/* Don't return key if we got an error for the internal primary key */`
`1736`	`1736`	`if (flag & HA_STATUS_ERRKEY && last_dup_key < table->keys)`
`1737`	`1737`	`errkey= last_dup_key;`
`1738`		`- DBUG_VOID_RETURN;`
	`1738`	`+ DBUG_RETURN(0);`
`1739`	`1739`	`}`
`1740`	`1740`
`1741`	`1741`
Original file line number	Diff line number	Diff line change
`@@ -282,7 +282,7 @@ void ha_heap::position(const byte *record)`
`282`	`282`	`(HEAP_PTR) ref= heap_position(file); // Ref is aligned`
`283`	`283`	`}`
`284`	`284`
`285`		`-void ha_heap::info(uint flag)`
	`285`	`+int ha_heap::info(uint flag)`
`286`	`286`	`{`
`287`	`287`	`HEAPINFO info;`
`288`	`288`	`(void) heap_info(file,&info,flag);`
`@@ -304,6 +304,7 @@ void ha_heap::info(uint flag)`
`304`	`304`	`*/`
`305`	`305`	`if (key_stat_version != file->s->key_stat_version)`
`306`	`306`	`update_key_stats();`
	`307`	`+ return 0;`
`307`	`308`	`}`
`308`	`309`
`309`	`310`	`int ha_heap::extra(enum ha_extra_function operation)`