← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzle.cc

Merge in Monty/Andrew's boolean MySQL compatible patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzle.cc
37
37
#include <config.h>
38
38
#include <libdrizzle/drizzle_client.h>
39
39
 
40
 
#include <client/get_password.h>
 
40
#include "server_detect.h"
 
41
#include "get_password.h"
41
42
 
42
43
#include <boost/date_time/posix_time/posix_time.hpp>
43
44
 
307
308
static uint32_t select_limit;
308
309
static uint32_t max_join_size;
309
310
static uint32_t opt_connect_timeout= 0;
 
311
static ServerDetect::server_type server_type= ServerDetect::SERVER_UNKNOWN_FOUND;
310
312
std::string current_db,
311
313
  delimiter_str,  
312
314
  current_host,
3128
3130
  drizzle_return_t ret;
3129
3131
  drizzle_column_st *field;
3130
3132
  std::vector<bool> num_flag;
 
3133
  std::vector<bool> boolean_flag;
 
3134
  std::vector<bool> ansi_boolean_flag;
3131
3135
  string separator;
3132
3136
 
3133
3137
  separator.reserve(256);
3134
3138
 
3135
3139
  num_flag.resize(drizzle_result_column_count(result));
 
3140
  boolean_flag.resize(drizzle_result_column_count(result));
 
3141
  ansi_boolean_flag.resize(drizzle_result_column_count(result));
3136
3142
  if (column_types_flag)
3137
3143
  {
3138
3144
    print_field_types(result);
3175
3181
      // Room for "NULL"
3176
3182
      length=4;
3177
3183
    }
 
3184
    if ((length < 5) and 
 
3185
      (server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and
 
3186
      (drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY) and
 
3187
      (drizzle_column_type(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))
 
3188
    {
 
3189
      // Room for "FALSE"
 
3190
      length= 5;
 
3191
    }
3178
3192
    drizzle_column_set_max_size(field, length);
3179
3193
 
3180
3194
    for (x=0; x< (length+2); x++)
3198
3212
                  drizzle_column_name(field));
3199
3213
      num_flag[off]= ((drizzle_column_type(field) <= DRIZZLE_COLUMN_TYPE_LONGLONG) ||
3200
3214
                      (drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_NEWDECIMAL));
 
3215
      if ((server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and
 
3216
        (drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY))
 
3217
      {
 
3218
        if ((drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))
 
3219
        {
 
3220
          ansi_boolean_flag[off]= true;
 
3221
        }
 
3222
        else
 
3223
        {
 
3224
          ansi_boolean_flag[off]= false;
 
3225
        }
 
3226
        boolean_flag[off]= true;
 
3227
        num_flag[off]= false;
 
3228
      }
 
3229
      else
 
3230
      {
 
3231
        boolean_flag[off]= false;
 
3232
      }
3201
3233
    }
3202
3234
    (void) tee_fputs("\n", PAGER);
3203
3235
    tee_puts((char*) separator.c_str(), PAGER);
3236
3268
        buffer= "NULL";
3237
3269
        data_length= 4;
3238
3270
      }
 
3271
      else if (boolean_flag[off])
 
3272
      {
 
3273
        if (strncmp(cur[off],"1", 1) == 0)
 
3274
        {
 
3275
          if (ansi_boolean_flag[off])
 
3276
          {
 
3277
            buffer= "YES";
 
3278
            data_length= 3;
 
3279
          }
 
3280
          else
 
3281
          {
 
3282
            buffer= "TRUE";
 
3283
            data_length= 4;
 
3284
          }
 
3285
        }
 
3286
        else
 
3287
        {
 
3288
          if (ansi_boolean_flag[off])
 
3289
          {
 
3290
            buffer= "NO";
 
3291
            data_length= 2;
 
3292
          }
 
3293
          else
 
3294
          {
 
3295
            buffer= "FALSE";
 
3296
            data_length= 5;
 
3297
          }
 
3298
        }
 
3299
      }
3239
3300
      else
3240
3301
      {
3241
3302
        buffer= cur[off];
3509
3570
  drizzle_return_t ret;
3510
3571
  drizzle_column_st *field;
3511
3572
  size_t *lengths;
3512
 
 
3513
 
  if (opt_silent < 2 && column_names)
 
3573
  std::vector<bool> boolean_flag;
 
3574
  std::vector<bool> ansi_boolean_flag;
 
3575
 
 
3576
  boolean_flag.resize(drizzle_result_column_count(result));
 
3577
  ansi_boolean_flag.resize(drizzle_result_column_count(result));
 
3578
 
 
3579
  int first=0;
 
3580
  for (uint32_t off= 0; (field = drizzle_column_next(result)); off++)
3514
3581
  {
3515
 
    int first=0;
3516
 
    while ((field = drizzle_column_next(result)))
 
3582
    if (opt_silent < 2 && column_names)
3517
3583
    {
3518
3584
      if (first++)
3519
3585
        (void) tee_fputs("\t", PAGER);
3520
3586
      (void) tee_fputs(drizzle_column_name(field), PAGER);
3521
3587
    }
 
3588
    if ((server_type == ServerDetect::SERVER_DRIZZLE_FOUND) and
 
3589
      (drizzle_column_type(field) == DRIZZLE_COLUMN_TYPE_TINY))
 
3590
    {
 
3591
      if ((drizzle_column_flags(field) & DRIZZLE_COLUMN_FLAGS_UNSIGNED))
 
3592
      {
 
3593
        ansi_boolean_flag[off]= true;
 
3594
      }
 
3595
      else
 
3596
      {
 
3597
        ansi_boolean_flag[off]= false;
 
3598
      }
 
3599
      boolean_flag[off]= true;
 
3600
    }
 
3601
    else
 
3602
    {
 
3603
      boolean_flag[off]= false;
 
3604
    }
 
3605
  }
 
3606
  if (opt_silent < 2 && column_names)
 
3607
  {
3522
3608
    (void) tee_fputs("\n", PAGER);
3523
3609
  }
3524
3610
  while (1)
3539
3625
      break;
3540
3626
 
3541
3627
    lengths= drizzle_row_field_sizes(result);
3542
 
    safe_put_field(cur[0],lengths[0]);
3543
 
    for (uint32_t off=1 ; off < drizzle_result_column_count(result); off++)
 
3628
    drizzle_column_seek(result, 0);
 
3629
    for (uint32_t off=0 ; off < drizzle_result_column_count(result); off++)
3544
3630
    {
3545
 
      (void) tee_fputs("\t", PAGER);
3546
 
      safe_put_field(cur[off], lengths[off]);
 
3631
      if (off != 0)
 
3632
        (void) tee_fputs("\t", PAGER);
 
3633
      if (boolean_flag[off])
 
3634
      {
 
3635
        if (strncmp(cur[off],"1", 1) == 0)
 
3636
        {
 
3637
          if (ansi_boolean_flag[off])
 
3638
          {
 
3639
            safe_put_field("YES", 3);
 
3640
          }
 
3641
          else
 
3642
          {
 
3643
            safe_put_field("TRUE", 4);
 
3644
          }
 
3645
        }
 
3646
        else
 
3647
        {
 
3648
          if (ansi_boolean_flag[off])
 
3649
          {
 
3650
            safe_put_field("NO", 2);
 
3651
          }
 
3652
          else
 
3653
          {
 
3654
            safe_put_field("FALSE", 5);
 
3655
          }
 
3656
        }
 
3657
      }
 
3658
      else
 
3659
      {
 
3660
        safe_put_field(cur[off], lengths[off]);
 
3661
      }
3547
3662
    }
3548
3663
    (void) tee_fputs("\n", PAGER);
3549
3664
    if (quick)
4108
4223
  }
4109
4224
  connected=1;
4110
4225
 
 
4226
  ServerDetect server_detect(&con);
 
4227
  server_type= server_detect.getServerType();
 
4228
 
4111
4229
  build_completion_hash(opt_rehash, 1);
4112
4230
  return 0;
4113
4231
}