← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/sql_insert.cc

Use List::size()

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/sql_insert.cc
70
70
{
71
71
  Table *table= table_list->table;
72
72
 
73
 
  if (fields.elements == 0 && values.elements != 0)
 
73
  if (fields.size() == 0 && values.size() != 0)
74
74
  {
75
 
    if (values.elements != table->getShare()->sizeFields())
 
75
    if (values.size() != table->getShare()->sizeFields())
76
76
    {
77
77
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1L);
78
78
      return -1;
92
92
    Name_resolution_context_state ctx_state;
93
93
    int res;
94
94
 
95
 
    if (fields.elements != values.elements)
 
95
    if (fields.size() != values.size())
96
96
    {
97
97
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1L);
98
98
      return -1;
258
258
    the current connection mode or table operation.
259
259
  */
260
260
  upgrade_lock_type(session, &table_list->lock_type, duplic,
261
 
                    values_list.elements > 1);
 
261
                    values_list.size() > 1);
262
262
 
263
263
  if (session->openTablesLock(table_list))
264
264
  {
271
271
  session->set_proc_info("init");
272
272
  session->used_tables=0;
273
273
  values= its++;
274
 
  value_count= values->elements;
 
274
  value_count= values->size();
275
275
 
276
276
  if (prepare_insert(session, table_list, table, fields, values,
277
277
                           update_fields, update_values, duplic, &unused_conds,
278
278
                           false,
279
 
                           (fields.elements || !value_count ||
 
279
                           (fields.size() || !value_count ||
280
280
                            (0) != 0), !ignore))
281
281
  {
282
282
    if (table != NULL)
314
314
  while ((values= its++))
315
315
  {
316
316
    counter++;
317
 
    if (values->elements != value_count)
 
317
    if (values->size() != value_count)
318
318
    {
319
319
      my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), counter);
320
320
 
370
370
  {
371
371
    if (duplic != DUP_ERROR || ignore)
372
372
      table->cursor->extra(HA_EXTRA_IGNORE_DUP_KEY);
373
 
    table->cursor->ha_start_bulk_insert(values_list.elements);
 
373
    table->cursor->ha_start_bulk_insert(values_list.size());
374
374
  }
375
375
 
376
376
 
380
380
 
381
381
  while ((values= its++))
382
382
  {
383
 
    if (fields.elements || !value_count)
 
383
    if (fields.size() || !value_count)
384
384
    {
385
385
      table->restoreRecordAsDefault();  // Get empty record
386
386
      if (fill_record(session, fields, *values))
387
387
      {
388
 
        if (values_list.elements != 1 && ! session->is_error())
 
388
        if (values_list.size() != 1 && ! session->is_error())
389
389
        {
390
390
          info.records++;
391
391
          continue;
405
405
 
406
406
      if (fill_record(session, table->getFields(), *values))
407
407
      {
408
 
        if (values_list.elements != 1 && ! session->is_error())
 
408
        if (values_list.size() != 1 && ! session->is_error())
409
409
        {
410
410
          info.records++;
411
411
          continue;
490
490
    return true;
491
491
  }
492
492
 
493
 
  if (values_list.elements == 1 && (!(session->options & OPTION_WARNINGS) ||
 
493
  if (values_list.size() == 1 && (!(session->options & OPTION_WARNINGS) ||
494
494
                                    !session->cuted_fields))
495
495
  {
496
496
    session->row_count_func= info.copied + info.deleted + info.updated;
838
838
        assert(table->insert_values.size());
839
839
        table->storeRecordAsInsert();
840
840
        table->restoreRecord();
841
 
        assert(info->update_fields->elements ==
842
 
                    info->update_values->elements);
 
841
        assert(info->update_fields->size() ==
 
842
                    info->update_values->size());
843
843
        if (fill_record(session, *info->update_fields,
844
844
                                                 *info->update_values,
845
845
                                                 info->ignore))
1104
1104
                           !insert_into_view, &map) ||
1105
1105
       setup_fields(session, 0, values, MARK_COLUMNS_READ, 0, 0);
1106
1106
 
1107
 
  if (!res && fields->elements)
 
1107
  if (!res && fields->size())
1108
1108
  {
1109
1109
    bool saved_abort_on_warning= session->abortOnWarning();
1110
1110
    session->setAbortOnWarning(not info.ignore);
1326
1326
 
1327
1327
void select_insert::store_values(List<Item> &values)
1328
1328
{
1329
 
  if (fields->elements)
 
1329
  if (fields->size())
1330
1330
    fill_record(session, *fields, values, true);
1331
1331
  else
1332
1332
    fill_record(session, table->getFields(), values, true);
1491
1491
                                      identifier::Table::const_reference identifier)
1492
1492
{
1493
1493
  TableShare share(message::Table::INTERNAL);
1494
 
  uint32_t select_field_count= items->elements;
 
1494
  uint32_t select_field_count= items->size();
1495
1495
  /* Add selected items to field list */
1496
1496
  List<Item>::iterator it(items->begin());
1497
1497
  Item *item;
1689
1689
    *m_plock= extra_lock;
1690
1690
  }
1691
1691
 
1692
 
  if (table->getShare()->sizeFields() < values.elements)
 
1692
  if (table->getShare()->sizeFields() < values.size())
1693
1693
  {
1694
1694
    my_error(ER_WRONG_VALUE_COUNT_ON_ROW, MYF(0), 1);
1695
1695
    return(-1);
1696
1696
  }
1697
1697
 
1698
1698
 /* First field to copy */
1699
 
  field= table->getFields() + table->getShare()->sizeFields() - values.elements;
 
1699
  field= table->getFields() + table->getShare()->sizeFields() - values.size();
1700
1700
 
1701
1701
  /* Mark all fields that are given values */
1702
1702
  for (Field **f= field ; *f ; f++)