1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
|
#ifdef __cplusplus
#ifndef SERVICE_RULES_TABLE_INCLUDED
#define SERVICE_RULES_TABLE_INCLUDED
/* Copyright (c) 2015, Oracle and/or its affiliates. All rights reserved.
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 <my_global.h>
#include <my_dbug.h>
#include <string>
#ifndef MYSQL_ABI_CHECK
#include <stdlib.h>
#endif
/**
@file service_rules_table.h
Plugin service that provides access to the rewrite rules table that is used
by the Rewriter plugin. No other use intended.
*/
class THD;
struct TABLE_LIST;
class Field;
namespace rules_table_service
{
/**
There must be one function of this kind in order for the symbols in the
server's dynamic library to be visible to plugins.
*/
int dummy_function_to_ensure_we_are_linked_into_the_server();
/**
Frees a const char pointer allocated in the server's dynamic library using
new[].
*/
void free_string(const char *str);
/**
Writable cursor that allows reading and updating of rows in a persistent
table.
*/
class Cursor
{
public:
typedef int column_id;
static const column_id ILLEGAL_COLUMN_ID= -1;
/**
Creates a cursor to an already-opened table. The constructor is kept
explicit because of implicit conversions from void*.
*/
explicit Cursor(THD *thd);
/// Creates a past-the-end cursor.
Cursor() :
m_thd(NULL), m_table_list(NULL), m_is_finished(true)
{}
column_id pattern_column() const { return m_pattern_column; }
column_id pattern_database_column() const
{
return m_pattern_database_column;
}
column_id replacement_column() const { return m_replacement_column; }
column_id enabled_column() const { return m_enabled_column; }
column_id message_column() const { return m_message_column; }
column_id pattern_digest_column() const { return m_pattern_digest_column; }
column_id normalized_pattern_column() const {
return m_normalized_pattern_column;
}
/**
True if the table does not contain columns named 'pattern', 'replacement',
'enabled' and 'message'. In this case the cursor is equal to any
past-the-end Cursor.
*/
bool table_is_malformed() { return m_table_is_malformed; }
/**
Fetches the value of the column with the given number as a C string.
This interface is meant for crossing dynamic library boundaries, hence the
use of C-style const char*. The function casts a column value to a C
string and returns a copy, allocated in the callee's DL. The pointer
must be freed using free_string().
@param fieldno One of PATTERN_COLUMN, REPLACEMENT_COLUMN, ENABLED_COLUMN
or MESSAGE_COLUMN.
*/
const char *fetch_string(int fieldno);
/**
Equality operator. The only cursors that are equal are past-the-end
cursors.
*/
bool operator== (const Cursor &other)
{
return (m_is_finished == other.m_is_finished);
}
/**
Inequality operator. All cursors are considered different except
past-the-end cursors.
*/
bool operator!= (const Cursor &other) { return !(*this == other); }
/**
Advances this Cursor. Read errors are kept, and had_serious_read_error()
will tell if there was an unexpected error (e.g. not EOF) while reading.
*/
Cursor &operator++ ()
{
if (!m_is_finished)
read();
return *this;
}
/// Prepares the write buffer for updating the current row.
void make_writeable();
/**
Sets the value of column colno to a string value.
@param colno The column number.
@param str The string.
@param length The string's length.
*/
void set(int colno, const char* str, size_t length);
/// Writes the row in the write buffer to the table at the current row.
int write();
/// True if there was an unexpected error while reading, e.g. other than EOF.
bool had_serious_read_error() const;
/// Closes the table scan if initiated and commits the transaction.
~Cursor();
private:
int field_index(const char *field_name);
int m_pattern_column;
int m_pattern_database_column;
int m_replacement_column;
int m_enabled_column;
int m_message_column;
int m_pattern_digest_column;
int m_normalized_pattern_column;
THD *m_thd;
TABLE_LIST *m_table_list;
bool m_is_finished;
bool m_table_is_malformed;
int m_last_read_status;
int read();
};
/**
A past-the-end Cursor. All past-the-end cursors are considered equal
when compared with operator ==.
*/
Cursor end();
}
#endif // SERVICE_RULES_TABLE_INCLUDED
#endif // __cplusplus
|
