/*************** Xindex H Declares Source Code File (.H) ***************/ /* Name: XINDEX.H Version 3.5 */ /* */ /* (C) Copyright to the author Olivier BERTRAND 2004 - 2015 */ /* */ /* This file contains the XINDEX class declares. */ /***********************************************************************/ #ifndef __XINDEX_H__ #define __XINDEX_H__ #include "block.h" #include "csort.h" /* Base class declares */ #include "xtable.h" #include "valblk.h" #if defined(XMAP) #include "maputil.h" #endif // XMAP enum IDT {TYPE_IDX_ERROR = 0, /* Type not defined */ TYPE_IDX_INDX = 4, /* Permanent standard index */ TYPE_IDX_XROW = 5}; /* Permanent row index */ #if defined(XMAP) typedef MEMMAP *MMP; #endif // XMAP typedef class INDEXDEF *PIXDEF; typedef class KPARTDEF *PKPDEF; typedef class XINDEX *PXINDEX; typedef class XLOAD *PXLOAD; typedef class KXYCOL *PXCOL; /***********************************************************************/ /* Structures used when checking for possible indexing */ /***********************************************************************/ typedef struct index_col *PICOL; typedef struct index_val *PIVAL; typedef struct index_def *PINDX; typedef struct indx_used *PXUSED; typedef struct index_val : public BLOCK { index_val(PXOB xp) {Next = NULL; Xval = xp; Kp = NULL;} PIVAL Next; // Next value PXOB Xval; // To value or array int *Kp; // The coordonates in a LSTBLK } IVAL; typedef struct index_col : public BLOCK { index_col(PCOL cp) {Next = Nxtgrp = NULL; Colp = cp; Ngrp = N = 0; Vals = NULL;} PICOL Next; // Next column PICOL Nxtgrp; // Next group PCOL Colp; // The column PIVAL Vals; // To column values int Ngrp; // Group number of values int N; // Column number of values } ICOL; typedef struct index_def : public BLOCK { index_def(PIXDEF xdp) {Next = NULL; Pxdf = xdp; Cols = NULL; Alloc = false;} PINDX Next; PIXDEF Pxdf; PICOL Cols; bool Alloc; // Must allocate values } INDX; typedef struct index_off { union { #if defined(WORDS_BIGENDIAN) struct {int High; int Low;} v; #else // !WORDS_BIGENDIAN struct {int Low; int High;} v; #endif //!WORDS_BIGENDIAN longlong Val; // File position }; // end of union } IOFF; /***********************************************************************/ /* Index definition block. */ /***********************************************************************/ class DllExport INDEXDEF : public BLOCK { /* Index description block */ friend class PLUGCAT; friend class DOSDEF; friend class ha_connect; friend int PlgMakeIndex(PGLOBAL g, PSZ name, PIXDEF pxdf, bool add); public: // Constructor INDEXDEF(char *name, bool uniq = false, int n = 0); // Implementation PIXDEF GetNext(void) {return Next;} void SetNext(PIXDEF pxdf) {Next = pxdf;} PSZ GetName(void) {return (PSZ)Name;} bool IsUnique(void) {return Unique;} bool IsDynamic(void) {return Dynamic;} bool IsAuto(void) {return AutoInc;} bool IsValid(void) {return !Invalid;} void SetAuto(bool b) {AutoInc = b;} void SetInvalid(bool b) {Invalid = b;} int GetNparts(void) {return Nparts;} int GetID(void) {return ID;} void SetID(int n) {ID = n;} PKPDEF GetToKeyParts(void) {return ToKeyParts;} void SetToKeyParts(PKPDEF kp) {ToKeyParts = kp;} void SetNParts(uint np) {Nparts = (signed)np;} void SetMaxSame(int mxs) {MaxSame = mxs;} void SetMxsame(PXINDEX x); int GetMaxSame(void) {return MaxSame;} bool Define(PGLOBAL g, void *memp, PTABDEF dfp, LPCSTR p); PIXDEF GetIndexOf(PCOL colp, bool hd = false); int IsIndexOf(PCOL colp); PKXBASE CheckIndexing(PGLOBAL g, PTDBDOS tdbp); PINDX CheckAND(PGLOBAL g, PINDX pix1, PINDX pix2); PINDX CheckOR(PGLOBAL g, PINDX pix1, PINDX pix2); PINDX CheckEQ(PGLOBAL g, PTDB tdbp, PXOB *arg, int op, int *kp = NULL); bool TestEQ(PGLOBAL g, PTDB tdbp, PXOB *arg, int op, bool b = false); protected: PIXDEF Next; /* To next block */ PKPDEF ToKeyParts; /* To the key part definitions */ char *Name; /* Index name */ bool Unique; /* true if defined as unique */ bool Invalid; /* true if marked as Invalid */ bool AutoInc; /* true if unique key in auto increment */ bool Dynamic; /* KINDEX style */ bool Mapped; /* Use file mapping */ int Nparts; /* Number of key parts */ int ID; /* Index ID number */ int MaxSame; /* Max number of same values */ }; // end of INDEXDEF typedef struct indx_used : public BLOCK { indx_used(PTDB tp, PIXDEF xdp, PCOL *cp, int k) {Tname = (char*)tp->GetName(); Xname = xdp->GetName(); Cp = cp; K = k;} PXUSED Next; char *Tname; PSZ Xname; PCOL *Cp; int K; } XUSED; /***********************************************************************/ /* Index Key Part definition block. */ /***********************************************************************/ class DllExport KPARTDEF : public BLOCK { /* Index Key Part desc block */ friend class INDEXDEF; friend class XINDEX; friend class PLUGCAT; friend class DOSDEF; friend class ha_connect; friend int PlgMakeIndex(PGLOBAL g, PSZ name, PIXDEF pxdf, bool add); public: KPARTDEF(PSZ name, int n); // Constructor // Implementation PKPDEF GetNext(void) {return Next;} PSZ GetName(void) {return (PSZ)Name;} int GetNcol(void) {return Ncol;} void SetNext(PKPDEF pkdf) {Next = pkdf;} void SetKlen(int len) {Klen = len;} void SetMxsame(int mxs) {Mxsame = mxs;} protected: PKPDEF Next; /* To next block */ PSZ Name; /* Field name */ int Mxsame; /* Field max same values */ int Ncol; /* Field number */ int Klen; /* Key length */ }; // end of KPARTDEF /***********************************************************************/ /* This is the XDB Index virtual base class declaration. */ /***********************************************************************/ class DllExport XXBASE : public CSORT, public BLOCK { friend class INDEXDEF; friend class KXYCOL; public: // Constructor XXBASE(PTDBDOS tbxp, bool b); // Implementation virtual IDT GetType(void) = 0; virtual void Reset(void) = 0; virtual bool IsMul(void) {return false;} virtual bool IsRandom(void) {return true;} virtual bool IsDynamic(void) {return Dynamic;} virtual void SetDynamic(bool dyn) {Dynamic = dyn;} //virtual bool HaveSame(void) {return false;} virtual int GetCurPos(void) {return Cur_K;} virtual void SetNval(int n) {assert(n == 1);} virtual void SetOp(OPVAL op) {Op = op;} int GetNdif(void) {return Ndif;} int GetNum_K(void) {return Num_K;} int GetCur_K(void) {return Cur_K;} int GetID(void) {return ID;} void SetID(int id) {ID = id;} void SetNth(int n) {Nth = n;} int *GetPof(void) {return Pof;} int *GetPex(void) {return Pex;} bool IsSorted(void) {return Srtd;} void FreeIndex(void) {PlgDBfree(Index);} // Methods virtual void Printf(PGLOBAL g, FILE *f, uint n); virtual void Prints(PGLOBAL g, char *ps, uint z); virtual bool Init(PGLOBAL g) = 0; virtual bool Make(PGLOBAL g, PIXDEF sxp) = 0; #if defined(XMAP) virtual bool MapInit(PGLOBAL g) = 0; #endif // XMAP virtual int MaxRange(void) {return 1;} virtual int Fetch(PGLOBAL g) = 0; virtual bool NextVal(bool) {return true;} virtual bool PrevVal(void) {return true;} virtual int FastFind(void) = 0; virtual bool Reorder(PGLOBAL) {return true;} virtual int Range(PGLOBAL, int = 0, bool = true) {return -1;} // Means error virtual int Qcompare(int *, int *) = 0; virtual int GroupSize(void) {return 1;} virtual void Close(void) = 0; protected: // Members PTDBASE Tbxp; // Points to calling table TDB PXCOL To_KeyCol; // To KeyCol class list MBLOCK Record; // Record allocation block int* &To_Rec; // We are using ftell, fseek int Cur_K; // Index of current record int Old_K; // Index of last record int Num_K; // Size of Rec_K pointer array int Ndif; // Number of distinct values int Bot; // Bottom of research index int Top; // Top of research index int Inf, Sup; // Used for block optimization OPVAL Op; // Search operator bool Mul; // true if multiple bool Srtd; // true for sorted column bool Dynamic; // true when dynamically made int Val_K; // Index of current value int Nblk; // Number of blocks int Sblk; // Block size int Thresh; // Thresh for sorting join indexes int ID; // Index ID number int Nth; // Nth constant to fetch }; // end of class XXBASE /***********************************************************************/ /* This is the standard (multicolumn) Index class declaration. */ /***********************************************************************/ class DllExport XINDEX : public XXBASE { friend class KXYCOL; public: // Constructor XINDEX(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp, PCOL *cp, PXOB *xp = NULL, int k = 0); // Implementation virtual IDT GetType(void) {return TYPE_IDX_INDX;} virtual bool IsMul(void) {return (Nval < Nk) ? true : Mul;} //virtual bool HaveSame(void) {return Op == OP_SAME;} virtual int GetCurPos(void) {return (Pex) ? Pex[Cur_K] : Cur_K;} virtual void SetNval(int n) {Nval = n;} int GetMaxSame(void) {return MaxSame;} // Methods virtual void Reset(void); virtual bool Init(PGLOBAL g); #if defined(XMAP) virtual bool MapInit(PGLOBAL g); #endif // XMAP virtual int Qcompare(int *, int *); virtual int Fetch(PGLOBAL g); virtual int FastFind(void); virtual int GroupSize(void); virtual int Range(PGLOBAL g, int limit = 0, bool incl = true); virtual int MaxRange(void) {return MaxSame;} virtual int ColMaxSame(PXCOL kp); virtual void Close(void); virtual bool NextVal(bool eq); virtual bool PrevVal(void); virtual bool Make(PGLOBAL g, PIXDEF sxp); virtual bool SaveIndex(PGLOBAL g, PIXDEF sxp); virtual bool Reorder(PGLOBAL g); bool GetAllSizes(PGLOBAL g,/* int &ndif,*/ int &numk); protected: bool AddColumns(void); bool NextValDif(void); // Members PIXDEF Xdp; // To index definition PTDBDOS Tdbp; // Points to calling table TDB PXLOAD X; // To XLOAD class PXCOL To_LastCol; // To the last key part block PXCOL To_LastVal; // To the last used key part block PCOL *To_Cols; // To array of indexed columns PXOB *To_Vals; // To array of column values int Nk; // The number of indexed columns int Nval; // The number of used columns int Incr; // Increment of record position int MaxSame; // Max number of same values }; // end of class XINDEX /***********************************************************************/ /* This is the fast single column index class declaration. */ /***********************************************************************/ class DllExport XINDXS : public XINDEX { friend class KXYCOL; public: // Constructor XINDXS(PTDBDOS tdbp, PIXDEF xdp, PXLOAD pxp, PCOL *cp, PXOB *xp = NULL); // Implementation virtual void SetNval(int n) {assert(n == 1);} // Methods virtual int Qcompare(int *, int *); virtual int Fetch(PGLOBAL g); virtual int FastFind(void); virtual bool NextVal(bool eq); virtual bool PrevVal(void); virtual int Range(PGLOBAL g, int limit = 0, bool incl = true); virtual int GroupSize(void); protected: // Members }; // end of class XINDXS /***********************************************************************/ /* This is the saving/loading index utility base class. */ /***********************************************************************/ class DllExport XLOAD : public BLOCK { friend class XINDEX; friend class XBIGEX; friend class XBIGXS; public: // Constructor XLOAD(void); // Methods virtual bool Open(PGLOBAL g, char *filename, int id, MODE mode) = 0; virtual bool Seek(PGLOBAL g, int low, int high, int origin) = 0; virtual bool Read(PGLOBAL g, void *buf, int n, int size) = 0; virtual int Write(PGLOBAL g, void *buf, int n, int size, bool& rc) = 0; virtual void Close(char *fn, int id) = 0; virtual void Close(void); #if defined(XMAP) virtual void *FileView(PGLOBAL g, char *fn) = 0; #endif // XMAP protected: // Members #if defined(_WIN32) HANDLE Hfile; // Handle to file or map #else // UNIX int Hfile; // Descriptor to file or map #endif // UNIX IOFF NewOff; // New offset }; // end of class XLOAD /***********************************************************************/ /* This is the saving/loading indexes utility class. */ /***********************************************************************/ class DllExport XFILE : public XLOAD { public: // Constructor XFILE(void); // Methods virtual bool Open(PGLOBAL g, char *filename, int id, MODE mode); virtual bool Seek(PGLOBAL g, int low, int high, int origin); virtual bool Read(PGLOBAL g, void *buf, int n, int size); virtual int Write(PGLOBAL g, void *buf, int n, int size, bool& rc); virtual void Close(char *fn, int id); virtual void Close(void); #if defined(XMAP) virtual void *FileView(PGLOBAL g, char *fn); #endif // XMAP protected: // Members FILE *Xfile; // Index stream file #if defined(XMAP) MMP Mmp; // Mapped view base address and length #endif // XMAP }; // end of class XFILE /***********************************************************************/ /* This is the saving/loading huge indexes utility class. */ /***********************************************************************/ class DllExport XHUGE : public XLOAD { public: // Constructor XHUGE(void) : XLOAD() {} // Methods using XLOAD::Close; virtual bool Open(PGLOBAL g, char *filename, int id, MODE mode); virtual bool Seek(PGLOBAL g, int low, int high, int origin); virtual bool Read(PGLOBAL g, void *buf, int n, int size); virtual int Write(PGLOBAL g, void *buf, int n, int size, bool& rc); virtual void Close(char *fn, int id); #if defined(XMAP) virtual void *FileView(PGLOBAL g, char *fn); #endif // XMAP protected: // Members }; // end of class XHUGE /***********************************************************************/ /* This is the XDB index for columns containing ROWID values. */ /***********************************************************************/ class DllExport XXROW : public XXBASE { friend class KXYCOL; public: // Constructor XXROW(PTDBDOS tbxp); // Implementation virtual IDT GetType(void) {return TYPE_IDX_XROW;} virtual void Reset(void); // Methods virtual bool Init(PGLOBAL g); #if defined(XMAP) virtual bool MapInit(PGLOBAL) {return true;} #endif // XMAP virtual int Fetch(PGLOBAL g); virtual int FastFind(void); virtual int MaxRange(void) {return 1;} virtual int Range(PGLOBAL g, int limit = 0, bool incl = true); virtual int Qcompare(int *, int *) {assert(false); return 0;} virtual bool Make(PGLOBAL, PIXDEF) {return false;} virtual void Close(void) {} protected: // Members PTDBDOS Tdbp; // Points to calling table TDB PVAL Valp; // The value to match in index }; // end of class XXROW /***********************************************************************/ /* Definition of class KXYCOL used to store values of indexed columns */ /***********************************************************************/ class KXYCOL: public BLOCK { friend class INDEXDEF; friend class XINDEX; friend class XINDXS; friend class XBIGEX; friend class XBIGXS; friend class TDBDOS; public: // Constructors KXYCOL(PKXBASE kp); // Implementation int GetType(void) {return Type;} void SetValue(PCOL colp, int i); public: // Methods virtual bool Init(PGLOBAL g, PCOL colp, int n, bool sm, int kln); virtual bool InitFind(PGLOBAL g, PXOB xp); virtual void ReAlloc(PGLOBAL g, int n); virtual void FreeData(void); virtual void FillValue(PVAL valp); virtual int CompVal(int i); // void InitBinFind(void *vp); bool MakeBlockArray(PGLOBAL g, int nb, int size); int Compare(int i1, int i2); int CompBval(int i); void Save(int i) {Valp->SetBinValue(Kblp->GetValPtr(i));} void Restore(int j) {Kblp->SetValue(Valp, j);} void Move(int j, int k) {Kblp->Move(k, j);} // Specific functions #if defined(XMAP) BYTE *MapInit(PGLOBAL g, PCOL colp, int *n, BYTE *m); #endif // XMAP int *MakeOffset(PGLOBAL g, int n); protected: // Members PXCOL Next; // To next in the key part list PXCOL Previous; // To previous in the key part list PKXBASE Kxp; // To the INDEX class block PCOL Colp; // To matching object if a column bool IsSorted; // true if column is already sorted bool Asc; // true for ascending sort, false for Desc MBLOCK Keys; // Data array allocation block void* &To_Keys; // To data array PVBLK Kblp; // To Valblock of the data array MBLOCK Bkeys; // Block array allocation block void* &To_Bkeys; // To block array PVBLK Blkp; // To Valblock of the block array PVAL Valp; // Value use by Find int Klen; // Length of character string or num value int Kprec; // The Value(s) precision or CI int Type; // The Value(s) type bool Prefix; // Key on CHAR column prefix MBLOCK Koff; // Offset allocation block CPINT &Kof; // Reference to offset array int Val_K; // Index of current column value int Ndf; // Number of stored values int Mxs; // Max same for this column }; // end of class KXYCOL #endif // __XINDEX_H__