← 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-26 23:14:59 UTC
  • mto: This revision was merged to the branch mainline in revision 2465.
  • Revision ID: brian@tangent.org-20111126231459-pa9i3arizevf0vlr
Remove con from being passed object.

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