← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to examples/client.c

  • Committer: Brian Aker
  • Date: 2010-12-18 18:24:57 UTC
  • mfrom: (1999.6.3 trunk)
  • Revision ID: brian@tangent.org-20101218182457-yi1wd0so2hml1k1w
Merge in Lee's copyright header fix

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/client.c
 
1
/*
 
2
 * Drizzle Client & Protocol Library
 
3
 *
 
4
 * Copyright (C) 2008 Eric Day (eday@oddments.org)
 
5
 * All rights reserved.
 
6
 *
 
7
 * Redistribution and use in source and binary forms, with or without
 
8
 * modification, are permitted provided that the following conditions are
 
9
 * met:
 
10
 *
 
11
 *     * Redistributions of source code must retain the above copyright
 
12
 * notice, this list of conditions and the following disclaimer.
 
13
 *
 
14
 *     * Redistributions in binary form must reproduce the above
 
15
 * copyright notice, this list of conditions and the following disclaimer
 
16
 * in the documentation and/or other materials provided with the
 
17
 * distribution.
 
18
 *
 
19
 *     * The names of its contributors may not be used to endorse or
 
20
 * promote products derived from this software without specific prior
 
21
 * written permission.
 
22
 *
 
23
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 
24
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 
25
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 
26
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 
27
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 
28
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 
29
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 
30
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 
31
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 
32
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 
33
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
34
 *
 
35
 */
 
36
 
 
37
 
 
38
#include "config.h"
 
39
 
 
40
#include <errno.h>
 
41
#include <stdbool.h>
 
42
#include <stdint.h>
 
43
#include <stdio.h>
 
44
#include <stdlib.h>
 
45
#include <string.h>
 
46
#include <unistd.h>
 
47
 
 
48
#include <libdrizzle/drizzle_client.h>
 
49
 
 
50
typedef enum
 
51
{
 
52
  CLIENT_QUERY,
 
53
  CLIENT_FIELDS,
 
54
  CLIENT_ROWS
 
55
} client_state;
 
56
 
 
57
typedef enum
 
58
{
 
59
  BUFFER_NONE,
 
60
  BUFFER_FIELD,
 
61
  BUFFER_ROW,
 
62
  BUFFER_ALL
 
63
} buffer_level;
 
64
 
 
65
typedef struct
 
66
{
 
67
  drizzle_con_st con;
 
68
  drizzle_result_st result;
 
69
  drizzle_column_st column;
 
70
  client_state state;
 
71
  uint64_t row;
 
72
} client_con_st;
 
73
 
 
74
typedef struct
 
75
{
 
76
  drizzle_st drizzle;
 
77
  bool mysql_protocol;
 
78
  client_con_st *client_con_list;
 
79
  uint32_t client_con_count;
 
80
  buffer_level level;
 
81
  char *query;
 
82
  size_t query_len;
 
83
} client_st;
 
84
 
 
85
char client_process(client_st *client, client_con_st *client_con);
 
86
void con_info(drizzle_con_st *con);
 
87
void result_info(drizzle_result_st *result);
 
88
void column_info(drizzle_column_st *column);
 
89
 
 
90
#define CLIENT_ERROR(__function, __ret, __client) { \
 
91
    printf(__function ":%d:%s\n", __ret, \
 
92
           drizzle_error(&((__client)->drizzle))); \
 
93
    exit(1); }
 
94
 
 
95
int main(int argc, char *argv[])
 
96
{
 
97
  client_st client;
 
98
  int c;
 
99
  char blocking= 0;
 
100
  drizzle_return_t ret;
 
101
  uint32_t x;
 
102
  int wait_for_connections= 0;
 
103
  drizzle_con_st *con;
 
104
  client_con_st *client_con;
 
105
  char *host= NULL;
 
106
  in_port_t port= 0;
 
107
  char *user= NULL;
 
108
  char *password= NULL;
 
109
  char *db= NULL;
 
110
 
 
111
  memset(&client, 0, sizeof(client_st));
 
112
 
 
113
  /* Use one connection by default. */
 
114
  client.client_con_count= 1;
 
115
 
 
116
  while ((c = getopt(argc, argv, "bB:c:d:h:Hmp:P:u:")) != -1)
 
117
  {
 
118
    switch(c)
 
119
    {
 
120
    case 'b':
 
121
      blocking= 1;
 
122
      break;
 
123
 
 
124
    case 'B':
 
125
      if (!strcasecmp(optarg, "none"))
 
126
        client.level= BUFFER_NONE;
 
127
      else if (!strcasecmp(optarg, "field"))
 
128
        client.level= BUFFER_FIELD;
 
129
      else if (!strcasecmp(optarg, "row"))
 
130
        client.level= BUFFER_ROW;
 
131
      else if (!strcasecmp(optarg, "all"))
 
132
        client.level= BUFFER_ALL;
 
133
      else
 
134
      {
 
135
        printf("Invalid buffer level: %s\n", optarg);
 
136
        exit(0);
 
137
      }
 
138
      break;
 
139
 
 
140
    case 'c':
 
141
      client.client_con_count= (uint32_t)atoi(optarg);
 
142
      break;
 
143
 
 
144
    case 'd':
 
145
      db= optarg;
 
146
      break;
 
147
 
 
148
    case 'h':
 
149
      host= optarg;
 
150
      break;
 
151
 
 
152
    case 'm':
 
153
      client.mysql_protocol= true;
 
154
      break;
 
155
 
 
156
    case 'p':
 
157
      password= optarg;
 
158
      break;
 
159
 
 
160
    case 'P':
 
161
      port= (in_port_t)atoi(optarg);
 
162
      break;
 
163
 
 
164
    case 'u':
 
165
      user= optarg;
 
166
      break;
 
167
 
 
168
    case 'H':
 
169
    default:
 
170
      printf("\nUsage: %s [options] [query]\n", argv[0]);
 
171
      printf("\t-b            - Use blocking sockets\n");
 
172
      printf("\t-B <level>    - Use buffer <level>, options are:\n");
 
173
      printf("\t                none - Don't buffer anything (default)\n");
 
174
      printf("\t                field - Only buffer individual fields\n");
 
175
      printf("\t                row - Only buffer individual rows\n");
 
176
      printf("\t                all - Buffer entire result\n");
 
177
      printf("\t-c <cons>     - Create <cons> connections\n");
 
178
      printf("\t-d <db>       - Use <db> for the connection\n");
 
179
      printf("\t-h <host>     - Connect to <host>\n");
 
180
      printf("\t-H            - Print this help menu\n");
 
181
      printf("\t-m            - Use MySQL protocol\n");
 
182
      printf("\t-p <password> - Use <password> for authentication\n");
 
183
      printf("\t-P <port>     - Connect to <port>\n");
 
184
      printf("\t-u <user>     - Use <user> for authentication\n");
 
185
      exit(0);
 
186
    }
 
187
  }
 
188
 
 
189
  if (argc != optind)
 
190
  {
 
191
    client.query= argv[optind];
 
192
    client.query_len= strlen(client.query);
 
193
  }
 
194
 
 
195
  if (client.client_con_count > 0)
 
196
  {
 
197
    client.client_con_list= calloc(client.client_con_count,
 
198
                                   sizeof(client_con_st));
 
199
    if (client.client_con_list == NULL)
 
200
    {
 
201
      printf("calloc:%d\n", errno);
 
202
      exit(1);
 
203
    }
 
204
  }
 
205
 
 
206
  /* This may fail if there is other initialization that fails. See docs. */
 
207
  if (drizzle_create(&(client.drizzle)) == NULL)
 
208
  {
 
209
    printf("drizzle_create failed\n");
 
210
    exit(1);
 
211
  }
 
212
 
 
213
  if (blocking == 0)
 
214
    drizzle_add_options(&(client.drizzle), DRIZZLE_NON_BLOCKING);
 
215
 
 
216
  /* Start all connections, and if in non-blocking mode, return as soon as the
 
217
     connection would block. In blocking mode, this completes the entire
 
218
     connection/query/result. */
 
219
  for (x= 0; x < client.client_con_count; x++)
 
220
  {
 
221
    /* This may fail if there is other initialization that fails. See docs. */
 
222
    con= drizzle_con_add_tcp(&(client.drizzle),
 
223
                              &(client.client_con_list[x].con),
 
224
                              host, port, user, password, db,
 
225
                              client.mysql_protocol ? DRIZZLE_CON_MYSQL : 0);
 
226
    if (con == NULL)
 
227
      CLIENT_ERROR("drizzle_con_add_tcp", 0, &client);
 
228
    drizzle_con_set_context(&(client.client_con_list[x].con),
 
229
                            &(client.client_con_list[x]));
 
230
 
 
231
    if (client_process(&client, &(client.client_con_list[x])) == 1)
 
232
      wait_for_connections++;
 
233
  }
 
234
 
 
235
  /* If in non-blocking mode, continue to process connections as they become
 
236
     ready. Loop exits when all connections have completed. */
 
237
  while (wait_for_connections != 0)
 
238
  {
 
239
    ret= drizzle_con_wait(&(client.drizzle));
 
240
    if (ret != DRIZZLE_RETURN_OK)
 
241
      CLIENT_ERROR("drizzle_con_wait", ret, &client);
 
242
 
 
243
    while ((con= drizzle_con_ready(&(client.drizzle))) != NULL)
 
244
    {
 
245
      client_con= (client_con_st *)drizzle_con_context(con);
 
246
 
 
247
      if (client_process(&client, client_con) == 0)
 
248
        wait_for_connections--;
 
249
    }
 
250
  }
 
251
 
 
252
  for (x= 0; x < client.client_con_count; x++)
 
253
    drizzle_con_free(&(client.client_con_list[x].con));
 
254
 
 
255
  drizzle_free(&(client.drizzle));
 
256
 
 
257
  if (client.client_con_list != NULL)
 
258
    free(client.client_con_list);
 
259
 
 
260
  return 0;
 
261
}
 
262
 
 
263
char client_process(client_st *client, client_con_st *client_con)
 
264
{
 
265
  drizzle_return_t ret;
 
266
  drizzle_column_st *column;
 
267
  size_t offset= 0;
 
268
  size_t length;
 
269
  size_t total;
 
270
  drizzle_field_t field;
 
271
  drizzle_row_t row;
 
272
  size_t *field_sizes;
 
273
  uint16_t x;
 
274
 
 
275
  switch (client_con->state)
 
276
  {
 
277
  case CLIENT_QUERY:
 
278
    if (client->query == NULL)
 
279
      break;
 
280
 
 
281
    /* This may fail if some allocation fails, but it will set ret. */
 
282
    (void)drizzle_query(&(client_con->con), &(client_con->result),
 
283
                        client->query, client->query_len, &ret);
 
284
    if (ret == DRIZZLE_RETURN_IO_WAIT)
 
285
      return 1;
 
286
    else if (ret != DRIZZLE_RETURN_OK)
 
287
      CLIENT_ERROR("drizzle_query", ret, client);
 
288
 
 
289
    result_info(&(client_con->result));
 
290
 
 
291
    if (drizzle_result_column_count(&(client_con->result)) == 0)
 
292
      break;
 
293
 
 
294
    client_con->state= CLIENT_FIELDS;
 
295
 
 
296
  case CLIENT_FIELDS:
 
297
    if (client->level == BUFFER_ALL)
 
298
    {
 
299
      ret= drizzle_result_buffer(&(client_con->result));
 
300
      if (ret == DRIZZLE_RETURN_IO_WAIT)
 
301
        return 1;
 
302
      else if (ret != DRIZZLE_RETURN_OK)
 
303
        CLIENT_ERROR("drizzle_result_buffer", ret, client);
 
304
 
 
305
      while ((column= drizzle_column_next(&(client_con->result))) != NULL)
 
306
        column_info(column);
 
307
    }
 
308
    else
 
309
    {
 
310
      while (1)
 
311
      {
 
312
        column= drizzle_column_read(&(client_con->result),
 
313
                                    &(client_con->column), &ret);
 
314
        if (ret == DRIZZLE_RETURN_IO_WAIT)
 
315
          return 1;
 
316
        else if (ret != DRIZZLE_RETURN_OK)
 
317
          CLIENT_ERROR("drizzle_column_read", ret, client);
 
318
 
 
319
        if (column == NULL)
 
320
          break;
 
321
 
 
322
        column_info(column);
 
323
        drizzle_column_free(column);
 
324
      }
 
325
    }
 
326
 
 
327
    client_con->state= CLIENT_ROWS;
 
328
 
 
329
  case CLIENT_ROWS:
 
330
    if (client->level == BUFFER_ALL)
 
331
    {
 
332
      /* Everything has been buffered, just loop through and print. */
 
333
      while ((row= drizzle_row_next(&(client_con->result))) != NULL)
 
334
      {
 
335
        field_sizes= drizzle_row_field_sizes(&(client_con->result));
 
336
 
 
337
        printf("Row: %" PRId64 "\n",
 
338
               drizzle_row_current(&(client_con->result)));
 
339
 
 
340
        for (x= 0; x < drizzle_result_column_count(&(client_con->result)); x++)
 
341
        {
 
342
          if (row[x] == NULL)
 
343
            printf("     (NULL)\n");
 
344
          else
 
345
          {
 
346
            printf("     (%zd) %.*s\n", field_sizes[x], (int32_t)field_sizes[x],
 
347
                   row[x]);
 
348
          }
 
349
        }
 
350
 
 
351
        printf("\n");
 
352
      }
 
353
 
 
354
      drizzle_result_free(&(client_con->result));
 
355
      break;
 
356
    }
 
357
 
 
358
    while (1)
 
359
    {
 
360
      if (client->level == BUFFER_NONE || client->level == BUFFER_FIELD)
 
361
      {
 
362
        /* Still need to read a row at a time, and then each field. */
 
363
        if (client_con->row == 0)
 
364
        {
 
365
          client_con->row= drizzle_row_read(&(client_con->result), &ret);
 
366
          if (ret == DRIZZLE_RETURN_IO_WAIT)
 
367
          {
 
368
            client_con->row= 0;
 
369
            return 1;
 
370
          }
 
371
          else if (ret != DRIZZLE_RETURN_OK)
 
372
            CLIENT_ERROR("drizzle_row", ret, client);
 
373
 
 
374
          if (client_con->row == 0)
 
375
          {
 
376
            drizzle_result_free(&(client_con->result));
 
377
            break;
 
378
          }
 
379
 
 
380
          printf("Row: %" PRId64 "\n", client_con->row);
 
381
        }
 
382
 
 
383
        while (1)
 
384
        {
 
385
          if (client->level == BUFFER_FIELD)
 
386
          {
 
387
            /* Since an entire field is buffered, we don't need to worry about
 
388
               partial reads. */
 
389
            field= drizzle_field_buffer(&(client_con->result), &total, &ret);
 
390
            length= total;
 
391
          }
 
392
          else
 
393
          {
 
394
            field= drizzle_field_read(&(client_con->result), &offset, &length,
 
395
                                      &total, &ret);
 
396
          }
 
397
 
 
398
          if (ret == DRIZZLE_RETURN_IO_WAIT)
 
399
            return 1;
 
400
          else if (ret == DRIZZLE_RETURN_ROW_END)
 
401
            break;
 
402
          else if (ret != DRIZZLE_RETURN_OK)
 
403
            CLIENT_ERROR("drizzle_field_read", ret, client);
 
404
 
 
405
          if (field == NULL)
 
406
            printf("     (NULL)");
 
407
          else if (offset > 0)
 
408
            printf("%.*s", (int32_t)length, field);
 
409
          else
 
410
            printf("     (%zd) %.*s", total, (int32_t)length, field);
 
411
 
 
412
          if (offset + length == total)
 
413
            printf("\n");
 
414
 
 
415
          /* If we buffered the entire field, be sure to free it. */
 
416
          if (client->level == BUFFER_FIELD)
 
417
            drizzle_field_free(field);
 
418
        }
 
419
 
 
420
        client_con->row= 0;
 
421
        printf("\n");
 
422
      }
 
423
      else if (client->level == BUFFER_ROW)
 
424
      {
 
425
        /* The entire row will be buffered here, so no need to worry about
 
426
           partial reads. */
 
427
        row = drizzle_row_buffer(&(client_con->result), &ret);
 
428
        if (ret == DRIZZLE_RETURN_IO_WAIT)
 
429
          return 1;
 
430
        else if (ret != DRIZZLE_RETURN_OK)
 
431
          CLIENT_ERROR("drizzle_row", ret, client);
 
432
 
 
433
        /* This marks the end of rows. */
 
434
        if (row == NULL)
 
435
          break;
 
436
 
 
437
        field_sizes= drizzle_row_field_sizes(&(client_con->result));
 
438
 
 
439
        printf("Row: %" PRId64 "\n",
 
440
               drizzle_row_current(&(client_con->result)));
 
441
 
 
442
        for (x= 0; x < drizzle_result_column_count(&(client_con->result)); x++)
 
443
        {
 
444
          if (row[x] == NULL)
 
445
            printf("     (NULL)\n");
 
446
          else
 
447
          {
 
448
            printf("     (%zd) %.*s\n", field_sizes[x], (int32_t)field_sizes[x],
 
449
                   row[x]);
 
450
          }
 
451
        }
 
452
 
 
453
        drizzle_row_free(&(client_con->result), row);
 
454
        printf("\n");
 
455
      }
 
456
    }
 
457
 
 
458
    drizzle_result_free(&(client_con->result));
 
459
    break;
 
460
 
 
461
  default:
 
462
    /* This should be impossible. */
 
463
    return 1;
 
464
  }
 
465
 
 
466
  return 0;
 
467
}
 
468
 
 
469
void con_info(drizzle_con_st *con)
 
470
{
 
471
  printf("Connected: protocol_version=%u\n"
 
472
         "                    version=%s\n"
 
473
         "                  thread_id=%u\n"
 
474
         "               capabilities=%u\n"
 
475
         "                   language=%u\n"
 
476
         "                     status=%u\n\n",
 
477
         drizzle_con_protocol_version(con), drizzle_con_server_version(con),
 
478
         drizzle_con_thread_id(con), drizzle_con_capabilities(con),
 
479
         drizzle_con_charset(con), drizzle_con_status(con));
 
480
}
 
481
 
 
482
void result_info(drizzle_result_st *result)
 
483
{
 
484
  printf("Result:     row_count=%" PRId64 "\n"
 
485
         "            insert_id=%" PRId64 "\n"
 
486
         "        warning_count=%u\n"
 
487
         "         column_count=%u\n"
 
488
         "        affected_rows=%" PRId64 "\n\n",
 
489
         drizzle_result_row_count(result),
 
490
         drizzle_result_insert_id(result),
 
491
         drizzle_result_warning_count(result),
 
492
         drizzle_result_column_count(result),
 
493
         drizzle_result_affected_rows(result));
 
494
}
 
495
 
 
496
void column_info(drizzle_column_st *column)
 
497
{
 
498
  printf("Field:   catalog=%s\n"
 
499
         "              db=%s\n"
 
500
         "           table=%s\n"
 
501
         "       org_table=%s\n"
 
502
         "            name=%s\n"
 
503
         "        org_name=%s\n"
 
504
         "         charset=%u\n"
 
505
         "            size=%u\n"
 
506
         "        max_size=%zu\n"
 
507
         "            type=%u\n"
 
508
         "           flags=%u\n\n",
 
509
         drizzle_column_catalog(column), drizzle_column_db(column),
 
510
         drizzle_column_table(column), drizzle_column_orig_table(column),
 
511
         drizzle_column_name(column), drizzle_column_orig_name(column),
 
512
         drizzle_column_charset(column), drizzle_column_size(column),
 
513
         drizzle_column_max_size(column), drizzle_column_type(column),
 
514
         drizzle_column_flags(column));
 
515
}