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.29 and 1.31

version 1.29, 2008/06/24 17:43:48	version 1.31, 2008/07/01 13:40:33
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 36 static const char *RCSId="$Id$";	Line 49 static const char *RCSId="$Id$";
#endif	#endif

#ifndef max	#ifndef max
inline int max(int a,int b) { return a>b?a:b; }	inline int max(int a,int b){ return a>b?a:b; }
inline int min(int a,int b){ return a<b?a:b; }	inline int min(int a,int b){ return a<b?a:b; }
#endif	#endif

static char lsplit(char string, char delim) {	static char lsplit(char string, char delim){
if(string) {	if(string){
char *v=strchr(string, delim);	if(char *v=strchr(string, delim)){
if(v) {
*v=0;	*v=0;
return v+1;	return v+1;
}	}
Line 51 static char lsplit(char string, char d	Line 63 static char lsplit(char string, char d
return 0;	return 0;
}	}

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

static char* rsplit(char* string, char delim) {	static char* rsplit(char* string, char delim){
if(string) {	if(string){
char* v=strrchr(string, delim);	if(char* v=strrchr(string, delim)){
if(v) {
*v=0;	*v=0;
return v+1;	return v+1;
}	}
Line 69 static char* rsplit(char* string, char d	Line 80 static char* rsplit(char* string, char d
return NULL;	return NULL;
}	}

static void toupper_str(char out, const char in, size_t size) {	static void toupper_str(char out, const char in, size_t size){
while(size--)	while(size--)
out++=(char)toupper(in++);	out++=(char)toupper(in++);
}	}
Line 78 struct Connection {	Line 89 struct Connection {
SQL_Driver_services* services;	SQL_Driver_services* services;

PGconn *conn;	PGconn *conn;
const char* cstrClientCharset;	const char* client_charset;
bool autocommit;	bool autocommit;
	bool without_default_transactions;
};	};

/**	/**
Line 92 public:	Line 104 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(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";
}	}
Line 110 public:	Line 122 public:
/** connect	/** connect
@param url	@param url
format: @b user:pass@host[:port]\|[local]/database?	format: @b user:pass@host[:port]\|[local]/database?
ClientCharset=xyz& // transcode by parser	ClientCharset=charset& // transcode by parser
charset=xyz& // transcode by server with 'set CLIENT_ENCODING=xyz'	charset=value& // transcode by server with 'SET CLIENT_ENCODING=value'
datestyle=xyz& // set DATESTYLE=xyz	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 auto commit, 'BEGIN TRAN' at connection start and COMMIT/ROLLBACK at the end [can't be used together with autocommit option]
*/	*/
void connect(	void connect(
char *url,	char* url,
SQL_Driver_services& services,	SQL_Driver_services& services,
void *connection_ref ///< output: Connection	void** connection_ref ///< output: Connection*
) {	){
char *user=url;	char* user=url;
char *host=rsplit(user, '@');	char* host=rsplit(user, '@');
char *db=lsplit(host, '/');	char* db=lsplit(host, '/');
char *pwd=lsplit(user, ':');	char* pwd=lsplit(user, ':');
char *port=lsplit(host, ':');	char* port=lsplit(host, ':');

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

char *cstrBackwardCompAskServerToTranscode=0;	char* charset=0;
char* datestyle=0;	char* datestyle=0;

Connection& connection=(Connection )services.malloc(sizeof(Connection));	Connection& connection=(Connection )services.malloc(sizeof(Connection));
*connection_ref=&connection;	*connection_ref=&connection;
connection.services=&services;	connection.services=&services;
connection.cstrClientCharset=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 151 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.cstrClientCharset=value;	connection.client_charset=value;
} else if(strcasecmp(key, "charset")==0){ // transcoding with server	} else if(strcasecmp(key, "charset")==0){
cstrBackwardCompAskServerToTranscode=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 172 public:	Line 192 public:
}	}
}	}

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

execute_resultless(connection, statement);	_execute_cmd(connection, statement);
}	}

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

execute_resultless(connection, statement);	_execute_cmd(connection, statement);
}	}

begin_transaction(connection);	_begin_transaction(connection);
}	}

void disconnect(void *aconnection) {	void disconnect(void *aconnection){
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);

PQfinish(connection.conn);	PQfinish(connection.conn);
connection.conn=0;	connection.conn=0;
}	}

void commit(void *aconnection) {	void commit(void *aconnection){
execute_transaction_cmd(aconnection, "COMMIT");	Connection& connection=static_cast<Connection>(aconnection);
	if(!connection.without_default_transactions){
	_execute_cmd(connection, "COMMIT");
	}
	_begin_transaction(connection);
}	}

void rollback(void *aconnection) {	void rollback(void *aconnection){
execute_transaction_cmd(aconnection, "ROLLBACK");	Connection& connection=static_cast<Connection>(aconnection);
	if(!connection.without_default_transactions){
	_execute_cmd(connection, "ROLLBACK");
	}
	_begin_transaction(connection);
}	}

bool ping(void *aconnection) {	bool ping(void *aconnection) {
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);

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

const char* quote(	const char* quote(void aconnection, const char from, unsigned int length){
void *aconnection,
const char *from, unsigned int length) {
Connection& connection=static_cast<Connection>(aconnection);	Connection& connection=static_cast<Connection>(aconnection);

char result=(char)connection.services->malloc_atomic(length*2+1);	char result=(char)connection.services->malloc_atomic(length*2+1);
int err=0;	int err=0;
PQescapeStringConn (connection.conn,	PQescapeStringConn(connection.conn, result, from, length, &err);
result, from, length,
&err);
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,
unsigned long offset, unsigned long limit,	unsigned long offset, unsigned long limit,
SQL_Driver_query_event_handlers& handlers) {	SQL_Driver_query_event_handlers& handlers
// _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;

	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){
//services._throw("bind variables not supported (yet)");	int binds_size=sizeof(char)*placeholders_count;
int binds_size=sizeof(char) * placeholders_count;
paramValues = static_cast<const char**>(services.malloc_atomic(binds_size));	paramValues = static_cast<const char**>(services.malloc_atomic(binds_size));
bind_parameters(placeholders_count, placeholders, paramValues, connection);	_bind_parameters(placeholders_count, placeholders, paramValues, connection, transcode_needed);
}	}

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

const char *statement=preprocess_statement(connection,	const char *statement=_preprocess_statement(connection, astatement, offset, limit);
astatement, offset, limit);	// error after prepare?

PGresult *res;	PGresult *res;
if(placeholders_count>0){	if(placeholders_count>0){
Line 264 public:	Line 288 public:
throwPQerror;	throwPQerror;

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:	case PGRES_COMMAND_OK: // empty result: insert\|delete\|update\|...
// empty result: insert\|delete\|update\|...	PQclear(res);
PQclear(res);	return;
return;	case PGRES_TUPLES_OK:
case PGRES_TUPLES_OK:	break;
break;	default:
default:	PQclear_throwPQerror;
PQclear_throwPQerror;	break;
break;
}	}

int column_count=PQnfields(res);	int column_count=PQnfields(res);
Line 290 public:	Line 313 public:
goto cleanup; \	goto cleanup; \
}	}

	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++){
char *name=PQfname(res, i);	char *name=PQfname(res, i);
size_t length=strlen(name);	size_t length=strlen(name);
	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* 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 from ?ClientCharset to $request:charset	if(transcode_needed)
if(cstrClientCharset)	// transcode column name from ?ClientCharset to $request:charset
services.transcode(str, length,	services.transcode(str, length,
str, length,	str, length,
cstrClientCharset,	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 365 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(str && length) {	if(str && length && transcode_column[i]){
// transcode from ?ClientCharset to $request:charset	//services._throw("tr");
if(cstrClientCharset)	// transcode cell value from ?ClientCharset to $request:charset
services.transcode(str, length,	services.transcode(str, length,
str, length,	str, length,
cstrClientCharset,	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 374 cleanup:	Line 425 cleanup:
PQclear(res);	PQclear(res);
if(failed)	if(failed)
services._throw(sql_error);	services._throw(sql_error);
}

private: // private funcs	commit(aconnection);
	}

void bind_parameters(	private:
size_t placeholders_count,	void _bind_parameters(
Placeholder* placeholders,	size_t placeholders_count,
const char** paramValues,	Placeholder* placeholders,
Connection& connection	const char** paramValues,
) {	Connection& connection,
for(size_t i=0; i<placeholders_count; i++) {	bool transcode_needed
	){
	for(size_t i=0; i<placeholders_count; i++){
Placeholder& ph=placeholders[i];	Placeholder& ph=placeholders[i];
size_t value_length;	if(transcode_needed){
if(connection.cstrClientCharset) {
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.cstrClientCharset);	connection.client_charset);

if(ph.value) {	if(ph.value) {
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(),
connection.cstrClientCharset);	connection.client_charset);
}	}
}	}
if( atoi(ph.name) <= 0 \|\| atoi(ph.name) > placeholders_count) {	int name_numner=atoi(ph.name);
	if(name_numner <= 0 \|\| name_numner > placeholders_count)
connection.services->_throw("bad bind parameter key");	connection.services->_throw("bad bind parameter key");
}
paramValues[atoi(ph.name)-1] = ph.value;
}
}


void execute_transaction_cmd(void aconnection, const char query) {
Connection& connection=static_cast<Connection>(aconnection);

if(connection.autocommit){	paramValues[name_numner-1]=ph.value;
Connection& connection=static_cast<Connection>(aconnection);
execute_resultless(connection, query);
}	}

begin_transaction(connection);
}	}


/**	/**
Executes a query and throws the result.	Executes a query and throw away the result.
*/	*/
void execute_resultless(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 out the result [don't need but must call]
else	else
throwPQerror;	throwPQerror;
}	}

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

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

size_t statement_size=strlen(astatement);	size_t statement_size=strlen(astatement);
Line 448 private: // private funcs	Line 494 private: // private funcs
+1);	+1);
// offset & limit -> suffixes	// offset & limit -> suffixes
const char *o;	const char *o;
if(offset \|\| limit) {	if(offset \|\| limit!=SQL_NO_LIMIT){
char *cur=result;	char *cur=result;
memcpy(cur, astatement, statement_size); cur+=statement_size;	memcpy(cur, astatement, statement_size); cur+=statement_size;
if(limit)	if(limit!=SQL_NO_LIMIT)
cur+=snprintf(cur, 7+MAX_NUMBER, " limit %u", limit);	cur+=snprintf(cur, 7+MAX_NUMBER, " limit %u", limit);
if(offset)	if(offset)
cur+=snprintf(cur, 8+MAX_NUMBER, " offset %u", offset);	cur+=snprintf(cur, 8+MAX_NUMBER, " offset %u", offset);
Line 569 private: // conn client library funcs	Line 615 private: // conn client library funcs
typedef char* (t_PQgetvalue)(const PGresult res,	typedef char* (t_PQgetvalue)(const PGresult res,
int tup_num,	int tup_num,
int field_num); t_PQgetvalue PQgetvalue;	int field_num); t_PQgetvalue PQgetvalue;
typedef int (t_PQntuples)(const PGresult res); t_PQntuples PQntuples;	typedef int (t_PQntuples)(const PGresult res); t_PQntuples PQntuples;
typedef char (t_PQfname)(const PGresult *res,	typedef char (t_PQfname)(const PGresult *res,
int field_index); t_PQfname PQfname;	int field_index); t_PQfname PQfname;
typedef int (t_PQnfields)(const PGresult res); t_PQnfields PQnfields;	typedef int (t_PQnfields)(const PGresult res); t_PQnfields PQnfields;

E-mail:

Removed from v.1.29
changed lines
	Added in v.1.31