mirror of
https://github.com/MariaDB/server.git
synced 2025-11-04 04:46:15 +01:00
251 lines
11 KiB
C++
251 lines
11 KiB
C++
/*************** RelDef H Declares Source Code File (.H) ***************/
|
|
/* Name: RELDEF.H Version 1.6 */
|
|
/* */
|
|
/* (C) Copyright to the author Olivier BERTRAND 2004-2016 */
|
|
/* */
|
|
/* This file contains the DEF classes definitions. */
|
|
/***********************************************************************/
|
|
|
|
#ifndef __RELDEF_H
|
|
#define __RELDEF_H
|
|
|
|
#include "block.h"
|
|
#include "catalog.h"
|
|
//#include "my_sys.h"
|
|
#include "mycat.h"
|
|
|
|
typedef class INDEXDEF *PIXDEF;
|
|
typedef class ha_connect *PHC;
|
|
|
|
/***********************************************************************/
|
|
/* Table or View (relation) definition block. */
|
|
/***********************************************************************/
|
|
class DllExport RELDEF : public BLOCK { // Relation definition block
|
|
friend class CATALOG;
|
|
friend class PLUGCAT;
|
|
friend class MYCAT;
|
|
public:
|
|
RELDEF(void); // Constructor
|
|
|
|
// Implementation
|
|
PRELDEF GetNext(void) {return Next;}
|
|
PSZ GetName(void) {return Name;}
|
|
PSZ GetDB(void) {return (PSZ)Database;}
|
|
PCOLDEF GetCols(void) {return To_Cols;}
|
|
PHC GetHandler(void) {return Hc;}
|
|
void SetCols(PCOLDEF pcd) {To_Cols = pcd;}
|
|
PCATLG GetCat(void) {return Cat;}
|
|
virtual const char *GetType(void) = 0;
|
|
virtual AMT GetDefType(void) = 0;
|
|
void SetName(const char *str) { Name=(char*)str; }
|
|
void SetCat(PCATLG cat) { Cat=cat; }
|
|
|
|
// Methods
|
|
PTOS GetTopt(void);
|
|
bool GetBoolCatInfo(PCSZ what, bool bdef);
|
|
bool SetIntCatInfo(PCSZ what, int ival);
|
|
bool Partitioned(void);
|
|
int GetIntCatInfo(PCSZ what, int idef);
|
|
int GetSizeCatInfo(PCSZ what, PCSZ sdef);
|
|
int GetCharCatInfo(PCSZ what, PCSZ sdef, char *buf, int size);
|
|
char *GetStringCatInfo(PGLOBAL g, PCSZ what, PCSZ sdef);
|
|
virtual int Indexable(void) {return 0;}
|
|
virtual bool Define(PGLOBAL g, PCATLG cat,
|
|
LPCSTR name, LPCSTR schema, LPCSTR am) = 0;
|
|
virtual PTDB GetTable(PGLOBAL g, MODE mode) = 0;
|
|
|
|
protected:
|
|
PRELDEF Next; /* To next definition block */
|
|
PSZ Name; /* Name of the view */
|
|
LPCSTR Database; /* Table database */
|
|
PCOLDEF To_Cols; /* To a list of column desc */
|
|
PCATLG Cat; /* To DB catalog info */
|
|
PHC Hc; /* The Connect handler */
|
|
}; // end of RELDEF
|
|
|
|
/***********************************************************************/
|
|
/* This class corresponds to the data base description for tables */
|
|
/* of type DOS, FIX, CSV, DBF, BIN, VCT, JSON, XML... */
|
|
/***********************************************************************/
|
|
class DllExport TABDEF : public RELDEF { /* Logical table descriptor */
|
|
friend class CATALOG;
|
|
friend class PLUGCAT;
|
|
friend class MYCAT;
|
|
friend class TDB;
|
|
friend class TDBEXT;
|
|
public:
|
|
// Constructor
|
|
TABDEF(void); // Constructor
|
|
|
|
// Implementation
|
|
int GetDegree(void) {return Degree;}
|
|
void SetDegree(int d) {Degree = d;}
|
|
int GetElemt(void) {return Elemt;}
|
|
void SetNext(PTABDEF tdfp) {Next = tdfp;}
|
|
int GetMultiple(void) {return Multiple;}
|
|
int GetPseudo(void) {return Pseudo;}
|
|
RECFM GetRecfm(void) {return Recfm;}
|
|
PCSZ GetPath(void);
|
|
//PSZ GetPath(void)
|
|
// {return (Database) ? (PSZ)Database : Cat->GetDataPath();}
|
|
RECFM GetTableFormat(const char* type);
|
|
bool SepIndex(void) {return GetBoolCatInfo("SepIndex", false);}
|
|
bool IsReadOnly(void) {return Read_Only;}
|
|
AMT GetDefType(void) override {return TYPE_AM_TAB;}
|
|
virtual PIXDEF GetIndx(void) {return NULL;}
|
|
virtual void SetIndx(PIXDEF) {}
|
|
virtual bool IsHuge(void) {return false;}
|
|
const CHARSET_INFO *data_charset() {return m_data_charset;}
|
|
const char *GetCsName(void) {return csname;}
|
|
|
|
// Methods
|
|
int GetColCatInfo(PGLOBAL g);
|
|
void SetIndexInfo(void);
|
|
bool DropTable(PGLOBAL g, PSZ name);
|
|
bool Define(PGLOBAL g, PCATLG cat,
|
|
LPCSTR name, LPCSTR schema, LPCSTR am) override;
|
|
virtual bool DefineAM(PGLOBAL, LPCSTR, int) = 0;
|
|
|
|
protected:
|
|
// Members
|
|
PCSZ Schema; /* Table schema (for ODBC) */
|
|
PCSZ Desc; /* Table description */
|
|
RECFM Recfm; /* File or table format */
|
|
uint Catfunc; /* Catalog function ID */
|
|
int Card; /* (max) number of rows in table */
|
|
int Elemt; /* Number of rows in blocks or rowset */
|
|
int Sort; /* Table already sorted ??? */
|
|
int Multiple; /* 0: No 1: DIR 2: Section 3: filelist */
|
|
int Degree; /* Number of columns in the table */
|
|
int Pseudo; /* Bit: 1 ROWID }Ok, 2 FILEID Ok */
|
|
bool Read_Only; /* true for read only tables */
|
|
const CHARSET_INFO *m_data_charset;
|
|
const char *csname; /* Table charset name */
|
|
}; // end of TABDEF
|
|
|
|
/***********************************************************************/
|
|
/* Externally defined OEM tables. */
|
|
/***********************************************************************/
|
|
class DllExport OEMDEF : public TABDEF { /* OEM table */
|
|
friend class CATALOG;
|
|
friend class PLUGCAT;
|
|
friend class MYCAT;
|
|
public:
|
|
// Constructor
|
|
OEMDEF(void) {Hdll = NULL; Pxdef = NULL; Module = Subtype = NULL;}
|
|
|
|
// Implementation
|
|
const char *GetType(void) override {return "OEM";}
|
|
AMT GetDefType(void) override {return TYPE_AM_OEM;}
|
|
|
|
// Methods
|
|
bool DefineAM(PGLOBAL g, LPCSTR am, int poff) override;
|
|
PTDB GetTable(PGLOBAL g, MODE mode) override;
|
|
|
|
protected:
|
|
PTABDEF GetXdef(PGLOBAL g);
|
|
|
|
// Members
|
|
#if defined(_WIN32)
|
|
HANDLE Hdll; /* Handle to the external DLL */
|
|
#else // !_WIN32
|
|
void *Hdll; /* Handle for the loaded shared library */
|
|
#endif // !_WIN32
|
|
PTABDEF Pxdef; /* Pointer to the external TABDEF class */
|
|
char *Module; /* Path/Name of the DLL implementing it */
|
|
char *Subtype; /* The name of the OEM table sub type */
|
|
}; // end of OEMDEF
|
|
|
|
/***********************************************************************/
|
|
/* Column definition block used during creation. */
|
|
/***********************************************************************/
|
|
class DllExport COLCRT : public BLOCK { /* Column description block */
|
|
friend class TABDEF;
|
|
public:
|
|
COLCRT(PSZ name); // Constructor
|
|
COLCRT(void); // Constructor (for views)
|
|
|
|
// Implementation
|
|
PSZ GetName(void) {return Name;}
|
|
PSZ GetDecode(void) {return Decode;}
|
|
PSZ GetFmt(void) {return Fmt;}
|
|
int GetOpt(void) {return Opt;}
|
|
int GetFreq(void) {return Freq;}
|
|
int GetLong(void) {return Long;}
|
|
int GetPrecision(void) {return Precision;}
|
|
int GetOffset(void) {return Offset;}
|
|
void SetOffset(int offset) {Offset = offset;}
|
|
|
|
protected:
|
|
PCOLCRT Next; /* To next block */
|
|
PSZ Name; /* Column name */
|
|
PSZ Desc; /* Column description */
|
|
PSZ Decode; /* Date format */
|
|
PSZ Fmt; /* Input format for formatted files */
|
|
int Offset; /* Offset of field within record */
|
|
int Long; /* Length of field in file record (!BIN) */
|
|
int Key; /* Key (greater than 1 if multiple) */
|
|
int Precision; /* Logical column length */
|
|
int Scale; /* Decimals for float/decimal values */
|
|
int Opt; /* 0:Not 1:clustered 2:sorted-asc 3:desc */
|
|
int Freq; /* Estimated number of different values */
|
|
char DataType; /* Internal data type (C, N, F, T) */
|
|
}; // end of COLCRT
|
|
|
|
/***********************************************************************/
|
|
/* Column definition block. */
|
|
/***********************************************************************/
|
|
class DllExport COLDEF : public COLCRT { /* Column description block */
|
|
friend class TABDEF;
|
|
friend class COLBLK;
|
|
friend class DBFFAM;
|
|
friend class TDB;
|
|
friend class TDBASE;
|
|
friend class TDBDOS;
|
|
public:
|
|
COLDEF(void); // Constructor
|
|
|
|
// Implementation
|
|
PCOLDEF GetNext(void) {return (PCOLDEF)Next;}
|
|
void SetNext(PCOLDEF pcdf) {Next = pcdf;}
|
|
int GetLength(void) {return (int)F.Length;}
|
|
int GetClen(void) {return Clen;}
|
|
int GetType(void) {return Buf_Type;}
|
|
int GetPoff(void) {return Poff;}
|
|
void *GetMin(void) {return To_Min;}
|
|
void SetMin(void *minp) {To_Min = minp;}
|
|
void *GetMax(void) {return To_Max;}
|
|
void SetMax(void *maxp) {To_Max = maxp;}
|
|
bool GetXdb2(void) {return Xdb2;}
|
|
void SetXdb2(bool b) {Xdb2 = b;}
|
|
void *GetBmap(void) {return To_Bmap;}
|
|
void SetBmap(void *bmp) {To_Bmap = bmp;}
|
|
void *GetDval(void) {return To_Dval;}
|
|
void SetDval(void *dvp) {To_Dval = dvp;}
|
|
int GetNdv(void) {return Ndv;}
|
|
void SetNdv(int ndv) {Ndv = ndv;}
|
|
int GetNbm(void) {return Nbm;}
|
|
void SetNbm(int nbm) {Nbm = nbm;}
|
|
int Define(PGLOBAL g, void *memp, PCOLINFO cfp, int poff);
|
|
void Define(PGLOBAL g, PCOL colp);
|
|
bool IsSpecial(void) {return (Flags & U_SPECIAL) ? true : false;}
|
|
bool IsVirtual(void) {return (Flags & U_VIRTUAL) ? true : false;}
|
|
|
|
protected:
|
|
void *To_Min; /* Point to array of block min values */
|
|
void *To_Max; /* Point to array of block max values */
|
|
int *To_Pos; /* Point to array of block positions */
|
|
bool Xdb2; /* TRUE if to be optimized by XDB2 */
|
|
void *To_Bmap; /* To array of block bitmap values */
|
|
void *To_Dval; /* To array of column distinct values */
|
|
int Ndv; /* Number of distinct values */
|
|
int Nbm; /* Number of ULONG in bitmap (XDB2) */
|
|
int Buf_Type; /* Internal data type */
|
|
int Clen; /* Internal data size in chars (bytes) */
|
|
int Poff; /* Calculated offset for Packed tables */
|
|
FORMAT F; /* Output format (should be in COLCRT) */
|
|
ushort Flags; /* Used by MariaDB CONNECT handler */
|
|
}; // end of COLDEF
|
|
|
|
#endif // __RELDEF_H
|
|
|