← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/statement/alter_table.cc

  • Committer: Brian Aker
  • Date: 2010-12-08 21:50:36 UTC
  • mfrom: (1976.6.3 catalogs)
  • Revision ID: brian@tangent.org-20101208215036-8t90yz5tx3m8f4n9
Merge in 686197.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/statement/alter_table.cc
353
353
        if (def->sql_type == DRIZZLE_TYPE_BLOB)
354
354
        {
355
355
          my_error(ER_BLOB_CANT_HAVE_DEFAULT, MYF(0), def->change);
356
 
                goto err;
 
356
          return true;
357
357
        }
358
358
        if ((def->def= alter->def))
359
359
        {
361
361
          def->flags&= ~NO_DEFAULT_VALUE_FLAG;
362
362
        }
363
363
        else
 
364
        {
364
365
          def->flags|= NO_DEFAULT_VALUE_FLAG;
 
366
        }
365
367
        alter_it.remove();
366
368
      }
367
369
    }
372
374
    if (def->change && ! def->field)
373
375
    {
374
376
      my_error(ER_BAD_FIELD_ERROR, MYF(0), def->change, table->getMutableShare()->getTableName());
375
 
      goto err;
 
377
      return true;
376
378
    }
377
379
    /*
378
 
      Check that the DATE/DATETIME not null field we are going to add is
379
 
      either has a default value or the '0000-00-00' is allowed by the
380
 
      set sql mode.
381
 
      If the '0000-00-00' value isn't allowed then raise the error_if_not_empty
382
 
      flag to allow ALTER Table only if the table to be altered is empty.
 
380
      If we have been given a field which has no default value, and is not null then we need to bail.
383
381
    */
384
 
    if ((def->sql_type == DRIZZLE_TYPE_DATE ||
385
 
         def->sql_type == DRIZZLE_TYPE_DATETIME) &&
386
 
        ! alter_info->datetime_field &&
387
 
        ! (~def->flags & (NO_DEFAULT_VALUE_FLAG | NOT_NULL_FLAG)))
 
382
    if (not (~def->flags & (NO_DEFAULT_VALUE_FLAG | NOT_NULL_FLAG)) and not def->change)
388
383
    {
389
 
      alter_info->datetime_field= def;
390
384
      alter_info->error_if_not_empty= true;
391
385
    }
392
386
    if (! def->after)
 
387
    {
393
388
      new_create_list.push_back(def);
 
389
    }
394
390
    else if (def->after == first_keyword)
 
391
    {
395
392
      new_create_list.push_front(def);
 
393
    }
396
394
    else
397
395
    {
398
396
      CreateField *find;
405
403
      if (! find)
406
404
      {
407
405
        my_error(ER_BAD_FIELD_ERROR, MYF(0), def->after, table->getMutableShare()->getTableName());
408
 
        goto err;
 
406
        return true;
409
407
      }
410
408
      find_it.after(def); /* Put element after this */
411
409
      /*
421
419
      if (alter_info->build_method == HA_BUILD_ONLINE)
422
420
      {
423
421
        my_error(ER_NOT_SUPPORTED_YET, MYF(0), session->getQueryString()->c_str());
424
 
        goto err;
 
422
        return true;
425
423
      }
426
424
      alter_info->build_method= HA_BUILD_OFFLINE;
427
425
    }
432
430
             MYF(0),
433
431
             alter_info->alter_list.head()->name,
434
432
             table->getMutableShare()->getTableName());
435
 
    goto err;
 
433
    return true;
436
434
  }
437
435
  if (! new_create_list.elements)
438
436
  {
439
437
    my_message(ER_CANT_REMOVE_ALL_FIELDS,
440
438
               ER(ER_CANT_REMOVE_ALL_FIELDS),
441
439
               MYF(0));
442
 
    goto err;
 
440
    return true;
443
441
  }
444
442
 
445
443
  /*
576
574
      if (key->type == Key::FOREIGN_KEY)
577
575
      {
578
576
        if (((Foreign_key *)key)->validate(new_create_list))
579
 
          goto err;
 
577
        {
 
578
          return true;
 
579
        }
580
580
 
581
581
        Foreign_key *fkey= (Foreign_key*)key;
582
582
        add_foreign_key_to_table_message(&table_message,
597
597
        my_error(ER_WRONG_NAME_FOR_INDEX,
598
598
                 MYF(0),
599
599
                 key->name.str);
600
 
        goto err;
 
600
        return true;
601
601
      }
602
602
    }
603
603
  }
624
624
    my_error(ER_CANT_DROP_FIELD_OR_KEY,
625
625
             MYF(0),
626
626
             alter_info->drop_list.head()->name);
627
 
    goto err;
 
627
    return true;
628
628
  }
629
629
  if (alter_info->alter_list.elements)
630
630
  {
631
631
    my_error(ER_CANT_DROP_FIELD_OR_KEY,
632
632
             MYF(0),
633
633
             alter_info->alter_list.head()->name);
634
 
    goto err;
 
634
    return true;
635
635
  }
636
636
 
637
637
  if (not table_message.options().has_comment()
650
650
  rc= false;
651
651
  alter_info->create_list.swap(new_create_list);
652
652
  alter_info->key_list.swap(new_key_list);
653
 
err:
654
653
 
655
654
  size_t num_engine_options= table_message.engine().options_size();
656
655
  size_t original_num_engine_options= original_proto.engine().options_size();
677
676
 
678
677
  drizzled::message::update(table_message);
679
678
 
680
 
  return rc;
 
679
  return false;
681
680
}
682
681
 
683
682
/* table_list should contain just one table */
1150
1149
    */
1151
1150
    if (alter_info->error_if_not_empty && session->row_count)
1152
1151
    {
1153
 
      const char *f_val= 0;
1154
 
      enum enum_drizzle_timestamp_type t_type= DRIZZLE_TIMESTAMP_DATE;
1155
 
 
1156
 
      switch (alter_info->datetime_field->sql_type)
1157
 
      {
1158
 
      case DRIZZLE_TYPE_DATE:
1159
 
        f_val= "0000-00-00";
1160
 
        t_type= DRIZZLE_TIMESTAMP_DATE;
1161
 
        break;
1162
 
      case DRIZZLE_TYPE_DATETIME:
1163
 
        f_val= "0000-00-00 00:00:00";
1164
 
        t_type= DRIZZLE_TIMESTAMP_DATETIME;
1165
 
        break;
1166
 
      default:
1167
 
        /* Shouldn't get here. */
1168
 
        assert(0);
1169
 
      }
1170
 
      bool save_abort_on_warning= session->abort_on_warning;
1171
 
      session->abort_on_warning= true;
1172
 
      make_truncated_value_warning(session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
1173
 
                                   f_val, internal::strlength(f_val), t_type,
1174
 
                                   alter_info->datetime_field->field_name);
1175
 
      session->abort_on_warning= save_abort_on_warning;
 
1152
      my_error(ER_INVALID_ALTER_TABLE_FOR_NOT_NULL, MYF(0));
1176
1153
    }
1177
1154
 
1178
1155
    if (original_table_identifier.isTmp())
1569
1546
        to->next_number_field->reset();
1570
1547
    }
1571
1548
 
1572
 
    for (CopyField *copy_ptr=copy ; copy_ptr != copy_end ; copy_ptr++)
 
1549
    for (CopyField *copy_ptr= copy; copy_ptr != copy_end ; copy_ptr++)
1573
1550
    {
 
1551
      if (not copy->to_field->hasDefault() and copy->from_null_ptr and  *copy->from_null_ptr & copy->from_bit)
 
1552
      {
 
1553
        copy->to_field->set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN,
 
1554
                                    ER_WARN_DATA_TRUNCATED, 1);
 
1555
        copy->to_field->reset();
 
1556
        error= 1;
 
1557
        break;
 
1558
      }
 
1559
 
1574
1560
      copy_ptr->do_copy(copy_ptr);
1575
1561
    }
 
1562
 
 
1563
    if (error)
 
1564
    {
 
1565
      break;
 
1566
    }
 
1567
 
1576
1568
    prev_insert_id= to->cursor->next_insert_id;
1577
1569
    error= to->cursor->insertRecord(to->record[0]);
1578
1570
    to->auto_increment_field_not_null= false;
1579
1571
 
1580
1572
    if (error)
1581
1573
    { 
1582
 
      if (!ignore ||
1583
 
          to->cursor->is_fatal_error(error, HA_CHECK_DUP))
 
1574
      if (!ignore || to->cursor->is_fatal_error(error, HA_CHECK_DUP))
1584
1575
      { 
1585
1576
        to->print_error(error, MYF(0));
1586
1577
        break;