mirror/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-01-16 03:52:35 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
mariadb/sql/ha_sequence.cc
Sergei Golubchik 7c2ba9e9d7 MDEV-11412 Ensure that table is truly dropped when using DROP TABLE 
don't do table discovery on DROP. DROP falls back to "force"
approach when a table isn't found and will try to drop in all
engines anyway. That is, trying to discover in all engines before
the drop is redundant and may be expensive.
2020-07-04 01:44:47 +02:00

466 lines
13 KiB
C++
Raw Blame History

/*
Copyright (c) 2017, Aliyun and/or its affiliates.
Copyright (c) 2017, 2020, MariaDB Corporation.
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
*/
#include "mariadb.h"
#include "sql_list.h"
#include "table.h"
#include "sql_table.h"
#include "sql_sequence.h"
#include "ha_sequence.h"
#include "sql_plugin.h"
#include "mysql/plugin.h"
#include "sql_priv.h"
#include "sql_parse.h"
#include "sql_update.h"
#include "sql_base.h"
#include "log_event.h"
/*
Table flags we should inherit and disable from the original engine.
We add HA_STATS_RECORDS_IS_EXACT as ha_sequence::info() will ensure
that records is always 1
*/
#define SEQUENCE_ENABLED_TABLE_FLAGS (HA_STATS_RECORDS_IS_EXACT | \
HA_PERSISTENT_TABLE)
#define SEQUENCE_DISABLED_TABLE_FLAGS (HA_CAN_SQL_HANDLER | \
HA_CAN_INSERT_DELAYED | \
HA_BINLOG_STMT_CAPABLE)
handlerton *sql_sequence_hton;
/*
Create a sequence handler
*/
ha_sequence::ha_sequence(handlerton *hton, TABLE_SHARE *share)
:handler(hton, share), write_locked(0)
{
sequence= share->sequence;
DBUG_ASSERT(share->sequence);
}
/**
Destructor method must remove the underlying handler
*/
ha_sequence::~ha_sequence()
{
delete file;
}
/**
Sequence table open method
@param name Path to file (dbname and tablename)
@param mode mode
@param flags Flags how to open file
RETURN VALUES
@retval 0 Success
@retval != 0 Failure
*/
int ha_sequence::open(const char *name, int mode, uint flags)
{
int error;
DBUG_ENTER("ha_sequence::open");
DBUG_ASSERT(table->s == table_share && file);
file->table= table;
if (likely(!(error= file->open(name, mode, flags))))
{
/*
Allocate ref in table's mem_root. We can't use table's ref
as it's allocated by ha_ caller that allocates this.
*/
ref_length= file->ref_length;
if (!(ref= (uchar*) alloc_root(&table->mem_root,ALIGN_SIZE(ref_length)*2)))
{
file->ha_close();
error=HA_ERR_OUT_OF_MEM;
DBUG_RETURN(error);
}
file->ref= ref;
file->dup_ref= dup_ref= ref+ALIGN_SIZE(file->ref_length);
/*
ha_open() sets the following for us. We have to set this for the
underlying handler
*/
file->cached_table_flags= (file->table_flags() | HA_REUSES_FILE_NAMES);
file->reset_statistics();
internal_tmp_table= file->internal_tmp_table=
MY_TEST(flags & HA_OPEN_INTERNAL_TABLE);
reset_statistics();
/*
Don't try to read the initial row if the call is part of CREATE, REPAIR
or FLUSH
*/
if (!(flags & (HA_OPEN_FOR_CREATE | HA_OPEN_FOR_REPAIR |
HA_OPEN_FOR_FLUSH)))
{
if (unlikely((error= table->s->sequence->read_initial_values(table))))
file->ha_close();
}
else if (!table->s->tmp_table)
table->internal_set_needs_reopen(true);
/*
The following is needed to fix comparison of rows in
ha_update_first_row() for InnoDB
*/
if (!error)
memcpy(table->record[1], table->s->default_values, table->s->reclength);
}
DBUG_RETURN(error);
}
/*
Clone the sequence. Needed if table is used by range optimization
(Very, very unlikely)
*/
handler *ha_sequence::clone(const char *name, MEM_ROOT *mem_root)
{
ha_sequence *new_handler;
DBUG_ENTER("ha_sequence::clone");
if (!(new_handler= new (mem_root) ha_sequence(ht, table_share)))
DBUG_RETURN(NULL);
/*
Allocate new_handler->ref here because otherwise ha_open will allocate it
on this->table->mem_root and we will not be able to reclaim that memory
when the clone handler object is destroyed.
*/
if (!(new_handler->ref= (uchar*) alloc_root(mem_root,
ALIGN_SIZE(ref_length)*2)))
goto err;
if (new_handler->ha_open(table, name,
table->db_stat,
HA_OPEN_IGNORE_IF_LOCKED | HA_OPEN_NO_PSI_CALL))
goto err;
/* Reuse original storage engine data for duplicate key reference */
new_handler->ref= file->ref;
new_handler->ref_length= file->ref_length;
new_handler->dup_ref= file->dup_ref;
DBUG_RETURN((handler*) new_handler);
err:
delete new_handler;
DBUG_RETURN(NULL);
}
/*
Map the create table to the original storage engine
*/
int ha_sequence::create(const char *name, TABLE *form,
HA_CREATE_INFO *create_info)
{
DBUG_ASSERT(create_info->sequence);
/* Sequence tables has one and only one row */
create_info->max_rows= create_info->min_rows= 1;
return (file->create(name, form, create_info));
}
/**
Sequence write row method.
A sequence table has only one row. Any inserts in the table
will update this row.
@retval 0 Success
@retval != 0 Failure
NOTES:
write_locked is set if we are called from SEQUENCE::next_value
In this case the mutex is already locked and we should not update
the sequence with 'buf' as the sequence object is already up to date.
*/
int ha_sequence::write_row(const uchar *buf)
{
int error;
sequence_definition tmp_seq;
bool sequence_locked;
DBUG_ENTER("ha_sequence::write_row");
DBUG_ASSERT(table->record[0] == buf);
/*
Log to binary log even if this function has been called before
(The function ends by setting row_logging to 0)
*/
row_logging= row_logging_init;
if (unlikely(sequence->initialized == SEQUENCE::SEQ_IN_PREPARE))
{
/* This calls is from ha_open() as part of create table */
DBUG_RETURN(file->write_row(buf));
}
if (unlikely(sequence->initialized == SEQUENCE::SEQ_IN_ALTER))
{
int error= 0;
/* This is called from alter table */
tmp_seq.read_fields(table);
if (tmp_seq.check_and_adjust(0))
DBUG_RETURN(HA_ERR_SEQUENCE_INVALID_DATA);
sequence->copy(&tmp_seq);
if (likely(!(error= file->write_row(buf))))
sequence->initialized= SEQUENCE::SEQ_READY_TO_USE;
row_logging= 0;
DBUG_RETURN(error);
}
if (unlikely(sequence->initialized != SEQUENCE::SEQ_READY_TO_USE))
DBUG_RETURN(HA_ERR_WRONG_COMMAND);
sequence_locked= write_locked;
if (!write_locked) // If not from next_value()
{
/*
User tries to write a full row directly to the sequence table with
INSERT or LOAD DATA.
- Get an exclusive lock for the table. This is needed to ensure that
we excute all full inserts (same as ALTER SEQUENCE) in same order
on master and slaves
- Check that the new row is an accurate SEQUENCE object
*/
THD *thd= table->in_use;
if (table->s->tmp_table == NO_TMP_TABLE &&
thd->mdl_context.upgrade_shared_lock(table->mdl_ticket,
MDL_EXCLUSIVE,
thd->variables.
lock_wait_timeout))
DBUG_RETURN(ER_LOCK_WAIT_TIMEOUT);
tmp_seq.read_fields(table);
if (tmp_seq.check_and_adjust(0))
DBUG_RETURN(HA_ERR_SEQUENCE_INVALID_DATA);
/*
Lock sequence to ensure that no one can come in between
while sequence, table and binary log are updated.
*/
sequence->write_lock(table);
}
if (likely(!(error= file->update_first_row(buf))))
{
Log_func *log_func= Write_rows_log_event::binlog_row_logging_function;
if (!sequence_locked)
sequence->copy(&tmp_seq);
rows_changed++;
/* We have to do the logging while we hold the sequence mutex */
if (row_logging)
error= binlog_log_row(table, 0, buf, log_func);
}
/* Row is already logged, don't log it again in ha_write_row() */
row_logging= 0;
sequence->all_values_used= 0;
if (!sequence_locked)
sequence->write_unlock(table);
DBUG_RETURN(error);
}
/*
Inherit the sequence base table flags.
*/
handler::Table_flags ha_sequence::table_flags() const
{
DBUG_ENTER("ha_sequence::table_flags");
DBUG_RETURN((file->table_flags() & ~SEQUENCE_DISABLED_TABLE_FLAGS) |
SEQUENCE_ENABLED_TABLE_FLAGS);
}
int ha_sequence::info(uint flag)
{
DBUG_ENTER("ha_sequence::info");
file->info(flag);
/* Inform optimizer that we have always only one record */
stats= file->stats;
stats.records= 1;
DBUG_RETURN(false);
}
int ha_sequence::extra(enum ha_extra_function operation)
{
if (operation == HA_EXTRA_PREPARE_FOR_ALTER_TABLE)
{
/* In case of ALTER TABLE allow ::write_row() to copy rows */
sequence->initialized= SEQUENCE::SEQ_IN_ALTER;
}
return file->extra(operation);
}
bool ha_sequence::check_if_incompatible_data(HA_CREATE_INFO *create_info,
uint table_changes)
{
/* Table definition is locked for SEQUENCE tables */
return(COMPATIBLE_DATA_YES);
}
int ha_sequence::external_lock(THD *thd, int lock_type)
{
int error= file->external_lock(thd, lock_type);
/*
Copy lock flag to satisfy DBUG_ASSERT checks in ha_* functions in
handler.cc when we later call it with file->ha_..()
*/
if (!error)
file->m_lock_type= lock_type;
return error;
}
/*
Squence engine error deal method
*/
void ha_sequence::print_error(int error, myf errflag)
{
const char *sequence_db= table_share->db.str;
const char *sequence_name= table_share->table_name.str;
DBUG_ENTER("ha_sequence::print_error");
switch (error) {
case HA_ERR_SEQUENCE_INVALID_DATA:
{
my_error(ER_SEQUENCE_INVALID_DATA, MYF(errflag), sequence_db,
sequence_name);
DBUG_VOID_RETURN;
}
case HA_ERR_SEQUENCE_RUN_OUT:
{
my_error(ER_SEQUENCE_RUN_OUT, MYF(errflag), sequence_db, sequence_name);
DBUG_VOID_RETURN;
}
case HA_ERR_WRONG_COMMAND:
my_error(ER_ILLEGAL_HA, MYF(0), "SEQUENCE", sequence_db, sequence_name);
DBUG_VOID_RETURN;
case ER_WRONG_INSERT_INTO_SEQUENCE:
my_error(error, MYF(0));
DBUG_VOID_RETURN;
}
file->print_error(error, errflag);
DBUG_VOID_RETURN;
}
/*****************************************************************************
Sequence plugin interface
*****************************************************************************/
/*
Create an new handler
*/
static handler *sequence_create_handler(handlerton *hton,
TABLE_SHARE *share,
MEM_ROOT *mem_root)
{
DBUG_ENTER("sequence_create_handler");
if (unlikely(!share))
{
/*
This can happen if we call get_new_handler with a non existing share
*/
DBUG_RETURN(0);
}
DBUG_RETURN(new (mem_root) ha_sequence(hton, share));
}
/*
Sequence engine end.
SYNOPSIS
sequence_end()
p handlerton.
type panic type.
RETURN VALUES
0 Success
!=0 Failure
*/
static int sequence_end(handlerton* hton,
ha_panic_function type __attribute__((unused)))
{
DBUG_ENTER("sequence_end");
DBUG_RETURN(0);
}
/*
Sequence engine init.
SYNOPSIS
sequence_initialize()
@param p handlerton.
retval 0 Success
retval !=0 Failure
*/
static int sequence_initialize(void *p)
{
handlerton *local_sequence_hton= (handlerton *)p;
DBUG_ENTER("sequence_initialize");
local_sequence_hton->db_type= DB_TYPE_SEQUENCE;
local_sequence_hton->create= sequence_create_handler;
local_sequence_hton->panic= sequence_end;
local_sequence_hton->flags= (HTON_NOT_USER_SELECTABLE |
HTON_HIDDEN |
HTON_TEMPORARY_NOT_SUPPORTED |
HTON_ALTER_NOT_SUPPORTED |
HTON_NO_PARTITION);
DBUG_RETURN(0);
}
static struct st_mysql_storage_engine sequence_storage_engine=
{ MYSQL_HANDLERTON_INTERFACE_VERSION };
maria_declare_plugin(sql_sequence)
{
MYSQL_STORAGE_ENGINE_PLUGIN,
&sequence_storage_engine,
"SQL_SEQUENCE",
"jianwei.zhao @ Aliyun & Monty @ MariaDB corp",
"Sequence Storage Engine for CREATE SEQUENCE",
PLUGIN_LICENSE_GPL,
sequence_initialize, /* Plugin Init */
NULL, /* Plugin Deinit */
0x0100, /* 1.0 */
NULL, /* status variables */
NULL, /* system variables */
"1.0", /* string version */
MariaDB_PLUGIN_MATURITY_STABLE /* maturity */
}
maria_declare_plugin_end;
Reference in a new issue View git blame Copy permalink