← 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-01-06 05:17:09 UTC
  • Revision ID: brian@tangent.org-20110106051709-oa0se8ur02uc6i9o
Added native functions into the function table.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/message/statement_transform.cc
318
318
      sql_strings.push_back(destination);
319
319
    }
320
320
    break;
321
 
  case Statement::ALTER_SCHEMA:
322
 
    {
323
 
      assert(source.has_alter_schema_statement());
324
 
      string destination;
325
 
      error= transformAlterSchemaStatementToSql(source.alter_schema_statement(),
326
 
                                                destination,
327
 
                                                sql_variant);
328
 
      sql_strings.push_back(destination);
329
 
    }
330
 
    break;
331
321
  case Statement::SET_VARIABLE:
332
322
    {
333
323
      assert(source.has_set_variable_statement());
816
806
}
817
807
 
818
808
enum TransformSqlError
819
 
transformAlterSchemaStatementToSql(const AlterSchemaStatement &statement,
820
 
                                   string &destination,
821
 
                                   enum TransformSqlVariant sql_variant)
822
 
{
823
 
  const Schema &before= statement.before();
824
 
  const Schema &after= statement.after();
825
 
 
826
 
  /* Make sure we are given the before and after for the same object */
827
 
  if (before.uuid() != after.uuid())
828
 
    return UUID_MISMATCH;
829
 
 
830
 
  char quoted_identifier= '`';
831
 
  if (sql_variant == ANSI)
832
 
    quoted_identifier= '"';
833
 
 
834
 
  destination.append("ALTER SCHEMA ");
835
 
  destination.push_back(quoted_identifier);
836
 
  destination.append(before.name());
837
 
  destination.push_back(quoted_identifier);
838
 
 
839
 
  /*
840
 
   * Diff our schemas. Currently, only collation can change so a
841
 
   * diff of the two structures is not really necessary.
842
 
   */
843
 
  destination.append(" COLLATE = ");
844
 
  destination.append(after.collation());
845
 
 
846
 
  return NONE;
847
 
}
848
 
 
849
 
enum TransformSqlError
850
809
transformDropSchemaStatementToSql(const DropSchemaStatement &statement,
851
810
                                  string &destination,
852
811
                                  enum TransformSqlVariant sql_variant)
874
833
 
875
834
  const Schema &schema= statement.schema();
876
835
 
877
 
  destination.append("CREATE SCHEMA ");
 
836
  destination.append("CREATE SCHEMA ", 14);
878
837
  destination.push_back(quoted_identifier);
879
838
  destination.append(schema.name());
880
839
  destination.push_back(quoted_identifier);
881
840
 
882
841
  if (schema.has_collation())
883
842
  {
884
 
    destination.append(" COLLATE ");
 
843
    destination.append(" COLLATE ", 9);
885
844
    destination.append(schema.collation());
886
845
  }
887
846
 
899
858
 
900
859
  const TableMetadata &table_metadata= statement.table_metadata();
901
860
 
902
 
  destination.append("DROP TABLE ");
 
861
  destination.append("DROP TABLE ", 11);
903
862
 
904
863
  /* Add the IF EXISTS clause if necessary */
905
864
  if (statement.has_if_exists_clause() &&
906
865
      statement.if_exists_clause() == true)
907
866
  {
908
 
    destination.append("IF EXISTS ");
 
867
    destination.append("IF EXISTS ", 10);
909
868
  }
910
869
 
911
870
  destination.push_back(quoted_identifier);
930
889
 
931
890
  const TableMetadata &table_metadata= statement.table_metadata();
932
891
 
933
 
  destination.append("TRUNCATE TABLE ");
 
892
  destination.append("TRUNCATE TABLE ", 15);
934
893
  destination.push_back(quoted_identifier);
935
894
  destination.append(table_metadata.schema_name());
936
895
  destination.push_back(quoted_identifier);
951
910
  const FieldMetadata &variable_metadata= statement.variable_metadata();
952
911
  bool should_quote_field_value= shouldQuoteFieldValue(variable_metadata.type());
953
912
 
954
 
  destination.append("SET GLOBAL "); /* Only global variables are replicated */
 
913
  destination.append("SET GLOBAL ", 11); /* Only global variables are replicated */
955
914
  destination.append(variable_metadata.name());
956
915
  destination.push_back('=');
957
916
 
983
942
  if (sql_variant == ANSI)
984
943
    quoted_identifier= '"';
985
944
 
986
 
  destination.append("CREATE ");
 
945
  destination.append("CREATE ", 7);
987
946
 
988
947
  if (table.type() == Table::TEMPORARY)
989
 
    destination.append("TEMPORARY ");
 
948
    destination.append("TEMPORARY ", 10);
990
949
  
991
 
  destination.append("TABLE ");
 
950
  destination.append("TABLE ", 6);
992
951
  if (with_schema)
993
952
  {
994
953
    append_escaped_string(&destination, table.schema(), quoted_identifier);
995
954
    destination.push_back('.');
996
955
  }
997
956
  append_escaped_string(&destination, table.name(), quoted_identifier);
998
 
  destination.append(" (\n");
 
957
  destination.append(" (\n", 3);
999
958
 
1000
959
  enum TransformSqlError result= NONE;
1001
960
  size_t num_fields= table.field_size();
1004
963
    const Table::Field &field= table.field(x);
1005
964
 
1006
965
    if (x != 0)
1007
 
      destination.append(",\n");
 
966
      destination.append(",\n", 2);
1008
967
 
1009
968
    destination.append("  ");
1010
969
 
1017
976
  size_t num_indexes= table.indexes_size();
1018
977
  
1019
978
  if (num_indexes > 0)
1020
 
    destination.append(",\n");
 
979
    destination.append(",\n", 2);
1021
980
 
1022
981
  for (size_t x= 0; x < num_indexes; ++x)
1023
982
  {
1024
983
    const message::Table::Index &index= table.indexes(x);
1025
984
 
1026
985
    if (x != 0)
1027
 
      destination.append(",\n");
 
986
      destination.append(",\n", 2);
1028
987
 
1029
988
    result= transformIndexDefinitionToSql(index, table, destination, sql_variant);
1030
989
    
1035
994
  size_t num_foreign_keys= table.fk_constraint_size();
1036
995
 
1037
996
  if (num_foreign_keys > 0)
1038
 
    destination.append(",\n");
 
997
    destination.append(",\n", 2);
1039
998
 
1040
999
  for (size_t x= 0; x < num_foreign_keys; ++x)
1041
1000
  {
1042
1001
    const message::Table::ForeignKeyConstraint &fkey= table.fk_constraint(x);
1043
1002
 
1044
1003
    if (x != 0)
1045
 
      destination.append(",\n");
 
1004
      destination.append(",\n", 2);
1046
1005
 
1047
1006
    result= transformForeignKeyConstraintDefinitionToSql(fkey, table, destination, sql_variant);
1048
1007
 
1050
1009
      return result;
1051
1010
  }
1052
1011
 
1053
 
  destination.append("\n)");
 
1012
  destination.append("\n)", 2);
1054
1013
 
1055
1014
  /* Add ENGINE = " clause */
1056
1015
  if (table.has_engine())
1057
1016
  {
1058
 
    destination.append(" ENGINE=");
 
1017
    destination.append(" ENGINE=", 8);
1059
1018
    destination.append(table.engine().name());
1060
1019
 
1061
1020
    size_t num_engine_options= table.engine().options_size();
1065
1024
    {
1066
1025
      const Engine::Option &option= table.engine().options(x);
1067
1026
      destination.append(option.name());
1068
 
      destination.append("='");
 
1027
      destination.append("='", 2);
1069
1028
      destination.append(option.state());
1070
 
      destination.append("'");
1071
 
      if (x != num_engine_options-1)
1072
 
      {
1073
 
        destination.append(", ");
1074
 
      }
 
1029
      destination.append("'", 1);
 
1030
      if(x != num_engine_options-1)
 
1031
        destination.append(", ", 2);
1075
1032
    }
1076
1033
  }
1077
1034
 
1091
1048
 
1092
1049
  if (options.has_comment())
1093
1050
  {
1094
 
    destination.append(" COMMENT=");
 
1051
    destination.append(" COMMENT=", 9);
1095
1052
    append_escaped_string(&destination, options.comment());
1096
1053
  }
1097
1054
 
1098
1055
  if (options.has_collation())
1099
1056
  {
1100
 
    destination.append(" COLLATE = ");
 
1057
    destination.append(" COLLATE = ", 11);
1101
1058
    destination.append(options.collation());
1102
1059
  }
1103
1060
 
1104
1061
  if (options.has_data_file_name())
1105
1062
  {
1106
 
    destination.append("\nDATA_FILE_NAME = '");
 
1063
    destination.append("\nDATA_FILE_NAME = '", 19);
1107
1064
    destination.append(options.data_file_name());
1108
1065
    destination.push_back('\'');
1109
1066
  }
1110
1067
 
1111
1068
  if (options.has_index_file_name())
1112
1069
  {
1113
 
    destination.append("\nINDEX_FILE_NAME = '");
 
1070
    destination.append("\nINDEX_FILE_NAME = '", 20);
1114
1071
    destination.append(options.index_file_name());
1115
1072
    destination.push_back('\'');
1116
1073
  }
1117
1074
 
1118
1075
  if (options.has_max_rows())
1119
1076
  {
1120
 
    destination.append("\nMAX_ROWS = ");
 
1077
    destination.append("\nMAX_ROWS = ", 12);
1121
1078
    destination.append(boost::lexical_cast<string>(options.max_rows()));
1122
1079
  }
1123
1080
 
1124
1081
  if (options.has_min_rows())
1125
1082
  {
1126
 
    destination.append("\nMIN_ROWS = ");
 
1083
    destination.append("\nMIN_ROWS = ", 12);
1127
1084
    destination.append(boost::lexical_cast<string>(options.min_rows()));
1128
1085
  }
1129
1086
 
1130
1087
  if (options.has_user_set_auto_increment_value()
1131
1088
      && options.has_auto_increment_value())
1132
1089
  {
1133
 
    destination.append(" AUTO_INCREMENT=");
 
1090
    destination.append(" AUTO_INCREMENT=", 16);
1134
1091
    destination.append(boost::lexical_cast<string>(options.auto_increment_value()));
1135
1092
  }
1136
1093
 
1137
1094
  if (options.has_avg_row_length())
1138
1095
  {
1139
 
    destination.append("\nAVG_ROW_LENGTH = ");
 
1096
    destination.append("\nAVG_ROW_LENGTH = ", 18);
1140
1097
    destination.append(boost::lexical_cast<string>(options.avg_row_length()));
1141
1098
  }
1142
1099
 
1143
1100
  if (options.has_checksum() &&
1144
1101
      options.checksum())
1145
 
    destination.append("\nCHECKSUM = TRUE");
 
1102
    destination.append("\nCHECKSUM = TRUE", 16);
1146
1103
  if (options.has_page_checksum() &&
1147
1104
      options.page_checksum())
1148
 
    destination.append("\nPAGE_CHECKSUM = TRUE");
 
1105
    destination.append("\nPAGE_CHECKSUM = TRUE", 21);
1149
1106
 
1150
1107
  return NONE;
1151
1108
}
1163
1120
  destination.append("  ", 2);
1164
1121
 
1165
1122
  if (index.is_primary())
1166
 
    destination.append("PRIMARY ");
 
1123
    destination.append("PRIMARY ", 8);
1167
1124
  else if (index.is_unique())
1168
 
    destination.append("UNIQUE ");
 
1125
    destination.append("UNIQUE ", 7);
1169
1126
 
1170
1127
  destination.append("KEY ", 4);
1171
1128
  if (! (index.is_primary() && index.name().compare("PRIMARY")==0))
1217
1174
  case Table::Index::UNKNOWN_INDEX:
1218
1175
    break;
1219
1176
  case Table::Index::BTREE:
1220
 
    destination.append(" USING BTREE");
 
1177
    destination.append(" USING BTREE", 12);
1221
1178
    break;
1222
1179
  case Table::Index::RTREE:
1223
 
    destination.append(" USING RTREE");
 
1180
    destination.append(" USING RTREE", 12);
1224
1181
    break;
1225
1182
  case Table::Index::HASH:
1226
 
    destination.append(" USING HASH");
 
1183
    destination.append(" USING HASH", 11);
1227
1184
    break;
1228
1185
  case Table::Index::FULLTEXT:
1229
 
    destination.append(" USING FULLTEXT");
 
1186
    destination.append(" USING FULLTEXT", 15);
1230
1187
    break;
1231
1188
  }
1232
1189
 
1233
1190
  if (index.has_comment())
1234
1191
  {
1235
 
    destination.append(" COMMENT ");
 
1192
    destination.append(" COMMENT ", 9);
1236
1193
    append_escaped_string(&destination, index.comment());
1237
1194
  }
1238
1195
 
1272
1229
  if (sql_variant == ANSI)
1273
1230
    quoted_identifier= '"';
1274
1231
 
1275
 
  destination.append("  ");
 
1232
  destination.append("  ", 2);
1276
1233
 
1277
1234
  if (fkey.has_name())
1278
1235
  {
1279
 
    destination.append("CONSTRAINT ");
 
1236
    destination.append("CONSTRAINT ", 11);
1280
1237
    append_escaped_string(&destination, fkey.name(), quoted_identifier);
1281
1238
    destination.append(" ", 1);
1282
1239
  }
1283
1240
 
1284
 
  destination.append("FOREIGN KEY (");
 
1241
  destination.append("FOREIGN KEY (", 13);
1285
1242
 
1286
1243
  for (ssize_t x= 0; x < fkey.column_names_size(); ++x)
1287
1244
  {
1292
1249
                          quoted_identifier);
1293
1250
  }
1294
1251
 
1295
 
  destination.append(") REFERENCES ");
 
1252
  destination.append(") REFERENCES ", 13);
1296
1253
 
1297
1254
  append_escaped_string(&destination, fkey.references_table_name(),
1298
1255
                        quoted_identifier);
1299
 
  destination.append(" (");
 
1256
  destination.append(" (", 2);
1300
1257
 
1301
1258
  for (ssize_t x= 0; x < fkey.references_columns_size(); ++x)
1302
1259
  {
1311
1268
 
1312
1269
  if (fkey.has_update_option() and fkey.update_option() != Table::ForeignKeyConstraint::OPTION_UNDEF)
1313
1270
  {
1314
 
    destination.append(" ON UPDATE ");
 
1271
    destination.append(" ON UPDATE ", 11);
1315
1272
    transformForeignKeyOptionToSql(fkey.update_option(), destination);
1316
1273
  }
1317
1274
 
1318
1275
  if (fkey.has_delete_option() and fkey.delete_option() != Table::ForeignKeyConstraint::OPTION_UNDEF)
1319
1276
  {
1320
 
    destination.append(" ON DELETE ");
 
1277
    destination.append(" ON DELETE ", 11);
1321
1278
    transformForeignKeyOptionToSql(fkey.delete_option(), destination);
1322
1279
  }
1323
1280
 
1347
1304
  switch (field_type)
1348
1305
  {
1349
1306
    case Table::Field::DOUBLE:
1350
 
    destination.append(" DOUBLE");
 
1307
    destination.append(" DOUBLE", 7);
1351
1308
    if (field.has_numeric_options()
1352
1309
        && field.numeric_options().has_precision())
1353
1310
    {
1361
1318
    {
1362
1319
      if (field.string_options().has_collation()
1363
1320
          && field.string_options().collation().compare("binary") == 0)
1364
 
        destination.append(" VARBINARY(");
 
1321
        destination.append(" VARBINARY(", 11);
1365
1322
      else
1366
 
        destination.append(" VARCHAR(");
 
1323
        destination.append(" VARCHAR(", 9);
1367
1324
 
1368
1325
      destination.append(boost::lexical_cast<string>(field.string_options().length()));
1369
1326
      destination.append(")");
1373
1330
    {
1374
1331
      if (field.string_options().has_collation()
1375
1332
          && field.string_options().collation().compare("binary") == 0)
1376
 
        destination.append(" BLOB");
 
1333
        destination.append(" BLOB", 5);
1377
1334
      else
1378
 
        destination.append(" TEXT");
 
1335
        destination.append(" TEXT", 5);
1379
1336
    }
1380
1337
    break;
1381
1338
  case Table::Field::ENUM:
1382
1339
    {
1383
1340
      size_t num_field_values= field.enumeration_values().field_value_size();
1384
 
      destination.append(" ENUM(");
 
1341
      destination.append(" ENUM(", 6);
1385
1342
      for (size_t x= 0; x < num_field_values; ++x)
1386
1343
      {
1387
1344
        const string &type= field.enumeration_values().field_value(x);
1397
1354
      break;
1398
1355
    }
1399
1356
  case Table::Field::UUID:
1400
 
    destination.append(" UUID");
 
1357
    destination.append(" UUID", 5);
1401
1358
    break;
1402
1359
  case Table::Field::BOOLEAN:
1403
 
    destination.append(" BOOLEAN");
 
1360
    destination.append(" BOOLEAN", 8);
1404
1361
    break;
1405
1362
  case Table::Field::INTEGER:
1406
 
    destination.append(" INT");
 
1363
    destination.append(" INT", 4);
1407
1364
    break;
1408
1365
  case Table::Field::BIGINT:
1409
 
    if (field.has_constraints() and
1410
 
        field.constraints().is_unsigned())
1411
 
    {
1412
 
      destination.append(" BIGINT UNSIGNED");
1413
 
    }
1414
 
    else
1415
 
    {
1416
 
      destination.append(" BIGINT");
1417
 
    }
 
1366
    destination.append(" BIGINT", 7);
1418
1367
    break;
1419
1368
  case Table::Field::DECIMAL:
1420
1369
    {
1421
 
      destination.append(" DECIMAL(");
 
1370
      destination.append(" DECIMAL(", 9);
1422
1371
      stringstream ss;
1423
1372
      ss << field.numeric_options().precision() << ",";
1424
1373
      ss << field.numeric_options().scale() << ")";
1426
1375
    }
1427
1376
    break;
1428
1377
  case Table::Field::DATE:
1429
 
    destination.append(" DATE");
 
1378
    destination.append(" DATE", 5);
1430
1379
    break;
1431
 
 
1432
1380
  case Table::Field::EPOCH:
1433
 
    if (field.time_options().microseconds())
1434
 
    {
1435
 
      destination.append(" TIMESTAMP(6)");
1436
 
    }
1437
 
    else
1438
 
    {
1439
 
      destination.append(" TIMESTAMP");
1440
 
    }
 
1381
    destination.append(" TIMESTAMP",  10);
1441
1382
    break;
1442
 
 
1443
1383
  case Table::Field::DATETIME:
1444
 
    destination.append(" DATETIME");
 
1384
    destination.append(" DATETIME",  9);
1445
1385
    break;
1446
1386
  case Table::Field::TIME:
1447
 
    destination.append(" TIME");
 
1387
    destination.append(" TIME",  5);
1448
1388
    break;
1449
1389
  }
1450
1390
 
 
1391
  if (field.type() == Table::Field::INTEGER || 
 
1392
      field.type() == Table::Field::BIGINT)
 
1393
  {
 
1394
    if (field.has_constraints() &&
 
1395
        field.constraints().has_is_unsigned() &&
 
1396
        field.constraints().is_unsigned())
 
1397
    {
 
1398
      destination.append(" UNSIGNED", 9);
 
1399
    }
 
1400
  }
 
1401
 
1451
1402
  if (field.type() == Table::Field::BLOB ||
1452
1403
      field.type() == Table::Field::VARCHAR)
1453
1404
  {
1454
1405
    if (field.string_options().has_collation()
1455
1406
        && field.string_options().collation().compare("binary"))
1456
1407
    {
1457
 
      destination.append(" COLLATE ");
 
1408
      destination.append(" COLLATE ", 9);
1458
1409
      destination.append(field.string_options().collation());
1459
1410
    }
1460
1411
  }
1461
1412
 
1462
 
  if (field.has_constraints() and field.constraints().is_unique())
1463
 
  {
1464
 
    destination.append(" UNIQUE");
1465
 
  }
1466
 
 
1467
 
  if (field.has_constraints() && field.constraints().is_notnull())
1468
 
  {
1469
 
    destination.append(" NOT NULL");
 
1413
  if (field.has_constraints() &&
 
1414
      ! field.constraints().is_nullable())
 
1415
  {
 
1416
    destination.append(" NOT NULL", 9);
1470
1417
  }
1471
1418
  else if (field.type() == Table::Field::EPOCH)
1472
 
  {
1473
 
    destination.append(" NULL");
1474
 
  }
 
1419
    destination.append(" NULL", 5);
1475
1420
 
1476
1421
  if (field.type() == Table::Field::INTEGER || 
1477
1422
      field.type() == Table::Field::BIGINT)
1480
1425
    if (field.has_numeric_options() &&
1481
1426
        field.numeric_options().is_autoincrement())
1482
1427
    {
1483
 
      destination.append(" AUTO_INCREMENT");
 
1428
      destination.append(" AUTO_INCREMENT", 15);
1484
1429
    }
1485
1430
  }
1486
1431
 
1487
1432
  if (field.options().has_default_value())
1488
1433
  {
1489
 
    destination.append(" DEFAULT ");
 
1434
    destination.append(" DEFAULT ", 9);
1490
1435
    append_escaped_string(&destination, field.options().default_value());
1491
1436
  }
1492
1437
  else if (field.options().has_default_expression())
1493
1438
  {
1494
 
    destination.append(" DEFAULT ");
 
1439
    destination.append(" DEFAULT ", 9);
1495
1440
    destination.append(field.options().default_expression());
1496
1441
  }
1497
1442
  else if (field.options().has_default_bin_value())
1498
1443
  {
1499
1444
    const string &v= field.options().default_bin_value();
1500
1445
    if (v.length() == 0)
1501
 
    {
1502
 
      destination.append(" DEFAULT ''");
1503
 
    }
 
1446
      destination.append(" DEFAULT ''", 11);
1504
1447
    else
1505
1448
    {
1506
 
      destination.append(" DEFAULT 0x");
 
1449
      destination.append(" DEFAULT 0x", 11);
1507
1450
      for (size_t x= 0; x < v.length(); x++)
1508
1451
      {
1509
1452
        char hex[3];
1516
1459
           && field.options().default_null()
1517
1460
           && field.type() != Table::Field::BLOB)
1518
1461
  {
1519
 
    destination.append(" DEFAULT NULL");
 
1462
    destination.append(" DEFAULT NULL", 13);
1520
1463
  }
1521
1464
 
1522
1465
  if (field.has_options() && field.options().has_update_expression())
1523
1466
  {
1524
 
    destination.append(" ON UPDATE ");
 
1467
    destination.append(" ON UPDATE ", 11);
1525
1468
    destination.append(field.options().update_expression());
1526
1469
  }
1527
1470
 
1528
1471
  if (field.has_comment())
1529
1472
  {
1530
 
    destination.append(" COMMENT ");
 
1473
    destination.append(" COMMENT ", 9);
1531
1474
    append_escaped_string(&destination, field.comment(), quoted_default);
1532
1475
  }
1533
1476
  return NONE;
1557
1500
  case DRIZZLE_TYPE_NULL:
1558
1501
    assert(false); /* Not a user definable type */
1559
1502
    return Table::Field::INTEGER; /* unreachable */
1560
 
  case DRIZZLE_TYPE_MICROTIME:
1561
1503
  case DRIZZLE_TYPE_TIMESTAMP:
1562
1504
    return Table::Field::EPOCH;
1563
1505
  case DRIZZLE_TYPE_LONGLONG: