~drizzle-trunk/drizzle/development

#include <drizzled/server_includes.h>

/**

   Save the field metadata for varstring fields.

 

   Saves the field length in the first byte. Note: may consume

   2 bytes. Caller must ensure second byte is contiguous with

   first byte (e.g. array index 0,1).

 

   @param   metadata_ptr   First byte of field metadata

 

   @returns number of bytes written to metadata_ptr

*/

int Field_varstring::do_save_field_metadata(unsigned char *metadata_ptr)

{

  assert(field_length <= 65535);

  int2store(metadata_ptr, field_length);

  return 2;

}

 

uint32_t Field_varstring::data_length()

{

  return length_bytes == 1 ? (uint32_t) *ptr : uint2korr(ptr);

}

 

unsigned char *

Field_varstring::pack_key(unsigned char *to, const unsigned char *key, uint32_t max_length,

                          bool )

{

  uint32_t length=  length_bytes == 1 ? (uint32_t) *key : uint2korr(key);

  uint32_t local_char_length= ((field_charset->mbmaxlen > 1) ?

                     max_length/field_charset->mbmaxlen : max_length);

  key+= length_bytes;

  if (length > local_char_length)

  {

    local_char_length= my_charpos(field_charset, key, key+length,

                                  local_char_length);

    set_if_smaller(length, local_char_length);

  }

  *to++= (char) (length & 255);

  if (max_length > 255)

    *to++= (char) (length >> 8);

  if (length)

    memcpy(to, key, length);

  return to+length;

}

 

 

/**

  Unpack a key into a record buffer.

 

  A VARCHAR key has a maximum size of 64K-1.

  In its packed form, the length field is one or two bytes long,

  depending on 'max_length'.

 

  @param to                          Pointer into the record buffer.

  @param key                         Pointer to the packed key.

  @param max_length                  Key length limit from key description.

 

  @return

    Pointer to end of 'key' (To the next key part if multi-segment key)

*/

 

const unsigned char *

Field_varstring::unpack_key(unsigned char *,

                            const unsigned char *key, uint32_t max_length,

                            bool )

{

  /* get length of the blob key */

  uint32_t length= *key++;

  if (max_length > 255)

    length+= (*key++) << 8;

 

  /* put the length into the record buffer */

  if (length_bytes == 1)

    *ptr= (unsigned char) length;

  else

    int2store(ptr, length);

  memcpy(ptr + length_bytes, key, length);

  return key + length;

}

 

/**

  Create a packed key that will be used for storage in the index tree.

 

  @param to             Store packed key segment here

  @param from           Key segment (as given to index_read())

  @param max_length     Max length of key

 

  @return

    end of key storage

*/

 

unsigned char *

Field_varstring::pack_key_from_key_image(unsigned char *to, const unsigned char *from, uint32_t max_length,

                                         bool )

{

  /* Key length is always stored as 2 bytes */

  uint32_t length= uint2korr(from);

  if (length > max_length)

    length= max_length;

  *to++= (char) (length & 255);

  if (max_length > 255)

    *to++= (char) (length >> 8);

  if (length)

    memcpy(to, from+HA_KEY_BLOB_LENGTH, length);

  return to+length;

}

 

 

int Field_varstring::pack_cmp(const unsigned char *a, const unsigned char *b,

                              uint32_t key_length_arg,

                              bool insert_or_update)

{

  uint32_t a_length, b_length;

  if (key_length_arg > 255)

  {

    a_length=uint2korr(a); a+= 2;

    b_length=uint2korr(b); b+= 2;

  }

  else

  {

    a_length= (uint32_t) *a++;