← 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-11-19 20:09:58 UTC
  • mfrom: (1938.2.1 bug673579)
  • Revision ID: brian@tangent.org-20101119200958-anlloqi9va5gu4c7
Merge in Monty

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.cc
46
46
#include "drizzled/charset.h"
47
47
#include "drizzled/internal/m_string.h"
48
48
#include "plugin/myisam/myisam.h"
49
 
#include "drizzled/plugin/storage_engine.h"
50
49
 
51
50
#include <drizzled/item/string.h>
52
51
#include <drizzled/item/int.h>
55
54
#include <drizzled/item/null.h>
56
55
#include <drizzled/temporal.h>
57
56
 
58
 
#include <drizzled/refresh_version.h>
59
 
 
60
 
#include "drizzled/table/singular.h"
 
57
#include "drizzled/table/instance.h"
61
58
 
62
59
#include "drizzled/table_proto.h"
63
60
 
66
63
namespace drizzled
67
64
{
68
65
 
 
66
extern pid_t current_pid;
69
67
extern plugin::StorageEngine *heap_engine;
70
68
extern plugin::StorageEngine *myisam_engine;
71
69
 
72
70
/* Functions defined in this cursor */
73
71
 
 
72
void open_table_error(TableShare *share, int error, int db_errno,
 
73
                      myf errortype, int errarg);
 
74
 
74
75
/*************************************************************************/
75
76
 
76
77
// @note this should all be the destructor
81
82
  if (db_stat)
82
83
    error= cursor->close();
83
84
  _alias.clear();
84
 
 
85
85
  if (field)
86
86
  {
87
87
    for (Field **ptr=field ; *ptr ; ptr++)
112
112
                       uint32_t db_stat_arg)
113
113
{
114
114
  setShare(share);
115
 
  in_use= session;
116
 
 
117
115
  field= NULL;
118
116
 
119
117
  cursor= NULL;
126
124
  tablenr= 0;
127
125
  db_stat= db_stat_arg;
128
126
 
 
127
  in_use= session;
129
128
  record[0]= (unsigned char *) NULL;
130
129
  record[1]= (unsigned char *) NULL;
131
130
 
334
333
    true ok
335
334
*/
336
335
 
337
 
bool check_db_name(Session *session, identifier::Schema &schema_identifier)
 
336
bool check_db_name(Session *session, SchemaIdentifier &schema_identifier)
338
337
{
339
 
  if (not plugin::Authorization::isAuthorized(session->user(), schema_identifier))
 
338
  if (not plugin::Authorization::isAuthorized(session->getSecurityContext(), schema_identifier))
340
339
  {
341
340
    return false;
342
341
  }
522
521
    We must set bit in read set as update_auto_increment() is using the
523
522
    store() to check overflow of auto_increment values
524
523
  */
525
 
  setReadSet(found_next_number_field->position());
526
 
  setWriteSet(found_next_number_field->position());
 
524
  setReadSet(found_next_number_field->field_index);
 
525
  setWriteSet(found_next_number_field->field_index);
527
526
  if (getShare()->next_number_keypart)
528
527
    mark_columns_used_by_index_no_reset(getShare()->next_number_index);
529
528
}
572
571
    for (reg_field= field ; *reg_field ; reg_field++)
573
572
    {
574
573
      if ((*reg_field)->flags & PART_KEY_FLAG)
575
 
        setReadSet((*reg_field)->position());
 
574
        setReadSet((*reg_field)->field_index);
576
575
    }
577
576
  }
578
577
}
621
620
    {
622
621
      /* Merge keys is all keys that had a column refered to in the query */
623
622
      if (is_overlapping(merge_keys, (*reg_field)->part_of_key))
624
 
        setReadSet((*reg_field)->position());
 
623
        setReadSet((*reg_field)->field_index);
625
624
    }
626
625
  }
627
626
 
839
838
    copy_func_count+= param->sum_func_count;
840
839
  }
841
840
 
842
 
  table::Singular *table;
 
841
  table::Instance *table;
843
842
  table= session->getInstanceTable(); // This will not go into the tableshare cache, so no key is used.
844
843
 
845
844
  if (not table->getMemRoot()->multi_alloc_root(0,
885
884
 
886
885
  table->getMutableShare()->blob_field.resize(field_count+1);
887
886
  uint32_t *blob_field= &table->getMutableShare()->blob_field[0];
 
887
  table->getMutableShare()->blob_ptr_size= portable_sizeof_char_ptr;
888
888
  table->getMutableShare()->db_low_byte_first=1;                // True for HEAP and MyISAM
889
889
  table->getMutableShare()->table_charset= param->table_charset;
890
890
  table->getMutableShare()->keys_for_keyread.reset();
965
965
            */
966
966
            (*argp)->maybe_null=1;
967
967
          }
968
 
          new_field->setPosition(fieldnr++);
 
968
          new_field->field_index= fieldnr++;
969
969
        }
970
970
      }
971
971
    }
1012
1012
        group_null_items++;
1013
1013
        new_field->flags|= GROUP_FLAG;
1014
1014
      }
1015
 
      new_field->setPosition(fieldnr++);
 
1015
      new_field->field_index= fieldnr++;
1016
1016
      *(reg_field++)= new_field;
1017
1017
    }
1018
1018
    if (!--hidden_field_count)
1035
1035
  field_count= fieldnr;
1036
1036
  *reg_field= 0;
1037
1037
  *blob_field= 0;                               // End marker
1038
 
  table->getMutableShare()->setFieldSize(field_count);
 
1038
  table->getMutableShare()->fields= field_count;
1039
1039
 
1040
1040
  /* If result table is small; use a heap */
1041
1041
  /* future: storage engine selection can be made dynamic? */
1472
1472
  return false;
1473
1473
}
1474
1474
 
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->position()))
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
 
  */
 
1475
/* Return false if row hasn't changed */
 
1476
 
 
1477
bool Table::compare_record()
 
1478
{
1532
1479
  if (not getShare()->blob_fields + getShare()->hasVariableWidth())
1533
 
    // Fixed-size record: do bitwise comparison of the records
1534
1480
    return memcmp(this->getInsertRecord(), this->getUpdateRecord(), (size_t) getShare()->getRecordLength());
1535
 
 
 
1481
  
1536
1482
  /* Compare null bits */
1537
1483
  if (memcmp(null_flags, null_flags + getShare()->rec_buff_length, getShare()->null_bytes))
1538
1484
    return true; /* Diff in NULL value */
1540
1486
  /* Compare updated fields */
1541
1487
  for (Field **ptr= field ; *ptr ; ptr++)
1542
1488
  {
1543
 
    if (isWriteSet((*ptr)->position()) &&
 
1489
    if (isWriteSet((*ptr)->field_index) &&
1544
1490
        (*ptr)->cmp_binary_offset(getShare()->rec_buff_length))
1545
1491
      return true;
1546
1492
  }
1647
1593
  query_id(0),
1648
1594
  quick_condition_rows(0),
1649
1595
  timestamp_field_type(TIMESTAMP_NO_AUTO_SET),
1650
 
  map(0),
1651
 
  quick_rows(),
1652
 
  const_key_parts(),
1653
 
  quick_key_parts(),
1654
 
  quick_n_ranges()
 
1596
  map(0)
1655
1597
{
1656
1598
  record[0]= (unsigned char *) 0;
1657
1599
  record[1]= (unsigned char *) 0;
 
1600
 
 
1601
  reginfo.reset();
 
1602
  covering_keys.reset();
 
1603
  quick_keys.reset();
 
1604
  merge_keys.reset();
 
1605
 
 
1606
  keys_in_use_for_query.reset();
 
1607
  keys_in_use_for_group_by.reset();
 
1608
  keys_in_use_for_order_by.reset();
 
1609
 
 
1610
  memset(quick_rows, 0, sizeof(ha_rows) * MAX_KEY);
 
1611
  memset(const_key_parts, 0, sizeof(ha_rows) * MAX_KEY);
 
1612
 
 
1613
  memset(quick_key_parts, 0, sizeof(unsigned int) * MAX_KEY);
 
1614
  memset(quick_n_ranges, 0, sizeof(unsigned int) * MAX_KEY);
1658
1615
}
1659
1616
 
1660
1617
/*****************************************************************************
1676
1633
    print them to the .err log
1677
1634
  */
1678
1635
  if (error != HA_ERR_LOCK_DEADLOCK && error != HA_ERR_LOCK_WAIT_TIMEOUT)
1679
 
    errmsg_printf(error::ERROR, _("Got error %d when reading table '%s'"),
 
1636
    errmsg_printf(ERRMSG_LVL_ERROR, _("Got error %d when reading table '%s'"),
1680
1637
                  error, getShare()->getPath());
1681
1638
  print_error(error, MYF(0));
1682
1639
 
1754
1711
  }
1755
1712
}
1756
1713
 
1757
 
/*
1758
 
  Is this instance of the table should be reopen or represents a name-lock?
1759
 
*/
1760
 
bool Table::needs_reopen_or_name_lock() const
1761
 
{ 
1762
 
  return getShare()->getVersion() != refresh_version;
1763
 
}
1764
 
 
1765
 
uint32_t Table::index_flags(uint32_t idx) const
1766
 
{
1767
 
  return getShare()->getEngine()->index_flags(getShare()->getKeyInfo(idx).algorithm);
1768
 
}
1769
 
 
1770
 
void Table::print_error(int error, myf errflag) const
1771
 
{
1772
 
  getShare()->getEngine()->print_error(error, errflag, *this);
1773
 
}
1774
 
 
1775
1714
} /* namespace drizzled */