1/*************** Xindex H Declares Source Code File (.H) ***************/
2/* Name: XINDEX.H Version 3.5 */
3/* */
4/* (C) Copyright to the author Olivier BERTRAND 2004 - 2015 */
5/* */
6/* This file contains the XINDEX class declares. */
7/***********************************************************************/
8#ifndef __XINDEX_H__
9#define __XINDEX_H__
10#include "block.h"
11#include "csort.h" /* Base class declares */
12#include "xtable.h"
13#include "valblk.h"
14#if defined(XMAP)
15#include "maputil.h"
16#endif // XMAP
17
18enum IDT {TYPE_IDX_ERROR = 0, /* Type not defined */
19 TYPE_IDX_INDX = 4, /* Permanent standard index */
20 TYPE_IDX_XROW = 5}; /* Permanent row index */
21
22#if defined(XMAP)
23typedef MEMMAP *MMP;
24#endif // XMAP
25typedef class INDEXDEF *PIXDEF;
26typedef class KPARTDEF *PKPDEF;
27typedef class XINDEX *PXINDEX;
28typedef class XLOAD *PXLOAD;
29typedef class KXYCOL *PXCOL;
30
31/***********************************************************************/
32/* Structures used when checking for possible indexing */
33/***********************************************************************/
34typedef struct index_col *PICOL;
35typedef struct index_val *PIVAL;
36typedef struct index_def *PINDX;
37typedef struct indx_used *PXUSED;
38
39typedef struct index_val : public BLOCK {
40 index_val(PXOB xp) {Next = NULL; Xval = xp; Kp = NULL;}
41 PIVAL Next; // Next value
42 PXOB Xval; // To value or array
43 int *Kp; // The coordonates in a LSTBLK
44 } IVAL;
45
46typedef struct index_col : public BLOCK {
47 index_col(PCOL cp)
48 {Next = Nxtgrp = NULL; Colp = cp; Ngrp = N = 0; Vals = NULL;}
49 PICOL Next; // Next column
50 PICOL Nxtgrp; // Next group
51 PCOL Colp; // The column
52 PIVAL Vals; // To column values
53 int Ngrp; // Group number of values
54 int N; // Column number of values
55 } ICOL;
56
57typedef struct index_def : public BLOCK {
58 index_def(PIXDEF xdp)
59 {Next = NULL; Pxdf = xdp; Cols = NULL; Alloc = false;}
60 PINDX Next;
61 PIXDEF Pxdf;
62 PICOL Cols;
63 bool Alloc; // Must allocate values
64 } INDX;
65
66typedef struct index_off {
67 union {
68#if defined(WORDS_BIGENDIAN)
69 struct {int High; int Low;} v;
70#else // !WORDS_BIGENDIAN
71 struct {int Low; int High;} v;
72#endif //!WORDS_BIGENDIAN
73 longlong Val; // File position
74 }; // end of union
75 } IOFF;
76
77/***********************************************************************/
78/* Index definition block. */
79/***********************************************************************/
80class DllExport INDEXDEF : public BLOCK { /* Index description block */
81 friend class PLUGCAT;
82 friend class DOSDEF;
83 friend class ha_connect;
84 friend int PlgMakeIndex(PGLOBAL g, PSZ name, PIXDEF pxdf, bool add);
85 public:
86 // Constructor
87 INDEXDEF(char *name, bool uniq = false, int n = 0);
88
89 // Implementation
90 PIXDEF GetNext(void) {return Next;}
91 void SetNext(PIXDEF pxdf) {Next = pxdf;}
92 PSZ GetName(void) {return (PSZ)Name;}
93 bool IsUnique(void) {return Unique;}
94 bool IsDynamic(void) {return Dynamic;}
95 bool IsAuto(void) {return AutoInc;}
96 bool IsValid(void) {return !Invalid;}
97 void SetAuto(bool b) {AutoInc = b;}
98 void SetInvalid(bool b) {Invalid = b;}
99 int GetNparts(void) {return Nparts;}
100 int GetID(void) {return ID;}
101 void SetID(int n) {ID = n;}
102 PKPDEF GetToKeyParts(void) {return ToKeyParts;}
103 void SetToKeyParts(PKPDEF kp) {ToKeyParts = kp;}
104 void SetNParts(uint np) {Nparts = (signed)np;}
105 void SetMaxSame(int mxs) {MaxSame = mxs;}
106 void SetMxsame(PXINDEX x);
107 int GetMaxSame(void) {return MaxSame;}
108 bool Define(PGLOBAL g, void *memp, PTABDEF dfp, LPCSTR p);
109 PIXDEF GetIndexOf(PCOL colp, bool hd = false);
110 int IsIndexOf(PCOL colp);
111 PKXBASE CheckIndexing(PGLOBAL g, PTDBDOS tdbp);
112 PINDX CheckAND(PGLOBAL g, PINDX pix1, PINDX pix2);
113 PINDX CheckOR(PGLOBAL g, PINDX pix1, PINDX pix2);
114 PINDX CheckEQ(PGLOBAL g, PTDB tdbp, PXOB *arg, int op, int *kp = NULL);
115 bool TestEQ(PGLOBAL g, PTDB tdbp, PXOB *arg, int op, bool b = false);
116
117 protected:
118 PIXDEF Next; /* To next block */
119 PKPDEF ToKeyParts; /* To the key part definitions */
120 char *Name; /* Index name */
121 bool Unique; /* true if defined as unique */
122 bool Invalid; /* true if marked as Invalid */
123 bool AutoInc; /* true if unique key in auto increment */
124 bool Dynamic; /* KINDEX style */
125 bool Mapped; /* Use file mapping */
126 int Nparts; /* Number of key parts */
127 int ID; /* Index ID number */
128 int MaxSame; /* Max number of same values */
129 }; // end of INDEXDEF
130
131typedef struct indx_used : public BLOCK {
132 indx_used(PTDB tp, PIXDEF xdp, PCOL *cp, int k)
133 {Tname = (char*)tp->GetName(); Xname = xdp->GetName(); Cp = cp; K = k;}
134 PXUSED Next;
135 char *Tname;
136 PSZ Xname;
137 PCOL *Cp;
138 int K;
139 } XUSED;
140
141/***********************************************************************/
142/* Index Key Part definition block. */
143/***********************************************************************/
144class DllExport KPARTDEF : public BLOCK { /* Index Key Part desc block */
145 friend class INDEXDEF;
146 friend class XINDEX;
147 friend class PLUGCAT;
148 friend class DOSDEF;
149 friend class ha_connect;
150 friend int PlgMakeIndex(PGLOBAL g, PSZ name, PIXDEF pxdf, bool add);
151 public:
152 KPARTDEF(PSZ name, int n); // Constructor
153
154 // Implementation
155 PKPDEF GetNext(void) {return Next;}
156 PSZ GetName(void) {return (PSZ)Name;}
157 int GetNcol(void) {return Ncol;}
158 void SetNext(PKPDEF pkdf) {Next = pkdf;}
159 void SetKlen(int len) {Klen = len;}
160 void SetMxsame(int mxs) {Mxsame = mxs;}
161
162 protected:
163 PKPDEF Next; /* To next block */
164 PSZ Name; /* Field name */
165 int Mxsame; /* Field max same values */
166 int Ncol; /* Field number */
167 int Klen; /* Key length */
168 }; // end of KPARTDEF
169
170/***********************************************************************/
171/* This is the XDB Index virtual base class declaration. */
172/***********************************************************************/
173class DllExport XXBASE : public CSORT, public BLOCK {
174 friend class INDEXDEF;
175 friend class KXYCOL;
176 public:
177 // Constructor
178 XXBASE(PTDBDOS tbxp, bool b);
179
180 // Implementation
181 virtual IDT GetType(void) = 0;
182 virtual void Reset(void) = 0;
183 virtual bool IsMul(void) {return false;}
184 virtual bool IsRandom(void) {return true;}
185 virtual bool IsDynamic(void) {return Dynamic;}
186 virtual void SetDynamic(bool dyn) {Dynamic = dyn;}
187//virtual bool HaveSame(void) {return false;}
188 virtual int GetCurPos(void) {return Cur_K;}
189 virtual void SetNval(int n) {assert(n == 1);}
190 virtual void SetOp(OPVAL op) {Op = op;}
191 int GetNdif(void) {return Ndif;}
192 int GetNum_K(void) {return Num_K;}
193 int GetCur_K(void) {return Cur_K;}
194 int GetID(void) {return ID;}
195 void SetID(int id) {ID = id;}
196 void SetNth(int n) {Nth = n;}
197 int *GetPof(void) {return Pof;}
198 int *GetPex(void) {return Pex;}
199 bool IsSorted(void) {return Srtd;}
200 void FreeIndex(void) {PlgDBfree(Index);}
201
202 // Methods
203 virtual void Printf(PGLOBAL g, FILE *f, uint n);
204 virtual void Prints(PGLOBAL g, char *ps, uint z);
205 virtual bool Init(PGLOBAL g) = 0;
206 virtual bool Make(PGLOBAL g, PIXDEF sxp) = 0;
207#if defined(XMAP)
208 virtual bool MapInit(PGLOBAL g) = 0;
209#endif // XMAP
210 virtual int MaxRange(void) {return 1;}
211 virtual int Fetch(PGLOBAL g) = 0;
212 virtual bool NextVal(bool) {return true;}
213 virtual bool PrevVal(void) {return true;}
214 virtual int FastFind(void) = 0;
215 virtual bool Reorder(PGLOBAL) {return true;}
216 virtual int Range(PGLOBAL, int = 0, bool = true) {return -1;} // Means error
217 virtual int Qcompare(int *, int *) = 0;
218 virtual int GroupSize(void) {return 1;}
219 virtual void Close(void) = 0;
220
221 protected:
222 // Members
223 PTDBASE Tbxp; // Points to calling table TDB
224 PXCOL To_KeyCol; // To KeyCol class list
225 MBLOCK Record; // Record allocation block
226 int* &To_Rec; // We are using ftell, fseek
227 int Cur_K; // Index of current record
228 int Old_K; // Index of last record
229 int Num_K; // Size of Rec_K pointer array
230 int Ndif; // Number of distinct values
231 int Bot; // Bottom of research index
232 int Top; // Top of research index
233 int Inf, Sup; // Used for block optimization
234 OPVAL Op; // Search operator
235 bool Mul; // true if multiple
236 bool Srtd; // true for sorted column
237 bool Dynamic; // true when dynamically made
238 int Val_K; // Index of current value
239 int Nblk; // Number of blocks
240 int Sblk; // Block size
241 int Thresh; // Thresh for sorting join indexes
242 int ID; // Index ID number
243 int Nth; // Nth constant to fetch
244 }; // end of class XXBASE
245
246/***********************************************************************/
247/* This is the standard (multicolumn) Index class declaration. */
248/***********************************************************************/
249class DllExport XINDEX : public XXBASE {
250 friend class KXYCOL;
251 public:
252 // Constructor
253 XINDEX(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp,
254 PCOL *cp, PXOB *xp = NULL, int k = 0);
255
256 // Implementation
257 virtual IDT GetType(void) {return TYPE_IDX_INDX;}
258 virtual bool IsMul(void) {return (Nval < Nk) ? true : Mul;}
259//virtual bool HaveSame(void) {return Op == OP_SAME;}
260 virtual int GetCurPos(void) {return (Pex) ? Pex[Cur_K] : Cur_K;}
261 virtual void SetNval(int n) {Nval = n;}
262 int GetMaxSame(void) {return MaxSame;}
263
264 // Methods
265 virtual void Reset(void);
266 virtual bool Init(PGLOBAL g);
267#if defined(XMAP)
268 virtual bool MapInit(PGLOBAL g);
269#endif // XMAP
270 virtual int Qcompare(int *, int *);
271 virtual int Fetch(PGLOBAL g);
272 virtual int FastFind(void);
273 virtual int GroupSize(void);
274 virtual int Range(PGLOBAL g, int limit = 0, bool incl = true);
275 virtual int MaxRange(void) {return MaxSame;}
276 virtual int ColMaxSame(PXCOL kp);
277 virtual void Close(void);
278 virtual bool NextVal(bool eq);
279 virtual bool PrevVal(void);
280 virtual bool Make(PGLOBAL g, PIXDEF sxp);
281 virtual bool SaveIndex(PGLOBAL g, PIXDEF sxp);
282 virtual bool Reorder(PGLOBAL g);
283 bool GetAllSizes(PGLOBAL g,/* int &ndif,*/ int &numk);
284
285 protected:
286 bool AddColumns(void);
287 bool NextValDif(void);
288
289 // Members
290 PIXDEF Xdp; // To index definition
291 PTDBDOS Tdbp; // Points to calling table TDB
292 PXLOAD X; // To XLOAD class
293 PXCOL To_LastCol; // To the last key part block
294 PXCOL To_LastVal; // To the last used key part block
295 PCOL *To_Cols; // To array of indexed columns
296 PXOB *To_Vals; // To array of column values
297 int Nk; // The number of indexed columns
298 int Nval; // The number of used columns
299 int Incr; // Increment of record position
300 int MaxSame; // Max number of same values
301 }; // end of class XINDEX
302
303/***********************************************************************/
304/* This is the fast single column index class declaration. */
305/***********************************************************************/
306class DllExport XINDXS : public XINDEX {
307 friend class KXYCOL;
308 public:
309 // Constructor
310 XINDXS(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp, PCOL *cp, PXOB *xp = NULL);
311
312 // Implementation
313 virtual void SetNval(int n) {assert(n == 1);}
314
315 // Methods
316 virtual int Qcompare(int *, int *);
317 virtual int Fetch(PGLOBAL g);
318 virtual int FastFind(void);
319 virtual bool NextVal(bool eq);
320 virtual bool PrevVal(void);
321 virtual int Range(PGLOBAL g, int limit = 0, bool incl = true);
322 virtual int GroupSize(void);
323
324 protected:
325 // Members
326 }; // end of class XINDXS
327
328/***********************************************************************/
329/* This is the saving/loading index utility base class. */
330/***********************************************************************/
331class DllExport XLOAD : public BLOCK {
332 friend class XINDEX;
333 friend class XBIGEX;
334 friend class XBIGXS;
335 public:
336 // Constructor
337 XLOAD(void);
338
339 // Methods
340 virtual bool Open(PGLOBAL g, char *filename, int id, MODE mode) = 0;
341 virtual bool Seek(PGLOBAL g, int low, int high, int origin) = 0;
342 virtual bool Read(PGLOBAL g, void *buf, int n, int size) = 0;
343 virtual int Write(PGLOBAL g, void *buf, int n,
344 int size, bool& rc) = 0;
345 virtual void Close(char *fn, int id) = 0;
346 virtual void Close(void);
347#if defined(XMAP)
348 virtual void *FileView(PGLOBAL g, char *fn) = 0;
349#endif // XMAP
350
351 protected:
352 // Members
353#if defined(__WIN__)
354 HANDLE Hfile; // Handle to file or map
355#else // UNIX
356 int Hfile; // Descriptor to file or map
357#endif // UNIX
358 IOFF NewOff; // New offset
359 }; // end of class XLOAD
360
361/***********************************************************************/
362/* This is the saving/loading indexes utility class. */
363/***********************************************************************/
364class DllExport XFILE : public XLOAD {
365 public:
366 // Constructor
367 XFILE(void);
368
369 // Methods
370 virtual bool Open(PGLOBAL g, char *filename, int id, MODE mode);
371 virtual bool Seek(PGLOBAL g, int low, int high, int origin);
372 virtual bool Read(PGLOBAL g, void *buf, int n, int size);
373 virtual int Write(PGLOBAL g, void *buf, int n, int size, bool& rc);
374 virtual void Close(char *fn, int id);
375 virtual void Close(void);
376#if defined(XMAP)
377 virtual void *FileView(PGLOBAL g, char *fn);
378#endif // XMAP
379
380 protected:
381 // Members
382 FILE *Xfile; // Index stream file
383#if defined(XMAP)
384 MMP Mmp; // Mapped view base address and length
385#endif // XMAP
386 }; // end of class XFILE
387
388/***********************************************************************/
389/* This is the saving/loading huge indexes utility class. */
390/***********************************************************************/
391class DllExport XHUGE : public XLOAD {
392 public:
393 // Constructor
394 XHUGE(void) : XLOAD() {}
395
396 // Methods
397 using XLOAD::Close;
398 virtual bool Open(PGLOBAL g, char *filename, int id, MODE mode);
399 virtual bool Seek(PGLOBAL g, int low, int high, int origin);
400 virtual bool Read(PGLOBAL g, void *buf, int n, int size);
401 virtual int Write(PGLOBAL g, void *buf, int n, int size, bool& rc);
402 virtual void Close(char *fn, int id);
403#if defined(XMAP)
404 virtual void *FileView(PGLOBAL g, char *fn);
405#endif // XMAP
406
407 protected:
408 // Members
409 }; // end of class XHUGE
410
411/***********************************************************************/
412/* This is the XDB index for columns containing ROWID values. */
413/***********************************************************************/
414class DllExport XXROW : public XXBASE {
415 friend class KXYCOL;
416 public:
417 // Constructor
418 XXROW(PTDBDOS tbxp);
419
420 // Implementation
421 virtual IDT GetType(void) {return TYPE_IDX_XROW;}
422 virtual void Reset(void);
423
424 // Methods
425 virtual bool Init(PGLOBAL g);
426#if defined(XMAP)
427 virtual bool MapInit(PGLOBAL) {return true;}
428#endif // XMAP
429 virtual int Fetch(PGLOBAL g);
430 virtual int FastFind(void);
431 virtual int MaxRange(void) {return 1;}
432 virtual int Range(PGLOBAL g, int limit = 0, bool incl = true);
433 virtual int Qcompare(int *, int *) {assert(false); return 0;}
434 virtual bool Make(PGLOBAL, PIXDEF) {return false;}
435 virtual void Close(void) {}
436
437 protected:
438 // Members
439 PTDBDOS Tdbp; // Points to calling table TDB
440 PVAL Valp; // The value to match in index
441 }; // end of class XXROW
442
443/***********************************************************************/
444/* Definition of class KXYCOL used to store values of indexed columns */
445/***********************************************************************/
446class KXYCOL: public BLOCK {
447 friend class INDEXDEF;
448 friend class XINDEX;
449 friend class XINDXS;
450 friend class XBIGEX;
451 friend class XBIGXS;
452 friend class TDBDOS;
453 public:
454 // Constructors
455 KXYCOL(PKXBASE kp);
456
457 // Implementation
458 int GetType(void) {return Type;}
459 void SetValue(PCOL colp, int i);
460
461 public:
462 // Methods
463 virtual bool Init(PGLOBAL g, PCOL colp, int n, bool sm, int kln);
464 virtual bool InitFind(PGLOBAL g, PXOB xp);
465 virtual void ReAlloc(PGLOBAL g, int n);
466 virtual void FreeData(void);
467 virtual void FillValue(PVAL valp);
468 virtual int CompVal(int i);
469// void InitBinFind(void *vp);
470 bool MakeBlockArray(PGLOBAL g, int nb, int size);
471 int Compare(int i1, int i2);
472 int CompBval(int i);
473 void Save(int i) {Valp->SetBinValue(Kblp->GetValPtr(i));}
474 void Restore(int j) {Kblp->SetValue(Valp, j);}
475 void Move(int j, int k) {Kblp->Move(k, j);}
476
477 // Specific functions
478#if defined(XMAP)
479 BYTE *MapInit(PGLOBAL g, PCOL colp, int *n, BYTE *m);
480#endif // XMAP
481 int *MakeOffset(PGLOBAL g, int n);
482
483 protected:
484 // Members
485 PXCOL Next; // To next in the key part list
486 PXCOL Previous; // To previous in the key part list
487 PKXBASE Kxp; // To the INDEX class block
488 PCOL Colp; // To matching object if a column
489 bool IsSorted; // true if column is already sorted
490 bool Asc; // true for ascending sort, false for Desc
491 MBLOCK Keys; // Data array allocation block
492 void* &To_Keys; // To data array
493 PVBLK Kblp; // To Valblock of the data array
494 MBLOCK Bkeys; // Block array allocation block
495 void* &To_Bkeys; // To block array
496 PVBLK Blkp; // To Valblock of the block array
497 PVAL Valp; // Value use by Find
498 int Klen; // Length of character string or num value
499 int Kprec; // The Value(s) precision or CI
500 int Type; // The Value(s) type
501 bool Prefix; // Key on CHAR column prefix
502 MBLOCK Koff; // Offset allocation block
503 CPINT &Kof; // Reference to offset array
504 int Val_K; // Index of current column value
505 int Ndf; // Number of stored values
506 int Mxs; // Max same for this column
507 }; // end of class KXYCOL
508
509#endif // __XINDEX_H__
510