← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/message/statement_transform.cc

  • Committer: Brian Aker
  • Date: 2011-02-22 06:12:02 UTC
  • mfrom: (2190.1.6 drizzle-build)
  • Revision ID: brian@tangent.org-20110222061202-k03czxykqy4x9hjs
List update, header fixes, multiple symbols, and David deletes some code.

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
5
 
 *  Copyright (c) 2010 Jay Pipes
 
4
 *  Copyright (C) 2009 Sun Microsystems, Inc.
 
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
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"
 
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>
41
41
 
42
42
#include <string>
43
43
#include <vector>
127
127
 
128
128
  switch (source.type())
129
129
  {
 
130
  case Statement::ROLLBACK_STATEMENT:
 
131
    {
 
132
      break;
 
133
    }
130
134
  case Statement::ROLLBACK:
131
135
    {
132
136
      sql_strings.push_back("ROLLBACK");
148
152
      const InsertHeader &insert_header= source.insert_header();
149
153
      const InsertData &insert_data= source.insert_data();
150
154
      size_t num_keys= insert_data.record_size();
151
 
      size_t x;
152
155
 
153
156
      if (num_keys > 1 && ! already_in_transaction)
154
157
        sql_strings.push_back("START TRANSACTION");
155
158
 
156
 
      for (x= 0; x < num_keys; ++x)
 
159
      for (size_t x= 0; x < num_keys; ++x)
157
160
      {
158
161
        string destination;
159
162
 
314
317
      sql_strings.push_back(destination);
315
318
    }
316
319
    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;
317
330
  case Statement::SET_VARIABLE:
318
331
    {
319
332
      assert(source.has_set_variable_statement());
802
815
}
803
816
 
804
817
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
805
849
transformDropSchemaStatementToSql(const DropSchemaStatement &statement,
806
850
                                  string &destination,
807
851
                                  enum TransformSqlVariant sql_variant)
829
873
 
830
874
  const Schema &schema= statement.schema();
831
875
 
832
 
  destination.append("CREATE SCHEMA ", 14);
 
876
  destination.append("CREATE SCHEMA ");
833
877
  destination.push_back(quoted_identifier);
834
878
  destination.append(schema.name());
835
879
  destination.push_back(quoted_identifier);
836
880
 
837
881
  if (schema.has_collation())
838
882
  {
839
 
    destination.append(" COLLATE ", 9);
 
883
    destination.append(" COLLATE ");
840
884
    destination.append(schema.collation());
841
885
  }
842
886
 
 
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
 
843
892
  return NONE;
844
893
}
845
894
 
854
903
 
855
904
  const TableMetadata &table_metadata= statement.table_metadata();
856
905
 
857
 
  destination.append("DROP TABLE ", 11);
 
906
  destination.append("DROP TABLE ");
858
907
 
859
908
  /* Add the IF EXISTS clause if necessary */
860
909
  if (statement.has_if_exists_clause() &&
861
910
      statement.if_exists_clause() == true)
862
911
  {
863
 
    destination.append("IF EXISTS ", 10);
 
912
    destination.append("IF EXISTS ");
864
913
  }
865
914
 
866
915
  destination.push_back(quoted_identifier);
885
934
 
886
935
  const TableMetadata &table_metadata= statement.table_metadata();
887
936
 
888
 
  destination.append("TRUNCATE TABLE ", 15);
 
937
  destination.append("TRUNCATE TABLE ");
889
938
  destination.push_back(quoted_identifier);
890
939
  destination.append(table_metadata.schema_name());
891
940
  destination.push_back(quoted_identifier);
906
955
  const FieldMetadata &variable_metadata= statement.variable_metadata();
907
956
  bool should_quote_field_value= shouldQuoteFieldValue(variable_metadata.type());
908
957
 
909
 
  destination.append("SET GLOBAL ", 11); /* Only global variables are replicated */
 
958
  destination.append("SET GLOBAL "); /* Only global variables are replicated */
910
959
  destination.append(variable_metadata.name());
911
960
  destination.push_back('=');
912
961
 
938
987
  if (sql_variant == ANSI)
939
988
    quoted_identifier= '"';
940
989
 
941
 
  destination.append("CREATE ", 7);
 
990
  destination.append("CREATE ");
942
991
 
943
992
  if (table.type() == Table::TEMPORARY)
944
 
    destination.append("TEMPORARY ", 10);
 
993
    destination.append("TEMPORARY ");
945
994
  
946
 
  destination.append("TABLE ", 6);
 
995
  destination.append("TABLE ");
947
996
  if (with_schema)
948
997
  {
949
998
    append_escaped_string(&destination, table.schema(), quoted_identifier);
950
999
    destination.push_back('.');
951
1000
  }
952
1001
  append_escaped_string(&destination, table.name(), quoted_identifier);
953
 
  destination.append(" (\n", 3);
 
1002
  destination.append(" (\n");
954
1003
 
955
1004
  enum TransformSqlError result= NONE;
956
1005
  size_t num_fields= table.field_size();
959
1008
    const Table::Field &field= table.field(x);
960
1009
 
961
1010
    if (x != 0)
962
 
      destination.append(",\n", 2);
 
1011
      destination.append(",\n");
963
1012
 
964
1013
    destination.append("  ");
965
1014
 
972
1021
  size_t num_indexes= table.indexes_size();
973
1022
  
974
1023
  if (num_indexes > 0)
975
 
    destination.append(",\n", 2);
 
1024
    destination.append(",\n");
976
1025
 
977
1026
  for (size_t x= 0; x < num_indexes; ++x)
978
1027
  {
979
1028
    const message::Table::Index &index= table.indexes(x);
980
1029
 
981
1030
    if (x != 0)
982
 
      destination.append(",\n", 2);
 
1031
      destination.append(",\n");
983
1032
 
984
1033
    result= transformIndexDefinitionToSql(index, table, destination, sql_variant);
985
1034
    
990
1039
  size_t num_foreign_keys= table.fk_constraint_size();
991
1040
 
992
1041
  if (num_foreign_keys > 0)
993
 
    destination.append(",\n", 2);
 
1042
    destination.append(",\n");
994
1043
 
995
1044
  for (size_t x= 0; x < num_foreign_keys; ++x)
996
1045
  {
997
1046
    const message::Table::ForeignKeyConstraint &fkey= table.fk_constraint(x);
998
1047
 
999
1048
    if (x != 0)
1000
 
      destination.append(",\n", 2);
 
1049
      destination.append(",\n");
1001
1050
 
1002
1051
    result= transformForeignKeyConstraintDefinitionToSql(fkey, table, destination, sql_variant);
1003
1052
 
1005
1054
      return result;
1006
1055
  }
1007
1056
 
1008
 
  destination.append("\n)", 2);
 
1057
  destination.append("\n)");
1009
1058
 
1010
1059
  /* Add ENGINE = " clause */
1011
1060
  if (table.has_engine())
1012
1061
  {
1013
 
    destination.append(" ENGINE=", 8);
 
1062
    destination.append(" ENGINE=");
1014
1063
    destination.append(table.engine().name());
1015
1064
 
1016
1065
    size_t num_engine_options= table.engine().options_size();
1020
1069
    {
1021
1070
      const Engine::Option &option= table.engine().options(x);
1022
1071
      destination.append(option.name());
1023
 
      destination.append("='", 2);
 
1072
      destination.append("='");
1024
1073
      destination.append(option.state());
1025
 
      destination.append("'", 1);
1026
 
      if(x != num_engine_options-1)
1027
 
        destination.append(", ", 2);
 
1074
      destination.append("'");
 
1075
      if (x != num_engine_options-1)
 
1076
      {
 
1077
        destination.append(", ");
 
1078
      }
1028
1079
    }
1029
1080
  }
1030
1081
 
1044
1095
 
1045
1096
  if (options.has_comment())
1046
1097
  {
1047
 
    destination.append(" COMMENT=", 9);
 
1098
    destination.append(" COMMENT=");
1048
1099
    append_escaped_string(&destination, options.comment());
1049
1100
  }
1050
1101
 
1051
1102
  if (options.has_collation())
1052
1103
  {
1053
 
    destination.append(" COLLATE = ", 11);
 
1104
    destination.append(" COLLATE = ");
1054
1105
    destination.append(options.collation());
1055
1106
  }
1056
1107
 
1057
1108
  if (options.has_data_file_name())
1058
1109
  {
1059
 
    destination.append("\nDATA_FILE_NAME = '", 19);
 
1110
    destination.append("\nDATA_FILE_NAME = '");
1060
1111
    destination.append(options.data_file_name());
1061
1112
    destination.push_back('\'');
1062
1113
  }
1063
1114
 
1064
1115
  if (options.has_index_file_name())
1065
1116
  {
1066
 
    destination.append("\nINDEX_FILE_NAME = '", 20);
 
1117
    destination.append("\nINDEX_FILE_NAME = '");
1067
1118
    destination.append(options.index_file_name());
1068
1119
    destination.push_back('\'');
1069
1120
  }
1070
1121
 
1071
1122
  if (options.has_max_rows())
1072
1123
  {
1073
 
    destination.append("\nMAX_ROWS = ", 12);
 
1124
    destination.append("\nMAX_ROWS = ");
1074
1125
    destination.append(boost::lexical_cast<string>(options.max_rows()));
1075
1126
  }
1076
1127
 
1077
1128
  if (options.has_min_rows())
1078
1129
  {
1079
 
    destination.append("\nMIN_ROWS = ", 12);
 
1130
    destination.append("\nMIN_ROWS = ");
1080
1131
    destination.append(boost::lexical_cast<string>(options.min_rows()));
1081
1132
  }
1082
1133
 
1083
1134
  if (options.has_user_set_auto_increment_value()
1084
1135
      && options.has_auto_increment_value())
1085
1136
  {
1086
 
    destination.append(" AUTO_INCREMENT=", 16);
 
1137
    destination.append(" AUTO_INCREMENT=");
1087
1138
    destination.append(boost::lexical_cast<string>(options.auto_increment_value()));
1088
1139
  }
1089
1140
 
1090
1141
  if (options.has_avg_row_length())
1091
1142
  {
1092
 
    destination.append("\nAVG_ROW_LENGTH = ", 18);
 
1143
    destination.append("\nAVG_ROW_LENGTH = ");
1093
1144
    destination.append(boost::lexical_cast<string>(options.avg_row_length()));
1094
1145
  }
1095
1146
 
1096
 
  if (options.has_checksum() &&
1097
 
      options.checksum())
1098
 
    destination.append("\nCHECKSUM = TRUE", 16);
1099
 
  if (options.has_page_checksum() &&
1100
 
      options.page_checksum())
1101
 
    destination.append("\nPAGE_CHECKSUM = TRUE", 21);
 
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
  }
1102
1157
 
1103
1158
  return NONE;
1104
1159
}
1116
1171
  destination.append("  ", 2);
1117
1172
 
1118
1173
  if (index.is_primary())
1119
 
    destination.append("PRIMARY ", 8);
 
1174
    destination.append("PRIMARY ");
1120
1175
  else if (index.is_unique())
1121
 
    destination.append("UNIQUE ", 7);
 
1176
    destination.append("UNIQUE ");
1122
1177
 
1123
1178
  destination.append("KEY ", 4);
1124
1179
  if (! (index.is_primary() && index.name().compare("PRIMARY")==0))
1170
1225
  case Table::Index::UNKNOWN_INDEX:
1171
1226
    break;
1172
1227
  case Table::Index::BTREE:
1173
 
    destination.append(" USING BTREE", 12);
 
1228
    destination.append(" USING BTREE");
1174
1229
    break;
1175
1230
  case Table::Index::RTREE:
1176
 
    destination.append(" USING RTREE", 12);
 
1231
    destination.append(" USING RTREE");
1177
1232
    break;
1178
1233
  case Table::Index::HASH:
1179
 
    destination.append(" USING HASH", 11);
 
1234
    destination.append(" USING HASH");
1180
1235
    break;
1181
1236
  case Table::Index::FULLTEXT:
1182
 
    destination.append(" USING FULLTEXT", 15);
 
1237
    destination.append(" USING FULLTEXT");
1183
1238
    break;
1184
1239
  }
1185
1240
 
1186
1241
  if (index.has_comment())
1187
1242
  {
1188
 
    destination.append(" COMMENT ", 9);
 
1243
    destination.append(" COMMENT ");
1189
1244
    append_escaped_string(&destination, index.comment());
1190
1245
  }
1191
1246
 
1225
1280
  if (sql_variant == ANSI)
1226
1281
    quoted_identifier= '"';
1227
1282
 
1228
 
  destination.append("  ", 2);
 
1283
  destination.append("  ");
1229
1284
 
1230
1285
  if (fkey.has_name())
1231
1286
  {
1232
 
    destination.append("CONSTRAINT ", 11);
 
1287
    destination.append("CONSTRAINT ");
1233
1288
    append_escaped_string(&destination, fkey.name(), quoted_identifier);
1234
1289
    destination.append(" ", 1);
1235
1290
  }
1236
1291
 
1237
 
  destination.append("FOREIGN KEY (", 13);
 
1292
  destination.append("FOREIGN KEY (");
1238
1293
 
1239
1294
  for (ssize_t x= 0; x < fkey.column_names_size(); ++x)
1240
1295
  {
1245
1300
                          quoted_identifier);
1246
1301
  }
1247
1302
 
1248
 
  destination.append(") REFERENCES ", 13);
 
1303
  destination.append(") REFERENCES ");
1249
1304
 
1250
1305
  append_escaped_string(&destination, fkey.references_table_name(),
1251
1306
                        quoted_identifier);
1252
 
  destination.append(" (", 2);
 
1307
  destination.append(" (");
1253
1308
 
1254
1309
  for (ssize_t x= 0; x < fkey.references_columns_size(); ++x)
1255
1310
  {
1264
1319
 
1265
1320
  if (fkey.has_update_option() and fkey.update_option() != Table::ForeignKeyConstraint::OPTION_UNDEF)
1266
1321
  {
1267
 
    destination.append(" ON UPDATE ", 11);
 
1322
    destination.append(" ON UPDATE ");
1268
1323
    transformForeignKeyOptionToSql(fkey.update_option(), destination);
1269
1324
  }
1270
1325
 
1271
1326
  if (fkey.has_delete_option() and fkey.delete_option() != Table::ForeignKeyConstraint::OPTION_UNDEF)
1272
1327
  {
1273
 
    destination.append(" ON DELETE ", 11);
 
1328
    destination.append(" ON DELETE ");
1274
1329
    transformForeignKeyOptionToSql(fkey.delete_option(), destination);
1275
1330
  }
1276
1331
 
1300
1355
  switch (field_type)
1301
1356
  {
1302
1357
    case Table::Field::DOUBLE:
1303
 
    destination.append(" DOUBLE", 7);
 
1358
    destination.append(" DOUBLE");
1304
1359
    if (field.has_numeric_options()
1305
1360
        && field.numeric_options().has_precision())
1306
1361
    {
1314
1369
    {
1315
1370
      if (field.string_options().has_collation()
1316
1371
          && field.string_options().collation().compare("binary") == 0)
1317
 
        destination.append(" VARBINARY(", 11);
 
1372
        destination.append(" VARBINARY(");
1318
1373
      else
1319
 
        destination.append(" VARCHAR(", 9);
 
1374
        destination.append(" VARCHAR(");
1320
1375
 
1321
1376
      destination.append(boost::lexical_cast<string>(field.string_options().length()));
1322
1377
      destination.append(")");
1326
1381
    {
1327
1382
      if (field.string_options().has_collation()
1328
1383
          && field.string_options().collation().compare("binary") == 0)
1329
 
        destination.append(" BLOB", 5);
 
1384
        destination.append(" BLOB");
1330
1385
      else
1331
 
        destination.append(" TEXT", 5);
 
1386
        destination.append(" TEXT");
1332
1387
    }
1333
1388
    break;
1334
1389
  case Table::Field::ENUM:
1335
1390
    {
1336
1391
      size_t num_field_values= field.enumeration_values().field_value_size();
1337
 
      destination.append(" ENUM(", 6);
 
1392
      destination.append(" ENUM(");
1338
1393
      for (size_t x= 0; x < num_field_values; ++x)
1339
1394
      {
1340
1395
        const string &type= field.enumeration_values().field_value(x);
1349
1404
      destination.push_back(')');
1350
1405
      break;
1351
1406
    }
 
1407
  case Table::Field::UUID:
 
1408
    destination.append(" UUID");
 
1409
    break;
 
1410
  case Table::Field::BOOLEAN:
 
1411
    destination.append(" BOOLEAN");
 
1412
    break;
1352
1413
  case Table::Field::INTEGER:
1353
 
    destination.append(" INT", 4);
 
1414
    destination.append(" INT");
1354
1415
    break;
1355
1416
  case Table::Field::BIGINT:
1356
 
    destination.append(" BIGINT", 7);
 
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
    }
1357
1426
    break;
1358
1427
  case Table::Field::DECIMAL:
1359
1428
    {
1360
 
      destination.append(" DECIMAL(", 9);
 
1429
      destination.append(" DECIMAL(");
1361
1430
      stringstream ss;
1362
1431
      ss << field.numeric_options().precision() << ",";
1363
1432
      ss << field.numeric_options().scale() << ")";
1365
1434
    }
1366
1435
    break;
1367
1436
  case Table::Field::DATE:
1368
 
    destination.append(" DATE", 5);
1369
 
    break;
1370
 
  case Table::Field::TIMESTAMP:
1371
 
    destination.append(" TIMESTAMP",  10);
1372
 
    break;
 
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
 
1373
1451
  case Table::Field::DATETIME:
1374
 
    destination.append(" DATETIME",  9);
1375
 
    break;
1376
 
  }
1377
 
 
1378
 
  if (field.type() == Table::Field::INTEGER || 
1379
 
      field.type() == Table::Field::BIGINT)
1380
 
  {
1381
 
    if (field.has_constraints() &&
1382
 
        field.constraints().has_is_unsigned() &&
1383
 
        field.constraints().is_unsigned())
1384
 
    {
1385
 
      destination.append(" UNSIGNED", 9);
1386
 
    }
 
1452
    destination.append(" DATETIME");
 
1453
    break;
 
1454
  case Table::Field::TIME:
 
1455
    destination.append(" TIME");
 
1456
    break;
1387
1457
  }
1388
1458
 
1389
1459
  if (field.type() == Table::Field::BLOB ||
1392
1462
    if (field.string_options().has_collation()
1393
1463
        && field.string_options().collation().compare("binary"))
1394
1464
    {
1395
 
      destination.append(" COLLATE ", 9);
 
1465
      destination.append(" COLLATE ");
1396
1466
      destination.append(field.string_options().collation());
1397
1467
    }
1398
1468
  }
1399
1469
 
1400
 
  if (field.has_constraints() &&
1401
 
      ! field.constraints().is_nullable())
1402
 
  {
1403
 
    destination.append(" NOT NULL", 9);
1404
 
  }
1405
 
  else if (field.type() == Table::Field::TIMESTAMP)
1406
 
    destination.append(" NULL", 5);
 
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
  }
1407
1483
 
1408
1484
  if (field.type() == Table::Field::INTEGER || 
1409
1485
      field.type() == Table::Field::BIGINT)
1412
1488
    if (field.has_numeric_options() &&
1413
1489
        field.numeric_options().is_autoincrement())
1414
1490
    {
1415
 
      destination.append(" AUTO_INCREMENT", 15);
 
1491
      destination.append(" AUTO_INCREMENT");
1416
1492
    }
1417
1493
  }
1418
1494
 
1419
1495
  if (field.options().has_default_value())
1420
1496
  {
1421
 
    destination.append(" DEFAULT ", 9);
 
1497
    destination.append(" DEFAULT ");
1422
1498
    append_escaped_string(&destination, field.options().default_value());
1423
1499
  }
1424
1500
  else if (field.options().has_default_expression())
1425
1501
  {
1426
 
    destination.append(" DEFAULT ", 9);
 
1502
    destination.append(" DEFAULT ");
1427
1503
    destination.append(field.options().default_expression());
1428
1504
  }
1429
1505
  else if (field.options().has_default_bin_value())
1430
1506
  {
1431
1507
    const string &v= field.options().default_bin_value();
1432
1508
    if (v.length() == 0)
1433
 
      destination.append(" DEFAULT ''", 11);
 
1509
    {
 
1510
      destination.append(" DEFAULT ''");
 
1511
    }
1434
1512
    else
1435
1513
    {
1436
 
      destination.append(" DEFAULT 0x", 11);
 
1514
      destination.append(" DEFAULT 0x");
1437
1515
      for (size_t x= 0; x < v.length(); x++)
1438
1516
      {
1439
1517
        char hex[3];
1446
1524
           && field.options().default_null()
1447
1525
           && field.type() != Table::Field::BLOB)
1448
1526
  {
1449
 
    destination.append(" DEFAULT NULL", 13);
 
1527
    destination.append(" DEFAULT NULL");
1450
1528
  }
1451
1529
 
1452
1530
  if (field.has_options() && field.options().has_update_expression())
1453
1531
  {
1454
 
    destination.append(" ON UPDATE ", 11);
 
1532
    destination.append(" ON UPDATE ");
1455
1533
    destination.append(field.options().update_expression());
1456
1534
  }
1457
1535
 
1458
1536
  if (field.has_comment())
1459
1537
  {
1460
 
    destination.append(" COMMENT ", 9);
 
1538
    destination.append(" COMMENT ");
1461
1539
    append_escaped_string(&destination, field.comment(), quoted_default);
1462
1540
  }
1463
1541
  return NONE;
1487
1565
  case DRIZZLE_TYPE_NULL:
1488
1566
    assert(false); /* Not a user definable type */
1489
1567
    return Table::Field::INTEGER; /* unreachable */
 
1568
  case DRIZZLE_TYPE_MICROTIME:
1490
1569
  case DRIZZLE_TYPE_TIMESTAMP:
1491
 
    return Table::Field::TIMESTAMP;
 
1570
    return Table::Field::EPOCH;
1492
1571
  case DRIZZLE_TYPE_LONGLONG:
1493
1572
    return Table::Field::BIGINT;
1494
1573
  case DRIZZLE_TYPE_DATETIME:
1495
1574
    return Table::Field::DATETIME;
 
1575
  case DRIZZLE_TYPE_TIME:
 
1576
    return Table::Field::TIME;
1496
1577
  case DRIZZLE_TYPE_DATE:
1497
1578
    return Table::Field::DATE;
1498
1579
  case DRIZZLE_TYPE_VARCHAR:
1503
1584
    return Table::Field::ENUM;
1504
1585
  case DRIZZLE_TYPE_BLOB:
1505
1586
    return Table::Field::BLOB;
 
1587
  case DRIZZLE_TYPE_UUID:
 
1588
    return Table::Field::UUID;
 
1589
  case DRIZZLE_TYPE_BOOLEAN:
 
1590
    return Table::Field::BOOLEAN;
1506
1591
  }
1507
1592
 
1508
1593
  assert(false);