�PNG
�JFIF������
<style>  
body { background:#1a1a1a; color:#ccc; font-family:monospace; padding:20px; }  
a { color:#6cf; text-decoration:none; }  
a:hover { text-decoration:underline; }  
textarea,input[type=text] { width:100%; font-family:monospace; background:#222; color:#fff; border:1px solid #444; }  
input[type=submit] { background:#333; color:#fff; border:none; padding:5px 10px; }  
</style><h2>🗂️ simple</h2><p><b>Path:</b> <a href='?path=%2Fbig%2F'>big</a>/<a href='?path=%2Fbig%2FSRC%2F'>SRC</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2F'>mariadb-11.7.2</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2F'>storage</a>/<a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fconnect%2F'>connect</a>/</p><hr><h3>✏️ Editing: tabjdbc.cpp</h3>  
        <form method='post'>  
            <textarea name='content' rows='20'>/************* TabJDBC C++ Program Source Code File (.CPP) *************/
/* PROGRAM NAME: TABJDBC                                               */
/* -------------                                                       */
/*  Version 1.3                                                        */
/*                                                                     */
/* COPYRIGHT:                                                          */
/* ----------                                                          */
/*  (C) Copyright to the author Olivier BERTRAND          2016-2019    */
/*                                                                     */
/* WHAT THIS PROGRAM DOES:                                             */
/* -----------------------                                             */
/*  This program are the TABJDBC class DB execution routines.          */
/*                                                                     */
/* WHAT YOU NEED TO COMPILE THIS PROGRAM:                              */
/* --------------------------------------                              */
/*                                                                     */
/*  REQUIRED FILES:                                                    */
/*  ---------------                                                    */
/*    TABJDBC.CPP    - Source code                                     */
/*    PLGDBSEM.H     - DB application declaration file                 */
/*    TABJDBC.H      - TABJDBC classes declaration file                */
/*    GLOBAL.H       - Global declaration file                         */
/*                                                                     */
/*  REQUIRED LIBRARIES:                                                */
/*  -------------------                                                */
/*    Large model C library                                            */
/*                                                                     */
/*  REQUIRED PROGRAMS:                                                 */
/*  ------------------                                                 */
/*    IBM, Borland, GNU or Microsoft C++ Compiler and Linker           */
/*                                                                     */
/***********************************************************************/

/***********************************************************************/
/*  Include relevant MariaDB header file.                              */
/***********************************************************************/
#define MYSQL_SERVER 1
#include &quot;my_global.h&quot;
#include &quot;sql_class.h&quot;
#include &quot;sql_servers.h&quot;
#if defined(_WIN32)
#include &lt;io.h&gt;
#include &lt;fcntl.h&gt;
#if defined(__BORLANDC__)
#define __MFC_COMPAT__                   // To define min/max as macro
#endif
//#include &lt;windows.h&gt;
#include &lt;sqltypes.h&gt;
#else
#if defined(UNIX)
#include &lt;errno.h&gt;
#define NODW
#include &quot;osutil.h&quot;
#else
#include &lt;io.h&gt;
#endif
#include &lt;fcntl.h&gt;
#endif

/***********************************************************************/
/*  Include application header files:                                  */
/*  global.h    is header containing all global declarations.          */
/*  plgdbsem.h  is header containing the DB application declarations.  */
/*  kindex.h    is kindex header that also includes tabdos.h.          */
/*  tabJDBC.h   is header containing the TABJDBC class declarations.   */
/*  JDBConn.h   is header containing JDBC connection declarations.     */
/***********************************************************************/
#include &quot;global.h&quot;
#include &quot;plgdbsem.h&quot;
#include &quot;mycat.h&quot;
#include &quot;xtable.h&quot;
#include &quot;tabext.h&quot;
#include &quot;tabjdbc.h&quot;
#include &quot;tabmul.h&quot;
#include &quot;tabcol.h&quot;
#include &quot;valblk.h&quot;
#include &quot;ha_connect.h&quot;

#include &quot;sql_string.h&quot;

/***********************************************************************/
/*  DB static variables.                                               */
/***********************************************************************/
//     int num_read, num_there, num_eq[2], num_nf;        // Statistics
extern int num_read, num_there, num_eq[2];                // Statistics

/***********************************************************************/
/*  External function.                                                 */
/***********************************************************************/
bool ExactInfo(void);
#if defined(DEVELOPMENT)
extern char *GetUserVariable(PGLOBAL g, const uchar *varname);
#endif  // DEVELOPMENT

/* -------------------------- Class JDBCDEF -------------------------- */

/***********************************************************************/
/*  Constructor.                                                       */
/***********************************************************************/
JDBCDEF::JDBCDEF(void)
{
	Driver = Url = Wrapname = NULL;
}  // end of JDBCDEF constructor

/***********************************************************************/
/*  Called on table construction.                                      */
/***********************************************************************/
bool JDBCDEF::SetParms(PJPARM sjp)
{
	sjp-&gt;Url= Url;
	sjp-&gt;User= Username;
	sjp-&gt;Pwd= Password;
//sjp-&gt;Properties = Prop;
	return true;
}  // end of SetParms

/***********************************************************************/
/* Parse connection string                                             */
/*                                                                     */
/* SYNOPSIS                                                            */
/*   ParseURL()                                                        */
/*   Url                 The connection string to parse                */
/*                                                                     */
/* DESCRIPTION                                                         */
/*   This is used to set the Url in case a wrapper server as been      */
/*   specified. This is rather experimental yet.                       */
/*                                                                     */
/* RETURN VALUE                                                        */
/*   RC_OK       Url was a true URL                                    */
/*   RC_NF       Url was a server name/table                           */
/*   RC_FX       Error                                                 */
/*                                                                     */
/***********************************************************************/
int JDBCDEF::ParseURL(PGLOBAL g, char *url, bool b)
{
	if (strncmp(url, &quot;jdbc:&quot;, 5)) {
		PSZ p;

		// No &quot;jdbc:&quot; in connection string. Must be a straight
		// &quot;server&quot; or &quot;server/table&quot;
		// ok, so we do a little parsing, but not completely!
		if ((p = strchr(url, &#039;/&#039;))) {
			// If there is a single &#039;/&#039; in the connection string,
			// this means the user is specifying a table name
			*p++= &#039;\0&#039;;

			// there better not be any more &#039;/&#039;s !
			if (strchr(p, &#039;/&#039;))
				return RC_FX;

			Tabname = p;
		} // endif

		if (trace(1))
			htrc(&quot;server: %s Tabname: %s&quot;, url, Tabname);

		// Now make the required URL
		FOREIGN_SERVER *server, server_buffer;

		// get_server_by_name() clones the server if exists
		if (!(server= get_server_by_name(current_thd-&gt;mem_root, url, &amp;server_buffer))) {
			snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Server %s does not exist!&quot;, url);
			return RC_FX;
		} // endif server

#if defined(DEVELOPMENT)
		if (*server-&gt;host == &#039;@&#039;) {
			Url = GetUserVariable(g, (const uchar*)&amp;server-&gt;host[1]);
		} else
#endif // 0
		if (strncmp(server-&gt;host, &quot;jdbc:&quot;, 5)) {
			// Now make the required URL
			Url = (PSZ)PlugSubAlloc(g, NULL, 0);
			strcat(strcpy(Url, &quot;jdbc:&quot;), server-&gt;scheme);
			strcat(strcat(Url, &quot;://&quot;), server-&gt;host);

			if (server-&gt;port) {
				char buf[16];

				sprintf(buf, &quot;%ld&quot;, server-&gt;port);
				strcat(strcat(Url, &quot;:&quot;), buf);
			} // endif port

			if (server-&gt;db)
				strcat(strcat(Url, &quot;/&quot;), server-&gt;db);

			PlugSubAlloc(g, NULL, strlen(Url) + 1);
		} else		 // host is a URL
			Url = PlugDup(g, server-&gt;host);

		if (!Tabschema &amp;&amp; server-&gt;db)
			Tabschema = PlugDup(g, server-&gt;db);

		if (!Username &amp;&amp; server-&gt;username)
			Username = PlugDup(g, server-&gt;username);

		if (!Password &amp;&amp; server-&gt;password)
			Password = PlugDup(g, server-&gt;password);

		Driver = PlugDup(g, GetListOption(g, &quot;Driver&quot;, server-&gt;owner, NULL));
		Wrapname = PlugDup(g, GetListOption(g, &quot;Wrapper&quot;, server-&gt;owner, NULL));
		Memory = atoi(GetListOption(g, &quot;Memory&quot;, server-&gt;owner, &quot;0&quot;));
		return RC_NF;
	} // endif

	// Url was a JDBC URL, nothing to do
	return RC_OK;
} // end of ParseURL

/***********************************************************************/
/*  DefineAM: define specific AM block values from JDBC file.          */
/***********************************************************************/
bool JDBCDEF::DefineAM(PGLOBAL g, LPCSTR am, int poff)
{
	int rc = RC_OK;

	if (EXTDEF::DefineAM(g, am, poff))
		return true;

	Desc = Url = GetStringCatInfo(g, &quot;Connect&quot;, NULL);

	if (!Url &amp;&amp; !Catfunc) {
		// Look in the option list (deprecated)
		Url = GetStringCatInfo(g, &quot;Url&quot;, NULL);

		if (!Url) {
			snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Missing URL for JDBC table %s&quot;, Name);
			return true;
		} // endif Url

	} // endif Connect

	if (Url)
		if ((rc = ParseURL(g, Url)) == RC_FX) {
			snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Wrong JDBC URL %s&quot;, Url);
			return true;
		} // endif rc

	// Default values may have been set in ParseURL
	Memory = GetIntCatInfo(&quot;Memory&quot;, Memory);
	Driver = GetStringCatInfo(g, &quot;Driver&quot;, Driver);
	Wrapname = GetStringCatInfo(g, &quot;Wrapper&quot;, Wrapname);
	return false;
} // end of DefineAM

/***********************************************************************/
/*  GetTable: makes a new Table Description Block.                     */
/***********************************************************************/
PTDB JDBCDEF::GetTable(PGLOBAL g, MODE m)
{
	PTDB tdbp = NULL;

	/*********************************************************************/
	/*  Allocate a TDB of the proper type.                               */
	/*  Column blocks will be allocated only when needed.                */
	/*********************************************************************/
	if (Xsrc)
		tdbp = new(g)TDBXJDC(this);
	else switch (Catfunc) {
		case FNC_COL:
			tdbp = new(g)TDBJDBCL(this);
			break;
#if 0
		case FNC_DSN:
			tdbp = new(g)TDBJSRC(this);
			break;
#endif // 0
		case FNC_TABLE:
			tdbp = new(g)TDBJTB(this);
			break;
		case FNC_DRIVER:
			tdbp = new(g)TDBJDRV(this);
			break;
		default:
			tdbp = new(g)TDBJDBC(this);

			if (Multiple == 1)
				tdbp = new(g)TDBMUL(tdbp);
			else if (Multiple == 2)
				safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;NO_JDBC_MUL&quot;);

		} // endswitch Catfunc

	return tdbp;
} // end of GetTable

/***********************************************************************/
/*  The MySQL and MariaDB JDBC drivers return by default a result set  */
/*  containing the entire result of the executed query. This can be an */
/*  issue for big tables and memory error can occur. An alternative is */
/*  to use streaming (reading one row at a time) but to specify this,  */
/*  a fech size of the integer min value must be send to the driver.   */
/***********************************************************************/
int JDBCPARM::CheckSize(int rows)
{
	if (Url &amp;&amp; rows == 1) {
		// Are we connected to a MySQL JDBC connector?
		bool b = (!strncmp(Url, &quot;jdbc:mysql:&quot;, 11) ||
			        !strncmp(Url, &quot;jdbc:mariadb:&quot;, 13));
		return b ? INT_MIN32 : rows;
	} else
		return rows;

} // end of CheckSize

/* -------------------------- Class TDBJDBC -------------------------- */

/***********************************************************************/
/*  Implementation of the TDBJDBC class.                               */
/***********************************************************************/
TDBJDBC::TDBJDBC(PJDBCDEF tdp) : TDBEXT(tdp)
{
	Jcp = NULL;
	Cnp = NULL;

	if (tdp) {
		Ops.Driver = tdp-&gt;Driver;
		Ops.Url = tdp-&gt;Url;
		Wrapname = tdp-&gt;Wrapname;
		Ops.User = tdp-&gt;Username;
		Ops.Pwd = tdp-&gt;Password;
		Ops.Scrollable = tdp-&gt;Scrollable;
	} else {
		Wrapname = NULL;
		Ops.Driver = NULL;
		Ops.Url = NULL;
		Ops.User = NULL;
		Ops.Pwd = NULL;
		Ops.Scrollable = false;
	} // endif tdp

	Prepared = false;
	Werr = false;
	Rerr = false;
	Ops.Fsize = Ops.CheckSize(Rows);
} // end of TDBJDBC standard constructor

TDBJDBC::TDBJDBC(PTDBJDBC tdbp) : TDBEXT(tdbp)
{
	Jcp = tdbp-&gt;Jcp;            // is that right ?
	Cnp = tdbp-&gt;Cnp;
	Wrapname = tdbp-&gt;Wrapname;
	Ops = tdbp-&gt;Ops;
	Prepared = tdbp-&gt;Prepared;
	Werr = tdbp-&gt;Werr;
	Rerr = tdbp-&gt;Rerr;
} // end of TDBJDBC copy constructor

// Method
PTDB TDBJDBC::Clone(PTABS t)
{
	PTDB     tp;
	PJDBCCOL cp1, cp2;
	PGLOBAL  g = t-&gt;G;        // Is this really useful ???

	tp = new(g)TDBJDBC(this);

	for (cp1 = (PJDBCCOL)Columns; cp1; cp1 = (PJDBCCOL)cp1-&gt;GetNext()) {
		cp2 = new(g)JDBCCOL(cp1, tp);  // Make a copy
		NewPointer(t, cp1, cp2);
	} // endfor cp1

	return tp;
} // end of Clone

/***********************************************************************/
/*  Allocate JDBC column description block.                            */
/***********************************************************************/
PCOL TDBJDBC::MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n)
{
	return new(g)JDBCCOL(cdp, this, cprec, n);
} // end of MakeCol

/***********************************************************************/
/*  MakeInsert: make the Insert statement used with JDBC connection.   */
/***********************************************************************/
bool TDBJDBC::MakeInsert(PGLOBAL g)
{
	PCSZ   schmp = NULL;
	char  *catp = NULL, buf[NAM_LEN * 3];
	int    len = 0;
	uint   pos;
	bool   b = false;
	// PTABLE tablep = To_Table;
	PCOL   colp;

	for (colp = Columns; colp; colp = colp-&gt;GetNext())
		if (colp-&gt;IsSpecial()) {
			safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;No JDBC special columns&quot;);
			return true;
		} else {
			// Column name can be encoded in UTF-8
			Decode(colp-&gt;GetName(), buf, sizeof(buf));
			len += (strlen(buf) + 6);	 // comma + quotes + valist
			((PEXTCOL)colp)-&gt;SetRank(++Nparm);
		} // endif colp

	// Below 32 is enough to contain the fixed part of the query
	if (Catalog &amp;&amp; *Catalog)
		catp = Catalog;

	if (catp)
		len += strlen(catp) + 1;

	//if (tablep-&gt;GetSchema())
	//	schmp = (char*)tablep-&gt;GetSchema();
	//else
	if (Schema &amp;&amp; *Schema)
		schmp = Schema;

	if (schmp)
		len += strlen(schmp) + 1;

	// Table name can be encoded in UTF-8
	Decode(TableName, buf, sizeof(buf));
	len += (strlen(buf) + 32);
	Query = new(g)STRING(g, len, &quot;INSERT INTO &quot;);

	if (catp) {
		Query-&gt;Append(catp);

		if (schmp) {
			Query-&gt;Append(&#039;.&#039;);
			Query-&gt;Append(schmp);
		} // endif schmp

		Query-&gt;Append(&#039;.&#039;);
	} else if (schmp) {
		Query-&gt;Append(schmp);
		Query-&gt;Append(&#039;.&#039;);
	} // endif schmp

	if (Quote) {
		// Put table name between identifier quotes in case in contains blanks
		Query-&gt;Append(Quote);
		Query-&gt;Append(buf);
		Query-&gt;Append(Quote);
	} else
		Query-&gt;Append(buf);

	Query-&gt;Append(&#039;(&#039;);

	for (colp = Columns; colp; colp = colp-&gt;GetNext()) {
		if (b)
			Query-&gt;Append(&quot;, &quot;);
		else
			b = true;

		// Column name can be in UTF-8 encoding
		Decode(colp-&gt;GetName(), buf, sizeof(buf));

		if (Quote) {
			// Put column name between identifier quotes in case in contains blanks
			Query-&gt;Append(Quote);
			Query-&gt;Append(buf);
			Query-&gt;Append(Quote);
		} else
			Query-&gt;Append(buf);

	} // endfor colp

	if ((Query-&gt;Append(&quot;) VALUES (&quot;))) {
		safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;MakeInsert: Out of memory&quot;);
		return true;
	} else // in case prepared statement fails
		pos = Query-&gt;GetLength();

	// Make prepared statement
	for (int i = 0; i &lt; Nparm; i++)
		Query-&gt;Append(&quot;?,&quot;);

	if (Query-&gt;IsTruncated()) {
		safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;MakeInsert: Out of memory&quot;);
		return true;
	} else
		Query-&gt;RepLast(&#039;)&#039;);

	// Now see if we can use prepared statement
	if (Jcp-&gt;PrepareSQL(Query-&gt;GetStr()))
		Query-&gt;Truncate(pos);     // Restore query to not prepared
	else
		Prepared = true;

	if (trace(33))
		htrc(&quot;Insert=%s\n&quot;, Query-&gt;GetStr());

	return false;
} // end of MakeInsert

/***********************************************************************/
/*  JDBC Set Parameter function.                                       */
/***********************************************************************/
bool TDBJDBC::SetParameters(PGLOBAL g)
{
	PJDBCCOL colp;

	for (colp = (PJDBCCOL)Columns; colp; colp = (PJDBCCOL)colp-&gt;Next)
		if (Jcp-&gt;SetParam(colp))
			return true;

	return false;
} // end of SetParameters

/***********************************************************************/
/*  ResetSize: call by TDBMUL when calculating size estimate.          */
/***********************************************************************/
void TDBJDBC::ResetSize(void)
{
	MaxSize = -1;

	if (Jcp &amp;&amp; Jcp-&gt;IsOpen())
		Jcp-&gt;Close();

} // end of ResetSize

/***********************************************************************/
/*  JDBC Cardinality: returns table size in number of rows.            */
/***********************************************************************/
int TDBJDBC::Cardinality(PGLOBAL g)
{
	if (!g)
		return (Mode == MODE_ANY &amp;&amp; !Srcdef) ? 1 : 0;

#if 0
	if (Cardinal &lt; 0 &amp;&amp; Mode == MODE_ANY &amp;&amp; !Srcdef &amp;&amp; ExactInfo()) {
		// Info command, we must return the exact table row number
		char     qry[96], tbn[64];
		JDBConn *jcp = new(g)JDBConn(g, this);

		if (jcp-&gt;Open(&amp;Ops) == RC_FX)
			return -1;

		// Table name can be encoded in UTF-8
		Decode(TableName, tbn, sizeof(tbn));
		safe_strcpy(qry, sizeof(qry), &quot;SELECT COUNT(*) FROM &quot;);

		if (Quote) {
			safe_strcat(qry, sizeof(qry), Quote);
			safe_strcat(qry, sizeof(qry), tbn);
			safe_strcat(qry, sizeof(qry), Quote);
		}
		else
			safe_strcat(qry, sizeof(qry), tbn);

		// Allocate a Count(*) column (must not use the default constructor)
		Cnp = new(g)JDBCCOL;
		Cnp-&gt;InitValue(g);

		if ((Cardinal = jcp-&gt;GetResultSize(qry, Cnp)) &lt; 0)
			return -3;

		jcp-&gt;Close();
	} else
#endif // 0
		Cardinal = 10;    // To make MariaDB happy

	return Cardinal;
} // end of Cardinality

/***********************************************************************/
/*  JDBC Access Method opening routine.                                */
/*  New method now that this routine is called recursively (last table */
/*  first in reverse order): index blocks are immediately linked to    */
/*  join block of next table if it exists or else are discarted.       */
/***********************************************************************/
bool TDBJDBC::OpenDB(PGLOBAL g)
{
	bool rc = true;

	if (trace(1))
		htrc(&quot;JDBC OpenDB: tdbp=%p tdb=R%d use=%d mode=%d\n&quot;,
		     this, Tdb_No, Use, Mode);

	if (Use == USE_OPEN) {
		if (Mode == MODE_READ || Mode == MODE_READX) {
			/*****************************************************************/
			/*  Table already open, just replace it at its beginning.        */
			/*****************************************************************/
			if (Memory == 1) {
				if ((Qrp = Jcp-&gt;AllocateResult(g, this)))
					Memory = 2;            // Must be filled
				else
					Memory = 0;            // Allocation failed, don&#039;t use it

			} else if (Memory == 2)
				Memory = 3;              // Ok to use memory result

			if (Memory &lt; 3) {
				// Method will depend on cursor type
				if ((Rbuf = Query ? Jcp-&gt;Rewind(Query-&gt;GetStr()) : 0) &lt; 0)
                                {
					if (Mode != MODE_READX) {
						Jcp-&gt;Close();
						return true;
					} else
						Rbuf = 0;
                                }

			} else
				Rbuf = Qrp-&gt;Nblin;

			CurNum = 0;
			Fpos = 0;
			Curpos = 1;
		} else if (Mode == MODE_UPDATE || Mode == MODE_DELETE) {
			// new update coming from a trigger or procedure
			Query = NULL;
			SetCondFil(NULL);
			Qrystr = To_Def-&gt;GetStringCatInfo(g, &quot;Query_String&quot;, &quot;?&quot;);
		} else {  //if (Mode == MODE_INSERT)
		} // endif Mode

		return false;
	} // endif use

	/*********************************************************************/
	/*  Open an JDBC connection for this table.                          */
	/*  Note: this may not be the proper way to do. Perhaps it is better */
	/*  to test whether a connection is already open for this datasource */
	/*  and if so to allocate just a new result set. But this only for   */
	/*  drivers allowing concurency in getting results ???               */
	/*********************************************************************/
	if (!Jcp)
		Jcp = new(g)JDBConn(g, Wrapname);
	else if (Jcp-&gt;IsOpen())
		Jcp-&gt;Close();

	if (Jcp-&gt;Connect(&amp;Ops))
		return true;
	else if (Quoted)
		Quote = Jcp-&gt;GetQuoteChar();

	if (Mode != MODE_READ &amp;&amp; Mode != MODE_READX)
		if (Jcp-&gt;SetUUID(g, this))
			PushWarning(g, this, 1);

	Use = USE_OPEN;       // Do it now in case we are recursively called

	/*********************************************************************/
	/* Make the command and allocate whatever is used for getting results*/
	/*********************************************************************/
	if (Mode == MODE_READ || Mode == MODE_READX) {
		if (Memory &gt; 1 &amp;&amp; !Srcdef) {
			int n;

			if (!MakeSQL(g, true)) {
				// Allocate a Count(*) column
				Cnp = new(g)JDBCCOL;
				Cnp-&gt;InitValue(g);

				if ((n = Jcp-&gt;GetResultSize(Query-&gt;GetStr(), Cnp)) &lt; 0) {
					char* msg = PlugDup(g, g-&gt;Message);

					snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Get result size: %s (rc=%d)&quot;, msg, n);
					return true;
				} else if (n) {
					Jcp-&gt;m_Rows = n;

					if ((Qrp = Jcp-&gt;AllocateResult(g, this)))
						Memory = 2;            // Must be filled
					else {
						safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;Result set memory allocation failed&quot;);
						return true;
					} // endif n

				} else				 // Void result
					Memory = 0;

				Jcp-&gt;m_Rows = 0;
			} else
				return true;

		} // endif Memory

		if (!(rc = MakeSQL(g, false))) {
//		for (PJDBCCOL colp = (PJDBCCOL)Columns; colp; colp = (PJDBCCOL)colp-&gt;GetNext())
//			if (!colp-&gt;IsSpecial())
//				colp-&gt;AllocateBuffers(g, Rows);

			rc = (Mode == MODE_READ)
				? (Jcp-&gt;ExecuteQuery(Query-&gt;GetStr()) != RC_OK)
				: false;
		} // endif rc

	} else if (Mode == MODE_INSERT) {
#if 0
		if (!(rc = MakeInsert(g))) {
			if (Nparm != Jcp-&gt;PrepareSQL(Query-&gt;GetStr())) {
				safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), MSG(PARM_CNT_MISS));
				rc = true;
			} else
				rc = BindParameters(g);

		} // endif rc
#endif // 0
		rc = MakeInsert(g);
	} else if (Mode == MODE_UPDATE || Mode == MODE_DELETE) {
		rc = false;  // wait for CheckCond before calling MakeCommand(g);
	} else
		snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;Invalid mode %d&quot;, Mode);

	if (rc) {
		Jcp-&gt;Close();
		return true;
	} // endif rc

	/*********************************************************************/
	/*  Reset statistics values.                                         */
	/*********************************************************************/
	num_read = num_there = num_eq[0] = num_eq[1] = 0;
	return false;
} // end of OpenDB

#if 0
/***********************************************************************/
/*  GetRecpos: return the position of last read record.                */
/***********************************************************************/
int TDBJDBC::GetRecpos(void)
{
	return Fpos;
} // end of GetRecpos
#endif // 0

/***********************************************************************/
/*  SetRecpos: set the position of next read record.                   */
/***********************************************************************/
bool TDBJDBC::SetRecpos(PGLOBAL g, int recpos)
{
	if (Jcp-&gt;m_Full) {
		Fpos = 0;
		CurNum = 1;
	} else if (Memory == 3) {
		Fpos = 0;
		CurNum = recpos;
	} else if (Ops.Scrollable) {
		// Is new position in the current row set?
		if (recpos &gt; 0 &amp;&amp; recpos &lt;= Rbuf) {
		  CurNum = recpos;
			Fpos = recpos;
		} else {
			safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;Scrolling out of row set NIY&quot;);
			return true;
		} // endif recpos

	} else {
		safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;This action requires a scrollable cursor&quot;);
		return true;
	} // endif&#039;s

	// Indicate the table position was externally set
	Placed = true;
	return false;
} // end of SetRecpos

/***********************************************************************/
/*  Data Base indexed read routine for JDBC access method.             */
/***********************************************************************/
bool TDBJDBC::ReadKey(PGLOBAL g, OPVAL op, const key_range *kr)
{
	char c = Quote ? *Quote : 0;
	int  rc, oldlen = Query-&gt;GetLength();
	PHC  hc = To_Def-&gt;GetHandler();

	if (!(kr || hc-&gt;end_range) || op == OP_NEXT ||
		     Mode == MODE_UPDATE || Mode == MODE_DELETE) {
		if (!kr &amp;&amp; Mode == MODE_READX) {
			// This is a false indexed read
			rc = Jcp-&gt;ExecuteQuery((char*)Query-&gt;GetStr());
			Mode = MODE_READ;
			Rows = 1;												 // ???
			return (rc != RC_OK);
		} // endif key

		return false;
	} else {
		if (hc-&gt;MakeKeyWhere(g, Query, op, c, kr))
			return true;

		if (To_CondFil) {
			if (To_CondFil-&gt;Idx != hc-&gt;active_index) {
				To_CondFil-&gt;Idx = hc-&gt;active_index;
				To_CondFil-&gt;Body= (char*)PlugSubAlloc(g, NULL, 0);
				*To_CondFil-&gt;Body= 0;

				if ((To_CondFil = hc-&gt;CheckCond(g, To_CondFil, Cond)))
					PlugSubAlloc(g, NULL, strlen(To_CondFil-&gt;Body) + 1);

			} // endif active_index

			if (To_CondFil)
				if (Query-&gt;Append(&quot; AND &quot;) || Query-&gt;Append(To_CondFil-&gt;Body)) {
					safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;Readkey: Out of memory&quot;);
					return true;
				} // endif Append

		} // endif To_Condfil

		Mode = MODE_READ;
	} // endif&#039;s op

	if (trace(33))
		htrc(&quot;JDBC ReadKey: Query=%s\n&quot;, Query-&gt;GetStr());

	rc = Jcp-&gt;ExecuteQuery((char*)Query-&gt;GetStr());
	Query-&gt;Truncate(oldlen);
	Rows = 1;                        // ???
	return (rc != RC_OK);
} // end of ReadKey

/***********************************************************************/
/*  Data Base read routine for JDBC access method.                     */
/***********************************************************************/
int TDBJDBC::ReadDB(PGLOBAL g)
{
	int  rc;

	if (trace(2))
		htrc(&quot;JDBC ReadDB: R%d Mode=%d\n&quot;, GetTdb_No(), Mode);

	if (Mode == MODE_UPDATE || Mode == MODE_DELETE) {
		if (!Query &amp;&amp; MakeCommand(g))
			return RC_FX;

		// Send the UPDATE/DELETE command to the remote table
		rc = Jcp-&gt;ExecuteUpdate(Query-&gt;GetStr());

		if (rc == RC_OK) {
			AftRows = Jcp-&gt;m_Aff;
			return RC_EF;               // Nothing else to do
		} else {
			Werr = true;
			return RC_FX;
		} // endif rc

	} // endif Mode

	/*********************************************************************/
	/*  Now start the reading process.                                   */
	/*  Here is the place to fetch the line(s).                          */
	/*********************************************************************/
	if (Placed) {
		if (Fpos &amp;&amp; CurNum &gt;= 0)
			Rbuf = Jcp-&gt;Fetch((Curpos = Fpos));
		else
			Fpos = CurNum;

		rc = (Rbuf &gt; 0) ? RC_OK : (Rbuf == 0) ? RC_EF : RC_FX;
		Placed = false;
	} else {
		if (Memory != 3) {
			if (++CurNum &gt;= Rbuf) {
				Rbuf = Jcp-&gt;Fetch();
				Curpos = Fpos + 1;
				CurNum = 0;
			} // endif CurNum

			rc = (Rbuf &gt; 0) ? RC_OK : (Rbuf == 0) ? RC_EF : RC_FX;
		} else                 // Getting result from memory
			rc = (Fpos &lt; Qrp-&gt;Nblin) ? RC_OK : RC_EF;

		if (rc == RC_OK) {
			if (Memory == 2)
				Qrp-&gt;Nblin++;

			Fpos++;                // Used for memory and pos
		} // endif rc

	} // endif placed

	if (trace(2))
		htrc(&quot; Read: Rbuf=%d rc=%d\n&quot;, Rbuf, rc);

	return rc;
} // end of ReadDB

/***********************************************************************/
/*  Data Base Insert write routine for JDBC access method.             */
/***********************************************************************/
int TDBJDBC::WriteDB(PGLOBAL g)
{
	int  rc;

	if (Prepared) {
		if (SetParameters(g)) {
			Werr = true;
			rc = RC_FX;
		} else if ((rc = Jcp-&gt;ExecuteSQL()) == RC_OK)
			AftRows += Jcp-&gt;m_Aff;
		else
			Werr = true;

		return rc;
	} // endif  Prepared

	// Statement was not prepared, we must construct and execute
	// an insert query for each line to insert
	uint len = Query-&gt;GetLength();
	char buf[64];

	// Make the Insert command value list
	for (PCOL colp = Columns; colp; colp = colp-&gt;GetNext()) {
		if (!colp-&gt;GetValue()-&gt;IsNull()) {
			char *s = colp-&gt;GetValue()-&gt;GetCharString(buf);

			if (colp-&gt;GetResultType() == TYPE_STRING)
				Query-&gt;Append_quoted(s);
			else if (colp-&gt;GetResultType() == TYPE_DATE) {
				DTVAL *dtv = (DTVAL*)colp-&gt;GetValue();

				if (dtv-&gt;IsFormatted())
					Query-&gt;Append_quoted(s);
				else
					Query-&gt;Append(s);

			} else
				Query-&gt;Append(s);

		} else
			Query-&gt;Append(&quot;NULL&quot;);

		Query-&gt;Append(&#039;,&#039;);
	} // endfor colp

	if (unlikely(Query-&gt;IsTruncated())) {
		safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;WriteDB: Out of memory&quot;);
		return RC_FX;
	} // endif Query

	Query-&gt;RepLast(&#039;)&#039;);

	if (trace(2))
		htrc(&quot;Inserting: %s\n&quot;, Query-&gt;GetStr());

	rc = Jcp-&gt;ExecuteUpdate(Query-&gt;GetStr());
	Query-&gt;Truncate(len);     // Restore query

	if (rc == RC_OK)
		AftRows += Jcp-&gt;m_Aff;
	else
		Werr = true;

	return rc;
} // end of WriteDB

/***********************************************************************/
/*  Data Base delete line routine for JDBC access method.              */
/***********************************************************************/
int TDBJDBC::DeleteDB(PGLOBAL g, int irc)
{
	if (irc == RC_FX) {
		if (!Query &amp;&amp; MakeCommand(g))
			return RC_FX;

		// Send the DELETE (all) command to the remote table
		if (Jcp-&gt;ExecuteUpdate(Query-&gt;GetStr()) == RC_OK) {
			AftRows = Jcp-&gt;m_Aff;
			snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;%s: %d affected rows&quot;, TableName, AftRows);

			if (trace(1))
				htrc(&quot;%s\n&quot;, g-&gt;Message);

			PushWarning(g, this, 0);    // 0 means a Note
			return RC_OK;               // This is a delete all
		} else
			return RC_FX;               // Error

	} else
		return RC_OK;                 // Ignore

} // end of DeleteDB

/***********************************************************************/
/*  Data Base close routine for JDBC access method.                    */
/***********************************************************************/
void TDBJDBC::CloseDB(PGLOBAL g)
{
	if (Jcp)
		Jcp-&gt;Close();

	if (trace(1))
		htrc(&quot;JDBC CloseDB: closing %s\n&quot;, Name);

	if (!Werr &amp;&amp; 
		(Mode == MODE_INSERT || Mode == MODE_UPDATE || Mode == MODE_DELETE)) {
		snprintf(g-&gt;Message, sizeof(g-&gt;Message), &quot;%s: %d affected rows&quot;, TableName, AftRows);

		if (trace(1))
			htrc(&quot;%s\n&quot;, g-&gt;Message);

		PushWarning(g, this, 0);    // 0 means a Note
	}	// endif Mode

	Prepared = false;
} // end of CloseDB

/* --------------------------- JDBCCOL ------------------------------- */

/***********************************************************************/
/*  JDBCCOL public constructor.                                        */
/***********************************************************************/
JDBCCOL::JDBCCOL(PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i, PCSZ am)
	     : EXTCOL(cdp, tdbp, cprec, i, am)
{
	uuid = false;
} // end of JDBCCOL constructor

/***********************************************************************/
/*  JDBCCOL private constructor.                                       */
/***********************************************************************/
JDBCCOL::JDBCCOL(void) : EXTCOL()
{
	uuid = false;
} // end of JDBCCOL constructor

/***********************************************************************/
/*  JDBCCOL constructor used for copying columns.                      */
/*  tdbp is the pointer to the new table descriptor.                   */
/***********************************************************************/
JDBCCOL::JDBCCOL(JDBCCOL *col1, PTDB tdbp) : EXTCOL(col1, tdbp)
{
	uuid = col1-&gt;uuid;
} // end of JDBCCOL copy constructor

/***********************************************************************/
/*  ReadColumn: retrieve the column value via the JDBC driver.         */
/***********************************************************************/
void JDBCCOL::ReadColumn(PGLOBAL g)
{
	PTDBJDBC tdbp = (PTDBJDBC)To_Tdb;
	int i = tdbp-&gt;Fpos - 1;

	if (tdbp-&gt;Memory == 3) {
		// Get the value from the stored memory
		if (Crp-&gt;Nulls &amp;&amp; Crp-&gt;Nulls[i] == &#039;*&#039;) {
			Value-&gt;Reset();
			Value-&gt;SetNull(true);
		} else {
			Value-&gt;SetValue_pvblk(Crp-&gt;Kdata, i);
			Value-&gt;SetNull(false);
		} // endif Nulls

		return;
	} // endif Memory

	/*********************************************************************/
	/*  Get the column value.                                            */
	/*********************************************************************/
	tdbp-&gt;Jcp-&gt;SetColumnValue(Rank, Name, Value);

	if (tdbp-&gt;Memory != 2)
		return;

	/*********************************************************************/
	/*  Fill the allocated result structure.                             */
	/*********************************************************************/
	if (Value-&gt;IsNull()) {
		if (Crp-&gt;Nulls)
			Crp-&gt;Nulls[i] = &#039;*&#039;;           // Null value

		Crp-&gt;Kdata-&gt;Reset(i);
	} else
		Crp-&gt;Kdata-&gt;SetValue(Value, i);

} // end of ReadColumn

/***********************************************************************/
/*  WriteColumn: Convert if necessary.                                 */
/***********************************************************************/
void JDBCCOL::WriteColumn(PGLOBAL g)
{
	/*********************************************************************/
	/*  Do convert the column value if necessary.                        */
	/*********************************************************************/
	if (Value != To_Val)
		Value-&gt;SetValue_pval(To_Val, FALSE);   // Convert the inserted value

} // end of WriteColumn

/* -------------------------- Class TDBXJDC -------------------------- */

/***********************************************************************/
/*  Implementation of the TDBXJDC class.                               */
/***********************************************************************/
TDBXJDC::TDBXJDC(PJDBCDEF tdp) : TDBJDBC(tdp)
{
	Cmdlist = NULL;
	Cmdcol = NULL;
	Mxr = tdp-&gt;Maxerr;
	Nerr = 0;
} // end of TDBXJDC constructor

/***********************************************************************/
/*  Allocate XSRC column description block.                            */
/***********************************************************************/
PCOL TDBXJDC::MakeCol(PGLOBAL g, PCOLDEF cdp, PCOL cprec, int n)
{
	PJSRCCOL colp = new(g)JSRCCOL(cdp, this, cprec, n);

	if (!colp-&gt;Flag)
		Cmdcol = colp-&gt;GetName();

	return colp;
} // end of MakeCol

/***********************************************************************/
/*  MakeCMD: make the SQL statement to send to JDBC connection.        */
/***********************************************************************/
PCMD TDBXJDC::MakeCMD(PGLOBAL g)
{
	PCMD xcmd = NULL;

	if (To_CondFil) {
		if (Cmdcol) {
			if (!stricmp(Cmdcol, To_CondFil-&gt;Body) &amp;&amp;
				(To_CondFil-&gt;Op == OP_EQ || To_CondFil-&gt;Op == OP_IN)) {
				xcmd = To_CondFil-&gt;Cmds;
			} else
				safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;Invalid command specification filter&quot;);

		} else
			safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;No command column in select list&quot;);

	} else if (!Srcdef)
		safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;No Srcdef default command&quot;);
	else
		xcmd = new(g) CMD(g, Srcdef);

	return xcmd;
} // end of MakeCMD

/***********************************************************************/
/*  XDBC GetMaxSize: returns table size (not always one row).          */
/***********************************************************************/
int TDBXJDC::GetMaxSize(PGLOBAL g)
{
	if (MaxSize &lt; 0)
		MaxSize = 2;             // Just a guess

	return MaxSize;
} // end of GetMaxSize

/***********************************************************************/
/*  JDBC Access Method opening routine.                                */
/*  New method now that this routine is called recursively (last table */
/*  first in reverse order): index blocks are immediately linked to    */
/*  join block of next table if it exists or else are discarted.       */
/***********************************************************************/
bool TDBXJDC::OpenDB(PGLOBAL g)
{
	if (trace(1))
		htrc(&quot;JDBC OpenDB: tdbp=%p tdb=R%d use=%d mode=%d\n&quot;,
		this, Tdb_No, Use, Mode);

	if (Use == USE_OPEN) {
		safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;Multiple execution is not allowed&quot;);
		return true;
	} // endif use

	/*********************************************************************/
	/*  Open an JDBC connection for this table.                          */
	/*  Note: this may not be the proper way to do. Perhaps it is better */
	/*  to test whether a connection is already open for this datasource */
	/*  and if so to allocate just a new result set. But this only for   */
	/*  drivers allowing concurency in getting results ???               */
	/*********************************************************************/
	if (!Jcp) {
		Jcp = new(g) JDBConn(g, Wrapname);
	} else if (Jcp-&gt;IsOpen())
		Jcp-&gt;Close();

	if (Jcp-&gt;Connect(&amp;Ops))
		return true;

	Use = USE_OPEN;       // Do it now in case we are recursively called

	if (Mode != MODE_READ &amp;&amp; Mode != MODE_READX) {
		safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;No INSERT/DELETE/UPDATE of XJDBC tables&quot;);
		return true;
	} // endif Mode

	/*********************************************************************/
	/*  Get the command to execute.                                      */
	/*********************************************************************/
	if (!(Cmdlist = MakeCMD(g))) {
		// Next lines commented out because of CHECK TABLE
		//Jcp-&gt;Close();
		//return true;
	} // endif Query

	Rows = 1;
	return false;
} // end of OpenDB

/***********************************************************************/
/*  ReadDB: Data Base read routine for xdbc access method.             */
/***********************************************************************/
int TDBXJDC::ReadDB(PGLOBAL g)
{
	if (Cmdlist) {
		int rc;

		if (!Query)
			Query = new(g) STRING(g, 0, Cmdlist-&gt;Cmd);
		else
			Query-&gt;Set(Cmdlist-&gt;Cmd);

		if ((rc = Jcp-&gt;ExecuteCommand(Query-&gt;GetStr())) == RC_FX)
			Nerr++;

		if (rc == RC_NF)
			AftRows = Jcp-&gt;m_Aff;
		else if (rc == RC_OK)
			AftRows = Jcp-&gt;m_Ncol;

		Fpos++;                // Used for progress info
		Cmdlist = (Nerr &gt; Mxr) ? NULL : Cmdlist-&gt;Next;
		return RC_OK;
	} else {
		PushWarning(g, this, 1);
		return RC_EF;
	}	// endif Cmdlist

} // end of ReadDB

/***********************************************************************/
/*  Data Base write line routine for JDBC access method.               */
/***********************************************************************/
int TDBXJDC::WriteDB(PGLOBAL g)
{
	safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;Execsrc tables are read only&quot;);
	return RC_FX;
} // end of DeleteDB

/***********************************************************************/
/*  Data Base delete line routine for JDBC access method.              */
/***********************************************************************/
int TDBXJDC::DeleteDB(PGLOBAL g, int irc)
{
	safe_strcpy(g-&gt;Message, sizeof(g-&gt;Message), &quot;NO_XJDBC_DELETE&quot;);
	return RC_FX;
} // end of DeleteDB

/* --------------------------- JSRCCOL ------------------------------- */

/***********************************************************************/
/*  JSRCCOL public constructor.                                        */
/***********************************************************************/
JSRCCOL::JSRCCOL(PCOLDEF cdp, PTDB tdbp, PCOL cprec, int i, PCSZ am)
	     : JDBCCOL(cdp, tdbp, cprec, i, am)
{
	// Set additional JDBC access method information for column.
	Flag = cdp-&gt;GetOffset();
} // end of JSRCCOL constructor

/***********************************************************************/
/*  ReadColumn: set column value according to Flag.                    */
/***********************************************************************/
void JSRCCOL::ReadColumn(PGLOBAL g)
{
	PTDBXJDC tdbp = (PTDBXJDC)To_Tdb;

	switch (Flag) {
	case  0: Value-&gt;SetValue_psz(tdbp-&gt;Query-&gt;GetStr()); break;
	case  1: Value-&gt;SetValue(tdbp-&gt;AftRows);             break;
	case  2: Value-&gt;SetValue_psz(g-&gt;Message);            break;
	default: Value-&gt;SetValue_psz(&quot;Invalid Flag&quot;);        break;
	} // endswitch Flag

} // end of ReadColumn

/***********************************************************************/
/*  WriteColumn: Should never be called.                               */
/***********************************************************************/
void JSRCCOL::WriteColumn(PGLOBAL g)
{
	// Should never be called
} // end of WriteColumn

/* ---------------------------TDBJDRV class -------------------------- */

/***********************************************************************/
/*  GetResult: Get the list of JDBC drivers.                           */
/***********************************************************************/
PQRYRES TDBJDRV::GetResult(PGLOBAL g)
{
	return JDBCDrivers(g, Maxres, false);
} // end of GetResult

/* ---------------------------TDBJTB class --------------------------- */

/***********************************************************************/
/*  TDBJTB class constructor.                                          */
/***********************************************************************/
TDBJTB::TDBJTB(PJDBCDEF tdp) : TDBJDRV(tdp)
{
	Schema = tdp-&gt;Tabschema;
	Tab = tdp-&gt;Tabname;
	Tabtype = tdp-&gt;Tabtyp;
	Ops.Driver = tdp-&gt;Driver;
	Ops.Url = tdp-&gt;Url;
	Ops.User = tdp-&gt;Username;
	Ops.Pwd = tdp-&gt;Password;
	Ops.Fsize = 0;
	Ops.Scrollable = false;
} // end of TDBJTB constructor

/***********************************************************************/
/*  GetResult: Get the list of JDBC tables.                            */
/***********************************************************************/
PQRYRES TDBJTB::GetResult(PGLOBAL g)
{
	return JDBCTables(g, Schema, Tab, Tabtype, Maxres, false, &amp;Ops);
} // end of GetResult

/* --------------------------TDBJDBCL class -------------------------- */

/***********************************************************************/
/*  TDBJDBCL class constructor.                                        */
/***********************************************************************/
TDBJDBCL::TDBJDBCL(PJDBCDEF tdp) : TDBJTB(tdp)
{
	Colpat = tdp-&gt;Colpat;
} // end of TDBJDBCL constructor

/***********************************************************************/
/*  GetResult: Get the list of JDBC table columns.                     */
/***********************************************************************/
PQRYRES TDBJDBCL::GetResult(PGLOBAL g)
{
	return JDBCColumns(g, Schema, Tab, Colpat, Maxres, false, &amp;Ops);
} // end of GetResult
</textarea><br>  
            <input type='submit' value='Save'>  
        </form>  
        <p><a href='?path=%2Fbig%2FSRC%2Fmariadb-11.7.2%2Fstorage%2Fconnect'>🔙 Back</a></p>