Skip to content

M
mariadb
Commit 128136cb authored by Olivier Bertrand's avatar Olivier Bertrand
Browse files
Options

- Add support of partition tables 

modified:
  storage/connect/ha_connect.cc
  storage/connect/ha_connect.h
  storage/connect/reldef.cpp

- Add INSERT/UPDATE support to PROXY tables
modified:
  storage/connect/tabutil.cpp
  storage/connect/tabutil.h

- Take care of SPECIAL columns
modified:
  storage/connect/filamdbf.cpp
  storage/connect/reldef.h
  storage/connect/tabfmt.cpp

-Typo and misc
modified:
  storage/connect/odbconn.cpp
  storage/connect/tabfix.cpp
  storage/connect/xindex.cpp
parents 9cb4b6c0 7bbcc3e4
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 254 additions and 106 deletions
storage/connect/filamdbf.cpp
View file @ 128136cb
...@@ -546,10 +546,11 @@ bool DBFFAM::AllocateBuffer(PGLOBAL g) ...@@ -546,10 +546,11 @@ bool DBFFAM::AllocateBuffer(PGLOBAL g)
PDOSDEF tdp = (PDOSDEF)Tdbp->GetDef(); PDOSDEF tdp = (PDOSDEF)Tdbp->GetDef();
// Count the number of columns // Count the number of columns
for (cdp = tdp->GetCols(); cdp; cdp = cdp->GetNext()) { for (cdp = tdp->GetCols(); cdp; cdp = cdp->GetNext())
reclen += cdp->GetLong(); if (!(cdp->Flags & U_SPECIAL)) {
n++; reclen += cdp->GetLong();
} // endfor cdp n++;
} // endif Flags
if (Lrecl != reclen) { if (Lrecl != reclen) {
sprintf(g->Message, MSG(BAD_LRECL), Lrecl, reclen); sprintf(g->Message, MSG(BAD_LRECL), Lrecl, reclen);
...@@ -570,30 +571,31 @@ bool DBFFAM::AllocateBuffer(PGLOBAL g) ...@@ -570,30 +571,31 @@ bool DBFFAM::AllocateBuffer(PGLOBAL g)
descp = (DESCRIPTOR*)header; descp = (DESCRIPTOR*)header;
// Currently only standard Xbase types are supported // Currently only standard Xbase types are supported
for (cdp = tdp->GetCols(); cdp; cdp = cdp->GetNext()) { for (cdp = tdp->GetCols(); cdp; cdp = cdp->GetNext())
descp++; if (!(cdp->Flags & U_SPECIAL)) {
descp++;
switch ((c = *GetFormatType(cdp->GetType()))) {
case 'S': // Short integer switch ((c = *GetFormatType(cdp->GetType()))) {
case 'L': // Large (big) integer case 'S': // Short integer
case 'T': // Tiny integer case 'L': // Large (big) integer
c = 'N'; // Numeric case 'T': // Tiny integer
case 'N': // Numeric (integer) c = 'N'; // Numeric
case 'F': // Float (double) case 'N': // Numeric (integer)
descp->Decimals = (uchar)cdp->F.Prec; case 'F': // Float (double)
case 'C': // Char descp->Decimals = (uchar)cdp->F.Prec;
case 'D': // Date case 'C': // Char
break; case 'D': // Date
default: // Should never happen break;
sprintf(g->Message, "Unsupported DBF type %c for column %s", default: // Should never happen
c, cdp->GetName()); sprintf(g->Message, "Unsupported DBF type %c for column %s",
return true; c, cdp->GetName());
} // endswitch c return true;
} // endswitch c
strncpy(descp->Name, cdp->GetName(), 11);
descp->Type = c; strncpy(descp->Name, cdp->GetName(), 11);
descp->Length = (uchar)cdp->GetLong(); descp->Type = c;
} // endfor cdp descp->Length = (uchar)cdp->GetLong();
} // endif Flags
*(char*)(++descp) = EOH; *(char*)(++descp) = EOH;
......
storage/connect/ha_connect.cc
View file @ 128136cb
This diff is collapsed.
storage/connect/ha_connect.h
View file @ 128136cb
...@@ -201,11 +201,13 @@ public: ...@@ -201,11 +201,13 @@ public:
PIXDEF GetIndexInfo(TABLE_SHARE *s= NULL); PIXDEF GetIndexInfo(TABLE_SHARE *s= NULL);
const char *GetDBName(const char *name); const char *GetDBName(const char *name);
const char *GetTableName(void); const char *GetTableName(void);
char *GetPartName(void);
//int GetColNameLen(Field *fp); //int GetColNameLen(Field *fp);
//char *GetColName(Field *fp); //char *GetColName(Field *fp);
//void AddColName(char *cp, Field *fp); //void AddColName(char *cp, Field *fp);
TABLE *GetTable(void) {return table;} TABLE *GetTable(void) {return table;}
bool IsSameIndex(PIXDEF xp1, PIXDEF xp2); bool IsSameIndex(PIXDEF xp1, PIXDEF xp2);
bool IsPartitioned(void);
PTDB GetTDB(PGLOBAL g); PTDB GetTDB(PGLOBAL g);
int OpenTable(PGLOBAL g, bool del= false); int OpenTable(PGLOBAL g, bool del= false);
...@@ -520,7 +522,7 @@ protected: ...@@ -520,7 +522,7 @@ protected:
PVAL sdvalin; // Used to convert date values PVAL sdvalin; // Used to convert date values
PVAL sdvalout; // Used to convert date values PVAL sdvalout; // Used to convert date values
bool istable; // True for table handler bool istable; // True for table handler
//char tname[64]; // The table name char partname[64]; // The partition name
MODE xmod; // Table mode MODE xmod; // Table mode
XINFO xinfo; // The table info structure XINFO xinfo; // The table info structure
bool valid_info; // True if xinfo is valid bool valid_info; // True if xinfo is valid
......
storage/connect/odbconn.cpp
View file @ 128136cb
...@@ -2135,7 +2135,7 @@ int ODBConn::GetCatInfo(CATPARM *cap) ...@@ -2135,7 +2135,7 @@ int ODBConn::GetCatInfo(CATPARM *cap)
PSZ fnc = "Unknown"; PSZ fnc = "Unknown";
UWORD n; UWORD n;
SWORD ncol, len, tp; SWORD ncol, len, tp;
SQLULEN crow; SQLULEN crow = 0;
PQRYRES qrp = cap->Qrp; PQRYRES qrp = cap->Qrp;
PCOLRES crp; PCOLRES crp;
RETCODE rc = 0; RETCODE rc = 0;
......
storage/connect/reldef.cpp
View file @ 128136cb
...@@ -132,19 +132,28 @@ int RELDEF::GetCharCatInfo(PSZ what, PSZ sdef, char *buf, int size) ...@@ -132,19 +132,28 @@ int RELDEF::GetCharCatInfo(PSZ what, PSZ sdef, char *buf, int size)
/***********************************************************************/ /***********************************************************************/
char *RELDEF::GetStringCatInfo(PGLOBAL g, PSZ what, PSZ sdef) char *RELDEF::GetStringCatInfo(PGLOBAL g, PSZ what, PSZ sdef)
{ {
char *sval= NULL, *s= Hc->GetStringOption(what, sdef); char *name, *sval= NULL, *s= Hc->GetStringOption(what, sdef);
if (s) { if (s) {
sval= (char*)PlugSubAlloc(g, NULL, strlen(s) + 1); if (Hc->IsPartitioned() &&
strcpy(sval, s); (!stricmp(what, "filename") || !stricmp(what, "tabname"))) {
name= Hc->GetPartName();
sval= (char*)PlugSubAlloc(g, NULL, strlen(s) + strlen(name));
sprintf(sval, s, name);
} else {
sval= (char*)PlugSubAlloc(g, NULL, strlen(s) + 1);
strcpy(sval, s);
} // endif partitioned
} else if (!stricmp(what, "filename")) { } else if (!stricmp(what, "filename")) {
// Return default file name // Return default file name
char *ftype= Hc->GetStringOption("Type", "*"); char *ftype= Hc->GetStringOption("Type", "*");
int i, n; int i, n;
if (IsFileType(GetTypeID(ftype))) { if (IsFileType(GetTypeID(ftype))) {
sval= (char*)PlugSubAlloc(g, NULL, strlen(Hc->GetTableName()) + 12); name= Hc->GetPartName();
strcat(strcpy(sval, Hc->GetTableName()), "."); sval= (char*)PlugSubAlloc(g, NULL, strlen(name) + 12);
strcat(strcpy(sval, name), ".");
n= strlen(sval); n= strlen(sval);
// Fold ftype to lower case // Fold ftype to lower case
......
storage/connect/reldef.h
View file @ 128136cb
...@@ -213,6 +213,7 @@ class DllExport COLDEF : public COLCRT { /* Column description block ...@@ -213,6 +213,7 @@ class DllExport COLDEF : public COLCRT { /* Column description block
void SetNbm(int nbm) {Nbm = nbm;} void SetNbm(int nbm) {Nbm = nbm;}
int Define(PGLOBAL g, void *memp, PCOLINFO cfp, int poff); int Define(PGLOBAL g, void *memp, PCOLINFO cfp, int poff);
void Define(PGLOBAL g, PCOL colp); void Define(PGLOBAL g, PCOL colp);
bool IsSpecial(void) {return (Flags & U_SPECIAL) ? true : false;}
protected: protected:
void *To_Min; /* Point to array of block min values */ void *To_Min; /* Point to array of block min values */
......
storage/connect/tabfix.cpp
View file @ 128136cb
...@@ -132,6 +132,7 @@ int TDBFIX::ResetTableOpt(PGLOBAL g, bool dop, bool dox) ...@@ -132,6 +132,7 @@ int TDBFIX::ResetTableOpt(PGLOBAL g, bool dop, bool dox)
To_Filter = NULL; // Disable filtering To_Filter = NULL; // Disable filtering
//To_BlkIdx = NULL; // and block filtering //To_BlkIdx = NULL; // and block filtering
To_BlkFil = NULL; // and index filtering To_BlkFil = NULL; // and index filtering
Cardinality(g); // If called by create
RestoreNrec(); // May have been modified RestoreNrec(); // May have been modified
MaxSize = -1; // Size must be recalculated MaxSize = -1; // Size must be recalculated
Cardinal = -1; // as well as Cardinality Cardinal = -1; // as well as Cardinality
......
storage/connect/tabfmt.cpp
View file @ 128136cb
...@@ -406,7 +406,7 @@ bool CSVDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff) ...@@ -406,7 +406,7 @@ bool CSVDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
// Double check correctness of offset values // Double check correctness of offset values
if (Catfunc == FNC_NO) if (Catfunc == FNC_NO)
for (PCOLDEF cdp = To_Cols; cdp; cdp = cdp->GetNext()) for (PCOLDEF cdp = To_Cols; cdp; cdp = cdp->GetNext())
if (cdp->GetOffset() < 1) { if (cdp->GetOffset() < 1 && !cdp->IsSpecial()) {
strcpy(g->Message, MSG(BAD_OFFSET_VAL)); strcpy(g->Message, MSG(BAD_OFFSET_VAL));
return true; return true;
} // endif Offset } // endif Offset
......
storage/connect/tabutil.cpp
View file @ 128136cb
...@@ -313,7 +313,7 @@ bool PRXDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff) ...@@ -313,7 +313,7 @@ bool PRXDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
if (!(tab = GetStringCatInfo(g, "Tabname", NULL))) { if (!(tab = GetStringCatInfo(g, "Tabname", NULL))) {
if (!def) { if (!def) {
strcpy(g->Message, "Missing object table definition"); strcpy(g->Message, "Missing object table definition");
return TRUE; return true;
} else } else
tab = "Noname"; tab = "Noname";
...@@ -327,7 +327,7 @@ bool PRXDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff) ...@@ -327,7 +327,7 @@ bool PRXDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
Tablep = new(g) XTAB(tab, def); Tablep = new(g) XTAB(tab, def);
Tablep->SetQualifier(db); Tablep->SetQualifier(db);
return FALSE; return false;
} // end of DefineAM } // end of DefineAM
/***********************************************************************/ /***********************************************************************/
...@@ -352,6 +352,28 @@ TDBPRX::TDBPRX(PPRXDEF tdp) : TDBASE(tdp) ...@@ -352,6 +352,28 @@ TDBPRX::TDBPRX(PPRXDEF tdp) : TDBASE(tdp)
Tdbp = NULL; // The object table Tdbp = NULL; // The object table
} // end of TDBPRX constructor } // end of TDBPRX constructor
TDBPRX::TDBPRX(PGLOBAL g, PTDBPRX tdbp) : TDBASE(tdbp)
{
Tdbp = tdbp->Tdbp;
} // end of TDBPRX copy constructor
// Method
PTDB TDBPRX::CopyOne(PTABS t)
{
PTDB tp;
PPRXCOL cp1, cp2;
PGLOBAL g = t->G;
tp = new(g) TDBPRX(g, this);
for (cp1 = (PPRXCOL)Columns; cp1; cp1 = (PPRXCOL)cp1->GetNext()) {
cp2 = new(g) PRXCOL(cp1, tp); // Make a copy
NewPointer(t, cp1, cp2);
} // endfor cp1
return tp;
} // end of CopyOne
/***********************************************************************/ /***********************************************************************/
/* Get the PTDB of the sub-table. */ /* Get the PTDB of the sub-table. */
/***********************************************************************/ /***********************************************************************/
...@@ -423,7 +445,7 @@ PTDBASE TDBPRX::GetSubTable(PGLOBAL g, PTABLE tabp, bool b) ...@@ -423,7 +445,7 @@ PTDBASE TDBPRX::GetSubTable(PGLOBAL g, PTABLE tabp, bool b)
} else { } else {
// Sub-table is a CONNECT table // Sub-table is a CONNECT table
tabp->Next = To_Table; // For loop checking tabp->Next = To_Table; // For loop checking
tdbp = cat->GetTable(g, tabp); tdbp = cat->GetTable(g, tabp, Mode);
} // endif mysql } // endif mysql
if (s) { if (s) {
...@@ -456,11 +478,12 @@ bool TDBPRX::InitTable(PGLOBAL g) ...@@ -456,11 +478,12 @@ bool TDBPRX::InitTable(PGLOBAL g)
if (!Tdbp) { if (!Tdbp) {
// Get the table description block of this table // Get the table description block of this table
if (!(Tdbp = GetSubTable(g, ((PPRXDEF)To_Def)->Tablep))) if (!(Tdbp = GetSubTable(g, ((PPRXDEF)To_Def)->Tablep)))
return TRUE; return true;
Tdbp->SetMode(Mode);
} // endif Tdbp } // endif Tdbp
return FALSE; return false;
} // end of InitTable } // end of InitTable
/***********************************************************************/ /***********************************************************************/
...@@ -507,32 +530,51 @@ bool TDBPRX::OpenDB(PGLOBAL g) ...@@ -507,32 +530,51 @@ bool TDBPRX::OpenDB(PGLOBAL g)
return Tdbp->OpenDB(g); return Tdbp->OpenDB(g);
} // endif use } // endif use
if (Mode != MODE_READ) { if (Mode == MODE_DELETE) {
/*******************************************************************/ /*******************************************************************/
/* Currently XCOL tables cannot be modified. */ /* Currently XCOL tables cannot be modified. */
/*******************************************************************/ /*******************************************************************/
strcpy(g->Message, "PROXY tables are read only"); strcpy(g->Message, "No DELETE for PROXY tables");
return TRUE; return true;
} // endif Mode } // endif Mode
if (InitTable(g)) if (InitTable(g))
return TRUE; return true;
/*********************************************************************/ /*********************************************************************/
/* Check and initialize the subtable columns. */ /* Check and initialize the subtable columns. */
/*********************************************************************/ /*********************************************************************/
for (PCOL cp = Columns; cp; cp = cp->GetNext()) for (PCOL cp = Columns; cp; cp = cp->GetNext())
if (((PPRXCOL)cp)->Init(g)) if (((PPRXCOL)cp)->Init(g, Tdbp))
return TRUE; return true;
/*********************************************************************/
/* In Update mode, the updated column blocks must be distinct from */
/* the read column blocks. So make a copy of the TDB and allocate */
/* its column blocks in mode write (required by XML tables). */
/*********************************************************************/
if (Mode == MODE_UPDATE) {
PTDBASE utp;
if (!(utp= (PTDBASE)Tdbp->Duplicate(g))) {
sprintf(g->Message, MSG(INV_UPDT_TABLE), Tdbp->GetName());
return true;
} // endif tp
for (PCOL cp = To_SetCols; cp; cp = cp->GetNext())
if (((PPRXCOL)cp)->Init(g, utp))
return true;
} // endif MODE_UPDATE
/*********************************************************************/ /*********************************************************************/
/* Physically open the object table. */ /* Physically open the object table. */
/*********************************************************************/ /*********************************************************************/
if (Tdbp->OpenDB(g)) if (Tdbp->OpenDB(g))
return TRUE; return true;
Use = USE_OPEN; Use = USE_OPEN;
return FALSE; return false;
} // end of OpenDB } // end of OpenDB
/***********************************************************************/ /***********************************************************************/
...@@ -551,8 +593,9 @@ int TDBPRX::ReadDB(PGLOBAL g) ...@@ -551,8 +593,9 @@ int TDBPRX::ReadDB(PGLOBAL g)
/***********************************************************************/ /***********************************************************************/
int TDBPRX::WriteDB(PGLOBAL g) int TDBPRX::WriteDB(PGLOBAL g)
{ {
sprintf(g->Message, "%s tables are read only", To_Def->GetType()); //sprintf(g->Message, "%s tables are read only", To_Def->GetType());
return RC_FX; //return RC_FX;
return Tdbp->WriteDB(g);
} // end of WriteDB } // end of WriteDB
/***********************************************************************/ /***********************************************************************/
...@@ -594,7 +637,7 @@ PRXCOL::PRXCOL(PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i, PSZ am) ...@@ -594,7 +637,7 @@ PRXCOL::PRXCOL(PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i, PSZ am)
//strcpy(F_Date, cdp->F_Date); //strcpy(F_Date, cdp->F_Date);
Colp = NULL; Colp = NULL;
To_Val = NULL; To_Val = NULL;
Pseudo = FALSE; Pseudo = false;
Colnum = cdp->GetOffset(); // If columns are retrieved by number Colnum = cdp->GetOffset(); // If columns are retrieved by number
if (trace) if (trace)
...@@ -602,30 +645,49 @@ PRXCOL::PRXCOL(PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i, PSZ am) ...@@ -602,30 +645,49 @@ PRXCOL::PRXCOL(PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i, PSZ am)
} // end of PRXCOL constructor } // end of PRXCOL constructor
/***********************************************************************/
/* PRXCOL constructor used for copying columns. */
/* tdbp is the pointer to the new table descriptor. */
/***********************************************************************/
PRXCOL::PRXCOL(PRXCOL *col1, PTDB tdbp) : COLBLK(col1, tdbp)
{
Colp = col1->Colp;
To_Val = col1->To_Val;
Pseudo = col1->Pseudo;
Colnum = col1->Colnum;
} // end of PRXCOL copy constructor
/***********************************************************************/ /***********************************************************************/
/* PRXCOL initialization routine. */ /* PRXCOL initialization routine. */
/* Look for the matching column in the object table. */ /* Look for the matching column in the object table. */
/***********************************************************************/ /***********************************************************************/
bool PRXCOL::Init(PGLOBAL g) bool PRXCOL::Init(PGLOBAL g, PTDBASE tp)
{ {
PTDBPRX tdbp = (PTDBPRX)To_Tdb; if (!tp)
tp = ((PTDBPRX)To_Tdb)->Tdbp;
if (!(Colp = tdbp->Tdbp->ColDB(g, Name, 0)) && Colnum) if (!(Colp = tp->ColDB(g, Name, 0)) && Colnum)
Colp = tdbp->Tdbp->ColDB(g, NULL, Colnum); Colp = tp->ColDB(g, NULL, Colnum);
if (Colp) { if (Colp) {
MODE mode = To_Tdb->GetMode();
// May not have been done elsewhere // May not have been done elsewhere
Colp->InitValue(g); Colp->InitValue(g);
To_Val = Colp->GetValue(); To_Val = Colp->GetValue();
if (mode == MODE_INSERT || mode == MODE_UPDATE)
if (Colp->SetBuffer(g, Colp->GetValue(), true, false))
return true;
// this may be needed by some tables (which?) // this may be needed by some tables (which?)
Colp->SetColUse(ColUse); Colp->SetColUse(ColUse);
} else { } else {
sprintf(g->Message, MSG(NO_MATCHING_COL), Name, tdbp->Tdbp->GetName()); sprintf(g->Message, MSG(NO_MATCHING_COL), Name, tp->GetName());
return TRUE; return true;
} // endif Colp } // endif Colp
return FALSE; return false;
} // end of Init } // end of Init
/***********************************************************************/ /***********************************************************************/
...@@ -659,6 +721,21 @@ void PRXCOL::ReadColumn(PGLOBAL g) ...@@ -659,6 +721,21 @@ void PRXCOL::ReadColumn(PGLOBAL g)
} // end of ReadColumn } // end of ReadColumn
/***********************************************************************/
/* WriteColumn: */
/***********************************************************************/
void PRXCOL::WriteColumn(PGLOBAL g)
{
if (trace > 1)
htrc("PRX WriteColumn: name=%s\n", Name);
if (Colp) {
To_Val->SetValue_pval(Value);
Colp->WriteColumn(g);
} // endif Colp
} // end of WriteColumn
/* ---------------------------TDBTBC class --------------------------- */ /* ---------------------------TDBTBC class --------------------------- */
/***********************************************************************/ /***********************************************************************/
......
storage/connect/tabutil.h
View file @ 128136cb
...@@ -57,13 +57,17 @@ class DllExport TDBPRX : public TDBASE { ...@@ -57,13 +57,17 @@ class DllExport TDBPRX : public TDBASE {
friend class PRXDEF; friend class PRXDEF;
friend class PRXCOL; friend class PRXCOL;
public: public:
// Constructor // Constructors
TDBPRX(PPRXDEF tdp); TDBPRX(PPRXDEF tdp);
TDBPRX(PGLOBAL g, PTDBPRX tdbp);
// Implementation // Implementation
virtual AMT GetAmType(void) {return TYPE_AM_PRX;} virtual AMT GetAmType(void) {return TYPE_AM_PRX;}
virtual PTDB Duplicate(PGLOBAL g)
{return (PTDB)new(g) TDBPRX(g, this);}
// Methods // Methods
virtual PTDB CopyOne(PTABS t);
virtual int GetRecpos(void) {return Tdbp->GetRecpos();} virtual int GetRecpos(void) {return Tdbp->GetRecpos();}
virtual void ResetDB(void) {Tdbp->ResetDB();} virtual void ResetDB(void) {Tdbp->ResetDB();}
virtual int RowNumber(PGLOBAL g, bool b = FALSE); virtual int RowNumber(PGLOBAL g, bool b = FALSE);
...@@ -97,15 +101,19 @@ class DllExport PRXCOL : public COLBLK { ...@@ -97,15 +101,19 @@ class DllExport PRXCOL : public COLBLK {
public: public:
// Constructors // Constructors
PRXCOL(PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i, PSZ am = "PRX"); PRXCOL(PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i, PSZ am = "PRX");
PRXCOL(PRXCOL *colp, PTDB tdbp); // Constructor used in copy process
// Implementation // Implementation
virtual int GetAmType(void) {return TYPE_AM_PRX;} virtual int GetAmType(void) {return TYPE_AM_PRX;}
// Methods // Methods
virtual void Reset(void); virtual void Reset(void);
virtual bool IsSpecial(void) {return Pseudo;} virtual bool IsSpecial(void) {return Pseudo;}
virtual void ReadColumn(PGLOBAL g); virtual bool SetBuffer(PGLOBAL g, PVAL value, bool ok, bool check)
bool Init(PGLOBAL g); {return false;}
virtual void ReadColumn(PGLOBAL g);
virtual void WriteColumn(PGLOBAL g);
bool Init(PGLOBAL g, PTDBASE tp = NULL);
protected: protected:
// Default constructor not to be used // Default constructor not to be used
......
storage/connect/xindex.cpp
View file @ 128136cb
...@@ -2407,7 +2407,7 @@ void XFILE::Close(void) ...@@ -2407,7 +2407,7 @@ void XFILE::Close(void)
#if defined(XMAP) #if defined(XMAP)
if (Mmp && CloseMemMap(Mmp->memory, Mmp->lenL)) if (Mmp && CloseMemMap(Mmp->memory, Mmp->lenL))
printf("Error %d closing mapped index\n"); printf("Error closing mapped index\n");
#endif // XMAP #endif // XMAP
} // end of Close } // end of Close
...@@ -2574,8 +2574,8 @@ bool XHUGE::Open(PGLOBAL g, char *filename, int id, MODE mode) ...@@ -2574,8 +2574,8 @@ bool XHUGE::Open(PGLOBAL g, char *filename, int id, MODE mode)
} // endif Hfile } // endif Hfile
if (trace) if (trace)
htrc(" rc=%d oflag=%p mode=%d handle=%d fn=%s\n", htrc(" oflag=%p mode=%d handle=%d fn=%s\n",
rc, oflag, mode, Hfile, filename); oflag, mode, Hfile, filename);
if (mode == MODE_INSERT) { if (mode == MODE_INSERT) {
/*******************************************************************/ /*******************************************************************/
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7