List:Commits« Previous MessageNext Message »
From:Guilhem Bichot Date:October 21 2010 1:03pm
Subject:bzr commit into mysql-next-mr-bugfixing branch (guilhem:3225)
View as plain text  
#At file:///home/mysql_src/bzrrepos_new/mysql-next-mr-opt-backporting-wl4800/ based on revid:guilhem@stripped

 3225 Guilhem Bichot	2010-10-21
      String-related variants of Opt_trace_struct::add() are renamed to add_str().

    modified:
      sql/opt_trace.cc
      sql/opt_trace.h
      sql/opt_trace2server.cc
      sql/sql_select.cc
      sql/sql_test.cc
      sql/sql_view.cc
      unittest/gunit/opt_trace-t.cc
=== modified file 'sql/opt_trace.cc'
--- a/sql/opt_trace.cc	2010-10-19 12:56:36 +0000
+++ b/sql/opt_trace.cc	2010-10-21 13:03:30 +0000
@@ -85,9 +85,9 @@ void Opt_trace_struct::do_construct(Opt_
     if (stmt->current_struct != NULL)
     {
       if (key != NULL)
-        stmt->current_struct->add(key, "...");
+        stmt->current_struct->add_str(key, "...");
       else
-        stmt->current_struct->add("...");
+        stmt->current_struct->add_str("...");
     }
     stmt->support_I_S= false; // disable tracing for this struct and children
   }

=== modified file 'sql/opt_trace.h'
--- a/sql/opt_trace.h	2010-10-09 15:04:30 +0000
+++ b/sql/opt_trace.h	2010-10-21 13:03:30 +0000
@@ -799,8 +799,19 @@ public:
      2.0 secs, but it is hoped that the used testcase (20-table plan) is
      unusually intensive on the optimizer and thus real-life cases should have
      a smaller penalty. This will be benchmarked with the QA teams.
+
+     String-related add() variants are named add_str():
+     - to avoid confusing the compiler between:
+     add(const char *value, size_t    val_length) and
+     add(const char *key,   ulonglong value)
+     - and because String::length() returns uint32 and not size_t, so for
+     add(str.ptr(), str.length())
+     compiler may pick
+     add(const char *key,   double value) instead of
+     add(const char *value, size_t val_length).
   */
-  Opt_trace_struct& add(const char *key, const char *value, size_t val_length)
+  Opt_trace_struct& add_str(const char *key,
+                            const char *value, size_t val_length)
   {
     if (likely(!started))
       return *this;
@@ -813,13 +824,14 @@ public:
      @param  value       value, in UTF8
      @param  val_length  length of string 'value'
   */
-  Opt_trace_struct& add_escaped(const char *key, const char *value, size_t val_length)
+  Opt_trace_struct& add_str_escaped(const char *key,
+                                    const char *value, size_t val_length)
   {
     if (likely(!started))
       return *this;
     return do_add(key, value, val_length, true);
   }
-  Opt_trace_struct& add(const char *key, const char *value)
+  Opt_trace_struct& add_str(const char *key, const char *value)
   {
     if (likely(!started))
       return *this;
@@ -831,13 +843,13 @@ public:
      @param  value  value, in ASCII
      @return a reference to the structure
   */
-  Opt_trace_struct& add(const char *value, size_t val_length)
+  Opt_trace_struct& add_str(const char *value, size_t val_length)
   {
     if (likely(!started))
       return *this;
     return do_add(NULL, value, val_length, false);
   }
-  Opt_trace_struct& add(const char *value)
+  Opt_trace_struct& add_str(const char *value)
   {
     if (likely(!started))
       return *this;
@@ -1299,9 +1311,11 @@ public:
   Opt_trace_object(Opt_trace_context *ctx,
                    Opt_trace_context::feature_value feature=
                    Opt_trace_context::MISC) {}
-  Opt_trace_object& add(const char *key, const char *value, size_t val_length)
+  Opt_trace_object& add_str(const char *key,
+                            const char *value, size_t val_length)
+  { return *this; }
+  Opt_trace_object& add_str(const char *key, const char *value)
   { return *this; }
-  Opt_trace_object& add(const char *key, const char *value) { return *this; }
   Opt_trace_object& add(const char *key, Item *item) { return *this; }
   Opt_trace_object& add(const char *key, bool value) { return *this; }
   Opt_trace_object& add(const char *key, int value) { return *this; }
@@ -1320,9 +1334,9 @@ public:
   Opt_trace_array(Opt_trace_context *ctx,
                   Opt_trace_context::feature_value feature=
                   Opt_trace_context::MISC) {}
-  Opt_trace_array& add(const char *value, size_t val_length)
+  Opt_trace_array& add_str(const char *value, size_t val_length)
   { return *this; }
-  Opt_trace_array& add(const char *value) { return *this; }
+  Opt_trace_array& add_str(const char *value) { return *this; }
   Opt_trace_array& add(Item *item) { return *this; }
   Opt_trace_array& add(bool value) { return *this; }
   Opt_trace_array& add(int value) { return *this; }
@@ -1371,7 +1385,7 @@ public:
     Opt_trace_object object_level0(trace);                              \
     Opt_trace_object object_level1(trace, "transformation");            \
     opt_trace_add_select_number(&object_level1, select_number);         \
-    object_level1.add("from", from).add("to", to);
+    object_level1.add_str("from", from).add_str("to", to);
 
 #if !defined(DBUG_OFF) && !defined(OPTIMIZER_TRACE)
 

=== modified file 'sql/opt_trace2server.cc'
--- a/sql/opt_trace2server.cc	2010-10-09 15:04:30 +0000
+++ b/sql/opt_trace2server.cc	2010-10-21 13:03:30 +0000
@@ -142,8 +142,8 @@ void opt_trace_print_expanded_query(THD 
   */
   thd->lex->unit.print(&str, enum_query_type(QT_EXPAND_VIEW_DEFINITION |
                                              QT_SHOW_SELECT_NUMBER));
-  Opt_trace_object(trace).add_escaped("expanded_query",
-                                      str.ptr(), str.length());
+  Opt_trace_object(trace).add_str_escaped("expanded_query",
+                                          str.ptr(), str.length());
 }
 
 
@@ -153,7 +153,7 @@ void opt_trace_add_select_number(Opt_tra
   if (unlikely(select_number >= INT_MAX))
   {
     /* clearer than any huge number */
-    s->add("select#", "fake");
+    s->add_str("select#", "fake");
   }
   else
     s->add("select#", select_number);

=== modified file 'sql/sql_select.cc'
--- a/sql/sql_select.cc	2010-10-20 13:00:27 +0000
+++ b/sql/sql_select.cc	2010-10-21 13:03:30 +0000
@@ -987,7 +987,7 @@ bool resolve_subquery(THD *thd, JOIN *jo
                         "IN (SELECT)", "materialization");
       oto1.add("chosen", choice == 2);
       if (types_problem)
-        oto1.add("cause", "field types");
+        oto1.add_str("cause", "field types");
     }
   }
 
@@ -1815,7 +1815,7 @@ JOIN::optimize()
   if (zero_result_cause != NULL)
   {
     Opt_trace_object oto2(trace, "empty_result");
-    oto2.add("cause", zero_result_cause);
+    oto2.add_str("cause", zero_result_cause);
     /*
       Even with zero matching rows, subqueries in the HAVING clause may
       need to be evaluated if there are aggregate functions in the
@@ -4130,7 +4130,7 @@ skip_conversion:
                         (*subq)->get_select_lex()->select_number,
                         "IN (SELECT)", "semijoin");
       if (outer_join_objection)
-        oto1.add("cause", "outer_join");
+        oto1.add_str("cause", "outer_join");
       oto1.add("chosen", false);
     }
     JOIN *child_join= (*subq)->unit->first_select()->join;
@@ -4362,7 +4362,7 @@ int pull_out_semijoin_tables(JOIN *join)
         if (tbl->table->map & join->const_table_map)
         {
           pulled_tables |= tbl->table->map;
-          Opt_trace_object(trace).add("table", tbl->table->alias).
+          Opt_trace_object(trace).add_str("table", tbl->table->alias).
             add("constant", true);
         }
       }
@@ -4388,7 +4388,7 @@ int pull_out_semijoin_tables(JOIN *join)
           {
             pulled_a_table= TRUE;
             pulled_tables |= tbl->table->map;
-            Opt_trace_object(trace).add("table", tbl->table->alias).
+            Opt_trace_object(trace).add_str("table", tbl->table->alias).
               add("functionally_dependent", true);
             /*
               Pulling a table out of uncorrelated subquery in general makes
@@ -4954,7 +4954,7 @@ make_join_statistics(JOIN *join, TABLE_L
           continue;
         }
         Opt_trace_object trace_one_table(trace);
-        trace_one_table.add("table", s->table->alias);
+        trace_one_table.add_str("table", s->table->alias);
         /* Approximate found rows and time to read them */
         s->found_records= s->records= s->table->file->stats.records;
         s->read_time= (ha_rows) s->table->file->scan_time();
@@ -4987,7 +4987,7 @@ make_join_statistics(JOIN *join, TABLE_L
         {
 #ifdef NO_OPT_TRACE_FOR_RANGE_OPT
           Opt_trace_object(join->thd->opt_trace, "more_range_optimizer_trace").
-            add("TODO?", "yes!");
+            add_str("TODO?", "yes!");
 #endif
           ha_rows records;
           SQL_SELECT *select;
@@ -6975,8 +6975,8 @@ best_access_path(JOIN      *join,
       DBUG_PRINT("info", ("Considering ref access on key %s",
                           keyuse->table->key_info[keyuse->key].name));
       Opt_trace_object trace_index_path(trace);
-      trace_index_path.add("access_type", "index").
-        add("index", keyinfo->name);
+      trace_index_path.add_str("access_type", "index").
+        add_str("index", keyinfo->name);
 
       /* 
          True if we find some keys from the range optimizer that match more
@@ -7332,7 +7332,7 @@ best_access_path(JOIN      *join,
   }
 
   Opt_trace_object trace_scan_path(trace);
-  trace_scan_path.add("access_type", "table scan");
+  trace_scan_path.add_str("access_type", "table scan");
   /*
     Don't test table scan if it can't be better.
     Prefer key lookup if we would use the same key for scanning.
@@ -8262,7 +8262,7 @@ best_extension_by_limited_search(JOIN   
       double current_record_count, current_read_time;
       POSITION *position= join->positions + idx;
       Opt_trace_object trace_one_table(trace);
-      trace_one_table.add("table", s->table->alias);
+      trace_one_table.add_str("table", s->table->alias);
 
       /* Find the best access method from 's' to the current partial plan */
       POSITION loose_scan_pos;
@@ -8683,8 +8683,8 @@ static bool fix_semijoin_strategies_for_
         Opt_trace_object oto0(trace);
         Opt_trace_object oto1(trace,
                               "reconsidering_access_paths_for_semijoin");
-        oto1.add("strategy", "MaterializationScan").
-          add("table", join->best_positions[i].table->table->alias);
+        oto1.add_str("strategy", "MaterializationScan").
+          add_str("table", join->best_positions[i].table->table->alias);
         best_access_path(join, join->best_positions[i].table, rem_tables, i, FALSE,
                          prefix_rec_count, join->best_positions + i, &dummy);
         prefix_rec_count *= join->best_positions[i].records_read;
@@ -8720,8 +8720,8 @@ static bool fix_semijoin_strategies_for_
           Opt_trace_object oto0(trace);
           Opt_trace_object oto1(trace,
                                 "reconsidering_access_paths_for_semijoin");
-          oto1.add("strategy", "FirstMatch").
-            add("table", join->best_positions[idx].table->table->alias);
+          oto1.add_str("strategy", "FirstMatch").
+            add_str("table", join->best_positions[idx].table->table->alias);
           best_access_path(join, join->best_positions[idx].table, 
                            rem_tables, idx, TRUE /* no jbuf */,
                            record_count, join->best_positions + idx, &dummy);
@@ -8754,7 +8754,7 @@ static bool fix_semijoin_strategies_for_
           Opt_trace_object oto0(trace);
           Opt_trace_object oto1(trace,
                                 "reconsidering_access_paths_for_semijoin");
-          oto1.add("strategy", "LooseScan").
+          oto1.add_str("strategy", "LooseScan").
             add("table", join->best_positions[idx].table->table->alias);
           best_access_path(join, join->best_positions[idx].table,
                            rem_tables, idx, TRUE /* no jbuf */,
@@ -9629,7 +9629,7 @@ static bool make_join_select(JOIN *join,
     {
       tab= join->join_tab+i;
       Opt_trace_object trace_one_table(thd->opt_trace);
-      trace_one_table.add("table", tab->table->alias);
+      trace_one_table.add_str("table", tab->table->alias);
       /*
         first_inner is the X in queries like:
         SELECT * FROM t1 LEFT OUTER JOIN (t2 JOIN t3) ON X
@@ -13760,7 +13760,7 @@ void optimize_wo_join_buffering(JOIN *jo
   DBUG_ENTER("optimize_wo_join_buffering");
 
   Opt_trace_object trace_recompute(trace, "recompute_best_access_paths");
-  trace_recompute.add("cause", "join_buffering_not_possible");
+  trace_recompute.add_str("cause", "join_buffering_not_possible");
   Opt_trace_array trace_tables(trace, "tables");
 
   if (first_tab > join->const_tables)
@@ -13786,7 +13786,7 @@ void optimize_wo_join_buffering(JOIN *jo
     {
       /* Find the best access method that would not use join buffering */
       Opt_trace_object trace_one_table(trace);
-      trace_one_table.add("table", rs->table->alias);
+      trace_one_table.add_str("table", rs->table->alias);
       best_access_path(join, rs, reopt_remaining_tables, i, 
                        i < no_jbuf_before, inner_fanout * outer_fanout,
                        &pos, &loose_scan_pos);
@@ -13986,7 +13986,7 @@ void advance_sj_state(JOIN *join, table_
         double reopt_cost, reopt_rec_count;
         /* We use the same FirstLetterUpcase as in EXPLAIN */
         Opt_trace_object trace_one_strategy(trace);
-        trace_one_strategy.add("strategy", "FirstMatch");
+        trace_one_strategy.add_str("strategy", "FirstMatch");
         optimize_wo_join_buffering(join, pos->first_firstmatch_table, idx,
                                    remaining_tables, FALSE, idx,
                                    &reopt_rec_count, &reopt_cost);
@@ -14057,7 +14057,7 @@ void advance_sj_state(JOIN *join, table_
       /* Got a complete LooseScan range. Calculate its cost */
       double reopt_cost, reopt_rec_count;
       Opt_trace_object trace_one_strategy(trace);
-      trace_one_strategy.add("strategy", "LooseScan");
+      trace_one_strategy.add_str("strategy", "LooseScan");
       /*
         The same problem as with FirstMatch - we need to save POSITIONs
         somewhere but reserving space for all cases would require too
@@ -14134,8 +14134,8 @@ void advance_sj_state(JOIN *join, table_
       emb_sj_nest->sj_inner_tables | 
       emb_sj_nest->nested_join->sj_depends_on;
     pos->sjm_scan_last_inner= idx;
-    Opt_trace_object(trace).add("strategy", "MaterializationScan").
-      add("choice", "deferred");
+    Opt_trace_object(trace).add_str("strategy", "MaterializationScan").
+      add_str("choice", "deferred");
   }
   else if (sjm_strategy == SJ_OPT_MATERIALIZE_LOOKUP)
   {
@@ -14159,7 +14159,7 @@ void advance_sj_state(JOIN *join, table_
       prefix_rec_count * emb_sj_nest->nested_join->sjm.lookup_cost.total_cost();
 
     Opt_trace_object trace_one_strategy(trace);
-    trace_one_strategy.add("strategy", "MaterializationLookup").
+    trace_one_strategy.add_str("strategy", "MaterializationLookup").
       add("cost", mat_read_time).add("records", prefix_rec_count).
       add("duplicate_tables_left", pos->dups_producing_tables != 0);
     if (mat_read_time < *current_read_time || pos->dups_producing_tables)
@@ -14192,7 +14192,7 @@ void advance_sj_state(JOIN *join, table_
     int first_tab= pos->sjm_scan_last_inner + 1 - table_count;
 
     Opt_trace_object trace_one_strategy(trace);
-    trace_one_strategy.add("strategy", "MaterializationScan");
+    trace_one_strategy.add_str("strategy", "MaterializationScan");
 
     /* Get the prefix cost */
     if (first_tab == (int)join->const_tables)
@@ -14221,13 +14221,14 @@ void advance_sj_state(JOIN *join, table_
     /* Need to re-run best-access-path as we prefix_rec_count has changed */
     {
       Opt_trace_object trace_recompute(trace, "recompute_best_access_paths");
-      trace_recompute.add("cause", "costs_of_prefix_changed");
+      trace_recompute.add_str("cause", "costs_of_prefix_changed");
       Opt_trace_array trace_tables(trace, "tables");
 
       for (i= first_tab + table_count; i <= idx; i++)
       {
         Opt_trace_object trace_one_table(trace);
-        trace_one_table.add("table", join->positions[i].table->table->alias);
+        trace_one_table.add_str("table",
+                                join->positions[i].table->table->alias);
         best_access_path(join, join->positions[i].table, rem_tables, i, FALSE,
                          prefix_rec_count, &curpos, &dummy);
         prefix_rec_count *= curpos.records_read;
@@ -14354,7 +14355,7 @@ void advance_sj_state(JOIN *join, table_
         leave duplicate-producing tables not handled by any strategy.
       */
       Opt_trace_object trace_one_strategy(trace);
-      trace_one_strategy.add("strategy", "DuplicatesWeedout").
+      trace_one_strategy.add_str("strategy", "DuplicatesWeedout").
         add("cost", dups_cost).
         add("records", prefix_rec_count * sj_outer_fanout).
         add("duplicate_tables_left", pos->dups_producing_tables != 0);
@@ -14508,7 +14509,7 @@ optimize_cond(JOIN *join, Item *conds, L
   {
     Opt_trace_object trace_wrapper(trace);
     Opt_trace_object trace_cond(trace, "condition_processing");
-    trace_cond.add("condition", build_equalities ? "WHERE" : "HAVING");
+    trace_cond.add_str("condition", build_equalities ? "WHERE" : "HAVING");
     /* 
       Build all multiple equality predicates and eliminate equality
       predicates that can be inferred from these multiple equalities.
@@ -17936,7 +17937,7 @@ join_read_const_table(JOIN_TAB *tab, POS
   table->null_row=0;
   table->status=STATUS_NO_RECORD;
 
-  trace_array->add(table->alias); /// @todo add info about findings below
+  trace_array->add_str(table->alias); /// @todo add info about findings below
   if (tab->type == JT_SYSTEM)
   {
     if ((error=join_read_system(tab)))

=== modified file 'sql/sql_test.cc'
--- a/sql/sql_test.cc	2010-09-24 09:11:29 +0000
+++ b/sql/sql_test.cc	2010-10-21 13:03:30 +0000
@@ -268,7 +268,7 @@ static void print_keyuse(Opt_trace_conte
   DBUG_UNLOCK_FILE;
   //key_part_map keypart_map; --?? there can be several?
   sprintf(buff2, "%s.%s= %s", keyuse->table->alias, fieldname, str.ptr());
-  Opt_trace_object(trace).add("condition", buff2).
+  Opt_trace_object(trace).add_str_escaped("condition", buff2, strlen(buff2)).
     add("null_rejecting", keyuse->null_rejecting);
 }
 

=== modified file 'sql/sql_view.cc'
--- a/sql/sql_view.cc	2010-10-19 12:56:36 +0000
+++ b/sql/sql_view.cc	2010-10-21 13:03:30 +0000
@@ -1141,8 +1141,8 @@ bool mysql_make_view(THD *thd, File_pars
 
   Opt_trace_object trace_wrapper(thd->opt_trace);
   Opt_trace_object trace_view(thd->opt_trace, "view");
-  trace_view.add("db", table->db, table->db_length).
-    add("name", table->table_name, table->table_name_length).
+  trace_view.add_str("db", table->db, table->db_length).
+    add_str("name", table->table_name, table->table_name_length).
     add("in_select#", old_lex->select_lex.select_number);
 
   /*
@@ -1479,7 +1479,7 @@ bool mysql_make_view(THD *thd, File_pars
 
       table->effective_algorithm= VIEW_ALGORITHM_MERGE;
       DBUG_PRINT("info", ("algorithm: MERGE"));
-      trace_view.add("merged",true);
+      trace_view.add("merged", true);
       table->updatable= (table->updatable_view != 0);
       table->effective_with_check=
         old_lex->get_effective_with_check(table);
@@ -1571,7 +1571,7 @@ bool mysql_make_view(THD *thd, File_pars
 
     table->effective_algorithm= VIEW_ALGORITHM_TMPTABLE;
     DBUG_PRINT("info", ("algorithm: TEMPORARY TABLE"));
-    trace_view.add("materialized",true);
+    trace_view.add("materialized", true);
     view_select->linkage= DERIVED_TABLE_TYPE;
     table->updatable= 0;
     table->effective_with_check= VIEW_CHECK_NONE;

=== modified file 'unittest/gunit/opt_trace-t.cc'
--- a/unittest/gunit/opt_trace-t.cc	2010-10-09 15:04:30 +0000
+++ b/unittest/gunit/opt_trace-t.cc	2010-10-21 13:03:30 +0000
@@ -76,11 +76,11 @@ TEST(Trace_content_test, normal_usage)
       ota.add(200.4);
       {
         Opt_trace_object oto1(&trace);
-        oto1.add("one key", "one value").
+        oto1.add_str("one key", "one value").
           add("another key", 100U);
       }
       Opt_trace_context *trace_ptr= &trace;
-      OPT_TRACE(trace_ptr, add("one string element"));
+      OPT_TRACE(trace_ptr, add_str("one string element"));
       ota.add(true);
     }
     oto.add("yet another key", -1000LL);
@@ -137,10 +137,10 @@ TEST(Trace_content_test, tail)
       ota.add(200.4);
       {
         Opt_trace_object oto1(&trace);
-        oto1.add("one key", "one value").
+        oto1.add_str("one key", "one value").
           add("another key", 100LL);
       }
-      ota.add("one string element");
+      ota.add_str("one string element");
       ota.add(true);
     }
     oto.add("yet another key", -1000LL);
@@ -199,10 +199,10 @@ TEST(Trace_content_test, buggy_object)
       {
         Opt_trace_object oto1(&trace);
         Opt_trace_struct::dbug_assert_on_syntax_error= false;
-        oto1.add("one value"); // no key, which is wrong
+        oto1.add_str("one value"); // no key, which is wrong
         Opt_trace_struct::dbug_assert_on_syntax_error= true;
       }
-      ota.add("one string element");
+      ota.add_str("one string element");
       ota.add(true);
     }
     oto.add("yet another key", -1000LL);
@@ -301,7 +301,7 @@ TEST(Trace_content_test, disable_I_S)
       ota.add(200.4);
       {
         Opt_trace_object oto1(&trace);
-        oto1.add("one key", "one value").
+        oto1.add_str("one key", "one value").
           add("another key", 100LL);
         Opt_trace_disable_I_S otd(&trace, true);
         oto1.add("a third key", false);
@@ -313,7 +313,7 @@ TEST(Trace_content_test, disable_I_S)
         oto2.add("another key inside", 5LL);
       }
       Opt_trace_context *trace_ptr= &trace;
-      OPT_TRACE(trace_ptr, add("one string element"));
+      OPT_TRACE(trace_ptr, add_str("one string element"));
       ota.add(true);
     }
     Opt_trace_disable_I_S otd2(&trace, false); // don't disable
@@ -467,7 +467,7 @@ TEST(Trace_settings_test, max_mem_size)
     Opt_trace_array ota(&trace, "one array");
     for (int i= 0; i < 100; i++)
     {
-      ota.add("make it long");
+      ota.add_str("make it long");
     }
   }
   trace.end();
@@ -503,14 +503,14 @@ TEST(Trace_settings_test, max_mem_size2)
   /* make a "long" trace */
   {
     Opt_trace_object oto(&trace);
-    oto.add("some key1", "make it long");
+    oto.add_str("some key1", "make it long");
   }
   trace.end();
   /* A second similar trace */
   ASSERT_EQ(false, trace.start(true, false, false, -2, 2, 21, all_features));
   {
     Opt_trace_object oto(&trace);
-    oto.add("some key2", "make it long");
+    oto.add_str("some key2", "make it long");
   }
   trace.end();
   Opt_trace_iterator it(&trace);
@@ -534,7 +534,7 @@ TEST(Trace_settings_test, max_mem_size2)
   ASSERT_EQ(false, trace.start(true, false, false, -2, 2, 21, all_features));
   {
     Opt_trace_object oto(&trace);
-    oto.add("some key3", "make it long");
+    oto.add_str("some key3", "make it long");
   }
   trace.end();
   Opt_trace_iterator it2(&trace);
@@ -606,7 +606,7 @@ TEST(Trace_content_test, filtering_by_fe
       ota.add(200.4);
       {
         Opt_trace_object oto1(&trace, Opt_trace_context::GREEDY_SEARCH);
-        oto1.add("one key", "one value").
+        oto1.add_str("one key", "one value").
           add("another key", 100LL);
         Opt_trace_object oto2(&trace, "a fourth key",
                               Opt_trace_context::MISC);


Attachment: [text/bzr-bundle] bzr/guilhem@mysql.com-20101021130330-4r2mlwim44fovph2.bundle
Thread
bzr commit into mysql-next-mr-bugfixing branch (guilhem:3225) Guilhem Bichot21 Oct