← Back to branch summary

~linuxjedi/libdrizzle/5.1-docs2

« back to all changes in this revision

Viewing changes to libdrizzle/statement_param.cc

  • Committer: Continuous Integration
  • Date: 2013-01-17 11:33:48 UTC
  • mfrom: (93.1.3 5.1-better-realloc)
  • Revision ID: ci@drizzle.org-20130117113348-e3yaws0qbijip8cv
Merge lp:~linuxjedi/libdrizzle/5.1-better-realloc Build: jenkins-Libdrizzle-49

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle/statement_param.cc
39
39
#include "libdrizzle/common.h"
40
40
 
41
41
/* Internal function */
42
 
drizzle_return_t drizzle_stmt_set_param(drizzle_stmt_st *stmt, uint16_t param_num, drizzle_column_type_t type, void *data, uint32_t length, bool is_unsigned, bool is_allocated)
 
42
drizzle_return_t drizzle_stmt_set_param(drizzle_stmt_st *stmt, uint16_t param_num, drizzle_column_type_t type, void *data, uint32_t length, bool is_unsigned)
43
43
{
44
44
  if ((stmt == NULL) || (param_num >= stmt->param_count) || (data == NULL))
45
45
  {
55
55
  stmt->query_params[param_num].data= data;
56
56
  stmt->query_params[param_num].length= length;
57
57
  stmt->query_params[param_num].options.is_unsigned= is_unsigned;
58
 
  stmt->query_params[param_num].options.is_allocated= is_allocated;
59
58
  stmt->query_params[param_num].is_bound= true;
60
59
 
61
60
  return DRIZZLE_RETURN_OK;
65
64
drizzle_return_t drizzle_stmt_set_tiny(drizzle_stmt_st *stmt, uint16_t param_num, uint8_t value, bool is_unsigned)
66
65
{
67
66
  uint8_t *val;
68
 
  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(uint8_t));
69
 
  val= (uint8_t*) stmt->query_params[param_num].data;
 
67
  val= (uint8_t*) stmt->query_params[param_num].data_buffer;
70
68
  *val= value;
71
69
 
72
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TINY, val, 1, is_unsigned, false);
 
70
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TINY, val, 1, is_unsigned);
73
71
}
74
72
drizzle_return_t drizzle_stmt_set_short(drizzle_stmt_st *stmt, uint16_t param_num, uint16_t value, bool is_unsigned)
75
73
{
76
74
  uint16_t *val;
77
 
  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(uint16_t));
78
 
  val= (uint16_t*) stmt->query_params[param_num].data;
 
75
  val= (uint16_t*) stmt->query_params[param_num].data_buffer;
79
76
  *val= value;
80
77
 
81
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_SHORT, val, 2, is_unsigned, false);
 
78
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_SHORT, val, 2, is_unsigned);
82
79
}
83
80
 
84
81
drizzle_return_t drizzle_stmt_set_int(drizzle_stmt_st *stmt, uint16_t param_num, uint32_t value, bool is_unsigned)
85
82
{
86
83
  uint32_t *val;
87
 
  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(uint32_t));
88
 
  val= (uint32_t*) stmt->query_params[param_num].data;
 
84
  val= (uint32_t*) stmt->query_params[param_num].data_buffer;
89
85
  *val= value;
90
86
 
91
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_LONG, val, 4, is_unsigned, true);
 
87
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_LONG, val, 4, is_unsigned);
92
88
}
93
89
 
94
90
drizzle_return_t drizzle_stmt_set_bigint(drizzle_stmt_st *stmt, uint16_t param_num, uint64_t value, bool is_unsigned)
95
91
{
96
92
  uint64_t *val;
97
 
  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(uint64_t));
98
 
  val= (uint64_t*) stmt->query_params[param_num].data;
 
93
  val= (uint64_t*) stmt->query_params[param_num].data_buffer;
99
94
  *val= value;
100
95
 
101
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_LONGLONG, val, 8, is_unsigned, false);
 
96
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_LONGLONG, val, 8, is_unsigned);
102
97
}
103
98
 
104
99
drizzle_return_t drizzle_stmt_set_double(drizzle_stmt_st *stmt, uint16_t param_num, double value)
105
100
{
106
101
  double *val;
107
 
  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(double));
108
 
  val= (double*) stmt->query_params[param_num].data;
 
102
  val= (double*) stmt->query_params[param_num].data_buffer;
109
103
  *val= value;
110
104
 
111
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_DOUBLE, val, 8, false, false);
 
105
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_DOUBLE, val, 8, false);
112
106
}
113
107
 
114
108
drizzle_return_t drizzle_stmt_set_float(drizzle_stmt_st *stmt, uint16_t param_num, float value)
115
109
{
116
110
  float *val;
117
 
  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(float));
118
 
  val= (float*) stmt->query_params[param_num].data;
 
111
  val= (float*) stmt->query_params[param_num].data_buffer;
119
112
  *val= value;
120
113
 
121
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_FLOAT, val, 4, false, false);
 
114
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_FLOAT, val, 4, false);
122
115
}
123
116
 
124
117
drizzle_return_t drizzle_stmt_set_string(drizzle_stmt_st *stmt, uint16_t param_num, char *value, size_t length)
125
118
{
126
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_STRING, value, length, false, false);
 
119
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_STRING, value, length, false);
127
120
}
128
121
 
129
122
drizzle_return_t drizzle_stmt_set_null(drizzle_stmt_st *stmt, uint16_t param_num)
130
123
{
131
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_NULL, NULL, 0, false, false);
 
124
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_NULL, NULL, 0, false);
132
125
}
133
126
 
134
127
drizzle_return_t drizzle_stmt_set_time(drizzle_stmt_st *stmt, uint16_t param_num, uint32_t days, uint8_t hours, uint8_t minutes, uint8_t seconds, uint32_t microseconds, bool is_negative)
135
128
{
136
129
  drizzle_datetime_st *time;
137
 
  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(drizzle_datetime_st));
138
 
  time= (drizzle_datetime_st*) stmt->query_params[param_num].data;
 
130
  time= (drizzle_datetime_st*) stmt->query_params[param_num].data_buffer;
139
131
 
140
132
  time->negative= is_negative;
141
133
  time->day= days;
145
137
  time->microsecond= microseconds;
146
138
 
147
139
  /* Length not important because we will figure that out when packing */
148
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, time, 0, false, true);
 
140
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, time, 0, false);
149
141
}
150
142
 
151
143
drizzle_return_t drizzle_stmt_set_timestamp(drizzle_stmt_st *stmt, uint16_t param_num, uint16_t year, uint8_t month, uint8_t day, uint8_t hours, uint8_t minutes, uint8_t seconds, uint32_t microseconds)
152
144
{
153
145
  drizzle_datetime_st *timestamp;
154
 
  stmt->query_params[param_num].data = realloc(stmt->query_params[param_num].data, sizeof(drizzle_datetime_st));
155
 
  timestamp= (drizzle_datetime_st*) stmt->query_params[param_num].data;
 
146
  timestamp= (drizzle_datetime_st*) stmt->query_params[param_num].data_buffer;
156
147
 
157
148
  timestamp->negative= false;
158
149
  timestamp->year= year;
165
156
  timestamp->microsecond= microseconds;
166
157
 
167
158
  /* Length not important because we will figure that out when packing */ 
168
 
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, timestamp, 0, false, true);
 
159
  return drizzle_stmt_set_param(stmt, param_num, DRIZZLE_COLUMN_TYPE_TIME, timestamp, 0, false);
169
160
}
170
161
 
171
162
bool drizzle_stmt_get_is_null_from_name(drizzle_stmt_st *stmt, const char *column_name, drizzle_return_t *ret_ptr)
582
573
 
583
574
char *long_to_string(drizzle_bind_st *param, uint32_t val)
584
575
{
585
 
  /* Max length is -INT32_MAX + NUL = 12 */
586
 
  param->converted_data= (char*)realloc(param->converted_data, 12);
 
576
  /* Pick an empty point in the buffer to make the str */
 
577
  char* buffer= param->data_buffer + 50;
587
578
  if (param->options.is_unsigned)
588
579
  {
589
 
    snprintf(param->converted_data, 12, "%"PRIu32, val);
 
580
    snprintf(buffer, 12, "%"PRIu32, val);
590
581
  }
591
582
  else
592
583
  {
593
 
    snprintf(param->converted_data, 12, "%"PRId32, (int32_t)val);
 
584
    snprintf(buffer, 12, "%"PRId32, (int32_t)val);
594
585
  }
595
 
  return param->converted_data;
 
586
  return buffer;
596
587
}
597
588
 
598
589
char *longlong_to_string(drizzle_bind_st *param, uint64_t val)
599
590
{ 
600
591
  /* Max length is -INT64_MAX + NUL = 21 */
601
 
  param->converted_data= (char*)realloc(param->converted_data, 21);
 
592
  char* buffer= param->data_buffer + 50;
602
593
  if (param->options.is_unsigned)
603
594
  { 
604
 
    snprintf(param->converted_data, 21, "%"PRIu64, val);
 
595
    snprintf(buffer, 21, "%"PRIu64, val);
605
596
  }
606
597
  else
607
598
  {
608
 
    snprintf(param->converted_data, 21, "%"PRId64, (int64_t)val);
 
599
    snprintf(buffer, 21, "%"PRId64, (int64_t)val);
609
600
  }
610
 
  return param->converted_data;
 
601
  return buffer;
611
602
}
612
603
 
613
604
char *double_to_string(drizzle_bind_st *param, double val)
614
605
{ 
615
606
  /* Max length is 23 */
616
 
  param->converted_data= (char*)realloc(param->converted_data, 23);
617
 
  snprintf(param->converted_data, 23, "%f", val);
618
 
  return param->converted_data;
 
607
  char* buffer= param->data_buffer + 50;
 
608
  snprintf(buffer, 23, "%f", val);
 
609
  return buffer;
619
610
}
620
611
 
621
612
char *time_to_string(drizzle_bind_st *param, drizzle_datetime_st *time)
622
613
{
623
614
  /* Max time is -HHH:MM:SS.ssssss + NUL = 17 */
624
 
  param->converted_data= (char*)realloc(param->converted_data, 17);
 
615
  char* buffer= param->data_buffer + 50;
625
616
  if (time->microsecond == 0)
626
617
  {
627
 
    snprintf(param->converted_data, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8, (time->negative) ? "-" : "", time->hour, time->minute, time->second);
 
618
    snprintf(buffer, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8, (time->negative) ? "-" : "", time->hour, time->minute, time->second);
628
619
  }
629
620
  else
630
621
  {
631
 
    snprintf(param->converted_data, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, (time->negative) ? "-" : "", time->hour, time->minute, time->second, time->microsecond);
 
622
    snprintf(buffer, 17, "%s%"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, (time->negative) ? "-" : "", time->hour, time->minute, time->second, time->microsecond);
632
623
  }
633
 
  return param->converted_data;
 
624
  return buffer;
634
625
}
635
626
 
636
627
char *timestamp_to_string(drizzle_bind_st *param, drizzle_datetime_st *timestamp)
637
628
{
638
629
  /* Max timestamp is YYYY-MM-DD HH:MM:SS.ssssss + NUL = 26 */
639
 
  param->converted_data= (char*)realloc(param->converted_data, 26);
 
630
  char* buffer= param->data_buffer + 50;
640
631
  if (timestamp->microsecond == 0)
641
632
  {
642
 
    snprintf(param->converted_data, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second);
 
633
    snprintf(buffer, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second);
643
634
  }
644
635
  else
645
636
  {
646
 
    snprintf(param->converted_data, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second, timestamp->microsecond);
 
637
    snprintf(buffer, 26, "%"PRIu16"-%"PRIu8"-%"PRIu32" %"PRIu16":%"PRIu8":%"PRIu8".%"PRIu32, timestamp->year, timestamp->month, timestamp->day, timestamp->hour, timestamp->minute, timestamp->second, timestamp->microsecond);
647
638
  }
648
 
  return param->converted_data;
 
639
  return buffer;
649
640
}
650
641
 
651
642
uint16_t drizzle_stmt_column_lookup(drizzle_result_st *result, const char *column_name, drizzle_return_t *ret_ptr)