testoibasic.cpp

mysql-5.0.22.tar.gz源码包

Row::calc(Par par, unsigned i, unsigned mask)
{
  const Tab& tab = m_tab;
  for (unsigned k = 0; k < tab.m_cols; k++) {
    if (! (mask & (1 << k))) {
      Val& val = *m_val[k];
      val.calc(par, i);
    }
  }
}

const Row&
Row::dbrow() const
{
  if (m_dbrow == 0)
    return *this;
  assert(m_pending == Row::UpdOp || m_pending == Row::DelOp);
  return *m_dbrow;
}

int
Row::verify(Par par, const Row& row2) const
{
  const Tab& tab = m_tab;
  const Row& row1 = *this;
  assert(&row1.m_tab == &row2.m_tab && row1.m_exist && row2.m_exist);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    const Val& val1 = *row1.m_val[k];
    const Val& val2 = *row2.m_val[k];
    CHK(val1.verify(par, val2) == 0);
  }
  return 0;
}

int
Row::insrow(Par par)
{
  Con& con = par.con();
  const Tab& tab = m_tab;
  assert(! m_exist);
  CHK(con.getNdbOperation(tab) == 0);
  CHKCON(con.m_op->insertTuple() == 0, con);
  Rsq rsq1(tab.m_cols);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    unsigned k2 = rsq1.next();
    const Val& val = *m_val[k2];
    const Col& col = val.m_col;
    if (col.m_pk)
      CHK(val.equal(par) == 0);
  }
  Rsq rsq2(tab.m_cols);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    unsigned k2 = rsq2.next();
    const Val& val = *m_val[k2];
    const Col& col = val.m_col;
    if (! col.m_pk)
      CHK(val.setval(par) == 0);
  }
  m_pending = InsOp;
  return 0;
}

int
Row::updrow(Par par)
{
  Con& con = par.con();
  const Tab& tab = m_tab;
  assert(m_exist);
  CHK(con.getNdbOperation(tab) == 0);
  CHKCON(con.m_op->updateTuple() == 0, con);
  Rsq rsq1(tab.m_cols);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    unsigned k2 = rsq1.next();
    const Val& val = *m_val[k2];
    const Col& col = val.m_col;
    if (col.m_pk)
      CHK(val.equal(par) == 0);
  }
  Rsq rsq2(tab.m_cols);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    unsigned k2 = rsq2.next();
    const Val& val = *m_val[k2];
    const Col& col = val.m_col;
    if (! col.m_pk)
      CHK(val.setval(par) == 0);
  }
  m_pending = UpdOp;
  return 0;
}

int
Row::updrow(Par par, const ITab& itab)
{
  Con& con = par.con();
  const Tab& tab = m_tab;
  assert(itab.m_type == ITab::UniqueHashIndex && &itab.m_tab == &tab);
  assert(m_exist);
  CHK(con.getNdbIndexOperation(itab, tab) == 0);
  CHKCON(con.m_op->updateTuple() == 0, con);
  Rsq rsq1(itab.m_icols);
  for (unsigned k = 0; k < itab.m_icols; k++) {
    unsigned k2 = rsq1.next();
    const ICol& icol = *itab.m_icol[k2];
    const Col& col = icol.m_col;
    unsigned m = col.m_num;
    const Val& val = *m_val[m];
    CHK(val.equal(par, icol) == 0);
  }
  Rsq rsq2(tab.m_cols);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    unsigned k2 = rsq2.next();
    const Val& val = *m_val[k2];
    const Col& col = val.m_col;
    if (! col.m_pk)
      CHK(val.setval(par) == 0);
  }
  m_pending = UpdOp;
  return 0;
}

int
Row::delrow(Par par)
{
  Con& con = par.con();
  const Tab& tab = m_tab;
  assert(m_exist);
  CHK(con.getNdbOperation(m_tab) == 0);
  CHKCON(con.m_op->deleteTuple() == 0, con);
  Rsq rsq1(tab.m_cols);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    unsigned k2 = rsq1.next();
    const Val& val = *m_val[k2];
    const Col& col = val.m_col;
    if (col.m_pk)
      CHK(val.equal(par) == 0);
  }
  m_pending = DelOp;
  return 0;
}

int
Row::delrow(Par par, const ITab& itab)
{
  Con& con = par.con();
  const Tab& tab = m_tab;
  assert(itab.m_type == ITab::UniqueHashIndex && &itab.m_tab == &tab);
  assert(m_exist);
  CHK(con.getNdbIndexOperation(itab, tab) == 0);
  CHKCON(con.m_op->deleteTuple() == 0, con);
  Rsq rsq1(itab.m_icols);
  for (unsigned k = 0; k < itab.m_icols; k++) {
    unsigned k2 = rsq1.next();
    const ICol& icol = *itab.m_icol[k2];
    const Col& col = icol.m_col;
    unsigned m = col.m_num;
    const Val& val = *m_val[m];
    CHK(val.equal(par, icol) == 0);
  }
  m_pending = DelOp;
  return 0;
}

int
Row::selrow(Par par)
{
  Con& con = par.con();
  const Tab& tab = m_tab;
  CHK(con.getNdbOperation(m_tab) == 0);
  CHKCON(con.m_op->readTuple() == 0, con);
  Rsq rsq1(tab.m_cols);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    unsigned k2 = rsq1.next();
    const Val& val = *m_val[k2];
    const Col& col = val.m_col;
    if (col.m_pk)
      CHK(val.equal(par) == 0);
  }
  return 0;
}

int
Row::selrow(Par par, const ITab& itab)
{
  Con& con = par.con();
  const Tab& tab = m_tab;
  assert(itab.m_type == ITab::UniqueHashIndex && &itab.m_tab == &tab);
  CHK(con.getNdbIndexOperation(itab, tab) == 0);
  CHKCON(con.m_op->readTuple() == 0, con);
  Rsq rsq1(itab.m_icols);
  for (unsigned k = 0; k < itab.m_icols; k++) {
    unsigned k2 = rsq1.next();
    const ICol& icol = *itab.m_icol[k2];
    const Col& col = icol.m_col;
    unsigned m = col.m_num;
    const Val& val = *m_val[m];
    CHK(val.equal(par, icol) == 0);
  }
  return 0;
}

int
Row::setrow(Par par)
{
  Con& con = par.con();
  const Tab& tab = m_tab;
  Rsq rsq1(tab.m_cols);
  for (unsigned k = 0; k < tab.m_cols; k++) {
    unsigned k2 = rsq1.next();
    const Val& val = *m_val[k2];
    const Col& col = val.m_col;
    if (! col.m_pk)
      CHK(val.setval(par) == 0);
  }
  m_pending = UpdOp;
  return 0;
}

int
Row::cmp(Par par, const Row& row2) const
{
  const Tab& tab = m_tab;
  assert(&tab == &row2.m_tab);
  int c = 0;
  for (unsigned k = 0; k < tab.m_cols; k++) {
    const Val& val = *m_val[k];
    const Val& val2 = *row2.m_val[k];
    if ((c = val.cmp(par, val2)) != 0)
      break;
  }
  return c;
}

int
Row::cmp(Par par, const Row& row2, const ITab& itab) const
{
  const Tab& tab = m_tab;
  int c = 0;
  for (unsigned i = 0; i < itab.m_icols; i++) {
    const ICol& icol = *itab.m_icol[i];
    const Col& col = icol.m_col;
    unsigned k = col.m_num;
    assert(k < tab.m_cols);
    const Val& val = *m_val[k];
    const Val& val2 = *row2.m_val[k];
    if ((c = val.cmp(par, val2)) != 0)
      break;
  }
  return c;
}

static NdbOut&
operator<<(NdbOut& out, const Row::Op op)
{
  if (op == Row::NoOp)
    out << "NoOp";
  else if (op == Row::InsOp)
    out << "InsOp";
  else if (op == Row::UpdOp)
    out << "UpdOp";
  else if (op == Row::DelOp)
    out << "DelOp";
  else
    out << op;
  return out;
}

static NdbOut&
operator<<(NdbOut& out, const Row& row)
{
  const Tab& tab = row.m_tab;
  for (unsigned i = 0; i < tab.m_cols; i++) {
    if (i > 0)
      out << " ";
    out << *row.m_val[i];
  }
  out << " exist=" << row.m_exist;
  if (row.m_pending)
    out << " pending=" << row.m_pending;
  if (row.m_dbrow != 0)
    out << " [dbrow=" << *row.m_dbrow << "]";
  return out;
}

static NdbOut&
operator<<(NdbOut& out, const Row* rowptr)
{
  if (rowptr == 0)
    out << "null";
  else
    out << *rowptr;
  return out;
}

// Set - set of table tuples

struct Set {
  const Tab& m_tab;
  unsigned m_rows;
  Row** m_row;
  unsigned* m_rowkey; // maps row number (from 0) in scan to tuple key
  Row* m_keyrow;
  NdbRecAttr** m_rec;
  Set(const Tab& tab, unsigned rows);
  ~Set();
  void reset();
  unsigned count() const;
  // old and new values
  bool exist(unsigned i) const;
  void dbsave(unsigned i);
  void calc(Par par, unsigned i, unsigned mask = 0);
  bool pending(unsigned i, unsigned mask) const;
  void notpending(unsigned i, ExecType et = Commit);
  void notpending(const Lst& lst, ExecType et = Commit);
  void dbdiscard(unsigned i);
  void dbdiscard(const Lst& lst);
  const Row& dbrow(unsigned i) const;
  // operations
  int insrow(Par par, unsigned i);
  int updrow(Par par, unsigned i);
  int updrow(Par par, const ITab& itab, unsigned i);
  int delrow(Par par, unsigned i);
  int delrow(Par par, const ITab& itab, unsigned i);
  int selrow(Par par, const Row& keyrow);
  int selrow(Par par, const ITab& itab, const Row& keyrow);
  // set and get
  void setkey(Par par, const Row& keyrow);
  void setkey(Par par, const ITab& itab, const Row& keyrow);
  int setrow(Par par, unsigned i);
  int getval(Par par);
  int getkey(Par par, unsigned* i);
  int putval(unsigned i, bool force, unsigned n = ~0);
  // verify
  int verify(Par par, const Set& set2) const;
  int verifyorder(Par par, const ITab& itab, bool descending) const;
  // protect structure
  NdbMutex* m_mutex;
  void lock() const {
    NdbMutex_Lock(m_mutex);
  }
  void unlock() const {
    NdbMutex_Unlock(m_mutex);
  }
private:
  Set& operator=(const Set& set2);
};

Set::Set(const Tab& tab, unsigned rows) :
  m_tab(tab)
{
  m_rows = rows;
  m_row = new Row* [m_rows];
  for (unsigned i = 0; i < m_rows; i++) {
    // allocate on need to save space
    m_row[i] = 0;
  }
  m_rowkey = new unsigned [m_rows];
  for (unsigned n = 0; n < m_rows; n++) {
    // initialize to null
    m_rowkey[n] = ~0;
  }
  m_keyrow = new Row(tab);
  m_rec = new NdbRecAttr* [tab.m_cols];
  for (unsigned k = 0; k < tab.m_cols; k++) {
    m_rec[k] = 0;
  }
  m_mutex = NdbMutex_Create();
  assert(m_mutex != 0);
}

Set::~Set()
{
  for (unsigned i = 0; i < m_rows; i++) {
    delete m_row[i];
  }
  delete [] m_row;
  delete [] m_rowkey;
  delete m_keyrow;
  delete [] m_rec;
  NdbMutex_Destroy(m_mutex);
}

void
Set::reset()
{
  for (unsigned i = 0; i < m_rows; i++) {
    if (m_row[i] != 0) {
      Row& row = *m_row[i];
      row.m_exist = false;
    }
  }
}

unsigned
Set::count() const
{
  unsigned count = 0;
  for (unsigned i = 0; i < m_rows; i++) {
    if (m_row[i] != 0) {
      Row& row = *m_row[i];
      if (row.m_exist)
        count++;
    }
  }
  return count;
}

// old and new values

bool
Set::exist(unsigned i) const
{
  assert(i < m_rows);
  if (m_row[i] == 0)    // not allocated => not exist
    return false;
  return m_row[i]->m_exist;
}

void
Set::dbsave(unsigned i)
{
  const Tab& tab = m_tab;
  assert(i < m_rows && m_row[i] != 0);
  Row& row = *m_row[i];
  LL5("dbsave " << i << ": " << row);
  assert(row.m_exist && ! row.m_pending && row.m_dbrow == 0);
  // could swap pointers but making copy is safer
  Row* rowptr = new Row(tab);
  rowptr->copy(row);
  row.m_dbrow = rowptr;
}

void
Set::calc(Par par, unsigned i, unsigned mask)
{
  const Tab& tab = m_tab;
  if (m_row[i] == 0)
    m_row[i] = new Row(tab);
  Row& row = *m_row[i];
  row.calc(par, i, mask);
}

bool
Set::pending(unsigned i, unsigned mask) const
{
  assert(i < m_rows);
  if (m_row[i] == 0)    // not allocated => not pending
    return Row::NoOp;
  return m_row[i]->m_pending & mask;
}

void
Set::notpending(unsigned i, ExecType et)
{
  assert(m_row[i] != 0);
  Row& row = *m_row[i];
  if (et == Commit) {
    if (row.m_pending == Row::InsOp)
      row.m_exist = true;
    if (row.m_pending == Row::DelOp)
      row.m_exist = false;
  } else {
    if (row.m_pending == Row::InsOp)
      row.m_exist = false;
    if (row.m_pending == Row::DelOp)
      row.m_exist = true;
  }
  row.m_pending = Row::NoOp;
}

void
Set::notpending(const Lst& lst, ExecType et)
{
  for (unsigned j = 0; j < lst.m_cnt; j++) {
    unsigned i = lst.m_arr[j];
    notpending(i, et);
  }
}

void
Set::dbdiscard(unsigned i)
{
  assert(m_row[i] != 0);
  Row& row = *m_row[i];
  LL5("dbdiscard " << i << ": " << row);
  assert(row.m_dbrow != 0);
  delete row.m_dbrow;
  row.m_dbrow = 0;
}

const Row&
Set::dbrow(unsigned i) const
{
  assert(m_row[i] != 0);
  Row& row = *m_row[i];
  return row.dbrow();
}

void
Set::dbdiscard(const Lst& lst)
{
  for (unsigned j = 0; j < lst.m_cnt; j++) {
    unsigned i = lst.m_arr[j];
    dbdiscard(i);
  }
}

// operations

int
Set::insrow(Par par, unsigned i)
{
  assert(m_row[i] != 0);
  Row& row = *m_row[i];
  CHK(row.insrow(par) == 0);
  return 0;
}

int
Set::updrow(Par par, unsigned i)
{
  assert(m_row[i] != 0);
  Row& row = *m_row[i];
  CHK(row.updrow(par) == 0);
  return 0;
}

int
Set::updrow(Par par, const ITab& itab, unsigned i)
{
  assert(m_row[i] != 0);
  Row& row = *m_row[i];
  CHK(row.updrow(par, itab) == 0);
  return 0;
}

int
Set::delrow(Par par, unsigned i)
{
  assert(m_row[i] != 0);
  Row& row = *m_row[i];
  CHK(row.delrow(par) == 0);
  return 0;
}

int
Set::delrow(Par par, const ITab& itab, unsigned i)
{
  assert(m_row[i] != 0);
  Row& row = *m_row[i];
  CHK(row.delrow(par, itab) == 0);
  return 0;
}

int
Set::selrow(Par par, const Row& keyrow)
{
  Con& con = par.con();
  const Tab& tab = par.tab();
  setkey(par, keyrow);
  L