← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to plugin/oldlibdrizzle/oldlibdrizzle.cc

  • Committer: Monty Taylor
  • Date: 2009-06-08 13:39:05 UTC
  • mto: This revision was merged to the branch mainline in revision 1060.
  • Revision ID: mordred@inaugust.com-20090608133905-3hogrrafmfg6e5hs
Removed CHARSET_INFO stuff from protocol plugin interface - it makes no sense.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugin/oldlibdrizzle/oldlibdrizzle.cc
115
115
}
116
116
 
117
117
 
118
 
/*
119
 
  netStoreData() - extended version with character set conversion.
120
 
 
121
 
  It is optimized for short strings whose length after
122
 
  conversion is garanteed to be less than 251, which accupies
123
 
  exactly one byte to store length. It allows not to use
124
 
  the "convert" member as a temporary buffer, conversion
125
 
  is done directly to the "packet" member.
126
 
  The limit 251 is good enough to optimize send_fields()
127
 
  because column, table, database names fit into this limit.
128
 
*/
129
 
 
130
 
bool ProtocolOldLibdrizzle::netStoreData(const unsigned char *from, size_t length,
131
 
                              const CHARSET_INFO * const from_cs,
132
 
                              const CHARSET_INFO * const to_cs)
133
 
{
134
 
  uint32_t dummy_errors;
135
 
  /* Calculate maxumum possible result length */
136
 
  uint32_t conv_length= to_cs->mbmaxlen * length / from_cs->mbminlen;
137
 
  if (conv_length > 250)
138
 
  {
139
 
    /*
140
 
      For strings with conv_length greater than 250 bytes
141
 
      we don't know how many bytes we will need to store length: one or two,
142
 
      because we don't know result length until conversion is done.
143
 
      For example, when converting from utf8 (mbmaxlen=3) to latin1,
144
 
      conv_length=300 means that the result length can vary between 100 to 300.
145
 
      length=100 needs one byte, length=300 needs to bytes.
146
 
 
147
 
      Thus conversion directly to "packet" is not worthy.
148
 
      Let's use "convert" as a temporary buffer.
149
 
    */
150
 
    return (convert->copy((const char*) from, length, from_cs,
151
 
                          to_cs, &dummy_errors) ||
152
 
            netStoreData((const unsigned char*) convert->ptr(), convert->length()));
153
 
  }
154
 
 
155
 
  size_t packet_length= packet->length();
156
 
  size_t new_length= packet_length + conv_length + 1;
157
 
 
158
 
  if (new_length > packet->alloced_length() && packet->realloc(new_length))
159
 
    return 1;
160
 
 
161
 
  char *length_pos= (char*) packet->ptr() + packet_length;
162
 
  char *to= length_pos + 1;
163
 
 
164
 
  to+= copy_and_convert(to, conv_length, to_cs,
165
 
                        (const char*) from, length, from_cs, &dummy_errors);
166
 
 
167
 
  drizzleclient_net_store_length((unsigned char*) length_pos, to - length_pos - 1);
168
 
  packet->length((uint32_t) (to - packet->ptr()));
169
 
  return 0;
170
 
}
171
 
 
172
 
 
173
118
/**
174
119
  Return ok to the client.
175
120
 
398
343
  while ((item=it++))
399
344
  {
400
345
    char *pos;
401
 
    const CHARSET_INFO * const cs= system_charset_info;
402
346
    Send_field field;
403
347
    item->make_field(&field);
404
348
 
405
349
    prepareForResend();
406
350
 
407
 
    if (store(STRING_WITH_LEN("def"), cs) ||
408
 
        store(field.db_name, cs) ||
409
 
        store(field.table_name, cs) ||
410
 
        store(field.org_table_name, cs) ||
411
 
        store(field.col_name, cs) ||
412
 
        store(field.org_col_name, cs) ||
 
351
    if (store(STRING_WITH_LEN("def")) ||
 
352
        store(field.db_name) ||
 
353
        store(field.table_name) ||
 
354
        store(field.org_table_name) ||
 
355
        store(field.col_name) ||
 
356
        store(field.org_col_name) ||
413
357
        packet->realloc(packet->length()+12))
414
358
      goto err;
415
359
 
416
360
    /* Store fixed length fields */
417
361
    pos= (char*) packet->ptr()+packet->length();
418
362
    *pos++= 12;                // Length of packed fields
419
 
    if (item->collation.collation == &my_charset_bin)
420
 
    {
421
 
      /* No conversion */
422
 
      int2store(pos, field.charsetnr);
423
 
      int4store(pos+2, field.length);
424
 
    }
425
 
    else
426
 
    {
427
 
      /* With conversion */
428
 
      uint32_t max_char_len;
429
 
      int2store(pos, cs->number);
430
 
      /*
431
 
        For TEXT/BLOB columns, field_length describes the maximum data
432
 
        length in bytes. There is no limit to the number of characters
433
 
        that a TEXT column can store, as long as the data fits into
434
 
        the designated space.
435
 
        For the rest of textual columns, field_length is evaluated as
436
 
        char_count * mbmaxlen, where character count is taken from the
437
 
        definition of the column. In other words, the maximum number
438
 
        of characters here is limited by the column definition.
439
 
      */
440
 
      max_char_len= field.length / item->collation.collation->mbmaxlen;
441
 
      int4store(pos+2, max_char_len * cs->mbmaxlen);
442
 
    }
 
363
    /* No conversion */
 
364
    int2store(pos, field.charsetnr);
 
365
    int4store(pos+2, field.length);
443
366
    pos[6]= field.type;
444
367
    int2store(pos+7,field.flags);
445
368
    pos[9]= (char) field.decimals;
627
550
}
628
551
 
629
552
 
630
 
/**
631
 
  Auxilary function to convert string to the given character set
632
 
  and store in network buffer.
633
 
*/
634
 
 
635
 
bool ProtocolOldLibdrizzle::storeString(const char *from, size_t length,
636
 
                                        const CHARSET_INFO * const fromcs,
637
 
                                        const CHARSET_INFO * const tocs)
638
 
{
639
 
  /* 'tocs' is set 0 when client issues SET character_set_results=NULL */
640
 
  if (tocs && !my_charset_same(fromcs, tocs) &&
641
 
      fromcs != &my_charset_bin &&
642
 
      tocs != &my_charset_bin)
643
 
  {
644
 
    /* Store with conversion */
645
 
    return netStoreData((unsigned char*) from, length, fromcs, tocs);
646
 
  }
647
 
  /* Store without conversion */
648
 
  return netStoreData((unsigned char*) from, length);
649
 
}
650
 
 
651
 
 
652
 
bool ProtocolOldLibdrizzle::store(const char *from, size_t length,
653
 
                          const CHARSET_INFO * const fromcs)
654
 
{
655
 
  const CHARSET_INFO * const tocs= default_charset_info;
656
 
  return storeString(from, length, fromcs, tocs);
 
553
bool ProtocolOldLibdrizzle::store(const char *from, size_t length)
 
554
{
 
555
  return netStoreData((const unsigned char *)from, length);
657
556
}
658
557
 
659
558
 
699
598
    return store();
700
599
  char buff[MAX_FIELD_WIDTH];
701
600
  String str(buff,sizeof(buff), &my_charset_bin);
702
 
  const CHARSET_INFO * const tocs= default_charset_info;
703
601
 
704
602
  from->val_str(&str);
705
603
 
706
 
  return storeString(str.ptr(), str.length(), str.charset(), tocs);
 
604
  return netStoreData((const unsigned char *)str.ptr(), str.length());
707
605
}
708
606
 
709
607