← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to examples/sqlite_server.cc

  • Committer: Brian Aker
  • Date: 2011-11-27 01:25:57 UTC
  • mto: This revision was merged to the branch mainline in revision 2465.
  • Revision ID: brian@tangent.org-20111127012557-vxph9h1v32v3m1bz
Move result over to being behind API.

Show diffs side-by-side

added added

removed removed

Lines of Context:
examples/sqlite_server.cc
73
73
{
74
74
  drizzle_st *drizzle;
75
75
  drizzle_con_st *con;
76
 
  drizzle_result_st result;
 
76
  drizzle_result_st *result;
77
77
  drizzle_column_st column;
78
78
  sqlite3* db;
79
79
  bool send_columns;
247
247
  ret= drizzle_handshake_client_read(server->con);
248
248
  DRIZZLE_RETURN_CHECK(ret, "drizzle_handshake_client_read", server->drizzle)
249
249
 
250
 
  if (drizzle_result_create(server->con, &(server->result)) == NULL)
251
 
    DRIZZLE_RETURN_ERROR("drizzle_result_create", server->drizzle)
 
250
  if ((server->result= drizzle_result_create(server->con)) == NULL)
 
251
  {
 
252
    DRIZZLE_RETURN_ERROR("drizzle_result_create", server->drizzle);
 
253
  }
252
254
 
253
 
  ret= drizzle_result_write(server->con, &(server->result), true);
 
255
  ret= drizzle_result_write(server->con, server->result, true);
254
256
  DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
255
257
 
256
258
  /* Command loop. */
257
259
  while (1)
258
260
  {
259
 
    drizzle_result_free(&(server->result));
 
261
    drizzle_result_free(server->result);
260
262
    free(data);
261
263
 
262
264
    data= (uint8_t *)drizzle_con_command_buffer(server->con, &command, &total, &ret);
266
268
      free(data);
267
269
      return;
268
270
    }
269
 
    DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_buffer", server->drizzle)
 
271
    DRIZZLE_RETURN_CHECK(ret, "drizzle_con_command_buffer", server->drizzle);
270
272
 
271
273
    if (server->verbose >= DRIZZLE_VERBOSE_INFO)
272
274
    {
274
276
             data == NULL ? "NULL" : (char *)data);
275
277
    }
276
278
 
277
 
    if (drizzle_result_create(server->con, &(server->result)) == NULL)
278
 
      DRIZZLE_RETURN_ERROR("drizzle_result_create", server->drizzle)
 
279
    if ((server->result= drizzle_result_create(server->con)) == NULL)
 
280
    {
 
281
      DRIZZLE_RETURN_ERROR("drizzle_result_create", server->drizzle);
 
282
    }
279
283
 
280
284
    if (command != DRIZZLE_COMMAND_QUERY ||
281
285
        !strcasecmp((char *)data, "SHOW DATABASES"))
282
286
    {
283
 
      ret= drizzle_result_write(server->con, &(server->result), true);
284
 
      DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
 
287
      ret= drizzle_result_write(server->con, server->result, true);
 
288
      DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle);
285
289
 
286
290
      if (command == DRIZZLE_COMMAND_FIELD_LIST)
287
291
      {
288
 
        drizzle_result_set_eof(&(server->result), true);
289
 
        ret= drizzle_result_write(server->con, &(server->result), true);
290
 
        DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
 
292
        drizzle_result_set_eof(server->result, true);
 
293
        ret= drizzle_result_write(server->con, server->result, true);
 
294
        DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle);
291
295
      }
292
296
 
293
297
      continue;
325
329
      }
326
330
      else
327
331
      {
328
 
        drizzle_result_set_error_code(&(server->result), (uint16_t)sqlite_ret);
329
 
        drizzle_result_set_error(&(server->result), sqlite_err);
330
 
        ret= drizzle_result_write(server->con, &(server->result), true);
 
332
        drizzle_result_set_error_code(server->result, (uint16_t)sqlite_ret);
 
333
        drizzle_result_set_error(server->result, sqlite_err);
 
334
        ret= drizzle_result_write(server->con, server->result, true);
331
335
        DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
332
336
 
333
337
        fprintf(stderr, "sqlite3_exec:%s\n", sqlite_err);
339
343
 
340
344
    if (server->rows == 0)
341
345
    {
342
 
      drizzle_result_set_column_count(&(server->result), 0);
343
 
      ret= drizzle_result_write(server->con, &(server->result), true);
 
346
      drizzle_result_set_column_count(server->result, 0);
 
347
      ret= drizzle_result_write(server->con, server->result, true);
344
348
      DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
345
349
    }
346
350
    else
347
351
    {
348
 
      drizzle_result_set_eof(&(server->result), true);
349
 
      ret= drizzle_result_write(server->con, &(server->result), true);
 
352
      drizzle_result_set_eof(server->result, true);
 
353
      ret= drizzle_result_write(server->con, server->result, true);
350
354
      DRIZZLE_RETURN_CHECK(ret, "drizzle_result_write", server->drizzle)
351
355
    }
352
356
  }
362
366
  if (server->send_columns == true)
363
367
  {
364
368
    server->send_columns= false;
365
 
    drizzle_result_set_column_count(&(server->result), (uint16_t)field_count);
 
369
    drizzle_result_set_column_count(server->result, (uint16_t)field_count);
366
370
 
367
 
    ret= drizzle_result_write(server->con, &(server->result), false);
 
371
    ret= drizzle_result_write(server->con, server->result, false);
368
372
    DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
369
373
 
370
 
    if (drizzle_column_create(&(server->result), &(server->column)) == NULL)
 
374
    if (drizzle_column_create(server->result, &(server->column)) == NULL)
371
375
    {
372
376
      DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create", server->drizzle)
373
377
    }
387
391
      drizzle_column_set_name(&(server->column), columns[x]);
388
392
      drizzle_column_set_orig_name(&(server->column), columns[x]);
389
393
 
390
 
      ret= drizzle_column_write(&(server->result), &(server->column));
 
394
      ret= drizzle_column_write(server->result, &(server->column));
391
395
      DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", server->drizzle)
392
396
    }
393
397
 
394
398
    drizzle_column_free(&(server->column));
395
399
 
396
 
    drizzle_result_set_eof(&(server->result), true);
 
400
    drizzle_result_set_eof(server->result, true);
397
401
 
398
 
    ret= drizzle_result_write(server->con, &(server->result), false);
 
402
    ret= drizzle_result_write(server->con, server->result, false);
399
403
    DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
400
404
  }
401
405
 
408
412
  }
409
413
 
410
414
  /* This is needed for MySQL and old Drizzle protocol. */
411
 
  drizzle_result_calc_row_size(&(server->result), (drizzle_field_t *)fields,
 
415
  drizzle_result_calc_row_size(server->result, (drizzle_field_t *)fields,
412
416
                               sizes);
413
417
 
414
 
  ret= drizzle_row_write(&(server->result));
 
418
  ret= drizzle_row_write(server->result);
415
419
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", server->drizzle)
416
420
 
417
421
  for (x= 0; x < field_count; x++)
418
422
  {
419
 
    ret= drizzle_field_write(&(server->result), (drizzle_field_t)fields[x],
 
423
    ret= drizzle_field_write(server->result, (drizzle_field_t)fields[x],
420
424
                             sizes[x], sizes[x]);
421
425
    DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", server->drizzle)
422
426
  }
437
441
  fields[0]= (drizzle_field_t)SQLITE_SERVER_VERSION;
438
442
  sizes[0]= strlen(SQLITE_SERVER_VERSION);
439
443
 
440
 
  drizzle_result_set_column_count(&(server->result), 1);
 
444
  drizzle_result_set_column_count(server->result, 1);
441
445
 
442
 
  ret= drizzle_result_write(server->con, &(server->result), false);
 
446
  ret= drizzle_result_write(server->con, server->result, false);
443
447
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
444
448
 
445
 
  if (drizzle_column_create(&(server->result), &(server->column)) == NULL)
 
449
  if (drizzle_column_create(server->result, &(server->column)) == NULL)
446
450
  {
447
451
    DRIZZLE_RETURN_CHECK_VAL(DRIZZLE_RETURN_MEMORY, "drizzle_column_create", server->drizzle)
448
452
  }
457
461
  drizzle_column_set_name(&(server->column), "version");
458
462
  drizzle_column_set_orig_name(&(server->column), "version");
459
463
 
460
 
  ret= drizzle_column_write(&(server->result), &(server->column));
 
464
  ret= drizzle_column_write(server->result, &(server->column));
461
465
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_column_write", server->drizzle)
462
466
 
463
467
  drizzle_column_free(&(server->column));
464
468
 
465
 
  drizzle_result_set_eof(&(server->result), true);
 
469
  drizzle_result_set_eof(server->result, true);
466
470
 
467
 
  ret= drizzle_result_write(server->con, &(server->result), false);
 
471
  ret= drizzle_result_write(server->con, server->result, false);
468
472
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
469
473
 
470
474
  /* This is needed for MySQL and old Drizzle protocol. */
471
 
  drizzle_result_calc_row_size(&(server->result), fields, sizes);
 
475
  drizzle_result_calc_row_size(server->result, fields, sizes);
472
476
 
473
 
  ret= drizzle_row_write(&(server->result));
 
477
  ret= drizzle_row_write(server->result);
474
478
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_row_write", server->drizzle)
475
479
 
476
 
  ret= drizzle_field_write(&(server->result), fields[0], sizes[0], sizes[0]);
 
480
  ret= drizzle_field_write(server->result, fields[0], sizes[0], sizes[0]);
477
481
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_field_write", server->drizzle)
478
482
 
479
 
  ret= drizzle_result_write(server->con, &(server->result), true);
 
483
  ret= drizzle_result_write(server->con, server->result, true);
480
484
  DRIZZLE_RETURN_CHECK_VAL(ret, "drizzle_result_write", server->drizzle)
481
485
 
482
486
  return DRIZZLE_RETURN_OK;