~drizzle-trunk/drizzle/development

 *

 * @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 */

    See also comment for Field_timestamp::Field_timestamp().

  */

  enum utype

    NONE,

    NEXT_NUMBER,

    TIMESTAMP_OLD_FIELD,

 

  static void *operator new(size_t size) {return sql_alloc(size); }

  static void *operator new(size_t size, MEM_ROOT *mem_root)

  static void operator delete(void *, size_t)

  { TRASH(ptr_arg, size); }

 

        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);

  }

  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);

  virtual Field *new_key_field(MEM_ROOT *root, Table *new_table,

                               unsigned char *new_null_ptr,

                               uint32_t new_null_bit);

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

   * 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);

    @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 */

 * Send_field is basically a stripped-down POD class for

 * representing basic information about a field...

 */

{

public:

  const char *db_name;