← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle/column.cc

  • Committer: Mark Atwood
  • Date: 2011-12-22 04:39:00 UTC
  • mfrom: (2472.1.2 drizzle-build)
  • Revision ID: me@mark.atwood.name-20111222043900-utca466m80z3gj61
merge lp:~brianaker/drizzle/null-safety-fix-libdrizzle

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/column.cc
355
355
drizzle_column_st *drizzle_column_create(drizzle_result_st *result,
356
356
                                         drizzle_column_st *column)
357
357
{
 
358
  if (result == NULL)
 
359
  {
 
360
    return NULL;
 
361
  }
 
362
 
358
363
  if (column == NULL)
359
364
  {
360
365
    column= new (std::nothrow) (drizzle_column_st);
420
425
 
421
426
void drizzle_column_free(drizzle_column_st *column)
422
427
{
 
428
  if (column == NULL)
 
429
  {
 
430
    return;
 
431
  }
 
432
 
423
433
  if (column->result->column_list == column)
424
434
    column->result->column_list= column->next;
425
435
 
437
447
 
438
448
drizzle_result_st *drizzle_column_drizzle_result(drizzle_column_st *column)
439
449
{
 
450
  if (column == NULL)
 
451
  {
 
452
    return NULL;
 
453
  }
 
454
 
440
455
  return column->result;
441
456
}
442
457
 
443
458
const char *drizzle_column_catalog(drizzle_column_st *column)
444
459
{
 
460
  if (column == NULL)
 
461
  {
 
462
    return NULL;
 
463
  }
 
464
 
445
465
  return column->catalog;
446
466
}
447
467
 
448
468
const char *drizzle_column_db(drizzle_column_st *column)
449
469
{
 
470
  if (column == NULL)
 
471
  {
 
472
    return NULL;
 
473
  }
 
474
 
450
475
  return column->db;
451
476
}
452
477
 
453
478
const char *drizzle_column_table(drizzle_column_st *column)
454
479
{
 
480
  if (column == NULL)
 
481
  {
 
482
    return NULL;
 
483
  }
 
484
 
455
485
  return column->table;
456
486
}
457
487
 
458
488
const char *drizzle_column_orig_table(drizzle_column_st *column)
459
489
{
 
490
  if (column == NULL)
 
491
  {
 
492
    return NULL;
 
493
  }
 
494
 
460
495
  return column->orig_table;
461
496
}
462
497
 
463
498
const char *drizzle_column_name(drizzle_column_st *column)
464
499
{
 
500
  if (column == NULL)
 
501
  {
 
502
    return NULL;
 
503
  }
 
504
 
465
505
  return column->name;
466
506
}
467
507
 
468
508
const char *drizzle_column_orig_name(drizzle_column_st *column)
469
509
{
 
510
  if (column == NULL)
 
511
  {
 
512
    return NULL;
 
513
  }
 
514
 
470
515
  return column->orig_name;
471
516
}
472
517
 
473
518
drizzle_charset_t drizzle_column_charset(drizzle_column_st *column)
474
519
{
 
520
  if (column == NULL)
 
521
  {
 
522
    return drizzle_charset_t();
 
523
  }
 
524
 
475
525
  return column->charset;
476
526
}
477
527
 
478
528
uint32_t drizzle_column_size(drizzle_column_st *column)
479
529
{
 
530
  if (column == NULL)
 
531
  {
 
532
    return 0;
 
533
  }
 
534
 
480
535
  return column->size;
481
536
}
482
537
 
483
538
size_t drizzle_column_max_size(drizzle_column_st *column)
484
539
{
 
540
  if (column == NULL)
 
541
  {
 
542
    return 0;
 
543
  }
 
544
 
485
545
  return column->max_size;
486
546
}
487
547
 
488
548
void drizzle_column_set_max_size(drizzle_column_st *column, size_t size)
489
549
{
 
550
  if (column == NULL)
 
551
  {
 
552
    return;
 
553
  }
 
554
 
490
555
  column->max_size= size;
491
556
}
492
557
 
493
558
drizzle_column_type_t drizzle_column_type(drizzle_column_st *column)
494
559
{
 
560
  if (column == NULL)
 
561
  {
 
562
    return drizzle_column_type_t();
 
563
  }
 
564
 
495
565
  return column->type;
496
566
}
497
567
 
498
568
drizzle_column_type_drizzle_t
499
569
drizzle_column_type_drizzle(drizzle_column_st *column)
500
570
{
 
571
  if (column == NULL)
 
572
  {
 
573
    return drizzle_column_type_drizzle_t();
 
574
  }
 
575
 
501
576
  return _column_type_drizzle_map_from[column->type];
502
577
}
503
578
 
504
579
drizzle_column_flags_t drizzle_column_flags(drizzle_column_st *column)
505
580
{
 
581
  if (column == NULL)
 
582
  {
 
583
    return drizzle_column_flags_t();
 
584
  }
 
585
 
506
586
  return drizzle_column_flags_t(column->flags);
507
587
}
508
588
 
509
589
uint8_t drizzle_column_decimals(drizzle_column_st *column)
510
590
{
 
591
  if (column == NULL)
 
592
  {
 
593
    return 0;
 
594
  }
 
595
 
511
596
  return column->decimals;
512
597
}
513
598
 
514
599
const uint8_t *drizzle_column_default_value(drizzle_column_st *column,
515
600
                                            size_t *size)
516
601
{
 
602
  if (column == NULL)
 
603
  {
 
604
    return NULL;
 
605
  }
 
606
 
517
607
  *size= column->default_value_size;
518
608
  return column->default_value;
519
609
}
524
614
 
525
615
drizzle_return_t drizzle_column_skip(drizzle_result_st *result)
526
616
{
 
617
  if (result == NULL)
 
618
  {
 
619
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
620
  }
 
621
 
527
622
  drizzle_return_t ret;
528
623
  if (drizzle_state_none(result->con))
529
624
  {
539
634
 
540
635
drizzle_return_t drizzle_column_skip_all(drizzle_result_st *result)
541
636
{
 
637
  if (result == NULL)
 
638
  {
 
639
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
640
  }
 
641
 
542
642
  for (uint16_t it= 1; it <= result->column_count; it++)
543
643
  {
544
644
    drizzle_return_t ret= drizzle_column_skip(result);
556
656
                                       drizzle_column_st *column,
557
657
                                       drizzle_return_t *ret_ptr)
558
658
{
 
659
  drizzle_return_t unused_ret;
 
660
  if (ret_ptr == NULL)
 
661
  {
 
662
    ret_ptr= &unused_ret;
 
663
  }
 
664
 
 
665
  if (result == NULL)
 
666
  {
 
667
    return NULL;
 
668
  }
 
669
 
559
670
  if (drizzle_state_none(result->con))
560
671
  {
561
672
    result->column= column;
571
682
 
572
683
drizzle_return_t drizzle_column_buffer(drizzle_result_st *result)
573
684
{
 
685
  if (result == NULL)
 
686
  {
 
687
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
688
  }
 
689
 
574
690
  drizzle_return_t ret;
575
691
 
576
692
  if (result->column_buffer == NULL)
605
721
 
606
722
drizzle_column_st *drizzle_column_next(drizzle_result_st *result)
607
723
{
 
724
  if (result == NULL)
 
725
  {
 
726
    return NULL;
 
727
  }
 
728
 
608
729
  if (result->column_current == result->column_count)
609
730
  {
610
731
    return NULL;
616
737
 
617
738
drizzle_column_st *drizzle_column_prev(drizzle_result_st *result)
618
739
{
 
740
  if (result == NULL)
 
741
  {
 
742
    return NULL;
 
743
  }
 
744
 
619
745
  if (result->column_current == 0)
620
746
  {
621
747
    return NULL;
627
753
 
628
754
void drizzle_column_seek(drizzle_result_st *result, uint16_t column)
629
755
{
 
756
  if (result == NULL)
 
757
  {
 
758
    return;
 
759
  }
 
760
 
630
761
  if (column <= result->column_count)
631
762
  {
632
763
    result->column_current= column;
636
767
drizzle_column_st *drizzle_column_index(drizzle_result_st *result,
637
768
                                        uint16_t column)
638
769
{
 
770
  if (result == NULL)
 
771
  {
 
772
    return NULL;
 
773
  }
 
774
 
639
775
  if (column >= result->column_count)
640
776
  {
641
777
    return NULL;
646
782
 
647
783
uint16_t drizzle_column_current(drizzle_result_st *result)
648
784
{
 
785
  if (result == NULL)
 
786
  {
 
787
    return 0;
 
788
  }
 
789
 
649
790
  return result->column_current;
650
791
}
651
792
 
656
797
drizzle_return_t drizzle_column_write(drizzle_result_st *result,
657
798
                                      drizzle_column_st *column)
658
799
{
 
800
  if (result == NULL)
 
801
  {
 
802
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
803
  }
 
804
 
659
805
  if (drizzle_state_none(result->con))
660
806
  {
661
807
    result->column= column;
668
814
 
669
815
void drizzle_column_set_catalog(drizzle_column_st *column, const char *catalog)
670
816
{
 
817
  if (column == NULL)
 
818
  {
 
819
    return;
 
820
  }
 
821
 
671
822
  if (catalog == NULL)
672
823
  {
673
824
    column->catalog[0]= 0;
681
832
 
682
833
void drizzle_column_set_db(drizzle_column_st *column, const char *db)
683
834
{
 
835
  if (column == NULL)
 
836
  {
 
837
    return;
 
838
  }
 
839
 
684
840
  if (db == NULL)
685
841
  {
686
842
    column->db[0]= 0;
694
850
 
695
851
void drizzle_column_set_table(drizzle_column_st *column, const char *table)
696
852
{
 
853
  if (column == NULL)
 
854
  {
 
855
    return;
 
856
  }
 
857
 
697
858
  if (table == NULL)
698
859
  {
699
860
    column->table[0]= 0;
708
869
void drizzle_column_set_orig_table(drizzle_column_st *column,
709
870
                                   const char *orig_table)
710
871
{
 
872
  if (column == NULL)
 
873
  {
 
874
    return;
 
875
  }
 
876
 
711
877
  if (orig_table == NULL)
712
878
  {
713
879
    column->orig_table[0]= 0;
721
887
 
722
888
void drizzle_column_set_name(drizzle_column_st *column, const char *name)
723
889
{
 
890
  if (column == NULL)
 
891
  {
 
892
    return;
 
893
  }
 
894
 
724
895
  if (name == NULL)
725
896
  {
726
897
    column->name[0]= 0;
747
918
void drizzle_column_set_charset(drizzle_column_st *column,
748
919
                                drizzle_charset_t charset)
749
920
{
 
921
  if (column == NULL)
 
922
  {
 
923
    return;
 
924
  }
 
925
 
750
926
  column->charset= charset;
751
927
}
752
928
 
753
929
void drizzle_column_set_size(drizzle_column_st *column, uint32_t size)
754
930
{
 
931
  if (column == NULL)
 
932
  {
 
933
    return;
 
934
  }
 
935
 
755
936
  column->size= size;
756
937
}
757
938
 
758
939
void drizzle_column_set_type(drizzle_column_st *column,
759
940
                             drizzle_column_type_t type)
760
941
{
 
942
  if (column == NULL)
 
943
  {
 
944
    return;
 
945
  }
 
946
 
761
947
  column->type= type;
762
948
}
763
949
 
764
950
void drizzle_column_set_flags(drizzle_column_st *column,
765
951
                              drizzle_column_flags_t flags)
766
952
{
 
953
  if (column == NULL)
 
954
  {
 
955
    return;
 
956
  }
 
957
 
767
958
  column->flags= flags;
768
959
}
769
960
 
770
961
void drizzle_column_set_decimals(drizzle_column_st *column, uint8_t decimals)
771
962
{
 
963
  if (column == NULL)
 
964
  {
 
965
    return;
 
966
  }
 
967
 
772
968
  column->decimals= decimals;
773
969
}
774
970
 
776
972
                                      const uint8_t *default_value,
777
973
                                      size_t size)
778
974
{
 
975
  if (column == NULL)
 
976
  {
 
977
    return;
 
978
  }
 
979
 
779
980
  if (default_value == NULL)
 
981
  {
780
982
    column->default_value[0]= 0;
 
983
  }
781
984
  else
782
985
  {
783
986
    if (size < DRIZZLE_MAX_DEFAULT_VALUE_SIZE)
802
1005
 
803
1006
drizzle_return_t drizzle_state_column_read(drizzle_con_st *con)
804
1007
{
 
1008
  if (con == NULL)
 
1009
  {
 
1010
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1011
  }
 
1012
 
805
1013
  drizzle_column_st *column;
806
1014
  drizzle_column_type_drizzle_t drizzle_type;
807
1015
 
905
1113
 
906
1114
drizzle_return_t drizzle_state_column_write(drizzle_con_st *con)
907
1115
{
 
1116
  if (con == NULL)
 
1117
  {
 
1118
    return DRIZZLE_RETURN_INVALID_ARGUMENT;
 
1119
  }
 
1120
 
908
1121
  uint8_t *start= con->buffer_ptr + con->buffer_size;
909
1122
  uint8_t *ptr;
910
1123
  drizzle_column_st *column= con->result->column;
967
1180
  ptr+= 4;
968
1181
 
969
1182
  if (con->options & DRIZZLE_CON_MYSQL)
 
1183
  {
970
1184
    ptr[0]= column->type;
 
1185
  }
971
1186
  else
 
1187
  {
972
1188
    ptr[0]= _column_type_drizzle_map_from[column->type];
 
1189
  }
973
1190
  ptr++;
974
1191
 
975
1192
  drizzle_set_byte2(ptr, column->flags);