← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.cc

  • Committer: Brian Aker
  • Date: 2010-12-08 22:35:56 UTC
  • mfrom: (1819.9.158 update-innobase)
  • Revision ID: brian@tangent.org-20101208223556-37mi4omqg7lkjzf3
Merge in Stewart's changes, 1.3 changes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
1472
1472
  return false;
1473
1473
}
1474
1474
 
1475
 
/* Return false if row hasn't changed */
1476
 
 
1477
 
bool Table::compare_record()
1478
 
{
 
1475
/**
 
1476
   True if the table's input and output record buffers are comparable using
 
1477
   compare_records(TABLE*).
 
1478
 */
 
1479
bool Table::records_are_comparable()
 
1480
{
 
1481
  return ((getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) == 0) ||
 
1482
          write_set->is_subset_of(*read_set));
 
1483
}
 
1484
 
 
1485
/**
 
1486
   Compares the input and outbut record buffers of the table to see if a row
 
1487
   has changed. The algorithm iterates over updated columns and if they are
 
1488
   nullable compares NULL bits in the buffer before comparing actual
 
1489
   data. Special care must be taken to compare only the relevant NULL bits and
 
1490
   mask out all others as they may be undefined. The storage engine will not
 
1491
   and should not touch them.
 
1492
 
 
1493
   @param table The table to evaluate.
 
1494
 
 
1495
   @return true if row has changed.
 
1496
   @return false otherwise.
 
1497
*/
 
1498
bool Table::compare_records()
 
1499
{
 
1500
  if (getEngine()->check_flag(HTON_BIT_PARTIAL_COLUMN_READ) != 0)
 
1501
  {
 
1502
    /*
 
1503
      Storage engine may not have read all columns of the record.  Fields
 
1504
      (including NULL bits) not in the write_set may not have been read and
 
1505
      can therefore not be compared.
 
1506
    */
 
1507
    for (Field **ptr= this->field ; *ptr != NULL; ptr++)
 
1508
    {
 
1509
      Field *f= *ptr;
 
1510
      if (write_set->test(f->field_index))
 
1511
      {
 
1512
        if (f->real_maybe_null())
 
1513
        {
 
1514
          unsigned char null_byte_index= f->null_ptr - record[0];
 
1515
 
 
1516
          if (((record[0][null_byte_index]) & f->null_bit) !=
 
1517
              ((record[1][null_byte_index]) & f->null_bit))
 
1518
            return true;
 
1519
        }
 
1520
        if (f->cmp_binary_offset(getShare()->rec_buff_length))
 
1521
          return true;
 
1522
      }
 
1523
    }
 
1524
    return false;
 
1525
  }
 
1526
 
 
1527
  /*
 
1528
    The storage engine has read all columns, so it's safe to compare all bits
 
1529
    including those not in the write_set. This is cheaper than the
 
1530
    field-by-field comparison done above.
 
1531
  */
1479
1532
  if (not getShare()->blob_fields + getShare()->hasVariableWidth())
 
1533
    // Fixed-size record: do bitwise comparison of the records
1480
1534
    return memcmp(this->getInsertRecord(), this->getUpdateRecord(), (size_t) getShare()->getRecordLength());
1481
 
  
 
1535
 
1482
1536
  /* Compare null bits */
1483
1537
  if (memcmp(null_flags, null_flags + getShare()->rec_buff_length, getShare()->null_bytes))
1484
1538
    return true; /* Diff in NULL value */