← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/cursor.cc

merge trunk

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/cursor.cc
54
54
** General Cursor functions
55
55
****************************************************************************/
56
56
Cursor::Cursor(plugin::StorageEngine &engine_arg,
57
 
               TableShare &share_arg)
58
 
  : table_share(&share_arg), table(0),
59
 
    estimation_rows_to_insert(0), engine(&engine_arg),
 
57
               Table &arg)
 
58
  : table(arg),
 
59
    engine(engine_arg),
 
60
    estimation_rows_to_insert(0),
60
61
    ref(0),
61
62
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
62
63
    ref_length(sizeof(internal::my_off_t)),
79
80
 */
80
81
Cursor *Cursor::clone(memory::Root *mem_root)
81
82
{
82
 
  Cursor *new_handler= table->getMutableShare()->db_type()->getCursor(*table->getMutableShare());
 
83
  Cursor *new_handler= getTable()->getMutableShare()->db_type()->getCursor(*getTable());
83
84
 
84
85
  /*
85
86
    Allocate Cursor->ref here because otherwise ha_open will allocate it
89
90
  if (!(new_handler->ref= (unsigned char*) mem_root->alloc_root(ALIGN_SIZE(ref_length)*2)))
90
91
    return NULL;
91
92
 
92
 
  TableIdentifier identifier(table->getShare()->getSchemaName(),
93
 
                             table->getShare()->getTableName(),
94
 
                             table->getShare()->getType());
 
93
  TableIdentifier identifier(getTable()->getShare()->getSchemaName(),
 
94
                             getTable()->getShare()->getTableName(),
 
95
                             getTable()->getShare()->getType());
95
96
 
96
97
  if (new_handler && !new_handler->ha_open(identifier,
97
 
                                           table,
98
 
                                           table->getDBStat(),
 
98
                                           getTable()->getDBStat(),
99
99
                                           HA_OPEN_IGNORE_IF_LOCKED))
100
100
    return new_handler;
101
101
  return NULL;
111
111
  /* works only with key prefixes */
112
112
  assert(((keypart_map_arg + 1) & keypart_map_arg) == 0);
113
113
 
114
 
  const KeyPartInfo *key_part_found= table->getShare()->getKeyInfo(key_position).key_part;
115
 
  const KeyPartInfo *end_key_part_found= key_part_found + table->getShare()->getKeyInfo(key_position).key_parts;
 
114
  const KeyPartInfo *key_part_found= getTable()->getShare()->getKeyInfo(key_position).key_part;
 
115
  const KeyPartInfo *end_key_part_found= key_part_found + getTable()->getShare()->getKeyInfo(key_position).key_parts;
116
116
  uint32_t length= 0;
117
117
 
118
118
  while (key_part_found < end_key_part_found && keypart_map_arg)
175
175
  return end_bulk_insert();
176
176
}
177
177
 
178
 
void Cursor::change_table_ptr(Table *table_arg, TableShare *share)
179
 
{
180
 
  table= table_arg;
181
 
  table_share= share;
182
 
}
183
 
 
184
178
const key_map *Cursor::keys_to_use_for_scanning()
185
179
{
186
180
  return &key_map_empty;
188
182
 
189
183
bool Cursor::has_transactions()
190
184
{
191
 
  return (table->getShare()->db_type()->check_flag(HTON_BIT_DOES_TRANSACTIONS));
 
185
  return (getTable()->getShare()->db_type()->check_flag(HTON_BIT_DOES_TRANSACTIONS));
192
186
}
193
187
 
194
188
void Cursor::ha_statistic_increment(uint64_t system_status_var::*offset) const
195
189
{
196
 
  (table->in_use->status_var.*offset)++;
 
190
  (getTable()->in_use->status_var.*offset)++;
197
191
}
198
192
 
199
193
void **Cursor::ha_data(Session *session) const
200
194
{
201
 
  return session->getEngineData(engine);
 
195
  return session->getEngineData(getEngine());
202
196
}
203
197
 
204
198
bool Cursor::is_fatal_error(int error, uint32_t flags)
214
208
 
215
209
ha_rows Cursor::records() { return stats.records; }
216
210
uint64_t Cursor::tableSize() { return stats.index_file_length + stats.data_file_length; }
217
 
uint64_t Cursor::rowSize() { return table->getRecordLength() + table->sizeFields(); }
 
211
uint64_t Cursor::rowSize() { return getTable()->getRecordLength() + getTable()->sizeFields(); }
218
212
 
219
213
int Cursor::doOpen(const TableIdentifier &identifier, int mode, uint32_t test_if_locked)
220
214
{
228
222
  Don't wait for locks if not HA_OPEN_WAIT_IF_LOCKED is set
229
223
*/
230
224
int Cursor::ha_open(const TableIdentifier &identifier,
231
 
                    Table *table_arg,
232
225
                    int mode,
233
226
                    int test_if_locked)
234
227
{
235
228
  int error;
236
229
 
237
 
  table= table_arg;
238
 
  assert(table->getShare() == table_share);
239
 
 
240
230
  if ((error= doOpen(identifier, mode, test_if_locked)))
241
231
  {
242
232
    if ((error == EACCES || error == EROFS) && mode == O_RDWR &&
243
 
        (table->db_stat & HA_TRY_READ_ONLY))
 
233
        (getTable()->db_stat & HA_TRY_READ_ONLY))
244
234
    {
245
 
      table->db_stat|=HA_READ_ONLY;
 
235
      getTable()->db_stat|=HA_READ_ONLY;
246
236
      error= doOpen(identifier, O_RDONLY,test_if_locked);
247
237
    }
248
238
  }
252
242
  }
253
243
  else
254
244
  {
255
 
    if (table->getShare()->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
256
 
      table->db_stat|=HA_READ_ONLY;
 
245
    if (getTable()->getShare()->db_options_in_use & HA_OPTION_READ_ONLY_DATA)
 
246
      getTable()->db_stat|=HA_READ_ONLY;
257
247
    (void) extra(HA_EXTRA_NO_READCHECK);        // Not needed in SQL
258
248
 
259
249
    /* ref is already allocated for us if we're called from Cursor::clone() */
260
 
    if (!ref && !(ref= (unsigned char*) table->alloc_root(ALIGN_SIZE(ref_length)*2)))
 
250
    if (!ref && !(ref= (unsigned char*) getTable()->alloc_root(ALIGN_SIZE(ref_length)*2)))
261
251
    {
262
252
      close();
263
253
      error=HA_ERR_OUT_OF_MEM;
286
276
    TODO remove the test for HA_READ_ORDER
287
277
  */
288
278
  if (stats.deleted < 10 || primary_key >= MAX_KEY ||
289
 
      !(table->index_flags(primary_key) & HA_READ_ORDER))
 
279
      !(getTable()->index_flags(primary_key) & HA_READ_ORDER))
290
280
  {
291
281
    (void) startTableScan(1);
292
282
    while ((error= rnd_next(buf)) == HA_ERR_RECORD_DELETED) ;
314
304
  @verbatim 1,5,15,25,35,... @endverbatim
315
305
*/
316
306
inline uint64_t
317
 
compute_next_insert_id(uint64_t nr,struct system_variables *variables)
 
307
compute_next_insert_id(uint64_t nr, drizzle_system_variables *variables)
318
308
{
319
309
  if (variables->auto_increment_increment == 1)
320
310
    return (nr+1); // optimization of the formula below
334
324
    Session::next_insert_id to be greater than the explicit value.
335
325
  */
336
326
  if ((next_insert_id > 0) && (nr >= next_insert_id))
337
 
    set_next_insert_id(compute_next_insert_id(nr, &table->in_use->variables));
 
327
    set_next_insert_id(compute_next_insert_id(nr, &getTable()->in_use->variables));
338
328
}
339
329
 
340
330
 
354
344
    The number X if it exists, "nr" otherwise.
355
345
*/
356
346
inline uint64_t
357
 
prev_insert_id(uint64_t nr, struct system_variables *variables)
 
347
prev_insert_id(uint64_t nr, drizzle_system_variables *variables)
358
348
{
359
349
  if (unlikely(nr < variables->auto_increment_offset))
360
350
  {
451
441
{
452
442
  uint64_t nr, nb_reserved_values;
453
443
  bool append= false;
454
 
  Session *session= table->in_use;
455
 
  struct system_variables *variables= &session->variables;
 
444
  Session *session= getTable()->in_use;
 
445
  drizzle_system_variables *variables= &session->variables;
456
446
 
457
447
  /*
458
448
    next_insert_id is a "cursor" into the reserved interval, it may go greater
464
454
     for an auto increment column, not a magic value like NULL is.
465
455
     same as sql_mode=NO_AUTO_VALUE_ON_ZERO */
466
456
 
467
 
  if ((nr= table->next_number_field->val_int()) != 0
468
 
      || table->auto_increment_field_not_null)
 
457
  if ((nr= getTable()->next_number_field->val_int()) != 0
 
458
      || getTable()->auto_increment_field_not_null)
469
459
  {
470
460
    /*
471
461
      Update next_insert_id if we had already generated a value in this
543
533
      nr= compute_next_insert_id(nr-1, variables);
544
534
    }
545
535
 
546
 
    if (table->getShare()->next_number_keypart == 0)
 
536
    if (getTable()->getShare()->next_number_keypart == 0)
547
537
    {
548
538
      /* We must defer the appending until "nr" has been possibly truncated */
549
539
      append= true;
550
540
    }
551
541
  }
552
542
 
553
 
  if (unlikely(table->next_number_field->store((int64_t) nr, true)))
 
543
  if (unlikely(getTable()->next_number_field->store((int64_t) nr, true)))
554
544
  {
555
545
    /*
556
546
      first test if the query was aborted due to strict mode constraints
566
556
      bother shifting the right bound (anyway any other value from this
567
557
      interval will cause a duplicate key).
568
558
    */
569
 
    nr= prev_insert_id(table->next_number_field->val_int(), variables);
570
 
    if (unlikely(table->next_number_field->store((int64_t) nr, true)))
571
 
      nr= table->next_number_field->val_int();
 
559
    nr= prev_insert_id(getTable()->next_number_field->val_int(), variables);
 
560
    if (unlikely(getTable()->next_number_field->store((int64_t) nr, true)))
 
561
      nr= getTable()->next_number_field->val_int();
572
562
  }
573
563
  if (append)
574
564
  {
622
612
      this statement used forced auto_increment values if there were some,
623
613
      wipe them away for other statements.
624
614
    */
625
 
    table->in_use->auto_inc_intervals_forced.empty();
 
615
    getTable()->in_use->auto_inc_intervals_forced.empty();
626
616
  }
627
617
}
628
618
 
668
658
   * possible resource to gain (and if there is... then there is a bug such
669
659
   * that in_use should have been set.
670
660
 */
671
 
  if (not table || not table->in_use)
 
661
  if (not getTable()->in_use)
672
662
    return;
673
663
 
674
 
  resource_context= table->in_use->getResourceContext(engine);
 
664
  resource_context= getTable()->in_use->getResourceContext(getEngine());
675
665
  /*
676
666
    When a storage engine method is called, the transaction must
677
667
    have been started, unless it's a DDL call, for which the
712
702
     * @todo Make TransactionServices generic to AfterTriggerServices
713
703
     * or similar...
714
704
     */
715
 
    Session *const session= table->in_use;
 
705
    Session *const session= getTable()->in_use;
716
706
    TransactionServices &transaction_services= TransactionServices::singleton();
717
 
    transaction_services.truncateTable(session, table);
 
707
    transaction_services.truncateTable(session, getTable());
718
708
  }
719
709
 
720
710
  return result;
813
803
  int error;
814
804
  if (!(error=index_next(buf)))
815
805
  {
816
 
    ptrdiff_t ptrdiff= buf - table->getInsertRecord();
 
806
    ptrdiff_t ptrdiff= buf - getTable()->getInsertRecord();
817
807
    unsigned char *save_record_0= NULL;
818
808
    KeyInfo *key_info= NULL;
819
809
    KeyPartInfo *key_part;
829
819
    */
830
820
    if (ptrdiff)
831
821
    {
832
 
      save_record_0= table->getInsertRecord();
833
 
      table->record[0]= buf;
834
 
      key_info= table->key_info + active_index;
 
822
      save_record_0= getTable()->getInsertRecord();
 
823
      getTable()->record[0]= buf;
 
824
      key_info= getTable()->key_info + active_index;
835
825
      key_part= key_info->key_part;
836
826
      key_part_end= key_part + key_info->key_parts;
837
827
      for (; key_part < key_part_end; key_part++)
841
831
      }
842
832
    }
843
833
 
844
 
    if (key_cmp_if_same(table, key, active_index, keylen))
 
834
    if (key_cmp_if_same(getTable(), key, active_index, keylen))
845
835
    {
846
 
      table->status=STATUS_NOT_FOUND;
 
836
      getTable()->status=STATUS_NOT_FOUND;
847
837
      error=HA_ERR_END_OF_FILE;
848
838
    }
849
839
 
850
840
    /* Move back if necessary. */
851
841
    if (ptrdiff)
852
842
    {
853
 
      table->record[0]= save_record_0;
 
843
      getTable()->record[0]= save_record_0;
854
844
      for (key_part= key_info->key_part; key_part < key_part_end; key_part++)
855
845
        key_part->field->move_field_offset(-ptrdiff);
856
846
    }
887
877
double Cursor::index_only_read_time(uint32_t keynr, double key_records)
888
878
{
889
879
  uint32_t keys_per_block= (stats.block_size/2/
890
 
                        (table->key_info[keynr].key_length + ref_length) + 1);
 
880
                        (getTable()->key_info[keynr].key_length + ref_length) + 1);
891
881
  return ((double) (key_records + keys_per_block-1) /
892
882
          (double) keys_per_block);
893
883
}
1194
1184
    key_compare_result_on_equal= ((end_key->flag == HA_READ_BEFORE_KEY) ? 1 :
1195
1185
                                  (end_key->flag == HA_READ_AFTER_KEY) ? -1 : 0);
1196
1186
  }
1197
 
  range_key_part= table->key_info[active_index].key_part;
 
1187
  range_key_part= getTable()->key_info[active_index].key_part;
1198
1188
 
1199
1189
  if (!start_key)                       // Read first record
1200
 
    result= index_first(table->getInsertRecord());
 
1190
    result= index_first(getTable()->getInsertRecord());
1201
1191
  else
1202
 
    result= index_read_map(table->getInsertRecord(),
 
1192
    result= index_read_map(getTable()->getInsertRecord(),
1203
1193
                           start_key->key,
1204
1194
                           start_key->keypart_map,
1205
1195
                           start_key->flag);
1232
1222
  if (eq_range)
1233
1223
  {
1234
1224
    /* We trust that index_next_same always gives a row in range */
1235
 
    return(index_next_same(table->getInsertRecord(),
 
1225
    return(index_next_same(getTable()->getInsertRecord(),
1236
1226
                                end_range->key,
1237
1227
                                end_range->length));
1238
1228
  }
1239
 
  result= index_next(table->getInsertRecord());
 
1229
  result= index_next(getTable()->getInsertRecord());
1240
1230
  if (result)
1241
1231
    return result;
1242
1232
  return(compare_key(end_range) <= 0 ? 0 : HA_ERR_END_OF_FILE);
1404
1394
  {
1405
1395
    if (lock_type == F_RDLCK)
1406
1396
    {
1407
 
      DRIZZLE_CURSOR_RDLOCK_START(table_share->getSchemaName(),
1408
 
                                  table_share->getTableName());
 
1397
      DRIZZLE_CURSOR_RDLOCK_START(getTable()->getShare()->getSchemaName(),
 
1398
                                  getTable()->getShare()->getTableName());
1409
1399
    }
1410
1400
    else if (lock_type == F_WRLCK)
1411
1401
    {
1412
 
      DRIZZLE_CURSOR_WRLOCK_START(table_share->getSchemaName(),
1413
 
                                  table_share->getTableName());
 
1402
      DRIZZLE_CURSOR_WRLOCK_START(getTable()->getShare()->getSchemaName(),
 
1403
                                  getTable()->getShare()->getTableName());
1414
1404
    }
1415
1405
    else if (lock_type == F_UNLCK)
1416
1406
    {
1417
 
      DRIZZLE_CURSOR_UNLOCK_START(table_share->getSchemaName(),
1418
 
                                  table_share->getTableName());
 
1407
      DRIZZLE_CURSOR_UNLOCK_START(getTable()->getShare()->getSchemaName(),
 
1408
                                  getTable()->getShare()->getTableName());
1419
1409
    }
1420
1410
  }
1421
1411
 
1454
1444
int Cursor::ha_reset()
1455
1445
{
1456
1446
  /* Check that we have called all proper deallocation functions */
1457
 
  assert(! table->getShare()->all_set.none());
1458
 
  assert(table->key_read == 0);
 
1447
  assert(! getTable()->getShare()->all_set.none());
 
1448
  assert(getTable()->key_read == 0);
1459
1449
  /* ensure that ha_index_end / endTableScan has been called */
1460
1450
  assert(inited == NONE);
1461
1451
  /* Free cache used by filesort */
1462
 
  table->free_io_cache();
 
1452
  getTable()->free_io_cache();
1463
1453
  /* reset the bitmaps to point to defaults */
1464
 
  table->default_column_bitmaps();
 
1454
  getTable()->default_column_bitmaps();
1465
1455
  return(reset());
1466
1456
}
1467
1457
 
1476
1466
   * @TODO Technically, the below two lines can be take even further out of the
1477
1467
   * Cursor interface and into the fill_record() method.
1478
1468
   */
1479
 
  if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
 
1469
  if (getTable()->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_INSERT)
1480
1470
  {
1481
 
    table->timestamp_field->set_time();
 
1471
    getTable()->timestamp_field->set_time();
1482
1472
  }
1483
1473
 
1484
 
  DRIZZLE_INSERT_ROW_START(table_share->getSchemaName(), table_share->getTableName());
 
1474
  DRIZZLE_INSERT_ROW_START(getTable()->getShare()->getSchemaName(), getTable()->getShare()->getTableName());
1485
1475
  setTransactionReadWrite();
1486
1476
  
1487
 
  if (unlikely(plugin::EventObserver::beforeInsertRecord(*table, buf)))
 
1477
  if (unlikely(plugin::EventObserver::beforeInsertRecord(*getTable(), buf)))
1488
1478
  {
1489
1479
    error= ER_EVENT_OBSERVER_PLUGIN;
1490
1480
  }
1491
1481
  else
1492
1482
  {
1493
1483
    error= doInsertRecord(buf);
1494
 
    if (unlikely(plugin::EventObserver::afterInsertRecord(*table, buf, error))) 
 
1484
    if (unlikely(plugin::EventObserver::afterInsertRecord(*getTable(), buf, error))) 
1495
1485
    {
1496
1486
      error= ER_EVENT_OBSERVER_PLUGIN;
1497
1487
    }
1506
1496
    return error;
1507
1497
  }
1508
1498
 
1509
 
  if (unlikely(log_row_for_replication(table, NULL, buf)))
 
1499
  if (unlikely(log_row_for_replication(getTable(), NULL, buf)))
1510
1500
    return HA_ERR_RBR_LOGGING_FAILED;
1511
1501
 
1512
1502
  return 0;
1521
1511
    Some storage engines require that the new record is in getInsertRecord()
1522
1512
    (and the old record is in getUpdateRecord()).
1523
1513
   */
1524
 
  assert(new_data == table->getInsertRecord());
 
1514
  assert(new_data == getTable()->getInsertRecord());
1525
1515
 
1526
 
  DRIZZLE_UPDATE_ROW_START(table_share->getSchemaName(), table_share->getTableName());
 
1516
  DRIZZLE_UPDATE_ROW_START(getTable()->getShare()->getSchemaName(), getTable()->getShare()->getTableName());
1527
1517
  setTransactionReadWrite();
1528
 
  if (unlikely(plugin::EventObserver::beforeUpdateRecord(*table, old_data, new_data)))
 
1518
  if (unlikely(plugin::EventObserver::beforeUpdateRecord(*getTable(), old_data, new_data)))
1529
1519
  {
1530
1520
    error= ER_EVENT_OBSERVER_PLUGIN;
1531
1521
  }
1532
1522
  else
1533
1523
  {
1534
 
    if (table->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
 
1524
    if (getTable()->timestamp_field_type & TIMESTAMP_AUTO_SET_ON_UPDATE)
1535
1525
    {
1536
 
      table->timestamp_field->set_time();
 
1526
      getTable()->timestamp_field->set_time();
1537
1527
    }
1538
1528
 
1539
1529
    error= doUpdateRecord(old_data, new_data);
1540
 
    if (unlikely(plugin::EventObserver::afterUpdateRecord(*table, old_data, new_data, error)))
 
1530
    if (unlikely(plugin::EventObserver::afterUpdateRecord(*getTable(), old_data, new_data, error)))
1541
1531
    {
1542
1532
      error= ER_EVENT_OBSERVER_PLUGIN;
1543
1533
    }
1552
1542
    return error;
1553
1543
  }
1554
1544
 
1555
 
  if (unlikely(log_row_for_replication(table, old_data, new_data)))
 
1545
  if (unlikely(log_row_for_replication(getTable(), old_data, new_data)))
1556
1546
    return HA_ERR_RBR_LOGGING_FAILED;
1557
1547
 
1558
1548
  return 0;
1559
1549
}
 
1550
TableShare *Cursor::getShare()
 
1551
{
 
1552
  return getTable()->getMutableShare();
 
1553
}
1560
1554
 
1561
1555
int Cursor::deleteRecord(const unsigned char *buf)
1562
1556
{
1563
1557
  int error;
1564
1558
 
1565
 
  DRIZZLE_DELETE_ROW_START(table_share->getSchemaName(), table_share->getTableName());
 
1559
  DRIZZLE_DELETE_ROW_START(getTable()->getShare()->getSchemaName(), getTable()->getShare()->getTableName());
1566
1560
  setTransactionReadWrite();
1567
 
  if (unlikely(plugin::EventObserver::beforeDeleteRecord(*table, buf)))
 
1561
  if (unlikely(plugin::EventObserver::beforeDeleteRecord(*getTable(), buf)))
1568
1562
  {
1569
1563
    error= ER_EVENT_OBSERVER_PLUGIN;
1570
1564
  }
1571
1565
  else
1572
1566
  {
1573
1567
    error= doDeleteRecord(buf);
1574
 
    if (unlikely(plugin::EventObserver::afterDeleteRecord(*table, buf, error)))
 
1568
    if (unlikely(plugin::EventObserver::afterDeleteRecord(*getTable(), buf, error)))
1575
1569
    {
1576
1570
      error= ER_EVENT_OBSERVER_PLUGIN;
1577
1571
    }
1584
1578
  if (unlikely(error))
1585
1579
    return error;
1586
1580
 
1587
 
  if (unlikely(log_row_for_replication(table, buf, NULL)))
 
1581
  if (unlikely(log_row_for_replication(getTable(), buf, NULL)))
1588
1582
    return HA_ERR_RBR_LOGGING_FAILED;
1589
1583
 
1590
1584
  return 0;