← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/message/statement_transform.cc

  • Committer: Djellel E. Difallah
  • Date: 2010-03-27 10:10:49 UTC
  • mto: This revision was merged to the branch mainline in revision 1429.
  • Revision ID: ded@ubuntu-20100327101049-oo3arvatjoyku124
merge my_decimal and decimal

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/message/statement_transform.cc
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2009 Sun Microsystems, Inc.
5
 
 *  Copyright (C) 2010 Jay Pipes
 
4
 *  Copyright (C) 2009 Sun Microsystems
 
5
 *  Copyright (c) 2010 Jay Pipes
6
6
 *
7
7
 *  Authors:
8
8
 *
29
29
 * Statement messages to other formats, including SQL strings.
30
30
 */
31
31
 
32
 
#include <config.h>
 
32
#include "config.h"
33
33
 
34
 
#include <boost/lexical_cast.hpp>
35
 
#include <drizzled/message/statement_transform.h>
36
 
#include <drizzled/message/transaction.pb.h>
37
 
#include <drizzled/message/table.pb.h>
38
 
#include <drizzled/charset.h>
39
 
#include <drizzled/charset_info.h>
40
 
#include <drizzled/global_charset_info.h>
 
34
#include "drizzled/message/statement_transform.h"
 
35
#include "drizzled/message/transaction.pb.h"
 
36
#include "drizzled/message/table.pb.h"
41
37
 
42
38
#include <string>
43
39
#include <vector>
44
40
#include <sstream>
45
 
#include <cstdio>
46
41
 
47
42
using namespace std;
48
43
 
52
47
namespace message
53
48
{
54
49
 
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
50
enum TransformSqlError
121
51
transformStatementToSql(const Statement &source,
122
52
                        vector<string> &sql_strings,
127
57
 
128
58
  switch (source.type())
129
59
  {
130
 
  case Statement::ROLLBACK_STATEMENT:
131
 
    {
132
 
      break;
133
 
    }
134
 
  case Statement::ROLLBACK:
135
 
    {
136
 
      sql_strings.push_back("ROLLBACK");
137
 
      break;
138
 
    }
139
60
  case Statement::INSERT:
140
61
    {
141
62
      if (! source.has_insert_header())
152
73
      const InsertHeader &insert_header= source.insert_header();
153
74
      const InsertData &insert_data= source.insert_data();
154
75
      size_t num_keys= insert_data.record_size();
 
76
      size_t x;
155
77
 
156
78
      if (num_keys > 1 && ! already_in_transaction)
157
79
        sql_strings.push_back("START TRANSACTION");
158
80
 
159
 
      for (size_t x= 0; x < num_keys; ++x)
 
81
      for (x= 0; x < num_keys; ++x)
160
82
      {
161
83
        string destination;
162
84
 
317
239
      sql_strings.push_back(destination);
318
240
    }
319
241
    break;
320
 
  case Statement::ALTER_SCHEMA:
321
 
    {
322
 
      assert(source.has_alter_schema_statement());
323
 
      string destination;
324
 
      error= transformAlterSchemaStatementToSql(source.alter_schema_statement(),
325
 
                                                destination,
326
 
                                                sql_variant);
327
 
      sql_strings.push_back(destination);
328
 
    }
329
 
    break;
330
242
  case Statement::SET_VARIABLE:
331
243
    {
332
244
      assert(source.has_set_variable_statement());
410
322
 
411
323
    const FieldMetadata &field_metadata= header.field_metadata(x);
412
324
 
413
 
    if (record.is_null(x))
414
 
    {
415
 
      should_quote_field_value= false;
416
 
    }
417
 
    else 
418
 
    {
419
 
      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
420
 
    }
 
325
    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
421
326
 
422
327
    if (should_quote_field_value)
423
328
      destination.push_back('\'');
424
329
 
425
 
    if (record.is_null(x))
 
330
    if (field_metadata.type() == Table::Field::BLOB)
426
331
    {
427
 
      destination.append("NULL");
 
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());
428
340
    }
429
341
    else
430
342
    {
431
 
      if (field_metadata.type() == Table::Field::BLOB)
432
 
      {
433
 
        /*
434
 
         * We do this here because BLOB data is returned
435
 
         * in a string correctly, but calling append()
436
 
         * without a length will result in only the string
437
 
         * up to a \0 being output here.
438
 
         */
439
 
        string raw_data(record.insert_value(x));
440
 
        destination.append(raw_data.c_str(), raw_data.size());
441
 
      }
442
 
      else
443
 
      {
444
 
        string tmp(record.insert_value(x));
445
 
        escapeEmbeddedQuotes(tmp);
446
 
        destination.append(tmp);
447
 
      }
 
343
      destination.append(record.insert_value(x));
448
344
    }
449
345
 
450
346
    if (should_quote_field_value)
507
403
      }
508
404
      else
509
405
      {
510
 
        string tmp(data.record(x).insert_value(y));
511
 
        escapeEmbeddedQuotes(tmp);
512
 
        destination.append(tmp);
 
406
        destination.append(data.record(x).insert_value(y));
513
407
      }
514
408
 
515
409
      if (should_quote_field_value)
573
467
    destination.push_back(quoted_identifier);
574
468
    destination.push_back('=');
575
469
 
576
 
    if (record.is_null(x))
577
 
    {
578
 
      should_quote_field_value= false;
579
 
    }
580
 
    else 
581
 
    {
582
 
      should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
583
 
    }    
 
470
    should_quote_field_value= shouldQuoteFieldValue(field_metadata.type());
584
471
 
585
472
    if (should_quote_field_value)
586
473
      destination.push_back('\'');
587
474
 
588
 
    if (record.is_null(x))
 
475
    if (field_metadata.type() == Table::Field::BLOB)
589
476
    {
590
 
      destination.append("NULL");
 
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());
591
485
    }
592
 
    else 
 
486
    else
593
487
    {
594
 
      if (field_metadata.type() == Table::Field::BLOB)
595
 
      {
596
 
        /*
597
 
         * We do this here because BLOB data is returned
598
 
         * in a string correctly, but calling append()
599
 
         * without a length will result in only the string
600
 
         * up to a \0 being output here.
601
 
         */
602
 
        string raw_data(record.after_value(x));
603
 
        destination.append(raw_data.c_str(), raw_data.size());
604
 
      }
605
 
      else 
606
 
      {
607
 
        string tmp(record.after_value(x));
608
 
        escapeEmbeddedQuotes(tmp);
609
 
        destination.append(tmp);
610
 
      }
 
488
      destination.append(record.after_value(x));
611
489
    }
612
490
 
613
491
    if (should_quote_field_value)
729
607
    }
730
608
    else
731
609
    {
732
 
      string tmp(record.key_value(x));
733
 
      escapeEmbeddedQuotes(tmp);
734
 
      destination.append(tmp);
 
610
      destination.append(record.key_value(x));
735
611
    }
736
612
 
737
613
    if (should_quote_field_value)
800
676
      }
801
677
      else
802
678
      {
803
 
        string tmp(data.record(x).key_value(y));
804
 
        escapeEmbeddedQuotes(tmp);
805
 
        destination.append(tmp);
 
679
        destination.append(data.record(x).key_value(y));
806
680
      }
807
681
 
808
682
      if (should_quote_field_value)
815
689
}
816
690
 
817
691
enum TransformSqlError
818
 
transformAlterSchemaStatementToSql(const AlterSchemaStatement &statement,
819
 
                                   string &destination,
820
 
                                   enum TransformSqlVariant sql_variant)
821
 
{
822
 
  const Schema &before= statement.before();
823
 
  const Schema &after= statement.after();
824
 
 
825
 
  /* Make sure we are given the before and after for the same object */
826
 
  if (before.uuid() != after.uuid())
827
 
    return UUID_MISMATCH;
828
 
 
829
 
  char quoted_identifier= '`';
830
 
  if (sql_variant == ANSI)
831
 
    quoted_identifier= '"';
832
 
 
833
 
  destination.append("ALTER SCHEMA ");
834
 
  destination.push_back(quoted_identifier);
835
 
  destination.append(before.name());
836
 
  destination.push_back(quoted_identifier);
837
 
 
838
 
  /*
839
 
   * Diff our schemas. Currently, only collation can change so a
840
 
   * diff of the two structures is not really necessary.
841
 
   */
842
 
  destination.append(" COLLATE = ");
843
 
  destination.append(after.collation());
844
 
 
845
 
  return NONE;
846
 
}
847
 
 
848
 
enum TransformSqlError
849
692
transformDropSchemaStatementToSql(const DropSchemaStatement &statement,
850
693
                                  string &destination,
851
694
                                  enum TransformSqlVariant sql_variant)
873
716
 
874
717
  const Schema &schema= statement.schema();
875
718
 
876
 
  destination.append("CREATE SCHEMA ");
 
719
  destination.append("CREATE SCHEMA ", 14);
877
720
  destination.push_back(quoted_identifier);
878
721
  destination.append(schema.name());
879
722
  destination.push_back(quoted_identifier);
880
723
 
881
724
  if (schema.has_collation())
882
725
  {
883
 
    destination.append(" COLLATE ");
 
726
    destination.append(" COLLATE ", 9);
884
727
    destination.append(schema.collation());
885
728
  }
886
729
 
887
 
  if (schema.has_replication_options() and schema.replication_options().has_dont_replicate() and schema.replication_options().dont_replicate())
888
 
  {
889
 
    destination.append(" REPLICATION = FALSE");
890
 
  }
891
 
 
892
730
  return NONE;
893
731
}
894
732
 
903
741
 
904
742
  const TableMetadata &table_metadata= statement.table_metadata();
905
743
 
906
 
  destination.append("DROP TABLE ");
 
744
  destination.append("DROP TABLE ", 11);
907
745
 
908
746
  /* Add the IF EXISTS clause if necessary */
909
747
  if (statement.has_if_exists_clause() &&
910
748
      statement.if_exists_clause() == true)
911
749
  {
912
 
    destination.append("IF EXISTS ");
 
750
    destination.append("IF EXISTS ", 10);
913
751
  }
914
752
 
915
753
  destination.push_back(quoted_identifier);
934
772
 
935
773
  const TableMetadata &table_metadata= statement.table_metadata();
936
774
 
937
 
  destination.append("TRUNCATE TABLE ");
 
775
  destination.append("TRUNCATE TABLE ", 15);
938
776
  destination.push_back(quoted_identifier);
939
777
  destination.append(table_metadata.schema_name());
940
778
  destination.push_back(quoted_identifier);
955
793
  const FieldMetadata &variable_metadata= statement.variable_metadata();
956
794
  bool should_quote_field_value= shouldQuoteFieldValue(variable_metadata.type());
957
795
 
958
 
  destination.append("SET GLOBAL "); /* Only global variables are replicated */
 
796
  destination.append("SET GLOBAL ", 11); /* Only global variables are replicated */
959
797
  destination.append(variable_metadata.name());
960
798
  destination.push_back('=');
961
799
 
987
825
  if (sql_variant == ANSI)
988
826
    quoted_identifier= '"';
989
827
 
990
 
  destination.append("CREATE ");
 
828
  destination.append("CREATE ", 7);
991
829
 
992
830
  if (table.type() == Table::TEMPORARY)
993
 
    destination.append("TEMPORARY ");
 
831
    destination.append("TEMPORARY ", 10);
994
832
  
995
 
  destination.append("TABLE ");
 
833
  destination.append("TABLE ", 6);
996
834
  if (with_schema)
997
835
  {
998
 
    append_escaped_string(&destination, table.schema(), quoted_identifier);
 
836
    destination.push_back(quoted_identifier);
 
837
    destination.append(table.schema());
 
838
    destination.push_back(quoted_identifier);
999
839
    destination.push_back('.');
1000
840
  }
1001
 
  append_escaped_string(&destination, table.name(), quoted_identifier);
1002
 
  destination.append(" (\n");
 
841
  destination.push_back(quoted_identifier);
 
842
  destination.append(table.name());
 
843
  destination.push_back(quoted_identifier);
 
844
  destination.append(" (\n", 3);
1003
845
 
1004
846
  enum TransformSqlError result= NONE;
1005
847
  size_t num_fields= table.field_size();
1008
850
    const Table::Field &field= table.field(x);
1009
851
 
1010
852
    if (x != 0)
1011
 
      destination.append(",\n");
1012
 
 
1013
 
    destination.append("  ");
 
853
      destination.append(",\n", 2);
1014
854
 
1015
855
    result= transformFieldDefinitionToSql(field, destination, sql_variant);
1016
 
 
 
856
    
1017
857
    if (result != NONE)
1018
858
      return result;
1019
859
  }
1021
861
  size_t num_indexes= table.indexes_size();
1022
862
  
1023
863
  if (num_indexes > 0)
1024
 
    destination.append(",\n");
 
864
    destination.append(",\n", 2);
1025
865
 
1026
866
  for (size_t x= 0; x < num_indexes; ++x)
1027
867
  {
1028
868
    const message::Table::Index &index= table.indexes(x);
1029
869
 
1030
870
    if (x != 0)
1031
 
      destination.append(",\n");
 
871
      destination.append(",\n", 2);
1032
872
 
1033
873
    result= transformIndexDefinitionToSql(index, table, destination, sql_variant);
1034
874
    
1035
875
    if (result != NONE)
1036
876
      return result;
1037
877
  }
1038
 
 
1039
 
  size_t num_foreign_keys= table.fk_constraint_size();
1040
 
 
1041
 
  if (num_foreign_keys > 0)
1042
 
    destination.append(",\n");
1043
 
 
1044
 
  for (size_t x= 0; x < num_foreign_keys; ++x)
1045
 
  {
1046
 
    const message::Table::ForeignKeyConstraint &fkey= table.fk_constraint(x);
1047
 
 
1048
 
    if (x != 0)
1049
 
      destination.append(",\n");
1050
 
 
1051
 
    result= transformForeignKeyConstraintDefinitionToSql(fkey, table, destination, sql_variant);
1052
 
 
1053
 
    if (result != NONE)
1054
 
      return result;
1055
 
  }
1056
 
 
1057
 
  destination.append("\n)");
 
878
  destination.append("\n)", 2);
1058
879
 
1059
880
  /* Add ENGINE = " clause */
1060
881
  if (table.has_engine())
1061
882
  {
1062
 
    destination.append(" ENGINE=");
1063
 
    destination.append(table.engine().name());
 
883
    const Table::StorageEngine &engine= table.engine();
 
884
    destination.append("\nENGINE = ", 10);
 
885
    destination.append(engine.name());
1064
886
 
1065
 
    size_t num_engine_options= table.engine().options_size();
1066
 
    if (num_engine_options > 0)
1067
 
      destination.append(" ", 1);
 
887
    size_t num_engine_options= engine.option_size();
1068
888
    for (size_t x= 0; x < num_engine_options; ++x)
1069
889
    {
1070
 
      const Engine::Option &option= table.engine().options(x);
1071
 
      destination.append(option.name());
1072
 
      destination.append("='");
1073
 
      destination.append(option.state());
1074
 
      destination.append("'");
1075
 
      if (x != num_engine_options-1)
1076
 
      {
1077
 
        destination.append(", ");
1078
 
      }
 
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');
1079
896
    }
1080
897
  }
1081
898
 
1093
910
  if (sql_variant == ANSI)
1094
911
    return NONE; /* ANSI does not support table options... */
1095
912
 
 
913
  stringstream ss;
 
914
 
1096
915
  if (options.has_comment())
1097
916
  {
1098
 
    destination.append(" COMMENT=");
1099
 
    append_escaped_string(&destination, options.comment());
 
917
    destination.append("\nCOMMENT = '", 12);
 
918
    destination.append(options.comment());
 
919
    destination.push_back('\'');
1100
920
  }
1101
921
 
1102
922
  if (options.has_collation())
1103
923
  {
1104
 
    destination.append(" COLLATE = ");
 
924
    destination.append("\nCOLLATE = ", 11);
1105
925
    destination.append(options.collation());
1106
926
  }
1107
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
 
1108
944
  if (options.has_data_file_name())
1109
945
  {
1110
 
    destination.append("\nDATA_FILE_NAME = '");
 
946
    destination.append("\nDATA_FILE_NAME = '", 19);
1111
947
    destination.append(options.data_file_name());
1112
948
    destination.push_back('\'');
1113
949
  }
1114
950
 
1115
951
  if (options.has_index_file_name())
1116
952
  {
1117
 
    destination.append("\nINDEX_FILE_NAME = '");
 
953
    destination.append("\nINDEX_FILE_NAME = '", 20);
1118
954
    destination.append(options.index_file_name());
1119
955
    destination.push_back('\'');
1120
956
  }
1121
957
 
1122
958
  if (options.has_max_rows())
1123
959
  {
1124
 
    destination.append("\nMAX_ROWS = ");
1125
 
    destination.append(boost::lexical_cast<string>(options.max_rows()));
 
960
    ss << options.max_rows();
 
961
    destination.append("\nMAX_ROWS = ", 12);
 
962
    destination.append(ss.str());
 
963
    ss.clear();
1126
964
  }
1127
965
 
1128
966
  if (options.has_min_rows())
1129
967
  {
1130
 
    destination.append("\nMIN_ROWS = ");
1131
 
    destination.append(boost::lexical_cast<string>(options.min_rows()));
 
968
    ss << options.min_rows();
 
969
    destination.append("\nMIN_ROWS = ", 12);
 
970
    destination.append(ss.str());
 
971
    ss.clear();
1132
972
  }
1133
973
 
1134
 
  if (options.has_user_set_auto_increment_value()
1135
 
      && options.has_auto_increment_value())
 
974
  if (options.has_auto_increment_value())
1136
975
  {
1137
 
    destination.append(" AUTO_INCREMENT=");
1138
 
    destination.append(boost::lexical_cast<string>(options.auto_increment_value()));
 
976
    ss << options.auto_increment_value();
 
977
    destination.append("\nAUTO_INCREMENT = ", 18);
 
978
    destination.append(ss.str());
 
979
    ss.clear();
1139
980
  }
1140
981
 
1141
982
  if (options.has_avg_row_length())
1142
983
  {
1143
 
    destination.append("\nAVG_ROW_LENGTH = ");
1144
 
    destination.append(boost::lexical_cast<string>(options.avg_row_length()));
1145
 
  }
1146
 
 
1147
 
  if (options.has_checksum() && options.checksum())
1148
 
    destination.append("\nCHECKSUM = TRUE");
1149
 
 
1150
 
  if (options.has_page_checksum() && options.page_checksum())
1151
 
    destination.append("\nPAGE_CHECKSUM = TRUE");
1152
 
 
1153
 
  if (options.has_dont_replicate() and options.dont_replicate())
1154
 
  {
1155
 
    destination.append(" REPLICATION = FALSE");
1156
 
  }
 
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);
1157
1018
 
1158
1019
  return NONE;
1159
1020
}
1168
1029
  if (sql_variant == ANSI)
1169
1030
    quoted_identifier= '"';
1170
1031
 
1171
 
  destination.append("  ", 2);
1172
 
 
1173
1032
  if (index.is_primary())
1174
 
    destination.append("PRIMARY ");
 
1033
    destination.append("PRIMARY ", 8);
1175
1034
  else if (index.is_unique())
1176
 
    destination.append("UNIQUE ");
 
1035
    destination.append("UNIQUE ", 7);
1177
1036
 
1178
1037
  destination.append("KEY ", 4);
1179
 
  if (! (index.is_primary() && index.name().compare("PRIMARY")==0))
1180
 
  {
1181
 
    destination.push_back(quoted_identifier);
1182
 
    destination.append(index.name());
1183
 
    destination.push_back(quoted_identifier);
1184
 
    destination.append(" (", 2);
1185
 
  }
1186
 
  else
1187
 
    destination.append("(", 1);
1188
 
 
 
1038
  destination.push_back(quoted_identifier);
 
1039
  destination.append(index.name());
 
1040
  destination.push_back(quoted_identifier);
 
1041
  destination.append(" (", 2);
 
1042
  
1189
1043
  size_t num_parts= index.index_part_size();
1190
1044
  for (size_t x= 0; x < num_parts; ++x)
1191
1045
  {
1209
1063
    {
1210
1064
      if (part.has_compare_length())
1211
1065
      {
1212
 
        if (part.compare_length() != field.string_options().length())
 
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())
1213
1074
        {
 
1075
          stringstream ss;
1214
1076
          destination.push_back('(');
1215
 
          destination.append(boost::lexical_cast<string>(part.compare_length()));
 
1077
          ss << compare_length_in_chars;
 
1078
          destination.append(ss.str());
1216
1079
          destination.push_back(')');
1217
1080
        }
1218
1081
      }
1220
1083
  }
1221
1084
  destination.push_back(')');
1222
1085
 
1223
 
  switch (index.type())
1224
 
  {
1225
 
  case Table::Index::UNKNOWN_INDEX:
1226
 
    break;
1227
 
  case Table::Index::BTREE:
1228
 
    destination.append(" USING BTREE");
1229
 
    break;
1230
 
  case Table::Index::RTREE:
1231
 
    destination.append(" USING RTREE");
1232
 
    break;
1233
 
  case Table::Index::HASH:
1234
 
    destination.append(" USING HASH");
1235
 
    break;
1236
 
  case Table::Index::FULLTEXT:
1237
 
    destination.append(" USING FULLTEXT");
1238
 
    break;
1239
 
  }
1240
 
 
1241
 
  if (index.has_comment())
1242
 
  {
1243
 
    destination.append(" COMMENT ");
1244
 
    append_escaped_string(&destination, index.comment());
1245
 
  }
1246
 
 
1247
 
  return NONE;
1248
 
}
1249
 
 
1250
 
static void transformForeignKeyOptionToSql(Table::ForeignKeyConstraint::ForeignKeyOption opt, string &destination)
1251
 
{
1252
 
  switch (opt)
1253
 
  {
1254
 
  case Table::ForeignKeyConstraint::OPTION_RESTRICT:
1255
 
    destination.append("RESTRICT");
1256
 
    break;
1257
 
  case Table::ForeignKeyConstraint::OPTION_CASCADE:
1258
 
    destination.append("CASCADE");
1259
 
    break;
1260
 
  case Table::ForeignKeyConstraint::OPTION_SET_NULL:
1261
 
    destination.append("SET NULL");
1262
 
    break;
1263
 
  case Table::ForeignKeyConstraint::OPTION_UNDEF:
1264
 
  case Table::ForeignKeyConstraint::OPTION_NO_ACTION:
1265
 
    destination.append("NO ACTION");
1266
 
    break;
1267
 
  case Table::ForeignKeyConstraint::OPTION_SET_DEFAULT:
1268
 
    destination.append("SET DEFAULT");
1269
 
    break;
1270
 
  }
1271
 
}
1272
 
 
1273
 
enum TransformSqlError
1274
 
transformForeignKeyConstraintDefinitionToSql(const Table::ForeignKeyConstraint &fkey,
1275
 
                                             const Table &,
1276
 
                                             string &destination,
1277
 
                                             enum TransformSqlVariant sql_variant)
1278
 
{
1279
 
  char quoted_identifier= '`';
1280
 
  if (sql_variant == ANSI)
1281
 
    quoted_identifier= '"';
1282
 
 
1283
 
  destination.append("  ");
1284
 
 
1285
 
  if (fkey.has_name())
1286
 
  {
1287
 
    destination.append("CONSTRAINT ");
1288
 
    append_escaped_string(&destination, fkey.name(), quoted_identifier);
1289
 
    destination.append(" ", 1);
1290
 
  }
1291
 
 
1292
 
  destination.append("FOREIGN KEY (");
1293
 
 
1294
 
  for (ssize_t x= 0; x < fkey.column_names_size(); ++x)
1295
 
  {
1296
 
    if (x != 0)
1297
 
      destination.append(", ");
1298
 
 
1299
 
    append_escaped_string(&destination, fkey.column_names(x),
1300
 
                          quoted_identifier);
1301
 
  }
1302
 
 
1303
 
  destination.append(") REFERENCES ");
1304
 
 
1305
 
  append_escaped_string(&destination, fkey.references_table_name(),
1306
 
                        quoted_identifier);
1307
 
  destination.append(" (");
1308
 
 
1309
 
  for (ssize_t x= 0; x < fkey.references_columns_size(); ++x)
1310
 
  {
1311
 
    if (x != 0)
1312
 
      destination.append(", ");
1313
 
 
1314
 
    append_escaped_string(&destination, fkey.references_columns(x),
1315
 
                          quoted_identifier);
1316
 
  }
1317
 
 
1318
 
  destination.push_back(')');
1319
 
 
1320
 
  if (fkey.has_update_option() and fkey.update_option() != Table::ForeignKeyConstraint::OPTION_UNDEF)
1321
 
  {
1322
 
    destination.append(" ON UPDATE ");
1323
 
    transformForeignKeyOptionToSql(fkey.update_option(), destination);
1324
 
  }
1325
 
 
1326
 
  if (fkey.has_delete_option() and fkey.delete_option() != Table::ForeignKeyConstraint::OPTION_UNDEF)
1327
 
  {
1328
 
    destination.append(" ON DELETE ");
1329
 
    transformForeignKeyOptionToSql(fkey.delete_option(), destination);
1330
 
  }
1331
 
 
1332
1086
  return NONE;
1333
1087
}
1334
1088
 
1338
1092
                              enum TransformSqlVariant sql_variant)
1339
1093
{
1340
1094
  char quoted_identifier= '`';
1341
 
  char quoted_default;
1342
 
 
1343
1095
  if (sql_variant == ANSI)
1344
1096
    quoted_identifier= '"';
1345
1097
 
1346
 
  if (sql_variant == DRIZZLE)
1347
 
    quoted_default= '\'';
1348
 
  else
1349
 
    quoted_default= quoted_identifier;
1350
 
 
1351
 
  append_escaped_string(&destination, field.name(), quoted_identifier);
 
1098
  destination.push_back(quoted_identifier);
 
1099
  destination.append(field.name());
 
1100
  destination.push_back(quoted_identifier);
1352
1101
 
1353
1102
  Table::Field::FieldType field_type= field.type();
1354
1103
 
1355
1104
  switch (field_type)
1356
1105
  {
1357
1106
    case Table::Field::DOUBLE:
1358
 
    destination.append(" DOUBLE");
1359
 
    if (field.has_numeric_options()
1360
 
        && field.numeric_options().has_precision())
1361
 
    {
1362
 
      stringstream ss;
1363
 
      ss << "(" << field.numeric_options().precision() << ",";
1364
 
      ss << field.numeric_options().scale() << ")";
1365
 
      destination.append(ss.str());
1366
 
    }
 
1107
    destination.append(" DOUBLE", 7);
1367
1108
    break;
1368
1109
  case Table::Field::VARCHAR:
1369
1110
    {
1370
 
      if (field.string_options().has_collation()
1371
 
          && field.string_options().collation().compare("binary") == 0)
1372
 
        destination.append(" VARBINARY(");
1373
 
      else
1374
 
        destination.append(" VARCHAR(");
1375
 
 
1376
 
      destination.append(boost::lexical_cast<string>(field.string_options().length()));
1377
 
      destination.append(")");
 
1111
      destination.append(" VARCHAR(", 9);
 
1112
      stringstream ss;
 
1113
      ss << field.string_options().length() << ")";
 
1114
      destination.append(ss.str());
1378
1115
    }
1379
1116
    break;
1380
1117
  case Table::Field::BLOB:
1381
 
    {
1382
 
      if (field.string_options().has_collation()
1383
 
          && field.string_options().collation().compare("binary") == 0)
1384
 
        destination.append(" BLOB");
1385
 
      else
1386
 
        destination.append(" TEXT");
1387
 
    }
 
1118
    destination.append(" BLOB", 5);
1388
1119
    break;
1389
1120
  case Table::Field::ENUM:
1390
1121
    {
1391
1122
      size_t num_field_values= field.enumeration_values().field_value_size();
1392
 
      destination.append(" ENUM(");
 
1123
      destination.append(" ENUM(", 6);
1393
1124
      for (size_t x= 0; x < num_field_values; ++x)
1394
1125
      {
1395
1126
        const string &type= field.enumeration_values().field_value(x);
1404
1135
      destination.push_back(')');
1405
1136
      break;
1406
1137
    }
1407
 
  case Table::Field::UUID:
1408
 
    destination.append(" UUID");
1409
 
    break;
1410
 
  case Table::Field::BOOLEAN:
1411
 
    destination.append(" BOOLEAN");
1412
 
    break;
1413
1138
  case Table::Field::INTEGER:
1414
 
    destination.append(" INT");
 
1139
    destination.append(" INT", 4);
1415
1140
    break;
1416
1141
  case Table::Field::BIGINT:
1417
 
    if (field.has_constraints() and
1418
 
        field.constraints().is_unsigned())
1419
 
    {
1420
 
      destination.append(" BIGINT UNSIGNED");
1421
 
    }
1422
 
    else
1423
 
    {
1424
 
      destination.append(" BIGINT");
1425
 
    }
 
1142
    destination.append(" BIGINT", 7);
1426
1143
    break;
1427
1144
  case Table::Field::DECIMAL:
1428
1145
    {
1429
 
      destination.append(" DECIMAL(");
 
1146
      destination.append(" DECIMAL(", 9);
1430
1147
      stringstream ss;
1431
1148
      ss << field.numeric_options().precision() << ",";
1432
1149
      ss << field.numeric_options().scale() << ")";
1434
1151
    }
1435
1152
    break;
1436
1153
  case Table::Field::DATE:
1437
 
    destination.append(" DATE");
1438
 
    break;
1439
 
 
1440
 
  case Table::Field::EPOCH:
1441
 
    if (field.time_options().microseconds())
1442
 
    {
1443
 
      destination.append(" TIMESTAMP(6)");
1444
 
    }
1445
 
    else
1446
 
    {
1447
 
      destination.append(" TIMESTAMP");
1448
 
    }
1449
 
    break;
1450
 
 
 
1154
    destination.append(" DATE", 5);
 
1155
    break;
 
1156
  case Table::Field::TIMESTAMP:
 
1157
    destination.append(" TIMESTAMP",  10);
 
1158
    break;
1451
1159
  case Table::Field::DATETIME:
1452
 
    destination.append(" DATETIME");
1453
 
    break;
1454
 
  case Table::Field::TIME:
1455
 
    destination.append(" TIME");
1456
 
    break;
 
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
    }
1457
1192
  }
1458
1193
 
1459
1194
  if (field.type() == Table::Field::BLOB ||
1460
1195
      field.type() == Table::Field::VARCHAR)
1461
1196
  {
1462
 
    if (field.string_options().has_collation()
1463
 
        && field.string_options().collation().compare("binary"))
 
1197
    if (field.string_options().has_collation())
1464
1198
    {
1465
 
      destination.append(" COLLATE ");
 
1199
      destination.append(" COLLATE ", 9);
1466
1200
      destination.append(field.string_options().collation());
1467
1201
    }
1468
1202
  }
1469
1203
 
1470
 
  if (field.has_constraints() and field.constraints().is_unique())
1471
 
  {
1472
 
    destination.append(" UNIQUE");
1473
 
  }
1474
 
 
1475
 
  if (field.has_constraints() && field.constraints().is_notnull())
1476
 
  {
1477
 
    destination.append(" NOT NULL");
1478
 
  }
1479
 
  else if (field.type() == Table::Field::EPOCH)
1480
 
  {
1481
 
    destination.append(" NULL");
1482
 
  }
1483
 
 
1484
 
  if (field.type() == Table::Field::INTEGER || 
1485
 
      field.type() == Table::Field::BIGINT)
1486
 
  {
1487
 
    /* AUTO_INCREMENT must be after NOT NULL */
1488
 
    if (field.has_numeric_options() &&
1489
 
        field.numeric_options().is_autoincrement())
1490
 
    {
1491
 
      destination.append(" AUTO_INCREMENT");
1492
 
    }
1493
 
  }
1494
 
 
1495
1204
  if (field.options().has_default_value())
1496
1205
  {
1497
 
    destination.append(" DEFAULT ");
1498
 
    append_escaped_string(&destination, field.options().default_value());
1499
 
  }
1500
 
  else if (field.options().has_default_expression())
1501
 
  {
1502
 
    destination.append(" DEFAULT ");
1503
 
    destination.append(field.options().default_expression());
1504
 
  }
1505
 
  else if (field.options().has_default_bin_value())
 
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())
1506
1213
  {
1507
1214
    const string &v= field.options().default_bin_value();
1508
 
    if (v.length() == 0)
1509
 
    {
1510
 
      destination.append(" DEFAULT ''");
1511
 
    }
1512
 
    else
1513
 
    {
1514
 
      destination.append(" DEFAULT 0x");
1515
 
      for (size_t x= 0; x < v.length(); x++)
1516
 
      {
1517
 
        char hex[3];
1518
 
        snprintf(hex, sizeof(hex), "%.2X", *(v.c_str() + x));
1519
 
        destination.append(hex, 2);
1520
 
      }
1521
 
    }
1522
 
  }
1523
 
  else if (field.options().has_default_null()
1524
 
           && field.options().default_null()
1525
 
           && field.type() != Table::Field::BLOB)
1526
 
  {
1527
 
    destination.append(" DEFAULT NULL");
 
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
    }
1528
1220
  }
1529
1221
 
1530
 
  if (field.has_options() && field.options().has_update_expression())
1531
 
  {
1532
 
    destination.append(" ON UPDATE ");
1533
 
    destination.append(field.options().update_expression());
1534
 
  }
 
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);
1535
1226
 
1536
1227
  if (field.has_comment())
1537
1228
  {
1538
 
    destination.append(" COMMENT ");
1539
 
    append_escaped_string(&destination, field.comment(), quoted_default);
 
1229
    destination.append(" COMMENT ", 9);
 
1230
    destination.push_back(quoted_identifier);
 
1231
    destination.append(field.comment());
 
1232
    destination.push_back(quoted_identifier);
1540
1233
  }
1541
1234
  return NONE;
1542
1235
}
1549
1242
  case Table::Field::DECIMAL:
1550
1243
  case Table::Field::INTEGER:
1551
1244
  case Table::Field::BIGINT:
 
1245
  case Table::Field::ENUM:
1552
1246
    return false;
1553
1247
  default:
1554
1248
    return true;
1565
1259
  case DRIZZLE_TYPE_NULL:
1566
1260
    assert(false); /* Not a user definable type */
1567
1261
    return Table::Field::INTEGER; /* unreachable */
1568
 
  case DRIZZLE_TYPE_MICROTIME:
1569
1262
  case DRIZZLE_TYPE_TIMESTAMP:
1570
 
    return Table::Field::EPOCH;
 
1263
    return Table::Field::TIMESTAMP;
1571
1264
  case DRIZZLE_TYPE_LONGLONG:
1572
1265
    return Table::Field::BIGINT;
1573
1266
  case DRIZZLE_TYPE_DATETIME:
1574
1267
    return Table::Field::DATETIME;
1575
 
  case DRIZZLE_TYPE_TIME:
1576
 
    return Table::Field::TIME;
1577
1268
  case DRIZZLE_TYPE_DATE:
1578
1269
    return Table::Field::DATE;
1579
1270
  case DRIZZLE_TYPE_VARCHAR:
1584
1275
    return Table::Field::ENUM;
1585
1276
  case DRIZZLE_TYPE_BLOB:
1586
1277
    return Table::Field::BLOB;
1587
 
  case DRIZZLE_TYPE_UUID:
1588
 
    return Table::Field::UUID;
1589
 
  case DRIZZLE_TYPE_BOOLEAN:
1590
 
    return Table::Field::BOOLEAN;
1591
1278
  }
1592
1279
 
1593
1280
  assert(false);