Function lock_tables

sql/sql_base.cc:6030–6199

*/

bool lock_tables(THD *thd, TABLE_LIST *tables, uint count, uint flags)
{
  TABLE_LIST *table, *first_not_own;
  DBUG_ENTER("lock_tables");
  /*
    We can't meet statement requiring prelocking if we already
    in prelocked mode.
  */
  DBUG_ASSERT(thd->locked_tables_mode <= LTM_LOCK_TABLES ||
              !thd->lex->requires_prelocking());

  if (!tables && !thd->lex->requires_prelocking())
    DBUG_RETURN(0);

  first_not_own= thd->lex->first_not_own_table();

  /*
    Check for thd->locked_tables_mode to avoid a redundant
    and harmful attempt to lock the already locked tables again.
    Checking for thd->lock is not enough in some situations. For example,
    if a stored function contains
    "drop table t3; create temporary t3 ..; insert into t3 ...;"
    thd->lock may be 0 after drop tables, whereas locked_tables_mode
    is still on. In this situation an attempt to lock temporary
    table t3 will lead to a memory leak.
  */
  if (! thd->locked_tables_mode)
  {
    DBUG_ASSERT(thd->lock == 0);	// You must lock everything at once
    TABLE **start,**ptr;
    bool found_first_not_own= 0;

    if (!(ptr= start= thd->alloc<TABLE*>(count)))
      DBUG_RETURN(TRUE);

    /*
      Collect changes tables for table lock.
      Mark own tables with query id as this is needed by
      prepare_for_row_logging()
    */
    for (table= tables; table; table= table->next_global)
    {
      if (table == first_not_own)
        found_first_not_own= 1;
      if (!table->placeholder())
      {
        DBUG_ASSERT(table->lock_type != TL_IGNORE);
        *(ptr++)= table->table;
        if (!found_first_not_own)
          table->table->query_id= thd->query_id;
      }
    }

#ifdef ENABLED_DEBUG_SYNC
    if (!tables ||
        !(strcmp(tables->db.str, "mysql") == 0 &&
          strcmp(tables->table_name.str, "proc") == 0))
      DEBUG_SYNC(thd, "before_lock_tables_takes_lock");