sql/sqlite/parser3sqlite.C - diff

Return to parser3sqlite.C CVS log

Up to [parser3project] / sql / sqlite

Diff for /sql/sqlite/parser3sqlite.C between versions 1.16 and 1.20

version 1.16, 2019/11/30 21:51:35	version 1.20, 2021/11/08 09:03:09
Line 18 volatile const char * IDENT_PARSER3SQLIT	Line 18 volatile const char * IDENT_PARSER3SQLIT
#define MAX_NUMBER 20	#define MAX_NUMBER 20

#define SQLITE_DEFAULT_CHARSET "UTF-8"	#define SQLITE_DEFAULT_CHARSET "UTF-8"
	#define PA_REGEXP

#if _MSC_VER	#if _MSC_VER
# define snprintf _snprintf	# define snprintf _snprintf
Line 57 struct Connection {	Line 58 struct Connection {
int busy_timeout;	int busy_timeout;
};	};

	// sqlite client library funcs

	typedef int (t_sqlite3_open)(const char filename, sqlite3 **ppDb); t_sqlite3_open pa_sqlite3_open;

	typedef int (t_sqlite3_close)(sqlite3 ); t_sqlite3_close pa_sqlite3_close;

	typedef int (t_sqlite3_busy_timeout)(sqlite3, int ms); t_sqlite3_busy_timeout pa_sqlite3_busy_timeout;

	typedef int (t_sqlite3_exec)(sqlite3, const char sql, sqlite3_callback, void , char **errmsg); t_sqlite3_exec pa_sqlite3_exec;

	typedef void (t_sqlite3_free)(char z); t_sqlite3_free pa_sqlite3_free;

	typedef const char ( t_sqlite3_errmsg)(sqlite3*); t_sqlite3_errmsg pa_sqlite3_errmsg;

	typedef int (* t_sqlite3_prepare)(sqlite3 db, const char zSql, int nBytes, sqlite3_stmt ppStmt, const char pzTail); t_sqlite3_prepare pa_sqlite3_prepare;

	typedef int (* t_sqlite3_column_count)(sqlite3_stmt *pStmt); t_sqlite3_column_count pa_sqlite3_column_count;

	typedef int (* t_sqlite3_finalize)(sqlite3_stmt *pStmt); t_sqlite3_finalize pa_sqlite3_finalize;

	typedef const char ( t_sqlite3_column_name)(sqlite3_stmt*,int); t_sqlite3_column_name pa_sqlite3_column_name;

	typedef int (* t_sqlite3_step)(sqlite3_stmt*); t_sqlite3_step pa_sqlite3_step;

	typedef int (* t_sqlite3_column_type)(sqlite3_stmt*, int iCol); t_sqlite3_column_type pa_sqlite3_column_type;

	typedef const unsigned char ( t_sqlite3_column_text)(sqlite3_stmt*, int iCol); t_sqlite3_column_text pa_sqlite3_column_text;

	typedef const unsigned char ( t_sqlite3_column_blob)(sqlite3_stmt*, int iCol); t_sqlite3_column_blob pa_sqlite3_column_blob;

	typedef int (* t_sqlite3_column_bytes)(sqlite3_stmt*, int iCol); t_sqlite3_column_bytes pa_sqlite3_column_bytes;

	#ifdef PA_REGEXP
	typedef int (* t_sqlite3_create_function)(sqlite3 , const char , int, int, void , void ()(sqlite3_context,int,sqlite3_value), void , void *); t_sqlite3_create_function pa_sqlite3_create_function;

	typedef const unsigned char ( t_sqlite3_value_text)(sqlite3_value*); static t_sqlite3_value_text pa_sqlite3_value_text;

	typedef void ( t_sqlite3_get_auxdata)(sqlite3_context*, int N); static t_sqlite3_get_auxdata pa_sqlite3_get_auxdata;

	typedef void (* t_sqlite3_set_auxdata)(sqlite3_context, int N, void, void ()(void)); static t_sqlite3_set_auxdata pa_sqlite3_set_auxdata;

	typedef void (* t_sqlite3_result_error)(sqlite3_context, const char, int); static t_sqlite3_result_error pa_sqlite3_result_error;

	typedef void (* t_sqlite3_result_error_nomem)(sqlite3_context*); static t_sqlite3_result_error_nomem pa_sqlite3_result_error_nomem;

	typedef void (* t_sqlite3_result_int)(sqlite3_context*, int); static t_sqlite3_result_int pa_sqlite3_result_int;


	// "regexp.h" hardcoded
	struct ReCompiled;
	const char pa_re_compile(ReCompiled ppRe, const char zIn, int noCase);
	void pa_re_free(ReCompiled *pRe);
	int pa_re_match(ReCompiled pRe, const unsigned char zIn, int nIn);

	// regexp(pattern, string) sqlite3 function implementation
	static void regexp_sql_func(sqlite3_context context, int argc, sqlite3_value *argv){
	ReCompiled pRe = (ReCompiled )pa_sqlite3_get_auxdata(context, 0);
	int setAux = 0; /* True to invoke sqlite3_set_auxdata() */

	if( pRe==0 ){
	const char zPattern = (const char)pa_sqlite3_value_text(argv[0]);
	if( zPattern==0 ) return;
	const char *zErr = pa_re_compile(&pRe, zPattern, 0);
	if( zErr ){
	pa_re_free(pRe);
	pa_sqlite3_result_error(context, zErr, -1);
	return;
	}
	if( pRe==0 ){
	pa_sqlite3_result_error_nomem(context);
	return;
	}
	setAux = 1;
	}
	const unsigned char zStr = (const unsigned char)pa_sqlite3_value_text(argv[1]);
	if( zStr!=0 ){
	pa_sqlite3_result_int(context, pa_re_match(pRe, zStr, -1));
	}
	if( setAux ){
	pa_sqlite3_set_auxdata(context, 0, pRe, (void()(void))pa_re_free);
	}
	}
	#endif


/**	/**
Line 73 public:	Line 157 public:

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

/** connect	/** connect
Line 155 public:	Line 238 public:
}	}


int rc=sqlite3_open(db_path, &connection.handle);	int rc=pa_sqlite3_open(db_path, &connection.handle);
	#ifdef PA_REGEXP
	if(rc==SQLITE_OK)
	rc=pa_sqlite3_create_function(connection.handle, "regexp", 2, SQLITE_UTF8, 0, regexp_sql_func, 0, 0);
	#endif
if(rc!=SQLITE_OK){	if(rc!=SQLITE_OK){
const char* error_msg=sqlite3_errmsg(connection.handle);	const char* error_msg=pa_sqlite3_errmsg(connection.handle);
sqlite3_close(connection.handle);	pa_sqlite3_close(connection.handle);
_throw(connection, error_msg);	_throw(connection, error_msg);
}	}

sqlite3_busy_timeout(connection.handle, connection.busy_timeout);	pa_sqlite3_busy_timeout(connection.handle, connection.busy_timeout);

_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);
sqlite3_close(connection.handle);	pa_sqlite3_close(connection.handle);
connection.handle=0;	connection.handle=0;
}	}

Line 276 public:	Line 363 public:
bool failed=false;	bool failed=false;

do{ // cycling through SQL commands	do{ // cycling through SQL commands
rc=sqlite3_prepare(connection.handle, statement, -1, &SQL, &pzTail);	rc=pa_sqlite3_prepare(connection.handle, statement, -1, &SQL, &pzTail);
next_statement_length=strlen(pzTail);	next_statement_length=strlen(pzTail);
if(rc!=SQLITE_OK){	if(rc!=SQLITE_OK){
//sqlite3_free((char*)pzTail);	//pa_sqlite3_free((char*)pzTail);
_throw(connection, sqlite3_errmsg(connection.handle));	_throw(connection, pa_sqlite3_errmsg(connection.handle));
}	}
if(!connection.multi_statements && next_statement_length>0){ // multi statements was not allowed but pzTail point to not empty one	if(!connection.multi_statements && next_statement_length>0){ // multi statements was not allowed but pzTail point to not empty one
//sqlite3_free((char*)pzTail);	//pa_sqlite3_free((char*)pzTail);
_throw(connection, "multi statements are not allowed until option ?multi_statements=1 in connect string is specified.");	_throw(connection, "multi statements are not allowed until option ?multi_statements=1 in connect string is specified.");
}	}

#define CHECK(afailed) if(afailed){ failed=true; goto cleanup; }	#define CHECK(afailed) if(afailed){ failed=true; goto cleanup; }

int column_count=sqlite3_column_count(SQL);	int column_count=pa_sqlite3_column_count(SQL);

if(!column_count){ // empty result: insert\|delete\|update\|...	if(!column_count){ // empty result: insert\|delete\|update\|...
rc=sqlite3_step(SQL);	rc=pa_sqlite3_step(SQL);
} else {	} else {
for(int i=0; i<column_count; i++){	for(int i=0; i<column_count; i++){
const char *column_name=sqlite3_column_name(SQL, i);	const char *column_name=pa_sqlite3_column_name(SQL, i);
size_t length=strlen(column_name);	size_t length=strlen(column_name);

char* strm=(char*)services.malloc_atomic(length+1);	char* strm=(char*)services.malloc_atomic(length+1);
Line 317 public:	Line 404 public:
size_t length=0;	size_t length=0;

do{	do{
rc=sqlite3_step(SQL);	rc=pa_sqlite3_step(SQL);
if(rc==SQLITE_ROW){ // new line!!	if(rc==SQLITE_ROW){ // new line!!

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++){
// SQLite allow to get value of any type using sqlite3_column_text function	// SQLite allow to get value of any type using pa_sqlite3_column_text function
bool transcode_value=false;	bool transcode_value=false;
int column_type=sqlite3_column_type(SQL, i);	int column_type=pa_sqlite3_column_type(SQL, i);
switch(column_type){	switch(column_type){
case SQLITE_NULL:	case SQLITE_NULL:
length=0;	length=0;
str=NULL;	str=NULL;
break;	break;
case SQLITE_BLOB:	case SQLITE_BLOB:
str=(const char*)sqlite3_column_blob(SQL, i);	str=(const char*)pa_sqlite3_column_blob(SQL, i);
length=(size_t)sqlite3_column_bytes(SQL, i);	length=(size_t)pa_sqlite3_column_bytes(SQL, i);
break;	break;
case SQLITE_TEXT: // for text transcoding can be required	case SQLITE_TEXT: // for text transcoding can be required
default: // anything else?	default: // anything else?
transcode_value=transcode_needed;	transcode_value=transcode_needed;
case SQLITE_INTEGER:	case SQLITE_INTEGER:
case SQLITE_FLOAT:	case SQLITE_FLOAT:
str=(const char*)sqlite3_column_text(SQL, i);	str=(const char*)pa_sqlite3_column_text(SQL, i);
length=(size_t)sqlite3_column_bytes(SQL, i);	length=(size_t)pa_sqlite3_column_bytes(SQL, i);
break;	break;
}	}

Line 370 public:	Line 457 public:
}	}

if(rc==SQLITE_ERROR \|\| rc==SQLITE_MISUSE){	if(rc==SQLITE_ERROR \|\| rc==SQLITE_MISUSE){
_throw(connection, sqlite3_errmsg(connection.handle));	_throw(connection, pa_sqlite3_errmsg(connection.handle));
}	}

cleanup:	cleanup:
sqlite3_finalize(SQL);	pa_sqlite3_finalize(SQL);
statement=pzTail;	statement=pzTail;
} while (next_statement_length>0);	} while (next_statement_length>0);

Line 391 private:	Line 478 private:

void _execute_cmd(Connection& connection, const char* statement){	void _execute_cmd(Connection& connection, const char* statement){
char* zErr;	char* zErr;
int rc=sqlite3_exec(connection.handle, statement, 0, 0, &zErr);	int rc=pa_sqlite3_exec(connection.handle, statement, 0, 0, &zErr);
if(rc!=SQLITE_OK){	if(rc!=SQLITE_OK){
size_t length=strlen(zErr);	size_t length=strlen(zErr);
char* err_msg=(char *)connection.services->malloc_atomic(length+1);	char* err_msg=(char *)connection.services->malloc_atomic(length+1);
memcpy(err_msg, zErr, length);	memcpy(err_msg, zErr, length);

sqlite3_free(zErr);	pa_sqlite3_free(zErr);
_throw(connection, err_msg);	_throw(connection, err_msg);
}	}

Line 420 private:	Line 507 private:
}	}


private: // sqlite client library funcs

typedef int (t_sqlite3_open)(const char filename, sqlite3 **ppDb); t_sqlite3_open sqlite3_open;

typedef int (t_sqlite3_close)(sqlite3 ); t_sqlite3_close sqlite3_close;

typedef int (t_sqlite3_busy_timeout)(sqlite3, int ms); t_sqlite3_busy_timeout sqlite3_busy_timeout;

typedef int (t_sqlite3_exec)(sqlite3, const char sql, sqlite3_callback, void , char **errmsg); t_sqlite3_exec sqlite3_exec;

typedef void (t_sqlite3_free)(char z); t_sqlite3_free sqlite3_free;

typedef const char ( t_sqlite3_errmsg)(sqlite3*); t_sqlite3_errmsg sqlite3_errmsg;

typedef int (* t_sqlite3_prepare)(sqlite3 db, const char zSql, int nBytes, sqlite3_stmt ppStmt, const char pzTail); t_sqlite3_prepare sqlite3_prepare;

typedef int (* t_sqlite3_column_count)(sqlite3_stmt *pStmt); t_sqlite3_column_count sqlite3_column_count;

typedef int (* t_sqlite3_finalize)(sqlite3_stmt *pStmt); t_sqlite3_finalize sqlite3_finalize;

typedef const char ( t_sqlite3_column_name)(sqlite3_stmt*,int); t_sqlite3_column_name sqlite3_column_name;

typedef int (* t_sqlite3_step)(sqlite3_stmt*); t_sqlite3_step sqlite3_step;

typedef int (* t_sqlite3_column_type)(sqlite3_stmt*, int iCol); t_sqlite3_column_type sqlite3_column_type;

typedef const unsigned char ( t_sqlite3_column_text)(sqlite3_stmt*, int iCol); t_sqlite3_column_text sqlite3_column_text;

typedef const unsigned char ( t_sqlite3_column_blob)(sqlite3_stmt*, int iCol); t_sqlite3_column_blob sqlite3_column_blob;

typedef int (* t_sqlite3_column_bytes)(sqlite3_stmt*, int iCol); t_sqlite3_column_bytes sqlite3_column_bytes;


private: // sqlite client library funcs linking	private: // sqlite client library funcs linking

const char dlink(const char dlopen_file_spec) {	const char dlink(char dlopen_file_spec) {
if(lt_dlinit()){	if(lt_dlinit()){
if(const char* result=lt_dlerror())	if(const char* result=lt_dlerror())
return result;	return result;
return "can not prepare to dynamic loading";	return "can not prepare to dynamic loading";
}	}

lt_dlhandle handle=lt_dlopen(dlopen_file_spec);	lt_dlhandle handle;
	do {
	char *next=lsplit(dlopen_file_spec, ',');
	handle=lt_dlopen(dlopen_file_spec);
	dlopen_file_spec=next;
	} while (!handle && dlopen_file_spec);

if(!handle){	if(!handle){
if(const char* result=lt_dlerror())	if(const char* result=lt_dlerror())
Line 471 private: // sqlite client library funcs	Line 530 private: // sqlite client library funcs
}	}

#define DSLINK(name, action) \	#define DSLINK(name, action) \
name=(t_##name)lt_dlsym(handle, #name); \	pa_##name=(t_##name)lt_dlsym(handle, #name); \
if(!name) \	if(!pa_##name) \
action;	action;

#define DLINK(name) DSLINK(name, return "function " #name " was not found")	#define DLINK(name) DSLINK(name, return "function " #name " was not found")
Line 493 private: // sqlite client library funcs	Line 552 private: // sqlite client library funcs
DLINK(sqlite3_column_text);	DLINK(sqlite3_column_text);
DLINK(sqlite3_column_blob);	DLINK(sqlite3_column_blob);
DLINK(sqlite3_column_bytes);	DLINK(sqlite3_column_bytes);
	#ifdef PA_REGEXP
	DLINK(sqlite3_create_function);
	DLINK(sqlite3_value_text);
	DLINK(sqlite3_get_auxdata);
	DLINK(sqlite3_set_auxdata);
	DLINK(sqlite3_result_error);
	DLINK(sqlite3_result_error_nomem);
	DLINK(sqlite3_result_int);
	#endif
return 0;	return 0;
}	}

E-mail:

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