← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/message/statement_transform.h

Merge Jay

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/message/statement_transform.h
 
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 
3
 *
 
4
 *  Copyright (C) 2009 Sun Microsystems
 
5
 *
 
6
 *  Authors:
 
7
 *
 
8
 *    Jay Pipes <joinfu@sun.com>
 
9
 *
 
10
 *  This program is free software; you can redistribute it and/or modify
 
11
 *  it under the terms of the GNU General Public License as published by
 
12
 *  the Free Software Foundation; version 2 of the License.
 
13
 *
 
14
 *  This program is distributed in the hope that it will be useful,
 
15
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 
16
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
17
 *  GNU General Public License for more details.
 
18
 *
 
19
 *  You should have received a copy of the GNU General Public License
 
20
 *  along with this program; if not, write to the Free Software
 
21
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 
22
 */
 
23
 
 
24
/**
 
25
 * @file
 
26
 *
 
27
 * Declarations of various routines that can be used to convert
 
28
 * Transaction messages to other formats, including SQL statements.
 
29
 */
 
30
 
 
31
#ifndef DRIZZLED_MESSAGE_STATEMENT_TRANSFORM_H
 
32
#define DRIZZLED_MESSAGE_STATEMENT_TRANSFORM_H
 
33
 
 
34
#include <drizzled/message/table.pb.h>
 
35
#include <string>
 
36
#include <vector>
 
37
 
 
38
namespace drizzled
 
39
{
 
40
namespace message
 
41
{
 
42
/* some forward declarations */
 
43
class Statement;
 
44
class InsertHeader;
 
45
class InsertData;
 
46
class InsertRecord;
 
47
class UpdateHeader;
 
48
class UpdateData;
 
49
class UpdateRecord;
 
50
class DeleteHeader;
 
51
class DeleteData;
 
52
class DeleteRecord;
 
53
class SetVariableStatement;
 
54
 
 
55
/** A Variation of SQL to be output during transformation */
 
56
enum TransformSqlVariant
 
57
{
 
58
  ANSI,
 
59
  MYSQL_4,
 
60
  MYSQL_5,
 
61
  DRIZZLE
 
62
};
 
63
 
 
64
/** Error codes which can happen during tranformations */
 
65
enum TransformSqlError
 
66
{
 
67
  NONE= 0,
 
68
  MISSING_HEADER= 1, /* A data segment without a header segment was found */
 
69
  MISSING_DATA= 2 /* A header segment without a data segment was found */
 
70
};
 
71
 
 
72
/**
 
73
 * This function looks at the Statement
 
74
 * message and appends one or more correctly-formatted SQL
 
75
 * strings to the supplied vector of strings.
 
76
 *
 
77
 * @param Statement message to transform
 
78
 * @param Vector of strings to append SQL statements to
 
79
 * @param Variation of SQL to generate
 
80
 *
 
81
 * @retval
 
82
 *  NONE if successful transformation
 
83
 * @retval
 
84
 *  Error code (see enum TransformSqlError definition) if failure
 
85
 */
 
86
enum TransformSqlError
 
87
transformStatementToSql(const Statement &source,
 
88
                        std::vector<std::string> &sql_strings,
 
89
                        enum TransformSqlVariant sql_variant= DRIZZLE);
 
90
 
 
91
/**
 
92
 * This function looks at a supplied InsertHeader
 
93
 * and InsertData message and constructs a correctly-formatted SQL
 
94
 * statement to the supplied destination string.
 
95
 *
 
96
 * @note
 
97
 *
 
98
 * This function is used when you want to construct a <strong>
 
99
 * single SQL statement</strong> from an entire InsertHeader and
 
100
 * InsertData message.  If there are many records in the InsertData
 
101
 * message, the SQL statement will be a multi-value INSERT statement.
 
102
 *
 
103
 * @param InsertHeader message to transform
 
104
 * @param InsertData message to transform
 
105
 * @param Destination string to append SQL to
 
106
 * @param Variation of SQL to generate
 
107
 *
 
108
 * @retval
 
109
 *  NONE if successful transformation
 
110
 * @retval
 
111
 *  Error code (see enum TransformSqlError definition) if failure
 
112
 */
 
113
enum TransformSqlError
 
114
transformInsertStatementToSql(const InsertHeader &header,
 
115
                              const InsertData &data,
 
116
                              std::string *destination,
 
117
                              enum TransformSqlVariant sql_variant= DRIZZLE);
 
118
 
 
119
/**
 
120
 * This function looks at a supplied InsertHeader
 
121
 * and a single InsertRecord message and constructs a correctly-formatted
 
122
 * SQL statement to the supplied destination string.
 
123
 *
 
124
 * @param InsertHeader message to transform
 
125
 * @param InsertRecord message to transform
 
126
 * @param Destination string to append SQL to
 
127
 * @param Variation of SQL to generate
 
128
 *
 
129
 * @retval
 
130
 *  NONE if successful transformation
 
131
 * @retval
 
132
 *  Error code (see enum TransformSqlError definition) if failure
 
133
 */
 
134
enum TransformSqlError
 
135
transformInsertRecordToSql(const InsertHeader &header,
 
136
                           const InsertRecord &record,
 
137
                           std::string *destination,
 
138
                           enum TransformSqlVariant sql_variant= DRIZZLE);
 
139
 
 
140
/**
 
141
 * Helper function to construct the header portion of an INSERT
 
142
 * SQL statement from an InsertHeader message.
 
143
 *
 
144
 * @param InsertHeader message to transform
 
145
 * @param Destination string to append SQL to
 
146
 * @param Variation of SQL to generate
 
147
 *
 
148
 * @retval
 
149
 *  NONE if successful transformation
 
150
 * @retval
 
151
 *  Error code (see enum TransformSqlError definition) if failure
 
152
 */
 
153
enum TransformSqlError
 
154
transformInsertHeaderToSql(const InsertHeader &header,
 
155
                           std::string *destination,
 
156
                           enum TransformSqlVariant sql_variant= DRIZZLE);
 
157
/**
 
158
 * This function looks at a supplied UpdateHeader
 
159
 * and UpdateData message and constructs a correctly-formatted SQL
 
160
 * statement to the supplied destination string.
 
161
 *
 
162
 * @note
 
163
 *
 
164
 * This function constructs a <strong>single SQL statement</strong>
 
165
 * that contains all the update keys represented in all records in 
 
166
 * the UpdateData message.
 
167
 *
 
168
 * @param UpdateHeader message to transform
 
169
 * @param UpdateData message to transform
 
170
 * @param Destination string to append SQL to
 
171
 * @param Variation of SQL to generate
 
172
 *
 
173
 * @retval
 
174
 *  NONE if successful transformation
 
175
 * @retval
 
176
 *  Error code (see enum TransformSqlError definition) if failure
 
177
 */
 
178
enum TransformSqlError
 
179
transformUpdateStatementToSql(const UpdateHeader &header,
 
180
                              const UpdateData &data,
 
181
                              std::string *destination,
 
182
                              enum TransformSqlVariant sql_variant= DRIZZLE);
 
183
 
 
184
/**
 
185
 * Helper function to construct the header portion of an UPDATE
 
186
 * SQL statement from an UpdateHeader message.
 
187
 *
 
188
 * @param UpdateHeader message to transform
 
189
 * @param Destination string to append SQL to
 
190
 * @param Variation of SQL to generate
 
191
 *
 
192
 * @retval
 
193
 *  NONE if successful transformation
 
194
 * @retval
 
195
 *  Error code (see enum TransformSqlError definition) if failure
 
196
 */
 
197
enum TransformSqlError
 
198
transformUpdateHeaderToSql(const UpdateHeader &header,
 
199
                           std::string *destination,
 
200
                           enum TransformSqlVariant sql_variant= DRIZZLE);
 
201
 
 
202
/**
 
203
 * This function looks at a supplied UpdateHeader
 
204
 * and a single UpdateRecord message and constructs a correctly-formatted
 
205
 * SQL statement to the supplied destination string.
 
206
 *
 
207
 * @param UpdateHeader message to transform
 
208
 * @param UpdateRecord message to transform
 
209
 * @param Destination string to append SQL to
 
210
 * @param Variation of SQL to generate
 
211
 *
 
212
 * @retval
 
213
 *  NONE if successful transformation
 
214
 * @retval
 
215
 *  Error code (see enum TransformSqlError definition) if failure
 
216
 */
 
217
enum TransformSqlError
 
218
transformUpdateRecordToSql(const UpdateHeader &header,
 
219
                           const UpdateRecord &record,
 
220
                           std::string *destination,
 
221
                           enum TransformSqlVariant sql_variant= DRIZZLE);
 
222
 
 
223
/**
 
224
 * This function looks at a supplied DeleteHeader
 
225
 * and DeleteData message and constructs a correctly-formatted SQL
 
226
 * statement to the supplied destination string.
 
227
 *
 
228
 * @note
 
229
 *
 
230
 * This function constructs a <strong>single SQL statement</strong>
 
231
 * for all keys in the DeleteData message.
 
232
 *
 
233
 * @param DeleteHeader message to transform
 
234
 * @param DeleteData message to transform
 
235
 * @param Destination string to append SQL to
 
236
 * @param Variation of SQL to generate
 
237
 *
 
238
 * @retval
 
239
 *  NONE if successful transformation
 
240
 * @retval
 
241
 *  Error code (see enum TransformSqlError definition) if failure
 
242
 */
 
243
enum TransformSqlError
 
244
transformDeleteStatementToSql(const DeleteHeader &header,
 
245
                              const DeleteData &data,
 
246
                              std::string *destination,
 
247
                              enum TransformSqlVariant sql_variant= DRIZZLE);
 
248
 
 
249
/**
 
250
 * This function looks at a supplied DeleteHeader
 
251
 * and a single DeleteRecord message and constructs a correctly-formatted
 
252
 * SQL statement to the supplied destination string.
 
253
 *
 
254
 * @param DeleteHeader message to transform
 
255
 * @param DeleteRecord message to transform
 
256
 * @param Destination string to append SQL to
 
257
 * @param Variation of SQL to generate
 
258
 *
 
259
 * @retval
 
260
 *  NONE if successful transformation
 
261
 * @retval
 
262
 *  Error code (see enum TransformSqlError definition) if failure
 
263
 */
 
264
enum TransformSqlError
 
265
transformDeleteRecordToSql(const DeleteHeader &header,
 
266
                           const DeleteRecord &record,
 
267
                           std::string *destination,
 
268
                           enum TransformSqlVariant sql_variant= DRIZZLE);
 
269
 
 
270
/**
 
271
 * Helper function to construct the header portion of a DELETE
 
272
 * SQL statement from an DeleteHeader message.
 
273
 *
 
274
 * @param DeleteHeader message to transform
 
275
 * @param Destination string to append SQL to
 
276
 * @param Variation of SQL to generate
 
277
 *
 
278
 * @retval
 
279
 *  NONE if successful transformation
 
280
 * @retval
 
281
 *  Error code (see enum TransformSqlError definition) if failure
 
282
 */
 
283
enum TransformSqlError
 
284
transformDeleteHeaderToSql(const DeleteHeader &header,
 
285
                           std::string *destination,
 
286
                           enum TransformSqlVariant sql_variant= DRIZZLE);
 
287
 
 
288
/**
 
289
 * This function looks at a supplied SetVariableStatement
 
290
 * and constructs a correctly-formatted SQL
 
291
 * statement to the supplied destination string.
 
292
 *
 
293
 * @param SetVariableStatement message to transform
 
294
 * @param Destination string to append SQL to
 
295
 * @param Variation of SQL to generate
 
296
 *
 
297
 * @retval
 
298
 *  NONE if successful transformation
 
299
 * @retval
 
300
 *  Error code (see enum TransformSqlError definition) if failure
 
301
 */
 
302
enum TransformSqlError
 
303
transformSetVariableStatementToSql(const SetVariableStatement &statement,
 
304
                                   std::string *destination,
 
305
                                   enum TransformSqlVariant sql_variant= DRIZZLE);
 
306
 
 
307
 
 
308
/**
 
309
 * Returns true if the supplied message::Table::Field::FieldType
 
310
 * should have its values quoted when modifying values.
 
311
 *
 
312
 * @param[in] type of field
 
313
 */
 
314
bool shouldQuoteFieldValue(Table::Field::FieldType in_type);
 
315
 
 
316
} /* end namespace drizzled::message */
 
317
} /* end namespace drizzled */
 
318
 
 
319
#endif /* DRIZZLED_MESSAGE_STATEMENT_TRANSFORM_H */