database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-08-08 11:22:35 +03:00
Code Activity

WL#1218 "Triggers". Some very preliminary version of patch.

Browse Source 
Mostly needed for Monty for him getting notion what needed for triggers 
from new .FRM format. 

Things to be done:
- Right placement of trigger's invocations
- Right handling of errors in triggers (including transaction rollback)
- Support for priviliges
- Right handling of DROP/RENAME table (hope that it will be handled automatically
  with merging of .TRG into .FRM file)
- Saving/restoring some information critical for trigger creation and replication
  with their definitions (e.g. sql_mode, creator, ...)
- Replication

Already has some known bugs so probably not for general review.


include/mysqld_error.h:
  Added trigger related error codes.
sql/Makefile.am:
  Added sql_trigger.* files to list of sources from which mysqld is built.
sql/item.cc:
  Added Item_trigger_field class representing field of new/old version of row which is 
  inserted/updated/deleted and for which trigger is invoked.
sql/item.h:
  Added enums for describing trigger properties. (Here because of dependencies).
  Added Item_trigger_field class representing field of new/old version of row which is 
  inserted/updated/deleted and for which trigger is invoked.
sql/item_func.cc:
  Added Item_func_set_user_var::print_as_stmt() for printing of assignment to ser variable
  from stored procedures.
  Added comment clarifying why we don't need set no_send_ok when calling stored functions.
sql/item_func.h:
  Added Item_func_set_user_var::print_as_stmt() for printing of assignment to ser variable
  from stored procedures.
sql/lex.h:
  Symbols used in statements defining triggers were added.
sql/mysql_priv.h:
  Exported some functions needed for triggers implementation.
sql/parse_file.cc:
  Cleaned up FILE_OPTIONS_STRLIST handling (needed for triggers).
sql/parse_file.h:
  Cleaned up FILE_OPTIONS_STRLIST handling (needed for triggers).
sql/share/czech/errmsg.txt:
  Added trigger related error messages.
sql/share/danish/errmsg.txt:
  Added trigger related error messages.
sql/share/dutch/errmsg.txt:
  Added trigger related error messages.
sql/share/english/errmsg.txt:
  Added trigger related error messages.
sql/share/estonian/errmsg.txt:
  Added trigger related error messages.
sql/share/french/errmsg.txt:
  Added trigger related error messages.
sql/share/german/errmsg.txt:
  Added trigger related error messages.
sql/share/greek/errmsg.txt:
  Added trigger related error messages.
sql/share/hungarian/errmsg.txt:
  Added trigger related error messages.
sql/share/italian/errmsg.txt:
  Added trigger related error messages.
sql/share/japanese/errmsg.txt:
  Added trigger related error messages.
sql/share/korean/errmsg.txt:
  Added trigger related error messages.
sql/share/norwegian-ny/errmsg.txt:
  Added trigger related error messages.
sql/share/norwegian/errmsg.txt:
  Added trigger related error messages.
sql/share/polish/errmsg.txt:
  Added trigger related error messages.
sql/share/portuguese/errmsg.txt:
  Added trigger related error messages.
sql/share/romanian/errmsg.txt:
  Added trigger related error messages.
sql/share/russian/errmsg.txt:
  Added trigger related error messages.
sql/share/serbian/errmsg.txt:
  Added trigger related error messages.
sql/share/slovak/errmsg.txt:
  Added trigger related error messages.
sql/share/spanish/errmsg.txt:
  Added trigger related error messages.
sql/share/swedish/errmsg.txt:
  Added trigger related error messages.
sql/share/ukrainian/errmsg.txt:
  Added trigger related error messages.
sql/sp_head.cc:
  sp_head::init_strings(): added support for triggers 
    (we don't have most of strings for them)
  sp_head::execute_function(): triggers don't require RETURN
  sp_head::reset_lex(): added propagation of trigger properties to LEX used for 
   parsing of statements composing trigger body.
  Added two more SP instructions:
  - sp_instr_set_user_var for setting user variables in stored functions and triggers
    (we can't use sp_instr_stmt and "SET @a:=..." statement since it will close open 
    tables and thus break execution of calling statement.
  - sp_instr_set_trigger_field for assignment to fields of row being updated/inserted in
    triggers
sql/sp_head.h:
  Added new type of sp_head object - TYPE_ENUM_TRIGGER
  Added two more SP instructions:
  - sp_instr_set_user_var for setting user variables in stored functions and triggers
    (we can't use sp_instr_stmt and "SET @a:=..." statement since it will close open 
    tables and thus break execution of calling statement.
  - sp_instr_set_trigger_field for assignment to fields of row being updated/inserted in
    triggers
sql/sql_base.cc:
  Now freeing memory occupied by trigger related structures when closing tables.
  open_unireg_entry(): added loading of triggers for table.
  find_field_in_real_table() is now public since it required by Item_trigger_field in item.cc
sql/sql_delete.cc:
  Added triggers invocation for DELETE (should be fixed for sure :))
sql/sql_insert.cc:
  Added triggers invocation for INSERT (should be fixed for sure :))
sql/sql_lex.cc:
  Added trg_new_row_fake_var variable pointer to which is used for distinguishing between
  assignment to NEW row field (when parsing trigger definition) and structured variable.
  Added initialization of LEX->trg_table to lex_start(). (When triggers are parsed during
  opening of table it points to table object.)
sql/sql_lex.h:
  Added trigger related commands.
  Added st_trg_chistics structure describing properties of trigger being created
  (as struct and as LEX member).
  Added trg_new_row_fake_var variable pointer to which is used for
  distinguishing between assignment to NEW row field (when parsing trigger definition)
  and structured variable.
  Added LEX::trg_table which points to table being opened when we are parsing trigger
  definition while opening table.
sql/sql_parse.cc:
  Added support for CREATE/DROP TRIGGER commands.
sql/sql_table.cc:
  Cleanup. close_cached_table() always returns 0 and its result is not analyzed in most
  places so chenged its return type to void.
sql/sql_update.cc:
  Added triggers invocation for UPDATE (should be fixed for sure :))
sql/sql_yacc.yy:
  Added support for CREATE/DROP TRIGGER statements.
  Added support for OLD/NEW row identifiers in trigger.
  Made assignment to user variables not to break execution of stored function or trigger.
sql/table.h:
  Added TABLE::triggers member representing triggers for this table.
This commit is contained in:
unknown
2004-09-07 16:29:46 +04:00
parent df94015604
commit 52ac4935e7
49 changed files with 1664 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

434
sql/sql_trigger.cc Normal file
View File

@@ -0,0 +1,434 @@
#include "mysql_priv.h"
#include "sp_head.h"
#include "sql_trigger.h"
#include "parse_file.h"
static const LEX_STRING triggers_file_type= {(char *)"TRIGGERS", 8};
static const char * const triggers_file_ext= ".TRG";
/*
Table of .TRG file field descriptors.
We have here only one field now because in nearest future .TRG
files will be merged into .FRM files (so we don't need something
like md5 or created fields).
*/
static File_option triggers_file_parameters[]=
{
{{(char*)"triggers", 8}, offsetof(Table_triggers_list, definitions_list),
FILE_OPTIONS_STRLIST},
{{NULL, 0}, 0, FILE_OPTIONS_STRING}
};
/*
Create or drop trigger for table.
SYNOPSIS
mysql_create_or_drop_trigger()
thd - current thread context (including trigger definition in LEX)
tables - table list containing one table for which trigger is created.
create - whenever we create (true) or drop (false) trigger
NOTE
This function is mainly responsible for opening and locking of table and
invalidation of all its instances in table cache after trigger creation.
Real work on trigger creation/dropping is done inside Table_triggers_list
methods.
RETURN VALUE
0 - Success, non-0 in case of error.
*/
int mysql_create_or_drop_trigger(THD *thd, TABLE_LIST *tables, bool create)
{
TABLE *table;
int result= 0;
DBUG_ENTER("mysql_create_or_drop_trigger");
/*
QQ: This function could be merged in mysql_alter_table() function
But do we want this ?
*/
if (open_and_lock_tables(thd, tables))
DBUG_RETURN(-1);
// TODO: We should check if user has TRIGGER privilege for table here.
table= tables->table;
/*
We do not allow creation of triggers on views or temporary tables.
We have to do this check here and not in
Table_triggers_list::create_trigger() because we want to avoid messing
with table cash for views and temporary tables.
*/
if (tables->view || table->tmp_table != NO_TMP_TABLE)
{
my_error(ER_TRG_ON_VIEW_OR_TEMP_TABLE, MYF(0), tables->alias);
DBUG_RETURN(-1);
}
if (!table->triggers)
{
if (!create)
{
my_error(ER_TRG_DOES_NOT_EXIST, MYF(0));
DBUG_RETURN(-1);
}
if (!(table->triggers= new (&table->mem_root) Table_triggers_list()))
DBUG_RETURN(-1);
}
/*
We don't want perform our operations while global read lock is held
so we have to wait until its end and then prevent it from occuring
again until we are done. (Acquiring LOCK_open is not enough because
global read lock is held without helding LOCK_open).
*/
if (wait_if_global_read_lock(thd, 0))
DBUG_RETURN(-1);
VOID(pthread_mutex_lock(&LOCK_open));
if ((create ? table->triggers->create_trigger(thd, tables):
table->triggers->drop_trigger(thd, tables)))
result= -1;
/* It is sensible to invalidate table in any case */
close_cached_table(thd, table);
VOID(pthread_mutex_unlock(&LOCK_open));
start_waiting_global_read_lock(thd);
if (!result)
send_ok(thd);
DBUG_RETURN(result);
}
/*
Create trigger for table.
SYNOPSIS
create_trigger()
thd - current thread context (including trigger definition in LEX)
tables - table list containing one open table for which trigger is
created.
RETURN VALUE
False - success
True - error
*/
bool Table_triggers_list::create_trigger(THD *thd, TABLE_LIST *tables)
{
LEX *lex= thd->lex;
TABLE *table= tables->table;
char dir_buff[FN_REFLEN], file_buff[FN_REFLEN];
LEX_STRING dir, file;
MEM_ROOT *old_global_root;
LEX_STRING *trg_def, *name;
List_iterator_fast<LEX_STRING> it(names_list);
/* 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_TRG_ALREADY_EXISTS, MYF(0));
return 1;
}
/* Let us check if trigger with the same name exists */
while ((name= it++))
{
if (my_strcasecmp(system_charset_info, lex->name_and_length.str,
name->str) == 0)
{
my_error(ER_TRG_ALREADY_EXISTS, MYF(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
*/
strxnmov(dir_buff, FN_REFLEN, mysql_data_home, "/", tables->db, "/", NullS);
dir.length= unpack_filename(dir_buff, dir_buff);
dir.str= dir_buff;
file.length= strxnmov(file_buff, FN_REFLEN, tables->real_name,
triggers_file_ext, NullS) - file_buff;
file.str= file_buff;
old_global_root= my_pthread_getspecific_ptr(MEM_ROOT*, THR_MALLOC);
my_pthread_setspecific_ptr(THR_MALLOC, &table->mem_root);
/*
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))
{
my_pthread_setspecific_ptr(THR_MALLOC, old_global_root);
return 1;
}
trg_def->str= thd->query;
trg_def->length= thd->query_length;
my_pthread_setspecific_ptr(THR_MALLOC, old_global_root);
return sql_create_definition_file(&dir, &file, &triggers_file_type,
(gptr)this, triggers_file_parameters, 3);
}
/*
Drop trigger for table.
SYNOPSIS
drop_trigger()
thd - current thread context (including trigger definition in LEX)
tables - table list containing one open table for which trigger is
dropped.
RETURN VALUE
False - success
True - error
*/
bool Table_triggers_list::drop_trigger(THD *thd, TABLE_LIST *tables)
{
LEX *lex= thd->lex;
LEX_STRING *name;
List_iterator_fast<LEX_STRING> it_name(names_list);
List_iterator<LEX_STRING> it_def(definitions_list);
while ((name= it_name++))
{
it_def++;
if (my_strcasecmp(system_charset_info, lex->name_and_length.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();
if (definitions_list.is_empty())
{
char path[FN_REFLEN];
/*
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).
*/
strxnmov(path, FN_REFLEN, mysql_data_home, "/", tables->db, "/",
tables->real_name, triggers_file_ext, NullS);
unpack_filename(path, path);
return my_delete(path, MYF(MY_WME));
}
else
{
char dir_buff[FN_REFLEN], file_buff[FN_REFLEN];
LEX_STRING dir, file;
strxnmov(dir_buff, FN_REFLEN, mysql_data_home, "/", tables->db,
"/", NullS);
dir.length= unpack_filename(dir_buff, dir_buff);
dir.str= dir_buff;
file.length= strxnmov(file_buff, FN_REFLEN, tables->real_name,
triggers_file_ext, NullS) - file_buff;
file.str= file_buff;
return sql_create_definition_file(&dir, &file, &triggers_file_type,
(gptr)this,
triggers_file_parameters, 3);
}
}
}
my_error(ER_TRG_DOES_NOT_EXIST, MYF(0));
return 1;
}
Table_triggers_list::~Table_triggers_list()
{
for (int i= 0; i < 3; i++)
for (int j= 0; j < 2; j++)
delete bodies[i][j];
if (old_field)
for (Field **fld_ptr= old_field; *fld_ptr; fld_ptr++)
delete *fld_ptr;
}
/*
Check whenever .TRG file for table exist and load all triggers it contains.
SYNOPSIS
check_n_load()
thd - current thread context
db - table's database name
table_name - table's name
table - pointer to table object
RETURN VALUE
False - success
True - error
*/
bool Table_triggers_list::check_n_load(THD *thd, const char *db,
const char *table_name, TABLE *table)
{
char path_buff[FN_REFLEN];
LEX_STRING path;
File_parser *parser;
MEM_ROOT *old_global_mem_root;
DBUG_ENTER("Table_triggers_list::check_n_load");
strxnmov(path_buff, FN_REFLEN, mysql_data_home, "/", db, "/", table_name,
triggers_file_ext, NullS);
path.length= unpack_filename(path_buff, path_buff);
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 (!strncmp(triggers_file_type.str, parser->type()->str,
parser->type()->length))
{
int i;
Table_triggers_list *triggers_info=
new (&table->mem_root) Table_triggers_list();
if (!triggers_info)
DBUG_RETURN(1);
if (parser->parse((gptr)triggers_info, &table->mem_root,
triggers_file_parameters, 1))
DBUG_RETURN(1);
table->triggers= triggers_info;
/*
We have to prepare array of Field objects which will represent OLD.*
row values by referencing to record[1] instead of record[0]
TODO: This could be avoided if there is no ON UPDATE trigger.
*/
if (!(triggers_info->old_field=
(Field **)alloc_root(&table->mem_root, (table->fields + 1) *
sizeof(Field*))))
DBUG_RETURN(1);
for (i= 0; i < table->fields; i++)
{
/*
QQ: it is supposed that it is ok to use this function for field
cloning...
*/
if (!(triggers_info->old_field[i]=
table->field[i]->new_field(&table->mem_root, table)))
DBUG_RETURN(1);
triggers_info->old_field[i]->move_field((my_ptrdiff_t)
(table->record[1] -
table->record[0]));
}
triggers_info->old_field[i]= 0;
List_iterator_fast<LEX_STRING> it(triggers_info->definitions_list);
LEX_STRING *trg_create_str, *trg_name_str;
char *trg_name_buff;
LEX *old_lex= thd->lex, lex;
thd->lex= &lex;
while ((trg_create_str= it++))
{
lex_start(thd, (uchar*)trg_create_str->str, trg_create_str->length);
mysql_init_query(thd, true);
lex.trg_table= table;
if (yyparse((void *)thd) || thd->is_fatal_error)
{
/*
Free lex associated resources
QQ: Do we really need all this stuff here ?
*/
if (lex.sphead)
{
if (&lex != thd->lex)
thd->lex->sphead->restore_lex(thd);
delete lex.sphead;
}
goto err_with_lex_cleanup;
}
triggers_info->bodies[lex.trg_chistics.event]
[lex.trg_chistics.action_time]= lex.sphead;
lex.sphead= 0;
if (!(trg_name_buff= alloc_root(&table->mem_root,
sizeof(LEX_STRING) +
lex.name_and_length.length + 1)))
goto err_with_lex_cleanup;
trg_name_str= (LEX_STRING *)trg_name_buff;
trg_name_buff+= sizeof(LEX_STRING);
memcpy(trg_name_buff, lex.name_and_length.str,
lex.name_and_length.length + 1);
trg_name_str->str= trg_name_buff;
trg_name_str->length= lex.name_and_length.length;
old_global_mem_root= my_pthread_getspecific_ptr(MEM_ROOT*, THR_MALLOC);
my_pthread_setspecific_ptr(THR_MALLOC, &table->mem_root);
if (triggers_info->names_list.push_back(trg_name_str))
goto err_with_lex_cleanup;
my_pthread_setspecific_ptr(THR_MALLOC, old_global_mem_root);
lex_end(&lex);
}
thd->lex= old_lex;
DBUG_RETURN(0);
err_with_lex_cleanup:
// QQ: anything else ?
lex_end(&lex);
thd->lex= old_lex;
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, "TRIGGER");
DBUG_RETURN(1);
}
DBUG_RETURN(1);
}