PostgreSQL Source Code: src/backend/access/gin/ginpostinglist.c Source File (original) (raw)

1

2

3

4

5

6

7

8

9

10

11

12

13

14

16

18

19#ifdef USE_ASSERT_CHECKING

20#define CHECK_ENCODING_ROUNDTRIP

21#endif

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81#define MaxHeapTuplesPerPageBits 11

82

83

84#define MaxBytesPerInteger 7

85

88{

90

93

97

98 return val;

99}

100

101static inline void

103{

107

109}

110

111

112

113

114static void

116{

117 unsigned char *p = *ptr;

118

119 while (val > 0x7F)

120 {

121 *(p++) = 0x80 | (val & 0x7F);

122 val >>= 7;

123 }

124 *(p++) = (unsigned char) val;

125

126 *ptr = p;

127}

128

129

130

131

134{

136 unsigned char *p = *ptr;

138

139

140 c = *(p++);

141 val = c & 0x7F;

142 if (c & 0x80)

143 {

144

145 c = *(p++);

146 val |= (c & 0x7F) << 7;

147 if (c & 0x80)

148 {

149

150 c = *(p++);

151 val |= (c & 0x7F) << 14;

152 if (c & 0x80)

153 {

154

155 c = *(p++);

156 val |= (c & 0x7F) << 21;

157 if (c & 0x80)

158 {

159

160 c = *(p++);

161 val |= (c & 0x7F) << 28;

162 if (c & 0x80)

163 {

164

165 c = *(p++);

166 val |= (c & 0x7F) << 35;

167 if (c & 0x80)

168 {

169

170 c = *(p++);

171 val |= c << 42;

173 }

174 }

175 }

176 }

177 }

178 }

179

180 *ptr = p;

181

182 return val;

183}

184

185

186

187

188

189

190

191

192

193

194

195

198 int *nwritten)

199{

201 int totalpacked = 0;

202 int maxbytes;

204 unsigned char *ptr;

205 unsigned char *endptr;

206

208

209 result = palloc(maxsize);

210

211 maxbytes = maxsize - offsetof(GinPostingList, bytes);

212 Assert(maxbytes > 0);

213

214

215 result->first = ipd[0];

216

218

219 ptr = result->bytes;

220 endptr = result->bytes + maxbytes;

221 for (totalpacked = 1; totalpacked < nipd; totalpacked++)

222 {

225

227

230 else

231 {

232

233

234

235

237 unsigned char *p = buf;

238

240 if (p - buf > (endptr - ptr))

241 break;

242

243 memcpy(ptr, buf, p - buf);

244 ptr += (p - buf);

245 }

246 prev = val;

247 }

249

250

251

252

253

256

257 if (nwritten)

258 *nwritten = totalpacked;

259

261

262

263

264

265#if defined (CHECK_ENCODING_ROUNDTRIP)

266 {

267 int ndecoded;

269

270 Assert(ndecoded == totalpacked);

273 }

274#endif

275

276 return result;

277}

278

279

280

281

282

285{

288 ndecoded_out);

289}

290

291

292

293

294

295

298{

300 int nallocated;

302 char *endseg = ((char *) segment) + len;

303 int ndecoded;

304 unsigned char *ptr;

305 unsigned char *endptr;

306

307

308

309

310 nallocated = segment->nbytes * 2 + 1;

312

313 ndecoded = 0;

314 while ((char *) segment < endseg)

315 {

316

317 if (ndecoded >= nallocated)

318 {

319 nallocated *= 2;

321 }

322

323

326 result[ndecoded] = segment->first;

327 ndecoded++;

328

330 ptr = segment->bytes;

331 endptr = segment->bytes + segment->nbytes;

332 while (ptr < endptr)

333 {

334

335 if (ndecoded >= nallocated)

336 {

337 nallocated *= 2;

339 }

340

342

344 ndecoded++;

345 }

347 }

348

349 if (ndecoded_out)

350 *ndecoded_out = ndecoded;

351 return result;

352}

353

354

355

356

357int

360{

361 int ndecoded;

363

367

368 return ndecoded;

369}

370

371

372

373

374

375

376

380 int *nmerged)

381{

383

385

386

387

388

389

391 {

394 *nmerged = na + nb;

395 }

397 {

400 *nmerged = na + nb;

401 }

402 else

403 {

407

408 while (aptr - a < na && bptr - b < nb)

409 {

411

412 if (cmp > 0)

413 *dptr++ = *bptr++;

414 else if (cmp == 0)

415 {

416

417 *dptr++ = *bptr++;

418 aptr++;

419 }

420 else

421 *dptr++ = *aptr++;

422 }

423

424 while (aptr - a < na)

425 *dptr++ = *aptr++;

426

427 while (bptr - b < nb)

428 *dptr++ = *bptr++;

429

430 *nmerged = dptr - dst;

431 }

432

433 return dst;

434}

#define SHORTALIGN_DOWN(LEN)

static int ginCompareItemPointers(ItemPointer a, ItemPointer b)

#define GinItemPointerGetOffsetNumber(pointer)

#define SizeOfGinPostingList(plist)

#define GinItemPointerSetBlockNumber(pointer, blkno)

#define GinNextPostingListSegment(cur)

#define GinItemPointerSetOffsetNumber(pointer, offnum)

#define GinItemPointerGetBlockNumber(pointer)

ItemPointer ginPostingListDecodeAllSegments(GinPostingList *segment, int len, int *ndecoded_out)

static uint64 itemptr_to_uint64(const ItemPointer iptr)

int ginPostingListDecodeAllSegmentsToTbm(GinPostingList *ptr, int len, TIDBitmap *tbm)

static void encode_varbyte(uint64 val, unsigned char **ptr)

ItemPointer ginPostingListDecode(GinPostingList *plist, int *ndecoded_out)

GinPostingList * ginCompressPostingList(const ItemPointer ipd, int nipd, int maxsize, int *nwritten)

static uint64 decode_varbyte(unsigned char **ptr)

#define MaxBytesPerInteger

#define MaxHeapTuplesPerPageBits

static void uint64_to_itemptr(uint64 val, ItemPointer iptr)

ItemPointer ginMergeItemPointers(ItemPointerData *a, uint32 na, ItemPointerData *b, uint32 nb, int *nmerged)

Assert(PointerIsAligned(start, uint64))

if(TABLE==NULL||TABLE_index==NULL)

static OffsetNumber ItemPointerGetOffsetNumber(const ItemPointerData *pointer)

ItemPointerData * ItemPointer

struct ItemPointerData ItemPointerData

static bool ItemPointerIsValid(const ItemPointerData *pointer)

void * repalloc(void *pointer, Size size)

void pfree(void *pointer)

#define OffsetNumberIsValid(offsetNumber)

static int cmp(const chr *x, const chr *y, size_t len)

unsigned char bytes[FLEXIBLE_ARRAY_MEMBER]

void tbm_add_tuples(TIDBitmap *tbm, const ItemPointer tids, int ntids, bool recheck)