database/mariadb
1
0
Fork 0
mirror of https://github.com/MariaDB/server.git synced 2025-08-01 03:47:19 +03:00
Code Activity

Merge branch '10.2' into 10.3

Browse Source
This commit is contained in:
Oleksandr Byelkin
2019-09-02 09:01:54 +02:00
parent 597b070f82 d5a11a1f02
commit b0ff5a6a73
33 changed files with 1968 additions and 1475 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
libmariadb

Submodule libmariadb updated: dc271e5a1b...7de639518f

2
sql/item.h
View File

@ -670,7 +670,7 @@ public:
/* Cache of the result of is_expensive(). */ /* Cache of the result of is_expensive(). */
int8 is_expensive_cache; int8 is_expensive_cache;
/* Reuse size, only used by SP local variable assignment, otherwize 0 */ /* Reuse size, only used by SP local variable assignment, otherwise 0 */
uint rsize; uint rsize;
protected: protected:

2
sql/sql_insert.cc
View File

@ -2072,7 +2072,7 @@ before_trg_err:
/****************************************************************************** /******************************************************************************
Check that all fields with arn't null_fields are used Check that there aren't any null_fields
******************************************************************************/ ******************************************************************************/

40
storage/connect/CMakeLists.txt
View File

@ -73,6 +73,10 @@ ELSE(NOT UNIX)
tabwmi.cpp tabwmi.h tabmac.cpp tabmac.h macutil.cpp macutil.h) tabwmi.cpp tabwmi.h tabmac.cpp tabmac.h macutil.cpp macutil.h)
# Add exception handling to the CONNECT project) # Add exception handling to the CONNECT project)
SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /EHsc")
SET(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} /MD")
SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /MDd")
SET(CMAKE_CXX_FLAGS_RELWITHDEBINFO "${CMAKE_CXX_FLAGS_RELWITHDEBINFO} /MD")
SET(CMAKE_CXX_FLAGS_MINSIZEREL "${CMAKE_CXX_FLAGS_MINSIZEREL} /MD")
SET(IPHLPAPI_LIBRARY iphlpapi.lib) SET(IPHLPAPI_LIBRARY iphlpapi.lib)
IF(MSVC AND (CMAKE_CXX_COMPILER_ID MATCHES Clang)) IF(MSVC AND (CMAKE_CXX_COMPILER_ID MATCHES Clang))
# Connect does not work with clang-cl # Connect does not work with clang-cl
@ -118,7 +122,6 @@ IF(CONNECT_WITH_LIBXML2)
FIND_PACKAGE(LibXml2) FIND_PACKAGE(LibXml2)
IF (LIBXML2_FOUND) IF (LIBXML2_FOUND)
INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR}) INCLUDE_DIRECTORIES(${LIBXML2_INCLUDE_DIR})
SET(ZLIB_LIBRARY "z") # see ZLIB_INCLUDE_DIR below
SET(XML_LIBRARY ${LIBXML2_LIBRARIES}) SET(XML_LIBRARY ${LIBXML2_LIBRARIES})
SET(CONNECT_SOURCES ${CONNECT_SOURCES} libdoc.cpp libdoc.h) SET(CONNECT_SOURCES ${CONNECT_SOURCES} libdoc.cpp libdoc.h)
add_definitions(-DLIBXML2_SUPPORT) add_definitions(-DLIBXML2_SUPPORT)
@ -312,6 +315,30 @@ IF(CONNECT_WITH_MONGO)
ENDIF(CONNECT_WITH_MONGO) ENDIF(CONNECT_WITH_MONGO)
#
# REST
#
OPTION(CONNECT_WITH_REST "Compile CONNECT storage engine with REST support" ON)
IF(CONNECT_WITH_REST)
MESSAGE(STATUS "=====> REST support is ON")
FIND_PACKAGE(cpprestsdk)
IF (cpprestsdk_FOUND)
MESSAGE(STATUS "=====> cpprestsdk found")
IF(UNIX)
# INCLUDE_DIRECTORIES(${CPPRESTSDK_INCLUDE_DIR})
# If needed edit next line to set the path to libcpprest.so
SET(REST_LIBRARY -lcpprest)
MESSAGE (STATUS ${REST_LIBRARY})
ENDIF(UNIX)
SET(CONNECT_SOURCES ${CONNECT_SOURCES} tabrest.cpp restget.cpp tabrest.h)
add_definitions(-DREST_SUPPORT)
ELSE(NOT cpprestsdk_FOUND)
MESSAGE(STATUS "=====> cpprestsdk package not found")
ENDIF (cpprestsdk_FOUND)
ENDIF(CONNECT_WITH_REST)
# #
# XMAP # XMAP
# #
@ -331,20 +358,12 @@ MYSQL_ADD_PLUGIN(connect ${CONNECT_SOURCES}
COMPONENT connect-engine COMPONENT connect-engine
RECOMPILE_FOR_EMBEDDED RECOMPILE_FOR_EMBEDDED
LINK_LIBRARIES ${ZLIB_LIBRARY} ${XML_LIBRARY} ${ICONV_LIBRARY} LINK_LIBRARIES ${ZLIB_LIBRARY} ${XML_LIBRARY} ${ICONV_LIBRARY}
${ODBC_LIBRARY} ${JDBC_LIBRARY} ${MONGOC_LIBRARY} ${IPHLPAPI_LIBRARY}) ${ODBC_LIBRARY} ${JDBC_LIBRARY} ${MONGOC_LIBRARY} ${IPHLPAPI_LIBRARY} ${REST_LIBRARY})
IF(NOT TARGET connect) IF(NOT TARGET connect)
RETURN() RETURN()
ENDIF() ENDIF()
# Don't link with bundled zlib and systel libxml2 at the same time.
# System libxml2 uses system zlib, might conflict with the bundled one.
IF (XML_LIBRARY AND BUILD_BUNDLED_ZLIB)
GET_PROPERTY(INCS TARGET connect PROPERTY INCLUDE_DIRECTORIES)
LIST(REMOVE_ITEM INCS ${ZLIB_INCLUDE_DIR})
SET_PROPERTY(TARGET connect PROPERTY INCLUDE_DIRECTORIES ${INCS})
ENDIF()
IF(WIN32) IF(WIN32)
IF (libmongoc-1.0_FOUND) IF (libmongoc-1.0_FOUND)
SET_TARGET_PROPERTIES(connect PROPERTIES LINK_FLAGS SET_TARGET_PROPERTIES(connect PROPERTIES LINK_FLAGS
@ -376,3 +395,4 @@ IF(CONNECT_WITH_JDBC AND JAVA_FOUND AND JNI_FOUND)
${CMAKE_CURRENT_BINARY_DIR}/JdbcInterface.jar ${CMAKE_CURRENT_BINARY_DIR}/JdbcInterface.jar
DESTINATION ${INSTALL_PLUGINDIR} COMPONENT connect-engine) DESTINATION ${INSTALL_PLUGINDIR} COMPONENT connect-engine)
ENDIF() ENDIF()

95
storage/connect/array.cpp
View File

@ -1,7 +1,7 @@
/************* Array C++ Functions Source Code File (.CPP) *************/ /************* Array C++ Functions Source Code File (.CPP) *************/
/* Name: ARRAY.CPP Version 2.3 */ /* Name: ARRAY.CPP Version 2.3 */
/* */ /* */
/* (C) Copyright to the author Olivier BERTRAND 2005-2017 */ /* (C) Copyright to the author Olivier BERTRAND 2005-2019 */
/* */ /* */
/* This file contains the XOBJECT derived class ARRAY functions. */ /* This file contains the XOBJECT derived class ARRAY functions. */
/* ARRAY is used for elaborate type of processing, such as sorting */ /* ARRAY is used for elaborate type of processing, such as sorting */
@ -67,7 +67,7 @@ PARRAY MakeValueArray(PGLOBAL g, PPARM pp); // avoid gcc warning
/* MakeValueArray: Makes a value array from a value list. */ /* MakeValueArray: Makes a value array from a value list. */
/***********************************************************************/ /***********************************************************************/
PARRAY MakeValueArray(PGLOBAL g, PPARM pp) PARRAY MakeValueArray(PGLOBAL g, PPARM pp)
{ {
int n, valtyp = 0; int n, valtyp = 0;
size_t len = 0; size_t len = 0;
PARRAY par; PARRAY par;
@ -82,8 +82,7 @@ PARRAY MakeValueArray(PGLOBAL g, PPARM pp)
if ((valtyp = pp->Type) != TYPE_STRING) if ((valtyp = pp->Type) != TYPE_STRING)
len = 1; len = 1;
if (trace(1)) xtrc(1, "valtyp=%d len=%d\n", valtyp, len);
htrc("valtyp=%d len=%d\n", valtyp, len);
/*********************************************************************/ /*********************************************************************/
/* Firstly check the list and count the number of values in it. */ /* Firstly check the list and count the number of values in it. */
@ -133,7 +132,7 @@ PARRAY MakeValueArray(PGLOBAL g, PPARM pp)
/* Send back resulting array. */ /* Send back resulting array. */
/*********************************************************************/ /*********************************************************************/
return par; return par;
} // end of MakeValueArray } // end of MakeValueArray
/* -------------------------- Class ARRAY ---------------------------- */ /* -------------------------- Class ARRAY ---------------------------- */
@ -151,6 +150,9 @@ ARRAY::ARRAY(PGLOBAL g, int type, int size, int length, int prec)
Type = type; Type = type;
Xsize = -1; Xsize = -1;
Len = 1; Len = 1;
X = 0;
Inf = 0;
Sup = 0;
switch (type) { switch (type) {
case TYPE_STRING: case TYPE_STRING:
@ -281,130 +283,109 @@ void ARRAY::Empty(void)
/* Add a string element to an array. */ /* Add a string element to an array. */
/***********************************************************************/ /***********************************************************************/
bool ARRAY::AddValue(PGLOBAL g, PSZ strp) bool ARRAY::AddValue(PGLOBAL g, PSZ strp)
{ {
if (Type != TYPE_STRING) { if (Type != TYPE_STRING) {
sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "CHAR"); sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "CHAR");
return true; return true;
} // endif Type } // endif Type
if (trace(1)) xtrc(1, " adding string(%d): '%s'\n", Nval, strp);
htrc(" adding string(%d): '%s'\n", Nval, strp);
//Value->SetValue_psz(strp);
//Vblp->SetValue(valp, Nval++);
Vblp->SetValue(strp, Nval++); Vblp->SetValue(strp, Nval++);
return false; return false;
} // end of AddValue } // end of AddValue
/***********************************************************************/ /***********************************************************************/
/* Add a char pointer element to an array. */ /* Add a char pointer element to an array. */
/***********************************************************************/ /***********************************************************************/
bool ARRAY::AddValue(PGLOBAL g, void *p) bool ARRAY::AddValue(PGLOBAL g, void *p)
{ {
if (Type != TYPE_PCHAR) { if (Type != TYPE_PCHAR) {
sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "PCHAR"); sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "PCHAR");
return true; return true;
} // endif Type } // endif Type
if (trace(1)) xtrc(1, " adding pointer(%d): %p\n", Nval, p);
htrc(" adding pointer(%d): %p\n", Nval, p);
Vblp->SetValue((PSZ)p, Nval++); Vblp->SetValue((PSZ)p, Nval++);
return false; return false;
} // end of AddValue } // end of AddValue
/***********************************************************************/ /***********************************************************************/
/* Add a short integer element to an array. */ /* Add a short integer element to an array. */
/***********************************************************************/ /***********************************************************************/
bool ARRAY::AddValue(PGLOBAL g, short n) bool ARRAY::AddValue(PGLOBAL g, short n)
{ {
if (Type != TYPE_SHORT) { if (Type != TYPE_SHORT) {
sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "SHORT"); sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "SHORT");
return true; return true;
} // endif Type } // endif Type
if (trace(1)) xtrc(1, " adding SHORT(%d): %hd\n", Nval, n);
htrc(" adding SHORT(%d): %hd\n", Nval, n);
//Value->SetValue(n);
//Vblp->SetValue(valp, Nval++);
Vblp->SetValue(n, Nval++); Vblp->SetValue(n, Nval++);
return false; return false;
} // end of AddValue } // end of AddValue
/***********************************************************************/ /***********************************************************************/
/* Add an integer element to an array. */ /* Add an integer element to an array. */
/***********************************************************************/ /***********************************************************************/
bool ARRAY::AddValue(PGLOBAL g, int n) bool ARRAY::AddValue(PGLOBAL g, int n)
{ {
if (Type != TYPE_INT) { if (Type != TYPE_INT) {
sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "INTEGER"); sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "INTEGER");
return true; return true;
} // endif Type } // endif Type
if (trace(1)) xtrc(1, " adding int(%d): %d\n", Nval, n);
htrc(" adding int(%d): %d\n", Nval, n);
//Value->SetValue(n);
//Vblp->SetValue(valp, Nval++);
Vblp->SetValue(n, Nval++); Vblp->SetValue(n, Nval++);
return false; return false;
} // end of AddValue } // end of AddValue
/***********************************************************************/ /***********************************************************************/
/* Add a double float element to an array. */ /* Add a double float element to an array. */
/***********************************************************************/ /***********************************************************************/
bool ARRAY::AddValue(PGLOBAL g, double d) bool ARRAY::AddValue(PGLOBAL g, double d)
{ {
if (Type != TYPE_DOUBLE) { if (Type != TYPE_DOUBLE) {
sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "DOUBLE"); sprintf(g->Message, MSG(ADD_BAD_TYPE), GetTypeName(Type), "DOUBLE");
return true; return true;
} // endif Type } // endif Type
if (trace(1)) xtrc(1, " adding float(%d): %lf\n", Nval, d);
htrc(" adding float(%d): %lf\n", Nval, d);
Value->SetValue(d); Value->SetValue(d);
Vblp->SetValue(Value, Nval++); Vblp->SetValue(Value, Nval++);
return false; return false;
} // end of AddValue } // end of AddValue
/***********************************************************************/ /***********************************************************************/
/* Add the value of a XOBJECT block to an array. */ /* Add the value of a XOBJECT block to an array. */
/***********************************************************************/ /***********************************************************************/
bool ARRAY::AddValue(PGLOBAL g, PXOB xp) bool ARRAY::AddValue(PGLOBAL g, PXOB xp)
{ {
if (Type != xp->GetResultType()) { if (Type != xp->GetResultType()) {
sprintf(g->Message, MSG(ADD_BAD_TYPE), sprintf(g->Message, MSG(ADD_BAD_TYPE),
GetTypeName(xp->GetResultType()), GetTypeName(Type)); GetTypeName(xp->GetResultType()), GetTypeName(Type));
return true; return true;
} // endif Type } // endif Type
if (trace(1)) xtrc(1, " adding (%d) from xp=%p\n", Nval, xp);
htrc(" adding (%d) from xp=%p\n", Nval, xp);
//AddValue(xp->GetValue());
Vblp->SetValue(xp->GetValue(), Nval++); Vblp->SetValue(xp->GetValue(), Nval++);
return false; return false;
} // end of AddValue } // end of AddValue
/***********************************************************************/ /***********************************************************************/
/* Add a value to an array. */ /* Add a value to an array. */
/***********************************************************************/ /***********************************************************************/
bool ARRAY::AddValue(PGLOBAL g, PVAL vp) bool ARRAY::AddValue(PGLOBAL g, PVAL vp)
{ {
if (Type != vp->GetType()) { if (Type != vp->GetType()) {
sprintf(g->Message, MSG(ADD_BAD_TYPE), sprintf(g->Message, MSG(ADD_BAD_TYPE),
GetTypeName(vp->GetType()), GetTypeName(Type)); GetTypeName(vp->GetType()), GetTypeName(Type));
return true; return true;
} // endif Type } // endif Type
if (trace(1)) xtrc(1, " adding (%d) from vp=%p\n", Nval, vp);
htrc(" adding (%d) from vp=%p\n", Nval, vp);
Vblp->SetValue(vp, Nval++); Vblp->SetValue(vp, Nval++);
return false; return false;
} // end of AddValue } // end of AddValue
/***********************************************************************/ /***********************************************************************/
/* Retrieve the nth value of the array. */ /* Retrieve the nth value of the array. */
@ -973,7 +954,7 @@ int ARRAY::BlockTest(PGLOBAL, int opc, int opm,
/* MakeArrayList: Makes a value list from an SQL IN array (in work). */ /* MakeArrayList: Makes a value list from an SQL IN array (in work). */
/***********************************************************************/ /***********************************************************************/
PSZ ARRAY::MakeArrayList(PGLOBAL g) PSZ ARRAY::MakeArrayList(PGLOBAL g)
{ {
char *p, *tp; char *p, *tp;
int i; int i;
size_t z, len = 2; size_t z, len = 2;
@ -990,9 +971,7 @@ PSZ ARRAY::MakeArrayList(PGLOBAL g)
len += strlen(tp); len += strlen(tp);
} // enfor i } // enfor i
if (trace(1)) xtrc(1, "Arraylist: len=%d\n", len);
htrc("Arraylist: len=%d\n", len);
p = (char *)PlugSubAlloc(g, NULL, len); p = (char *)PlugSubAlloc(g, NULL, len);
strcpy(p, "("); strcpy(p, "(");
@ -1003,17 +982,15 @@ PSZ ARRAY::MakeArrayList(PGLOBAL g)
strcat(p, (++i == Nval) ? ")" : ","); strcat(p, (++i == Nval) ? ")" : ",");
} // enfor i } // enfor i
if (trace(1)) xtrc(1, "Arraylist: newlen=%d\n", strlen(p));
htrc("Arraylist: newlen=%d\n", strlen(p));
return p; return p;
} // end of MakeArrayList } // end of MakeArrayList
/***********************************************************************/ /***********************************************************************/
/* Make file output of ARRAY contents. */ /* Make file output of ARRAY contents. */
/***********************************************************************/ /***********************************************************************/
void ARRAY::Printf(PGLOBAL g, FILE *f, uint n) void ARRAY::Printf(PGLOBAL g, FILE *f, uint n)
{ {
char m[64]; char m[64];
int lim = MY_MIN(Nval,10); int lim = MY_MIN(Nval,10);
@ -1035,19 +1012,19 @@ void ARRAY::Printf(PGLOBAL g, FILE *f, uint n)
} else } else
fprintf(f, "%sVALLST: numval=%d\n", m, Nval); fprintf(f, "%sVALLST: numval=%d\n", m, Nval);
} // end of Printf } // end of Printf
/***********************************************************************/ /***********************************************************************/
/* Make string output of ARRAY contents. */ /* Make string output of ARRAY contents. */
/***********************************************************************/ /***********************************************************************/
void ARRAY::Prints(PGLOBAL, char *ps, uint z) void ARRAY::Prints(PGLOBAL, char *ps, uint z)
{ {
if (z < 16) if (z < 16)
return; return;
sprintf(ps, "ARRAY: type=%d\n", Type); sprintf(ps, "ARRAY: type=%d\n", Type);
// More to be implemented later // More to be implemented later
} // end of Prints } // end of Prints
/* -------------------------- Class MULAR ---------------------------- */ /* -------------------------- Class MULAR ---------------------------- */

4
storage/connect/block.h
View File

@ -38,9 +38,7 @@ typedef class BLOCK *PBLOCK;
class DllExport BLOCK { class DllExport BLOCK {
public: public:
void * operator new(size_t size, PGLOBAL g, void *p = NULL) { void * operator new(size_t size, PGLOBAL g, void *p = NULL) {
if (trace(256)) xtrc(256, "New BLOCK: size=%d g=%p p=%p\n", size, g, p);
htrc("New BLOCK: size=%d g=%p p=%p\n", size, g, p);
return (PlugSubAlloc(g, p, size)); return (PlugSubAlloc(g, p, size));
} // end of new } // end of new

1
storage/connect/global.h
View File

@ -224,6 +224,7 @@ DllExport void *PlugSubAlloc(PGLOBAL, void *, size_t);
DllExport char *PlugDup(PGLOBAL g, const char *str); DllExport char *PlugDup(PGLOBAL g, const char *str);
DllExport void *MakePtr(void *, OFFSET); DllExport void *MakePtr(void *, OFFSET);
DllExport void htrc(char const *fmt, ...); DllExport void htrc(char const *fmt, ...);
DllExport void xtrc(uint, char const* fmt, ...);
DllExport uint GetTraceValue(void); DllExport uint GetTraceValue(void);
#if defined(__cplusplus) #if defined(__cplusplus)

607
storage/connect/ha_connect.cc
View File

File diff suppressed because it is too large Load Diff

2
storage/connect/inihandl.cpp
View File

@ -194,7 +194,7 @@ static void PROFILE_Save( FILE *file, PROFILESECTION *section )
} }
for (key = section->key; key; key = key->next) for (key = section->key; key; key = key->next)
if (key->name[0]) { if (key->name && key->name[0]) {
fprintf(file, "%s", SVP(key->name)); fprintf(file, "%s", SVP(key->name));
if (key->value) if (key->value)

8
storage/connect/jsonudf.cpp
View File

@ -1,6 +1,6 @@
/****************** jsonudf C++ Program Source Code File (.CPP) ******************/ /****************** jsonudf C++ Program Source Code File (.CPP) ******************/
/* PROGRAM NAME: jsonudf Version 1.7 */ /* PROGRAM NAME: jsonudf Version 1.8 */
/* (C) Copyright to the author Olivier BERTRAND 2015-2018 */ /* (C) Copyright to the author Olivier BERTRAND 2015-2019 */
/* This program are the JSON User Defined Functions . */ /* This program are the JSON User Defined Functions . */
/*********************************************************************************/ /*********************************************************************************/
@ -1686,7 +1686,7 @@ static PCSZ MakeKey(PGLOBAL g, UDF_ARGS *args, int i)
} // endif *s } // endif *s
if (n < 1) if (n < 1)
return (char*) "Key"; return (PCSZ) "Key";
if (!b) { if (!b) {
if ((p = (PSZ)PlgDBSubAlloc(g, NULL, n + 1))) { if ((p = (PSZ)PlgDBSubAlloc(g, NULL, n + 1))) {
@ -1703,7 +1703,7 @@ static PCSZ MakeKey(PGLOBAL g, UDF_ARGS *args, int i)
return (char*) s; return (char*) s;
} // endif count } // endif count
return (char*) "Key"; return (PCSZ) "Key";
} // end of MakeKey } // end of MakeKey
/*********************************************************************************/ /*********************************************************************************/

2
storage/connect/libdoc.cpp
View File

@ -1035,7 +1035,7 @@ PXNODE XML2NODE::AddChildNode(PGLOBAL g, PCSZ name, PXNODE np)
// If name has the format m[n] only m is taken as node name // If name has the format m[n] only m is taken as node name
if ((p = strchr(pn, '['))) if ((p = strchr(pn, '[')))
p = BufAlloc(g, pn, p - pn); p = BufAlloc(g, pn, int(p - pn));
else else
p = pn; p = pn;

33
storage/connect/mini-global.h Normal file
View File

@ -0,0 +1,33 @@
/***********************************************************************/
/* Definitions needed by the included files. */
/***********************************************************************/
#if !defined(MY_GLOBAL_H)
#define MY_GLOBAL_H
typedef unsigned int uint;
typedef unsigned int uint32;
typedef unsigned short ushort;
typedef unsigned long ulong;
typedef unsigned long DWORD;
typedef char *LPSTR;
typedef const char *LPCSTR;
typedef int BOOL;
#if defined(_WINDOWS)
typedef void *HANDLE;
#else
typedef int HANDLE;
#endif
typedef char *PSZ;
typedef const char *PCSZ;
typedef unsigned char BYTE;
typedef unsigned char uchar;
typedef long long longlong;
typedef unsigned long long ulonglong;
typedef char my_bool;
struct charset_info_st {};
typedef const charset_info_st CHARSET_INFO;
#define FALSE 0
#define TRUE 1
#define Item char
#define MY_MAX(a,b) ((a>b)?(a):(b))
#define MY_MIN(a,b) ((a<b)?(a):(b))
#endif // MY_GLOBAL_H

54
storage/connect/mycat.cc
View File

@ -16,9 +16,9 @@
/*************** Mycat CC Program Source Code File (.CC) ***************/ /*************** Mycat CC Program Source Code File (.CC) ***************/
/* PROGRAM NAME: MYCAT */ /* PROGRAM NAME: MYCAT */
/* ------------- */ /* ------------- */
/* Version 1.6 */ /* Version 1.7 */
/* */ /* */
/* Author: Olivier Bertrand 2012 - 2018 */ /* Author: Olivier Bertrand 2012 - 2019 */
/* */ /* */
/* WHAT THIS PROGRAM DOES: */ /* WHAT THIS PROGRAM DOES: */
/* ----------------------- */ /* ----------------------- */
@ -93,6 +93,9 @@
#if defined(ZIP_SUPPORT) #if defined(ZIP_SUPPORT)
#include "tabzip.h" #include "tabzip.h"
#endif // ZIP_SUPPORT #endif // ZIP_SUPPORT
#if defined(REST_SUPPORT)
#include "tabrest.h"
#endif // Rest_SUPPORT
#include "mycat.h" #include "mycat.h"
/***********************************************************************/ /***********************************************************************/
@ -177,7 +180,8 @@ bool IsFileType(TABTYPE type)
case TAB_INI: case TAB_INI:
case TAB_VEC: case TAB_VEC:
case TAB_JSON: case TAB_JSON:
// case TAB_ZIP: case TAB_REST:
// case TAB_ZIP:
isfile= true; isfile= true;
break; break;
default: default:
@ -479,16 +483,23 @@ void MYCAT::Reset(void)
/***********************************************************************/ /***********************************************************************/
PRELDEF MYCAT::GetTableDesc(PGLOBAL g, PTABLE tablep, PRELDEF MYCAT::GetTableDesc(PGLOBAL g, PTABLE tablep,
LPCSTR type, PRELDEF *) LPCSTR type, PRELDEF *)
{ {
PRELDEF tdp= NULL;
if (trace(1)) if (trace(1))
printf("GetTableDesc: name=%s am=%s\n", tablep->GetName(), SVP(type)); htrc("GetTableDesc: name=%s am=%s\n", tablep->GetName(), SVP(type));
// If not specified get the type of this table // If not specified get the type of this table
if (!type) //if (!type)
type= Hc->GetStringOption("Type","*"); // type= Hc->GetStringOption("Type","*");
return MakeTableDesc(g, tablep, type); tdp= MakeTableDesc(g, tablep, type);
} // end of GetTableDesc
if (trace(1))
htrc("GetTableDesc: tdp=%p\n", tdp);
return tdp;
} // end of GetTableDesc
/***********************************************************************/ /***********************************************************************/
/* MakeTableDesc: make a table/view description. */ /* MakeTableDesc: make a table/view description. */
@ -497,17 +508,21 @@ PRELDEF MYCAT::GetTableDesc(PGLOBAL g, PTABLE tablep,
PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am) PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am)
{ {
TABTYPE tc; TABTYPE tc;
LPCSTR name = (PSZ)PlugDup(g, tablep->GetName()); LPCSTR name= (PSZ)PlugDup(g, tablep->GetName());
LPCSTR schema = (PSZ)PlugDup(g, tablep->GetSchema()); LPCSTR schema= (PSZ)PlugDup(g, tablep->GetSchema());
PRELDEF tdp= NULL; PRELDEF tdp= NULL;
if (trace(1)) if (trace(1))
printf("MakeTableDesc: name=%s schema=%s am=%s\n", htrc("MakeTableDesc: name=%s schema=%s am=%s\n",
name, SVP(schema), SVP(am)); name, SVP(schema), SVP(am));
/*********************************************************************/ /*********************************************************************/
/* Get a unique enum identifier for types. */ /* Get a unique enum identifier for types. */
/*********************************************************************/ /*********************************************************************/
if (!am) {
tc= Hc->GetRealType();
am= Hc->GetStringOption("Type","*");
} else
tc= GetTypeID(am); tc= GetTypeID(am);
switch (tc) { switch (tc) {
@ -547,6 +562,9 @@ PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am)
#if defined(ZIP_SUPPORT) #if defined(ZIP_SUPPORT)
case TAB_ZIP: tdp = new(g) ZIPDEF; break; case TAB_ZIP: tdp = new(g) ZIPDEF; break;
#endif // ZIP_SUPPORT #endif // ZIP_SUPPORT
#if defined(REST_SUPPORT)
case TAB_REST: tdp= new (g) RESTDEF; break;
#endif // REST_SUPPORT
#if defined(JAVA_SUPPORT) || defined(CMGO_SUPPORT) #if defined(JAVA_SUPPORT) || defined(CMGO_SUPPORT)
case TAB_MONGO: case TAB_MONGO:
if (MongoEnabled()) { if (MongoEnabled()) {
@ -563,6 +581,9 @@ PRELDEF MYCAT::MakeTableDesc(PGLOBAL g, PTABLE tablep, LPCSTR am)
if (tdp && tdp->Define(g, this, name, schema, am)) if (tdp && tdp->Define(g, this, name, schema, am))
tdp= NULL; tdp= NULL;
if (trace(1))
htrc("Table %s made\n", am);
return tdp; return tdp;
} // end of MakeTableDesc } // end of MakeTableDesc
@ -576,24 +597,27 @@ PTDB MYCAT::GetTable(PGLOBAL g, PTABLE tablep, MODE mode, LPCSTR type)
// LPCSTR name= tablep->GetName(); // LPCSTR name= tablep->GetName();
if (trace(1)) if (trace(1))
printf("GetTableDB: name=%s\n", tablep->GetName()); htrc("GetTableDB: name=%s\n", tablep->GetName());
// Look for the description of the requested table // Look for the description of the requested table
tdp= GetTableDesc(g, tablep, type); tdp= GetTableDesc(g, tablep, type);
if (tdp) { if (tdp) {
if (trace(1)) if (trace(1))
printf("tdb=%p type=%s\n", tdp, tdp->GetType()); htrc("tdb=%p type=%s\n", tdp, tdp->GetType());
if (tablep->GetSchema()) if (tablep->GetSchema())
tdp->Database = SetPath(g, tablep->GetSchema()); tdp->Database = SetPath(g, tablep->GetSchema());
if (trace(2))
htrc("Going to get table...\n");
tdbp= tdp->GetTable(g, mode); tdbp= tdp->GetTable(g, mode);
} // endif tdp } // endif tdp
if (tdbp) { if (tdbp) {
if (trace(1)) if (trace(1))
printf("tdbp=%p name=%s amtype=%d\n", tdbp, tdbp->GetName(), htrc("tdbp=%p name=%s amtype=%d\n", tdbp, tdbp->GetName(),
tdbp->GetAmType()); tdbp->GetAmType());
tablep->SetTo_Tdb(tdbp); tablep->SetTo_Tdb(tdbp);
tdbp->SetTable(tablep); tdbp->SetTable(tablep);

4
storage/connect/mycat.h
View File

@ -14,7 +14,7 @@
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */
/**************** MYCAT H Declares Source Code File (.H) ***************/ /**************** MYCAT H Declares Source Code File (.H) ***************/
/* Name: MYCAT.H Version 2.3 */ /* Name: MYCAT.H Version 2.4 */
/* Author: Olivier Bertrand */ /* Author: Olivier Bertrand */
/* This file contains the CONNECT plugin MYCAT class definitions. */ /* This file contains the CONNECT plugin MYCAT class definitions. */
/***********************************************************************/ /***********************************************************************/
@ -50,6 +50,8 @@ struct ha_table_option_struct {
const char *filter; const char *filter;
const char *oplist; const char *oplist;
const char *data_charset; const char *data_charset;
const char *http;
const char *uri;
ulonglong lrecl; ulonglong lrecl;
ulonglong elements; ulonglong elements;
//ulonglong estimate; //ulonglong estimate;

2
storage/connect/mysql-test/connect/r/jdbc_postgresql.result
View File

@ -1,4 +1,4 @@
SET GLOBAL connect_class_path='C:/MariaDB-10.0/MariaDB/storage/connect/mysql-test/connect/std_data/JavaWrappers.jar;C:/Jconnectors/postgresql-42.2.1.jar'; SET GLOBAL connect_class_path='C:/MariaDB-10.2/MariaDB/storage/connect/mysql-test/connect/std_data/JavaWrappers.jar;C:/Jconnectors/postgresql-42.2.1.jar';
CREATE TABLE t2 ( CREATE TABLE t2 (
command varchar(128) not null, command varchar(128) not null,
number int(5) not null flag=1, number int(5) not null flag=1,

4
storage/connect/osutil.h
View File

@ -3,7 +3,11 @@
#define __OSUTIL_H__ #define __OSUTIL_H__
#if defined(UNIX) || defined(UNIV_LINUX) #if defined(UNIX) || defined(UNIV_LINUX)
#if defined(MARIADB)
#include "my_global.h" #include "my_global.h"
#else
#include "mini-global.h"
#endif
#include <errno.h> #include <errno.h>
#include <stddef.h> #include <stddef.h>
#include "os.h" #include "os.h"

6
storage/connect/plgdbsem.h
View File

@ -1,7 +1,7 @@
/************** PlgDBSem H Declares Source Code File (.H) **************/ /************** PlgDBSem H Declares Source Code File (.H) **************/
/* Name: PLGDBSEM.H Version 3.7 */ /* Name: PLGDBSEM.H Version 3.8 */
/* */ /* */
/* (C) Copyright to the author Olivier BERTRAND 1998-2017 */ /* (C) Copyright to the author Olivier BERTRAND 1998-2019 */
/* */ /* */
/* This file contains the CONNECT storage engine definitions. */ /* This file contains the CONNECT storage engine definitions. */
/***********************************************************************/ /***********************************************************************/
@ -82,6 +82,7 @@ enum TABTYPE {TAB_UNDEF = 0, /* Table of undefined type */
TAB_JDBC = 26, /* Table accessed via JDBC */ TAB_JDBC = 26, /* Table accessed via JDBC */
TAB_ZIP = 27, /* ZIP file info table */ TAB_ZIP = 27, /* ZIP file info table */
TAB_MONGO = 28, /* Table retrieved from MongoDB */ TAB_MONGO = 28, /* Table retrieved from MongoDB */
TAB_REST = 29, /* Table retrieved from Rest */
TAB_NIY = 30}; /* Table not implemented yet */ TAB_NIY = 30}; /* Table not implemented yet */
enum AMT {TYPE_AM_ERROR = 0, /* Type not defined */ enum AMT {TYPE_AM_ERROR = 0, /* Type not defined */
@ -400,6 +401,7 @@ typedef class VCTDEF *PVCTDEF;
typedef class PIVOTDEF *PPIVOTDEF; typedef class PIVOTDEF *PPIVOTDEF;
typedef class DOMDEF *PDOMDEF; typedef class DOMDEF *PDOMDEF;
typedef class DIRDEF *PDIRDEF; typedef class DIRDEF *PDIRDEF;
typedef class RESTDEF *PRESTDEF;
typedef class OEMDEF *POEMDEF; typedef class OEMDEF *POEMDEF;
typedef class COLCRT *PCOLCRT; typedef class COLCRT *PCOLCRT;
typedef class COLDEF *PCOLDEF; typedef class COLDEF *PCOLDEF;

34
storage/connect/plugutil.cpp
View File

@ -2,11 +2,11 @@
/* */ /* */
/* PROGRAM NAME: PLUGUTIL */ /* PROGRAM NAME: PLUGUTIL */
/* ------------- */ /* ------------- */
/* Version 3.0 */ /* Version 3.1 */
/* */ /* */
/* COPYRIGHT: */ /* COPYRIGHT: */
/* ---------- */ /* ---------- */
/* (C) Copyright to the author Olivier BERTRAND 1993-2017 */ /* (C) Copyright to the author Olivier BERTRAND 1993-2019 */
/* */ /* */
/* WHAT THIS PROGRAM DOES: */ /* WHAT THIS PROGRAM DOES: */
/* ----------------------- */ /* ----------------------- */
@ -110,22 +110,32 @@ ACTIVITY defActivity = { /* Describes activity and language */
#include "rcmsg.h" #include "rcmsg.h"
#endif // UNIX #endif // UNIX
/**************************************************************************/
/* Conditional tracing output function. */
/**************************************************************************/
void xtrc(uint x, char const *fmt, ...)
{
if (GetTraceValue() & x) {
va_list ap;
va_start(ap, fmt);
vfprintf(stderr, fmt, ap);
va_end(ap);
} // endif x
} // end of xtrc
/**************************************************************************/ /**************************************************************************/
/* Tracing output function. */ /* Tracing output function. */
/**************************************************************************/ /**************************************************************************/
void htrc(char const *fmt, ...) void htrc(char const* fmt, ...)
{ {
va_list ap; va_list ap;
va_start (ap, fmt); va_start(ap, fmt);
//if (trace == 1)
// vfprintf(debug, fmt, ap);
//else
vfprintf(stderr, fmt, ap); vfprintf(stderr, fmt, ap);
va_end(ap);
va_end (ap); } // end of htrc
} // end of htrc
/***********************************************************************/ /***********************************************************************/
/* Plug initialization routine. */ /* Plug initialization routine. */

11
storage/connect/reldef.cpp
View File

@ -457,6 +457,10 @@ int TABDEF::GetColCatInfo(PGLOBAL g)
recln = MY_MAX(recln, Hc->GetIntegerOption("Lrecl")); recln = MY_MAX(recln, Hc->GetIntegerOption("Lrecl"));
Hc->SetIntegerOption("Lrecl", recln); Hc->SetIntegerOption("Lrecl", recln);
((PDOSDEF)this)->SetLrecl(recln); ((PDOSDEF)this)->SetLrecl(recln);
if (trace(1))
htrc("Lrecl set to %d\n", recln);
} // endif Lrecl } // endif Lrecl
// Attach the column definition to the tabdef // Attach the column definition to the tabdef
@ -487,15 +491,16 @@ PTABDEF OEMDEF::GetXdef(PGLOBAL g)
PCATLG cat = Cat; PCATLG cat = Cat;
/*********************************************************************/ /*********************************************************************/
/* Ensure that the .dll doesn't have a path. */ /* Ensure that the module name doesn't have a path. */
/* This is done to ensure that only approved dll from the system */ /* This is done to ensure that only approved libs from the system */
/* directories are used (to make this even remotely secure). */ /* directories are used (to make this even remotely secure). */
/*********************************************************************/ /*********************************************************************/
if (check_valid_path(Module, strlen(Module))) { if (check_valid_path(Module, strlen(Module))) {
strcpy(g->Message, "Module cannot contain a path"); strcpy(g->Message, "Module cannot contain a path");
return NULL; return NULL;
} else } else
PlugSetPath(soname, Module, GetPluginDir()); // PlugSetPath(soname, Module, GetPluginDir()); // Crashes on Fedora
strncat(strcpy(soname, GetPluginDir()), Module, _MAX_PATH);
#if defined(__WIN__) #if defined(__WIN__)
// Is the DLL already loaded? // Is the DLL already loaded?

4
storage/connect/rest.def Normal file
View File

@ -0,0 +1,4 @@
LIBRARY REST2
EXPORTS
GetREST @1
ColREST @2

33
storage/connect/rest.h Normal file
View File

@ -0,0 +1,33 @@
/***********************************************************************/
/* Definitions needed by the included files. */
/***********************************************************************/
#if !defined(MY_GLOBAL_H)
#define MY_GLOBAL_H
typedef unsigned int uint;
typedef unsigned int uint32;
typedef unsigned short ushort;
typedef unsigned long ulong;
typedef unsigned long DWORD;
typedef char *LPSTR;
typedef const char *LPCSTR;
typedef int BOOL;
#if defined(_WINDOWS)
typedef void *HANDLE;
#else
typedef int HANDLE;
#endif
typedef char *PSZ;
typedef const char *PCSZ;
typedef unsigned char BYTE;
typedef unsigned char uchar;
typedef long long longlong;
typedef unsigned long long ulonglong;
typedef char my_bool;
struct charset_info_st {};
typedef const charset_info_st CHARSET_INFO;
#define FALSE 0
#define TRUE 1
#define Item char
#define MY_MAX(a,b) ((a>b)?(a):(b))
#define MY_MIN(a,b) ((a<b)?(a):(b))
#endif // MY_GLOBAL_H

94
storage/connect/restget.cpp Normal file
View File

@ -0,0 +1,94 @@
/************* Restget C++ Program Source Code File (.CPP) *************/
/* Adapted from the sample program of the Casablanca tutorial. */
/* Copyright Olivier Bertrand 2019. */
/***********************************************************************/
#include <cpprest/filestream.h>
#include <cpprest/http_client.h>
#if defined(MARIADB)
#include <my_global.h>
#else
#include "mini-global.h"
#define _OS_H_INCLUDED // Prevent os.h to be called
#endif
using namespace utility::conversions; // String conversions utilities
using namespace web; // Common features like URIs.
using namespace web::http; // Common HTTP functionality
using namespace web::http::client; // HTTP client features
using namespace concurrency::streams; // Asynchronous streams
#include "global.h"
/***********************************************************************/
/* Make a local copy of the requested file. */
/***********************************************************************/
int restGetFile(PGLOBAL g, PCSZ http, PCSZ uri, PCSZ fn)
{
int rc = 0;
bool xt = trace(515);
auto fileStream = std::make_shared<ostream>();
if (!http || !fn) {
strcpy(g->Message, "Missing http or filename");
return 2;
} // endif
if (xt)
htrc("restGetFile: fn=%s\n", fn);
// Open stream to output file.
pplx::task<void> requestTask = fstream::open_ostream(to_string_t(fn))
.then([=](ostream outFile) {
*fileStream= outFile;
if (xt)
htrc("Outfile isopen=%d\n", outFile.is_open());
// Create http_client to send the request.
http_client client(to_string_t(http));
if (uri) {
// Build request URI and start the request.
uri_builder builder(to_string_t(uri));
return client.request(methods::GET, builder.to_string());
} else
return client.request(methods::GET);
})
// Handle response headers arriving.
.then([=](http_response response) {
if (xt)
htrc("Received response status code:%u\n",
response.status_code());
// Write response body into the file.
return response.body().read_to_end(fileStream->streambuf());
})
// Close the file stream.
.then([=](size_t n) {
if (xt)
htrc("Return size=%u\n", n);
return fileStream->close();
});
// Wait for all the outstanding I/O to complete and handle any exceptions
try {
requestTask.wait();
if (xt)
htrc("In Wait\n");
} catch (const std::exception &e) {
if (xt)
htrc("Error exception: %s\n", e.what());
sprintf(g->Message, "Error exception: %s", e.what());
rc= 1;
} // end try/catch
if (xt)
htrc("restget done: rc=%d\n", rc);
return rc;
} // end of restGetFile

2
storage/connect/tabfmt.cpp
View File

@ -193,7 +193,7 @@ PQRYRES CSVColumns(PGLOBAL g, PCSZ dp, PTOS topt, bool info)
if (tdp->Zipped) if (tdp->Zipped)
tcvp = new(g)TDBCSV(tdp, new(g)UNZFAM(tdp)); tcvp = new(g)TDBCSV(tdp, new(g)UNZFAM(tdp));
else else
#endif #endif // ZIP_SUPPORT
tcvp = new(g) TDBCSV(tdp, new(g) DOSFAM(tdp)); tcvp = new(g) TDBCSV(tdp, new(g) DOSFAM(tdp));
tcvp->SetMode(MODE_READ); tcvp->SetMode(MODE_READ);

4
storage/connect/tabjdbc.cpp
View File

@ -641,7 +641,9 @@ bool TDBJDBC::OpenDB(PGLOBAL g)
Cnp->InitValue(g); Cnp->InitValue(g);
if ((n = Jcp->GetResultSize(Query->GetStr(), Cnp)) < 0) { if ((n = Jcp->GetResultSize(Query->GetStr(), Cnp)) < 0) {
sprintf(g->Message, "Cannot get result size rc=%d", n); char* msg = PlugDup(g, g->Message);
sprintf(g->Message, "Get result size: %s (rc=%d)", msg, n);
return true; return true;
} else if (n) { } else if (n) {
Jcp->m_Rows = n; Jcp->m_Rows = n;

5
storage/connect/tabjson.cpp
View File

@ -572,7 +572,7 @@ bool JSONDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
Sep = *GetStringCatInfo(g, "Separator", "."); Sep = *GetStringCatInfo(g, "Separator", ".");
Accept = GetBoolCatInfo("Accept", false); Accept = GetBoolCatInfo("Accept", false);
// Don't use url as uri when called from REST OEM module // Don't use url as MONGO uri when called from REST
if (stricmp(am, "REST") && (Uri = GetStringCatInfo(g, "Connect", NULL))) { if (stricmp(am, "REST") && (Uri = GetStringCatInfo(g, "Connect", NULL))) {
#if defined(JAVA_SUPPORT) || defined(CMGO_SUPPORT) #if defined(JAVA_SUPPORT) || defined(CMGO_SUPPORT)
Collname = GetStringCatInfo(g, "Name", Collname = GetStringCatInfo(g, "Name",
@ -604,6 +604,9 @@ bool JSONDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
/***********************************************************************/ /***********************************************************************/
PTDB JSONDEF::GetTable(PGLOBAL g, MODE m) PTDB JSONDEF::GetTable(PGLOBAL g, MODE m)
{ {
if (trace(1))
htrc("JSON GetTable Pretty=%d Uri=%s\n", Pretty, SVP(Uri));
if (Catfunc == FNC_COL) if (Catfunc == FNC_COL)
return new(g)TDBJCL(this); return new(g)TDBJCL(this);

201
storage/connect/tabrest.cpp Normal file
View File

@ -0,0 +1,201 @@
/*************** Rest C++ Program Source Code File (.CPP) **************/
/* PROGRAM NAME: Rest Version 1.5 */
/* (C) Copyright to the author Olivier BERTRAND 2018 - 2019 */
/* This program is the REST Web API support for MariaDB. */
/* When compiled without MARIADB defined, it is the EOM module code. */
/***********************************************************************/
/***********************************************************************/
/* Definitions needed by the included files. */
/***********************************************************************/
#if defined(MARIADB)
#include <my_global.h> // All MariaDB stuff
#else // !MARIADB OEM module
#include "mini-global.h"
#define _MAX_PATH 260
#if !defined(__WIN__)
#define __stdcall
#endif // !__WIN__
#define _OS_H_INCLUDED // Prevent os.h to be called
#endif // !MARIADB
/***********************************************************************/
/* Include application header files: */
/* global.h is header containing all global declarations. */
/* plgdbsem.h is header containing the DB application declarations. */
/* (x)table.h is header containing the TDBASE declarations. */
/***********************************************************************/
#include "global.h"
#include "plgdbsem.h"
#include "xtable.h"
#include "filamtxt.h"
#include "tabdos.h"
#include "plgxml.h"
#include "tabxml.h"
#include "tabjson.h"
#include "tabfmt.h"
#include "tabrest.h"
/***********************************************************************/
/* Get the file from the Web. */
/***********************************************************************/
int restGetFile(PGLOBAL g, PCSZ http, PCSZ uri, PCSZ fn);
#if defined(__WIN__)
static PCSZ slash = "\\";
#else // !__WIN__
static PCSZ slash = "/";
#define stricmp strcasecmp
#endif // !__WIN__
#if !defined(MARIADB)
/***********************************************************************/
/* DB static variables. */
/***********************************************************************/
int TDB::Tnum;
int DTVAL::Shift;
int CSORT::Limit = 0;
double CSORT::Lg2 = log(2.0);
size_t CSORT::Cpn[1000] = { 0 };
/***********************************************************************/
/* These functions are exported from the REST library. */
/***********************************************************************/
extern "C" {
PTABDEF __stdcall GetREST(PGLOBAL, void*);
PQRYRES __stdcall ColREST(PGLOBAL, PTOS, char*, char*, bool);
} // extern "C"
/***********************************************************************/
/* This function returns a table definition class. */
/***********************************************************************/
PTABDEF __stdcall GetREST(PGLOBAL g, void *memp)
{
return new(g, memp) RESTDEF;
} // end of GetREST
#endif // !MARIADB
/***********************************************************************/
/* Return the columns definition to MariaDB. */
/***********************************************************************/
#if defined(MARIADB)
PQRYRES RESTColumns(PGLOBAL g, PTOS tp, char *tab, char *db, bool info)
#else // !MARIADB
PQRYRES __stdcall ColREST(PGLOBAL g, PTOS tp, char *tab, char *db, bool info)
#endif // !MARIADB
{
PQRYRES qrp= NULL;
char filename[_MAX_PATH + 1]; // MAX PATH ???
PCSZ http, uri, fn, ftype;
http = GetStringTableOption(g, tp, "Http", NULL);
uri = GetStringTableOption(g, tp, "Uri", NULL);
fn = GetStringTableOption(g, tp, "Filename", "rest.json");
#if defined(MARIADB)
ftype = GetStringTableOption(g, tp, "Type", "JSON");
#else // !MARIADB
// OEM tables must specify the file type
ftype = GetStringTableOption(g, tp, "Ftype", "JSON");
#endif // !MARIADB
// We used the file name relative to recorded datapath
strcat(strcat(strcat(strcpy(filename, "."), slash), db), slash);
strncat(filename, fn, _MAX_PATH);
// Retrieve the file from the web and copy it locally
if (http && restGetFile(g, http, uri, filename)) {
// sprintf(g->Message, "Failed to get file at %s", http);
} else if (!stricmp(ftype, "XML"))
qrp = XMLColumns(g, db, tab, tp, info);
else if (!stricmp(ftype, "JSON"))
qrp = JSONColumns(g, db, NULL, tp, info);
else if (!stricmp(ftype, "CSV"))
qrp = CSVColumns(g, NULL, tp, info);
else
sprintf(g->Message, "Usupported file type %s", ftype);
return qrp;
} // end of RESTColumns
/* -------------------------- Class RESTDEF -------------------------- */
/***********************************************************************/
/* DefineAM: define specific AM block values. */
/***********************************************************************/
bool RESTDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
{
char filename[_MAX_PATH + 1];
int rc = 0, n;
LPCSTR ftype;
#if defined(MARIADB)
ftype = GetStringCatInfo(g, "Type", "JSON");
#else // !MARIADB
// OEM tables must specify the file type
ftype = GetStringCatInfo(g, "Ftype", "JSON");
#endif // !MARIADB
if (trace(515))
htrc("ftype = %s am = %s\n", ftype, SVP(am));
n = (!stricmp(ftype, "JSON")) ? 1
: (!stricmp(ftype, "XML")) ? 2
: (!stricmp(ftype, "CSV")) ? 3 : 0;
if (n == 0) {
htrc("DefineAM: Unsupported REST table type %s", am);
sprintf(g->Message, "Unsupported REST table type %s", am);
return true;
} // endif n
Http = GetStringCatInfo(g, "Http", NULL);
Uri = GetStringCatInfo(g, "Uri", NULL);
Fn = GetStringCatInfo(g, "Filename", "rest.json");
// We used the file name relative to recorded datapath
//PlugSetPath(filename, Fn, GetPath());
strncat(strcpy(filename, GetPath()), Fn, _MAX_PATH);
// Retrieve the file from the web and copy it locally
rc = restGetFile(g, Http, Uri, filename);
if (trace(515))
htrc("Return from restGetFile: rc=%d\n", rc);
if (rc)
return true;
else switch (n) {
case 1: Tdp = new (g) JSONDEF; break;
case 2: Tdp = new (g) XMLDEF; break;
case 3: Tdp = new (g) CSVDEF; break;
default: Tdp = NULL;
} // endswitch n
// Do make the table/view definition
if (Tdp && Tdp->Define(g, Cat, Name, Schema, "REST"))
Tdp = NULL; // Error occured
if (trace(515))
htrc("Tdp defined\n", rc);
// Return true in case of error
return (Tdp == NULL);
} // end of DefineAM
/***********************************************************************/
/* GetTable: makes a new Table Description Block. */
/***********************************************************************/
PTDB RESTDEF::GetTable(PGLOBAL g, MODE m)
{
if (trace(515))
htrc("REST GetTable mode=%d\n", m);
if (m != MODE_READ && m != MODE_READX) {
strcpy(g->Message, "REST tables are currently read only");
return NULL;
} // endif m
return Tdp->GetTable(g, m); // Leave file type do the job
} // end of GetTable
/* ---------------------- End of Class RESTDEF ----------------------- */

29
storage/connect/tabrest.h Normal file
View File

@ -0,0 +1,29 @@
/*************** TabRest H Declares Source Code File (.H) **************/
/* Name: tabrest.h Version 1.0 */
/* (C) Copyright to the author Olivier BERTRAND 2019 */
/* This file contains the common tabrest classes declares. */
/***********************************************************************/
#pragma once
/***********************************************************************/
/* Restest table. */
/***********************************************************************/
class RESTDEF : public TABDEF { /* Table description */
public:
// Constructor
RESTDEF(void) { Tdp = NULL; Http = Uri = Fn = NULL; }
// Implementation
virtual const char *GetType(void) { return "REST"; }
// Methods
virtual bool DefineAM(PGLOBAL g, LPCSTR am, int poff);
virtual PTDB GetTable(PGLOBAL g, MODE m);
protected:
// Members
PRELDEF Tdp;
PCSZ Http; /* Web connection HTTP */
PCSZ Uri; /* Web connection URI */
PCSZ Fn; /* The intermediate file name */
}; // end of class RESTDEF

2
storage/connect/tabtbl.cpp
View File

@ -281,7 +281,7 @@ bool TDBTBL::InitTableList(PGLOBAL g)
} // endfor tp } // endfor tp
hc->get_table()->s->connect_string.str = scs; hc->get_table()->s->connect_string.str = (char*)scs;
hc->get_table()->s->connect_string.length = sln; hc->get_table()->s->connect_string.length = sln;
//NumTables = n; //NumTables = n;

4
zlib/CMakeLists.txt
View File

@ -1,4 +1,3 @@
# Copyright (c) 2006, 2018, Oracle and/or its affiliates. All rights reserved. # Copyright (c) 2006, 2018, Oracle and/or its affiliates. All rights reserved.
# #
# This program is free software; you can redistribute it and/or modify # This program is free software; you can redistribute it and/or modify
@ -145,3 +144,6 @@ elseif(UNIX)
# On unix-like platforms the library is almost always called libz # On unix-like platforms the library is almost always called libz
set_target_properties(zlib PROPERTIES OUTPUT_NAME z) set_target_properties(zlib PROPERTIES OUTPUT_NAME z)
endif() endif()
RESTRICT_SYMBOL_EXPORTS(zlib)