[[ Sqlite382 ]] Added second option parameter to connection - 'binary' and 'extensions'

runrevmark · runrevmark · commit f9106bd1a250 · 2014-01-29T13:12:09.000Z
[[ Sqlite382 ]] If 'binary' specified then no binary encode/decode is done on BLOB columns - the data is stored in sqlite verbatim.
[[ Sqlite382 ]] If 'extensions' specified then loading extensions is enabled.
diff --git a/revdb/src/dbsqlite.h b/revdb/src/dbsqlite.h
@@ -44,7 +44,7 @@ along with LiveCode.  If not see <http://www.gnu.org/licenses/>.  */
 class DBCursor_SQLITE : public CDBCursor
 {
 	public:
-		DBCursor_SQLITE(SqliteDatabase &db);
+		DBCursor_SQLITE(SqliteDatabase &db, bool enable_binary);
 		virtual ~DBCursor_SQLITE();
 		
 		Bool open(DBConnection *newconnection);
@@ -62,6 +62,9 @@ class DBCursor_SQLITE : public CDBCursor
 		Bool getFieldsInformation();
 		SqliteDatabase &mDB;
 		Dataset *mDataset;
+	
+	// MW-2014-01-29: [[ Sqlite382 ]] If true the binary data will not be decoded.
+	bool m_enable_binary : 1;
 };
 
 class DBConnection_SQLITE : public CDBConnection
@@ -71,7 +74,8 @@ class DBConnection_SQLITE : public CDBConnection
 		~DBConnection_SQLITE();
 
 		Bool IsError();
-
+		bool IsBinaryEnabled(void);
+	
 		Bool connect(char **args, int numargs);
 
 		void disconnect();
@@ -101,5 +105,8 @@ class DBConnection_SQLITE : public CDBConnection
 		SqliteDatabase mDB;
 		char *mErrorStr;
 		bool mIsError;
+	
+	bool m_enable_extensions : 1;
+	bool m_enable_binary : 1;
 };
 #endif
diff --git a/revdb/src/sqlite_connection.cpp b/revdb/src/sqlite_connection.cpp
@@ -31,6 +31,10 @@ DBConnection_SQLITE::DBConnection_SQLITE() :
 	mIsError(false)
 {
 	connectionType = CT_SQLITE;
+	
+	// MW-2014-01-29: [[ Sqlite382 ]] Make sure options are set to defaults (false).
+	m_enable_binary = false;
+	m_enable_extensions = false;
 }
 
 DBConnection_SQLITE::~DBConnection_SQLITE()
@@ -39,6 +43,11 @@ DBConnection_SQLITE::~DBConnection_SQLITE()
 	disconnect();
 }
 
+bool DBConnection_SQLITE::IsBinaryEnabled(void)
+{
+	return m_enable_binary;
+}
+
 // Only 1 arguments are expected.
 //  args[0]: --unused--
 //  args[1]: filename of database
@@ -50,7 +59,8 @@ Bool DBConnection_SQLITE::connect(char **args, int numargs)
 	Bool ret = False;
 
 
-	if(!isConnected && numargs > 1) {
+	// MW-2014-01-29: [[ Sqlite382 ]] We only need a minimum of one argument.
+	if(!isConnected && numargs >= 1) {
 		char *fname;
 		string bhash;
 		string mash;
@@ -61,6 +71,36 @@ Bool DBConnection_SQLITE::connect(char **args, int numargs)
 		//   path encoded as UTF-8.
 		fname = os_path_to_native_utf8(args[0]);
 		
+		// MW-2014-01-29: [[ Sqlite382 ]] If there's a second argument, then interpret
+		//   it as an options string.
+		if (numargs >= 2)
+		{
+			const char *t_start;
+			t_start = args[1];
+			for(;;)
+			{
+				// Find the end of the item (delimited by ',').
+				const char *t_end;
+				t_end = strchr(t_start, ',');
+				if (t_end == NULL)
+					t_end = t_start + strlen(t_start);
+				
+				// Check to see if we recognise the option (ignoring ones we don't know
+				// anything about).
+				if ((t_end - t_start) == 6 && strncasecmp(t_start, "binary", 6) == 0)
+					m_enable_binary = true;
+				if ((t_end - t_start) == 10 && strncasecmp(t_start, "extensions", 10) == 0)
+					m_enable_extensions = true;
+				
+				// If the end points to NUL we are done.
+				if (*t_end == '\0')
+					break;
+				
+				// Start is the char after the separating ','.
+				t_start = t_end + 1;
+			}
+		}
+
 		try
 		{
 			mDB.setDatabase(fname);
@@ -72,13 +112,18 @@ Bool DBConnection_SQLITE::connect(char **args, int numargs)
 			{
 				ret = True;
 				isConnected = True;
+				
+				// MW-2014-01-29: [[ Sqlite382 ]] Now we have a handle, configure extension
+				//   loading.
+				sqlite3_enable_load_extension(mDB . getHandle(), m_enable_extensions ? 1 : 0);
 			}
 		}
 		catch(DbErrors &e)
 		{
 			mIsError = true;
 			setErrorStr(e.getMsg());
 		}
+
 		free(fname);
 	}
 	return ret;
@@ -193,7 +238,7 @@ DBCursor *DBConnection_SQLITE::sqlQuery(char *query, DBString *args, int numargs
 	}
 
 	try {
-		ret = new DBCursor_SQLITE(mDB);
+		ret = new DBCursor_SQLITE(mDB, m_enable_binary);
 		Dataset *ds = ret->getDataset();
 
 		ds->query(newquery);
@@ -325,6 +370,13 @@ char *replaceString(char *p_string, char *p_find, char *p_replace)
 	return t_output_buffer_copy;
 }
 
+static char num2nibble(int p_nibble)
+{
+	if (p_nibble < 10)
+		return '0' + p_nibble;
+	return 'A' + (p_nibble - 10);
+}
+
 bool queryCallback(void *p_context, int p_placeholder, DBBuffer& p_output)
 {
 	QueryMetadata *t_query_metadata;
@@ -339,11 +391,45 @@ bool queryCallback(void *p_context, int p_placeholder, DBBuffer& p_output)
 	size_t t_escaped_string_length;
 	t_escaped_string_length = 0;
 	
+	// MW-2014-01-29: [[ Sqlite382 ]] If true the value needs quoting, otherwise it is
+	//   already quoted appropriately.
+	bool t_needs_quotes;
+	t_needs_quotes = true;
 	if (t_parameter_value . isbinary)
 	{
-		// According to documentation in sqlitedecode.cpp, this is the required size of output buffer
-		t_escaped_string = malloc(2 + (257 * t_parameter_value . length) / 254);
-		t_escaped_string_length = sqlite_encode_binary((const unsigned char *)t_parameter_value . sptr, t_parameter_value . length, (unsigned char *)t_escaped_string);
+		DBConnection_SQLITE *t_conn;
+		t_conn = (DBConnection_SQLITE *)t_query_metadata -> connection;
+		
+		if (t_conn -> IsBinaryEnabled())
+		{
+			// MW-2014-01-29: [[ Sqlite382 ]] Encode the binary as BLOB literal - X'<hex>'. Thus
+			//   the length of the escaped string is 3 + 2 * size.;
+			t_escaped_string_length = 3 + 2 * t_parameter_value . length;
+			t_escaped_string = malloc(t_escaped_string_length);
+			t_needs_quotes = false;
+			
+			// Quote the binary!
+			char *t_buffer;
+			t_buffer = (char *)t_escaped_string;
+			
+			*t_buffer++ = 'X';
+			*t_buffer++ = '\'';
+			for(size_t i = 0; i < t_parameter_value . length; i++)
+			{
+				char t_high_nibble, t_low_nibble;
+				t_high_nibble = num2nibble(((unsigned)t_parameter_value . sptr[i] & 0xff) >> 4);
+				t_low_nibble = num2nibble(((unsigned)t_parameter_value . sptr[i]) & 0xf);
+				*t_buffer++ = t_high_nibble;
+				*t_buffer++ = t_low_nibble;
+			}
+			*t_buffer++ = '\'';
+		}
+		else
+		{
+			// According to documentation in sqlitedecode.cpp, this is the required size of output buffer
+			t_escaped_string = malloc(2 + (257 * t_parameter_value . length) / 254);
+			t_escaped_string_length = sqlite_encode_binary((const unsigned char *)t_parameter_value . sptr, t_parameter_value . length, (unsigned char *)t_escaped_string);
+		}
 	}
 	else
 	{
@@ -363,18 +449,26 @@ bool queryCallback(void *p_context, int p_placeholder, DBBuffer& p_output)
 		}
 	}
 
-	p_output . ensure(t_escaped_string_length + 2);
-	memcpy(p_output . getFrontier(), "'", 1);
-	p_output . advance(1);
+	if (t_needs_quotes)
+	{
+		p_output . ensure(t_escaped_string_length + 2);
+		memcpy(p_output . getFrontier(), "'", 1);
+		p_output . advance(1);
+	}
+	else
+		p_output . ensure(t_escaped_string_length);
 
 	if (t_escaped_string != NULL)
 	{
 		memcpy(p_output . getFrontier(), t_escaped_string, t_escaped_string_length);
 		p_output . advance(t_escaped_string_length);
 	}
 
-	memcpy(p_output . getFrontier(), "'", 1);
-	p_output . advance(1);
+	if (t_needs_quotes)
+	{
+		memcpy(p_output . getFrontier(), "'", 1);
+		p_output . advance(1);
+	}
 	
 	free(t_escaped_string);
 	return true;
@@ -398,6 +492,7 @@ char *DBConnection_SQLITE::BindVariables(char *p_query, int p_query_length, DBSt
 		QueryMetadata t_query_metadata;
 		t_query_metadata . argument_count = p_argument_count;
 		t_query_metadata . arguments = p_arguments;
+		t_query_metadata . connection = this;
 
 		DBBuffer t_query_buffer(t_parsed_query_length + 1);
 
diff --git a/revdb/src/sqlite_cursor.cpp b/revdb/src/sqlite_cursor.cpp
@@ -40,13 +40,16 @@ last - move to last row of resultset
 
 #include "dbsqlite.h"
 
+#include <sqlitedecode.h>
+
 #define ENTER 
 
-DBCursor_SQLITE::DBCursor_SQLITE(SqliteDatabase &db) 
+DBCursor_SQLITE::DBCursor_SQLITE(SqliteDatabase &db, bool enable_binary) 
 	: mDB(db)
 {
 	ENTER;
 	mDataset = mDB.CreateDataset();
+	m_enable_binary = enable_binary;
 }
 
 DBCursor_SQLITE::~DBCursor_SQLITE()
@@ -283,6 +286,12 @@ Bool DBCursor_SQLITE::getFieldsInformation()
 					MDEBUG0("Type: double\n");
 					tfield->fieldType = FT_DOUBLE;
 					break;
+				case ft_Object :
+					if (m_enable_binary)
+						tfield -> fieldType = FT_BLOB;
+					else
+						tfield -> fieldType = FT_STRING;
+					break;
 				case ft_String :
 				default:
 					MDEBUG0("Type: string\n");
@@ -337,18 +346,48 @@ Bool DBCursor_SQLITE::getRowData()
 			fields[i]->isNull = fv.get_isNull();
 			
 			if(!fields[i]->isNull) {
+				
 				std::string tmp = fv.get_asString();
-				int bufsize = tmp.size();
-				fields[i]->data = new char[tmp.size() + 1];
-
+				
+				// MW-2014-01-29: [[ Sqlite382 ]] If the field type is BLOB and we aren't in binary mode,
+				//   we must decode the data; otherwise we just use the contents directly.
+				if (fv.get_fType() == ft_Object && !m_enable_binary)
+				{
+					// This code has moved from libsqlite/sqlitedataset.cpp:callback().
+					int bufsize;
+					bufsize = tmp.size();
+					
+					char *mybuff;
+					mybuff = (char *)malloc(bufsize);
+					memset(mybuff,0,bufsize);
+					bufsize = sqlite_decode_binary((const unsigned char *)tmp.c_str(), bufsize, ( unsigned char *)mybuff, bufsize);
+					if (bufsize == -1)
+					{
+						fields[i] -> data = NULL;
+						fields[i] -> dataSize = 0;
+						fields[i] -> isNull = True;
+						free(mybuff);
+					}
+					else
+					{
+						fields[i] -> data = mybuff;
+						fields[i] -> dataSize = bufsize;
+					}
+				}
+				else
+				{
+					int bufsize = tmp.size();
+					fields[i]->data = new char[tmp.size() + 1];
+
+					memset(fields[i]->data,0,bufsize+1);
+					memcpy(fields[i]->data, tmp.data(), tmp.size());
+					fields[i]->dataSize = tmp.size();
+				}
+				
 				// OK-2009-05-26: [[Bug 8065]] - Because we copied the data in the line above,
 				// We have to set FreeBuffer otherwise it will not be freed when the cursor is closed,
 				// leading to memory leaks.
 				fields[i] -> freeBuffer = True;
-
-				memset(fields[i]->data,0,bufsize+1);
-				memcpy(fields[i]->data, tmp.data(), tmp.size());
-				fields[i]->dataSize = tmp.size();
 			}
 
 			MDEBUG("getRowData() -- fv=[%s]\n", fields[i]->data);
diff --git a/thirdparty b/thirdparty
@@ -1 +1 @@
-Subproject commit 9f8a6c5ba77904e93af95c77e709d1ab79dea27b
+Subproject commit f6374ac7069bf7da98a27ead3ed1b606d0068b1d
