descriptor.c File Reference (original) (raw)

235{

236 va_list args;

239 int ntuples,

240 act_tuple;

243

244 if (sqlca == NULL)

245 {

248 return false;

249 }

250

254 if (!ECPGresult)

255 {

256 va_end(args);

257 return false;

258 }

259

261

263 {

265 va_end(args);

266 return false;

267 }

268

269 ecpg_log("ECPGget_desc: reading items for tuple %d\n", index);

271

273

274 memset(&data_var, 0, sizeof data_var);

277

279 {

280 char type_str[20];

281 long varcharsize;

282 long offset;

283 long arrsize;

285 void *var;

286

288 var = va_arg(args, void *);

289 varcharsize = va_arg(args, long);

290 arrsize = va_arg(args, long);

291 offset = va_arg(args, long);

292

293 switch (type)

294 {

297 data_var.ind_type = vartype;

298 data_var.ind_pointer = var;

299 data_var.ind_varcharsize = varcharsize;

300 data_var.ind_arrsize = arrsize;

301 data_var.ind_offset = offset;

302 if (data_var.ind_arrsize == 0 || data_var.ind_varcharsize == 0)

303 data_var.ind_value = *((void **) (data_var.ind_pointer));

304 else

305 data_var.ind_value = data_var.ind_pointer;

306 break;

307

310 data_var.type = vartype;

311 data_var.pointer = var;

312 data_var.varcharsize = varcharsize;

313 data_var.arrsize = arrsize;

314 data_var.offset = offset;

315 if (data_var.arrsize == 0 || data_var.varcharsize == 0)

316 data_var.value = *((void **) (data_var.pointer));

317 else

318 data_var.value = data_var.pointer;

319 break;

320

323 {

324 va_end(args);

325 return false;

326 }

327

329 break;

330

333 {

334 va_end(args);

335 return false;

336 }

337

338 break;

339

342 {

343 va_end(args);

344 return false;

345 }

346

347 break;

348

351 {

352 va_end(args);

353 return false;

354 }

355

357 break;

358

361 {

362 va_end(args);

363 return false;

364 }

365

366 ecpg_log("ECPGget_desc: PRECISION = %d\n", PQfmod(ECPGresult, index) >> 16);

367 break;

368

371 {

372 va_end(args);

373 return false;

374 }

375

377 break;

378

381 {

382 va_end(args);

383 return false;

384 }

385

387 break;

388

391 {

392 va_end(args);

393 return false;

394 }

395

397 break;

398

401 {

402 va_end(args);

403 return false;

404 }

405

407 break;

408

411 {

412 va_end(args);

413 return false;

414 }

415

416 ecpg_log("ECPGget_desc: CARDINALITY = %d\n", PQntuples(ECPGresult));

417 break;

418

421

423

424

425

426

427 if (arrsize > 0 && ntuples > arrsize)

428 {

429 ecpg_log("ECPGget_desc on line %d: incorrect number of matches; %d don't fit into array of %ld\n",

430 lineno, ntuples, arrsize);

432 va_end(args);

433 return false;

434 }

435

436 if (arrsize == 0 && *(void **) var == NULL)

437 {

439

440 if (!mem)

441 {

442 va_end(args);

443 return false;

444 }

445 *(void **) var = mem;

446 var = mem;

447 }

448

449 for (act_tuple = 0; act_tuple < ntuples; act_tuple++)

450 {

452 {

453 va_end(args);

454 return false;

455 }

456 var = (char *) var + offset;

457 ecpg_log("ECPGget_desc: RETURNED[%d] = %d\n", act_tuple, PQgetlength(ECPGresult, act_tuple, index));

458 }

459 break;

460

461 default:

462 snprintf(type_str, sizeof(type_str), "%d", type);

464 va_end(args);

465 return false;

466 }

467

469 }

470

472 {

474

475 memset(&stmt, 0, sizeof stmt);

477

478

479

480

481#ifdef HAVE_USELOCALE

482

483

484

485

486

487

488

489

490 Assert(ecpg_clocale);

491 stmt.oldlocale = uselocale(ecpg_clocale);

492#else

493#ifdef WIN32

494 stmt.oldthreadlocale = _configthreadlocale(_ENABLE_PER_THREAD_LOCALE);

495#endif

498#endif

499

500

503

504#ifdef HAVE_USELOCALE

506 uselocale(stmt.oldlocale);

507#else

508 if (stmt.oldlocale)

509 {

512 }

513#ifdef WIN32

514 if (stmt.oldthreadlocale != -1)

515 _configthreadlocale(stmt.oldthreadlocale);

516#endif

517#endif

518 }

519 else if (data_var.ind_type != ECPGt_NO_INDICATOR && data_var.ind_pointer != NULL)

520

521

522

523

524

525

526 {

527

528

529

530

531 if (data_var.ind_arrsize > 0 && ntuples > data_var.ind_arrsize)

532 {

533 ecpg_log("ECPGget_desc on line %d: incorrect number of matches (indicator); %d don't fit into array of %ld\n",

534 lineno, ntuples, data_var.ind_arrsize);

536 va_end(args);

537 return false;

538 }

539

540

541 if (data_var.ind_arrsize == 0 && data_var.ind_value == NULL)

542 {

544

545 if (!mem)

546 {

547 va_end(args);

548 return false;

549 }

550 *(void **) data_var.ind_pointer = mem;

551 data_var.ind_value = mem;

552 }

553

554 for (act_tuple = 0; act_tuple < ntuples; act_tuple++)

555 {

557 {

558 va_end(args);

559 return false;

560 }

561 data_var.ind_value = (char *) data_var.ind_value + data_var.ind_offset;

562 ecpg_log("ECPGget_desc: INDICATOR[%d] = %d\n", act_tuple, -PQgetisnull(ECPGresult, act_tuple, index));

563 }

564 }

565 sqlca->sqlerrd[2] = ntuples;

566 va_end(args);

567 return true;

568}

#define ECPG_UNKNOWN_DESCRIPTOR_ITEM

#define ECPG_INVALID_DESCRIPTOR_INDEX

#define ECPG_TOO_MANY_MATCHES

static bool get_char_item(int lineno, void *var, enum ECPGttype vartype, char *value, int varcharsize)

#define RETURN_IF_NO_DATA

static PGresult * ecpg_result_by_descriptor(int line, const char *name)

static bool get_int_item(int lineno, void *var, enum ECPGttype vartype, int value)

static unsigned int ecpg_dynamic_type_DDT(Oid type)

bool ecpg_store_result(const PGresult *results, int act_field, const struct statement *stmt, struct variable *var)

char * ecpg_auto_alloc(long size, int lineno)

void ecpg_log(const char *format,...) pg_attribute_printf(1

#define ECPG_SQLSTATE_CARDINALITY_VIOLATION

#define ECPG_SQLSTATE_INVALID_DESCRIPTOR_INDEX

int ecpg_dynamic_type(Oid type)

char * ecpg_strdup(const char *string, int lineno)

int PQgetlength(const PGresult *res, int tup_num, int field_num)

Oid PQftype(const PGresult *res, int field_num)

int PQntuples(const PGresult *res)

char * PQfname(const PGresult *res, int field_num)

int PQfmod(const PGresult *res, int field_num)

int PQgetisnull(const PGresult *res, int tup_num, int field_num)

int PQnfields(const PGresult *res)

int PQfsize(const PGresult *res, int field_num)

Assert(PointerIsAligned(start, uint64))