~drizzle-trunk/drizzle/development

#include "drizzled/sql_bitmap.h"

#include "drizzled/sql_list.h"

#include "drizzled/structs.h"

 

#include <string>

#include <vector>

#define ASSERT_COLUMN_MARKED_FOR_WRITE

#endif

 

const uint32_t max_field_size= (uint32_t) 4294967295U;

 

class SendField;

 *

 * @details

 *

 * unsigned char pointer member variable called ptr.  The

 * convert the byte into the appropriate output (int, decimal, etc).

 *

 * The store_xxx() methods take various input and convert

class Field

{

  /* Prevent use of these */

  void operator=(Field &);

public:

  unsigned char *ptr; /**< Position to field in record. Stores raw field value */

  unsigned char *null_ptr; /**< Byte where null_bit is */

 

  /**

   *

   * @note You can use table->in_use as replacement for current_session member

   * only inside of val_*() and store() members (e.g. you can't use it in cons)

   */

  Table *orig_table; /**< Pointer to the original Table. @TODO What is "the original table"? */

  const char **table_name; /**< Pointer to the name of the table. @TODO This is redundant with Table::table_name. */

  const char *field_name; /**< Name of the field */

  key_map part_of_sortkey;

 

  /*

  */

  enum utype

    NONE,

    NEXT_NUMBER,

    TIMESTAMP_OLD_FIELD,

   */

  bool is_created_from_null_item;

 

  static void operator delete(void *, size_t)

 

  Field(unsigned char *ptr_arg,

        uint32_t length_arg,

        const char *field_name_arg);

  virtual ~Field() {}

  /* Store functions returns 1 on overflow and -1 on fatal error */

                    const CHARSET_INFO * const cs)=0;

  virtual int store(double nr)=0;

  virtual int store(int64_t nr, bool unsigned_val)=0;

  virtual int store_decimal(const my_decimal *d)=0;

            uint32_t length,

            const CHARSET_INFO * const cs,

            enum_check_fields check_level);

  virtual double val_real(void)=0;

  virtual int64_t val_int(void)=0;

  virtual my_decimal *val_decimal(my_decimal *);

  {

    return val_str(str, str);

  }

    field_length + 1, field_length, and pack_length_no_ptr() respectfully.

  */

  virtual uint32_t row_pack_length();

 

  /**

   * For varstrings, this does _not_ include the length bytes.

   */

  virtual uint32_t data_length();

   * use field->val_int() for comparison.  Used to optimize clauses like

   * 'a_column BETWEEN date_const AND date_const'.

   */

  {

    return false;

  }

  virtual void free() {}

                           Table *new_table,

                           bool keep_type);

                               unsigned char *new_null_ptr,

                               uint32_t new_null_bit);

  /** This is used to generate a field in Table from TableShare */

  inline void move_field(unsigned char *ptr_arg,unsigned char *null_ptr_arg,unsigned char null_bit_arg)

  {

    ptr= ptr_arg;

   * characters have maximal possible size (mbmaxlen). In the other words,

   * "length" parameter is a number of characters multiplied by

   * field_charset->mbmaxlen.

   * @retval

   *   Number of copied bytes (excluding padded zero bytes -- see above).

   */

  {

    unsigned char *old_ptr= ptr;

    int64_t return_value;

    return_value= val_int();

    ptr= old_ptr;

    return return_value;

  inline String *val_str(String *str, const unsigned char *new_ptr)

  {

    unsigned char *old_ptr= ptr;

    val_str(str);

    ptr= old_ptr;

    return str;

 

  virtual unsigned char *pack_key(unsigned char* to,

                                  const unsigned char *from,

                                  bool low_byte_first)

  {

    return pack(to, from, max_length, low_byte_first);

  }

  virtual const unsigned char *unpack_key(unsigned char* to,

                                          const unsigned char *from,

                                          uint32_t max_length,

  {

    return unpack(to, from, max_length, low_byte_first);

  }

  virtual uint32_t max_packed_col_length(uint32_t max_length)

  {

    return max_length;

  }

 

  inline uint32_t offset(unsigned char *record)

  {

    return (uint32_t) (ptr - record);

    @retval

      0 otherwise

  */

                   unsigned int code,

                   int cuted_increment);

  /**

      fields counter if count_cuted_fields ==FIELD_CHECK_IGNORE for current

      thread.

  */

                            uint32_t code,

                            uint32_t str_len,

                            int cuted_increment);

  /**

    Produce warning or note about integer datetime value saved into field.

      fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current

      thread.

  */

                            uint32_t code,

                            enum enum_drizzle_timestamp_type ts_type,

                            int cuted_increment);

  /**

      fields counter if count_cuted_fields == FIELD_CHECK_IGNORE for current

      thread.

  */

                            const uint32_t code,

                            enum enum_drizzle_timestamp_type ts_type);

  inline bool check_overflow(int op_result)

  {

    @return

      value converted from val

  */

                                  bool unsigned_flag,

                                  int *err);

  /* The max. number of characters */

  bool isWriteSet();

  void setReadSet(bool arg= true);

  void setWriteSet(bool arg= true);

};

 

#include "drizzled/create_field.h"

 * Send_field is basically a stripped-down POD class for

 * representing basic information about a field...

 */

{

public:

  const char *db_name;

/**

 * A class for quick copying data to fields

 */

{

  /**

    Convenience definition of a copy function returned by

};

 

Field *make_field(TableShare *share,

                  unsigned char *ptr,

                  uint32_t field_length,

                  bool is_nullable,