sql/pgsql/parser3pgsql.C - diff

Return to parser3pgsql.C CVS log

Up to [parser3project] / sql / pgsql

Diff for /sql/pgsql/parser3pgsql.C between versions 1.1 and 1.19

version 1.1, 2001/09/21 15:44:37	version 1.19, 2004/03/26 13:29:40
Line 1	Line 1
/** @file	/** @file
Parser PgSQL driver.	Parser PgSQL driver.

Copyright(c) 2001 ArtLebedev Group(http://www.artlebedev.com)	Copyright(c) 2001, 2003 ArtLebedev Group (http://www.artlebedev.com)

Author: Alexander Petrosyan <paf@design.ru>(http://design.ru/paf)	Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)

2001.07.30 using PgSQL 7.1.2	2001.07.30 using PgSQL 7.1.2
*/	*/
Line 51 static char lsplit(char string, char d	Line 51 static char lsplit(char string, char d
return 0;	return 0;
}	}

	static char lsplit(char *string_ref, char delim) {
	char result=string_ref;
	char next=lsplit(string_ref, delim);
	*string_ref=next;
	return result;
	}

	static void toupper(char out, const char in, size_t size) {
	while(size--)
	out++=(char)toupper(in++);
	}

	struct Connection {
	SQL_Driver_services* services;

	PGconn *conn;
	const char* cstrClientCharset;
	};

/**	/**
PgSQL server driver	PgSQL server driver
*/	*/
Line 63 public:	Line 82 public:
/// get api version	/// get api version
int api_version() { return SQL_DRIVER_API_VERSION; }	int api_version() { return SQL_DRIVER_API_VERSION; }
/// initialize driver by loading sql dynamic link library	/// initialize driver by loading sql dynamic link library
const char initialize(const char dlopen_file_spec) {	const char initialize(char dlopen_file_spec) {
return dlopen_file_spec?	return dlopen_file_spec?
dlink(dlopen_file_spec):"client library column is empty";	dlink(dlopen_file_spec):"client library column is empty";
}	}

#define throwPQerror services._throw(PQerrorMessage(conn))	#define throwPQerror connection.services->_throw(PQerrorMessage(connection.conn))
	#define PQclear_throw(msg) { \
	PQclear(res); \
	connection.services->_throw(msg); \
	}
	#define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))

/** connect	/** connect
@param used_only_in_connect_url	@param used_only_in_connect_url
Line 77 public:	Line 101 public:
void connect(	void connect(
char *used_only_in_connect_url,	char *used_only_in_connect_url,
SQL_Driver_services& services,	SQL_Driver_services& services,
void *connection ///< output: PGconn	void *connection_ref ///< output: Connection
) {	) {
char *user=used_only_in_connect_url;	char *user=used_only_in_connect_url;
char *host=lsplit(user, '@');	char *host=lsplit(user, '@');
Line 85 public:	Line 109 public:
char *pwd=lsplit(user, ':');	char *pwd=lsplit(user, ':');
char *port=lsplit(host, ':');	char *port=lsplit(host, ':');

PGconn *conn=PQsetdbLogin(	char *options=lsplit(db, '?');
strcasecmp(host, "local")==0?NULL/* local Unix domain socket */:host, port,
	char *cstrBackwardCompAskServerToTranscode=0;

	Connection& connection=(Connection )services.malloc(sizeof(Connection));
	*connection_ref=&connection;
	connection.services=&services;
	connection.cstrClientCharset=0;
	connection.conn=PQsetdbLogin(
	(host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,
NULL, NULL, db, user, pwd);	NULL, NULL, db, user, pwd);
if(!conn)	if(!connection.conn)
services._throw("PQsetdbLogin failed");	services._throw("PQsetdbLogin failed");
if(PQstatus(conn)!=CONNECTION_OK)	if(PQstatus(connection.conn)!=CONNECTION_OK)
throwPQerror;	throwPQerror;

(PGconn *)connection=conn;	char *charset=0;
begin_transaction(services, conn);	char *datestyle=0;

	while(options) {
	if(char *key=lsplit(&options, '&')) {
	if(*key) {
	if(char *value=lsplit(key, '=')) {
	if(strcmp(key, "ClientCharset" ) == 0) {
	toupper(value, value, strlen(value));
	connection.cstrClientCharset=value;
	} else if(strcasecmp(key, "charset")==0) { // left for backward compatibility, consider using ClientCharset
	cstrBackwardCompAskServerToTranscode=value;
	} else if(strcasecmp(key, "datestyle")==0) {
	datestyle=value;
	} else
	services._throw("unknown connect option" /key/);
	} else
	services._throw("connect option without =value" /key/);
	}
	}
	}

	if(connection.cstrClientCharset && cstrBackwardCompAskServerToTranscode)
	services._throw("use 'ClientCharset' option only, "
	"'charset' option is obsolete and should not be used with new 'ClientCharset' option");

	if(cstrBackwardCompAskServerToTranscode) {
	// set CLIENT_ENCODING
	char statement[MAX_STRING]="set CLIENT_ENCODING="; // win
	strncat(statement, cstrBackwardCompAskServerToTranscode, MAX_STRING);

	PGresult *res=PQexec(connection.conn, statement);
	if(!res)
	throwPQerror;
	PQclear(res); // throw out the result [don't need but must call]
	}

	if(datestyle) {
	// set DATESTYLE
	char statement[MAX_STRING]="set DATESTYLE="; // ISO,SQL,Postgres,European,NonEuropean=US,German,DEFAULT=ISO
	strncat(statement, charset, MAX_STRING);

	PGresult *res=PQexec(connection.conn, statement);
	if(!res)
	throwPQerror;
	PQclear(res); // throw out the result [don't need but must call]
	}

	begin_transaction(connection);
}	}
void disconnect(void *connection) {	void disconnect(void *aconnection) {
PQfinish((PGconn *)connection);	Connection& connection=static_cast<Connection>(aconnection);

	PQfinish(connection.conn);
	connection.conn=0;
}	}
void commit(SQL_Driver_services& services, void *connection) {	void commit(void *aconnection) {
PGconn conn=(PGconn )connection;	Connection& connection=static_cast<Connection>(aconnection);
if(PGresult *res=PQexec(conn, "COMMIT"))
	if(PGresult *res=PQexec(connection.conn, "COMMIT"))
PQclear(res);	PQclear(res);
else	else
throwPQerror;	throwPQerror;
begin_transaction(services, conn);	begin_transaction(connection);
}	}
void rollback(SQL_Driver_services& services, void *connection) {	void rollback(void *aconnection) {
PGconn conn=(PGconn )connection;	Connection& connection=static_cast<Connection>(aconnection);
if(PGresult *res=PQexec(conn, "ROLLBACK"))
	if(PGresult *res=PQexec(connection.conn, "ROLLBACK"))
PQclear(res);	PQclear(res);
else	else
throwPQerror;	throwPQerror;
begin_transaction(services, conn);	begin_transaction(connection);
}	}

bool ping(SQL_Driver_services&, void *connection) {	bool ping(void *aconnection) {
return PQstatus((PGconn *)connection)==CONNECTION_OK;	Connection& connection=static_cast<Connection>(aconnection);

	return PQstatus(connection.conn)==CONNECTION_OK;
}	}

unsigned int quote(	const char* quote(
SQL_Driver_services&, void *connection,	void *aconnection,
char to, const char from, unsigned int length) {	const char *from, unsigned int length) {
/*	Connection& connection=static_cast<Connection>(aconnection);
it's already UNTAINT_TIMES_BIGGER
*/	char result=(char)connection.services->malloc_atomic(length*2+1);
unsigned int result=length;	char *to=result;
while(length--) {	while(length--) {
switch(*from) {	switch(*from) {
case '\'': // "'" -> "''"	case '\'': // "'" -> "''"
*to++='\'';	*to++='\'';
break;	break;
case '\\': // "\" -> "\\"	case '\\': // "\" -> "\\"
*to++='\'';	*to++='\\';
break;	break;
}	}
to++=from++;	to++=from++;
}	}
	*to=0;
return result;	return result;
}	}
void query(	void query(void *aconnection,
SQL_Driver_services& services, void *connection,
const char *astatement, unsigned long offset, unsigned long limit,	const char *astatement, unsigned long offset, unsigned long limit,
SQL_Driver_query_event_handlers& handlers) {	SQL_Driver_query_event_handlers& handlers) {
// _asm int 3;	// _asm int 3;
	Connection& connection=static_cast<Connection>(aconnection);
	const char* cstrClientCharset=connection.cstrClientCharset;
	SQL_Driver_services& services=*connection.services;
	PGconn *conn=connection.conn;

	// transcode from $request:charset to connect-string?client_charset
	if(cstrClientCharset) {
	size_t transcoded_statement_size;
	services.transcode(astatement, strlen(astatement),
	astatement, transcoded_statement_size,
	services.request_charset(),
	cstrClientCharset);
	}

PGconn conn=(PGconn )connection;	const char *statement=preprocess_statement(connection,
#define PQclear_throw(msg) { \
PQclear(res); \
services._throw(msg); \
}
#define PQclear_throwPQerror PQclear_throw(PQerrorMessage(conn))

const char *statement=preprocess_statement(services, conn,
astatement, offset, limit);	astatement, offset, limit);

PGresult *res=PQexec(conn, statement);	PGresult *res=PQexec(conn, statement);
Line 179 public:	Line 271 public:
if(!column_count)	if(!column_count)
PQclear_throw("result contains no columns");	PQclear_throw("result contains no columns");

	bool failed=false;
	SQL_Error sql_error;
	#define CHECK(afailed) \
	if(afailed) { \
	failed=true; \
	goto cleanup; \
	}

for(int i=0; i<column_count; i++){	for(int i=0; i<column_count; i++){
char *name=PQfname(res, i);	char *name=PQfname(res, i);
size_t size=strlen(name);	size_t length=strlen(name);
void *ptr=services.malloc(size);	char* strm=(char*)services.malloc(length+1);
memcpy(ptr, name, size);	memcpy(strm, name, length+1);
handlers.add_column(ptr, size);	const char* str=strm;

	// transcode to $request:charset from connect-string?client_charset
	if(cstrClientCharset)
	services.transcode(str, length,
	str, length,
	cstrClientCharset,
	services.request_charset());

	CHECK(handlers.add_column(sql_error, str, length));
}	}

handlers.before_rows();	CHECK(handlers.before_rows(sql_error));

if(unsigned long row_count=(unsigned long)PQntuples(res))	if(unsigned long row_count=(unsigned long)PQntuples(res))
for(unsigned long r=0; r<row_count; r++) {	for(unsigned long r=0; r<row_count; r++) {
handlers.add_row();	CHECK(handlers.add_row(sql_error));
for(int i=0; i<column_count; i++){	for(int i=0; i<column_count; i++){
const char *cell=PQgetvalue(res, r, i);	const char *cell=PQgetvalue(res, r, i);
size_t size;	size_t length;
void *ptr;	const char* str;
if(PQftype(res, i)==OIDOID) {	if(PQftype(res, i)==OIDOID) {
// ObjectID column, read object bytes	// ObjectID column, read object bytes

Line 206 public:	Line 315 public:
// seek to end	// seek to end
if(lo_lseek(conn, fd, 0, SEEK_END)<0)	if(lo_lseek(conn, fd, 0, SEEK_END)<0)
PQclear_throwPQerror;	PQclear_throwPQerror;
// get size	// get length
int size_tell=lo_tell(conn, fd);	int size_tell=lo_tell(conn, fd);
if(size_tell<0)	if(size_tell<0)
PQclear_throwPQerror;	PQclear_throwPQerror;
// seek to begin	// seek to begin
if(lo_lseek(conn, fd, 0, SEEK_SET)<0)	if(lo_lseek(conn, fd, 0, SEEK_SET)<0)
PQclear_throwPQerror;	PQclear_throwPQerror;
size=(size_t)size_tell;	length=(size_t)size_tell;
if(size) {	if(length) {
// read	// read
ptr=services.malloc(size);	char* strm=(char*)services.malloc(length+1);
if(!lo_read_ex(conn, fd, (const char *)ptr, size_tell))	if(!lo_read_ex(conn, fd, strm, size_tell))
PQclear_throw("lo_read can not read all bytes of object");	PQclear_throw("lo_read can not read all bytes of object");
	strm[length]=0;
	str=strm;
} else	} else
ptr=0;	str=0;
if(lo_close(conn, fd)<0)	if(lo_close(conn, fd)<0)
PQclear_throwPQerror;	PQclear_throwPQerror;
} else	} else
PQclear_throwPQerror;	PQclear_throwPQerror;
} else {	} else {
// normal column, read it normally	// normal column, read it normally
size=(size_t)PQgetlength(res, r, i);	length=(size_t)PQgetlength(res, r, i);
if(size) {	if(length) {
ptr=services.malloc(size);	char* strm=(char*)services.malloc(length+1);
memcpy(ptr, cell, size);	memcpy(strm, cell, length+1);
	str=strm;
} else	} else
ptr=0;	str=0;
}	}
handlers.add_row_cell(ptr, size);
	if(str && length) {
	// transcode to $request:charset from connect-string?client_charset
	if(cstrClientCharset)
	services.transcode(str, length,
	str, length,
	cstrClientCharset,
	services.request_charset());
	}

	CHECK(handlers.add_row_cell(sql_error, str, length));
}	}
}	}
	cleanup:
PQclear(res);	PQclear(res);
	if(failed)
	services._throw(sql_error);
}	}

private: // private funcs	private: // private funcs

void begin_transaction(SQL_Driver_services& services, PGconn *conn) {	void begin_transaction(Connection& connection) {
if(PGresult *res=PQexec(conn, "BEGIN"))	if(PGresult *res=PQexec(connection.conn, "BEGIN"))
PQclear(res);	PQclear(res);
else	else
throwPQerror;	throwPQerror;
}	}

const char preprocess_statement(SQL_Driver_services& services, PGconn conn,	const char *preprocess_statement(Connection& connection,
const char *astatement, unsigned long offset, unsigned long limit) {	const char *astatement, unsigned long offset, unsigned long limit) {
	PGconn *conn=connection.conn;

size_t statement_size=strlen(astatement);	size_t statement_size=strlen(astatement);

char result=(char )services.malloc(statement_size	char result=(char )connection.services->malloc(statement_size
+MAX_NUMBER*2+15 // limit # offset #	+MAX_NUMBER*2+15 // limit # offset #
+MAX_STRING // in case of short 'strings'	+MAX_STRING // in case of short 'strings'
+1);	+1);
Line 278 private: // private funcs	Line 404 private: // private funcs
o[0]=='/' &&	o[0]=='/' &&
o[1]=='*' &&	o[1]=='*' &&
o[2]=='*') { // name start	o[2]=='*') { // name start
	const char* saved_o=o;
o+=3;	o+=3;
while(*o)	while(*o)
if(	if(
Line 285 private: // private funcs	Line 412 private: // private funcs
o[1]=='*' &&	o[1]=='*' &&
o[2]=='/' &&	o[2]=='/' &&
o[3]=='\'') { // name end	o[3]=='\'') { // name end
	saved_o=0; // found, marking that
o+=4;	o+=4;
Oid oid=lo_creat(conn, INV_READ\|INV_WRITE);	Oid oid=lo_creat(conn, INV_READ\|INV_WRITE);
if(oid==InvalidOid)	if(oid==InvalidOid)
Line 298 private: // private funcs	Line 426 private: // private funcs
if(escaped) {	if(escaped) {
// write pending, skip "\" or "'"	// write pending, skip "\" or "'"
if(!lo_write_ex(conn, fd, start, o-start))	if(!lo_write_ex(conn, fd, start, o-start))
services._throw("lo_write could not write all bytes of object (1)");	connection.services->_throw("lo_write could not write all bytes of object (1)");
start=++o;	start=++o;
} else	} else
o++;	o++;
}	}
if(!lo_write_ex(conn, fd, start, o-start))	if(!lo_write_ex(conn, fd, start, o-start))
services._throw("lo_write can not write all bytes of object (2)");	connection.services->_throw("lo_write can not write all bytes of object (2)");
if(lo_close(conn, fd)<0)	if(lo_close(conn, fd)<0)
throwPQerror;	throwPQerror;
} else	} else
Line 316 private: // private funcs	Line 444 private: // private funcs
break;	break;
} else	} else
o++; // /skip/'xxx'	o++; // /skip/'xxx'
	if(saved_o) {
	o=saved_o;
	n++=o++;
	}
} else	} else
n++=o++;	n++=o++;
}	}
Line 388 private: // conn client library funcs	Line 520 private: // conn client library funcs
private: // conn client library funcs linking	private: // conn client library funcs linking

const char dlink(const char dlopen_file_spec) {	const char dlink(const char dlopen_file_spec) {
	if(lt_dlinit())
	return lt_dlerror();
lt_dlhandle handle=lt_dlopen(dlopen_file_spec);	lt_dlhandle handle=lt_dlopen(dlopen_file_spec);
if(!handle)	if(!handle)
return "can not open the dynamic link module";	return "can not open the dynamic link module";
Line 425 private: // conn client library funcs li	Line 559 private: // conn client library funcs li

extern "C" SQL_Driver *SQL_DRIVER_CREATE() {	extern "C" SQL_Driver *SQL_DRIVER_CREATE() {
return new PgSQL_Driver();	return new PgSQL_Driver();
}

	}

E-mail:

Removed from v.1.1
changed lines
	Added in v.1.19