Updated style after review

sql/ha_ndbcluster.cc

@@ -4834,16 +4834,16 @@ uint8 ha_ndbcluster::table_cache_type()
 }
 
 
-uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname, 
-			 Uint64* commit_count)
+uint ndb_get_commitcount(THD *thd, char *dbname, char *tabname,
+			 Uint64 *commit_count)
 {
   DBUG_ENTER("ndb_get_commitcount");
 
   if (ndb_cache_check_time > 0)
   {
-    // Use cached commit_count from share
+    /* Use cached commit_count from share */
     char name[FN_REFLEN];
-    NDB_SHARE* share;
+    NDB_SHARE *share;
     (void)strxnmov(name, FN_REFLEN,
 		   "./",dbname,"/",tabname,NullS);
     DBUG_PRINT("info", ("name: %s", name));
@@ -4861,7 +4861,7 @@ uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname,
     DBUG_RETURN(0);
   }
 
-  // Get commit_count from NDB
+  /* Get commit_count from NDB */
   Ndb *ndb;
   if (!(ndb= check_ndb_in_thd(thd)))
     DBUG_RETURN(1);
@@ -4906,16 +4906,16 @@ uint ndb_get_commitcount(THD* thd, char* dbname, char* tabname,
 */
 
 static my_bool
-ndbcluster_cache_retrieval_allowed(THD*	thd, 
-				   char* full_name, uint full_name_len, 
+ndbcluster_cache_retrieval_allowed(THD *thd,
+				   char *full_name, uint full_name_len,
 				   ulonglong *engine_data)
 {
   DBUG_ENTER("ndbcluster_cache_retrieval_allowed");
 
   Uint64 commit_count;
   bool is_autocommit= !(thd->options & (OPTION_NOT_AUTOCOMMIT | OPTION_BEGIN));
-  char* dbname= full_name;
-  char* tabname= dbname+strlen(dbname)+1;
+  char *dbname= full_name;
+  char *tabname= dbname+strlen(dbname)+1;
 
   DBUG_PRINT("enter",("dbname=%s, tabname=%s, autocommit=%d",
 		      dbname, tabname, is_autocommit));
@@ -4925,14 +4925,14 @@ ndbcluster_cache_retrieval_allowed(THD*	thd,
 
   if (ndb_get_commitcount(thd, dbname, tabname, &commit_count))
   {
-    *engine_data+= 1; // invalidate
+    *engine_data+= 1; /* invalidate */
     DBUG_RETURN(FALSE);
   }
   DBUG_PRINT("info", ("*engine_data=%llu, commit_count=%llu",
 		      *engine_data, commit_count));
   if (*engine_data != commit_count)
   {
-    *engine_data= commit_count; // invalidate
+    *engine_data= commit_count; /* invalidate */
     DBUG_PRINT("exit",("Do not use cache, commit_count has changed"));
     DBUG_RETURN(FALSE);
   }
@@ -4965,8 +4965,8 @@ ndbcluster_cache_retrieval_allowed(THD*	thd,
 */
 
 my_bool
-ha_ndbcluster::register_query_cache_table(THD* thd, 
-					  char* full_name, uint full_name_len,
+ha_ndbcluster::register_query_cache_table(THD *thd,
+					  char *full_name, uint full_name_len,
 					  qc_engine_callback *engine_callback,
 					  ulonglong *engine_data)
 {
@@ -4978,7 +4978,6 @@ ha_ndbcluster::register_query_cache_table(THD* thd,
   if (!is_autocommit)
     DBUG_RETURN(FALSE);
 
-  
   Uint64 commit_count;
   if (ndb_get_commitcount(thd, m_dbname, m_tabname, &commit_count))
   {
@@ -4992,6 +4991,7 @@ ha_ndbcluster::register_query_cache_table(THD* thd,
   DBUG_RETURN(TRUE);
 }
 
+
 /*
   Handling the shared NDB_SHARE structure that is needed to
   provide table locking.
@@ -5648,21 +5648,21 @@ ha_ndbcluster::update_table_comment(
 extern "C" pthread_handler_decl(ndb_util_thread_func,
                                 arg __attribute__((unused)))
 {
-  THD *thd; // needs to be first for thread_stack
-  int error = 0;
+  THD *thd; /* needs to be first for thread_stack */
+  int error= 0;
   struct timespec abstime;
 
   my_thread_init();
   DBUG_ENTER("ndb_util_thread");
   DBUG_PRINT("enter", ("ndb_cache_check_time: %d", ndb_cache_check_time));
 
-  thd= new THD; // note that contructor of THD uses DBUG_ !
+  thd= new THD; /* note that contructor of THD uses DBUG_ */
   THD_CHECK_SENTRY(thd);
 
   pthread_detach_this_thread();
-  ndb_util_thread = pthread_self();
+  ndb_util_thread= pthread_self();
 
-  thd->thread_stack = (char*)&thd; // remember where our stack is
+  thd->thread_stack= (char*)&thd; /* remember where our stack is */
   if (thd->store_globals())
   {
     thd->cleanup();
@@ -5685,7 +5685,7 @@ extern "C" pthread_handler_decl(ndb_util_thread_func,
                                    ndb_cache_check_time));
 
     if (abort_loop)
-      break; // Shutting down server
+      break; /* Shutting down server */
 
     if (ndb_cache_check_time == 0)
     {
@@ -5693,32 +5693,31 @@ extern "C" pthread_handler_decl(ndb_util_thread_func,
       continue;
     }
 
-    // Set new time to wake up 
+    /* Set new time to wake up */
     set_timespec(abstime, ndb_cache_check_time);
 
-    // Lock mutex and fill list with pointers to all open tables
+    /* Lock mutex and fill list with pointers to all open tables */
     NDB_SHARE *share;
     pthread_mutex_lock(&ndbcluster_mutex);
     for (uint i= 0; i < ndbcluster_open_tables.records; i++)
     {
       share= (NDB_SHARE *)hash_element(&ndbcluster_open_tables, i);
-      share->use_count++; // Make sure the table can't be closed
+      share->use_count++; /* Make sure the table can't be closed */
 
       DBUG_PRINT("ndb_util_thread",
                  ("Found open table[%d]: %s, use_count: %d",
                   i, share->table_name, share->use_count));
 
-      // Store pointer to table
+      /* Store pointer to table */
       util_open_tables.push_back(share);
     }
     pthread_mutex_unlock(&ndbcluster_mutex);
 
-    
-    // Iterate through the  open files list 
+    /* Iterate through the  open files list */
     List_iterator_fast<NDB_SHARE> it(util_open_tables);
-    while (share=it++)
+    while (share= it++)
     {
-      // Split tab- and dbname
+      /* Split tab- and dbname */
       char buf[FN_REFLEN];
       char *tabname, *db;
       uint length= dirname_length(share->table_name);
@@ -5730,10 +5729,11 @@ extern "C" pthread_handler_decl(ndb_util_thread_func,
                  ("Fetching commit count for: %s, db: %s, tab: %s",
                   share->table_name, db, tabname));
 
-      // Contact NDB to get commit count for table
+      /* Contact NDB to get commit count for table */
       g_ndb->setDatabaseName(db);
       struct Ndb_statistics stat;;
-      if(ndb_get_table_statistics(g_ndb, tabname, &stat) == 0){
+      if(ndb_get_table_statistics(g_ndb, tabname, &stat) == 0)
+      {
         DBUG_PRINT("ndb_util_thread",
                    ("Table: %s, rows: %llu, commit_count: %llu",
                     share->table_name, stat.row_count, stat.commit_count));
@@ -5744,13 +5744,13 @@ extern "C" pthread_handler_decl(ndb_util_thread_func,
         DBUG_PRINT("ndb_util_thread",
                    ("Error: Could not get commit count for table %s",
                     share->table_name));
-	share->commit_count++; // Invalidate
+        share->commit_count++; /* Invalidate */
       }
-      // Decrease the use count and possibly free share
+      /* Decrease the use count and possibly free share */
       free_share(share);
     }
 
-    // Clear the list of open tables
+    /* Clear the list of open tables */
     util_open_tables.empty();
 
   }