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.16 and 1.22

version 1.16, 2004/01/26 15:22:26	version 1.22, 2004/06/23 07:32:07
Line 58 static char lsplit(char *string_ref, c	Line 58 static char lsplit(char *string_ref, c
return result;	return result;
}	}

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

struct Connection {	struct Connection {
SQL_Driver_services* services;	SQL_Driver_services* services;

PGconn *conn;	PGconn *conn;
	const char* cstrClientCharset;
};	};

/**	/**
Line 89 public:	Line 95 public:
#define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))	#define PQclear_throwPQerror PQclear_throw(PQerrorMessage(connection.conn))

/** connect	/** connect
@param used_only_in_connect_url	@param url
format: @b user:pass@host[:port]\|[local]/database	format: @b user:pass@host[:port]\|[local]/database
*/	*/
void connect(	void connect(
char *used_only_in_connect_url,	char *url,
SQL_Driver_services& services,	SQL_Driver_services& services,
void *connection_ref ///< output: Connection	void *connection_ref ///< output: Connection
) {	) {
char *user=used_only_in_connect_url;	char *user=url;
char *host=lsplit(user, '@');	char *host=lsplit(user, '@');
char *db=lsplit(host, '/');	char *db=lsplit(host, '/');
char *pwd=lsplit(user, ':');	char *pwd=lsplit(user, ':');
Line 105 public:	Line 111 public:

char *options=lsplit(db, '?');	char *options=lsplit(db, '?');

Connection& connection=(Connection )::calloc(sizeof(Connection), 1);	char *cstrBackwardCompAskServerToTranscode=0;

	Connection& connection=(Connection )services.malloc(sizeof(Connection));
*connection_ref=&connection;	*connection_ref=&connection;
connection.services=&services;	connection.services=&services;
	connection.cstrClientCharset=0;
connection.conn=PQsetdbLogin(	connection.conn=PQsetdbLogin(
(host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,	(host&&strcasecmp(host, "local")==0)?NULL/* local Unix domain socket */:host, port,
NULL, NULL, db, user, pwd);	NULL, NULL, db, user, pwd);
Line 123 public:	Line 132 public:
if(char *key=lsplit(&options, '&')) {	if(char *key=lsplit(&options, '&')) {
if(*key) {	if(*key) {
if(char *value=lsplit(key, '=')) {	if(char *value=lsplit(key, '=')) {
if(strcasecmp(key, "charset")==0) {	if(strcmp(key, "ClientCharset" ) == 0) {
charset=value;	toupper_str(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) {	} else if(strcasecmp(key, "datestyle")==0) {
datestyle=value;	datestyle=value;
} else	} else
Line 135 public:	Line 147 public:
}	}
}	}

if(charset) {	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	// set CLIENT_ENCODING
char statement[MAX_STRING]="set CLIENT_ENCODING="; // win	char statement[MAX_STRING]="set CLIENT_ENCODING="; // win
strncat(statement, charset, MAX_STRING);	strncat(statement, cstrBackwardCompAskServerToTranscode, MAX_STRING);

PGresult *res=PQexec(connection.conn, statement);	PGresult *res=PQexec(connection.conn, statement);
if(!res)	if(!res)
Line 212 public:	Line 228 public:
return result;	return result;
}	}
void query(void *aconnection,	void query(void *aconnection,
const char *astatement, unsigned long offset, unsigned long limit,	const char *astatement,
	size_t placeholders_count, Placeholder* placeholders,
	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);	Connection& connection=static_cast<Connection>(aconnection);
	const char* cstrClientCharset=connection.cstrClientCharset;
SQL_Driver_services& services=*connection.services;	SQL_Driver_services& services=*connection.services;
PGconn *conn=connection.conn;	PGconn *conn=connection.conn;

	if(placeholders_count>0)
	services._throw("bind variables not supported (yet)");

	// 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);
	}

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

Line 255 public:	Line 286 public:

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);
char* str=(char*)services.malloc(size+1);	char* strm=(char*)services.malloc(length+1);
memcpy(str, name, size+1);	memcpy(strm, name, length+1);
CHECK(handlers.add_column(sql_error, str, 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));
}	}

CHECK(handlers.before_rows(sql_error));	CHECK(handlers.before_rows(sql_error));
Line 268 public:	Line 308 public:
CHECK(handlers.add_row(sql_error));	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;
char* str;	const char* str;
if(PQftype(res, i)==OIDOID) {	if(PQftype(res, i)==OIDOID) {
// ObjectID column, read object bytes	// ObjectID column, read object bytes

Line 280 public:	Line 320 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
str=(char*)services.malloc(size+1);	char* strm=(char*)services.malloc(length+1);
if(!lo_read_ex(conn, fd, str, 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");
str[size]=0;	strm[length]=0;
	str=strm;
} else	} else
str=0;	str=0;
if(lo_close(conn, fd)<0)	if(lo_close(conn, fd)<0)
Line 302 public:	Line 343 public:
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) {
str=(char*)services.malloc(size+1);	char* strm=(char*)services.malloc(length+1);
memcpy(str, cell, size+1);	memcpy(strm, cell, length+1);
	str=strm;
} else	} else
str=0;	str=0;
}	}
CHECK(handlers.add_row_cell(sql_error, str, 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:	cleanup:

E-mail:

Removed from v.1.16
changed lines
	Added in v.1.22