← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to client/drizzle.cc

  • Committer: Mark Atwood
  • Date: 2011-11-22 17:04:41 UTC
  • mfrom: (2462.1.3 drizzle-include)
  • Revision ID: me@mark.atwood.name-20111122170441-5dehm0e0ax20z19b
merge lp:~brianaker/drizzle/fedora-16-fixes

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/drizzle.cc
281
281
enum enum_info_type { INFO_INFO,INFO_ERROR,INFO_RESULT};
282
282
typedef enum enum_info_type INFO_TYPE;
283
283
 
284
 
static drizzle_st *drizzle= NULL;      /* The library handle */
285
 
static drizzle_con_st *con= NULL;      /* The connection */
 
284
static drizzle_st drizzle;      /* The library handle */
 
285
static drizzle_con_st con;      /* The connection */
286
286
static bool ignore_errors= false, quick= false,
287
287
  connected= false, opt_raw_data= false, unbuffered= false,
288
288
  output_tables= false, opt_rehash= true, skip_updates= false,
1188
1188
static bool server_shutdown(void)
1189
1189
{
1190
1190
  drizzle_result_st result;
 
1191
  drizzle_return_t ret;
1191
1192
 
1192
1193
  if (verbose)
1193
1194
  {
1194
1195
    printf(_("shutting down drizzled"));
1195
1196
    if (opt_drizzle_port > 0)
1196
 
    {
1197
1197
      printf(_(" on port %d"), opt_drizzle_port);
1198
 
    }
1199
1198
    printf("... ");
1200
1199
  }
1201
1200
 
1202
 
  drizzle_return_t ret;
1203
 
  if (drizzle_shutdown(con, &result, DRIZZLE_SHUTDOWN_DEFAULT, &ret) == NULL or
1204
 
      ret != DRIZZLE_RETURN_OK)
 
1201
  if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,
 
1202
                       &ret) == NULL || ret != DRIZZLE_RETURN_OK)
1205
1203
  {
1206
1204
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
1207
1205
    {
1208
 
      fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_result_error(&result));
 
1206
      fprintf(stderr, _("shutdown failed; error: '%s'"),
 
1207
              drizzle_result_error(&result));
1209
1208
      drizzle_result_free(&result);
1210
1209
    }
1211
1210
    else
1212
1211
    {
1213
 
      fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_con_error(con));
 
1212
      fprintf(stderr, _("shutdown failed; error: '%s'"),
 
1213
              drizzle_con_error(&con));
1214
1214
    }
1215
1215
    return false;
1216
1216
  }
1218
1218
  drizzle_result_free(&result);
1219
1219
 
1220
1220
  if (verbose)
1221
 
  {
1222
1221
    printf(_("done\n"));
1223
 
  }
1224
1222
 
1225
1223
  return true;
1226
1224
}
1236
1234
    printf("... ");
1237
1235
  }
1238
1236
 
1239
 
  if (drizzle_kill(con, &result, query_id,
 
1237
  if (drizzle_kill(&con, &result, query_id,
1240
1238
                   &ret) == NULL || ret != DRIZZLE_RETURN_OK)
1241
1239
  {
1242
1240
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
1247
1245
    }
1248
1246
    else
1249
1247
    {
1250
 
      fprintf(stderr, _("kill failed; error: '%s'"), drizzle_con_error(con));
 
1248
      fprintf(stderr, _("kill failed; error: '%s'"),
 
1249
              drizzle_con_error(&con));
1251
1250
    }
1252
1251
    return false;
1253
1252
  }
1273
1272
  drizzle_result_st result;
1274
1273
  drizzle_return_t ret;
1275
1274
 
1276
 
  if (drizzle_ping(con, &result, &ret) != NULL && ret == DRIZZLE_RETURN_OK)
 
1275
  if (drizzle_ping(&con, &result, &ret) != NULL && ret == DRIZZLE_RETURN_OK)
1277
1276
  {
1278
1277
    if (opt_silent < 2)
1279
1278
      printf(_("drizzled is alive\n"));
1288
1287
    }
1289
1288
    else
1290
1289
    {
1291
 
      fprintf(stderr, _("drizzled won't answer to ping, error: '%s'"), drizzle_con_error(con));
 
1290
      fprintf(stderr, _("drizzled won't answer to ping, error: '%s'"),
 
1291
              drizzle_con_error(&con));
1292
1292
    }
1293
1293
    return false;
1294
1294
  }
1840
1840
  glob_buffer->reserve(512);
1841
1841
 
1842
1842
  snprintf(&output_buff[0], output_buff.size(),
1843
 
           _("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),
1844
 
           drizzle_con_thread_id(con),
1845
 
           opt_protocol.c_str(),
1846
 
           server_version_string(con));
 
1843
          _("Your Drizzle connection id is %u\nConnection protocol: %s\nServer version: %s\n"),
 
1844
          drizzle_con_thread_id(&con),
 
1845
          opt_protocol.c_str(),
 
1846
          server_version_string(&con));
1847
1847
  put_info(&output_buff[0], INFO_INFO, 0, 0);
1848
1848
 
1849
1849
 
1898
1898
 
1899
1899
void drizzle_end(int sig)
1900
1900
{
1901
 
  drizzle_con_free(con);
1902
 
  drizzle_free(drizzle);
 
1901
  drizzle_con_free(&con);
 
1902
  drizzle_free(&drizzle);
1903
1903
  if (!status.getBatch() && !quick && histfile)
1904
1904
  {
1905
1905
    /* write-history */
1937
1937
extern "C"
1938
1938
void handle_sigint(int sig)
1939
1939
{
 
1940
  char kill_buffer[40];
 
1941
  boost::scoped_ptr<drizzle_con_st> kill_drizzle(new drizzle_con_st);
 
1942
  drizzle_result_st res;
 
1943
  drizzle_return_t ret;
 
1944
 
1940
1945
  /* terminate if no query being executed, or we already tried interrupting */
1941
 
  if (executing_query == false or interrupted_query)
1942
 
  { }
1943
 
  else if (drizzle)
1944
 
  {
1945
 
    drizzle_con_st *kill_drizzle_con;
1946
 
    if ((kill_drizzle_con= drizzle_con_add_tcp(drizzle,
1947
 
                                               current_host.c_str(), opt_drizzle_port,
1948
 
                                               current_user.c_str(), opt_password.c_str(), NULL,
1949
 
                                               use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL)))
1950
 
    {
1951
 
      /* kill_buffer is always big enough because max length of %lu is 15 */
1952
 
      char kill_buffer[40];
1953
 
      snprintf(kill_buffer, sizeof(kill_buffer), "KILL /*!50000 QUERY */ %u", drizzle_con_thread_id(kill_drizzle_con));
1954
 
 
1955
 
      drizzle_return_t ret;
1956
 
      drizzle_result_st res;
1957
 
      if ((drizzle_query_str(kill_drizzle_con, &res, kill_buffer, &ret)))
1958
 
      {
1959
 
        drizzle_result_free(&res);
1960
 
      }
1961
 
 
1962
 
      drizzle_con_free(kill_drizzle_con);
1963
 
 
1964
 
      tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));
1965
 
 
1966
 
      interrupted_query= true;
1967
 
 
1968
 
      return;
1969
 
    }
1970
 
  }
1971
 
 
 
1946
  if (!executing_query || interrupted_query)
 
1947
  {
 
1948
    goto err;
 
1949
  }
 
1950
 
 
1951
  if (drizzle_con_add_tcp(&drizzle, kill_drizzle.get(), current_host.c_str(),
 
1952
    opt_drizzle_port, current_user.c_str(), opt_password.c_str(), NULL,
 
1953
    use_drizzle_protocol ? DRIZZLE_CON_EXPERIMENTAL : DRIZZLE_CON_MYSQL) == NULL)
 
1954
  {
 
1955
    goto err;
 
1956
  }
 
1957
 
 
1958
  /* kill_buffer is always big enough because max length of %lu is 15 */
 
1959
  sprintf(kill_buffer, "KILL /*!50000 QUERY */ %u",
 
1960
          drizzle_con_thread_id(&con));
 
1961
 
 
1962
  if (drizzle_query_str(kill_drizzle.get(), &res, kill_buffer, &ret) != NULL)
 
1963
    drizzle_result_free(&res);
 
1964
 
 
1965
  drizzle_con_free(kill_drizzle.get());
 
1966
  tee_fprintf(stdout, _("Query aborted by Ctrl+C\n"));
 
1967
 
 
1968
  interrupted_query= 1;
 
1969
 
 
1970
  return;
 
1971
 
 
1972
err:
1972
1973
  drizzle_end(sig);
1973
1974
}
1974
1975
 
2205
2206
      }
2206
2207
    }
2207
2208
    if (!*ml_comment && inchar == '\\' &&
2208
 
        !(*in_string && (drizzle_con_status(con) & DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES)))
 
2209
        !(*in_string && (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_NO_BACKSLASH_ESCAPES)))
2209
2210
    {
2210
2211
      // Found possbile one character command like \c
2211
2212
 
2621
2622
  /* hash Drizzle functions (to be implemented) */
2622
2623
 
2623
2624
  /* hash all database names */
2624
 
  if (drizzle_query_str(con, &databases, "select schema_name from information_schema.schemata", &ret) != NULL)
 
2625
  if (drizzle_query_str(&con, &databases, "select schema_name from information_schema.schemata", &ret) != NULL)
2625
2626
  {
2626
2627
    if (ret == DRIZZLE_RETURN_OK)
2627
2628
    {
2628
2629
      if (drizzle_result_buffer(&databases) != DRIZZLE_RETURN_OK)
2629
 
      {
2630
 
        put_info(drizzle_error(drizzle),INFO_INFO,0,0);
2631
 
      }
 
2630
        put_info(drizzle_error(&drizzle),INFO_INFO,0,0);
2632
2631
      else
2633
2632
      {
2634
2633
        while ((database_row=drizzle_row_next(&databases)))
2647
2646
  query.append(current_db);
2648
2647
  query.append("' order by table_name");
2649
2648
  
2650
 
  if (drizzle_query(con, &fields, query.c_str(), query.length(), &ret) != NULL)
 
2649
  if (drizzle_query(&con, &fields, query.c_str(), query.length(),
 
2650
                    &ret) != NULL)
2651
2651
  {
2652
2652
    if (ret == DRIZZLE_RETURN_OK &&
2653
2653
        drizzle_result_buffer(&fields) == DRIZZLE_RETURN_OK)
2712
2712
  current_db.erase();
2713
2713
  current_db= "";
2714
2714
  /* In case of error below current_db will be NULL */
2715
 
  if (drizzle_query_str(con, &res, "SELECT DATABASE()", &ret) != NULL)
 
2715
  if (drizzle_query_str(&con, &res, "SELECT DATABASE()", &ret) != NULL)
2716
2716
  {
2717
2717
    if (ret == DRIZZLE_RETURN_OK &&
2718
2718
        drizzle_result_buffer(&res) == DRIZZLE_RETURN_OK)
2738
2738
  for (uint32_t retry=0;; retry++)
2739
2739
  {
2740
2740
    int error;
2741
 
    if (drizzle_query(con, result, buf, length, &ret) != NULL and
 
2741
    if (drizzle_query(&con,result,buf,length,&ret) != NULL &&
2742
2742
        ret == DRIZZLE_RETURN_OK)
2743
2743
    {
2744
2744
      return 0;
2745
2745
    }
2746
 
    error= put_error(con, result);
 
2746
    error= put_error(&con, result);
2747
2747
 
2748
2748
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
2749
2749
    {
2765
2765
int drizzleclient_store_result_for_lazy(drizzle_result_st *result)
2766
2766
{
2767
2767
  if (drizzle_result_buffer(result) == DRIZZLE_RETURN_OK)
2768
 
  {
2769
2768
    return 0;
2770
 
  }
2771
2769
 
2772
 
  if (drizzle_con_error(con)[0])
 
2770
  if (drizzle_con_error(&con)[0])
2773
2771
  {
2774
 
    int ret= put_error(con, result);
 
2772
    int ret= put_error(&con, result);
2775
2773
    drizzle_result_free(result);
2776
2774
    return ret;
2777
2775
  }
2778
 
 
2779
2776
  return 0;
2780
2777
}
2781
2778
 
2839
2836
  uint32_t      error_code= 0;
2840
2837
  int           err= 0;
2841
2838
 
2842
 
  interrupted_query= false;
 
2839
  interrupted_query= 0;
2843
2840
 
2844
2841
  /* Remove garbage for nicer messages */
2845
2842
  remove_cntrl(buffer);
2869
2866
  }
2870
2867
 
2871
2868
  timer=start_timer();
2872
 
  executing_query= true;
 
2869
  executing_query= 1;
2873
2870
  error= drizzleclient_real_query_for_lazy(buffer->c_str(),buffer->length(),&result, &error_code);
2874
2871
 
2875
2872
  if (status.getAddToHistory())
2892
2889
    {
2893
2890
      if (drizzle_column_buffer(&result) != DRIZZLE_RETURN_OK)
2894
2891
      {
2895
 
        error= put_error(con, &result);
 
2892
        error= put_error(&con, &result);
2896
2893
        goto end;
2897
2894
      }
2898
2895
    }
2931
2928
                (long) drizzle_result_row_count(&result));
2932
2929
        end_pager();
2933
2930
        if (drizzle_result_error_code(&result))
2934
 
          error= put_error(con, &result);
 
2931
          error= put_error(&con, &result);
2935
2932
      }
2936
2933
    }
2937
2934
    else if (drizzle_result_affected_rows(&result) == ~(uint64_t) 0)
2966
2963
      fflush(stdout);
2967
2964
    drizzle_result_free(&result);
2968
2965
 
2969
 
    if (drizzle_con_status(con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS)
 
2966
    if (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS)
2970
2967
    {
2971
 
      if (drizzle_result_read(con, &result, &ret) == NULL ||
 
2968
      if (drizzle_result_read(&con, &result, &ret) == NULL ||
2972
2969
          ret != DRIZZLE_RETURN_OK)
2973
2970
      {
2974
2971
        if (ret == DRIZZLE_RETURN_ERROR_CODE)
2977
2974
          drizzle_result_free(&result);
2978
2975
        }
2979
2976
 
2980
 
        error= put_error(con, NULL);
 
2977
        error= put_error(&con, NULL);
2981
2978
        goto end;
2982
2979
      }
2983
2980
    }
2984
2981
 
2985
 
  } while (drizzle_con_status(con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS);
 
2982
  } while (drizzle_con_status(&con) & DRIZZLE_CON_STATUS_MORE_RESULTS_EXISTS);
2986
2983
  if (err >= 1)
2987
 
  {
2988
 
    error= put_error(con, NULL);
2989
 
  }
 
2984
    error= put_error(&con, NULL);
2990
2985
 
2991
2986
end:
2992
2987
 
2994
2989
  if (show_warnings == 1 && (warnings >= 1 || error))
2995
2990
    print_warnings(error_code);
2996
2991
 
2997
 
  if (!error && !status.getBatch() and
2998
 
      drizzle_con_status(con) & DRIZZLE_CON_STATUS_DB_DROPPED)
 
2992
  if (!error && !status.getBatch() &&
 
2993
      drizzle_con_status(&con) & DRIZZLE_CON_STATUS_DB_DROPPED)
2999
2994
  {
3000
2995
    get_current_db();
3001
2996
  }
3002
2997
 
3003
 
  executing_query= false;
 
2998
  executing_query= 0;
3004
2999
  return error;        /* New command follows */
3005
3000
}
3006
3001
 
3007
3002
 
3008
3003
static void init_pager()
3009
3004
{
3010
 
  if (opt_nopager == false)
 
3005
  if (!opt_nopager)
3011
3006
  {
3012
3007
    if (!(PAGER= popen(pager.c_str(), "w")))
3013
3008
    {
3016
3011
    }
3017
3012
  }
3018
3013
  else
3019
 
  {
3020
3014
    PAGER= stdout;
3021
 
  }
3022
3015
}
3023
3016
 
3024
3017
static void end_pager()
3032
3025
{
3033
3026
  FILE* new_outfile;
3034
3027
  if (opt_outfile)
3035
 
  {
3036
3028
    end_tee();
3037
 
  }
3038
 
 
3039
 
  if ((new_outfile= fopen(file_name, "a")) == NULL)
 
3029
  if (!(new_outfile= fopen(file_name, "a")))
3040
3030
  {
3041
3031
    tee_fprintf(stdout, _("Error logging to file '%s'\n"), file_name);
3042
3032
    return;
3269
3259
      cur= drizzle_row_buffer(result, &ret);
3270
3260
      if (ret != DRIZZLE_RETURN_OK)
3271
3261
      {
3272
 
        (void)put_error(con, result);
 
3262
        (void)put_error(&con, result);
3273
3263
        break;
3274
3264
      }
3275
3265
    }
3475
3465
      cur= drizzle_row_buffer(result, &ret);
3476
3466
      if (ret != DRIZZLE_RETURN_OK)
3477
3467
      {
3478
 
        (void)put_error(con, result);
 
3468
        (void)put_error(&con, result);
3479
3469
        break;
3480
3470
      }
3481
3471
    }
3641
3631
      cur= drizzle_row_buffer(result, &ret);
3642
3632
      if (ret != DRIZZLE_RETURN_OK)
3643
3633
      {
3644
 
        (void)put_error(con, result);
 
3634
        (void)put_error(&con, result);
3645
3635
        break;
3646
3636
      }
3647
3637
    }
3885
3875
 
3886
3876
  if (connected)
3887
3877
  {
3888
 
    sprintf(buff, _("Connection id:    %u"), drizzle_con_thread_id(con));
 
3878
    sprintf(buff, _("Connection id:    %u"), drizzle_con_thread_id(&con));
3889
3879
    put_info(buff,INFO_INFO,0,0);
3890
3880
    sprintf(buff, _("Current schema: %.128s\n"),
3891
3881
            !current_db.empty() ? current_db.c_str() : _("*** NONE ***"));
4036
4026
      return opt_reconnect ? -1 : 1;                        // Fatal error
4037
4027
    for (bool try_again= true; try_again; try_again= false)
4038
4028
    {
4039
 
      if (drizzle_select_db(con, &result, tmp, &ret) == NULL ||
 
4029
      if (drizzle_select_db(&con,&result,tmp,&ret) == NULL ||
4040
4030
          ret != DRIZZLE_RETURN_OK)
4041
4031
      {
4042
4032
        if (ret == DRIZZLE_RETURN_ERROR_CODE)
4043
4033
        {
4044
 
          int error= put_error(con, &result);
 
4034
          int error= put_error(&con, &result);
4045
4035
          drizzle_result_free(&result);
4046
4036
          return error;
4047
4037
        }
4048
4038
 
4049
4039
        if (ret != DRIZZLE_RETURN_LOST_CONNECTION || !try_again)
4050
 
        {
4051
 
          return put_error(con, NULL);
4052
 
        }
 
4040
          return put_error(&con, NULL);
4053
4041
 
4054
4042
        if (reconnect())
4055
 
        {
4056
4043
          return opt_reconnect ? -1 : 1;                      // Fatal error
4057
 
        }
4058
4044
      }
4059
4045
      else
4060
4046
        drizzle_result_free(&result);
4081
4067
    printf("... ");
4082
4068
  }
4083
4069
 
4084
 
  if (drizzle_shutdown(con, &result, DRIZZLE_SHUTDOWN_DEFAULT,
 
4070
  if (drizzle_shutdown(&con, &result, DRIZZLE_SHUTDOWN_DEFAULT,
4085
4071
                       &ret) == NULL || ret != DRIZZLE_RETURN_OK)
4086
4072
  {
4087
4073
    if (ret == DRIZZLE_RETURN_ERROR_CODE)
4088
4074
    {
4089
 
      fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_result_error(&result));
 
4075
      fprintf(stderr, _("shutdown failed; error: '%s'"),
 
4076
              drizzle_result_error(&result));
4090
4077
      drizzle_result_free(&result);
4091
4078
    }
4092
4079
    else
4093
4080
    {
4094
 
      fprintf(stderr, _("shutdown failed; error: '%s'"), drizzle_con_error(con));
 
4081
      fprintf(stderr, _("shutdown failed; error: '%s'"),
 
4082
              drizzle_con_error(&con));
4095
4083
    }
4096
4084
    return false;
4097
4085
  }
4189
4177
  if (connected)
4190
4178
  {
4191
4179
    connected= 0;
4192
 
    drizzle_con_free(con);
4193
 
    drizzle_free(drizzle);
4194
 
  }
4195
 
 
4196
 
  drizzle= drizzle_create();
4197
 
  if (drizzle == NULL)
4198
 
  {
4199
 
    return 1;
4200
 
  }
4201
 
 
4202
 
  if ((con= drizzle_con_add_tcp(drizzle, host.c_str(),
4203
 
                                opt_drizzle_port, user.c_str(),
4204
 
                                password.c_str(), database.c_str(),
4205
 
                                global_con_options)) == NULL)
4206
 
  {
4207
 
    (void) put_error(con, NULL);
 
4180
    drizzle_con_free(&con);
 
4181
    drizzle_free(&drizzle);
 
4182
  }
 
4183
  drizzle_create(&drizzle);
 
4184
 
 
4185
  if (drizzle_con_add_tcp(&drizzle, &con, (char *)host.c_str(),
 
4186
                          opt_drizzle_port, (char *)user.c_str(),
 
4187
                          (char *)password.c_str(), (char *)database.c_str(),
 
4188
                          global_con_options) == NULL)
 
4189
  {
 
4190
    (void) put_error(&con, NULL);
4208
4191
    (void) fflush(stdout);
4209
4192
    return 1;
4210
4193
  }
4211
4194
 
4212
 
  if ((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)
 
4195
  if ((ret= drizzle_con_connect(&con)) != DRIZZLE_RETURN_OK)
4213
4196
  {
4214
4197
 
4215
4198
    if (opt_silent < 2)
4216
4199
    {
4217
 
      (void) put_error(con, NULL);
 
4200
      (void) put_error(&con, NULL);
4218
4201
      (void) fflush(stdout);
4219
4202
      return ignore_errors ? -1 : 1;    // Abort
4220
4203
    }
4222
4205
  }
4223
4206
  connected= 1;
4224
4207
 
4225
 
  ServerDetect server_detect(con);
 
4208
  ServerDetect server_detect(&con);
4226
4209
  server_type= server_detect.getServerType();
4227
4210
 
4228
4211
  build_completion_hash(opt_rehash, 1);
4248
4231
 
4249
4232
  if (connected)
4250
4233
  {
4251
 
    tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(con));
 
4234
    tee_fprintf(stdout, _("\nConnection id:\t\t%lu\n"),drizzle_con_thread_id(&con));
4252
4235
    /*
4253
4236
      Don't remove "limit 1",
4254
4237
      it is protection againts SQL_SELECT_LIMIT=0
4255
4238
    */
4256
 
    if (drizzle_query_str(con, &result, "select DATABASE(), USER() limit 1",
 
4239
    if (drizzle_query_str(&con,&result,"select DATABASE(), USER() limit 1",
4257
4240
                          &ret) != NULL && ret == DRIZZLE_RETURN_OK &&
4258
4241
        drizzle_result_buffer(&result) == DRIZZLE_RETURN_OK)
4259
4242
    {
4285
4268
  tee_fprintf(stdout, _("Current pager:\t\t%s\n"), pager.c_str());
4286
4269
  tee_fprintf(stdout, _("Using outfile:\t\t'%s'\n"), opt_outfile ? outfile.c_str() : "");
4287
4270
  tee_fprintf(stdout, _("Using delimiter:\t%s\n"), delimiter);
4288
 
  tee_fprintf(stdout, _("Server version:\t\t%s\n"), server_version_string(con));
 
4271
  tee_fprintf(stdout, _("Server version:\t\t%s\n"), server_version_string(&con));
4289
4272
  tee_fprintf(stdout, _("Protocol:\t\t%s\n"), opt_protocol.c_str());
4290
 
  tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(con));
4291
 
  tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(con));
 
4273
  tee_fprintf(stdout, _("Protocol version:\t%d\n"), drizzle_con_protocol_version(&con));
 
4274
  tee_fprintf(stdout, _("Connection:\t\t%s\n"), drizzle_con_host(&con));
4292
4275
/* XXX need to save this from result
4293
4276
  if ((id= drizzleclient_insert_id(&drizzle)))
4294
4277
    tee_fprintf(stdout, "Insert id:\t\t%s\n", internal::llstr(id, buff));
4295
4278
*/
4296
4279
 
4297
 
  if (drizzle_con_uds(con))
4298
 
  {
4299
 
    tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(con));
4300
 
  }
 
4280
  if (drizzle_con_uds(&con))
 
4281
    tee_fprintf(stdout, _("UNIX socket:\t\t%s\n"), drizzle_con_uds(&con));
4301
4282
  else
4302
 
  {
4303
 
    tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(con));
4304
 
  }
 
4283
    tee_fprintf(stdout, _("TCP port:\t\t%d\n"), drizzle_con_port(&con));
4305
4284
 
4306
4285
  if (safe_updates)
4307
4286
  {
4440
4419
  {
4441
4420
    error= drizzle_result_error(res);
4442
4421
    if (!strcmp(error, ""))
4443
 
    {
4444
4422
      error= drizzle_con_error(local_con);
4445
 
    }
4446
4423
  }
4447
4424
  else
4448
 
  {
4449
4425
    error= drizzle_con_error(local_con);
4450
 
  }
4451
4426
 
4452
4427
  return put_info(error, INFO_ERROR,
4453
4428
                  res == NULL ? drizzle_con_error_code(local_con) :
4598
4573
        break;
4599
4574
      case 'v':
4600
4575
        if (connected)
4601
 
          processed_prompt->append(drizzle_con_server_version(con));
 
4576
          processed_prompt->append(drizzle_con_server_version(&con));
4602
4577
        else
4603
4578
          processed_prompt->append("not_connected");
4604
4579
        break;
4607
4582
        break;
4608
4583
      case 'h':
4609
4584
      {
4610
 
        const char *prompt= connected ? drizzle_con_host(con) : "not_connected";
 
4585
        const char *prompt= connected ? drizzle_con_host(&con) : "not_connected";
4611
4586
        if (strstr(prompt, "Localhost"))
4612
4587
          processed_prompt->append("localhost");
4613
4588
        else
4626
4601
          break;
4627
4602
        }
4628
4603
 
4629
 
        if (drizzle_con_uds(con))
 
4604
        if (drizzle_con_uds(&con))
4630
4605
        {
4631
 
          const char *pos=strrchr(drizzle_con_uds(con),'/');
4632
 
          processed_prompt->append(pos ? pos+1 : drizzle_con_uds(con));
 
4606
          const char *pos=strrchr(drizzle_con_uds(&con),'/');
 
4607
          processed_prompt->append(pos ? pos+1 : drizzle_con_uds(&con));
4633
4608
        }
4634
4609
        else
4635
 
          add_int_to_prompt(drizzle_con_port(con));
 
4610
          add_int_to_prompt(drizzle_con_port(&con));
4636
4611
      }
4637
4612
      break;
4638
4613
      case 'U':