database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-07-27 18:02:13 +03:00
Code Activity

MDEV-28152 Features for sequences

Browse Source 
- Add `as <int_type>` to sequence creation options
  - int_type can be signed or unsigned integer types, including
    tinyint, smallint, mediumint, int and bigint
  - Limitation: when alter sequence as <new_int_type>, cannot have any
    other alter options in the same statement
  - Limitation: increment remains signed longlong, and the hidden
    constraint (cache_size x abs(increment) < longlong_max) stays for
    unsigned types. This means for bigint unsigned, neither
    abs(increment) nor (cache_size x abs(increment)) can be between
    longlong_max and ulonglong_max
- Truncating maxvalue and minvalue from user input to the nearest max
  or min value of the type, plus or minus 1. When the truncation
  happens, a warning is emitted
- Information schema table for sequences
This commit is contained in:
Yuchen Pei
2024-01-04 12:12:50 +11:00
parent eeba940311
commit 374783c3d9
34 changed files with 3472 additions and 264 deletions
Download Patch File Download Diff File Expand all files Collapse all files

154
sql/sql_sequence.h
View File

@ -25,12 +25,35 @@
#define seq_field_used_cycle 32
#define seq_field_used_restart 64
#define seq_field_used_restart_value 128
#define seq_field_used_as 256
#define seq_field_specified_min_value 512
#define seq_field_specified_max_value 1024
/* Field position in sequence table for some fields we refer to directly */
#define NEXT_FIELD_NO 0
#define MIN_VALUE_FIELD_NO 1
#define ROUND_FIELD_NO 7
#include "mysql_com.h"
#include "sql_type_int.h"
class Create_field;
class Type_handler;
struct Sequence_field_definition
{
const char *field_name;
uint length;
const Type_handler *type_handler;
LEX_CSTRING comment;
ulong flags;
};
struct Sequence_row_definition
{
Sequence_field_definition fields[9];
};
/**
sequence_definition is used when defining a sequence as part of create
*/
@ -39,33 +62,56 @@ class sequence_definition :public Sql_alloc
{
public:
sequence_definition():
min_value(1), max_value(LONGLONG_MAX-1), start(1), increment(1),
cache(1000), round(0), restart(0), cycle(0), used_fields(0)
min_value_from_parser(1, false),
max_value_from_parser(LONGLONG_MAX-1, false), start_from_parser(1, false),
increment(1), cache(1000), round(0), restart_from_parser(0, false),
cycle(0), used_fields(0),
/*
We use value type and is_unsigned instead of a handler because
Type_handler is incomplete, which we cannot initialise here with
&type_handler_slonglong.
*/
value_type(MYSQL_TYPE_LONGLONG), is_unsigned(false)
{}
longlong reserved_until;
longlong min_value;
longlong max_value;
longlong start;
Longlong_hybrid min_value_from_parser;
Longlong_hybrid max_value_from_parser;
Longlong_hybrid start_from_parser;
longlong increment;
longlong cache;
ulonglong round;
longlong restart; // alter sequence restart value
Longlong_hybrid restart_from_parser;
bool cycle;
uint used_fields; // Which fields where used in CREATE
enum_field_types value_type; // value type of the sequence
bool is_unsigned;
bool check_and_adjust(bool set_reserved_until);
Type_handler const *value_type_handler();
/* max value for the value type, e.g. 32767 for smallint. */
longlong value_type_max();
/* min value for the value type, e.g. -32768 for smallint. */
longlong value_type_min();
bool check_and_adjust(THD *thd, bool set_reserved_until);
void store_fields(TABLE *table);
void read_fields(TABLE *table);
int write_initial_sequence(TABLE *table);
int write(TABLE *table, bool all_fields);
/* This must be called after sequence data has been updated */
void adjust_values(longlong next_value);
longlong truncate_value(const Longlong_hybrid& original);
inline void print_dbug()
{
DBUG_PRINT("sequence", ("reserved: %lld start: %lld increment: %lld min_value: %lld max_value: %lld cache: %lld round: %lld",
reserved_until, start, increment, min_value,
max_value, cache, round));
}
static bool is_allowed_value_type(enum_field_types type);
bool prepare_sequence_fields(List<Create_field> *fields, bool alter);
protected:
/*
The following values are the values from sequence_definition
@ -107,31 +153,90 @@ public:
longlong next_value(TABLE *table, bool second_round, int *error);
int set_value(TABLE *table, longlong next_value, ulonglong round_arg,
bool is_used);
longlong increment_value(longlong value)
{
if (real_increment > 0)
{
if (value > max_value - real_increment ||
value + real_increment > max_value)
value= max_value + 1;
else
value+= real_increment;
}
else
{
if (value + real_increment < min_value ||
value < min_value - real_increment)
value= min_value - 1;
else
value+= real_increment;
}
return value;
}
bool all_values_used;
seq_init initialized;
private:
/**
Check that a value is within a relevant bound
If increasing sequence, check that the value is lower than an
upper bound, otherwise check that the value is higher than a lower
bound.
@param in value The value to check
@param in upper The upper bound
@param in lower The lower bound
@param in increasing Which bound to check
@retval true The value is within the bound.
false The value is out of the bound.
*/
bool within_bound(const longlong value, const longlong upper,
const longlong lower, bool increasing)
{
return
(is_unsigned && increasing && (ulonglong) value < (ulonglong) upper) ||
(is_unsigned && !increasing && (ulonglong) value > (ulonglong) lower) ||
(!is_unsigned && increasing && value < upper) ||
(!is_unsigned && !increasing && value > lower);
}
/**
Increment a value, subject to truncation
Truncating to the nearer value between max_value + 1 and min_value
- 1
@param in value The original value
@param in increment The increment to add to the value
@return The value after increment and possible truncation
*/
longlong increment_value(longlong value, const longlong increment)
{
if (is_unsigned)
{
if (increment > 0)
{
if (/* in case value + increment overflows */
(ulonglong) value >
(ulonglong) max_value - (ulonglong) increment ||
/* in case max_value - increment underflows */
(ulonglong) value + (ulonglong) increment >
(ulonglong) max_value)
value= max_value + 1;
else
value+= increment;
}
else
{
if ((ulonglong) value - (ulonglong) (-increment) <
(ulonglong) min_value ||
(ulonglong) value <
(ulonglong) min_value + (ulonglong) (-increment))
value= min_value - 1;
else
value+= increment;
}
} else
if (increment > 0)
{
if (value > max_value - increment || value + increment > max_value)
value= max_value + 1;
else
value+= increment;
}
else
{
if (value + increment < min_value || value < min_value - increment)
value= min_value - 1;
else
value+= increment;
}
return value;
}
mysql_rwlock_t mutex;
};
@ -159,9 +264,6 @@ public:
uchar table_version[MY_UUID_SIZE];
};
class Create_field;
extern bool prepare_sequence_fields(THD *thd, List<Create_field> *fields);
extern bool check_sequence_fields(LEX *lex, List<Create_field> *fields,
const LEX_CSTRING db,
const LEX_CSTRING table_name);