← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/message/statement_transform.cc

  • Committer: Stewart Smith
  • Date: 2010-03-02 06:41:59 UTC
  • mto: (1309.2.13 build)
  • mto: This revision was merged to the branch mainline in revision 1318.
  • Revision ID: stewart@flamingspork.com-20100302064159-gktw6hcbs3u0fflm
move Item_result out to its own header file and out of common.h

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
31
30
 
32
31
#include "config.h"
33
32
 
34
 
#include <boost/lexical_cast.hpp>
35
33
#include "drizzled/message/statement_transform.h"
36
34
#include "drizzled/message/transaction.pb.h"
37
35
#include "drizzled/message/table.pb.h"
38
 
#include "drizzled/charset.h"
39
 
#include "drizzled/charset_info.h"
40
 
#include "drizzled/global_charset_info.h"
41
36
 
42
37
#include <string>
43
38
#include <vector>
44
 
#include <sstream>
45
 
#include <cstdio>
46
39
 
47
40
using namespace std;
48
41
 
49
42
namespace drizzled
50
43
{
51
44
 
52
 
namespace message
53
 
{
54
 
 
55
 
static void escapeEmbeddedQuotes(string &s, const char quote='\'')
56
 
{
57
 
  string::iterator it;
58
 
 
59
 
  for (it= s.begin(); it != s.end(); ++it)
60
 
  {
61
 
    if (*it == quote)
62
 
    {
63
 
      it= s.insert(it, quote);
64
 
      ++it;  // advance back to the quote
65
 
    }
66
 
  }
67
 
}
68
 
 
69
 
/* Incredibly similar to append_unescaped() in table.cc, but for std::string */
70
 
static void append_escaped_string(std::string *res, const std::string &input, const char quote='\'')
71
 
{
72
 
  const char *pos= input.c_str();
73
 
  const char *end= input.c_str()+input.length();
74
 
  res->push_back(quote);
75
 
 
76
 
  for (; pos != end ; pos++)
77
 
  {
78
 
    uint32_t mblen;
79
 
    if (use_mb(default_charset_info) &&
80
 
        (mblen= my_ismbchar(default_charset_info, pos, end)))
81
 
    {
82
 
      res->append(pos, mblen);
83
 
      pos+= mblen - 1;
84
 
      if (pos >= end)
85
 
        break;
86
 
      continue;
87
 
    }
88
 
 
89
 
    switch (*pos) {
90
 
    case 0:                             /* Must be escaped for 'mysql' */
91
 
      res->push_back('\\');
92
 
      res->push_back('0');
93
 
      break;
94
 
    case '\n':                          /* Must be escaped for logs */
95
 
      res->push_back('\\');
96
 
      res->push_back('n');
97
 
      break;
98
 
    case '\r':
99
 
      res->push_back('\\');             /* This gives better readability */
100
 
      res->push_back('r');
101
 
      break;
102
 
    case '\\':
103
 
      res->push_back('\\');             /* Because of the sql syntax */
104
 
      res->push_back('\\');
105
 
      break;
106
 
    default:
107
 
      if (*pos == quote) /* SQL syntax for quoting a quote */
108
 
      {
109
 
        res->push_back(quote);
110
 
        res->push_back(quote);
111
 
      }
112
 
      else
113
 
        res->push_back(*pos);
114
 
      break;
115
 
    }
116
 
  }
117
 
  res->push_back(quote);
118
 
}
119
 
 
120
 
enum TransformSqlError
121
 
transformStatementToSql(const Statement &source,
122
 
                        vector<string> &sql_strings,
123
 
                        enum TransformSqlVariant sql_variant,
124
 
                        bool already_in_transaction)
125
 
{
126
 
  TransformSqlError error= NONE;
 
45
enum message::TransformSqlError
 
46
message::transformStatementToSql(const message::Statement &source,
 
47
                                 vector<string> &sql_strings,
 
48
                                 enum message::TransformSqlVariant sql_variant,
 
49
                                 bool already_in_transaction)
 
50
{
 
51
  message::TransformSqlError error= NONE;
127
52
 
128
53
  switch (source.type())
129
54
  {
130
 
  case Statement::ROLLBACK_STATEMENT:
131
 
    {
132
 
      break;
133
 
    }
134
 
  case Statement::ROLLBACK:
135
 
    {
136
 
      sql_strings.push_back("ROLLBACK");
137
 
      break;
138
 
    }
139
 
  case Statement::INSERT:
 
55
  case message::Statement::INSERT:
140
56
    {
141
57
      if (! source.has_insert_header())
142
58
      {
149
65
        return error;
150
66
      }
151
67
 
152
 
      const InsertHeader &insert_header= source.insert_header();
153
 
      const InsertData &insert_data= source.insert_data();
 
68
      const message::InsertHeader &insert_header= source.insert_header();
 
69
      const message::InsertData &insert_data= source.insert_data();
154
70
      size_t num_keys= insert_data.record_size();
155
71
      size_t x;
156
72
 
163
79
 
164
80
        error= transformInsertRecordToSql(insert_header,
165
81
                                          insert_data.record(x),
166
 
                                          destination,
 
82
                                          &destination,
167
83
                                          sql_variant);
168
84
        if (error != NONE)
169
85
          break;
180
96
      }
181
97
    }
182
98
    break;
183
 
  case Statement::UPDATE:
 
99
  case message::Statement::UPDATE:
184
100
    {
185
101
      if (! source.has_update_header())
186
102
      {
193
109
        return error;
194
110
      }
195
111
 
196
 
      const UpdateHeader &update_header= source.update_header();
197
 
      const UpdateData &update_data= source.update_data();
 
112
      const message::UpdateHeader &update_header= source.update_header();
 
113
      const message::UpdateData &update_data= source.update_data();
198
114
      size_t num_keys= update_data.record_size();
199
115
      size_t x;
200
116
 
207
123
 
208
124
        error= transformUpdateRecordToSql(update_header,
209
125
                                          update_data.record(x),
210
 
                                          destination,
 
126
                                          &destination,
211
127
                                          sql_variant);
212
128
        if (error != NONE)
213
129
          break;
224
140
      }
225
141
    }
226
142
    break;
227
 
  case Statement::DELETE:
 
143
  case message::Statement::DELETE:
228
144
    {
229
145
      if (! source.has_delete_header())
230
146
      {
237
153
        return error;
238
154
      }
239
155
 
240
 
      const DeleteHeader &delete_header= source.delete_header();
241
 
      const DeleteData &delete_data= source.delete_data();
 
156
      const message::DeleteHeader &delete_header= source.delete_header();
 
157
      const message::DeleteData &delete_data= source.delete_data();
242
158
      size_t num_keys= delete_data.record_size();
243
159
      size_t x;
244
160
 
251
167
 
252
168
        error= transformDeleteRecordToSql(delete_header,
253
169
                                          delete_data.record(x),
254
 
                                          destination,
 
170
                                          &destination,
255
171
                                          sql_variant);
256
172
        if (error != NONE)
257
173
          break;
268
184
      }
269
185
    }
270
186
    break;
271
 
  case Statement::CREATE_TABLE:
272
 
    {
273
 
      assert(source.has_create_table_statement());
274
 
      string destination;
275
 
      error= transformCreateTableStatementToSql(source.create_table_statement(),
276
 
                                                destination,
277
 
                                                sql_variant);
278
 
      sql_strings.push_back(destination);
279
 
    }
280
 
    break;
281
 
  case Statement::TRUNCATE_TABLE:
 
187
  case message::Statement::TRUNCATE_TABLE:
282
188
    {
283
189
      assert(source.has_truncate_table_statement());
284
190
      string destination;
285
 
      error= transformTruncateTableStatementToSql(source.truncate_table_statement(),
286
 
                                                  destination,
287
 
                                                  sql_variant);
288
 
      sql_strings.push_back(destination);
289
 
    }
290
 
    break;
291
 
  case Statement::DROP_TABLE:
292
 
    {
293
 
      assert(source.has_drop_table_statement());
294
 
      string destination;
295
 
      error= transformDropTableStatementToSql(source.drop_table_statement(),
296
 
                                              destination,
297
 
                                              sql_variant);
298
 
      sql_strings.push_back(destination);
299
 
    }
300
 
    break;
301
 
  case Statement::CREATE_SCHEMA:
302
 
    {
303
 
      assert(source.has_create_schema_statement());
304
 
      string destination;
305
 
      error= transformCreateSchemaStatementToSql(source.create_schema_statement(),
306
 
                                                 destination,
307
 
                                                 sql_variant);
308
 
      sql_strings.push_back(destination);
309
 
    }
310
 
    break;
311
 
  case Statement::DROP_SCHEMA:
312
 
    {
313
 
      assert(source.has_drop_schema_statement());
314
 
      string destination;
315
 
      error= transformDropSchemaStatementToSql(source.drop_schema_statement(),
316
 
                                               destination,
317
 
                                               sql_variant);
318
 
      sql_strings.push_back(destination);
319
 
    }
320
 
    break;
321
 
  case Statement::SET_VARIABLE:
 
191
      error= message::transformTruncateTableStatementToSql(source.truncate_table_statement(),
 
192
                                                           &destination,
 
193
                                                           sql_variant);
 
194
      sql_strings.push_back(destination);
 
195
    }
 
196
    break;
 
197
  case message::Statement::SET_VARIABLE:
322
198
    {
323
199
      assert(source.has_set_variable_statement());
324
200
      string destination;
325
 
      error= transformSetVariableStatementToSql(source.set_variable_statement(),
326
 
                                                destination,
327
 
                                                sql_variant);
 
201
      error= message::transformSetVariableStatementToSql(source.set_variable_statement(),
 
202
                                                       &destination,
 
203
                                                       sql_variant);
328
204
      sql_strings.push_back(destination);
329
205
    }
330
206
    break;
331
 
  case Statement::RAW_SQL:
 
207
  case message::Statement::RAW_SQL:
332
208
  default:
333
209
    sql_strings.push_back(source.sql());
334
210
    break;
336
212
  return error;
337
213
}
338
214
 
339
 
enum TransformSqlError
340
 
transformInsertHeaderToSql(const InsertHeader &header,
341
 
                           string &destination,
342
 
                           enum TransformSqlVariant sql_variant)
 
215
enum message::TransformSqlError
 
216
message::transformInsertHeaderToSql(const message::InsertHeader &header,
 
217
                                    std::string *destination,
 
218
                                    enum message::TransformSqlVariant sql_variant)
343
219
{
344
220
  char quoted_identifier= '`';
345
221
  if (sql_variant == ANSI)
346
222
    quoted_identifier= '"';
347
223
 
348
 
  destination.assign("INSERT INTO ", 12);
349
 
  destination.push_back(quoted_identifier);
350
 
  destination.append(header.table_metadata().schema_name());
351
 
  destination.push_back(quoted_identifier);
352
 
  destination.push_back('.');
353
 
  destination.push_back(quoted_identifier);
354
 
  destination.append(header.table_metadata().table_name());
355
 
  destination.push_back(quoted_identifier);
356
 
  destination.append(" (", 2);
 
224
  destination->assign("INSERT INTO ", 12);
 
225
  destination->push_back(quoted_identifier);
 
226
  destination->append(header.table_metadata().schema_name());
 
227
  destination->push_back(quoted_identifier);
 
228
  destination->push_back('.');
 
229
  destination->push_back(quoted_identifier);
 
230
  destination->append(header.table_metadata().table_name());
 
231
  destination->push_back(quoted_identifier);
 
232
  destination->append(" (", 2);
357
233
 
358
234
  /* Add field list to SQL string... */
359
235
  size_t num_fields= header.field_metadata_size();
361
237
 
362
238
  for (x= 0; x < num_fields; ++x)
363
239
  {
364
 
    const FieldMetadata &field_metadata= header.field_metadata(x);
 
240
    const message::FieldMetadata &field_metadata= header.field_metadata(x);
365
241
    if (x != 0)
366
 
      destination.push_back(',');
 
242
      destination->push_back(',');
367
243
    
368
 
    destination.push_back(quoted_identifier);
369
 
    destination.append(field_metadata.name());
370
 
    destination.push_back(quoted_identifier);
 
244
    destination->push_back(quoted_identifier);
 
245
    destination->append(field_metadata.name());
 
246
    destination->push_back(quoted_identifier);
371
247
  }
372
248
 
373
249
  return NONE;
374
250
}
375
251
 
376
 
enum TransformSqlError
377
 
transformInsertRecordToSql(const InsertHeader &header,
378
 
                           const InsertRecord &record,
379
 
                           string &destination,
380
 
                           enum TransformSqlVariant sql_variant)
 
252
enum message::TransformSqlError
 
253
message::transformInsertRecordToSql(const message::InsertHeader &header,
 
254
                                    const message::InsertRecord &record,
 
255
                                    std::string *destination,
 
256
                                    enum message::TransformSqlVariant sql_variant)
381
257
{
382
 
  enum TransformSqlError error= transformInsertHeaderToSql(header,
383
 
                                                           destination,
384
 
                                                           sql_variant);
 
258
  enum message::TransformSqlError error= transformInsertHeaderToSql(header,
 
259
                                                                    destination,
 
260
                                                                    sql_variant);
385
261
 
386
262
  char quoted_identifier= '`';
387
263
  if (sql_variant == ANSI)
388
264
    quoted_identifier= '"';
389
265
 
390
 
  destination.append(") VALUES (");
 
266
  destination->append(") VALUES (");
391
267
 
392
268
  /* Add insert values */
393
269
  size_t num_fields= header.field_metadata_size();
397
273
  for (x= 0; x < num_fields; ++x)
398
274
  {
399
275
    if (x != 0)
400
 
      destination.push_back(',');
401
 
 
402
 
    const FieldMetadata &field_metadata= header.field_metadata(x);
403
 
 
404
 
    if (record.is_null(x))
405
 
    {
406
 
      should_quote_field_value= false;
407
 
    }
408
 
    else 
409
 
    {
410
 
      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
411
 
    }
 
276
      destination->push_back(',');
 
277
 
 
278
    const message::FieldMetadata &field_metadata= header.field_metadata(x);
 
279
 
 
280
    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
412
281
 
413
282
    if (should_quote_field_value)
414
 
      destination.push_back('\'');
 
283
      destination->push_back('\'');
415
284
 
416
 
    if (record.is_null(x))
 
285
    if (field_metadata.type() == message::Table::Field::BLOB)
417
286
    {
418
 
      destination.append("NULL");
 
287
      /* 
 
288
        * We do this here because BLOB data is returned
 
289
        * in a string correctly, but calling append()
 
290
        * without a length will result in only the string
 
291
        * up to a \0 being output here.
 
292
        */
 
293
      string raw_data(record.insert_value(x));
 
294
      destination->append(raw_data.c_str(), raw_data.size());
419
295
    }
420
296
    else
421
297
    {
422
 
      if (field_metadata.type() == Table::Field::BLOB)
423
 
      {
424
 
        /*
425
 
         * We do this here because BLOB data is returned
426
 
         * in a string correctly, but calling append()
427
 
         * without a length will result in only the string
428
 
         * up to a \0 being output here.
429
 
         */
430
 
        string raw_data(record.insert_value(x));
431
 
        destination.append(raw_data.c_str(), raw_data.size());
432
 
      }
433
 
      else
434
 
      {
435
 
        string tmp(record.insert_value(x));
436
 
        escapeEmbeddedQuotes(tmp);
437
 
        destination.append(tmp);
438
 
      }
 
298
      destination->append(record.insert_value(x));
439
299
    }
440
300
 
441
301
    if (should_quote_field_value)
442
 
      destination.push_back('\'');
 
302
      destination->push_back('\'');
443
303
  }
444
 
  destination.push_back(')');
 
304
  destination->push_back(')');
445
305
 
446
306
  return error;
447
307
}
448
308
 
449
 
enum TransformSqlError
450
 
transformInsertStatementToSql(const InsertHeader &header,
451
 
                              const InsertData &data,
452
 
                              string &destination,
453
 
                              enum TransformSqlVariant sql_variant)
 
309
enum message::TransformSqlError
 
310
message::transformInsertStatementToSql(const message::InsertHeader &header,
 
311
                                       const message::InsertData &data,
 
312
                                       std::string *destination,
 
313
                                       enum message::TransformSqlVariant sql_variant)
454
314
{
455
 
  enum TransformSqlError error= transformInsertHeaderToSql(header,
456
 
                                                           destination,
457
 
                                                           sql_variant);
 
315
  enum message::TransformSqlError error= transformInsertHeaderToSql(header,
 
316
                                                                    destination,
 
317
                                                                    sql_variant);
458
318
 
459
319
  char quoted_identifier= '`';
460
320
  if (sql_variant == ANSI)
461
321
    quoted_identifier= '"';
462
322
 
463
 
  destination.append(") VALUES (", 10);
 
323
  destination->append(") VALUES (", 10);
464
324
 
465
325
  /* Add insert values */
466
326
  size_t num_records= data.record_size();
471
331
  for (x= 0; x < num_records; ++x)
472
332
  {
473
333
    if (x != 0)
474
 
      destination.append("),(", 3);
 
334
      destination->append("),(", 3);
475
335
 
476
336
    for (y= 0; y < num_fields; ++y)
477
337
    {
478
338
      if (y != 0)
479
 
        destination.push_back(',');
 
339
        destination->push_back(',');
480
340
 
481
 
      const FieldMetadata &field_metadata= header.field_metadata(y);
 
341
      const message::FieldMetadata &field_metadata= header.field_metadata(y);
482
342
      
483
 
      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
343
      should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
484
344
 
485
345
      if (should_quote_field_value)
486
 
        destination.push_back('\'');
 
346
        destination->push_back('\'');
487
347
 
488
 
      if (field_metadata.type() == Table::Field::BLOB)
 
348
      if (field_metadata.type() == message::Table::Field::BLOB)
489
349
      {
490
350
        /* 
491
351
         * We do this here because BLOB data is returned
494
354
         * up to a \0 being output here.
495
355
         */
496
356
        string raw_data(data.record(x).insert_value(y));
497
 
        destination.append(raw_data.c_str(), raw_data.size());
 
357
        destination->append(raw_data.c_str(), raw_data.size());
498
358
      }
499
359
      else
500
360
      {
501
 
        string tmp(data.record(x).insert_value(y));
502
 
        escapeEmbeddedQuotes(tmp);
503
 
        destination.append(tmp);
 
361
        destination->append(data.record(x).insert_value(y));
504
362
      }
505
363
 
506
364
      if (should_quote_field_value)
507
 
        destination.push_back('\'');
 
365
        destination->push_back('\'');
508
366
    }
509
367
  }
510
 
  destination.push_back(')');
 
368
  destination->push_back(')');
511
369
 
512
370
  return error;
513
371
}
514
372
 
515
 
enum TransformSqlError
516
 
transformUpdateHeaderToSql(const UpdateHeader &header,
517
 
                           string &destination,
518
 
                           enum TransformSqlVariant sql_variant)
 
373
enum message::TransformSqlError
 
374
message::transformUpdateHeaderToSql(const message::UpdateHeader &header,
 
375
                                    std::string *destination,
 
376
                                    enum message::TransformSqlVariant sql_variant)
519
377
{
520
378
  char quoted_identifier= '`';
521
379
  if (sql_variant == ANSI)
522
380
    quoted_identifier= '"';
523
381
 
524
 
  destination.assign("UPDATE ", 7);
525
 
  destination.push_back(quoted_identifier);
526
 
  destination.append(header.table_metadata().schema_name());
527
 
  destination.push_back(quoted_identifier);
528
 
  destination.push_back('.');
529
 
  destination.push_back(quoted_identifier);
530
 
  destination.append(header.table_metadata().table_name());
531
 
  destination.push_back(quoted_identifier);
532
 
  destination.append(" SET ", 5);
 
382
  destination->assign("UPDATE ", 7);
 
383
  destination->push_back(quoted_identifier);
 
384
  destination->append(header.table_metadata().schema_name());
 
385
  destination->push_back(quoted_identifier);
 
386
  destination->push_back('.');
 
387
  destination->push_back(quoted_identifier);
 
388
  destination->append(header.table_metadata().table_name());
 
389
  destination->push_back(quoted_identifier);
 
390
  destination->append(" SET ", 5);
533
391
 
534
392
  return NONE;
535
393
}
536
394
 
537
 
enum TransformSqlError
538
 
transformUpdateRecordToSql(const UpdateHeader &header,
539
 
                           const UpdateRecord &record,
540
 
                           string &destination,
541
 
                           enum TransformSqlVariant sql_variant)
 
395
enum message::TransformSqlError
 
396
message::transformUpdateRecordToSql(const message::UpdateHeader &header,
 
397
                                    const message::UpdateRecord &record,
 
398
                                    std::string *destination,
 
399
                                    enum message::TransformSqlVariant sql_variant)
542
400
{
543
 
  enum TransformSqlError error= transformUpdateHeaderToSql(header,
544
 
                                                           destination,
545
 
                                                           sql_variant);
 
401
  enum message::TransformSqlError error= transformUpdateHeaderToSql(header,
 
402
                                                                    destination,
 
403
                                                                    sql_variant);
546
404
 
547
405
  char quoted_identifier= '`';
548
406
  if (sql_variant == ANSI)
555
413
 
556
414
  for (x= 0; x < num_set_fields; ++x)
557
415
  {
558
 
    const FieldMetadata &field_metadata= header.set_field_metadata(x);
 
416
    const message::FieldMetadata &field_metadata= header.set_field_metadata(x);
559
417
    if (x != 0)
560
 
      destination.push_back(',');
 
418
      destination->push_back(',');
561
419
    
562
 
    destination.push_back(quoted_identifier);
563
 
    destination.append(field_metadata.name());
564
 
    destination.push_back(quoted_identifier);
565
 
    destination.push_back('=');
566
 
 
567
 
    if (record.is_null(x))
568
 
    {
569
 
      should_quote_field_value= false;
570
 
    }
571
 
    else 
572
 
    {
573
 
      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
574
 
    }    
575
 
 
576
 
    if (should_quote_field_value)
577
 
      destination.push_back('\'');
578
 
 
579
 
    if (record.is_null(x))
580
 
    {
581
 
      destination.append("NULL");
582
 
    }
583
 
    else 
584
 
    {
585
 
      if (field_metadata.type() == Table::Field::BLOB)
586
 
      {
587
 
        /*
588
 
         * We do this here because BLOB data is returned
589
 
         * in a string correctly, but calling append()
590
 
         * without a length will result in only the string
591
 
         * up to a \0 being output here.
592
 
         */
593
 
        string raw_data(record.after_value(x));
594
 
        destination.append(raw_data.c_str(), raw_data.size());
595
 
      }
596
 
      else 
597
 
      {
598
 
        string tmp(record.after_value(x));
599
 
        escapeEmbeddedQuotes(tmp);
600
 
        destination.append(tmp);
601
 
      }
602
 
    }
603
 
 
604
 
    if (should_quote_field_value)
605
 
      destination.push_back('\'');
 
420
    destination->push_back(quoted_identifier);
 
421
    destination->append(field_metadata.name());
 
422
    destination->push_back(quoted_identifier);
 
423
    destination->push_back('=');
 
424
 
 
425
    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
 
426
 
 
427
    if (should_quote_field_value)
 
428
      destination->push_back('\'');
 
429
 
 
430
    if (field_metadata.type() == message::Table::Field::BLOB)
 
431
    {
 
432
      /* 
 
433
       * We do this here because BLOB data is returned
 
434
       * in a string correctly, but calling append()
 
435
       * without a length will result in only the string
 
436
       * up to a \0 being output here.
 
437
       */
 
438
      string raw_data(record.after_value(x));
 
439
      destination->append(raw_data.c_str(), raw_data.size());
 
440
    }
 
441
    else
 
442
    {
 
443
      destination->append(record.after_value(x));
 
444
    }
 
445
 
 
446
    if (should_quote_field_value)
 
447
      destination->push_back('\'');
606
448
  }
607
449
 
608
450
  size_t num_key_fields= header.key_field_metadata_size();
609
451
 
610
 
  destination.append(" WHERE ", 7);
 
452
  destination->append(" WHERE ", 7);
611
453
  for (x= 0; x < num_key_fields; ++x) 
612
454
  {
613
 
    const FieldMetadata &field_metadata= header.key_field_metadata(x);
 
455
    const message::FieldMetadata &field_metadata= header.key_field_metadata(x);
614
456
    
615
457
    if (x != 0)
616
 
      destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
617
 
 
618
 
    destination.push_back(quoted_identifier);
619
 
    destination.append(field_metadata.name());
620
 
    destination.push_back(quoted_identifier);
621
 
 
622
 
    destination.push_back('=');
623
 
 
624
 
    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
458
      destination->append(" AND ", 5); /* Always AND condition with a multi-column PK */
 
459
 
 
460
    destination->push_back(quoted_identifier);
 
461
    destination->append(field_metadata.name());
 
462
    destination->push_back(quoted_identifier);
 
463
 
 
464
    destination->push_back('=');
 
465
 
 
466
    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
625
467
 
626
468
    if (should_quote_field_value)
627
 
      destination.push_back('\'');
 
469
      destination->push_back('\'');
628
470
 
629
 
    if (field_metadata.type() == Table::Field::BLOB)
 
471
    if (field_metadata.type() == message::Table::Field::BLOB)
630
472
    {
631
473
      /* 
632
474
       * We do this here because BLOB data is returned
635
477
       * up to a \0 being output here.
636
478
       */
637
479
      string raw_data(record.key_value(x));
638
 
      destination.append(raw_data.c_str(), raw_data.size());
 
480
      destination->append(raw_data.c_str(), raw_data.size());
639
481
    }
640
482
    else
641
483
    {
642
 
      destination.append(record.key_value(x));
 
484
      destination->append(record.key_value(x));
643
485
    }
644
486
 
645
487
    if (should_quote_field_value)
646
 
      destination.push_back('\'');
 
488
      destination->push_back('\'');
647
489
  }
 
490
  if (num_key_fields > 1)
 
491
    destination->push_back(')');
648
492
 
649
493
  return error;
650
494
}
651
495
 
652
 
enum TransformSqlError
653
 
transformDeleteHeaderToSql(const DeleteHeader &header,
654
 
                           string &destination,
655
 
                           enum TransformSqlVariant sql_variant)
 
496
enum message::TransformSqlError
 
497
message::transformDeleteHeaderToSql(const message::DeleteHeader &header,
 
498
                                    std::string *destination,
 
499
                                    enum message::TransformSqlVariant sql_variant)
656
500
{
657
501
  char quoted_identifier= '`';
658
502
  if (sql_variant == ANSI)
659
503
    quoted_identifier= '"';
660
504
 
661
 
  destination.assign("DELETE FROM ", 12);
662
 
  destination.push_back(quoted_identifier);
663
 
  destination.append(header.table_metadata().schema_name());
664
 
  destination.push_back(quoted_identifier);
665
 
  destination.push_back('.');
666
 
  destination.push_back(quoted_identifier);
667
 
  destination.append(header.table_metadata().table_name());
668
 
  destination.push_back(quoted_identifier);
 
505
  destination->assign("DELETE FROM ", 12);
 
506
  destination->push_back(quoted_identifier);
 
507
  destination->append(header.table_metadata().schema_name());
 
508
  destination->push_back(quoted_identifier);
 
509
  destination->push_back('.');
 
510
  destination->push_back(quoted_identifier);
 
511
  destination->append(header.table_metadata().table_name());
 
512
  destination->push_back(quoted_identifier);
669
513
 
670
514
  return NONE;
671
515
}
672
516
 
673
 
enum TransformSqlError
674
 
transformDeleteRecordToSql(const DeleteHeader &header,
675
 
                           const DeleteRecord &record,
676
 
                           string &destination,
677
 
                           enum TransformSqlVariant sql_variant)
 
517
enum message::TransformSqlError
 
518
message::transformDeleteRecordToSql(const message::DeleteHeader &header,
 
519
                                    const message::DeleteRecord &record,
 
520
                                    std::string *destination,
 
521
                                    enum message::TransformSqlVariant sql_variant)
678
522
{
679
 
  enum TransformSqlError error= transformDeleteHeaderToSql(header,
680
 
                                                           destination,
681
 
                                                           sql_variant);
 
523
  enum message::TransformSqlError error= transformDeleteHeaderToSql(header,
 
524
                                                                    destination,
 
525
                                                                    sql_variant);
682
526
  char quoted_identifier= '`';
683
527
  if (sql_variant == ANSI)
684
528
    quoted_identifier= '"';
688
532
  uint32_t x;
689
533
  bool should_quote_field_value= false;
690
534
 
691
 
  destination.append(" WHERE ", 7);
 
535
  destination->append(" WHERE ", 7);
692
536
  for (x= 0; x < num_key_fields; ++x) 
693
537
  {
694
 
    const FieldMetadata &field_metadata= header.key_field_metadata(x);
 
538
    const message::FieldMetadata &field_metadata= header.key_field_metadata(x);
695
539
    
696
540
    if (x != 0)
697
 
      destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
698
 
 
699
 
    destination.push_back(quoted_identifier);
700
 
    destination.append(field_metadata.name());
701
 
    destination.push_back(quoted_identifier);
702
 
 
703
 
    destination.push_back('=');
704
 
 
705
 
    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
541
      destination->append(" AND ", 5); /* Always AND condition with a multi-column PK */
 
542
 
 
543
    destination->push_back(quoted_identifier);
 
544
    destination->append(field_metadata.name());
 
545
    destination->push_back(quoted_identifier);
 
546
 
 
547
    destination->push_back('=');
 
548
 
 
549
    should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
706
550
 
707
551
    if (should_quote_field_value)
708
 
      destination.push_back('\'');
 
552
      destination->push_back('\'');
709
553
 
710
 
    if (field_metadata.type() == Table::Field::BLOB)
 
554
    if (field_metadata.type() == message::Table::Field::BLOB)
711
555
    {
712
556
      /* 
713
557
       * We do this here because BLOB data is returned
716
560
       * up to a \0 being output here.
717
561
       */
718
562
      string raw_data(record.key_value(x));
719
 
      destination.append(raw_data.c_str(), raw_data.size());
 
563
      destination->append(raw_data.c_str(), raw_data.size());
720
564
    }
721
565
    else
722
566
    {
723
 
      string tmp(record.key_value(x));
724
 
      escapeEmbeddedQuotes(tmp);
725
 
      destination.append(tmp);
 
567
      destination->append(record.key_value(x));
726
568
    }
727
569
 
728
570
    if (should_quote_field_value)
729
 
      destination.push_back('\'');
 
571
      destination->push_back('\'');
730
572
  }
731
573
 
732
574
  return error;
733
575
}
734
576
 
735
 
enum TransformSqlError
736
 
transformDeleteStatementToSql(const DeleteHeader &header,
737
 
                              const DeleteData &data,
738
 
                              string &destination,
739
 
                              enum TransformSqlVariant sql_variant)
 
577
enum message::TransformSqlError
 
578
message::transformDeleteStatementToSql(const message::DeleteHeader &header,
 
579
                                       const message::DeleteData &data,
 
580
                                       std::string *destination,
 
581
                                       enum message::TransformSqlVariant sql_variant)
740
582
{
741
 
  enum TransformSqlError error= transformDeleteHeaderToSql(header,
742
 
                                                           destination,
743
 
                                                           sql_variant);
 
583
  enum message::TransformSqlError error= transformDeleteHeaderToSql(header,
 
584
                                                                    destination,
 
585
                                                                    sql_variant);
744
586
  char quoted_identifier= '`';
745
587
  if (sql_variant == ANSI)
746
588
    quoted_identifier= '"';
751
593
  uint32_t x, y;
752
594
  bool should_quote_field_value= false;
753
595
 
754
 
  destination.append(" WHERE ", 7);
 
596
  destination->append(" WHERE ", 7);
755
597
  for (x= 0; x < num_key_records; ++x)
756
598
  {
757
599
    if (x != 0)
758
 
      destination.append(" OR ", 4); /* Always OR condition for multiple key records */
 
600
      destination->append(" OR ", 4); /* Always OR condition for multiple key records */
759
601
 
760
602
    if (num_key_fields > 1)
761
 
      destination.push_back('(');
 
603
      destination->push_back('(');
762
604
 
763
605
    for (y= 0; y < num_key_fields; ++y) 
764
606
    {
765
 
      const FieldMetadata &field_metadata= header.key_field_metadata(y);
 
607
      const message::FieldMetadata &field_metadata= header.key_field_metadata(y);
766
608
      
767
609
      if (y != 0)
768
 
        destination.append(" AND ", 5); /* Always AND condition with a multi-column PK */
769
 
 
770
 
      destination.push_back(quoted_identifier);
771
 
      destination.append(field_metadata.name());
772
 
      destination.push_back(quoted_identifier);
773
 
 
774
 
      destination.push_back('=');
775
 
 
776
 
      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
 
610
        destination->append(" AND ", 5); /* Always AND condition with a multi-column PK */
 
611
 
 
612
      destination->push_back(quoted_identifier);
 
613
      destination->append(field_metadata.name());
 
614
      destination->push_back(quoted_identifier);
 
615
 
 
616
      destination->push_back('=');
 
617
 
 
618
      should_quote_field_value= message::shouldQuoteFieldValue(field_metadata.type());
777
619
 
778
620
      if (should_quote_field_value)
779
 
        destination.push_back('\'');
 
621
        destination->push_back('\'');
780
622
 
781
 
      if (field_metadata.type() == Table::Field::BLOB)
 
623
      if (field_metadata.type() == message::Table::Field::BLOB)
782
624
      {
783
625
        /* 
784
626
         * We do this here because BLOB data is returned
787
629
         * up to a \0 being output here.
788
630
         */
789
631
        string raw_data(data.record(x).key_value(y));
790
 
        destination.append(raw_data.c_str(), raw_data.size());
 
632
        destination->append(raw_data.c_str(), raw_data.size());
791
633
      }
792
634
      else
793
635
      {
794
 
        string tmp(data.record(x).key_value(y));
795
 
        escapeEmbeddedQuotes(tmp);
796
 
        destination.append(tmp);
 
636
        destination->append(data.record(x).key_value(y));
797
637
      }
798
638
 
799
639
      if (should_quote_field_value)
800
 
        destination.push_back('\'');
 
640
        destination->push_back('\'');
801
641
    }
802
642
    if (num_key_fields > 1)
803
 
      destination.push_back(')');
 
643
      destination->push_back(')');
804
644
  }
805
645
  return error;
806
646
}
807
647
 
808
 
enum TransformSqlError
809
 
transformDropSchemaStatementToSql(const DropSchemaStatement &statement,
810
 
                                  string &destination,
811
 
                                  enum TransformSqlVariant sql_variant)
812
 
{
813
 
  char quoted_identifier= '`';
814
 
  if (sql_variant == ANSI)
815
 
    quoted_identifier= '"';
816
 
 
817
 
  destination.append("DROP SCHEMA ", 12);
818
 
  destination.push_back(quoted_identifier);
819
 
  destination.append(statement.schema_name());
820
 
  destination.push_back(quoted_identifier);
821
 
 
822
 
  return NONE;
823
 
}
824
 
 
825
 
enum TransformSqlError
826
 
transformCreateSchemaStatementToSql(const CreateSchemaStatement &statement,
827
 
                                    string &destination,
828
 
                                    enum TransformSqlVariant sql_variant)
829
 
{
830
 
  char quoted_identifier= '`';
831
 
  if (sql_variant == ANSI)
832
 
    quoted_identifier= '"';
833
 
 
834
 
  const Schema &schema= statement.schema();
835
 
 
836
 
  destination.append("CREATE SCHEMA ", 14);
837
 
  destination.push_back(quoted_identifier);
838
 
  destination.append(schema.name());
839
 
  destination.push_back(quoted_identifier);
840
 
 
841
 
  if (schema.has_collation())
842
 
  {
843
 
    destination.append(" COLLATE ", 9);
844
 
    destination.append(schema.collation());
845
 
  }
846
 
 
847
 
  return NONE;
848
 
}
849
 
 
850
 
enum TransformSqlError
851
 
transformDropTableStatementToSql(const DropTableStatement &statement,
852
 
                                 string &destination,
853
 
                                 enum TransformSqlVariant sql_variant)
854
 
{
855
 
  char quoted_identifier= '`';
856
 
  if (sql_variant == ANSI)
857
 
    quoted_identifier= '"';
858
 
 
859
 
  const TableMetadata &table_metadata= statement.table_metadata();
860
 
 
861
 
  destination.append("DROP TABLE ", 11);
862
 
 
863
 
  /* Add the IF EXISTS clause if necessary */
864
 
  if (statement.has_if_exists_clause() &&
865
 
      statement.if_exists_clause() == true)
866
 
  {
867
 
    destination.append("IF EXISTS ", 10);
868
 
  }
869
 
 
870
 
  destination.push_back(quoted_identifier);
871
 
  destination.append(table_metadata.schema_name());
872
 
  destination.push_back(quoted_identifier);
873
 
  destination.push_back('.');
874
 
  destination.push_back(quoted_identifier);
875
 
  destination.append(table_metadata.table_name());
876
 
  destination.push_back(quoted_identifier);
877
 
 
878
 
  return NONE;
879
 
}
880
 
 
881
 
enum TransformSqlError
882
 
transformTruncateTableStatementToSql(const TruncateTableStatement &statement,
883
 
                                     string &destination,
884
 
                                     enum TransformSqlVariant sql_variant)
885
 
{
886
 
  char quoted_identifier= '`';
887
 
  if (sql_variant == ANSI)
888
 
    quoted_identifier= '"';
889
 
 
890
 
  const TableMetadata &table_metadata= statement.table_metadata();
891
 
 
892
 
  destination.append("TRUNCATE TABLE ", 15);
893
 
  destination.push_back(quoted_identifier);
894
 
  destination.append(table_metadata.schema_name());
895
 
  destination.push_back(quoted_identifier);
896
 
  destination.push_back('.');
897
 
  destination.push_back(quoted_identifier);
898
 
  destination.append(table_metadata.table_name());
899
 
  destination.push_back(quoted_identifier);
900
 
 
901
 
  return NONE;
902
 
}
903
 
 
904
 
enum TransformSqlError
905
 
transformSetVariableStatementToSql(const SetVariableStatement &statement,
906
 
                                   string &destination,
907
 
                                   enum TransformSqlVariant sql_variant)
 
648
enum message::TransformSqlError
 
649
message::transformTruncateTableStatementToSql(const message::TruncateTableStatement &statement,
 
650
                                              std::string *destination,
 
651
                                              enum message::TransformSqlVariant sql_variant)
 
652
{
 
653
  char quoted_identifier= '`';
 
654
  if (sql_variant == ANSI)
 
655
    quoted_identifier= '"';
 
656
 
 
657
  const message::TableMetadata &table_metadata= statement.table_metadata();
 
658
 
 
659
  destination->append("TRUNCATE TABLE ", 15);
 
660
  destination->push_back(quoted_identifier);
 
661
  destination->append(table_metadata.schema_name());
 
662
  destination->push_back(quoted_identifier);
 
663
  destination->push_back('.');
 
664
  destination->push_back(quoted_identifier);
 
665
  destination->append(table_metadata.table_name());
 
666
  destination->push_back(quoted_identifier);
 
667
 
 
668
  return NONE;
 
669
}
 
670
 
 
671
enum message::TransformSqlError
 
672
message::transformSetVariableStatementToSql(const message::SetVariableStatement &statement,
 
673
                                            std::string *destination,
 
674
                                            enum message::TransformSqlVariant sql_variant)
908
675
{
909
676
  (void) sql_variant;
910
 
  const FieldMetadata &variable_metadata= statement.variable_metadata();
911
 
  bool should_quote_field_value= shouldQuoteFieldValue(variable_metadata.type());
912
 
 
913
 
  destination.append("SET GLOBAL ", 11); /* Only global variables are replicated */
914
 
  destination.append(variable_metadata.name());
915
 
  destination.push_back('=');
916
 
 
917
 
  if (should_quote_field_value)
918
 
    destination.push_back('\'');
919
 
  
920
 
  destination.append(statement.variable_value());
921
 
 
922
 
  if (should_quote_field_value)
923
 
    destination.push_back('\'');
924
 
 
925
 
  return NONE;
926
 
}
927
 
 
928
 
enum TransformSqlError
929
 
transformCreateTableStatementToSql(const CreateTableStatement &statement,
930
 
                                   string &destination,
931
 
                                   enum TransformSqlVariant sql_variant)
932
 
{
933
 
  return transformTableDefinitionToSql(statement.table(), destination, sql_variant);
934
 
}
935
 
 
936
 
enum TransformSqlError
937
 
transformTableDefinitionToSql(const Table &table,
938
 
                              string &destination,
939
 
                              enum TransformSqlVariant sql_variant, bool with_schema)
940
 
{
941
 
  char quoted_identifier= '`';
942
 
  if (sql_variant == ANSI)
943
 
    quoted_identifier= '"';
944
 
 
945
 
  destination.append("CREATE ", 7);
946
 
 
947
 
  if (table.type() == Table::TEMPORARY)
948
 
    destination.append("TEMPORARY ", 10);
949
 
  
950
 
  destination.append("TABLE ", 6);
951
 
  if (with_schema)
952
 
  {
953
 
    append_escaped_string(&destination, table.schema(), quoted_identifier);
954
 
    destination.push_back('.');
955
 
  }
956
 
  append_escaped_string(&destination, table.name(), quoted_identifier);
957
 
  destination.append(" (\n", 3);
958
 
 
959
 
  enum TransformSqlError result= NONE;
960
 
  size_t num_fields= table.field_size();
961
 
  for (size_t x= 0; x < num_fields; ++x)
962
 
  {
963
 
    const Table::Field &field= table.field(x);
964
 
 
965
 
    if (x != 0)
966
 
      destination.append(",\n", 2);
967
 
 
968
 
    destination.append("  ");
969
 
 
970
 
    result= transformFieldDefinitionToSql(field, destination, sql_variant);
971
 
 
972
 
    if (result != NONE)
973
 
      return result;
974
 
  }
975
 
 
976
 
  size_t num_indexes= table.indexes_size();
977
 
  
978
 
  if (num_indexes > 0)
979
 
    destination.append(",\n", 2);
980
 
 
981
 
  for (size_t x= 0; x < num_indexes; ++x)
982
 
  {
983
 
    const message::Table::Index &index= table.indexes(x);
984
 
 
985
 
    if (x != 0)
986
 
      destination.append(",\n", 2);
987
 
 
988
 
    result= transformIndexDefinitionToSql(index, table, destination, sql_variant);
989
 
    
990
 
    if (result != NONE)
991
 
      return result;
992
 
  }
993
 
 
994
 
  size_t num_foreign_keys= table.fk_constraint_size();
995
 
 
996
 
  if (num_foreign_keys > 0)
997
 
    destination.append(",\n", 2);
998
 
 
999
 
  for (size_t x= 0; x < num_foreign_keys; ++x)
1000
 
  {
1001
 
    const message::Table::ForeignKeyConstraint &fkey= table.fk_constraint(x);
1002
 
 
1003
 
    if (x != 0)
1004
 
      destination.append(",\n", 2);
1005
 
 
1006
 
    result= transformForeignKeyConstraintDefinitionToSql(fkey, table, destination, sql_variant);
1007
 
 
1008
 
    if (result != NONE)
1009
 
      return result;
1010
 
  }
1011
 
 
1012
 
  destination.append("\n)", 2);
1013
 
 
1014
 
  /* Add ENGINE = " clause */
1015
 
  if (table.has_engine())
1016
 
  {
1017
 
    destination.append(" ENGINE=", 8);
1018
 
    destination.append(table.engine().name());
1019
 
 
1020
 
    size_t num_engine_options= table.engine().options_size();
1021
 
    if (num_engine_options > 0)
1022
 
      destination.append(" ", 1);
1023
 
    for (size_t x= 0; x < num_engine_options; ++x)
1024
 
    {
1025
 
      const Engine::Option &option= table.engine().options(x);
1026
 
      destination.append(option.name());
1027
 
      destination.append("='", 2);
1028
 
      destination.append(option.state());
1029
 
      destination.append("'", 1);
1030
 
      if(x != num_engine_options-1)
1031
 
        destination.append(", ", 2);
1032
 
    }
1033
 
  }
1034
 
 
1035
 
  if (table.has_options())
1036
 
    (void) transformTableOptionsToSql(table.options(), destination, sql_variant);
1037
 
 
1038
 
  return NONE;
1039
 
}
1040
 
 
1041
 
enum TransformSqlError
1042
 
transformTableOptionsToSql(const Table::TableOptions &options,
1043
 
                           string &destination,
1044
 
                           enum TransformSqlVariant sql_variant)
1045
 
{
1046
 
  if (sql_variant == ANSI)
1047
 
    return NONE; /* ANSI does not support table options... */
1048
 
 
1049
 
  if (options.has_comment())
1050
 
  {
1051
 
    destination.append(" COMMENT=", 9);
1052
 
    append_escaped_string(&destination, options.comment());
1053
 
  }
1054
 
 
1055
 
  if (options.has_collation())
1056
 
  {
1057
 
    destination.append(" COLLATE = ", 11);
1058
 
    destination.append(options.collation());
1059
 
  }
1060
 
 
1061
 
  if (options.has_data_file_name())
1062
 
  {
1063
 
    destination.append("\nDATA_FILE_NAME = '", 19);
1064
 
    destination.append(options.data_file_name());
1065
 
    destination.push_back('\'');
1066
 
  }
1067
 
 
1068
 
  if (options.has_index_file_name())
1069
 
  {
1070
 
    destination.append("\nINDEX_FILE_NAME = '", 20);
1071
 
    destination.append(options.index_file_name());
1072
 
    destination.push_back('\'');
1073
 
  }
1074
 
 
1075
 
  if (options.has_max_rows())
1076
 
  {
1077
 
    destination.append("\nMAX_ROWS = ", 12);
1078
 
    destination.append(boost::lexical_cast<string>(options.max_rows()));
1079
 
  }
1080
 
 
1081
 
  if (options.has_min_rows())
1082
 
  {
1083
 
    destination.append("\nMIN_ROWS = ", 12);
1084
 
    destination.append(boost::lexical_cast<string>(options.min_rows()));
1085
 
  }
1086
 
 
1087
 
  if (options.has_user_set_auto_increment_value()
1088
 
      && options.has_auto_increment_value())
1089
 
  {
1090
 
    destination.append(" AUTO_INCREMENT=", 16);
1091
 
    destination.append(boost::lexical_cast<string>(options.auto_increment_value()));
1092
 
  }
1093
 
 
1094
 
  if (options.has_avg_row_length())
1095
 
  {
1096
 
    destination.append("\nAVG_ROW_LENGTH = ", 18);
1097
 
    destination.append(boost::lexical_cast<string>(options.avg_row_length()));
1098
 
  }
1099
 
 
1100
 
  if (options.has_checksum() &&
1101
 
      options.checksum())
1102
 
    destination.append("\nCHECKSUM = TRUE", 16);
1103
 
  if (options.has_page_checksum() &&
1104
 
      options.page_checksum())
1105
 
    destination.append("\nPAGE_CHECKSUM = TRUE", 21);
1106
 
 
1107
 
  return NONE;
1108
 
}
1109
 
 
1110
 
enum TransformSqlError
1111
 
transformIndexDefinitionToSql(const Table::Index &index,
1112
 
                              const Table &table,
1113
 
                              string &destination,
1114
 
                              enum TransformSqlVariant sql_variant)
1115
 
{
1116
 
  char quoted_identifier= '`';
1117
 
  if (sql_variant == ANSI)
1118
 
    quoted_identifier= '"';
1119
 
 
1120
 
  destination.append("  ", 2);
1121
 
 
1122
 
  if (index.is_primary())
1123
 
    destination.append("PRIMARY ", 8);
1124
 
  else if (index.is_unique())
1125
 
    destination.append("UNIQUE ", 7);
1126
 
 
1127
 
  destination.append("KEY ", 4);
1128
 
  if (! (index.is_primary() && index.name().compare("PRIMARY")==0))
1129
 
  {
1130
 
    destination.push_back(quoted_identifier);
1131
 
    destination.append(index.name());
1132
 
    destination.push_back(quoted_identifier);
1133
 
    destination.append(" (", 2);
1134
 
  }
1135
 
  else
1136
 
    destination.append("(", 1);
1137
 
 
1138
 
  size_t num_parts= index.index_part_size();
1139
 
  for (size_t x= 0; x < num_parts; ++x)
1140
 
  {
1141
 
    const Table::Index::IndexPart &part= index.index_part(x);
1142
 
    const Table::Field &field= table.field(part.fieldnr());
1143
 
 
1144
 
    if (x != 0)
1145
 
      destination.push_back(',');
1146
 
    
1147
 
    destination.push_back(quoted_identifier);
1148
 
    destination.append(field.name());
1149
 
    destination.push_back(quoted_identifier);
1150
 
 
1151
 
    /* 
1152
 
     * If the index part's field type is VARCHAR or TEXT
1153
 
     * then check for a prefix length then is different
1154
 
     * from the field's full length...
1155
 
     */
1156
 
    if (field.type() == Table::Field::VARCHAR ||
1157
 
        field.type() == Table::Field::BLOB)
1158
 
    {
1159
 
      if (part.has_compare_length())
1160
 
      {
1161
 
        if (part.compare_length() != field.string_options().length())
1162
 
        {
1163
 
          destination.push_back('(');
1164
 
          destination.append(boost::lexical_cast<string>(part.compare_length()));
1165
 
          destination.push_back(')');
1166
 
        }
1167
 
      }
1168
 
    }
1169
 
  }
1170
 
  destination.push_back(')');
1171
 
 
1172
 
  switch (index.type())
1173
 
  {
1174
 
  case Table::Index::UNKNOWN_INDEX:
1175
 
    break;
1176
 
  case Table::Index::BTREE:
1177
 
    destination.append(" USING BTREE", 12);
1178
 
    break;
1179
 
  case Table::Index::RTREE:
1180
 
    destination.append(" USING RTREE", 12);
1181
 
    break;
1182
 
  case Table::Index::HASH:
1183
 
    destination.append(" USING HASH", 11);
1184
 
    break;
1185
 
  case Table::Index::FULLTEXT:
1186
 
    destination.append(" USING FULLTEXT", 15);
1187
 
    break;
1188
 
  }
1189
 
 
1190
 
  if (index.has_comment())
1191
 
  {
1192
 
    destination.append(" COMMENT ", 9);
1193
 
    append_escaped_string(&destination, index.comment());
1194
 
  }
1195
 
 
1196
 
  return NONE;
1197
 
}
1198
 
 
1199
 
static void transformForeignKeyOptionToSql(Table::ForeignKeyConstraint::ForeignKeyOption opt, string &destination)
1200
 
{
1201
 
  switch (opt)
1202
 
  {
1203
 
  case Table::ForeignKeyConstraint::OPTION_RESTRICT:
1204
 
    destination.append("RESTRICT");
1205
 
    break;
1206
 
  case Table::ForeignKeyConstraint::OPTION_CASCADE:
1207
 
    destination.append("CASCADE");
1208
 
    break;
1209
 
  case Table::ForeignKeyConstraint::OPTION_SET_NULL:
1210
 
    destination.append("SET NULL");
1211
 
    break;
1212
 
  case Table::ForeignKeyConstraint::OPTION_UNDEF:
1213
 
  case Table::ForeignKeyConstraint::OPTION_NO_ACTION:
1214
 
    destination.append("NO ACTION");
1215
 
    break;
1216
 
  case Table::ForeignKeyConstraint::OPTION_SET_DEFAULT:
1217
 
    destination.append("SET DEFAULT");
1218
 
    break;
1219
 
  }
1220
 
}
1221
 
 
1222
 
enum TransformSqlError
1223
 
transformForeignKeyConstraintDefinitionToSql(const Table::ForeignKeyConstraint &fkey,
1224
 
                                             const Table &,
1225
 
                                             string &destination,
1226
 
                                             enum TransformSqlVariant sql_variant)
1227
 
{
1228
 
  char quoted_identifier= '`';
1229
 
  if (sql_variant == ANSI)
1230
 
    quoted_identifier= '"';
1231
 
 
1232
 
  destination.append("  ", 2);
1233
 
 
1234
 
  if (fkey.has_name())
1235
 
  {
1236
 
    destination.append("CONSTRAINT ", 11);
1237
 
    append_escaped_string(&destination, fkey.name(), quoted_identifier);
1238
 
    destination.append(" ", 1);
1239
 
  }
1240
 
 
1241
 
  destination.append("FOREIGN KEY (", 13);
1242
 
 
1243
 
  for (ssize_t x= 0; x < fkey.column_names_size(); ++x)
1244
 
  {
1245
 
    if (x != 0)
1246
 
      destination.append(", ");
1247
 
 
1248
 
    append_escaped_string(&destination, fkey.column_names(x),
1249
 
                          quoted_identifier);
1250
 
  }
1251
 
 
1252
 
  destination.append(") REFERENCES ", 13);
1253
 
 
1254
 
  append_escaped_string(&destination, fkey.references_table_name(),
1255
 
                        quoted_identifier);
1256
 
  destination.append(" (", 2);
1257
 
 
1258
 
  for (ssize_t x= 0; x < fkey.references_columns_size(); ++x)
1259
 
  {
1260
 
    if (x != 0)
1261
 
      destination.append(", ");
1262
 
 
1263
 
    append_escaped_string(&destination, fkey.references_columns(x),
1264
 
                          quoted_identifier);
1265
 
  }
1266
 
 
1267
 
  destination.push_back(')');
1268
 
 
1269
 
  if (fkey.has_update_option() and fkey.update_option() != Table::ForeignKeyConstraint::OPTION_UNDEF)
1270
 
  {
1271
 
    destination.append(" ON UPDATE ", 11);
1272
 
    transformForeignKeyOptionToSql(fkey.update_option(), destination);
1273
 
  }
1274
 
 
1275
 
  if (fkey.has_delete_option() and fkey.delete_option() != Table::ForeignKeyConstraint::OPTION_UNDEF)
1276
 
  {
1277
 
    destination.append(" ON DELETE ", 11);
1278
 
    transformForeignKeyOptionToSql(fkey.delete_option(), destination);
1279
 
  }
1280
 
 
1281
 
  return NONE;
1282
 
}
1283
 
 
1284
 
enum TransformSqlError
1285
 
transformFieldDefinitionToSql(const Table::Field &field,
1286
 
                              string &destination,
1287
 
                              enum TransformSqlVariant sql_variant)
1288
 
{
1289
 
  char quoted_identifier= '`';
1290
 
  char quoted_default;
1291
 
 
1292
 
  if (sql_variant == ANSI)
1293
 
    quoted_identifier= '"';
1294
 
 
1295
 
  if (sql_variant == DRIZZLE)
1296
 
    quoted_default= '\'';
1297
 
  else
1298
 
    quoted_default= quoted_identifier;
1299
 
 
1300
 
  append_escaped_string(&destination, field.name(), quoted_identifier);
1301
 
 
1302
 
  Table::Field::FieldType field_type= field.type();
1303
 
 
1304
 
  switch (field_type)
1305
 
  {
1306
 
    case Table::Field::DOUBLE:
1307
 
    destination.append(" DOUBLE", 7);
1308
 
    if (field.has_numeric_options()
1309
 
        && field.numeric_options().has_precision())
1310
 
    {
1311
 
      stringstream ss;
1312
 
      ss << "(" << field.numeric_options().precision() << ",";
1313
 
      ss << field.numeric_options().scale() << ")";
1314
 
      destination.append(ss.str());
1315
 
    }
1316
 
    break;
1317
 
  case Table::Field::VARCHAR:
1318
 
    {
1319
 
      if (field.string_options().has_collation()
1320
 
          && field.string_options().collation().compare("binary") == 0)
1321
 
        destination.append(" VARBINARY(", 11);
1322
 
      else
1323
 
        destination.append(" VARCHAR(", 9);
1324
 
 
1325
 
      destination.append(boost::lexical_cast<string>(field.string_options().length()));
1326
 
      destination.append(")");
1327
 
    }
1328
 
    break;
1329
 
  case Table::Field::BLOB:
1330
 
    {
1331
 
      if (field.string_options().has_collation()
1332
 
          && field.string_options().collation().compare("binary") == 0)
1333
 
        destination.append(" BLOB", 5);
1334
 
      else
1335
 
        destination.append(" TEXT", 5);
1336
 
    }
1337
 
    break;
1338
 
  case Table::Field::ENUM:
1339
 
    {
1340
 
      size_t num_field_values= field.enumeration_values().field_value_size();
1341
 
      destination.append(" ENUM(", 6);
1342
 
      for (size_t x= 0; x < num_field_values; ++x)
1343
 
      {
1344
 
        const string &type= field.enumeration_values().field_value(x);
1345
 
 
1346
 
        if (x != 0)
1347
 
          destination.push_back(',');
1348
 
 
1349
 
        destination.push_back('\'');
1350
 
        destination.append(type);
1351
 
        destination.push_back('\'');
1352
 
      }
1353
 
      destination.push_back(')');
1354
 
      break;
1355
 
    }
1356
 
  case Table::Field::UUID:
1357
 
    destination.append(" UUID", 5);
1358
 
    break;
1359
 
  case Table::Field::INTEGER:
1360
 
    destination.append(" INT", 4);
1361
 
    break;
1362
 
  case Table::Field::BIGINT:
1363
 
    destination.append(" BIGINT", 7);
1364
 
    break;
1365
 
  case Table::Field::DECIMAL:
1366
 
    {
1367
 
      destination.append(" DECIMAL(", 9);
1368
 
      stringstream ss;
1369
 
      ss << field.numeric_options().precision() << ",";
1370
 
      ss << field.numeric_options().scale() << ")";
1371
 
      destination.append(ss.str());
1372
 
    }
1373
 
    break;
1374
 
  case Table::Field::DATE:
1375
 
    destination.append(" DATE", 5);
1376
 
    break;
1377
 
  case Table::Field::TIMESTAMP:
1378
 
    destination.append(" TIMESTAMP",  10);
1379
 
    break;
1380
 
  case Table::Field::DATETIME:
1381
 
    destination.append(" DATETIME",  9);
1382
 
    break;
1383
 
  }
1384
 
 
1385
 
  if (field.type() == Table::Field::INTEGER || 
1386
 
      field.type() == Table::Field::BIGINT)
1387
 
  {
1388
 
    if (field.has_constraints() &&
1389
 
        field.constraints().has_is_unsigned() &&
1390
 
        field.constraints().is_unsigned())
1391
 
    {
1392
 
      destination.append(" UNSIGNED", 9);
1393
 
    }
1394
 
  }
1395
 
 
1396
 
  if (field.type() == Table::Field::BLOB ||
1397
 
      field.type() == Table::Field::VARCHAR)
1398
 
  {
1399
 
    if (field.string_options().has_collation()
1400
 
        && field.string_options().collation().compare("binary"))
1401
 
    {
1402
 
      destination.append(" COLLATE ", 9);
1403
 
      destination.append(field.string_options().collation());
1404
 
    }
1405
 
  }
1406
 
 
1407
 
  if (field.has_constraints() &&
1408
 
      ! field.constraints().is_nullable())
1409
 
  {
1410
 
    destination.append(" NOT NULL", 9);
1411
 
  }
1412
 
  else if (field.type() == Table::Field::TIMESTAMP)
1413
 
    destination.append(" NULL", 5);
1414
 
 
1415
 
  if (field.type() == Table::Field::INTEGER || 
1416
 
      field.type() == Table::Field::BIGINT)
1417
 
  {
1418
 
    /* AUTO_INCREMENT must be after NOT NULL */
1419
 
    if (field.has_numeric_options() &&
1420
 
        field.numeric_options().is_autoincrement())
1421
 
    {
1422
 
      destination.append(" AUTO_INCREMENT", 15);
1423
 
    }
1424
 
  }
1425
 
 
1426
 
  if (field.options().has_default_value())
1427
 
  {
1428
 
    destination.append(" DEFAULT ", 9);
1429
 
    append_escaped_string(&destination, field.options().default_value());
1430
 
  }
1431
 
  else if (field.options().has_default_expression())
1432
 
  {
1433
 
    destination.append(" DEFAULT ", 9);
1434
 
    destination.append(field.options().default_expression());
1435
 
  }
1436
 
  else if (field.options().has_default_bin_value())
1437
 
  {
1438
 
    const string &v= field.options().default_bin_value();
1439
 
    if (v.length() == 0)
1440
 
      destination.append(" DEFAULT ''", 11);
1441
 
    else
1442
 
    {
1443
 
      destination.append(" DEFAULT 0x", 11);
1444
 
      for (size_t x= 0; x < v.length(); x++)
1445
 
      {
1446
 
        char hex[3];
1447
 
        snprintf(hex, sizeof(hex), "%.2X", *(v.c_str() + x));
1448
 
        destination.append(hex, 2);
1449
 
      }
1450
 
    }
1451
 
  }
1452
 
  else if (field.options().has_default_null()
1453
 
           && field.options().default_null()
1454
 
           && field.type() != Table::Field::BLOB)
1455
 
  {
1456
 
    destination.append(" DEFAULT NULL", 13);
1457
 
  }
1458
 
 
1459
 
  if (field.has_options() && field.options().has_update_expression())
1460
 
  {
1461
 
    destination.append(" ON UPDATE ", 11);
1462
 
    destination.append(field.options().update_expression());
1463
 
  }
1464
 
 
1465
 
  if (field.has_comment())
1466
 
  {
1467
 
    destination.append(" COMMENT ", 9);
1468
 
    append_escaped_string(&destination, field.comment(), quoted_default);
1469
 
  }
1470
 
  return NONE;
1471
 
}
1472
 
 
1473
 
bool shouldQuoteFieldValue(Table::Field::FieldType in_type)
 
677
  const message::FieldMetadata &variable_metadata= statement.variable_metadata();
 
678
  bool should_quote_field_value= message::shouldQuoteFieldValue(variable_metadata.type());
 
679
 
 
680
  destination->append("SET GLOBAL ", 11); /* Only global variables are replicated */
 
681
  destination->append(variable_metadata.name());
 
682
  destination->push_back('=');
 
683
 
 
684
  if (should_quote_field_value)
 
685
    destination->push_back('\'');
 
686
  
 
687
  destination->append(statement.variable_value());
 
688
 
 
689
  if (should_quote_field_value)
 
690
    destination->push_back('\'');
 
691
 
 
692
  return NONE;
 
693
}
 
694
 
 
695
bool message::shouldQuoteFieldValue(message::Table::Field::FieldType in_type)
1474
696
{
1475
697
  switch (in_type)
1476
698
  {
1477
 
  case Table::Field::DOUBLE:
1478
 
  case Table::Field::DECIMAL:
1479
 
  case Table::Field::INTEGER:
1480
 
  case Table::Field::BIGINT:
 
699
  case message::Table::Field::DOUBLE:
 
700
  case message::Table::Field::DECIMAL:
 
701
  case message::Table::Field::INTEGER:
 
702
  case message::Table::Field::BIGINT:
 
703
  case message::Table::Field::ENUM:
1481
704
    return false;
1482
705
  default:
1483
706
    return true;
1484
707
  } 
1485
708
}
1486
709
 
1487
 
Table::Field::FieldType internalFieldTypeToFieldProtoType(enum enum_field_types type)
 
710
drizzled::message::Table::Field::FieldType message::internalFieldTypeToFieldProtoType(enum enum_field_types type)
1488
711
{
1489
712
  switch (type) {
1490
713
  case DRIZZLE_TYPE_LONG:
1491
 
    return Table::Field::INTEGER;
 
714
    return message::Table::Field::INTEGER;
1492
715
  case DRIZZLE_TYPE_DOUBLE:
1493
 
    return Table::Field::DOUBLE;
 
716
    return message::Table::Field::DOUBLE;
1494
717
  case DRIZZLE_TYPE_NULL:
1495
718
    assert(false); /* Not a user definable type */
1496
 
    return Table::Field::INTEGER; /* unreachable */
 
719
    return message::Table::Field::INTEGER; /* unreachable */
1497
720
  case DRIZZLE_TYPE_TIMESTAMP:
1498
 
    return Table::Field::TIMESTAMP;
 
721
    return message::Table::Field::TIMESTAMP;
1499
722
  case DRIZZLE_TYPE_LONGLONG:
1500
 
    return Table::Field::BIGINT;
 
723
    return message::Table::Field::BIGINT;
1501
724
  case DRIZZLE_TYPE_DATETIME:
1502
 
    return Table::Field::DATETIME;
 
725
    return message::Table::Field::DATETIME;
1503
726
  case DRIZZLE_TYPE_DATE:
1504
 
    return Table::Field::DATE;
 
727
    return message::Table::Field::DATE;
1505
728
  case DRIZZLE_TYPE_VARCHAR:
1506
 
    return Table::Field::VARCHAR;
 
729
    return message::Table::Field::VARCHAR;
1507
730
  case DRIZZLE_TYPE_DECIMAL:
1508
 
    return Table::Field::DECIMAL;
 
731
    return message::Table::Field::DECIMAL;
1509
732
  case DRIZZLE_TYPE_ENUM:
1510
 
    return Table::Field::ENUM;
 
733
    return message::Table::Field::ENUM;
1511
734
  case DRIZZLE_TYPE_BLOB:
1512
 
    return Table::Field::BLOB;
1513
 
  case DRIZZLE_TYPE_UUID:
1514
 
    return Table::Field::UUID;
 
735
    return message::Table::Field::BLOB;
1515
736
  }
1516
737
 
1517
738
  assert(false);
1518
 
  return Table::Field::INTEGER; /* unreachable */
1519
 
}
1520
 
 
1521
 
bool transactionContainsBulkSegment(const Transaction &transaction)
1522
 
{
1523
 
  size_t num_statements= transaction.statement_size();
1524
 
  if (num_statements == 0)
1525
 
    return false;
1526
 
 
1527
 
  /*
1528
 
   * Only INSERT, UPDATE, and DELETE statements can possibly
1529
 
   * have bulk segments.  So, we loop through the statements
1530
 
   * checking for segment_id > 1 in those specific submessages.
1531
 
   */
1532
 
  size_t x;
1533
 
  for (x= 0; x < num_statements; ++x)
1534
 
  {
1535
 
    const Statement &statement= transaction.statement(x);
1536
 
    Statement::Type type= statement.type();
1537
 
 
1538
 
    switch (type)
1539
 
    {
1540
 
      case Statement::INSERT:
1541
 
        if (statement.insert_data().segment_id() > 1)
1542
 
          return true;
1543
 
        break;
1544
 
      case Statement::UPDATE:
1545
 
        if (statement.update_data().segment_id() > 1)
1546
 
          return true;
1547
 
        break;
1548
 
      case Statement::DELETE:
1549
 
        if (statement.delete_data().segment_id() > 1)
1550
 
          return true;
1551
 
        break;
1552
 
      default:
1553
 
        break;
1554
 
    }
1555
 
  }
1556
 
  return false;
1557
 
}
1558
 
 
1559
 
} /* namespace message */
 
739
  return message::Table::Field::INTEGER; /* unreachable */
 
740
}
 
741
 
1560
742
} /* namespace drizzled */