1/* Copyright (c) 2017, MariaDB corporation
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License as published by
5 the Free Software Foundation; version 2 of the License.
6
7 This program is distributed in the hope that it will be useful,
8 but WITHOUT ANY WARRANTY; without even the implied warranty of
9 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
10 GNU General Public License for more details.
11
12 You should have received a copy of the GNU General Public License
13 along with this program; if not, write to the Free Software
14 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
15*/
16
17#ifndef SQL_SEQUENCE_INCLUDED
18#define SQL_SEQUENCE_INCLUDED
19
20#define seq_field_used_min_value 1
21#define seq_field_used_max_value 2
22#define seq_field_used_start 4
23#define seq_field_used_increment 8
24#define seq_field_used_cache 16
25#define seq_field_used_cycle 32
26#define seq_field_used_restart 64
27#define seq_field_used_restart_value 128
28
29/* Field position in sequence table for some fields we refer to directly */
30#define NEXT_FIELD_NO 0
31#define MIN_VALUE_FIELD_NO 1
32#define ROUND_FIELD_NO 7
33
34/**
35 sequence_definition is used when defining a sequence as part of create
36*/
37
38class sequence_definition :public Sql_alloc
39{
40public:
41 sequence_definition():
42 min_value(1), max_value(LONGLONG_MAX-1), start(1), increment(1),
43 cache(1000), round(0), restart(0), cycle(0), used_fields(0)
44 {}
45 longlong reserved_until;
46 longlong min_value;
47 longlong max_value;
48 longlong start;
49 longlong increment;
50 longlong cache;
51 ulonglong round;
52 longlong restart; // alter sequence restart value
53 bool cycle;
54 uint used_fields; // Which fields where used in CREATE
55
56 bool check_and_adjust(bool set_reserved_until);
57 void store_fields(TABLE *table);
58 void read_fields(TABLE *table);
59 int write_initial_sequence(TABLE *table);
60 int write(TABLE *table, bool all_fields);
61 /* This must be called after sequence data has been updated */
62 void adjust_values(longlong next_value);
63 inline void print_dbug()
64 {
65 DBUG_PRINT("sequence", ("reserved: %lld start: %lld increment: %lld min_value: %lld max_value: %lld cache: %lld round: %lld",
66 reserved_until, start, increment, min_value,
67 max_value, cache, round));
68 }
69protected:
70 /*
71 The following values are the values from sequence_definition
72 merged with global auto_increment_offset and auto_increment_increment
73 */
74 longlong real_increment;
75 longlong next_free_value;
76};
77
78/**
79 SEQUENCE is in charge of managing the sequence values.
80 It's also responsible to generate new values and updating the sequence
81 table (engine=SQL_SEQUENCE) trough it's specialized handler interface.
82
83 If increment is 0 then the sequence will be be using
84 auto_increment_increment and auto_increment_offset variables, just like
85 AUTO_INCREMENT is using.
86*/
87
88class SEQUENCE :public sequence_definition
89{
90public:
91 enum seq_init { SEQ_UNINTIALIZED, SEQ_IN_PREPARE, SEQ_IN_ALTER,
92 SEQ_READY_TO_USE };
93 SEQUENCE();
94 ~SEQUENCE();
95 int read_initial_values(TABLE *table);
96 int read_stored_values(TABLE *table);
97 void write_lock(TABLE *table);
98 void write_unlock(TABLE *table);
99 void read_lock(TABLE *table);
100 void read_unlock(TABLE *table);
101 void copy(sequence_definition *seq)
102 {
103 sequence_definition::operator= (*seq);
104 adjust_values(reserved_until);
105 all_values_used= 0;
106 }
107 longlong next_value(TABLE *table, bool second_round, int *error);
108 int set_value(TABLE *table, longlong next_value, ulonglong round_arg,
109 bool is_used);
110 longlong increment_value(longlong value)
111 {
112 if (real_increment > 0)
113 {
114 if (value + real_increment > max_value ||
115 value > max_value - real_increment)
116 value= max_value + 1;
117 else
118 value+= real_increment;
119 }
120 else
121 {
122 if (value + real_increment < min_value ||
123 value < min_value - real_increment)
124 value= min_value - 1;
125 else
126 value+= real_increment;
127 }
128 return value;
129 }
130
131 bool all_values_used;
132 seq_init initialized;
133
134private:
135 mysql_rwlock_t mutex;
136};
137
138
139/**
140 Class to cache last value of NEXT VALUE from the sequence
141*/
142
143class SEQUENCE_LAST_VALUE
144{
145public:
146 SEQUENCE_LAST_VALUE(uchar *key_arg, uint length_arg)
147 :key(key_arg), length(length_arg)
148 {}
149 ~SEQUENCE_LAST_VALUE()
150 { my_free((void*) key); }
151 /* Returns 1 if table hasn't been dropped or re-created */
152 bool check_version(TABLE *table);
153 void set_version(TABLE *table);
154
155 const uchar *key;
156 uint length;
157 bool null_value;
158 longlong value;
159 uchar table_version[MY_UUID_SIZE];
160};
161
162
163class Create_field;
164extern bool prepare_sequence_fields(THD *thd, List<Create_field> *fields);
165extern bool check_sequence_fields(LEX *lex, List<Create_field> *fields);
166extern bool sequence_insert(THD *thd, LEX *lex, TABLE_LIST *table_list);
167#endif /* SQL_SEQUENCE_INCLUDED */
168