← 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-14 07:30:41 UTC
  • Revision ID: me@mark.atwood.name-20111114073041-mo2hgg8ouseo2kpu
release 2011.11.29

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