~drizzle-trunk/drizzle/development

#include <drizzled/item/null.h>

#include <drizzled/temporal.h>

 

 

#include "drizzled/table_proto.h"

 

 

  if (db_stat)

    error= cursor->close();

  if (field)

  {

    for (Field **ptr=field ; *ptr ; ptr++)

 

  if (free_share)

  {

  }

 

  return error;

}

 

 

void Table::resetTable(Session *session,

                       TableShare *share,

                       uint32_t db_stat_arg)

{

  field= NULL;

 

  cursor= NULL;

 

  pos_in_table_list= NULL;

  group= NULL;

  null_flags= NULL;

 

  lock_position= 0;

  return (nr);

} /* set_zone */

 

 

/*

  Store an SQL quoted string.

}

 

 

int rename_file_ext(const char * from,const char * to,const char * ext)

{

  string from_s, to_s;

 

bool check_db_name(Session *session, SchemaIdentifier &schema_identifier)

{

  {

    return false;

  }

{

 

  if ((cursor->getEngine()->check_flag(HTON_BIT_PRIMARY_KEY_IN_READ_INDEX)) &&

  {

  }

  return;

}

    We must set bit in read set as update_auto_increment() is using the

    store() to check overflow of auto_increment values

  */

}

 

 

    be able to do an delete

 

  */

  {

    /* fallback to use all columns in the table to identify row */

    use_all_columns();

    return;

  }

  else

 

  /* If we the engine wants all predicates we mark all keys */

  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))

    for (reg_field= field ; *reg_field ; reg_field++)

    {

      if ((*reg_field)->flags & PART_KEY_FLAG)

    }

  }

}

    the primary key, the hidden primary key or all columns to be

    able to do an update

  */

  {

    /* fallback to use all columns in the table to identify row */

    use_all_columns();

    return;

  }

  else

 

  if (cursor->getEngine()->check_flag(HTON_BIT_REQUIRES_KEY_COLUMNS_FOR_DELETE))

  {

    {

      /* Merge keys is all keys that had a column refered to in the query */

      if (is_overlapping(merge_keys, (*reg_field)->part_of_key))

    }

  }

 

  return length;

}

 

/****************************************************************************

 Functions for creating temporary tables.

****************************************************************************/

  */

  if (convert_blob_length && convert_blob_length <= Field_varstring::MAX_SIZE &&

      (org_field->flags & BLOB_FLAG))

    new_field= new Field_varstring(convert_blob_length,

                                   org_field->maybe_null(),

                                   org_field->charset());

  else

    new_field= org_field->new_field(session->mem_root, table,

                                    table == org_field->getTable());

  if (new_field)

  {

    new_field->init(table);

 

Table *

create_tmp_table(Session *session,Tmp_Table_Param *param,List<Item> &fields,

                 uint64_t select_options, ha_rows rows_limit,

                 const char *table_alias)

{

  memory::Root *mem_root_save;

  uint  i,field_count,null_count,null_pack_length;

  uint32_t  copy_func_count= param->func_count;

  uint32_t  hidden_null_count, hidden_null_pack_length, hidden_field_count;

    {

      group= 0;                                 // Can't use group key

    }

    {

      /*

        marker == 4 means two things:

    copy_func_count+= param->sum_func_count;

  }

 

 

                                                &default_field, sizeof(Field*) * (field_count),

                                                &from_field, sizeof(Field*)*field_count,

                                                &copy_func, sizeof(*copy_func)*(copy_func_count+1),

  param->items_to_copy= copy_func;

  /* make table according to fields */

 

  memset(default_field, 0, sizeof(Field*) * (field_count));

  memset(from_field, 0, sizeof(Field*)*field_count);

 

  mem_root_save= session->mem_root;

  session->mem_root= table->getMemRoot();

 

  table->reginfo.lock_type=TL_WRITE;    /* Will be updated */

  table->db_stat=HA_OPEN_KEYFILE+HA_OPEN_RNDFILE;

  table->map=1;

  table->covering_keys.reset();

  table->keys_in_use_for_query.reset();

 

 

  /* Calculate which type of fields we will store in the temporary table */

 

            */

            (*argp)->maybe_null=1;

          }

        }

      }

    }

        group_null_items++;

        new_field->flags|= GROUP_FLAG;

      }

      *(reg_field++)= new_field;

    }

    if (!--hidden_field_count)

  field_count= fieldnr;

  *reg_field= 0;

  *blob_field= 0;                               // End marker

 

  /* If result table is small; use a heap */

  /* future: storage engine selection can be made dynamic? */

      (session->lex->current_select->olap == ROLLUP_TYPE) ||

      (select_options & (OPTION_BIG_TABLES | SELECT_SMALL_RESULT)) == OPTION_BIG_TABLES)

  {

    if (group &&

        (param->group_parts > table->cursor->getEngine()->max_key_parts() ||

         param->group_length > table->cursor->getEngine()->max_key_length()))

  }

  else

  {

  }

  if (! table->cursor)

    goto err;

  if (! using_unique_constraint)

    reclength+= group_null_items;       // null flag is stored separately

 

  if (blob_count == 0)

  {

    /* We need to ensure that first byte is not 0 for the delete link */

  if (blob_count || ((string_total_length >= STRING_TOTAL_LENGTH_TO_PACK_ROWS) && (reclength / string_total_length <= RATIO_TO_PACK_ROWS || (string_total_length / string_count) >= AVG_STRING_LENGTH_TO_PACK_ROWS)))

    use_packed_rows= 1;

 

  {

    uint32_t alloc_length=ALIGN_SIZE(reclength+MI_UNIQUE_HASH_LENGTH+1);

    if (!(table->record[0]= (unsigned char*) table->alloc_root(alloc_length*2)))

    {

      goto err;

    }

    table->record[1]= table->getInsertRecord()+alloc_length;

  }

  copy_func[0]= 0;                              // End marker

  param->func_count= copy_func - param->items_to_copy;

    memset(null_flags, 255, null_pack_length);  // Set null fields

 

    table->null_flags= (unsigned char*) table->getInsertRecord();