array_expanded.c Source File (original) (raw)

26 void *result, Size allocated_size);

29{

32};

52{

65 "expanded array",

77 {

89 if (metacache == NULL)

90 metacache = &fakecache;

100

101

103 {

105

107 }

108

109

110

111

112

113

114

115

116

117

118

119 }

120

121

122

123

124

125

126

127

128

129

133

135

138

139

142 {

143

147 }

148 else

149 {

150

155

156 if (metacache)

157 {

162 }

163 }

164

165

171

172

176

177

179}

180

181

182

183

184static void

187{

189 int ndims = oldeah->ndims;

191

192

193 eah->ndims = ndims;

194

197

198 memcpy(eah->dims, oldeah->dims, ndims * sizeof(int));

199 memcpy(eah->lbound, oldeah->lbound, ndims * sizeof(int));

200

201

206

207

209 dvalueslen * sizeof(Datum));

212 {

214 dvalueslen * sizeof(bool));

215 memcpy(eah->dnulls, oldeah->dnulls, dvalueslen * sizeof(bool));

216 }

217 else

222

223

227}

228

229

230

231

234{

236 int nelems;

237 int ndims;

239 bool *dnulls;

241 int i;

242

244

245

248

249

252

253

254

255

256

257

258 nelems = eah->nelems;

259 ndims = eah->ndims;

262 dnulls = eah->dnulls;

263 nbytes = 0;

264 for (i = 0; i < nelems; i++)

265 {

266 if (dnulls && dnulls[i])

267 continue;

270

273 (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),

274 errmsg("array size exceeds the maximum allowed (%d)",

276 }

277

278 if (dnulls)

280 else

282

283

285

286 return nbytes;

287}

288

289

290

291

292static void

294 void *result, Size allocated_size)

295{

298 int nelems;

299 int ndims;

300 int32 dataoffset;

301

303

304

306 {

308 memcpy(result, eah->fvalue, allocated_size);

309 return;

310 }

311

312

314

315

316 nelems = eah->nelems;

317 ndims = eah->ndims;

318

321 else

322 dataoffset = 0;

323

324

325 memset(aresult, 0, allocated_size);

326

328 aresult->ndim = ndims;

331 memcpy(ARR_DIMS(aresult), eah->dims, ndims * sizeof(int));

332 memcpy(ARR_LBOUND(aresult), eah->lbound, ndims * sizeof(int));

333

337 false);

338}

339

340

341

342

343

344

345

346

347

348

349

350

353{

354

356 {

358

360 return eah;

361 }

362

363

366}

367

368

369

370

373{

374

376 {

378

380

381 if (metacache)

382 {

387 }

388 return eah;

389 }

390

391

394}

395

396

397

398

399

402{

404

405

406

407

409 {

413 }

414

415

417}

418

419

420

421

422

423void

425{

426 if (eah->dvalues == NULL)

427 {

430 bool *dnulls;

431 int nelems;

432

433 dnulls = NULL;

437 &dvalues,

439 &nelems);

440

441

442

443

444

445

446

447

449 eah->dnulls = dnulls;

452 }

453}

#define DatumGetArrayTypePCopy(X)

#define ARR_OVERHEAD_WITHNULLS(ndims, nitems)

#define ARR_OVERHEAD_NONULLS(ndims)

static void copy_byval_expanded_array(ExpandedArrayHeader *eah, ExpandedArrayHeader *oldeah)

ExpandedArrayHeader * DatumGetExpandedArrayX(Datum d, ArrayMetaState *metacache)

Datum expand_array(Datum arraydatum, MemoryContext parentcontext, ArrayMetaState *metacache)

void deconstruct_expanded_array(ExpandedArrayHeader *eah)

static Size EA_get_flat_size(ExpandedObjectHeader *eohptr)

ExpandedArrayHeader * DatumGetExpandedArray(Datum d)

AnyArrayType * DatumGetAnyArrayP(Datum d)

static void EA_flatten_into(ExpandedObjectHeader *eohptr, void *result, Size allocated_size)

static const ExpandedObjectMethods EA_methods

void CopyArrayEls(ArrayType *array, Datum *values, bool *nulls, int nitems, int typlen, bool typbyval, char typalign, bool freedata)

void deconstruct_array(ArrayType *array, Oid elmtype, int elmlen, bool elmbyval, char elmalign, Datum **elemsp, bool **nullsp, int *nelemsp)

int ArrayGetNItems(int ndim, const int *dims)

int errcode(int sqlerrcode)

int errmsg(const char *fmt,...)

#define ereport(elevel,...)

ExpandedObjectHeader * DatumGetEOHP(Datum d)

void EOH_init_header(ExpandedObjectHeader *eohptr, const ExpandedObjectMethods *methods, MemoryContext obj_context)

static Datum EOHPGetRWDatum(const struct ExpandedObjectHeader *eohptr)

#define PG_DETOAST_DATUM(datum)

Assert(PointerIsAligned(start, uint64))

void get_typlenbyvalalign(Oid typid, int16 *typlen, bool *typbyval, char *typalign)

void * MemoryContextAlloc(MemoryContext context, Size size)

MemoryContext CurrentMemoryContext

#define AllocSetContextCreate

#define ALLOCSET_START_SMALL_SIZES

#define AllocSizeIsValid(size)

static MemoryContext MemoryContextSwitchTo(MemoryContext context)

static Pointer DatumGetPointer(Datum X)

MemoryContext eoh_context

#define att_align_nominal(cur_offset, attalign)

#define att_addlength_datum(cur_offset, attlen, attdatum)

#define VARATT_IS_EXTERNAL_EXPANDED(PTR)

#define VARATT_IS_EXTERNAL_EXPANDED_RW(PTR)

#define SET_VARSIZE(PTR, len)