Skip navigation links

Recommended Servers for MySQL

The world's most popular open source database

Contact a MySQL Representative

Login | Register

• MySQL.com
• Downloads
• Developer Zone
• Partners & Solutions
• Customer Login

• DevZone
• Documentation
• Librarian
• Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs

 

 

 

• Get Started with MySQL
• Development with MySQL
• PHP
• Perl
• Python
• Ruby
• Java/JDBC
• C#/.NET

The world's most popular open source database

Table_triggers_list Class Reference

#include <sql_trigger.h>

Inheritance diagram for Table_triggers_list:

[legend]Collaboration diagram for Table_triggers_list:

[legend]List of all members.

Public Member Functions
	Table_triggers_list (TABLE *table_arg)
	~Table_triggers_list ()
bool	create_trigger (THD *thd, TABLE_LIST *table, LEX_STRING *definer_user, LEX_STRING *definer_host)
bool	drop_trigger (THD *thd, TABLE_LIST *table)
bool	process_triggers (THD *thd, trg_event_type event, trg_action_time_type time_type, bool old_row_is_record1)
bool	get_trigger_info (THD *thd, trg_event_type event, trg_action_time_type time_type, LEX_STRING *trigger_name, LEX_STRING *trigger_stmt, ulong *sql_mode, LEX_STRING *definer)
bool	has_delete_triggers ()
bool	has_before_update_triggers ()
void	set_table (TABLE *new_table)
void	mark_fields_used (trg_event_type event)
Static Public Member Functions
static bool	check_n_load (THD *thd, const char *db, const char *table_name, TABLE *table, bool names_only)
static bool	drop_all_triggers (THD *thd, char *db, char *table_name)
static bool	change_table_name (THD *thd, const char *db, const char *old_table, const char *new_db, const char *new_table)
Public Attributes
List< LEX_STRING >	definitions_list
List< ulonglong >	definition_modes_list
List< LEX_STRING >	definers_list
Private Member Functions
bool	prepare_record1_accessors (TABLE *table)
LEX_STRING *	change_table_name_in_trignames (const char *db_name, LEX_STRING *new_table_name, LEX_STRING *stopper)
bool	change_table_name_in_triggers (THD *thd, const char *db_name, LEX_STRING *old_table_name, LEX_STRING *new_table_name)
Private Attributes
sp_head *	bodies [TRG_EVENT_MAX][TRG_ACTION_MAX]
Item_trigger_field *	trigger_fields [TRG_EVENT_MAX][TRG_ACTION_MAX]
Field **	record1_field
Field **	new_field
Field **	old_field
TABLE *	table
List< LEX_STRING >	names_list
List< LEX_STRING >	on_table_names_list
LEX_STRING	sroutines_key
GRANT_INFO	subject_table_grants [TRG_EVENT_MAX][TRG_ACTION_MAX]
Friends
class	Item_trigger_field
int	sp_cache_routines_and_add_tables_for_triggers (THD *thd, LEX *lex, TABLE_LIST *table)

---

Detailed Description

Definition at line 24 of file sql_trigger.h.

---

Constructor & Destructor Documentation

Table_triggers_list::Table_triggers_list

(

TABLE *

table_arg

)

[inline]

Definition at line 86 of file sql_trigger.h.

References bodies, bzero, subject_table_grants, and trigger_fields.

Referenced by check_n_load().

00086                                        :
00087     record1_field(0), table(table_arg)
00088   {
00089     bzero((char *)bodies, sizeof(bodies));
00090     bzero((char *)trigger_fields, sizeof(trigger_fields));
00091     bzero((char *)&subject_table_grants, sizeof(subject_table_grants));
00092   }
  ~Table_triggers_list();

Here is the caller graph for this function:

Table_triggers_list::~Table_triggers_list

(

)

Definition at line 711 of file sql_trigger.cc.

References bodies, int(), record1_field, TRG_ACTION_MAX, and TRG_EVENT_MAX.

{
  for (int i= 0; i < (int)TRG_EVENT_MAX; i++)
    for (int j= 0; j < (int)TRG_ACTION_MAX; j++)
      delete bodies[i][j];

  if (record1_field)
    for (Field **fld_ptr= record1_field; *fld_ptr; fld_ptr++)
      delete *fld_ptr;
}

Here is the call graph for this function:

---

Member Function Documentation

bool Table_triggers_list::change_table_name	(	THD *	thd,
		const char *	db,
		const char *	old_table,
		const char *	new_db,
		const char *	new_table
	)			[static]

Definition at line 1410 of file sql_trigger.cc.

References bzero, check_n_load(), DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, ER_TRG_IN_WRONG_SCHEMA, free_root(), init_alloc_root(), LOCK_open, my_error(), my_strcasecmp, MYF, safe_mutex_assert_owner, strlen(), table, table_alias_charset, and TRUE.

Referenced by mysql_alter_table(), and rename_tables().

{
  TABLE table;
  bool result= 0;
  LEX_STRING *err_trigname;
  DBUG_ENTER("change_table_name");

  bzero(&table, sizeof(table));
  init_alloc_root(&table.mem_root, 8192, 0);

  safe_mutex_assert_owner(&LOCK_open);

  DBUG_ASSERT(my_strcasecmp(table_alias_charset, db, new_db) ||
              my_strcasecmp(table_alias_charset, old_table, new_table));

  if (Table_triggers_list::check_n_load(thd, db, old_table, &table, TRUE))
  {
    result= 1;
    goto end;
  }
  if (table.triggers)
  {
    LEX_STRING old_table_name= { (char *) old_table, strlen(old_table) };
    LEX_STRING new_table_name= { (char *) new_table, strlen(new_table) };
    /*
      Since triggers should be in the same schema as their subject tables
      moving table with them between two schemas raises too many questions.
      (E.g. what should happen if in new schema we already have trigger
       with same name ?).
    */
    if (my_strcasecmp(table_alias_charset, db, new_db))
    {
      my_error(ER_TRG_IN_WRONG_SCHEMA, MYF(0));
      result= 1;
      goto end;
    }
    if (table.triggers->change_table_name_in_triggers(thd, db,
                                                      &old_table_name,
                                                      &new_table_name))
    {
      result= 1;
      goto end;
    }
    if ((err_trigname= table.triggers->change_table_name_in_trignames(
                                         db, &new_table_name, 0)))
    {
      /*
        If we were unable to update one of .TRN files properly we will
        revert all changes that we have done and report about error.
        We assume that we will be able to undo our changes without errors
        (we can't do much if there will be an error anyway).
      */
      (void) table.triggers->change_table_name_in_trignames(db,
                                                            &old_table_name,
                                                            err_trigname);
      (void) table.triggers->change_table_name_in_triggers(thd, db,
                                                           &new_table_name,
                                                           &old_table_name);
      result= 1;
      goto end;
    }
  }
end:
  delete table.triggers;
  free_root(&table.mem_root, MYF(0));
  DBUG_RETURN(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Table_triggers_list::change_table_name_in_triggers	(	THD *	thd,
		const char *	db_name,
		LEX_STRING *	old_table_name,
		LEX_STRING *	new_table_name
	)			[private]

Definition at line 1281 of file sql_trigger.cc.

References String::append(), append_identifier(), DBUG_ASSERT, definition_modes_list, definitions_list, base_list::elements, FALSE, FN_REFLEN, LEX_STRING::length, String::length(), st_table::mem_root, memdup_root(), on_table_names_list, String::ptr(), rm_trigger_file(), save_trigger_file(), LEX_STRING::str, STRING_WITH_LEN, table, and TRUE.

{
  char path_buff[FN_REFLEN];
  LEX_STRING *def, *on_table_name, new_def;
  ulonglong *sql_mode;
  ulong save_sql_mode= thd->variables.sql_mode;
  List_iterator_fast<LEX_STRING> it_def(definitions_list);
  List_iterator_fast<LEX_STRING> it_on_table_name(on_table_names_list);
  List_iterator_fast<ulonglong> it_mode(definition_modes_list);
  uint on_q_table_name_len, before_on_len;
  String buff;

  DBUG_ASSERT(definitions_list.elements == on_table_names_list.elements &&
              definitions_list.elements == definition_modes_list.elements);

  while ((def= it_def++))
  {
    on_table_name= it_on_table_name++;
    thd->variables.sql_mode= *(it_mode++);

    /* Construct CREATE TRIGGER statement with new table name. */
    buff.length(0);
    before_on_len= on_table_name->str - def->str;
    buff.append(def->str, before_on_len);
    buff.append(STRING_WITH_LEN("ON "));
    append_identifier(thd, &buff, new_table_name->str, new_table_name->length);
    buff.append(STRING_WITH_LEN(" "));
    on_q_table_name_len= buff.length() - before_on_len;
    buff.append(on_table_name->str + on_table_name->length,
                def->length - (before_on_len + on_table_name->length));
    /*
      It is OK to allocate some memory on table's MEM_ROOT since this
      table instance will be thrown out at the end of rename anyway.
    */
    new_def.str= memdup_root(&table->mem_root, buff.ptr(), buff.length());
    new_def.length= buff.length();
    on_table_name->str= new_def.str + before_on_len;
    on_table_name->length= on_q_table_name_len;
    *def= new_def;
  }

  thd->variables.sql_mode= save_sql_mode;

  if (thd->is_fatal_error)
    return TRUE; /* OOM */

  if (save_trigger_file(this, db_name, new_table_name->str))
    return TRUE;
  if (rm_trigger_file(path_buff, db_name, old_table_name->str))
  {
    (void) rm_trigger_file(path_buff, db_name, new_table_name->str);
    return TRUE;
  }
  return FALSE;
}

Here is the call graph for this function:

LEX_STRING * Table_triggers_list::change_table_name_in_trignames	(	const char *	db_name,
		LEX_STRING *	new_table_name,
		LEX_STRING *	stopper
	)			[private]

Definition at line 1359 of file sql_trigger.cc.

References build_table_filename(), FN_REFLEN, names_list, NULL, sql_create_definition_file(), LEX_STRING::str, st_trigname::trigger_table, trigname_file_ext, trigname_file_parameters, and trigname_file_type.

{
  char trigname_buff[FN_REFLEN];
  struct st_trigname trigname;
  LEX_STRING trigname_file;
  LEX_STRING *trigger;
  List_iterator_fast<LEX_STRING> it_name(names_list);

  while ((trigger= it_name++) != stopper)
  {
    trigname_file.length= build_table_filename(trigname_buff, FN_REFLEN-1,
                                               db_name, trigger->str,
                                               trigname_file_ext, 0);
    trigname_file.str= trigname_buff;

    trigname.trigger_table= *new_table_name;

    if (sql_create_definition_file(NULL, &trigname_file, &trigname_file_type,
                                   (gptr)&trigname, trigname_file_parameters,
                                   0))
      return trigger;
  }

  return 0;
}

Here is the call graph for this function:

bool Table_triggers_list::check_n_load	(	THD *	thd,
		const char *	db,
		const char *	table_name,
		TABLE *	table,
		bool	names_only
	)			[static]

Definition at line 798 of file sql_trigger.cc.

References access, alloc_root(), build_table_filename(), DBUG_ASSERT, DBUG_ENTER, DBUG_RETURN, definers_list, definition_modes_list, base_list::empty(), ER, ER_TRG_NO_DEFINER, ER_WRONG_OBJECT, F_OK, FN_REFLEN, global_system_variables, is_equal(), LEX_STRING::length, lex_end(), lex_start(), st_table::mem_root, my_error(), my_strcasecmp, MYF, NullS, parser, path, push_warning_printf(), List_iterator_fast< T >::rewind(), system_variables::sql_mode, sql_parse_prepare(), sroutines_key, LEX_STRING::str, strlen(), strxmov(), table, table_alias_charset, Table_triggers_list(), TRG_NUM_REQUIRED_PARAMETERS, st_table::triggers, triggers_file_ext, triggers_file_parameters, triggers_file_type, TYPE_ENUM_TRIGGER, and MYSQL_ERROR::WARN_LEVEL_WARN.

Referenced by change_table_name(), drop_all_triggers(), and open_unireg_entry().

{
  char path_buff[FN_REFLEN];
  LEX_STRING path;
  File_parser *parser;
  LEX_STRING save_db;

  DBUG_ENTER("Table_triggers_list::check_n_load");

  path.length= build_table_filename(path_buff, FN_REFLEN-1,
                                    db, table_name, triggers_file_ext, 0);
  path.str= path_buff;

  // QQ: should we analyze errno somehow ?
  if (access(path_buff, F_OK))
    DBUG_RETURN(0);

  /*
    File exists so we got to load triggers.
    FIXME: A lot of things to do here e.g. how about other funcs and being
    more paranoical ?
  */

  if ((parser= sql_parse_prepare(&path, &table->mem_root, 1)))
  {
    if (is_equal(&triggers_file_type, parser->type()))
    {
      Table_triggers_list *triggers=
        new (&table->mem_root) Table_triggers_list(table);
      Handle_old_incorrect_sql_modes_hook sql_modes_hook(path.str);

      if (!triggers)
        DBUG_RETURN(1);

      /*
        We don't have the following attributes in old versions of .TRG file, so
        we should initialize the list for safety:
          - sql_modes;
          - definers;
      */
      triggers->definition_modes_list.empty();
      triggers->definers_list.empty();

      if (parser->parse((gptr)triggers, &table->mem_root,
                        triggers_file_parameters,
                        TRG_NUM_REQUIRED_PARAMETERS,
                        &sql_modes_hook))
        DBUG_RETURN(1);

      List_iterator_fast<LEX_STRING> it(triggers->definitions_list);
      LEX_STRING *trg_create_str, *trg_name_str;
      ulonglong *trg_sql_mode;

      if (triggers->definition_modes_list.is_empty() &&
          !triggers->definitions_list.is_empty())
      {
        /*
          It is old file format => we should fill list of sql_modes.

          We use one mode (current) for all triggers, because we have not
          information about mode in old format.
        */
        if (!(trg_sql_mode= (ulonglong*)alloc_root(&table->mem_root,
                                                   sizeof(ulonglong))))
        {
          DBUG_RETURN(1); // EOM
        }
        *trg_sql_mode= global_system_variables.sql_mode;
        while (it++)
        {
          if (triggers->definition_modes_list.push_back(trg_sql_mode,
                                                        &table->mem_root))
          {
            DBUG_RETURN(1); // EOM
          }
        }
        it.rewind();
      }

      if (triggers->definers_list.is_empty() &&
          !triggers->definitions_list.is_empty())
      {
        /*
          It is old file format => we should fill list of definers.

          If there is no definer information, we should not switch context to
          definer when checking privileges. I.e. privileges for such triggers
          are checked for "invoker" rather than for "definer".
        */

        LEX_STRING *trg_definer;

        if (! (trg_definer= (LEX_STRING*)alloc_root(&table->mem_root,
                                                    sizeof(LEX_STRING))))
          DBUG_RETURN(1); // EOM

        trg_definer->str= (char*) "";
        trg_definer->length= 0;

        while (it++)
        {
          if (triggers->definers_list.push_back(trg_definer,
                                                &table->mem_root))
          {
            DBUG_RETURN(1); // EOM
          }
        }

        it.rewind();
      }

      DBUG_ASSERT(triggers->definition_modes_list.elements ==
                  triggers->definitions_list.elements);
      DBUG_ASSERT(triggers->definers_list.elements ==
                  triggers->definitions_list.elements);

      table->triggers= triggers;

      /*
        Construct key that will represent triggers for this table in the set
        of routines used by statement.
      */
      triggers->sroutines_key.length= 1+strlen(db)+1+strlen(table_name)+1;
      if (!(triggers->sroutines_key.str=
              alloc_root(&table->mem_root, triggers->sroutines_key.length)))
        DBUG_RETURN(1);
      triggers->sroutines_key.str[0]= TYPE_ENUM_TRIGGER;
      strxmov(triggers->sroutines_key.str+1, db, ".", table_name, NullS);

      /*
        TODO: This could be avoided if there is no triggers
              for UPDATE and DELETE.
      */
      if (!names_only && triggers->prepare_record1_accessors(table))
        DBUG_RETURN(1);

      List_iterator_fast<ulonglong> itm(triggers->definition_modes_list);
      List_iterator_fast<LEX_STRING> it_definer(triggers->definers_list);
      LEX *old_lex= thd->lex, lex;
      sp_rcontext *save_spcont= thd->spcont;
      ulong save_sql_mode= thd->variables.sql_mode;
      LEX_STRING *on_table_name;

      thd->lex= &lex;

      save_db.str= thd->db;
      save_db.length= thd->db_length;
      thd->reset_db((char*) db, strlen(db));
      while ((trg_create_str= it++))
      {
        trg_sql_mode= itm++;
        LEX_STRING *trg_definer= it_definer++;

        thd->variables.sql_mode= (ulong)*trg_sql_mode;
        lex_start(thd, (uchar*)trg_create_str->str, trg_create_str->length);

        thd->spcont= 0;
        if (MYSQLparse((void *)thd) || thd->is_fatal_error)
        {
          /*
            Free lex associated resources.
            QQ: Do we really need all this stuff here ?
          */
          delete lex.sphead;
          goto err_with_lex_cleanup;
        }

        lex.sphead->set_info(0, 0, &lex.sp_chistics, *trg_sql_mode);

        triggers->bodies[lex.trg_chistics.event]
                             [lex.trg_chistics.action_time]= lex.sphead;

        if (!trg_definer->length)
        {
          /*
            This trigger was created/imported from the previous version of
            MySQL, which does not support triggers definers. We should emit
            warning here.
          */

          push_warning_printf(thd, MYSQL_ERROR::WARN_LEVEL_WARN,
                              ER_TRG_NO_DEFINER, ER(ER_TRG_NO_DEFINER),
                              (const char*) db,
                              (const char*) lex.sphead->m_name.str);

          /*
            Set definer to the '' to correct displaying in the information
            schema.
          */

          lex.sphead->set_definer((char*) "", 0);

          /*
            Triggers without definer information are executed under the
            authorization of the invoker.
          */

          lex.sphead->m_chistics->suid= SP_IS_NOT_SUID;
        }
        else
          lex.sphead->set_definer(trg_definer->str, trg_definer->length);

        if (triggers->names_list.push_back(&lex.sphead->m_name,
                                           &table->mem_root))
            goto err_with_lex_cleanup;

        if (!(on_table_name= (LEX_STRING*) alloc_root(&table->mem_root,
                                                      sizeof(LEX_STRING))))
          goto err_with_lex_cleanup;
        *on_table_name= lex.ident;
        if (triggers->on_table_names_list.push_back(on_table_name, &table->mem_root))
          goto err_with_lex_cleanup;

        /*
          Let us check that we correctly update trigger definitions when we
          rename tables with triggers.
        */
        DBUG_ASSERT(!my_strcasecmp(table_alias_charset, lex.query_tables->db, db) &&
                    !my_strcasecmp(table_alias_charset, lex.query_tables->table_name,
                                   table_name));

        if (names_only)
        {
          lex_end(&lex);
          continue;
        }

        /*
          Gather all Item_trigger_field objects representing access to fields
          in old/new versions of row in trigger into lists containing all such
          objects for the triggers with same action and timing.
        */
        triggers->trigger_fields[lex.trg_chistics.event]
                                [lex.trg_chistics.action_time]=
          (Item_trigger_field *)(lex.trg_table_fields.first);
        /*
          Also let us bind these objects to Field objects in table being
          opened.

          We ignore errors here, because if even something is wrong we still
          will be willing to open table to perform some operations (e.g.
          SELECT)...
          Anyway some things can be checked only during trigger execution.
        */
        for (Item_trigger_field *trg_field=
               (Item_trigger_field *)(lex.trg_table_fields.first);
             trg_field;
             trg_field= trg_field->next_trg_field)
        {
          trg_field->setup_field(thd, table, 
            &triggers->subject_table_grants[lex.trg_chistics.event]
                                           [lex.trg_chistics.action_time]);
        }

        lex_end(&lex);
      }
      thd->reset_db(save_db.str, save_db.length);
      thd->lex= old_lex;
      thd->spcont= save_spcont;
      thd->variables.sql_mode= save_sql_mode;

      DBUG_RETURN(0);

err_with_lex_cleanup:
      // QQ: anything else ?
      lex_end(&lex);
      thd->lex= old_lex;
      thd->spcont= save_spcont;
      thd->variables.sql_mode= save_sql_mode;
      thd->reset_db(save_db.str, save_db.length);
      DBUG_RETURN(1);
    }

    /*
      We don't care about this error message much because .TRG files will
      be merged into .FRM anyway.
    */
    my_error(ER_WRONG_OBJECT, MYF(0),
             table_name, triggers_file_ext+1, "TRIGGER");
    DBUG_RETURN(1);
  }

  DBUG_RETURN(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Table_triggers_list::create_trigger	(	THD *	thd,
		TABLE_LIST *	table,
		LEX_STRING *	definer_user,
		LEX_STRING *	definer_host
	)

Definition at line 360 of file sql_trigger.cc.

References access, alloc_root(), bodies, build_table_filename(), check_global_access(), create_default_definer(), st_table_list::db, st_table_share::db, definers_list, definition_modes_list, definitions_list, ER, ER_NO_SUCH_USER, ER_NOT_SUPPORTED_YET, ER_SPECIFIC_ACCESS_DENIED_ERROR, ER_TRG_ALREADY_EXISTS, ER_TRG_IN_WRONG_SCHEMA, F_OK, st_table::field, Item_trigger_field::fix_fields(), Item::fixed, FN_REFLEN, is_acl_user(), LEX_STRING::length, st_table::mem_root, my_delete(), my_error(), my_strcasecmp, MY_WME, MYF, name, new_field, Item_trigger_field::next_trg_field, NULL, NullS, old_field, List< T >::push_back(), push_warning_printf(), st_table::s, Item_trigger_field::setup_field(), sql_create_definition_file(), LEX_STRING::str, strcmp(), strxmov(), SUPER_ACL, system_charset_info, st_table_list::table, table, table_alias_charset, st_table_list::table_name, st_table_list::table_name_length, st_trigname::trigger_table, triggers_file_ext, triggers_file_parameters, triggers_file_type, trigname_file_ext, trigname_file_parameters, trigname_file_type, TRUE, USER_HOST_BUFF_SIZE, and MYSQL_ERROR::WARN_LEVEL_NOTE.

Referenced by mysql_create_or_drop_trigger().

{
  LEX *lex= thd->lex;
  TABLE *table= tables->table;
  char file_buff[FN_REFLEN], trigname_buff[FN_REFLEN];
  LEX_STRING file, trigname_file;
  LEX_STRING *trg_def, *name;
  ulonglong *trg_sql_mode;
  char trg_definer_holder[USER_HOST_BUFF_SIZE];
  LEX_STRING *trg_definer;
  Item_trigger_field *trg_field;
  struct st_trigname trigname;


  /* Trigger must be in the same schema as target table. */
  if (my_strcasecmp(table_alias_charset, table->s->db.str,
                    lex->spname->m_db.str))
  {
    my_error(ER_TRG_IN_WRONG_SCHEMA, MYF(0));
    return 1;
  }

  /* We don't allow creation of several triggers of the same type yet */
  if (bodies[lex->trg_chistics.event][lex->trg_chistics.action_time])
  {
    my_error(ER_NOT_SUPPORTED_YET, MYF(0),
             "multiple triggers with the same action time"
             " and event for one table");
    return 1;
  }

  if (!lex->definer)
  {
    /*
      DEFINER-clause is missing.

      If we are in slave thread, this means that we received CREATE TRIGGER
      from the master, that does not support definer in triggers. So, we
      should mark this trigger as non-SUID. Note that this does not happen
      when we parse triggers' definitions during opening .TRG file.
      LEX::definer is ignored in that case.

      Otherwise, we should use CURRENT_USER() as definer.

      NOTE: when CREATE TRIGGER statement is allowed to be executed in PS/SP,
      it will be required to create the definer below in persistent MEM_ROOT
      of PS/SP.
    */

    if (!thd->slave_thread)
    {
      if (!(lex->definer= create_default_definer(thd)))
        return 1;
    }
  }

  /*
    If the specified definer differs from the current user, we should check
    that the current user has SUPER privilege (in order to create trigger
    under another user one must have SUPER privilege).
  */
  
  if (lex->definer &&
      (strcmp(lex->definer->user.str, thd->security_ctx->priv_user) ||
       my_strcasecmp(system_charset_info,
                     lex->definer->host.str,
                     thd->security_ctx->priv_host)))
  {
    if (check_global_access(thd, SUPER_ACL))
    {
      my_error(ER_SPECIFIC_ACCESS_DENIED_ERROR, MYF(0), "SUPER");
      return TRUE;
    }
  }

  /*
    Let us check if all references to fields in old/new versions of row in
    this trigger are ok.

    NOTE: We do it here more from ease of use standpoint. We still have to
    do some checks on each execution. E.g. we can catch privilege changes
    only during execution. Also in near future, when we will allow access
    to other tables from trigger we won't be able to catch changes in other
    tables...

    Since we don't plan to access to contents of the fields it does not
    matter that we choose for both OLD and NEW values the same versions
    of Field objects here.
  */
  old_field= new_field= table->field;

  for (trg_field= (Item_trigger_field *)(lex->trg_table_fields.first);
       trg_field; trg_field= trg_field->next_trg_field)
  {
    /*
      NOTE: now we do not check privileges at CREATE TRIGGER time. This will
      be changed in the future.
    */
    trg_field->setup_field(thd, table, NULL);

    if (!trg_field->fixed &&
        trg_field->fix_fields(thd, (Item **)0))
      return 1;
  }

  /*
    Here we are creating file with triggers and save all triggers in it.
    sql_create_definition_file() files handles renaming and backup of older
    versions
  */
  file.length= build_table_filename(file_buff, FN_REFLEN-1,
                                    tables->db, tables->table_name,
                                    triggers_file_ext, 0);
  file.str= file_buff;
  trigname_file.length= build_table_filename(trigname_buff, FN_REFLEN-1,
                                             tables->db,
                                             lex->spname->m_name.str,
                                             trigname_file_ext, 0);
  trigname_file.str= trigname_buff;

  /* Use the filesystem to enforce trigger namespace constraints. */
  if (!access(trigname_buff, F_OK))
  {
    my_error(ER_TRG_ALREADY_EXISTS, MYF(0));
    return 1;
  }

  trigname.trigger_table.str= tables->table_name;
  trigname.trigger_table.length= tables->table_name_length;

  if (sql_create_definition_file(NULL, &trigname_file, &trigname_file_type,
                                 (gptr)&trigname, trigname_file_parameters, 0))
    return 1;

  /*
    Soon we will invalidate table object and thus Table_triggers_list object
    so don't care about place to which trg_def->ptr points and other
    invariants (e.g. we don't bother to update names_list)

    QQ: Hmm... probably we should not care about setting up active thread
        mem_root too.
  */
  if (!(trg_def= (LEX_STRING *)alloc_root(&table->mem_root,
                                          sizeof(LEX_STRING))) ||
      definitions_list.push_back(trg_def, &table->mem_root) ||
      !(trg_sql_mode= (ulonglong*)alloc_root(&table->mem_root,
                                             sizeof(ulonglong))) ||
      definition_modes_list.push_back(trg_sql_mode, &table->mem_root) ||
      !(trg_definer= (LEX_STRING*) alloc_root(&table->mem_root,
                                              sizeof(LEX_STRING))) ||
      definers_list.push_back(trg_definer, &table->mem_root))
    goto err_with_cleanup;

  trg_def->str= thd->query;
  trg_def->length= thd->query_length;
  *trg_sql_mode= thd->variables.sql_mode;

#ifndef NO_EMBEDDED_ACCESS_CHECKS
  if (lex->definer && !is_acl_user(lex->definer->host.str,
                                   lex->definer->user.str))
  {
    push_warning_printf(thd,
                        MYSQL_ERROR::WARN_LEVEL_NOTE,
                        ER_NO_SUCH_USER,
                        ER(ER_NO_SUCH_USER),
                        lex->definer->user.str,
                        lex->definer->host.str);
  }
#endif /* NO_EMBEDDED_ACCESS_CHECKS */

  if (lex->definer)
  {
    /* SUID trigger. */

    *definer_user= lex->definer->user;
    *definer_host= lex->definer->host;

    trg_definer->str= trg_definer_holder;
    trg_definer->length= strxmov(trg_definer->str, definer_user->str, "@",
                                 definer_host->str, NullS) - trg_definer->str;
  }
  else
  {
    /* non-SUID trigger. */

    definer_user->str= 0;
    definer_user->length= 0;

    definer_host->str= 0;
    definer_host->length= 0;

    trg_definer->str= (char*) "";
    trg_definer->length= 0;
  }

  if (!sql_create_definition_file(NULL, &file, &triggers_file_type,
                                  (gptr)this, triggers_file_parameters, 0))
    return 0;

err_with_cleanup:
  my_delete(trigname_buff, MYF(MY_WME));
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Table_triggers_list::drop_all_triggers	(	THD *	thd,
		char *	db,
		char *	table_name
	)			[static]

Definition at line 1215 of file sql_trigger.cc.

References bzero, check_n_load(), DBUG_ENTER, DBUG_RETURN, FN_REFLEN, free_root(), init_alloc_root(), LOCK_open, MYF, path, rm_trigger_file(), rm_trigname_file(), safe_mutex_assert_owner, LEX_STRING::str, and table.

Referenced by mysql_rm_table_part2().

{
  TABLE table;
  char path[FN_REFLEN];
  bool result= 0;
  DBUG_ENTER("drop_all_triggers");

  bzero(&table, sizeof(table));
  init_alloc_root(&table.mem_root, 8192, 0);

  safe_mutex_assert_owner(&LOCK_open);

  if (Table_triggers_list::check_n_load(thd, db, name, &table, 1))
  {
    result= 1;
    goto end;
  }
  if (table.triggers)
  {
    LEX_STRING *trigger;
    List_iterator_fast<LEX_STRING> it_name(table.triggers->names_list);

    while ((trigger= it_name++))
    {
      if (rm_trigname_file(path, db, trigger->str))
      {
        /*
          Instead of immediately bailing out with error if we were unable
          to remove .TRN file we will try to drop other files.
        */
        result= 1;
        continue;
      }
    }

    if (rm_trigger_file(path, db, name))
    {
      result= 1;
      goto end;
    }
  }
end:
  if (table.triggers)
    delete table.triggers;
  free_root(&table.mem_root, MYF(0));
  DBUG_RETURN(result);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Table_triggers_list::drop_trigger	(	THD *	thd,
		TABLE_LIST *	table
	)

Definition at line 656 of file sql_trigger.cc.

References st_table_list::db, definers_list, definition_modes_list, definitions_list, ER, ER_TRG_DOES_NOT_EXIST, FN_REFLEN, base_list::is_empty(), my_message(), my_strcasecmp, MYF, name, names_list, path, List_iterator< T >::remove(), rm_trigger_file(), rm_trigname_file(), save_trigger_file(), table_alias_charset, and st_table_list::table_name.

Referenced by mysql_create_or_drop_trigger().

{
  LEX *lex= thd->lex;
  LEX_STRING *name;
  List_iterator_fast<LEX_STRING> it_name(names_list);
  List_iterator<LEX_STRING>      it_def(definitions_list);
  List_iterator<ulonglong>       it_mod(definition_modes_list);
  List_iterator<LEX_STRING>      it_definer(definers_list);
  char path[FN_REFLEN];

  while ((name= it_name++))
  {
    it_def++;
    it_mod++;
    it_definer++;

    if (my_strcasecmp(table_alias_charset, lex->spname->m_name.str,
                      name->str) == 0)
    {
      /*
        Again we don't care much about other things required for
        clean trigger removing since table will be reopened anyway.
      */
      it_def.remove();
      it_mod.remove();
      it_definer.remove();

      if (definitions_list.is_empty())
      {
        /*
          TODO: Probably instead of removing .TRG file we should move
          to archive directory but this should be done as part of
          parse_file.cc functionality (because we will need it
          elsewhere).
        */
        if (rm_trigger_file(path, tables->db, tables->table_name))
          return 1;
      }
      else
      {
        if (save_trigger_file(this, tables->db, tables->table_name))
          return 1;
      }

      if (rm_trigname_file(path, tables->db, lex->spname->m_name.str))
        return 1;
      return 0;
    }
  }

  my_message(ER_TRG_DOES_NOT_EXIST, ER(ER_TRG_DOES_NOT_EXIST), MYF(0));
  return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Table_triggers_list::get_trigger_info	(	THD *	thd,
		trg_event_type	event,
		trg_action_time_type	time_type,
		LEX_STRING *	trigger_name,
		LEX_STRING *	trigger_stmt,
		ulong *	sql_mode,
		LEX_STRING *	definer
	)

Definition at line 1106 of file sql_trigger.cc.

References bodies, DBUG_ENTER, DBUG_RETURN, LEX_STRING::length, sp_head::m_body, sp_head::m_chistics, sp_head::m_definer_host, sp_head::m_definer_user, sp_head::m_name, sp_head::m_sql_mode, NullS, LEX_STRING::str, and strxmov().

Referenced by get_schema_triggers_record().

{
  sp_head *body;
  DBUG_ENTER("get_trigger_info");
  if ((body= bodies[event][time_type]))
  {
    *trigger_name= body->m_name;
    *trigger_stmt= body->m_body;
    *sql_mode= body->m_sql_mode;

    if (body->m_chistics->suid == SP_IS_NOT_SUID)
    {
      definer->str[0]= 0;
      definer->length= 0;
    }
    else
    {
      definer->length= strxmov(definer->str, body->m_definer_user.str, "@",
                               body->m_definer_host.str, NullS) - definer->str;
    }

    DBUG_RETURN(0);
  }
  DBUG_RETURN(1);
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Table_triggers_list::has_before_update_triggers

(

)

[inline]

Definition at line 121 of file sql_trigger.h.

References bodies, test, TRG_ACTION_BEFORE, and TRG_EVENT_UPDATE.

Referenced by safe_update_on_fly().

  {
    return test(bodies[TRG_EVENT_UPDATE][TRG_ACTION_BEFORE]);
  }

Here is the caller graph for this function:

bool Table_triggers_list::has_delete_triggers

(

)

[inline]

Definition at line 115 of file sql_trigger.h.

References bodies, TRG_ACTION_AFTER, TRG_ACTION_BEFORE, and TRG_EVENT_DELETE.

Referenced by delayed_insert::handle_inserts(), mysql_delete(), mysql_insert(), mysql_load(), and write_record().

  {
    return (bodies[TRG_EVENT_DELETE][TRG_ACTION_BEFORE] ||
            bodies[TRG_EVENT_DELETE][TRG_ACTION_AFTER]);
  }

Here is the caller graph for this function:

void Table_triggers_list::mark_fields_used

(

trg_event_type

event

)

Definition at line 1565 of file sql_trigger.cc.

References bitmap_set_bit(), Item_trigger_field::field_idx, Item_trigger_field::get_settable_routine_parameter(), int(), Item_trigger_field::next_trg_field, st_table::read_set, table, TRG_ACTION_MAX, trigger_fields, and st_table::write_set.

Referenced by st_table::mark_columns_needed_for_delete(), st_table::mark_columns_needed_for_insert(), and st_table::mark_columns_needed_for_update().

{
  int action_time;
  Item_trigger_field *trg_field;

  for (action_time= 0; action_time < (int)TRG_ACTION_MAX; action_time++)
  {
    for (trg_field= trigger_fields[event][action_time]; trg_field;
         trg_field= trg_field->next_trg_field)
    {
      /* We cannot mark fields which does not present in table. */
      if (trg_field->field_idx != (uint)-1)
      {
        bitmap_set_bit(table->read_set, trg_field->field_idx);
        if (trg_field->get_settable_routine_parameter())
          bitmap_set_bit(table->write_set, trg_field->field_idx);
      }
    }
  }
  table->file->column_bitmaps_signal();
}

Here is the call graph for this function:

Here is the caller graph for this function:

bool Table_triggers_list::prepare_record1_accessors

(

TABLE *

table

)

[private]

Definition at line 736 of file sql_trigger.cc.

References alloc_root(), st_table::field, st_table_share::fields, st_table::mem_root, Field::new_field(), st_table::record, record1_field, st_table::s, and table.

{
  Field **fld, **old_fld;

  if (!(record1_field= (Field **)alloc_root(&table->mem_root,
                                            (table->s->fields + 1) *
                                            sizeof(Field*))))
    return 1;

  for (fld= table->field, old_fld= record1_field; *fld; fld++, old_fld++)
  {
    /*
      QQ: it is supposed that it is ok to use this function for field
      cloning...
    */
    if (!(*old_fld= (*fld)->new_field(&table->mem_root, table,
                                      table == (*fld)->table)))
      return 1;
    (*old_fld)->move_field_offset((my_ptrdiff_t)(table->record[1] -
                                          table->record[0]));
  }
  *old_fld= 0;

  return 0;
}

Here is the call graph for this function:

bool Table_triggers_list::process_triggers	(	THD *	thd,
		trg_event_type	event,
		trg_action_time_type	time_type,
		bool	old_row_is_record1
	)

Definition at line 1482 of file sql_trigger.cc.

References bodies, st_table_share::db, ER_TABLEACCESS_DENIED_ERROR, sp_head::execute_trigger(), FALSE, st_table::field, fill_effective_table_privileges(), get_privilege_desc(), my_error(), MYF, new_field, old_field, record1_field, st_table::s, sp_change_security_context(), sp_restore_security_context(), LEX_STRING::str, subject_table_grants, table, st_table_share::table_name, TRIGGER_ACL, and TRUE.

Referenced by fill_record_n_invoke_before_triggers(), mysql_delete(), and write_record().

{
  bool err_status= FALSE;
  sp_head *sp_trigger= bodies[event][time_type];

  if (sp_trigger)
  {
    Sub_statement_state statement_state;

    if (old_row_is_record1)
    {
      old_field= record1_field;
      new_field= table->field;
    }
    else
    {
      new_field= record1_field;
      old_field= table->field;
    }
#ifndef NO_EMBEDDED_ACCESS_CHECKS
    Security_context *save_ctx;

    if (sp_change_security_context(thd, sp_trigger, &save_ctx))
      return TRUE;

    /*
      Fetch information about table-level privileges to GRANT_INFO structure for
      subject table. Check of privileges that will use it and information about
      column-level privileges will happen in Item_trigger_field::fix_fields().
    */

    fill_effective_table_privileges(thd,
                                    &subject_table_grants[event][time_type],
                                    table->s->db.str, table->s->table_name.str);

    /* Check that the definer has TRIGGER privilege on the subject table. */

    if (!(subject_table_grants[event][time_type].privilege & TRIGGER_ACL))
    {
      char priv_desc[128];
      get_privilege_desc(priv_desc, sizeof(priv_desc), TRIGGER_ACL);

      my_error(ER_TABLEACCESS_DENIED_ERROR, MYF(0), priv_desc,
               thd->security_ctx->priv_user, thd->security_ctx->host_or_ip,
               table->s->table_name.str);

      sp_restore_security_context(thd, save_ctx);
      return TRUE;
    }
#endif // NO_EMBEDDED_ACCESS_CHECKS

    thd->reset_sub_statement_state(&statement_state, SUB_STMT_TRIGGER);
    err_status= sp_trigger->execute_trigger
      (thd, table->s->db.str, table->s->table_name.str,
       &subject_table_grants[event][time_type]);
    thd->restore_sub_statement_state(&statement_state);

#ifndef NO_EMBEDDED_ACCESS_CHECKS
    sp_restore_security_context(thd, save_ctx);
#endif // NO_EMBEDDED_ACCESS_CHECKS
  }

  return err_status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void Table_triggers_list::set_table

(

TABLE *

new_table

)

Definition at line 771 of file sql_trigger.cc.

References st_table::alias, record1_field, table, and st_table::triggers.

Referenced by reopen_table().

{
  table= new_table;
  for (Field **field= table->triggers->record1_field ; *field ; field++)
  {
    (*field)->table= (*field)->orig_table= new_table;
    (*field)->table_name= &new_table->alias;
  }
}

Here is the caller graph for this function:

---

Friends And Related Function Documentation

friend class Item_trigger_field [friend]

Definition at line 130 of file sql_trigger.h.

int sp_cache_routines_and_add_tables_for_triggers	(	THD *	thd,
		LEX *	lex,
		TABLE_LIST *	table
	)			[friend]

Definition at line 1722 of file sp.cc.

{
  int ret= 0;
  Table_triggers_list *triggers= table->table->triggers;
  if (add_used_routine(lex, thd->stmt_arena, &triggers->sroutines_key,
                       table->belong_to_view))
  {
    Sroutine_hash_entry **last_cached_routine_ptr=
                            (Sroutine_hash_entry **)lex->sroutines_list.next;
    for (int i= 0; i < (int)TRG_EVENT_MAX; i++)
    {
      for (int j= 0; j < (int)TRG_ACTION_MAX; j++)
      {
        sp_head *trigger_body= triggers->bodies[i][j];
        if (trigger_body)
        {
          (void)trigger_body->
            add_used_tables_to_table_list(thd, &lex->query_tables_last,
                                          table->belong_to_view);
          sp_update_stmt_used_routines(thd, lex,
                                       &trigger_body->m_sroutines,
                                       table->belong_to_view);
          trigger_body->propagate_attributes(lex);
        }
      }
    }
    ret= sp_cache_routines_and_add_tables_aux(thd, lex,
                                              *last_cached_routine_ptr, FALSE);
  }
  return ret;
}

---

Member Data Documentation

sp_head* Table_triggers_list::bodies[TRG_EVENT_MAX][TRG_ACTION_MAX] [private]

Definition at line 27 of file sql_trigger.h.

Referenced by create_trigger(), get_trigger_info(), has_before_update_triggers(), has_delete_triggers(), process_triggers(), sp_cache_routines_and_add_tables_for_triggers(), Table_triggers_list(), and ~Table_triggers_list().

List<LEX_STRING> Table_triggers_list::definers_list

Definition at line 84 of file sql_trigger.h.

Referenced by check_n_load(), create_trigger(), and drop_trigger().

List<ulonglong> Table_triggers_list::definition_modes_list

Definition at line 82 of file sql_trigger.h.

Referenced by change_table_name_in_triggers(), check_n_load(), create_trigger(), and drop_trigger().

List<LEX_STRING> Table_triggers_list::definitions_list

Definition at line 78 of file sql_trigger.h.

Referenced by change_table_name_in_triggers(), create_trigger(), and drop_trigger().

List<LEX_STRING> Table_triggers_list::names_list [private]

Definition at line 53 of file sql_trigger.h.

Referenced by change_table_name_in_trignames(), and drop_trigger().

Field** Table_triggers_list::new_field [private]

Definition at line 44 of file sql_trigger.h.

Referenced by create_trigger(), Item_trigger_field::fix_fields(), and process_triggers().

Field** Table_triggers_list::old_field [private]

Definition at line 45 of file sql_trigger.h.

Referenced by create_trigger(), Item_trigger_field::fix_fields(), and process_triggers().

List<LEX_STRING> Table_triggers_list::on_table_names_list [private]

Definition at line 58 of file sql_trigger.h.

Referenced by change_table_name_in_triggers().

Field** Table_triggers_list::record1_field [private]

Definition at line 38 of file sql_trigger.h.

Referenced by prepare_record1_accessors(), process_triggers(), set_table(), and ~Table_triggers_list().

LEX_STRING Table_triggers_list::sroutines_key [private]

Definition at line 66 of file sql_trigger.h.

Referenced by check_n_load(), and sp_cache_routines_and_add_tables_for_triggers().

GRANT_INFO Table_triggers_list::subject_table_grants[TRG_EVENT_MAX][TRG_ACTION_MAX] [private]

Definition at line 71 of file sql_trigger.h.

Referenced by process_triggers(), and Table_triggers_list().

TABLE* Table_triggers_list::table [private]

Definition at line 47 of file sql_trigger.h.

Referenced by change_table_name(), change_table_name_in_triggers(), check_n_load(), create_trigger(), drop_all_triggers(), Item_trigger_field::fix_fields(), mark_fields_used(), prepare_record1_accessors(), process_triggers(), and set_table().

Item_trigger_field* Table_triggers_list::trigger_fields[TRG_EVENT_MAX][TRG_ACTION_MAX] [private]

Definition at line 32 of file sql_trigger.h.

Referenced by mark_fields_used(), and Table_triggers_list().

---

The documentation for this class was generated from the following files:

• mysql/src/5.1-dbg/sql/sql_trigger.h
• mysql/src/5.1-dbg/sql/sql_trigger.cc

---

• Products
• MySQL Enterprise
• MySQL Cluster
• MySQL Embedded (OEM/ISV)
• MySQL Data Warehouse
• MySQL Backup & Recovery
• MySQL Workbench
• MySQL Connectors
• Online Shop

• Downloads
• MySQL Community Server
• MySQL Enterprise
• MySQL Proxy
• MySQL Cluster
• MySQL Workbench
• GUI Tools
• Connectors
• Archives
• Snapshots
• Mirrors

• Developer Zone
• Documentation
• Librarian
• Developer Articles
• Forums
• Bugs
• Forge
• Planet MySQL
• Labs
• MySQL Meetups
• Guilds
• Lists

• About
• About MySQL
• Contact Us
• Legal
• Privacy Policy
• Job Opportunities
• Site Map

© 1995-2008 MySQL AB, 2008- Sun Microsystems, Inc.