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.30 and 1.35

version 1.30, 2008/06/26 15:49:40	version 1.35, 2010/10/27 22:48:51
Line 16 static const char *RCSId="$Id$";	Line 16 static const char *RCSId="$Id$";
#include <libpq-fe.h>	#include <libpq-fe.h>
#include <libpq/libpq-fs.h>	#include <libpq/libpq-fs.h>

// OIDOID from catalog/pg_type.h	// from catalog/pg_type.h
	#define BOOLOID 16
	#define INT8OID 20
	#define INT2OID 21
	#define INT4OID 23
#define OIDOID 26	#define OIDOID 26
	#define FLOAT4OID 700
	#define FLOAT8OID 701
	#define DATEOID 1082
	#define TIMEOID 1083
	#define TIMESTAMPOID 1114
	#define TIMESTAMPTZOID 1184
	#define TIMETZOID 1266
	#define NUMERICOID 1700

// LO_BUFSIZE from interfaces\libpq\fe-lobj.c = 8192 (0x2000)	// LO_BUFSIZE from interfaces\libpq\fe-lobj.c = 8192 (0x2000)
// actually writing chunks of that size failed, reduced it twice	// actually writing chunks of that size failed, reduced it twice
#define LO_BUFSIZE 0x1000	#define LO_BUFSIZE 0x1000
// from postgres_ext.h
//#define InvalidOid ((Oid) 0)


#include "ltdl.h"	#include "ltdl.h"

	#define MAX_COLS 500

#define MAX_STRING 0x400	#define MAX_STRING 0x400
#define MAX_NUMBER 20	#define MAX_NUMBER 20

Line 78 struct Connection {	Line 91 struct Connection {
PGconn *conn;	PGconn *conn;
const char* client_charset;	const char* client_charset;
bool autocommit;	bool autocommit;
	bool without_default_transactions;
};	};

/**	/**
Line 111 public:	Line 125 public:
ClientCharset=charset& // transcode by parser	ClientCharset=charset& // transcode by parser
charset=value& // transcode by server with 'SET CLIENT_ENCODING=value'	charset=value& // transcode by server with 'SET CLIENT_ENCODING=value'
datestyle=value& // 'SET DATESTYLE=value' available values are: ISO\|SQL\|Postgres\|European\|US\|German [default=ISO]	datestyle=value& // 'SET DATESTYLE=value' available values are: ISO\|SQL\|Postgres\|European\|US\|German [default=ISO]
autocommit=1&	autocommit=1& // each transaction is commited automatically (default)
WithoutDefaultTransaction=1 // == autocommit=0	WithoutDefaultTransaction=0 // 1 -- disable any BEGIN TRAN/COMMIT/ROLLBACK [can NOT be used with autocommit option]
*/	*/
void connect(	void connect(
char* url,	char* url,
Line 135 public:	Line 149 public:
connection.services=&services;	connection.services=&services;
connection.client_charset=0;	connection.client_charset=0;
connection.autocommit=true;	connection.autocommit=true;
	connection.without_default_transactions=false;

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 149 public:	Line 165 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(strcmp(key, "ClientCharset")==0){ // transcoding with parser	if(strcmp(key, "ClientCharset")==0){
toupper_str(value, value, strlen(value));	toupper_str(value, value, strlen(value));
connection.client_charset=value;	connection.client_charset=value;
} else if(strcasecmp(key, "charset")==0){ // transcoding with server	} else if(strcasecmp(key, "charset")==0){
charset=value;	charset=value;
} else if(strcasecmp(key, "datestyle")==0){	} else if(strcasecmp(key, "datestyle")==0){
datestyle=value;	datestyle=value;
} else if(strcasecmp(key, "autocommit")==0){	} else if(strcasecmp(key, "autocommit")==0){
	if(connection.without_default_transactions)
	services._throw("options WithoutDefaultTransaction and autocommit can't be used together");
if(atoi(value)==0)	if(atoi(value)==0)
connection.autocommit=false;	connection.autocommit=false;
} else if(strcmp(key, "WithoutDefaultTransaction")==0){ // backward, use autocommit=0	} else if(strcmp(key, "WithoutDefaultTransaction")==0){
if(atoi(value)==1)	if(!connection.autocommit)
	services._throw("options WithoutDefaultTransaction and autocommit can't be used together");
	if(atoi(value)==1){
	connection.without_default_transactions=true;
connection.autocommit=false;	connection.autocommit=false;
	}
} else	} else
services._throw("unknown connect option" /key/);	services._throw("unknown connect option" /key/);
} else	} else
Line 184 public:	Line 206 public:
_execute_cmd(connection, statement);	_execute_cmd(connection, statement);
}	}

_begin_transaction(connection);	_transaction_begin(connection);
}	}

void disconnect(void *aconnection){	void disconnect(void *aconnection){
Line 195 public:	Line 217 public:

void commit(void *aconnection){	void commit(void *aconnection){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
if(connection.autocommit){	_transaction_commit(connection);
_execute_cmd(connection, "COMMIT");	_transaction_begin(connection);
}
_begin_transaction(connection);
}	}

void rollback(void *aconnection){	void rollback(void *aconnection){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
if(connection.autocommit){	_transaction_rollback(connection);
_execute_cmd(connection, "ROLLBACK");	_transaction_begin(connection);
}
_begin_transaction(connection);
}	}

bool ping(void *aconnection) {	bool ping(void *aconnection) {
Line 214 public:	Line 232 public:
return PQstatus(connection.conn)==CONNECTION_OK;	return PQstatus(connection.conn)==CONNECTION_OK;
}	}

const char* quote(void aconnection, const char from, unsigned int length){	// charset here is services.request_charset(), not connection.client_charset
	// thus we can't use the sql server quoting support
	const char* quote(void aconnection, const char str, unsigned int length)
	{
	const char* from;
	const char* from_end=str+length;

	size_t quoted=0;

	for(from=str; from<from_end; from++){
	switch (*from) {
	case '\'':
	case '\\':
	quoted++;
	}
	}

	if(!quoted)
	return str;

Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
	char result=(char)connection.services->malloc_atomic(length + quoted + 1);
	char *to = result;

char result=(char)connection.services->malloc_atomic(length*2+1);	for(from=str; from<from_end; from++){
int err=0;	switch (*from) {
PQescapeStringConn(connection.conn, result, from, length, &err);	case '\'': // "'" -> "''"
	*to++='\'';
	break;
	case '\\': // "\" -> "\\"
	*to++='\\';
	break;
	}
	to++=from;
	}

	*to=0;
return result;	return result;
}	}

void query(void *aconnection,	void query(void *aconnection,
const char *astatement,	const char *astatement,
size_t placeholders_count, Placeholder* placeholders,	size_t placeholders_count, Placeholder* placeholders,
Line 230 public:	Line 279 public:
SQL_Driver_query_event_handlers& handlers	SQL_Driver_query_event_handlers& handlers
){	){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);
const char* client_charset=connection.client_charset;
SQL_Driver_services& services=*connection.services;	SQL_Driver_services& services=*connection.services;
PGconn *conn=connection.conn;	PGconn *conn=connection.conn;

bool transcode_needed=_transcode_required(connection);	const char* client_charset=connection.client_charset;
	const char* request_charset=services.request_charset();
	bool transcode_needed=client_charset && strcmp(client_charset, request_charset)!=0;

const char** paramValues;	const char** paramValues;
if(placeholders_count>0){	if(placeholders_count>0){
Line 243 public:	Line 293 public:
_bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);	_bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);
}	}

// transcode query from $request:charset to ?ClientCharset
if(transcode_needed){	if(transcode_needed){
	// transcode query from $request:charset to ?ClientCharset
size_t length=strlen(astatement);	size_t length=strlen(astatement);
services.transcode(astatement, length,	services.transcode(astatement, length,
astatement, length,	astatement, length,
services.request_charset(),	request_charset,
connection.client_charset);	client_charset);
}	}

const char *statement=_preprocess_statement(connection, astatement, offset, limit);	const char *statement=_preprocess_statement(connection, astatement, offset, limit);
Line 264 public:	Line 314 public:
if(!res)	if(!res)
throwPQerror;	throwPQerror;

	bool failed=false;
	SQL_Error sql_error;

switch(PQresultStatus(res)) {	switch(PQresultStatus(res)) {
case PGRES_EMPTY_QUERY:	case PGRES_EMPTY_QUERY:
PQclear_throw("no query");	PQclear_throw("no query");
break;	break;
case PGRES_COMMAND_OK: // empty result: insert\|delete\|update\|...	case PGRES_COMMAND_OK: // empty result: insert\|delete\|update\|...
PQclear(res);	PQclear(res);
	if(connection.autocommit)
	commit(aconnection);
return;	return;
case PGRES_TUPLES_OK:	case PGRES_TUPLES_OK:
break;	break;
Line 278 public:	Line 333 public:
break;	break;
}	}

int column_count=PQnfields(res);
if(!column_count)
PQclear_throw("result contains no columns");

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

	int column_count=PQnfields(res);
	if(!column_count)
	PQclear_throw("result contains no columns");

	if(column_count>MAX_COLS)
	column_count=MAX_COLS;

	unsigned int column_types[MAX_COLS];
	bool transcode_column[MAX_COLS];

for(int i=0; i<column_count; i++){	for(int i=0; i<column_count; i++){
	column_types[i]=PQftype(res, i);
	switch(column_types[i]){
	case BOOLOID:
	case INT8OID:
	case INT2OID:
	case INT4OID:
	case FLOAT4OID:
	case FLOAT8OID:
	case DATEOID:
	case TIMEOID:
	case TIMESTAMPOID:
	case TIMESTAMPTZOID:
	case TIMETZOID:
	case NUMERICOID:
	transcode_column[i]=false;
	break;
	default:
	transcode_column[i]=transcode_needed;
	break;
	}
char *name=PQfname(res, i);	char *name=PQfname(res, i);
size_t length=strlen(name);	size_t length=strlen(name);
char* strm=(char*)services.malloc(length+1);	char* strm=(char*)services.malloc(length+1);
memcpy(strm, name, length+1);	memcpy(strm, name, length+1);
const char* str=strm;	const char* str=strm;

// transcode column name from ?ClientCharset to $request:charset	if(transcode_needed) // transcode column name from ?ClientCharset to $request:charset
if(transcode_needed)
services.transcode(str, length,	services.transcode(str, length,
str, length,	str, length,
connection.client_charset,	client_charset,
services.request_charset());	request_charset);

CHECK(handlers.add_column(sql_error, str, length));	CHECK(handlers.add_column(sql_error, str, length));
}	}
Line 316 public:	Line 394 public:
const char *cell=PQgetvalue(res, r, i);	const char *cell=PQgetvalue(res, r, i);
size_t length;	size_t length;
const char* str;	const char* str;
if(PQftype(res, i)==OIDOID) {
// ObjectID column, read object bytes

char *error_pos=0;	switch(column_types[i]){
Oid oid=cell?atoi(cell):0;	case OIDOID:
int fd=lo_open(conn, oid, INV_READ);	{
if(fd>=0) {	char *error_pos=0;
// seek to end	Oid oid=cell?atoi(cell):0;
if(lo_lseek(conn, fd, 0, SEEK_END)<0)	int fd=lo_open(conn, oid, INV_READ);
PQclear_throwPQerror;	if(fd>=0){
// get length	// seek to end
int size_tell=lo_tell(conn, fd);	if(lo_lseek(conn, fd, 0, SEEK_END)<0)
if(size_tell<0)	PQclear_throwPQerror;
PQclear_throwPQerror;	// get length
// seek to begin	int size_tell=lo_tell(conn, fd);
if(lo_lseek(conn, fd, 0, SEEK_SET)<0)	if(size_tell<0)
PQclear_throwPQerror;	PQclear_throwPQerror;
length=(size_t)size_tell;	// seek to begin
if(length) {	if(lo_lseek(conn, fd, 0, SEEK_SET)<0)
// read	PQclear_throwPQerror;
	length=(size_t)size_tell;
	if(length){
	// read
	char* strm=(char*)services.malloc(length+1);
	if(!lo_read_ex(conn, fd, strm, size_tell))
	PQclear_throw("lo_read can not read all bytes of object");
	strm[length]=0;
	str=strm;
	} else
	str=0;
	if(lo_close(conn, fd)<0)
	PQclear_throwPQerror;
	} else
	PQclear_throwPQerror;
	}
	default:
	// normal column, read it normally
	length=(size_t)PQgetlength(res, r, i);
	if(length){
char* strm=(char*)services.malloc(length+1);	char* strm=(char*)services.malloc(length+1);
if(!lo_read_ex(conn, fd, strm, size_tell))	memcpy(strm, cell, length+1);
PQclear_throw("lo_read can not read all bytes of object");
strm[length]=0;
str=strm;	str=strm;
} else	} else
str=0;	str=0;
if(lo_close(conn, fd)<0)
PQclear_throwPQerror;
} else
PQclear_throwPQerror;
} else {
// normal column, read it normally
length=(size_t)PQgetlength(res, r, i);
if(length) {
char* strm=(char*)services.malloc(length+1);
memcpy(strm, cell, length+1);
str=strm;
} else
str=0;
}	}

if(transcode_needed && str && length){	if(str && length && transcode_column[i]){
// transcode cell value from ?ClientCharset to $request:charset	// transcode cell value from ?ClientCharset to $request:charset
services.transcode(str, length,	services.transcode(str, length,
str, length,	str, length,
connection.client_charset,	client_charset,
services.request_charset());	request_charset);
}	}

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

	if(connection.autocommit)
	commit(aconnection);
}	}

private:	private:
Line 387 private:	Line 470 private:
Placeholder& ph=placeholders[i];	Placeholder& ph=placeholders[i];
if(transcode_needed){	if(transcode_needed){
size_t name_length;	size_t name_length;
size_t value_length;
connection.services->transcode(ph.name, strlen(ph.name),	connection.services->transcode(ph.name, strlen(ph.name),
ph.name, name_length,	ph.name, name_length,
connection.services->request_charset(),	connection.services->request_charset(),
connection.client_charset);	connection.client_charset);

if(ph.value) {	if(ph.value) {
	size_t value_length;
connection.services->transcode(ph.value, strlen(ph.value),	connection.services->transcode(ph.value, strlen(ph.value),
ph.value, value_length,	ph.value, value_length,
connection.services->request_charset(),	connection.services->request_charset(),
Line 401 private:	Line 484 private:
}	}
}	}
int name_numner=atoi(ph.name);	int name_numner=atoi(ph.name);
if(name_numner <= 0 \|\| name_numner > placeholders_count)	if(name_numner <= 0 \|\| (size_t)name_numner > placeholders_count)
connection.services->_throw("bad bind parameter key");	connection.services->_throw("bad bind parameter key");

paramValues[name_numner-1]=ph.value;	paramValues[name_numner-1]=ph.value;
Line 409 private:	Line 492 private:
}	}


/**	void _transaction_begin(Connection& connection){
Executes a query and throw away the result.	_execute_transactions_cmd(connection, "BEGIN");
*/	}

	void _transaction_commit(Connection& connection){
	_execute_transactions_cmd(connection, "COMMIT");
	}

	void _transaction_rollback(Connection& connection){
	_execute_transactions_cmd(connection, "ROLLBACK");
	}

	void _execute_transactions_cmd(const Connection& connection, const char *query){
	if(!connection.without_default_transactions) // with option ?WithoutDefaultTransaction=1 user must execute BEGIN/COMMIT/ROLLBACK by himself
	_execute_cmd(connection, query);
	}

	// executes a query and throw away the result.
void _execute_cmd(const Connection& connection, const char *query){	void _execute_cmd(const Connection& connection, const char *query){
if(PGresult *res=PQexec(connection.conn, query))	if(PGresult *res=PQexec(connection.conn, query))
PQclear(res); // throw out the result [don't need but must call]	PQclear(res); // throw away the result [don't need but must call]
else	else
throwPQerror;	throwPQerror;
}	}

void _begin_transaction(Connection& connection){
if(connection.autocommit)
_execute_cmd(connection, "BEGIN");
}

const char *_preprocess_statement(	const char *_preprocess_statement(
Connection& connection,	Connection& connection,
const char *astatement,	const char *astatement,
Line 510 private:	Line 603 private:
return result;	return result;
}	}

bool _transcode_required(Connection& connection){
return (connection.client_charset && strcmp(connection.client_charset, connection.services->request_charset())!=0);
}

private: // lo_read/write exchancements	private: // lo_read/write exchancements

bool lo_read_ex(PGconn conn, int fd, const/paf/ char buf, size_t len) {	bool lo_read_ex(PGconn conn, int fd, const/paf/ char buf, size_t len) {

E-mail:

Removed from v.1.30
changed lines
	Added in v.1.35