~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to storage/myisam/mi_dynrec.c

• browse files at revision 261.1.6
• compare with another revision
• compare with revision 261.1.6
• download diff
• download tarball
• view history from revision 261.1.6

Show diffs side-by-side

added

removed

storage/myisam/mi_dynrec.c

680

680

        /* Make a long block for one write */

681

681

  record_end= *record+length-head_length;

682

682

  del_length=(res_length ? MI_DYN_DELETE_BLOCK_HEADER : 0);

683

 

  memcpy((uchar*) (*record-head_length),(uchar*) temp,head_length);

 

683

  memcpy(*record - head_length, temp, head_length);

684

684

  memcpy(temp,record_end,(size_t) (extra_length+del_length));

685

 

  memset((uchar*) record_end, 0, extra_length);

 

685

  memset(record_end, 0, extra_length);

686

686

 

687

687

  if (res_length)

688

688

  {

737

737

                  del_length,filepos,info->s->write_flag))

738

738

      goto err;

739

739

  }

740

 

  memcpy(record_end,temp,(size_t) (extra_length+del_length));

 

740

  memcpy(record_end, temp, extra_length + del_length);

741

741

  *record=record_end;

742

742

  *reclength-=(length-head_length);

743

743

  *flag=6;

947

947

        {

948

948

          char *temp_pos;

949

949

          size_t tmp_length=length-portable_sizeof_char_ptr;

950

 

          memcpy((uchar*) to,from,tmp_length);

 

950

          memcpy(to,from,tmp_length);

951

951

          memcpy(&temp_pos,from+tmp_length,sizeof(char*));

952

 

          memcpy(to+tmp_length,temp_pos,(size_t) blob->length);

 

952

          memcpy(to + tmp_length, temp_pos, blob->length);

953

953

          to+=tmp_length+blob->length;

954

954

        }

955

955

        blob++;

956

956

      }

957

957

      else if (type == FIELD_SKIP_ZERO)

958

958

      {

959

 

        if (memcmp((uchar*) from,zero_string,length) == 0)

 

959

        if (memcmp(from,zero_string,length) == 0)

960

960

          flag|=bit;

961

961

        else

962

962

        {

963

 

          memcpy((uchar*) to,from,(size_t) length); to+=length;

 

963

          memcpy(to, from, length);

 

964

          to+=length;

964

965

        }

965

966

      }

966

967

      else if (type == FIELD_SKIP_ENDSPACE ||

989

990

          }

990

991

          else

991

992

            *to++= (uchar) new_length;

992

 

          memcpy((uchar*) to,pos,(size_t) new_length); to+=new_length;

 

993

          memcpy(to, pos, new_length);

 

994

          to+=new_length;

993

995

          flag|=bit;

994

996

        }

995

997

        else

996

998

        {

997

 

          memcpy(to,from,(size_t) length); to+=length;

 

999

          memcpy(to, from, length);

 

1000

          to+=length;

998

1001

        }

999

1002

      }

1000

1003

      else if (type == FIELD_VARCHAR)

1011

1014

          tmp_length= uint2korr(from);

1012

1015

          store_key_length_inc(to,tmp_length);

1013

1016

        }

1014

 

        memcpy(to, from+pack_length,tmp_length);

 

1017

        memcpy(to, from+pack_length, tmp_length);

1015

1018

        to+= tmp_length;

1016

1019

        continue;

1017

1020

      }

1018

1021

      else

1019

1022

      {

1020

 

        memcpy(to,from,(size_t) length); to+=length;

 

1023

        memcpy(to, from, length);

 

1024

        to+=length;

1021

1025

        continue;                               /* Normal field */

1022

1026

      }

1023

1027

      if ((bit= bit << 1) >= 256)

1028

1032

    }

1029

1033

    else

1030

1034

    {

1031

 

      memcpy(to,from,(size_t) length); to+=length;

 

1035

      memcpy(to, from, length);

 

1036

      to+=length;

1032

1037

    }

1033

1038

  }

1034

1039

  if (bit != 1)

1073

1078

      }

1074

1079

      else if (type == FIELD_SKIP_ZERO)

1075

1080

      {

1076

 

        if (memcmp((uchar*) record,zero_string,length) == 0)

 

1081

        if (memcmp(record,zero_string,length) == 0)

1077

1082

        {

1078

1083

          if (!(flag & bit))

1079

1084

            goto err;

1217

1222

      if (flag & bit)

1218

1223

      {

1219

1224

        if (type == FIELD_BLOB || type == FIELD_SKIP_ZERO)

1220

 

          memset((uchar*) to, 0, rec_length);

 

1225

          memset(to, 0, rec_length);

1221

1226

        else if (type == FIELD_SKIP_ENDSPACE ||

1222

1227

                 type == FIELD_SKIP_PRESPACE)

1223

1228

        {

1239

1244

            goto err;

1240

1245

          if (type == FIELD_SKIP_ENDSPACE)

1241

1246

          {

1242

 

            memcpy(to,(uchar*) from,(size_t) length);

1243

 

            memset((uchar*) to+length, ' ', rec_length-length);

 

1247

            memcpy(to, from, length);

 

1248

            memset(to+length, ' ', rec_length-length);

1244

1249

          }

1245

1250

          else

1246

1251

          {

1247

 

            memset((uchar*) to, ' ', rec_length-length);

1248

 

            memcpy(to+rec_length-length,(uchar*) from,(size_t) length);

 

1252

            memset(to, ' ', rec_length-length);

 

1253

            memcpy(to + rec_length - length, from, length);

1249

1254

          }

1250

1255

          from+=length;

1251

1256

        }

1259

1264

            from_left - size_length < blob_length ||

1260

1265

            from_left - size_length - blob_length < min_pack_length)

1261

1266

          goto err;

1262

 

        memcpy((uchar*) to,(uchar*) from,(size_t) size_length);

 

1267

        memcpy(to, from, size_length);

1263

1268

        from+=size_length;

1264

 

        memcpy((uchar*) to+size_length,(uchar*) &from,sizeof(char*));

 

1269

        memcpy(to+size_length, &from, sizeof(char*));

1265

1270

        from+=blob_length;

1266

1271

      }

1267

1272

      else

1270

1275

          min_pack_length--;

1271

1276

        if (min_pack_length + rec_length > (uint) (from_end - from))

1272

1277

          goto err;

1273

 

        memcpy(to,(uchar*) from,(size_t) rec_length); from+=rec_length;

 

1278

        memcpy(to, from, rec_length);

 

1279

        from+=rec_length;

1274

1280

      }

1275

1281

      if ((bit= bit << 1) >= 256)

1276

1282

      {

1282

1288

      if (min_pack_length > (uint) (from_end - from))

1283

1289

        goto err;

1284

1290

      min_pack_length-=rec_length;

1285

 

      memcpy(to, (uchar*) from, (size_t) rec_length);

 

1291

      memcpy(to, from, rec_length);

1286

1292

      from+=rec_length;

1287

1293

    }

1288

1294

  }

1443

1449

          prefetch_len= block_info.data_len;

1444

1450

        if (prefetch_len)

1445

1451

        {

1446

 

          memcpy((uchar*) to, block_info.header + offset, prefetch_len);

 

1452

          memcpy(to, block_info.header + offset, prefetch_len);

1447

1453

          block_info.data_len-= prefetch_len;

1448

1454

          left_length-= prefetch_len;

1449

1455

          to+= prefetch_len;

1756

1762

        tmp_length= block_info.data_len;

1757

1763

      if (tmp_length)

1758

1764

      {

1759

 

        memcpy((uchar*) to, block_info.header+offset,tmp_length);

 

1765

        memcpy(to, block_info.header+offset,tmp_length);

1760

1766

        block_info.data_len-=tmp_length;

1761

1767

        left_len-=tmp_length;

1762

1768

        to+=tmp_length;

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1