← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/column.cc

  • Committer: Mark Atwood
  • Date: 2011-11-20 08:50:16 UTC
  • mfrom: (2461.1.2 drizzle-build)
  • Revision ID: me@mark.atwood.name-20111120085016-2o4no5btx18x2gws
merge lp:~brianaker/drizzle/libdrizzle-refactor

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/column.cc
354
354
drizzle_column_st *drizzle_column_create(drizzle_result_st *result,
355
355
                                         drizzle_column_st *column)
356
356
{
 
357
  if (result == NULL)
 
358
  {
 
359
    return NULL;
 
360
  }
 
361
 
357
362
  if (column == NULL)
358
363
  {
359
 
    column= new drizzle_column_st;
360
 
    column->result = result;
 
364
    column= new (std::nothrow) drizzle_column_st;
 
365
 
 
366
    if (column == NULL)
 
367
    {
 
368
      return NULL;
 
369
    }
 
370
 
 
371
    column->result= result;
361
372
    /* SET BELOW: column->next */
362
 
    column->prev = NULL;
 
373
    column->prev= NULL;
363
374
    column->options= DRIZZLE_COLUMN_ALLOCATED;
364
 
    column->catalog[0] = '\0';
365
 
    column->db[0] = '\0';
366
 
    column->table[0] = '\0';
367
 
    column->orig_table[0] = '\0';
368
 
    column->name[0] = '\0';
369
 
    column->orig_name[0] = '\0';
370
 
    column->charset = 0;
371
 
    column->size = 0;
372
 
    column->max_size = 0;
373
 
    column->type = static_cast<drizzle_column_type_t>(0);
374
 
    column->flags = drizzle_column_flags_t();
375
 
    column->decimals = 0;
 
375
    column->catalog[0]= '\0';
 
376
    column->schema[0]= '\0';
 
377
    column->table[0]= '\0';
 
378
    column->orig_table[0]= '\0';
 
379
    column->name[0]= '\0';
 
380
    column->orig_name[0]= '\0';
 
381
    column->charset= 0;
 
382
    column->size= 0;
 
383
    column->max_size= 0;
 
384
    column->type= static_cast<drizzle_column_type_t>(0);
 
385
    column->flags= drizzle_column_flags_t();
 
386
    column->decimals= 0;
376
387
    /* UNSET: column->default_value */
377
 
    column->default_value_size = 0;
378
 
 
 
388
    column->default_value_size= 0;
379
389
  }
380
390
  else
381
391
  {
384
394
    column->prev = NULL;
385
395
    column->options= drizzle_column_options_t();
386
396
    column->catalog[0] = '\0';
387
 
    column->db[0] = '\0';
 
397
    column->schema[0] = '\0';
388
398
    column->table[0] = '\0';
389
399
    column->orig_table[0] = '\0';
390
400
    column->name[0] = '\0';
411
421
 
412
422
void drizzle_column_free(drizzle_column_st *column)
413
423
{
 
424
  if (column == NULL)
 
425
  {
 
426
    return;
 
427
  }
 
428
 
414
429
  if (column->result->column_list == column)
 
430
  {
415
431
    column->result->column_list= column->next;
 
432
  }
 
433
 
416
434
  if (column->prev)
 
435
  {
417
436
    column->prev->next= column->next;
 
437
  }
 
438
 
418
439
  if (column->next)
 
440
  {
419
441
    column->next->prev= column->prev;
 
442
  }
420
443
 
421
444
  if (column->options & DRIZZLE_COLUMN_ALLOCATED)
 
445
  {
422
446
    delete column;
 
447
  }
423
448
}
424
449
 
425
450
drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
426
451
{
 
452
  if (column == NULL)
 
453
  {
 
454
    return NULL;
 
455
  }
 
456
 
427
457
  return column->result;
428
458
}
429
459
 
430
460
const char *drizzle_column_catalog(drizzle_column_st *column)
431
461
{
 
462
  if (column == NULL)
 
463
  {
 
464
    return NULL;
 
465
  }
 
466
 
432
467
  return column->catalog;
433
468
}
434
469
 
 
470
const char *drizzle_column_shema(drizzle_column_st *column)
 
471
{
 
472
  if (column == NULL)
 
473
  {
 
474
    return NULL;
 
475
  }
 
476
 
 
477
  return column->schema;
 
478
}
 
479
 
435
480
const char *drizzle_column_db(drizzle_column_st *column)
436
481
{
437
 
  return column->db;
 
482
  return drizzle_column_shema(column);
438
483
}
439
484
 
440
485
const char *drizzle_column_table(drizzle_column_st *column)
441
486
{
 
487
  if (column == NULL)
 
488
  {
 
489
    return NULL;
 
490
  }
 
491
 
442
492
  return column->table;
443
493
}
444
494
 
445
495
const char *drizzle_column_orig_table(drizzle_column_st *column)
446
496
{
 
497
  if (column == NULL)
 
498
  {
 
499
    return NULL;
 
500
  }
 
501
 
447
502
  return column->orig_table;
448
503
}
449
504
 
450
505
const char *drizzle_column_name(drizzle_column_st *column)
451
506
{
 
507
  if (column == NULL)
 
508
  {
 
509
    return NULL;
 
510
  }
 
511
 
452
512
  return column->name;
453
513
}
454
514
 
455
515
const char *drizzle_column_orig_name(drizzle_column_st *column)
456
516
{
 
517
  if (column == NULL)
 
518
  {
 
519
    return NULL;
 
520
  }
 
521
 
457
522
  return column->orig_name;
458
523
}
459
524
 
460
525
drizzle_charset_t drizzle_column_charset(drizzle_column_st *column)
461
526
{
 
527
  if (column == NULL)
 
528
  {
 
529
    return 0;
 
530
  }
 
531
 
462
532
  return column->charset;
463
533
}
464
534
 
465
535
uint32_t drizzle_column_size(drizzle_column_st *column)
466
536
{
 
537
  if (column == NULL)
 
538
  {
 
539
    return 0;
 
540
  }
 
541
 
467
542
  return column->size;
468
543
}
469
544
 
470
545
size_t drizzle_column_max_size(drizzle_column_st *column)
471
546
{
 
547
  if (column == NULL)
 
548
  {
 
549
    return 0;
 
550
  }
 
551
 
472
552
  return column->max_size;
473
553
}
474
554
 
475
555
void drizzle_column_set_max_size(drizzle_column_st *column, size_t size)
476
556
{
 
557
  if (column == NULL)
 
558
  {
 
559
    return;
 
560
  }
 
561
 
477
562
  column->max_size= size;
478
563
}
479
564
 
480
565
drizzle_column_type_t drizzle_column_type(drizzle_column_st *column)
481
566
{
 
567
  if (column == NULL)
 
568
  {
 
569
    return drizzle_column_type_t();
 
570
  }
 
571
 
482
572
  return column->type;
483
573
}
484
574
 
485
 
drizzle_column_type_drizzle_t
486
 
drizzle_column_type_drizzle(drizzle_column_st *column)
 
575
drizzle_column_type_drizzle_t drizzle_column_type_drizzle(drizzle_column_st *column)
487
576
{
 
577
  if (column == NULL)
 
578
  {
 
579
    return drizzle_column_type_drizzle_t();
 
580
  }
 
581
 
488
582
  return _column_type_drizzle_map_from[column->type];
489
583
}
490
584
 
491
585
int drizzle_column_flags(drizzle_column_st *column)
492
586
{
 
587
  if (column == NULL)
 
588
  {
 
589
    return 0;
 
590
  }
 
591
 
493
592
  return column->flags;
494
593
}
495
594
 
496
595
uint8_t drizzle_column_decimals(drizzle_column_st *column)
497
596
{
 
597
  if (column == NULL)
 
598
  {
 
599
    return 0;
 
600
  }
 
601
 
498
602
  return column->decimals;
499
603
}
500
604
 
511
615
 
512
616
drizzle_return_t drizzle_column_skip(drizzle_result_st *result)
513
617
{
514
 
  drizzle_return_t ret;
 
618
  if (result == NULL)
 
619
  {
 
620
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
621
  }
 
622
 
515
623
  if (drizzle_state_none(result->con))
516
624
  {
517
625
    result->options|= DRIZZLE_RESULT_SKIP_COLUMN;
519
627
    drizzle_state_push(result->con, drizzle_state_column_read);
520
628
    drizzle_state_push(result->con, drizzle_state_packet_read);
521
629
  }
522
 
  ret= drizzle_state_loop(result->con);
 
630
  drizzle_return_t ret= drizzle_state_loop(result->con);
523
631
  result->options&= ~DRIZZLE_RESULT_SKIP_COLUMN;
524
632
  return ret;
525
633
}
526
634
 
527
635
drizzle_return_t drizzle_column_skip_all(drizzle_result_st *result)
528
636
{
529
 
  drizzle_return_t ret;
530
 
  uint16_t it;
 
637
  if (result == NULL)
 
638
  {
 
639
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
640
  }
531
641
 
532
 
  for (it= 1; it <= result->column_count; it++)
 
642
  for (uint16_t it= 1; it <= result->column_count; it++)
533
643
  {
534
 
    ret= drizzle_column_skip(result);
 
644
    drizzle_return_t ret= drizzle_column_skip(result);
535
645
    if (ret != DRIZZLE_RETURN_OK)
 
646
    {
536
647
      return ret;
 
648
    }
537
649
  }
538
650
 
539
651
  return DRIZZLE_RETURN_OK;
543
655
                                       drizzle_column_st *column,
544
656
                                       drizzle_return_t *ret_ptr)
545
657
{
 
658
  if (result == NULL)
 
659
  {
 
660
    return NULL;
 
661
  }
 
662
 
546
663
  if (drizzle_state_none(result->con))
547
664
  {
548
665
    result->column= column;
557
674
 
558
675
drizzle_return_t drizzle_column_buffer(drizzle_result_st *result)
559
676
{
 
677
  if (result == NULL)
 
678
  {
 
679
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
680
  }
 
681
 
560
682
  drizzle_return_t ret;
561
683
 
562
684
  if (result->column_buffer == NULL)
567
689
      return DRIZZLE_RETURN_OK;
568
690
    }
569
691
 
570
 
    result->column_buffer= new drizzle_column_st[result->column_count];
 
692
    result->column_buffer= new (std::nothrow) drizzle_column_st[result->column_count];
 
693
 
 
694
    if (result->column_buffer == NULL)
 
695
    {
 
696
      return DRIZZLE_RETURN_MEMORY;
 
697
    }
571
698
  }
572
699
 
573
700
  /* No while body, just keep calling to buffer columns. */
587
714
 
588
715
drizzle_column_st *drizzle_column_next(drizzle_result_st *result)
589
716
{
 
717
  if (result == NULL)
 
718
  {
 
719
    return NULL;
 
720
  }
 
721
 
590
722
  if (result->column_current == result->column_count)
 
723
  {
591
724
    return NULL;
 
725
  }
592
726
 
593
727
  result->column_current++;
594
728
  return &(result->column_buffer[result->column_current - 1]);
605
739
 
606
740
void drizzle_column_seek(drizzle_result_st *result, uint16_t column)
607
741
{
 
742
  if (result == NULL)
 
743
  {
 
744
    return;
 
745
  }
 
746
 
608
747
  if (column <= result->column_count)
 
748
  {
609
749
    result->column_current= column;
 
750
  }
610
751
}
611
752
 
612
 
drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
613
 
                                        uint16_t column)
 
753
drizzle_column_st *drizzle_column_index(drizzle_result_st *result, uint16_t column)
614
754
{
 
755
  if (result == NULL)
 
756
  {
 
757
    return NULL;
 
758
  }
 
759
 
615
760
  if (column >= result->column_count)
 
761
  {
616
762
    return NULL;
 
763
  }
617
764
 
618
765
  return &(result->column_buffer[column]);
619
766
}
620
767
 
621
768
uint16_t drizzle_column_current(drizzle_result_st *result)
622
769
{
 
770
  if (result == NULL)
 
771
  {
 
772
    return 0;
 
773
  }
 
774
 
623
775
  return result->column_current;
624
776
}
625
777
 
630
782
drizzle_return_t drizzle_column_write(drizzle_result_st *result,
631
783
                                      drizzle_column_st *column)
632
784
{
 
785
  if (result == NULL)
 
786
  {
 
787
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
788
  }
 
789
 
633
790
  if (drizzle_state_none(result->con))
634
791
  {
635
792
    result->column= column;
642
799
 
643
800
void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog)
644
801
{
 
802
  if (column == NULL)
 
803
  {
 
804
    return;
 
805
  }
 
806
 
645
807
  if (catalog == NULL)
 
808
  {
646
809
    column->catalog[0]= 0;
 
810
  }
647
811
  else
648
812
  {
649
813
    strncpy(column->catalog, catalog, DRIZZLE_MAX_CATALOG_SIZE);
651
815
  }
652
816
}
653
817
 
654
 
void drizzle_column_set_db(drizzle_column_st *column, const char *db)
 
818
void drizzle_column_set_schema(drizzle_column_st *column, const char *schema)
655
819
{
656
 
  if (db == NULL)
657
 
    column->db[0]= 0;
 
820
  if (column == NULL)
 
821
  {
 
822
    return;
 
823
  }
 
824
 
 
825
  if (schema == NULL)
 
826
  {
 
827
    column->schema[0]= 0;
 
828
  }
658
829
  else
659
830
  {
660
 
    strncpy(column->db, db, DRIZZLE_MAX_DB_SIZE);
661
 
    column->db[DRIZZLE_MAX_DB_SIZE - 1]= 0;
 
831
    strncpy(column->schema, schema, DRIZZLE_MAX_DB_SIZE);
 
832
    column->schema[DRIZZLE_MAX_DB_SIZE - 1]= 0;
662
833
  }
663
834
}
664
835
 
 
836
void drizzle_column_set_db(drizzle_column_st *column, const char *schema)
 
837
{
 
838
  drizzle_column_set_schema(column, schema);
 
839
}
 
840
 
 
841
 
665
842
void drizzle_column_set_table(drizzle_column_st *column, const char *table)
666
843
{
 
844
  if (column == NULL)
 
845
  {
 
846
    return;
 
847
  }
 
848
 
667
849
  if (table == NULL)
 
850
  {
668
851
    column->table[0]= 0;
 
852
  }
669
853
  else
670
854
  {
671
855
    strncpy(column->table, table, DRIZZLE_MAX_TABLE_SIZE);
676
860
void drizzle_column_set_orig_table(drizzle_column_st *column,
677
861
                                   const char *orig_table)
678
862
{
 
863
  if (column == NULL)
 
864
  {
 
865
    return;
 
866
  }
 
867
 
679
868
  if (orig_table == NULL)
680
869
    column->orig_table[0]= 0;
681
870
  else
687
876
 
688
877
void drizzle_column_set_name(drizzle_column_st *column, const char *name)
689
878
{
 
879
  if (column == NULL)
 
880
  {
 
881
    return;
 
882
  }
 
883
 
690
884
  if (name == NULL)
691
885
    column->name[0]= 0;
692
886
  else
699
893
void drizzle_column_set_orig_name(drizzle_column_st *column,
700
894
                                  const char *orig_name)
701
895
{
 
896
  if (column == NULL)
 
897
  {
 
898
    return;
 
899
  }
 
900
 
702
901
  if (orig_name == NULL)
703
902
    column->orig_name[0]= 0;
704
903
  else
711
910
void drizzle_column_set_charset(drizzle_column_st *column,
712
911
                                drizzle_charset_t charset)
713
912
{
 
913
  if (column == NULL)
 
914
  {
 
915
    return;
 
916
  }
 
917
 
714
918
  column->charset= charset;
715
919
}
716
920
 
717
921
void drizzle_column_set_size(drizzle_column_st *column, uint32_t size)
718
922
{
 
923
  if (column == NULL)
 
924
  {
 
925
    return;
 
926
  }
 
927
 
719
928
  column->size= size;
720
929
}
721
930
 
722
931
void drizzle_column_set_type(drizzle_column_st *column,
723
932
                             drizzle_column_type_t type)
724
933
{
 
934
  if (column == NULL)
 
935
  {
 
936
    return;
 
937
  }
 
938
 
725
939
  column->type= type;
726
940
}
727
941
 
728
942
void drizzle_column_set_flags(drizzle_column_st *column,
729
943
                              int flags)
730
944
{
 
945
  if (column == NULL)
 
946
  {
 
947
    return;
 
948
  }
 
949
 
731
950
  column->flags= flags;
732
951
}
733
952
 
734
953
void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals)
735
954
{
 
955
  if (column == NULL)
 
956
  {
 
957
    return;
 
958
  }
 
959
 
736
960
  column->decimals= decimals;
737
961
}
738
962
 
740
964
                                      const uint8_t *default_value,
741
965
                                      size_t size)
742
966
{
 
967
  if (column == NULL)
 
968
  {
 
969
    return;
 
970
  }
 
971
 
743
972
  if (default_value == NULL)
 
973
  {
744
974
    column->default_value[0]= 0;
 
975
  }
745
976
  else
746
977
  {
747
978
    if (size < DRIZZLE_MAX_DEFAULT_VALUE_SIZE)
766
997
 
767
998
drizzle_return_t drizzle_state_column_read(drizzle_con_st *con)
768
999
{
 
1000
  if (con == NULL)
 
1001
  {
 
1002
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1003
  }
 
1004
 
769
1005
  drizzle_column_st *column;
770
1006
  drizzle_column_type_drizzle_t drizzle_type;
771
1007
 
809
1045
    /* These functions can only fail if they need to read data, but we know we
810
1046
       buffered the entire packet, so ignore returns. */
811
1047
    (void)drizzle_unpack_string(con, column->catalog, DRIZZLE_MAX_CATALOG_SIZE);
812
 
    (void)drizzle_unpack_string(con, column->db, DRIZZLE_MAX_DB_SIZE);
 
1048
    (void)drizzle_unpack_string(con, column->schema, DRIZZLE_MAX_DB_SIZE);
813
1049
    (void)drizzle_unpack_string(con, column->table, DRIZZLE_MAX_TABLE_SIZE);
814
1050
    (void)drizzle_unpack_string(con, column->orig_table,
815
1051
                                DRIZZLE_MAX_TABLE_SIZE);
867
1103
 
868
1104
drizzle_return_t drizzle_state_column_write(drizzle_con_st *con)
869
1105
{
 
1106
  if (con == NULL)
 
1107
  {
 
1108
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1109
  }
 
1110
 
870
1111
  uint8_t *start= con->buffer_ptr + con->buffer_size;
871
1112
  uint8_t *ptr;
872
1113
  drizzle_column_st *column= con->result->column;
875
1116
 
876
1117
  /* Calculate max packet size. */
877
1118
  con->packet_size= 9 + strlen(column->catalog)
878
 
                  + 9 + strlen(column->db)
 
1119
                  + 9 + strlen(column->schema)
879
1120
                  + 9 + strlen(column->table)
880
1121
                  + 9 + strlen(column->orig_table)
881
1122
                  + 9 + strlen(column->name)
912
1153
  ptr+= 4;
913
1154
 
914
1155
  ptr= drizzle_pack_string(column->catalog, ptr);
915
 
  ptr= drizzle_pack_string(column->db, ptr);
 
1156
  ptr= drizzle_pack_string(column->schema, ptr);
916
1157
  ptr= drizzle_pack_string(column->table, ptr);
917
1158
  ptr= drizzle_pack_string(column->orig_table, ptr);
918
1159
  ptr= drizzle_pack_string(column->name, ptr);