Line data Source code
1 : /*
2 : * SQLDA support routines
3 : *
4 : * The allocated memory area pointed by an sqlda pointer
5 : * contains both the metadata and the data, so freeing up
6 : * is a simple free(sqlda) as expected by the ESQL/C examples.
7 : */
8 :
9 : #define POSTGRES_ECPG_INTERNAL
10 : #include "postgres_fe.h"
11 :
12 : #include "catalog/pg_type_d.h"
13 : #include "decimal.h"
14 : #include "ecpg-pthread-win32.h"
15 : #include "ecpgerrno.h"
16 : #include "ecpglib.h"
17 : #include "ecpglib_extern.h"
18 : #include "ecpgtype.h"
19 : #include "sqlca.h"
20 : #include "sqlda-compat.h"
21 : #include "sqlda-native.h"
22 :
23 : /*
24 : * Compute the next variable's offset with
25 : * the current variable's size and alignment.
26 : *
27 : *
28 : * Returns:
29 : * - the current variable's offset in *current
30 : * - the next variable's offset in *next
31 : */
32 : static void
33 592 : ecpg_sqlda_align_add_size(long offset, int alignment, int size, long *current, long *next)
34 : {
35 592 : if (offset % alignment)
36 220 : offset += alignment - (offset % alignment);
37 592 : if (current)
38 592 : *current = offset;
39 592 : offset += size;
40 592 : if (next)
41 484 : *next = offset;
42 592 : }
43 :
44 : static long
45 44 : sqlda_compat_empty_size(const PGresult *res)
46 : {
47 : long offset;
48 : int i;
49 44 : int sqld = PQnfields(res);
50 :
51 : /* Initial size to store main structure and field structures */
52 44 : offset = sizeof(struct sqlda_compat) + sqld * sizeof(struct sqlvar_compat);
53 :
54 : /* Add space for field names */
55 228 : for (i = 0; i < sqld; i++)
56 184 : offset += strlen(PQfname(res, i)) + 1;
57 :
58 : /* Add padding to the first field value */
59 44 : ecpg_sqlda_align_add_size(offset, sizeof(int), 0, &offset, NULL);
60 :
61 44 : return offset;
62 : }
63 :
64 : static long
65 42 : sqlda_common_total_size(const PGresult *res, int row, enum COMPAT_MODE compat, long offset)
66 : {
67 42 : int sqld = PQnfields(res);
68 : int i;
69 : long next_offset;
70 :
71 : /* Add space for the field values */
72 270 : for (i = 0; i < sqld; i++)
73 : {
74 228 : enum ECPGttype type = sqlda_dynamic_type(PQftype(res, i), compat);
75 :
76 228 : switch (type)
77 : {
78 0 : case ECPGt_short:
79 : case ECPGt_unsigned_short:
80 0 : ecpg_sqlda_align_add_size(offset, sizeof(short), sizeof(short), &offset, &next_offset);
81 0 : break;
82 40 : case ECPGt_int:
83 : case ECPGt_unsigned_int:
84 40 : ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(int), &offset, &next_offset);
85 40 : break;
86 24 : case ECPGt_long:
87 : case ECPGt_unsigned_long:
88 24 : ecpg_sqlda_align_add_size(offset, sizeof(long), sizeof(long), &offset, &next_offset);
89 24 : break;
90 0 : case ECPGt_long_long:
91 : case ECPGt_unsigned_long_long:
92 0 : ecpg_sqlda_align_add_size(offset, sizeof(long long), sizeof(long long), &offset, &next_offset);
93 0 : break;
94 0 : case ECPGt_bool:
95 0 : ecpg_sqlda_align_add_size(offset, sizeof(bool), sizeof(bool), &offset, &next_offset);
96 0 : break;
97 0 : case ECPGt_float:
98 0 : ecpg_sqlda_align_add_size(offset, sizeof(float), sizeof(float), &offset, &next_offset);
99 0 : break;
100 40 : case ECPGt_double:
101 40 : ecpg_sqlda_align_add_size(offset, sizeof(double), sizeof(double), &offset, &next_offset);
102 40 : break;
103 16 : case ECPGt_decimal:
104 16 : ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(decimal), &offset, &next_offset);
105 16 : break;
106 26 : case ECPGt_numeric:
107 :
108 : /*
109 : * We align the numeric struct to allow it to store a pointer,
110 : * while the digits array is aligned to int (which seems like
111 : * overkill, but let's keep compatibility here).
112 : *
113 : * Unfortunately we need to deconstruct the value twice to
114 : * find out the digits array's size and then later fill it.
115 : */
116 26 : ecpg_sqlda_align_add_size(offset, sizeof(NumericDigit *), sizeof(numeric), &offset, &next_offset);
117 26 : if (!PQgetisnull(res, row, i))
118 : {
119 22 : char *val = PQgetvalue(res, row, i);
120 : numeric *num;
121 :
122 22 : num = PGTYPESnumeric_from_asc(val, NULL);
123 22 : if (!num)
124 0 : break;
125 22 : if (num->buf)
126 14 : ecpg_sqlda_align_add_size(next_offset, sizeof(int), num->digits - num->buf + num->ndigits, &offset, &next_offset);
127 22 : PGTYPESnumeric_free(num);
128 : }
129 26 : break;
130 0 : case ECPGt_date:
131 0 : ecpg_sqlda_align_add_size(offset, sizeof(date), sizeof(date), &offset, &next_offset);
132 0 : break;
133 0 : case ECPGt_timestamp:
134 0 : ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(timestamp), &offset, &next_offset);
135 0 : break;
136 0 : case ECPGt_interval:
137 0 : ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(interval), &offset, &next_offset);
138 0 : break;
139 82 : case ECPGt_char:
140 : case ECPGt_unsigned_char:
141 : case ECPGt_string:
142 : default:
143 : {
144 82 : long datalen = strlen(PQgetvalue(res, row, i)) + 1;
145 :
146 82 : ecpg_sqlda_align_add_size(offset, sizeof(int), datalen, &offset, &next_offset);
147 82 : break;
148 : }
149 : }
150 228 : offset = next_offset;
151 : }
152 42 : return offset;
153 : }
154 :
155 :
156 : static long
157 28 : sqlda_compat_total_size(const PGresult *res, int row, enum COMPAT_MODE compat)
158 : {
159 : long offset;
160 :
161 28 : offset = sqlda_compat_empty_size(res);
162 :
163 28 : if (row < 0)
164 12 : return offset;
165 :
166 16 : offset = sqlda_common_total_size(res, row, compat, offset);
167 16 : return offset;
168 : }
169 :
170 : static long
171 64 : sqlda_native_empty_size(const PGresult *res)
172 : {
173 : long offset;
174 64 : int sqld = PQnfields(res);
175 :
176 : /* Initial size to store main structure and field structures */
177 64 : offset = sizeof(struct sqlda_struct) + (sqld - 1) * sizeof(struct sqlvar_struct);
178 :
179 : /* Add padding to the first field value */
180 64 : ecpg_sqlda_align_add_size(offset, sizeof(int), 0, &offset, NULL);
181 :
182 64 : return offset;
183 : }
184 :
185 : static long
186 38 : sqlda_native_total_size(const PGresult *res, int row, enum COMPAT_MODE compat)
187 : {
188 : long offset;
189 :
190 38 : offset = sqlda_native_empty_size(res);
191 :
192 38 : if (row < 0)
193 12 : return offset;
194 :
195 26 : offset = sqlda_common_total_size(res, row, compat, offset);
196 26 : return offset;
197 : }
198 :
199 : /*
200 : * Build "struct sqlda_compat" (metadata only) from PGresult
201 : * leaving enough space for the field values in
202 : * the given row number
203 : */
204 : struct sqlda_compat *
205 28 : ecpg_build_compat_sqlda(int line, PGresult *res, int row, enum COMPAT_MODE compat)
206 : {
207 : struct sqlda_compat *sqlda;
208 : struct sqlvar_compat *sqlvar;
209 : char *fname;
210 : long size;
211 : int sqld;
212 : int i;
213 :
214 28 : size = sqlda_compat_total_size(res, row, compat);
215 28 : sqlda = (struct sqlda_compat *) ecpg_alloc(size, line);
216 28 : if (!sqlda)
217 0 : return NULL;
218 :
219 28 : memset(sqlda, 0, size);
220 28 : sqlvar = (struct sqlvar_compat *) (sqlda + 1);
221 28 : sqld = PQnfields(res);
222 28 : fname = (char *) (sqlvar + sqld);
223 :
224 28 : sqlda->sqld = sqld;
225 28 : ecpg_log("ecpg_build_compat_sqlda on line %d sqld = %d\n", line, sqld);
226 28 : sqlda->desc_occ = size; /* cheat here, keep the full allocated size */
227 28 : sqlda->sqlvar = sqlvar;
228 :
229 132 : for (i = 0; i < sqlda->sqld; i++)
230 : {
231 104 : sqlda->sqlvar[i].sqltype = sqlda_dynamic_type(PQftype(res, i), compat);
232 104 : strcpy(fname, PQfname(res, i));
233 104 : sqlda->sqlvar[i].sqlname = fname;
234 104 : fname += strlen(sqlda->sqlvar[i].sqlname) + 1;
235 :
236 : /*
237 : * this is reserved for future use, so we leave it empty for the time
238 : * being
239 : */
240 : /* sqlda->sqlvar[i].sqlformat = (char *) (long) PQfformat(res, i); */
241 104 : sqlda->sqlvar[i].sqlxid = PQftype(res, i);
242 104 : sqlda->sqlvar[i].sqltypelen = PQfsize(res, i);
243 : }
244 :
245 28 : return sqlda;
246 : }
247 :
248 : /*
249 : * Sets values from PGresult.
250 : */
251 : static int16 value_is_null = -1;
252 : static int16 value_is_not_null = 0;
253 :
254 : void
255 16 : ecpg_set_compat_sqlda(int lineno, struct sqlda_compat **_sqlda, const PGresult *res, int row, enum COMPAT_MODE compat)
256 : {
257 16 : struct sqlda_compat *sqlda = (*_sqlda);
258 : int i;
259 : long offset,
260 : next_offset;
261 :
262 16 : if (row < 0)
263 0 : return;
264 :
265 : /* Offset for the first field value */
266 16 : offset = sqlda_compat_empty_size(res);
267 :
268 : /*
269 : * Set sqlvar[i]->sqldata pointers and convert values to correct format
270 : */
271 96 : for (i = 0; i < sqlda->sqld; i++)
272 : {
273 : int isnull;
274 : int datalen;
275 80 : bool set_data = true;
276 :
277 80 : switch (sqlda->sqlvar[i].sqltype)
278 : {
279 0 : case ECPGt_short:
280 : case ECPGt_unsigned_short:
281 0 : ecpg_sqlda_align_add_size(offset, sizeof(short), sizeof(short), &offset, &next_offset);
282 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
283 0 : sqlda->sqlvar[i].sqllen = sizeof(short);
284 0 : break;
285 16 : case ECPGt_int:
286 : case ECPGt_unsigned_int:
287 16 : ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(int), &offset, &next_offset);
288 16 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
289 16 : sqlda->sqlvar[i].sqllen = sizeof(int);
290 16 : break;
291 0 : case ECPGt_long:
292 : case ECPGt_unsigned_long:
293 0 : ecpg_sqlda_align_add_size(offset, sizeof(long), sizeof(long), &offset, &next_offset);
294 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
295 0 : sqlda->sqlvar[i].sqllen = sizeof(long);
296 0 : break;
297 0 : case ECPGt_long_long:
298 : case ECPGt_unsigned_long_long:
299 0 : ecpg_sqlda_align_add_size(offset, sizeof(long long), sizeof(long long), &offset, &next_offset);
300 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
301 0 : sqlda->sqlvar[i].sqllen = sizeof(long long);
302 0 : break;
303 0 : case ECPGt_bool:
304 0 : ecpg_sqlda_align_add_size(offset, sizeof(bool), sizeof(bool), &offset, &next_offset);
305 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
306 0 : sqlda->sqlvar[i].sqllen = sizeof(bool);
307 0 : break;
308 0 : case ECPGt_float:
309 0 : ecpg_sqlda_align_add_size(offset, sizeof(float), sizeof(float), &offset, &next_offset);
310 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
311 0 : sqlda->sqlvar[i].sqllen = sizeof(float);
312 0 : break;
313 16 : case ECPGt_double:
314 16 : ecpg_sqlda_align_add_size(offset, sizeof(double), sizeof(double), &offset, &next_offset);
315 16 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
316 16 : sqlda->sqlvar[i].sqllen = sizeof(double);
317 16 : break;
318 16 : case ECPGt_decimal:
319 16 : ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(decimal), &offset, &next_offset);
320 16 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
321 16 : sqlda->sqlvar[i].sqllen = sizeof(decimal);
322 16 : break;
323 0 : case ECPGt_numeric:
324 : {
325 : numeric *num;
326 : char *val;
327 :
328 0 : set_data = false;
329 :
330 0 : ecpg_sqlda_align_add_size(offset, sizeof(NumericDigit *), sizeof(numeric), &offset, &next_offset);
331 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
332 0 : sqlda->sqlvar[i].sqllen = sizeof(numeric);
333 :
334 0 : if (PQgetisnull(res, row, i))
335 : {
336 0 : ECPGset_noind_null(ECPGt_numeric, sqlda->sqlvar[i].sqldata);
337 0 : break;
338 : }
339 :
340 0 : val = PQgetvalue(res, row, i);
341 0 : num = PGTYPESnumeric_from_asc(val, NULL);
342 0 : if (!num)
343 : {
344 0 : ECPGset_noind_null(ECPGt_numeric, sqlda->sqlvar[i].sqldata);
345 0 : break;
346 : }
347 :
348 0 : memcpy(sqlda->sqlvar[i].sqldata, num, sizeof(numeric));
349 :
350 0 : if (num->buf)
351 : {
352 0 : ecpg_sqlda_align_add_size(next_offset, sizeof(int), num->digits - num->buf + num->ndigits, &offset, &next_offset);
353 0 : memcpy((char *) sqlda + offset, num->buf, num->digits - num->buf + num->ndigits);
354 :
355 0 : ((numeric *) sqlda->sqlvar[i].sqldata)->buf = (NumericDigit *) sqlda + offset;
356 0 : ((numeric *) sqlda->sqlvar[i].sqldata)->digits = (NumericDigit *) sqlda + offset + (num->digits - num->buf);
357 : }
358 :
359 0 : PGTYPESnumeric_free(num);
360 :
361 0 : break;
362 : }
363 0 : case ECPGt_date:
364 0 : ecpg_sqlda_align_add_size(offset, sizeof(date), sizeof(date), &offset, &next_offset);
365 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
366 0 : sqlda->sqlvar[i].sqllen = sizeof(date);
367 0 : break;
368 0 : case ECPGt_timestamp:
369 0 : ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(timestamp), &offset, &next_offset);
370 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
371 0 : sqlda->sqlvar[i].sqllen = sizeof(timestamp);
372 0 : break;
373 0 : case ECPGt_interval:
374 0 : ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(interval), &offset, &next_offset);
375 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
376 0 : sqlda->sqlvar[i].sqllen = sizeof(interval);
377 0 : break;
378 32 : case ECPGt_char:
379 : case ECPGt_unsigned_char:
380 : case ECPGt_string:
381 : default:
382 32 : datalen = strlen(PQgetvalue(res, row, i)) + 1;
383 32 : ecpg_sqlda_align_add_size(offset, sizeof(int), datalen, &offset, &next_offset);
384 32 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
385 32 : sqlda->sqlvar[i].sqllen = datalen;
386 32 : if (datalen > 32768)
387 0 : sqlda->sqlvar[i].sqlilongdata = sqlda->sqlvar[i].sqldata;
388 32 : break;
389 : }
390 :
391 80 : isnull = PQgetisnull(res, row, i);
392 80 : ecpg_log("ecpg_set_compat_sqlda on line %d row %d col %d %s\n", lineno, row, i, isnull ? "IS NULL" : "IS NOT NULL");
393 80 : sqlda->sqlvar[i].sqlind = isnull ? &value_is_null : &value_is_not_null;
394 80 : sqlda->sqlvar[i].sqlitype = ECPGt_short;
395 80 : sqlda->sqlvar[i].sqlilen = sizeof(short);
396 80 : if (!isnull)
397 : {
398 64 : if (set_data)
399 64 : ecpg_get_data(res, row, i, lineno,
400 64 : sqlda->sqlvar[i].sqltype, ECPGt_NO_INDICATOR,
401 64 : sqlda->sqlvar[i].sqldata, NULL, 0, 0, 0,
402 : ECPG_ARRAY_NONE, compat, false);
403 : }
404 : else
405 16 : ECPGset_noind_null(sqlda->sqlvar[i].sqltype, sqlda->sqlvar[i].sqldata);
406 :
407 80 : offset = next_offset;
408 : }
409 : }
410 :
411 : struct sqlda_struct *
412 38 : ecpg_build_native_sqlda(int line, PGresult *res, int row, enum COMPAT_MODE compat)
413 : {
414 : struct sqlda_struct *sqlda;
415 : long size;
416 : int i;
417 :
418 38 : size = sqlda_native_total_size(res, row, compat);
419 38 : sqlda = (struct sqlda_struct *) ecpg_alloc(size, line);
420 38 : if (!sqlda)
421 0 : return NULL;
422 :
423 38 : memset(sqlda, 0, size);
424 :
425 38 : sprintf(sqlda->sqldaid, "SQLDA ");
426 38 : sqlda->sqld = sqlda->sqln = PQnfields(res);
427 38 : ecpg_log("ecpg_build_native_sqlda on line %d sqld = %d\n", line, sqlda->sqld);
428 38 : sqlda->sqldabc = sizeof(struct sqlda_struct) + (sqlda->sqld - 1) * sizeof(struct sqlvar_struct);
429 :
430 210 : for (i = 0; i < sqlda->sqld; i++)
431 : {
432 : char *fname;
433 :
434 172 : sqlda->sqlvar[i].sqltype = sqlda_dynamic_type(PQftype(res, i), compat);
435 172 : fname = PQfname(res, i);
436 172 : sqlda->sqlvar[i].sqlname.length = strlen(fname);
437 172 : strcpy(sqlda->sqlvar[i].sqlname.data, fname);
438 : }
439 :
440 38 : return sqlda;
441 : }
442 :
443 : void
444 26 : ecpg_set_native_sqlda(int lineno, struct sqlda_struct **_sqlda, const PGresult *res, int row, enum COMPAT_MODE compat)
445 : {
446 26 : struct sqlda_struct *sqlda = (*_sqlda);
447 : int i;
448 : long offset,
449 : next_offset;
450 :
451 26 : if (row < 0)
452 0 : return;
453 :
454 : /* Offset for the first field value */
455 26 : offset = sqlda_native_empty_size(res);
456 :
457 : /*
458 : * Set sqlvar[i]->sqldata pointers and convert values to correct format
459 : */
460 174 : for (i = 0; i < sqlda->sqld; i++)
461 : {
462 : int isnull;
463 : int datalen;
464 148 : bool set_data = true;
465 :
466 148 : switch (sqlda->sqlvar[i].sqltype)
467 : {
468 0 : case ECPGt_short:
469 : case ECPGt_unsigned_short:
470 0 : ecpg_sqlda_align_add_size(offset, sizeof(short), sizeof(short), &offset, &next_offset);
471 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
472 0 : sqlda->sqlvar[i].sqllen = sizeof(short);
473 0 : break;
474 24 : case ECPGt_int:
475 : case ECPGt_unsigned_int:
476 24 : ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(int), &offset, &next_offset);
477 24 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
478 24 : sqlda->sqlvar[i].sqllen = sizeof(int);
479 24 : break;
480 24 : case ECPGt_long:
481 : case ECPGt_unsigned_long:
482 24 : ecpg_sqlda_align_add_size(offset, sizeof(long), sizeof(long), &offset, &next_offset);
483 24 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
484 24 : sqlda->sqlvar[i].sqllen = sizeof(long);
485 24 : break;
486 0 : case ECPGt_long_long:
487 : case ECPGt_unsigned_long_long:
488 0 : ecpg_sqlda_align_add_size(offset, sizeof(long long), sizeof(long long), &offset, &next_offset);
489 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
490 0 : sqlda->sqlvar[i].sqllen = sizeof(long long);
491 0 : break;
492 0 : case ECPGt_bool:
493 0 : ecpg_sqlda_align_add_size(offset, sizeof(bool), sizeof(bool), &offset, &next_offset);
494 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
495 0 : sqlda->sqlvar[i].sqllen = sizeof(bool);
496 0 : break;
497 0 : case ECPGt_float:
498 0 : ecpg_sqlda_align_add_size(offset, sizeof(float), sizeof(float), &offset, &next_offset);
499 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
500 0 : sqlda->sqlvar[i].sqllen = sizeof(float);
501 0 : break;
502 24 : case ECPGt_double:
503 24 : ecpg_sqlda_align_add_size(offset, sizeof(double), sizeof(double), &offset, &next_offset);
504 24 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
505 24 : sqlda->sqlvar[i].sqllen = sizeof(double);
506 24 : break;
507 0 : case ECPGt_decimal:
508 0 : ecpg_sqlda_align_add_size(offset, sizeof(int), sizeof(decimal), &offset, &next_offset);
509 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
510 0 : sqlda->sqlvar[i].sqllen = sizeof(decimal);
511 0 : break;
512 26 : case ECPGt_numeric:
513 : {
514 : numeric *num;
515 : char *val;
516 :
517 26 : set_data = false;
518 :
519 26 : ecpg_sqlda_align_add_size(offset, sizeof(NumericDigit *), sizeof(numeric), &offset, &next_offset);
520 26 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
521 26 : sqlda->sqlvar[i].sqllen = sizeof(numeric);
522 :
523 26 : if (PQgetisnull(res, row, i))
524 : {
525 4 : ECPGset_noind_null(ECPGt_numeric, sqlda->sqlvar[i].sqldata);
526 4 : break;
527 : }
528 :
529 22 : val = PQgetvalue(res, row, i);
530 22 : num = PGTYPESnumeric_from_asc(val, NULL);
531 22 : if (!num)
532 : {
533 0 : ECPGset_noind_null(ECPGt_numeric, sqlda->sqlvar[i].sqldata);
534 0 : break;
535 : }
536 :
537 22 : memcpy(sqlda->sqlvar[i].sqldata, num, sizeof(numeric));
538 :
539 22 : if (num->buf)
540 : {
541 14 : ecpg_sqlda_align_add_size(next_offset, sizeof(int), num->digits - num->buf + num->ndigits, &offset, &next_offset);
542 14 : memcpy((char *) sqlda + offset, num->buf, num->digits - num->buf + num->ndigits);
543 :
544 14 : ((numeric *) sqlda->sqlvar[i].sqldata)->buf = (NumericDigit *) sqlda + offset;
545 14 : ((numeric *) sqlda->sqlvar[i].sqldata)->digits = (NumericDigit *) sqlda + offset + (num->digits - num->buf);
546 : }
547 :
548 22 : PGTYPESnumeric_free(num);
549 :
550 22 : break;
551 : }
552 0 : case ECPGt_date:
553 0 : ecpg_sqlda_align_add_size(offset, sizeof(date), sizeof(date), &offset, &next_offset);
554 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
555 0 : sqlda->sqlvar[i].sqllen = sizeof(date);
556 0 : break;
557 0 : case ECPGt_timestamp:
558 0 : ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(timestamp), &offset, &next_offset);
559 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
560 0 : sqlda->sqlvar[i].sqllen = sizeof(timestamp);
561 0 : break;
562 0 : case ECPGt_interval:
563 0 : ecpg_sqlda_align_add_size(offset, sizeof(int64), sizeof(interval), &offset, &next_offset);
564 0 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
565 0 : sqlda->sqlvar[i].sqllen = sizeof(interval);
566 0 : break;
567 50 : case ECPGt_char:
568 : case ECPGt_unsigned_char:
569 : case ECPGt_string:
570 : default:
571 50 : datalen = strlen(PQgetvalue(res, row, i)) + 1;
572 50 : ecpg_sqlda_align_add_size(offset, sizeof(int), datalen, &offset, &next_offset);
573 50 : sqlda->sqlvar[i].sqldata = (char *) sqlda + offset;
574 50 : sqlda->sqlvar[i].sqllen = datalen;
575 50 : break;
576 : }
577 :
578 148 : isnull = PQgetisnull(res, row, i);
579 148 : ecpg_log("ecpg_set_native_sqlda on line %d row %d col %d %s\n", lineno, row, i, isnull ? "IS NULL" : "IS NOT NULL");
580 148 : sqlda->sqlvar[i].sqlind = isnull ? &value_is_null : &value_is_not_null;
581 148 : if (!isnull)
582 : {
583 128 : if (set_data)
584 106 : ecpg_get_data(res, row, i, lineno,
585 106 : sqlda->sqlvar[i].sqltype, ECPGt_NO_INDICATOR,
586 : sqlda->sqlvar[i].sqldata, NULL, 0, 0, 0,
587 : ECPG_ARRAY_NONE, compat, false);
588 : }
589 :
590 148 : offset = next_offset;
591 : }
592 : }
|
