opt_trace.h

Go to the documentation of this file.

/* Copyright (c) 2011, 2012, Oracle and/or its affiliates. All rights reserved.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; version 2 of the License.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301  USA  */

#ifndef OPT_TRACE_INCLUDED
#define OPT_TRACE_INCLUDED

#include "my_config.h"  // OPTIMIZER_TRACE
#include "sql_array.h"  // Dynamic_array
#include "sql_list.h"   // because sql_cmd.h needs it
#include "sql_cmd.h"    // for enum_sql_command
#include "opt_trace_context.h" // Opt_trace_context

struct st_schema_table;
struct TABLE_LIST;
struct TABLE;
class sp_head;
class sp_printable;
class set_var_base;

#ifdef OPTIMIZER_TRACE

class Opt_trace_struct;
class Opt_trace_stmt;           // implementation detail local to opt_trace.cc


struct Opt_trace_info
{
  const char *trace_ptr;
  size_t trace_length;                          

  const char *query_ptr;
  size_t query_length;                          
  const CHARSET_INFO *query_charset;            

  size_t missing_bytes;
  bool missing_priv; 
};


class Opt_trace_iterator
{
public:
  Opt_trace_iterator(Opt_trace_context *ctx);

  void next();                           

  void get_value(Opt_trace_info *info) const;

  bool at_end() const { return cursor == NULL; }

private:
  Opt_trace_context *ctx;
  const Opt_trace_stmt *cursor; 
  long row_count;               
};


class Opt_trace_struct
{
protected:
  Opt_trace_struct(Opt_trace_context *ctx_arg, bool requires_key_arg,
                   const char *key,
                   Opt_trace_context::feature_value feature) :
    started(false)
  {
    // A first inlined test
    if (unlikely(ctx_arg->is_started()))
    {
      // Tracing enabled: must fully initialize the structure.
      do_construct(ctx_arg, requires_key_arg, key, feature);
    }
    /*
      Otherwise, just leave "started" to false, it marks that the structure is
      dummy.
    */
  }
  ~Opt_trace_struct() { if (unlikely(started)) do_destruct(); }

public:

  void end() { if (unlikely(started)) do_destruct(); }

  Opt_trace_struct& add_alnum(const char *key, const char *value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, value, strlen(value), false);
  }

  Opt_trace_struct& add_alnum(const char *value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, value, strlen(value), false);
  }

  Opt_trace_struct& add_utf8(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_utf8(const char *value, size_t val_length)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, value, val_length, true);
  }

  Opt_trace_struct& add_utf8(const char *key, const char *value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, value, strlen(value), true);
  }

  Opt_trace_struct& add_utf8(const char *value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, value, strlen(value), true);
  }

  Opt_trace_struct& add(const char *key, Item *item)
  {
    if (likely(!started))
      return *this;
    return do_add(key, item);
  }
  Opt_trace_struct& add(Item *item)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, item);
  }
public:
  Opt_trace_struct& add(const char *key, bool value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, value);
  }
  Opt_trace_struct& add(bool value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, value);
  }
  Opt_trace_struct& add(const char *key, int value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, static_cast<longlong>(value));
  }
  Opt_trace_struct& add(int value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, static_cast<longlong>(value));
  }
  Opt_trace_struct& add(const char *key, uint value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, static_cast<ulonglong>(value));
  }
  Opt_trace_struct& add(uint value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, static_cast<ulonglong>(value));
  }
  Opt_trace_struct& add(const char *key, ulong value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, static_cast<ulonglong>(value));
  }
  Opt_trace_struct& add(ulong value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, static_cast<ulonglong>(value));
  }
  Opt_trace_struct& add(const char *key, longlong value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, value);
  }
  Opt_trace_struct& add(longlong value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, value);
  }
  Opt_trace_struct& add(const char *key, ulonglong value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, value);
  }
  Opt_trace_struct& add(ulonglong value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, value);
  }
  Opt_trace_struct& add(const char *key, double value)
  {
    if (likely(!started))
      return *this;
    return do_add(key, value);
  }
  Opt_trace_struct& add(double value)
  {
    if (likely(!started))
      return *this;
    return do_add(NULL, value);
  }
  Opt_trace_struct& add_hex(const char *key, uint64 value)
  {
    if (likely(!started))
      return *this;
    return do_add_hex(key, value);
  }
  Opt_trace_struct& add_hex(uint64 value)
  {
    if (likely(!started))
      return *this;
    return do_add_hex(NULL, value);
  }
  Opt_trace_struct& add_null(const char *key)
  {
    if (likely(!started))
      return *this;
    return do_add_null(key);
  }
  Opt_trace_struct& add_utf8_table(const TABLE *tab)
  {
    if (likely(!started))
      return *this;
    return do_add_utf8_table(tab);
  }
  Opt_trace_struct& add_select_number(uint select_number)
  {
    return unlikely(select_number >= INT_MAX) ?
      // Clearer than any huge number.
      add_alnum("select#", "fake") :
      add("select#", select_number);
  }

  bool set_not_empty()
  {
    const bool old_empty= empty;
    empty= false;
    return old_empty;
  }
  const char *check_key(const char *key);

private:
  Opt_trace_struct& add(const char *key, const char* value);
  Opt_trace_struct& add(const char *key);

  void do_construct(Opt_trace_context *ctx,
                    bool requires_key, const char *key,
                    Opt_trace_context::feature_value feature);
  void do_destruct();
  Opt_trace_struct& do_add(const char *key, const char *value,
                           size_t val_length, bool escape);
  Opt_trace_struct& do_add(const char *key, Item *item);
  Opt_trace_struct& do_add(const char *key, bool value);
  Opt_trace_struct& do_add(const char *key, longlong value);
  Opt_trace_struct& do_add(const char *key, ulonglong value);
  Opt_trace_struct& do_add(const char *key, double value);
  Opt_trace_struct& do_add_hex(const char *key, uint64 value);
  Opt_trace_struct& do_add_null(const char *key);
  Opt_trace_struct& do_add_utf8_table(const TABLE *tab);

  Opt_trace_struct(const Opt_trace_struct&);            
  Opt_trace_struct& operator=(const Opt_trace_struct&); 

  bool started; 

  bool requires_key;

  bool has_disabled_I_S;
  bool empty;                                   
  Opt_trace_stmt *stmt;                        

  const char *saved_key;
#ifndef DBUG_OFF

  char previous_key[25];
#endif
};


class Opt_trace_object: public Opt_trace_struct
{
public:
  Opt_trace_object(Opt_trace_context *ctx, const char *key,
                   Opt_trace_context::feature_value feature=
                   Opt_trace_context::MISC)
    : Opt_trace_struct(ctx, true, key, feature)
  {}
  Opt_trace_object(Opt_trace_context *ctx,
                   Opt_trace_context::feature_value feature=
                   Opt_trace_context::MISC)
    : Opt_trace_struct(ctx, true, NULL, feature)
  {}
};


class Opt_trace_array: public Opt_trace_struct
{
public:
  Opt_trace_array(Opt_trace_context *ctx, const char *key,
                  Opt_trace_context::feature_value feature=
                  Opt_trace_context::MISC)
    : Opt_trace_struct(ctx, false, key, feature)
  {}
  Opt_trace_array(Opt_trace_context *ctx,
                  Opt_trace_context::feature_value feature=
                  Opt_trace_context::MISC)
    : Opt_trace_struct(ctx, false, NULL, feature)
  {}
};


class Opt_trace_disable_I_S
{
public:
  Opt_trace_disable_I_S(Opt_trace_context *ctx_arg, bool disable_arg)
  {
    if (disable_arg)
    {
      ctx= ctx_arg;
      ctx->disable_I_S_for_this_and_children();
    }
    else
      ctx= NULL;
  }

  ~Opt_trace_disable_I_S()
  {
    if (ctx != NULL)
      ctx->restore_I_S();
  }

private:
  Opt_trace_context *ctx;
  Opt_trace_disable_I_S(const Opt_trace_disable_I_S&); // not defined
  Opt_trace_disable_I_S& operator=(const Opt_trace_disable_I_S&);//not defined
};



class Opt_trace_start
{
public:
  Opt_trace_start(THD *thd_arg, TABLE_LIST *tbl,
                  enum enum_sql_command sql_command,
                  List<set_var_base> *set_vars,
                  const char *query, size_t query_length,
                  sp_printable *instr,
                  const CHARSET_INFO *query_charset);
  ~Opt_trace_start();
private:
  Opt_trace_context * const ctx;
  bool error; 
};


class st_select_lex;
void opt_trace_print_expanded_query(THD *thd,
                                    st_select_lex *select_lex,
                                    Opt_trace_object *trace_object);

void opt_trace_disable_if_no_security_context_access(THD *thd);

void opt_trace_disable_if_no_view_access(THD *thd, TABLE_LIST *view,
                                         TABLE_LIST *underlying_tables);

void opt_trace_disable_if_no_stored_proc_func_access(THD *thd, sp_head *sp);

int fill_optimizer_trace_info(THD *thd, TABLE_LIST *tables, Item *cond);


#else /* defined (OPTIMIZER_TRACE) */

/* all empty */

class Opt_trace_object
{
public:
  Opt_trace_object(Opt_trace_context *ctx, const char *key,
                   Opt_trace_context::feature_value feature=
                   Opt_trace_context::MISC)
  {}
  Opt_trace_object(Opt_trace_context *ctx,
                   Opt_trace_context::feature_value feature=
                   Opt_trace_context::MISC)
  {}
  Opt_trace_object& add_alnum(const char *key, const char *value)
  { return *this; }
  Opt_trace_object& add_utf8(const char *key,
                             const char *value, size_t val_length)
  { return *this; }
  Opt_trace_object& add_utf8(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; }
  Opt_trace_object& add(const char *key, uint value) { return *this; }
  Opt_trace_object& add(const char *key, ulong value) { return *this; }
  Opt_trace_object& add(const char *key, longlong value) { return *this; }
  Opt_trace_object& add(const char *key, ulonglong value) { return *this; }
  Opt_trace_object& add(const char *key, double value) { return *this; }
  Opt_trace_object& add_hex(const char *key, uint64 value) { return *this; }
  Opt_trace_object& add_utf8_table(const TABLE *tab) { return *this; }
  Opt_trace_object& add_select_number(uint select_number) { return *this; }
  void end() {}
};

class Opt_trace_array
{
public:
  Opt_trace_array(Opt_trace_context *ctx, const char *key,
                  Opt_trace_context::feature_value feature=
                  Opt_trace_context::MISC)
  {}
  Opt_trace_array(Opt_trace_context *ctx,
                  Opt_trace_context::feature_value feature=
                  Opt_trace_context::MISC)
  {}
  Opt_trace_array& add_alnum(const char *value) { return *this; }
  Opt_trace_array& add_utf8(const char *value, size_t val_length)
  { return *this; }
  Opt_trace_array& add_utf8(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; }
  Opt_trace_array& add(uint value) { return *this; }
  Opt_trace_array& add(longlong value) { return *this; }
  Opt_trace_array& add(ulonglong value) { return *this; }
  Opt_trace_array& add(double value) { return *this; }
  Opt_trace_array& add_hex(uint64 value) { return *this; }
  Opt_trace_array& add_utf8_table(TABLE *tab) { return *this; }
  Opt_trace_array& add_select_number(uint select_number) { return *this; }
  void end() {}
};

class Opt_trace_disable_I_S
{
public:
  Opt_trace_disable_I_S(Opt_trace_context *ctx_arg, bool disable_arg) {}
};

class Opt_trace_start
{
public:
  Opt_trace_start(THD *thd, const TABLE_LIST *tbl,
                  enum enum_sql_command sql_command,
                  List<set_var_base> *set_vars,
                  const char *query, size_t query_length,
                  sp_printable *instr,
                  const CHARSET_INFO *query_charset) {}
};

#define opt_trace_print_expanded_query(thd, select_lex, trace_object) \
  do {} while (0)
#define opt_trace_disable_if_no_view_access(thd, view, underlying_tables) \
  do {} while (0)
#define opt_trace_disable_if_no_stored_proc_func_access(thd, sp) do{} while(0)
#define opt_trace_disable_if_no_security_context_access(thd) do {} while (0)

#endif /* OPTIMIZER_TRACE */

#define OPT_TRACE_TRANSFORM(trace,object_level0,object_level1,          \
                            select_number,from,to)                      \
  Opt_trace_object object_level0(trace);                                \
  Opt_trace_object object_level1(trace, "transformation");              \
  object_level1.add_select_number(select_number);                       \
  object_level1.add_alnum("from", from).add_alnum("to", to);

/*
  A debug binary without optimizer trace compiled in, will miss some
  debugging info, be less useful, so:
*/
#if !defined(DBUG_OFF) && !defined(OPTIMIZER_TRACE)
#error debug binaries must support optimizer trace
#endif

#endif /* OPT_TRACE_INCLUDED */