← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/message/statement_transform.cc

Merge Stewart's dead code removal

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/message/statement_transform.cc
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
4
 *  Copyright (C) 2009 Sun Microsystems
5
 
 *  Copyright (c) 2010 Jay Pipes
6
5
 *
7
6
 *  Authors:
8
7
 *
9
 
 *    Jay Pipes <jaypipes@gmail.com>
 
8
 *    Jay Pipes <joinfu@sun.com>
10
9
 *
11
10
 *  This program is free software; you can redistribute it and/or modify
12
11
 *  it under the terms of the GNU General Public License as published by
29
28
 * Statement messages to other formats, including SQL strings.
30
29
 */
31
30
 
32
 
#include "config.h"
 
31
#include "drizzled/global.h"
33
32
 
34
33
#include "drizzled/message/statement_transform.h"
35
34
#include "drizzled/message/transaction.pb.h"
37
36
 
38
37
#include <string>
39
38
#include <vector>
40
 
#include <sstream>
41
39
 
42
40
using namespace std;
43
 
 
44
 
namespace drizzled
45
 
{
46
 
 
47
 
namespace message
48
 
{
49
 
 
50
 
enum TransformSqlError
51
 
transformStatementToSql(const Statement &source,
52
 
                        vector<string> &sql_strings,
53
 
                        enum TransformSqlVariant sql_variant,
54
 
                        bool already_in_transaction)
55
 
{
56
 
  TransformSqlError error= NONE;
 
41
using namespace drizzled;
 
42
 
 
43
enum message::TransformSqlError
 
44
message::transformStatementToSql(const message::Statement &source,
 
45
                                 vector<string> &sql_strings,
 
46
                                 enum message::TransformSqlVariant sql_variant)
 
47
{
 
48
  message::TransformSqlError error= NONE;
57
49
 
58
50
  switch (source.type())
59
51
  {
60
 
  case Statement::INSERT:
 
52
  case message::Statement::INSERT:
61
53
    {
62
54
      if (! source.has_insert_header())
63
55
      {
70
62
        return error;
71
63
      }
72
64
 
73
 
      const InsertHeader &insert_header= source.insert_header();
74
 
      const InsertData &insert_data= source.insert_data();
 
65
      const message::InsertHeader &insert_header= source.insert_header();
 
66
      const message::InsertData &insert_data= source.insert_data();
75
67
      size_t num_keys= insert_data.record_size();
76
68
      size_t x;
77
69
 
78
 
      if (num_keys > 1 && ! already_in_transaction)
 
70
      if (num_keys > 1)
79
71
        sql_strings.push_back("START TRANSACTION");
80
72
 
81
73
      for (x= 0; x < num_keys; ++x)
84
76
 
85
77
        error= transformInsertRecordToSql(insert_header,
86
78
                                          insert_data.record(x),
87
 
                                          destination,
 
79
                                          &destination,
88
80
                                          sql_variant);
89
81
        if (error != NONE)
90
82
          break;
92
84
        sql_strings.push_back(destination);
93
85
      }
94
86
 
95
 
      if (num_keys > 1 && ! already_in_transaction)
 
87
      if (num_keys > 1)
96
88
      {
97
89
        if (error == NONE)
98
90
          sql_strings.push_back("COMMIT");
101
93
      }
102
94
    }
103
95
    break;
104
 
  case Statement::UPDATE:
 
96
  case message::Statement::UPDATE:
105
97
    {
106
98
      if (! source.has_update_header())
107
99
      {
114
106
        return error;
115
107
      }
116
108
 
117
 
      const UpdateHeader &update_header= source.update_header();
118
 
      const UpdateData &update_data= source.update_data();
 
109
      const message::UpdateHeader &update_header= source.update_header();
 
110
      const message::UpdateData &update_data= source.update_data();
119
111
      size_t num_keys= update_data.record_size();
120
112
      size_t x;
121
113
 
122
 
      if (num_keys > 1 && ! already_in_transaction)
 
114
      if (num_keys > 1)
123
115
        sql_strings.push_back("START TRANSACTION");
124
116
 
125
117
      for (x= 0; x < num_keys; ++x)
128
120
 
129
121
        error= transformUpdateRecordToSql(update_header,
130
122
                                          update_data.record(x),
131
 
                                          destination,
 
123
                                          &destination,
132
124
                                          sql_variant);
133
125
        if (error != NONE)
134
126
          break;
136
128
        sql_strings.push_back(destination);
137
129
      }
138
130
 
139
 
      if (num_keys > 1 && ! already_in_transaction)
 
131
      if (num_keys > 1)
140
132
      {
141
133
        if (error == NONE)
142
134
          sql_strings.push_back("COMMIT");
145
137
      }
146
138
    }
147
139
    break;
148
 
  case Statement::DELETE:
 
140
  case message::Statement::DELETE:
149
141
    {
150
142
      if (! source.has_delete_header())
151
143
      {
158
150
        return error;
159
151
      }
160
152
 
161
 
      const DeleteHeader &delete_header= source.delete_header();
162
 
      const DeleteData &delete_data= source.delete_data();
 
153
      const message::DeleteHeader &delete_header= source.delete_header();
 
154
      const message::DeleteData &delete_data= source.delete_data();
163
155
      size_t num_keys= delete_data.record_size();
164
156
      size_t x;
165
157
 
166
 
      if (num_keys > 1 && ! already_in_transaction)
 
158
      if (num_keys > 1)
167
159
        sql_strings.push_back("START TRANSACTION");
168
160
 
169
161
      for (x= 0; x < num_keys; ++x)
172
164
 
173
165
        error= transformDeleteRecordToSql(delete_header,
174
166
                                          delete_data.record(x),
175
 
                                          destination,
 
167
                                          &destination,
176
168
                                          sql_variant);
177
169
        if (error != NONE)
178
170
          break;
180
172
        sql_strings.push_back(destination);
181
173
      }
182
174
 
183
 
      if (num_keys > 1 && ! already_in_transaction)
 
175
      if (num_keys > 1)
184
176
      {
185
177
        if (error == NONE)
186
178
          sql_strings.push_back("COMMIT");
189
181
      }
190
182
    }
191
183
    break;
192
 
  case Statement::CREATE_TABLE:
193
 
    {
194
 
      assert(source.has_create_table_statement());
195
 
      string destination;
196
 
      error= transformCreateTableStatementToSql(source.create_table_statement(),
197
 
                                                destination,
198
 
                                                sql_variant);
199
 
      sql_strings.push_back(destination);
200
 
    }
201
 
    break;
202
 
  case Statement::TRUNCATE_TABLE:
203
 
    {
204
 
      assert(source.has_truncate_table_statement());
205
 
      string destination;
206
 
      error= transformTruncateTableStatementToSql(source.truncate_table_statement(),
207
 
                                                  destination,
208
 
                                                  sql_variant);
209
 
      sql_strings.push_back(destination);
210
 
    }
211
 
    break;
212
 
  case Statement::DROP_TABLE:
213
 
    {
214
 
      assert(source.has_drop_table_statement());
215
 
      string destination;
216
 
      error= transformDropTableStatementToSql(source.drop_table_statement(),
217
 
                                              destination,
218
 
                                              sql_variant);
219
 
      sql_strings.push_back(destination);
220
 
    }
221
 
    break;
222
 
  case Statement::CREATE_SCHEMA:
223
 
    {
224
 
      assert(source.has_create_schema_statement());
225
 
      string destination;
226
 
      error= transformCreateSchemaStatementToSql(source.create_schema_statement(),
227
 
                                                 destination,
228
 
                                                 sql_variant);
229
 
      sql_strings.push_back(destination);
230
 
    }
231
 
    break;
232
 
  case Statement::DROP_SCHEMA:
233
 
    {
234
 
      assert(source.has_drop_schema_statement());
235
 
      string destination;
236
 
      error= transformDropSchemaStatementToSql(source.drop_schema_statement(),
237
 
                                               destination,
238
 
                                               sql_variant);
239
 
      sql_strings.push_back(destination);
240
 
    }
241
 
    break;
242
 
  case Statement::SET_VARIABLE:
 
184
  case message::Statement::SET_VARIABLE:
243
185
    {
244
186
      assert(source.has_set_variable_statement());
245
187
      string destination;
246
 
      error= transformSetVariableStatementToSql(source.set_variable_statement(),
247
 
                                                destination,
248
 
                                                sql_variant);
 
188
      error= message::transformSetVariableStatementToSql(source.set_variable_statement(),
 
189
                                                       &destination,
 
190
                                                       sql_variant);
249
191
      sql_strings.push_back(destination);
250
192
    }
251
193
    break;
252
 
  case Statement::RAW_SQL:
 
194
  case message::Statement::RAW_SQL:
253
195
  default:
254
196
    sql_strings.push_back(source.sql());
255
197
    break;
257
199
  return error;
258
200
}
259
201
 
260
 
enum TransformSqlError
261
 
transformInsertHeaderToSql(const InsertHeader &header,
262
 
                           string &destination,
263
 
                           enum TransformSqlVariant sql_variant)
 
202
enum message::TransformSqlError
 
203
message::transformInsertHeaderToSql(const message::InsertHeader &header,
 
204
                                    std::string *destination,
 
205
                                    enum message::TransformSqlVariant sql_variant)
264
206
{
265
207
  char quoted_identifier= '`';
266
208
  if (sql_variant == ANSI)
267
209
    quoted_identifier= '"';
268
210
 
269
 
  destination.assign("INSERT INTO ", 12);
270
 
  destination.push_back(quoted_identifier);
271
 
  destination.append(header.table_metadata().schema_name());
272
 
  destination.push_back(quoted_identifier);
273
 
  destination.push_back('.');
274
 
  destination.push_back(quoted_identifier);
275
 
  destination.append(header.table_metadata().table_name());
276
 
  destination.push_back(quoted_identifier);
277
 
  destination.append(" (", 2);
 
211
  destination->assign("INSERT INTO ");
 
212
  destination->push_back(quoted_identifier);
 
213
  destination->append(header.table_metadata().schema_name());
 
214
  destination->push_back(quoted_identifier);
 
215
  destination->push_back('.');
 
216
  destination->push_back(quoted_identifier);
 
217
  destination->append(header.table_metadata().table_name());
 
218
  destination->push_back(quoted_identifier);
 
219
  destination->append(" (");
278
220
 
279
221
  /* Add field list to SQL string... */
280
222
  size_t num_fields= header.field_metadata_size();
282
224
 
283
225
  for (x= 0; x < num_fields; ++x)
284
226
  {
285
 
    const FieldMetadata &field_metadata= header.field_metadata(x);
 
227
    const message::FieldMetadata &field_metadata= header.field_metadata(x);
286
228
    if (x != 0)
287
 
      destination.push_back(',');
 
229
      destination->push_back(',');
288
230
    
289
 
    destination.push_back(quoted_identifier);
290
 
    destination.append(field_metadata.name());
291
 
    destination.push_back(quoted_identifier);
 
231
    destination->push_back(quoted_identifier);
 
232
    destination->append(field_metadata.name());
 
233
    destination->push_back(quoted_identifier);
292
234
  }
293
235
 
294
236
  return NONE;
295
237
}
296
238
 
297
 
enum TransformSqlError
298
 
transformInsertRecordToSql(const InsertHeader &header,
299
 
                           const InsertRecord &record,
300
 
                           string &destination,
301
 
                           enum TransformSqlVariant sql_variant)
 
239
enum message::TransformSqlError
 
240
message::transformInsertRecordToSql(const message::InsertHeader &header,
 
241
                                    const message::InsertRecord &record,
 
242
                                    std::string *destination,
 
243
                                    enum message::TransformSqlVariant sql_variant)
302
244
{
303
 
  enum TransformSqlError error= transformInsertHeaderToSql(header,
304
 
                                                           destination,
305
 
                                                           sql_variant);
 
245
  enum message::TransformSqlError error= transformInsertHeaderToSql(header,
 
246
                                                                    destination,
 
247
                                                                    sql_variant);
306
248
 
307
249
  char quoted_identifier= '`';
308
250
  if (sql_variant == ANSI)
309
251
    quoted_identifier= '"';
310
252
 
311
 
  destination.append(") VALUES (");
 
253
  destination->append(") VALUES (");
312
254
 
313
255
  /* Add insert values */
314
256
  size_t num_fields= header.field_metadata_size();
318
260
  for (x= 0; x < num_fields; ++x)
319
261
  {
320
262
    if (x != 0)
321
 
      destination.push_back(',');
322
 
 
323
 
    const FieldMetadata &field_metadata= header.field_metadata(x);
324
 
 
325
 
    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
326
 
 
327
 
    if (should_quote_field_value)
328
 
      destination.push_back('\'');
329
 
 
330
 
    if (field_metadata.type() == Table::Field::BLOB)
331
 
    {
332
 
      /* 
333
 
        * We do this here because BLOB data is returned
334
 
        * in a string correctly, but calling append()
335
 
        * without a length will result in only the string
336
 
        * up to a \0 being output here.
337
 
        */
338
 
      string raw_data(record.insert_value(x));
339
 
      destination.append(raw_data.c_str(), raw_data.size());
340
 
    }
341
 
    else
342
 
    {
343
 
      destination.append(record.insert_value(x));
344
 
    }
345
 
 
346
 
    if (should_quote_field_value)
347
 
      destination.push_back('\'');
 
263
      destination->push_back(',');
 
264
 
 
265
    should_quote_field_value= message::shouldQuoteFieldValue(header.field_metadata(x).type());
 
266
 
 
267
    if (should_quote_field_value)
 
268
      destination->push_back('\'');
 
269
 
 
270
    destination->append(record.insert_value(x));
 
271
 
 
272
    if (should_quote_field_value)
 
273
      destination->push_back('\'');
348
274
  }
349
 
  destination.push_back(')');
 
275
  destination->push_back(')');
350
276
 
351
277
  return error;
352
278
}
353
279
 
354
 
enum TransformSqlError
355
 
transformInsertStatementToSql(const InsertHeader &header,
356
 
                              const InsertData &data,
357
 
                              string &destination,
358
 
                              enum TransformSqlVariant sql_variant)
 
280
enum message::TransformSqlError
 
281
message::transformInsertStatementToSql(const message::InsertHeader &header,
 
282
                                       const message::InsertData &data,
 
283
                                       std::string *destination,
 
284
                                       enum message::TransformSqlVariant sql_variant)
359
285
{
360
 
  enum TransformSqlError error= transformInsertHeaderToSql(header,
361
 
                                                           destination,
362
 
                                                           sql_variant);
 
286
  enum message::TransformSqlError error= transformInsertHeaderToSql(header,
 
287
                                                                    destination,
 
288
                                                                    sql_variant);
363
289
 
364
290
  char quoted_identifier= '`';
365
291
  if (sql_variant == ANSI)
366
292
    quoted_identifier= '"';
367
293
 
368
 
  destination.append(") VALUES (", 10);
 
294
  destination->append(") VALUES (");
369
295
 
370
296
  /* Add insert values */
371
297
  size_t num_records= data.record_size();
376
302
  for (x= 0; x < num_records; ++x)
377
303
  {
378
304
    if (x != 0)
379
 
      destination.append("),(", 3);
 
305
      destination->append("),(");
380
306
 
381
307
    for (y= 0; y < num_fields; ++y)
382
308
    {
383
309
      if (y != 0)
384
 
        destination.push_back(',');
385
 
 
386
 
      const FieldMetadata &field_metadata= header.field_metadata(y);
387
 
      
388
 
      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
389
 
 
390
 
      if (should_quote_field_value)
391
 
        destination.push_back('\'');
392
 
 
393
 
      if (field_metadata.type() == Table::Field::BLOB)
394
 
      {
395
 
        /* 
396
 
         * We do this here because BLOB data is returned
397
 
         * in a string correctly, but calling append()
398
 
         * without a length will result in only the string
399
 
         * up to a \0 being output here.
400
 
         */
401
 
        string raw_data(data.record(x).insert_value(y));
402
 
        destination.append(raw_data.c_str(), raw_data.size());
403
 
      }
404
 
      else
405
 
      {
406
 
        destination.append(data.record(x).insert_value(y));
407
 
      }
408
 
 
409
 
      if (should_quote_field_value)
410
 
        destination.push_back('\'');
 
310
        destination->push_back(',');
 
311
 
 
312
      should_quote_field_value= message::shouldQuoteFieldValue(header.field_metadata(y).type());
 
313
 
 
314
      if (should_quote_field_value)
 
315
        destination->push_back('\'');
 
316
 
 
317
      destination->append(data.record(x).insert_value(y));
 
318
 
 
319
      if (should_quote_field_value)
 
320
        destination->push_back('\'');
411
321
    }
412
322
  }
413
 
  destination.push_back(')');
 
323
  destination->push_back(')');
414
324
 
415
325
  return error;
416
326
}
417
327
 
418
 
enum TransformSqlError
419
 
transformUpdateHeaderToSql(const UpdateHeader &header,
420
 
                           string &destination,
421
 
                           enum TransformSqlVariant sql_variant)
422
 
{
423
 
  char quoted_identifier= '`';
424
 
  if (sql_variant == ANSI)
425
 
    quoted_identifier= '"';
426
 
 
427
 
  destination.assign("UPDATE ", 7);
428
 
  destination.push_back(quoted_identifier);
429
 
  destination.append(header.table_metadata().schema_name());
430
 
  destination.push_back(quoted_identifier);
431
 
  destination.push_back('.');
432
 
  destination.push_back(quoted_identifier);
433
 
  destination.append(header.table_metadata().table_name());
434
 
  destination.push_back(quoted_identifier);
435
 
  destination.append(" SET ", 5);
436
 
 
437
 
  return NONE;
438
 
}
439
 
 
440
 
enum TransformSqlError
441
 
transformUpdateRecordToSql(const UpdateHeader &header,
442
 
                           const UpdateRecord &record,
443
 
                           string &destination,
444
 
                           enum TransformSqlVariant sql_variant)
445
 
{
446
 
  enum TransformSqlError error= transformUpdateHeaderToSql(header,
447
 
                                                           destination,
448
 
                                                           sql_variant);
449
 
 
450
 
  char quoted_identifier= '`';
451
 
  if (sql_variant == ANSI)
452
 
    quoted_identifier= '"';
 
328
enum message::TransformSqlError
 
329
message::transformUpdateHeaderToSql(const message::UpdateHeader &header,
 
330
                                    std::string *destination,
 
331
                                    enum message::TransformSqlVariant sql_variant)
 
332
{
 
333
  char quoted_identifier= '`';
 
334
  if (sql_variant == ANSI)
 
335
    quoted_identifier= '"';
 
336
 
 
337
  destination->assign("UPDATE ");
 
338
  destination->push_back(quoted_identifier);
 
339
  destination->append(header.table_metadata().schema_name());
 
340
  destination->push_back(quoted_identifier);
 
341
  destination->push_back('.');
 
342
  destination->push_back(quoted_identifier);
 
343
  destination->append(header.table_metadata().table_name());
 
344
  destination->push_back(quoted_identifier);
 
345
  destination->append(" SET ");
453
346
 
454
347
  /* Add field SET list to SQL string... */
455
348
  size_t num_set_fields= header.set_field_metadata_size();
458
351
 
459
352
  for (x= 0; x < num_set_fields; ++x)
460
353
  {
461
 
    const FieldMetadata &field_metadata= header.set_field_metadata(x);
 
354
    const message::FieldMetadata &field_metadata= header.set_field_metadata(x);
462
355
    if (x != 0)
463
 
      destination.push_back(',');
 
356
      destination->push_back(',');
464
357
    
465
 
    destination.push_back(quoted_identifier);
466
 
    destination.append(field_metadata.name());
467
 
    destination.push_back(quoted_identifier);
468
 
    destination.push_back('=');
469
 
 
470
 
    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
471
 
 
472
 
    if (should_quote_field_value)
473
 
      destination.push_back('\'');
474
 
 
475
 
    if (field_metadata.type() == Table::Field::BLOB)
476
 
    {
477
 
      /* 
478
 
       * We do this here because BLOB data is returned
479
 
       * in a string correctly, but calling append()
480
 
       * without a length will result in only the string
481
 
       * up to a \0 being output here.
482
 
       */
483
 
      string raw_data(record.after_value(x));
484
 
      destination.append(raw_data.c_str(), raw_data.size());
485
 
    }
486
 
    else
487
 
    {
488
 
      destination.append(record.after_value(x));
489
 
    }
490
 
 
491
 
    if (should_quote_field_value)
492
 
      destination.push_back('\'');
 
358
    destination->push_back(quoted_identifier);
 
359
    destination->append(field_metadata.name());
 
360
    destination->push_back(quoted_identifier);
 
361
    destination->push_back('=');
 
362
 
 
363
    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
 
364
 
 
365
    if (should_quote_field_value)
 
366
      destination->push_back('\'');
 
367
 
 
368
    destination->append(header.set_value(x));
 
369
 
 
370
    if (should_quote_field_value)
 
371
      destination->push_back('\'');
493
372
  }
494
373
 
 
374
  return NONE;
 
375
}
 
376
 
 
377
enum message::TransformSqlError
 
378
message::transformUpdateRecordToSql(const message::UpdateHeader &header,
 
379
                                    const message::UpdateRecord &record,
 
380
                                    std::string *destination,
 
381
                                    enum message::TransformSqlVariant sql_variant)
 
382
{
 
383
  enum message::TransformSqlError error= transformUpdateHeaderToSql(header,
 
384
                                                                    destination,
 
385
                                                                    sql_variant);
 
386
 
 
387
  char quoted_identifier= '`';
 
388
  if (sql_variant == ANSI)
 
389
    quoted_identifier= '"';
 
390
 
495
391
  size_t num_key_fields= header.key_field_metadata_size();
 
392
  size_t x;
 
393
  bool should_quote_field_value= false;
496
394
 
497
 
  destination.append(" WHERE ", 7);
 
395
  destination->append(" WHERE ");
498
396
  for (x= 0; x < num_key_fields; ++x) 
499
397
  {
500
 
    const FieldMetadata &field_metadata= header.key_field_metadata(x);
 
398
    const message::FieldMetadata &field_metadata= header.key_field_metadata(x);
501
399
    
502
400
    if (x != 0)
503
 
      destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
504
 
 
505
 
    destination.push_back(quoted_identifier);
506
 
    destination.append(field_metadata.name());
507
 
    destination.push_back(quoted_identifier);
508
 
 
509
 
    destination.push_back('=');
510
 
 
511
 
    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
512
 
 
513
 
    if (should_quote_field_value)
514
 
      destination.push_back('\'');
515
 
 
516
 
    if (field_metadata.type() == Table::Field::BLOB)
517
 
    {
518
 
      /* 
519
 
       * We do this here because BLOB data is returned
520
 
       * in a string correctly, but calling append()
521
 
       * without a length will result in only the string
522
 
       * up to a \0 being output here.
523
 
       */
524
 
      string raw_data(record.key_value(x));
525
 
      destination.append(raw_data.c_str(), raw_data.size());
526
 
    }
527
 
    else
528
 
    {
529
 
      destination.append(record.key_value(x));
530
 
    }
531
 
 
532
 
    if (should_quote_field_value)
533
 
      destination.push_back('\'');
534
 
  }
535
 
 
536
 
  return error;
537
 
}
538
 
 
539
 
enum TransformSqlError
540
 
transformDeleteHeaderToSql(const DeleteHeader &header,
541
 
                           string &destination,
542
 
                           enum TransformSqlVariant sql_variant)
543
 
{
544
 
  char quoted_identifier= '`';
545
 
  if (sql_variant == ANSI)
546
 
    quoted_identifier= '"';
547
 
 
548
 
  destination.assign("DELETE FROM ", 12);
549
 
  destination.push_back(quoted_identifier);
550
 
  destination.append(header.table_metadata().schema_name());
551
 
  destination.push_back(quoted_identifier);
552
 
  destination.push_back('.');
553
 
  destination.push_back(quoted_identifier);
554
 
  destination.append(header.table_metadata().table_name());
555
 
  destination.push_back(quoted_identifier);
 
401
      destination->append(" AND "); /* Always AND condition with a multi-column PK */
 
402
 
 
403
    destination->push_back(quoted_identifier);
 
404
    destination->append(field_metadata.name());
 
405
    destination->push_back(quoted_identifier);
 
406
 
 
407
    destination->push_back('=');
 
408
 
 
409
    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
 
410
 
 
411
    if (should_quote_field_value)
 
412
      destination->push_back('\'');
 
413
 
 
414
    destination->append(record.key_value(x));
 
415
 
 
416
    if (should_quote_field_value)
 
417
      destination->push_back('\'');
 
418
  }
 
419
  if (num_key_fields > 1)
 
420
    destination->push_back(')');
 
421
 
 
422
  return error;
 
423
}
 
424
 
 
425
enum message::TransformSqlError
 
426
message::transformUpdateStatementToSql(const message::UpdateHeader &header,
 
427
                                       const message::UpdateData &data,
 
428
                                       std::string *destination,
 
429
                                       enum message::TransformSqlVariant sql_variant)
 
430
{
 
431
  enum message::TransformSqlError error= transformUpdateHeaderToSql(header,
 
432
                                                                    destination,
 
433
                                                                    sql_variant);
 
434
 
 
435
  char quoted_identifier= '`';
 
436
  if (sql_variant == ANSI)
 
437
    quoted_identifier= '"';
 
438
 
 
439
  /* Add WHERE clause to SQL string... */
 
440
  size_t num_key_fields= header.key_field_metadata_size();
 
441
  size_t num_key_records= data.record_size();
 
442
  size_t x, y;
 
443
  bool should_quote_field_value= false;
 
444
 
 
445
  destination->append(" WHERE ");
 
446
  for (x= 0; x < num_key_records; ++x)
 
447
  {
 
448
    if (x != 0)
 
449
      destination->append(" OR "); /* Always OR condition for multiple key records */
 
450
 
 
451
    if (num_key_fields > 1)
 
452
      destination->push_back('(');
 
453
 
 
454
    for (y= 0; y < num_key_fields; ++y) 
 
455
    {
 
456
      const message::FieldMetadata &field_metadata= header.key_field_metadata(y);
 
457
      
 
458
      if (y != 0)
 
459
        destination->append(" AND "); /* Always AND condition with a multi-column PK */
 
460
 
 
461
      destination->push_back(quoted_identifier);
 
462
      destination->append(field_metadata.name());
 
463
      destination->push_back(quoted_identifier);
 
464
 
 
465
      destination->push_back('=');
 
466
 
 
467
      should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
 
468
 
 
469
      if (should_quote_field_value)
 
470
        destination->push_back('\'');
 
471
 
 
472
      destination->append(data.record(x).key_value(y));
 
473
 
 
474
      if (should_quote_field_value)
 
475
        destination->push_back('\'');
 
476
    }
 
477
    if (num_key_fields > 1)
 
478
      destination->push_back(')');
 
479
  }
 
480
  return error;
 
481
}
 
482
 
 
483
enum message::TransformSqlError
 
484
message::transformDeleteHeaderToSql(const message::DeleteHeader &header,
 
485
                                    std::string *destination,
 
486
                                    enum message::TransformSqlVariant sql_variant)
 
487
{
 
488
  char quoted_identifier= '`';
 
489
  if (sql_variant == ANSI)
 
490
    quoted_identifier= '"';
 
491
 
 
492
  destination->assign("DELETE FROM ");
 
493
  destination->push_back(quoted_identifier);
 
494
  destination->append(header.table_metadata().schema_name());
 
495
  destination->push_back(quoted_identifier);
 
496
  destination->push_back('.');
 
497
  destination->push_back(quoted_identifier);
 
498
  destination->append(header.table_metadata().table_name());
 
499
  destination->push_back(quoted_identifier);
556
500
 
557
501
  return NONE;
558
502
}
559
503
 
560
 
enum TransformSqlError
561
 
transformDeleteRecordToSql(const DeleteHeader &header,
562
 
                           const DeleteRecord &record,
563
 
                           string &destination,
564
 
                           enum TransformSqlVariant sql_variant)
 
504
enum message::TransformSqlError
 
505
message::transformDeleteRecordToSql(const message::DeleteHeader &header,
 
506
                                    const message::DeleteRecord &record,
 
507
                                    std::string *destination,
 
508
                                    enum message::TransformSqlVariant sql_variant)
565
509
{
566
 
  enum TransformSqlError error= transformDeleteHeaderToSql(header,
567
 
                                                           destination,
568
 
                                                           sql_variant);
 
510
  enum message::TransformSqlError error= transformDeleteHeaderToSql(header,
 
511
                                                                    destination,
 
512
                                                                    sql_variant);
569
513
  char quoted_identifier= '`';
570
514
  if (sql_variant == ANSI)
571
515
    quoted_identifier= '"';
575
519
  uint32_t x;
576
520
  bool should_quote_field_value= false;
577
521
 
578
 
  destination.append(" WHERE ", 7);
 
522
  destination->append(" WHERE ");
579
523
  for (x= 0; x < num_key_fields; ++x) 
580
524
  {
581
 
    const FieldMetadata &field_metadata= header.key_field_metadata(x);
 
525
    const message::FieldMetadata &field_metadata= header.key_field_metadata(x);
582
526
    
583
527
    if (x != 0)
584
 
      destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
585
 
 
586
 
    destination.push_back(quoted_identifier);
587
 
    destination.append(field_metadata.name());
588
 
    destination.push_back(quoted_identifier);
589
 
 
590
 
    destination.push_back('=');
591
 
 
592
 
    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
593
 
 
594
 
    if (should_quote_field_value)
595
 
      destination.push_back('\'');
596
 
 
597
 
    if (field_metadata.type() == Table::Field::BLOB)
598
 
    {
599
 
      /* 
600
 
       * We do this here because BLOB data is returned
601
 
       * in a string correctly, but calling append()
602
 
       * without a length will result in only the string
603
 
       * up to a \0 being output here.
604
 
       */
605
 
      string raw_data(record.key_value(x));
606
 
      destination.append(raw_data.c_str(), raw_data.size());
607
 
    }
608
 
    else
609
 
    {
610
 
      destination.append(record.key_value(x));
611
 
    }
612
 
 
613
 
    if (should_quote_field_value)
614
 
      destination.push_back('\'');
 
528
      destination->append(" AND "); /* Always AND condition with a multi-column PK */
 
529
 
 
530
    destination->push_back(quoted_identifier);
 
531
    destination->append(field_metadata.name());
 
532
    destination->push_back(quoted_identifier);
 
533
 
 
534
    destination->push_back('=');
 
535
 
 
536
    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
 
537
 
 
538
    if (should_quote_field_value)
 
539
      destination->push_back('\'');
 
540
 
 
541
    destination->append(record.key_value(x));
 
542
 
 
543
    if (should_quote_field_value)
 
544
      destination->push_back('\'');
615
545
  }
 
546
  if (num_key_fields > 1)
 
547
    destination->push_back(')');
616
548
 
617
549
  return error;
618
550
}
619
551
 
620
 
enum TransformSqlError
621
 
transformDeleteStatementToSql(const DeleteHeader &header,
622
 
                              const DeleteData &data,
623
 
                              string &destination,
624
 
                              enum TransformSqlVariant sql_variant)
 
552
enum message::TransformSqlError
 
553
message::transformDeleteStatementToSql(const message::DeleteHeader &header,
 
554
                                       const message::DeleteData &data,
 
555
                                       std::string *destination,
 
556
                                       enum message::TransformSqlVariant sql_variant)
625
557
{
626
 
  enum TransformSqlError error= transformDeleteHeaderToSql(header,
627
 
                                                           destination,
628
 
                                                           sql_variant);
 
558
  enum message::TransformSqlError error= transformDeleteHeaderToSql(header,
 
559
                                                                    destination,
 
560
                                                                    sql_variant);
629
561
  char quoted_identifier= '`';
630
562
  if (sql_variant == ANSI)
631
563
    quoted_identifier= '"';
636
568
  uint32_t x, y;
637
569
  bool should_quote_field_value= false;
638
570
 
639
 
  destination.append(" WHERE ", 7);
 
571
  destination->append(" WHERE ");
640
572
  for (x= 0; x < num_key_records; ++x)
641
573
  {
642
574
    if (x != 0)
643
 
      destination.append(" OR ", 4); /* Always OR condition for multiple key records */
 
575
      destination->append(" OR "); /* Always OR condition for multiple key records */
644
576
 
645
577
    if (num_key_fields > 1)
646
 
      destination.push_back('(');
 
578
      destination->push_back('(');
647
579
 
648
580
    for (y= 0; y < num_key_fields; ++y) 
649
581
    {
650
 
      const FieldMetadata &field_metadata= header.key_field_metadata(y);
 
582
      const message::FieldMetadata &field_metadata= header.key_field_metadata(y);
651
583
      
652
584
      if (y != 0)
653
 
        destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
654
 
 
655
 
      destination.push_back(quoted_identifier);
656
 
      destination.append(field_metadata.name());
657
 
      destination.push_back(quoted_identifier);
658
 
 
659
 
      destination.push_back('=');
660
 
 
661
 
      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
662
 
 
663
 
      if (should_quote_field_value)
664
 
        destination.push_back('\'');
665
 
 
666
 
      if (field_metadata.type() == Table::Field::BLOB)
667
 
      {
668
 
        /* 
669
 
         * We do this here because BLOB data is returned
670
 
         * in a string correctly, but calling append()
671
 
         * without a length will result in only the string
672
 
         * up to a \0 being output here.
673
 
         */
674
 
        string raw_data(data.record(x).key_value(y));
675
 
        destination.append(raw_data.c_str(), raw_data.size());
676
 
      }
677
 
      else
678
 
      {
679
 
        destination.append(data.record(x).key_value(y));
680
 
      }
681
 
 
682
 
      if (should_quote_field_value)
683
 
        destination.push_back('\'');
 
585
        destination->append(" AND "); /* Always AND condition with a multi-column PK */
 
586
 
 
587
      destination->push_back(quoted_identifier);
 
588
      destination->append(field_metadata.name());
 
589
      destination->push_back(quoted_identifier);
 
590
 
 
591
      destination->push_back('=');
 
592
 
 
593
      should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
 
594
 
 
595
      if (should_quote_field_value)
 
596
        destination->push_back('\'');
 
597
 
 
598
      destination->append(data.record(x).key_value(y));
 
599
 
 
600
      if (should_quote_field_value)
 
601
        destination->push_back('\'');
684
602
    }
685
603
    if (num_key_fields > 1)
686
 
      destination.push_back(')');
 
604
      destination->push_back(')');
687
605
  }
688
606
  return error;
689
607
}
690
608
 
691
 
enum TransformSqlError
692
 
transformDropSchemaStatementToSql(const DropSchemaStatement &statement,
693
 
                                  string &destination,
694
 
                                  enum TransformSqlVariant sql_variant)
695
 
{
696
 
  char quoted_identifier= '`';
697
 
  if (sql_variant == ANSI)
698
 
    quoted_identifier= '"';
699
 
 
700
 
  destination.append("DROP SCHEMA ", 12);
701
 
  destination.push_back(quoted_identifier);
702
 
  destination.append(statement.schema_name());
703
 
  destination.push_back(quoted_identifier);
704
 
 
705
 
  return NONE;
706
 
}
707
 
 
708
 
enum TransformSqlError
709
 
transformCreateSchemaStatementToSql(const CreateSchemaStatement &statement,
710
 
                                    string &destination,
711
 
                                    enum TransformSqlVariant sql_variant)
712
 
{
713
 
  char quoted_identifier= '`';
714
 
  if (sql_variant == ANSI)
715
 
    quoted_identifier= '"';
716
 
 
717
 
  const Schema &schema= statement.schema();
718
 
 
719
 
  destination.append("CREATE SCHEMA ", 14);
720
 
  destination.push_back(quoted_identifier);
721
 
  destination.append(schema.name());
722
 
  destination.push_back(quoted_identifier);
723
 
 
724
 
  if (schema.has_collation())
725
 
  {
726
 
    destination.append(" COLLATE ", 9);
727
 
    destination.append(schema.collation());
728
 
  }
729
 
 
730
 
  return NONE;
731
 
}
732
 
 
733
 
enum TransformSqlError
734
 
transformDropTableStatementToSql(const DropTableStatement &statement,
735
 
                                 string &destination,
736
 
                                 enum TransformSqlVariant sql_variant)
737
 
{
738
 
  char quoted_identifier= '`';
739
 
  if (sql_variant == ANSI)
740
 
    quoted_identifier= '"';
741
 
 
742
 
  const TableMetadata &table_metadata= statement.table_metadata();
743
 
 
744
 
  destination.append("DROP TABLE ", 11);
745
 
 
746
 
  /* Add the IF EXISTS clause if necessary */
747
 
  if (statement.has_if_exists_clause() &&
748
 
      statement.if_exists_clause() == true)
749
 
  {
750
 
    destination.append("IF EXISTS ", 10);
751
 
  }
752
 
 
753
 
  destination.push_back(quoted_identifier);
754
 
  destination.append(table_metadata.schema_name());
755
 
  destination.push_back(quoted_identifier);
756
 
  destination.push_back('.');
757
 
  destination.push_back(quoted_identifier);
758
 
  destination.append(table_metadata.table_name());
759
 
  destination.push_back(quoted_identifier);
760
 
 
761
 
  return NONE;
762
 
}
763
 
 
764
 
enum TransformSqlError
765
 
transformTruncateTableStatementToSql(const TruncateTableStatement &statement,
766
 
                                     string &destination,
767
 
                                     enum TransformSqlVariant sql_variant)
768
 
{
769
 
  char quoted_identifier= '`';
770
 
  if (sql_variant == ANSI)
771
 
    quoted_identifier= '"';
772
 
 
773
 
  const TableMetadata &table_metadata= statement.table_metadata();
774
 
 
775
 
  destination.append("TRUNCATE TABLE ", 15);
776
 
  destination.push_back(quoted_identifier);
777
 
  destination.append(table_metadata.schema_name());
778
 
  destination.push_back(quoted_identifier);
779
 
  destination.push_back('.');
780
 
  destination.push_back(quoted_identifier);
781
 
  destination.append(table_metadata.table_name());
782
 
  destination.push_back(quoted_identifier);
783
 
 
784
 
  return NONE;
785
 
}
786
 
 
787
 
enum TransformSqlError
788
 
transformSetVariableStatementToSql(const SetVariableStatement &statement,
789
 
                                   string &destination,
790
 
                                   enum TransformSqlVariant sql_variant)
 
609
enum message::TransformSqlError
 
610
message::transformSetVariableStatementToSql(const message::SetVariableStatement &statement,
 
611
                                            std::string *destination,
 
612
                                            enum message::TransformSqlVariant sql_variant)
791
613
{
792
614
  (void) sql_variant;
793
 
  const FieldMetadata &variable_metadata= statement.variable_metadata();
794
 
  bool should_quote_field_value= shouldQuoteFieldValue(variable_metadata.type());
795
 
 
796
 
  destination.append("SET GLOBAL ", 11); /* Only global variables are replicated */
797
 
  destination.append(variable_metadata.name());
798
 
  destination.push_back('=');
799
 
 
800
 
  if (should_quote_field_value)
801
 
    destination.push_back('\'');
802
 
  
803
 
  destination.append(statement.variable_value());
804
 
 
805
 
  if (should_quote_field_value)
806
 
    destination.push_back('\'');
807
 
 
808
 
  return NONE;
809
 
}
810
 
 
811
 
enum TransformSqlError
812
 
transformCreateTableStatementToSql(const CreateTableStatement &statement,
813
 
                                   string &destination,
814
 
                                   enum TransformSqlVariant sql_variant)
815
 
{
816
 
  return transformTableDefinitionToSql(statement.table(), destination, sql_variant);
817
 
}
818
 
 
819
 
enum TransformSqlError
820
 
transformTableDefinitionToSql(const Table &table,
821
 
                              string &destination,
822
 
                              enum TransformSqlVariant sql_variant, bool with_schema)
823
 
{
824
 
  char quoted_identifier= '`';
825
 
  if (sql_variant == ANSI)
826
 
    quoted_identifier= '"';
827
 
 
828
 
  destination.append("CREATE ", 7);
829
 
 
830
 
  if (table.type() == Table::TEMPORARY)
831
 
    destination.append("TEMPORARY ", 10);
832
 
  
833
 
  destination.append("TABLE ", 6);
834
 
  if (with_schema)
835
 
  {
836
 
    destination.push_back(quoted_identifier);
837
 
    destination.append(table.schema());
838
 
    destination.push_back(quoted_identifier);
839
 
    destination.push_back('.');
840
 
  }
841
 
  destination.push_back(quoted_identifier);
842
 
  destination.append(table.name());
843
 
  destination.push_back(quoted_identifier);
844
 
  destination.append(" (\n", 3);
845
 
 
846
 
  enum TransformSqlError result= NONE;
847
 
  size_t num_fields= table.field_size();
848
 
  for (size_t x= 0; x < num_fields; ++x)
849
 
  {
850
 
    const Table::Field &field= table.field(x);
851
 
 
852
 
    if (x != 0)
853
 
      destination.append(",\n", 2);
854
 
 
855
 
    result= transformFieldDefinitionToSql(field, destination, sql_variant);
856
 
    
857
 
    if (result != NONE)
858
 
      return result;
859
 
  }
860
 
 
861
 
  size_t num_indexes= table.indexes_size();
862
 
  
863
 
  if (num_indexes > 0)
864
 
    destination.append(",\n", 2);
865
 
 
866
 
  for (size_t x= 0; x < num_indexes; ++x)
867
 
  {
868
 
    const message::Table::Index &index= table.indexes(x);
869
 
 
870
 
    if (x != 0)
871
 
      destination.append(",\n", 2);
872
 
 
873
 
    result= transformIndexDefinitionToSql(index, table, destination, sql_variant);
874
 
    
875
 
    if (result != NONE)
876
 
      return result;
877
 
  }
878
 
  destination.append("\n)", 2);
879
 
 
880
 
  /* Add ENGINE = " clause */
881
 
  if (table.has_engine())
882
 
  {
883
 
    const Table::StorageEngine &engine= table.engine();
884
 
    destination.append("\nENGINE = ", 10);
885
 
    destination.append(engine.name());
886
 
 
887
 
    size_t num_engine_options= engine.option_size();
888
 
    for (size_t x= 0; x < num_engine_options; ++x)
889
 
    {
890
 
      const Table::StorageEngine::EngineOption &option= engine.option(x);
891
 
      destination.push_back('\n');
892
 
      destination.append(option.option_name());
893
 
      destination.append(" = ", 3);
894
 
      destination.append(option.option_value());
895
 
      destination.push_back('\n');
896
 
    }
897
 
  }
898
 
 
899
 
  if (table.has_options())
900
 
    (void) transformTableOptionsToSql(table.options(), destination, sql_variant);
901
 
 
902
 
  return NONE;
903
 
}
904
 
 
905
 
enum TransformSqlError
906
 
transformTableOptionsToSql(const Table::TableOptions &options,
907
 
                           string &destination,
908
 
                           enum TransformSqlVariant sql_variant)
909
 
{
910
 
  if (sql_variant == ANSI)
911
 
    return NONE; /* ANSI does not support table options... */
912
 
 
913
 
  stringstream ss;
914
 
 
915
 
  if (options.has_comment())
916
 
  {
917
 
    destination.append("\nCOMMENT = '", 12);
918
 
    destination.append(options.comment());
919
 
    destination.push_back('\'');
920
 
  }
921
 
 
922
 
  if (options.has_collation())
923
 
  {
924
 
    destination.append("\nCOLLATE = ", 11);
925
 
    destination.append(options.collation());
926
 
  }
927
 
 
928
 
  if (options.has_auto_increment())
929
 
  {
930
 
    ss << options.auto_increment();
931
 
    destination.append("\nAUTOINCREMENT_OFFSET = ", 24);
932
 
    destination.append(ss.str());
933
 
    ss.clear();
934
 
  }
935
 
  
936
 
  if (options.has_row_type())
937
 
  {
938
 
    ss << options.row_type();
939
 
    destination.append("\nROW_TYPE = ", 12);
940
 
    destination.append(ss.str());
941
 
    ss.clear();
942
 
  }
943
 
 
944
 
  if (options.has_data_file_name())
945
 
  {
946
 
    destination.append("\nDATA_FILE_NAME = '", 19);
947
 
    destination.append(options.data_file_name());
948
 
    destination.push_back('\'');
949
 
  }
950
 
 
951
 
  if (options.has_index_file_name())
952
 
  {
953
 
    destination.append("\nINDEX_FILE_NAME = '", 20);
954
 
    destination.append(options.index_file_name());
955
 
    destination.push_back('\'');
956
 
  }
957
 
 
958
 
  if (options.has_max_rows())
959
 
  {
960
 
    ss << options.max_rows();
961
 
    destination.append("\nMAX_ROWS = ", 12);
962
 
    destination.append(ss.str());
963
 
    ss.clear();
964
 
  }
965
 
 
966
 
  if (options.has_min_rows())
967
 
  {
968
 
    ss << options.min_rows();
969
 
    destination.append("\nMIN_ROWS = ", 12);
970
 
    destination.append(ss.str());
971
 
    ss.clear();
972
 
  }
973
 
 
974
 
  if (options.has_auto_increment_value())
975
 
  {
976
 
    ss << options.auto_increment_value();
977
 
    destination.append("\nAUTO_INCREMENT = ", 18);
978
 
    destination.append(ss.str());
979
 
    ss.clear();
980
 
  }
981
 
 
982
 
  if (options.has_avg_row_length())
983
 
  {
984
 
    ss << options.avg_row_length();
985
 
    destination.append("\nAVG_ROW_LENGTH = ", 18);
986
 
    destination.append(ss.str());
987
 
    ss.clear();
988
 
  }
989
 
 
990
 
  if (options.has_key_block_size())
991
 
  {
992
 
    ss << options.key_block_size();
993
 
    destination.append("\nKEY_BLOCK_SIZE = ", 18);
994
 
    destination.append(ss.str());
995
 
    ss.clear();
996
 
  }
997
 
 
998
 
  if (options.has_block_size())
999
 
  {
1000
 
    ss << options.block_size();
1001
 
    destination.append("\nBLOCK_SIZE = ", 14);
1002
 
    destination.append(ss.str());
1003
 
    ss.clear();
1004
 
  }
1005
 
 
1006
 
  if (options.has_pack_keys() &&
1007
 
      options.pack_keys())
1008
 
    destination.append("\nPACK_KEYS = TRUE", 17);
1009
 
  if (options.has_pack_record() &&
1010
 
      options.pack_record())
1011
 
    destination.append("\nPACK_RECORD = TRUE", 19);
1012
 
  if (options.has_checksum() &&
1013
 
      options.checksum())
1014
 
    destination.append("\nCHECKSUM = TRUE", 16);
1015
 
  if (options.has_page_checksum() &&
1016
 
      options.page_checksum())
1017
 
    destination.append("\nPAGE_CHECKSUM = TRUE", 21);
1018
 
 
1019
 
  return NONE;
1020
 
}
1021
 
 
1022
 
enum TransformSqlError
1023
 
transformIndexDefinitionToSql(const Table::Index &index,
1024
 
                              const Table &table,
1025
 
                              string &destination,
1026
 
                              enum TransformSqlVariant sql_variant)
1027
 
{
1028
 
  char quoted_identifier= '`';
1029
 
  if (sql_variant == ANSI)
1030
 
    quoted_identifier= '"';
1031
 
 
1032
 
  if (index.is_primary())
1033
 
    destination.append("PRIMARY ", 8);
1034
 
  else if (index.is_unique())
1035
 
    destination.append("UNIQUE ", 7);
1036
 
 
1037
 
  destination.append("KEY ", 4);
1038
 
  destination.push_back(quoted_identifier);
1039
 
  destination.append(index.name());
1040
 
  destination.push_back(quoted_identifier);
1041
 
  destination.append(" (", 2);
1042
 
  
1043
 
  size_t num_parts= index.index_part_size();
1044
 
  for (size_t x= 0; x < num_parts; ++x)
1045
 
  {
1046
 
    const Table::Index::IndexPart &part= index.index_part(x);
1047
 
    const Table::Field &field= table.field(part.fieldnr());
1048
 
 
1049
 
    if (x != 0)
1050
 
      destination.push_back(',');
1051
 
    
1052
 
    destination.push_back(quoted_identifier);
1053
 
    destination.append(field.name());
1054
 
    destination.push_back(quoted_identifier);
1055
 
 
1056
 
    /* 
1057
 
     * If the index part's field type is VARCHAR or TEXT
1058
 
     * then check for a prefix length then is different
1059
 
     * from the field's full length...
1060
 
     */
1061
 
    if (field.type() == Table::Field::VARCHAR ||
1062
 
        field.type() == Table::Field::BLOB)
1063
 
    {
1064
 
      if (part.has_compare_length())
1065
 
      {
1066
 
        size_t compare_length_in_chars= part.compare_length();
1067
 
        
1068
 
        /* hack: compare_length() is bytes, not chars, but
1069
 
         * only for VARCHAR. Ass. */
1070
 
        if (field.type() == Table::Field::VARCHAR)
1071
 
          compare_length_in_chars/= 4;
1072
 
 
1073
 
        if (compare_length_in_chars != field.string_options().length())
1074
 
        {
1075
 
          stringstream ss;
1076
 
          destination.push_back('(');
1077
 
          ss << compare_length_in_chars;
1078
 
          destination.append(ss.str());
1079
 
          destination.push_back(')');
1080
 
        }
1081
 
      }
1082
 
    }
1083
 
  }
1084
 
  destination.push_back(')');
1085
 
 
1086
 
  return NONE;
1087
 
}
1088
 
 
1089
 
enum TransformSqlError
1090
 
transformFieldDefinitionToSql(const Table::Field &field,
1091
 
                              string &destination,
1092
 
                              enum TransformSqlVariant sql_variant)
1093
 
{
1094
 
  char quoted_identifier= '`';
1095
 
  if (sql_variant == ANSI)
1096
 
    quoted_identifier= '"';
1097
 
 
1098
 
  destination.push_back(quoted_identifier);
1099
 
  destination.append(field.name());
1100
 
  destination.push_back(quoted_identifier);
1101
 
 
1102
 
  Table::Field::FieldType field_type= field.type();
1103
 
 
1104
 
  switch (field_type)
1105
 
  {
1106
 
    case Table::Field::DOUBLE:
1107
 
    destination.append(" DOUBLE", 7);
1108
 
    break;
1109
 
  case Table::Field::VARCHAR:
1110
 
    {
1111
 
      destination.append(" VARCHAR(", 9);
1112
 
      stringstream ss;
1113
 
      ss << field.string_options().length() << ")";
1114
 
      destination.append(ss.str());
1115
 
    }
1116
 
    break;
1117
 
  case Table::Field::BLOB:
1118
 
    destination.append(" BLOB", 5);
1119
 
    break;
1120
 
  case Table::Field::ENUM:
1121
 
    {
1122
 
      size_t num_field_values= field.enumeration_values().field_value_size();
1123
 
      destination.append(" ENUM(", 6);
1124
 
      for (size_t x= 0; x < num_field_values; ++x)
1125
 
      {
1126
 
        const string &type= field.enumeration_values().field_value(x);
1127
 
 
1128
 
        if (x != 0)
1129
 
          destination.push_back(',');
1130
 
 
1131
 
        destination.push_back('\'');
1132
 
        destination.append(type);
1133
 
        destination.push_back('\'');
1134
 
      }
1135
 
      destination.push_back(')');
1136
 
      break;
1137
 
    }
1138
 
  case Table::Field::INTEGER:
1139
 
    destination.append(" INT", 4);
1140
 
    break;
1141
 
  case Table::Field::BIGINT:
1142
 
    destination.append(" BIGINT", 7);
1143
 
    break;
1144
 
  case Table::Field::DECIMAL:
1145
 
    {
1146
 
      destination.append(" DECIMAL(", 9);
1147
 
      stringstream ss;
1148
 
      ss << field.numeric_options().precision() << ",";
1149
 
      ss << field.numeric_options().scale() << ")";
1150
 
      destination.append(ss.str());
1151
 
    }
1152
 
    break;
1153
 
  case Table::Field::DATE:
1154
 
    destination.append(" DATE", 5);
1155
 
    break;
1156
 
  case Table::Field::TIMESTAMP:
1157
 
    destination.append(" TIMESTAMP",  10);
1158
 
    break;
1159
 
  case Table::Field::DATETIME:
1160
 
    destination.append(" DATETIME",  9);
1161
 
    break;
1162
 
  }
1163
 
 
1164
 
  if (field.type() == Table::Field::INTEGER || 
1165
 
      field.type() == Table::Field::BIGINT)
1166
 
  {
1167
 
    if (field.has_constraints() &&
1168
 
        field.constraints().has_is_unsigned() &&
1169
 
        field.constraints().is_unsigned())
1170
 
    {
1171
 
      destination.append(" UNSIGNED", 9);
1172
 
    }
1173
 
  }
1174
 
 
1175
 
 
1176
 
  if (! (field.has_constraints() &&
1177
 
         field.constraints().is_nullable()))
1178
 
  {
1179
 
    destination.append(" NOT", 4);
1180
 
  }
1181
 
  destination.append(" NULL", 5);
1182
 
 
1183
 
  if (field.type() == Table::Field::INTEGER || 
1184
 
      field.type() == Table::Field::BIGINT)
1185
 
  {
1186
 
    /* AUTO_INCREMENT must be after NOT NULL */
1187
 
    if (field.has_numeric_options() &&
1188
 
        field.numeric_options().is_autoincrement())
1189
 
    {
1190
 
      destination.append(" AUTO_INCREMENT", 15);
1191
 
    }
1192
 
  }
1193
 
 
1194
 
  if (field.type() == Table::Field::BLOB ||
1195
 
      field.type() == Table::Field::VARCHAR)
1196
 
  {
1197
 
    if (field.string_options().has_collation())
1198
 
    {
1199
 
      destination.append(" COLLATE ", 9);
1200
 
      destination.append(field.string_options().collation());
1201
 
    }
1202
 
  }
1203
 
 
1204
 
  if (field.options().has_default_value())
1205
 
  {
1206
 
    destination.append(" DEFAULT ", 9);
1207
 
    destination.push_back(quoted_identifier);
1208
 
    destination.append(field.options().default_value());
1209
 
    destination.push_back(quoted_identifier);
1210
 
  }
1211
 
 
1212
 
  if (field.options().has_default_bin_value())
1213
 
  {
1214
 
    const string &v= field.options().default_bin_value();
1215
 
    destination.append(" DEFAULT 0x", 11);
1216
 
    for (size_t x= 0; x < v.length(); x++)
1217
 
    {
1218
 
      printf("%.2x", *(v.c_str() + x));
1219
 
    }
1220
 
  }
1221
 
 
1222
 
  if (field.type() == Table::Field::TIMESTAMP)
1223
 
    if (field.timestamp_options().has_auto_updates() &&
1224
 
        field.timestamp_options().auto_updates())
1225
 
      destination.append(" ON UPDATE CURRENT_TIMESTAMP", 28);
1226
 
 
1227
 
  if (field.has_comment())
1228
 
  {
1229
 
    destination.append(" COMMENT ", 9);
1230
 
    destination.push_back(quoted_identifier);
1231
 
    destination.append(field.comment());
1232
 
    destination.push_back(quoted_identifier);
1233
 
  }
1234
 
  return NONE;
1235
 
}
1236
 
 
1237
 
bool shouldQuoteFieldValue(Table::Field::FieldType in_type)
 
615
  const message::FieldMetadata &variable_metadata= statement.variable_metadata();
 
616
  bool should_quote_field_value= message::shouldQuoteFieldValue(variable_metadata.type());
 
617
 
 
618
  destination->append("SET GLOBAL "); /* Only global variables are replicated */
 
619
  destination->append(variable_metadata.name());
 
620
  destination->push_back('=');
 
621
 
 
622
  if (should_quote_field_value)
 
623
    destination->push_back('\'');
 
624
  
 
625
  destination->append(statement.variable_value());
 
626
 
 
627
  if (should_quote_field_value)
 
628
    destination->push_back('\'');
 
629
 
 
630
  return NONE;
 
631
}
 
632
 
 
633
bool message::shouldQuoteFieldValue(message::Table::Field::FieldType in_type)
1238
634
{
1239
635
  switch (in_type)
1240
636
  {
1241
 
  case Table::Field::DOUBLE:
1242
 
  case Table::Field::DECIMAL:
1243
 
  case Table::Field::INTEGER:
1244
 
  case Table::Field::BIGINT:
1245
 
  case Table::Field::ENUM:
 
637
  case message::Table::Field::DOUBLE:
 
638
  case message::Table::Field::DECIMAL:
 
639
  case message::Table::Field::INTEGER:
 
640
  case message::Table::Field::BIGINT:
 
641
  case message::Table::Field::ENUM:
1246
642
    return false;
1247
643
  default:
1248
644
    return true;
1249
645
  } 
1250
646
}
1251
 
 
1252
 
Table::Field::FieldType internalFieldTypeToFieldProtoType(enum enum_field_types type)
1253
 
{
1254
 
  switch (type) {
1255
 
  case DRIZZLE_TYPE_LONG:
1256
 
    return Table::Field::INTEGER;
1257
 
  case DRIZZLE_TYPE_DOUBLE:
1258
 
    return Table::Field::DOUBLE;
1259
 
  case DRIZZLE_TYPE_NULL:
1260
 
    assert(false); /* Not a user definable type */
1261
 
    return Table::Field::INTEGER; /* unreachable */
1262
 
  case DRIZZLE_TYPE_TIMESTAMP:
1263
 
    return Table::Field::TIMESTAMP;
1264
 
  case DRIZZLE_TYPE_LONGLONG:
1265
 
    return Table::Field::BIGINT;
1266
 
  case DRIZZLE_TYPE_DATETIME:
1267
 
    return Table::Field::DATETIME;
1268
 
  case DRIZZLE_TYPE_DATE:
1269
 
    return Table::Field::DATE;
1270
 
  case DRIZZLE_TYPE_VARCHAR:
1271
 
    return Table::Field::VARCHAR;
1272
 
  case DRIZZLE_TYPE_DECIMAL:
1273
 
    return Table::Field::DECIMAL;
1274
 
  case DRIZZLE_TYPE_ENUM:
1275
 
    return Table::Field::ENUM;
1276
 
  case DRIZZLE_TYPE_BLOB:
1277
 
    return Table::Field::BLOB;
1278
 
  }
1279
 
 
1280
 
  assert(false);
1281
 
  return Table::Field::INTEGER; /* unreachable */
1282
 
}
1283
 
 
1284
 
bool transactionContainsBulkSegment(const Transaction &transaction)
1285
 
{
1286
 
  size_t num_statements= transaction.statement_size();
1287
 
  if (num_statements == 0)
1288
 
    return false;
1289
 
 
1290
 
  /*
1291
 
   * Only INSERT, UPDATE, and DELETE statements can possibly
1292
 
   * have bulk segments.  So, we loop through the statements
1293
 
   * checking for segment_id > 1 in those specific submessages.
1294
 
   */
1295
 
  size_t x;
1296
 
  for (x= 0; x < num_statements; ++x)
1297
 
  {
1298
 
    const Statement &statement= transaction.statement(x);
1299
 
    Statement::Type type= statement.type();
1300
 
 
1301
 
    switch (type)
1302
 
    {
1303
 
      case Statement::INSERT:
1304
 
        if (statement.insert_data().segment_id() > 1)
1305
 
          return true;
1306
 
        break;
1307
 
      case Statement::UPDATE:
1308
 
        if (statement.update_data().segment_id() > 1)
1309
 
          return true;
1310
 
        break;
1311
 
      case Statement::DELETE:
1312
 
        if (statement.delete_data().segment_id() > 1)
1313
 
          return true;
1314
 
        break;
1315
 
      default:
1316
 
        break;
1317
 
    }
1318
 
  }
1319
 
  return false;
1320
 
}
1321
 
 
1322
 
} /* namespace message */
1323
 
} /* namespace drizzled */