Thread: [Firebird-checkins] SF.net SVN: firebird:[57663] firebird/trunk (Page 27)

SourceForge Headquarters 1320 Columbia Street Suite 310 San Diego, CA 92101 +1 (858) 422-6466

Revision: 57663
          http://sourceforge.net/p/firebird/code/57663
Author:   alexpeshkoff
Date:     2013-02-17 12:08:53 +0000 (Sun, 17 Feb 2013)
Log Message:
-----------
Modified IStatement interface in our API:
1. Never allocate empty statement - always use att->prepare() to create statement interface
2. Separated IStatement into 2 parts - statement itself and resultset.
3. Added stmt->openCursor() (and att->openCursor() for unprepared statements) to create IResultSet.
4. Always use IMessageMetadata (former IParametersMetadata) to pass message fromat info from client,
   therefore avoiding need in BLR generation in client applications.

Modified Paths:
--------------
    firebird/trunk/builds/posix/Makefile.in.plugins_examples
    firebird/trunk/lang_helpers/gds_codes.ftn
    firebird/trunk/lang_helpers/gds_codes.pas
    firebird/trunk/src/auth/SecureRemotePassword/Message.h
    firebird/trunk/src/auth/SecureRemotePassword/manage/SrpManagement.cpp
    firebird/trunk/src/auth/SecureRemotePassword/server/SrpServer.cpp
    firebird/trunk/src/common/StatementMetadata.cpp
    firebird/trunk/src/common/StatementMetadata.h
    firebird/trunk/src/common/classes/ImplementHelper.cpp
    firebird/trunk/src/common/classes/ImplementHelper.h
    firebird/trunk/src/common/classes/RefMutex.h
    firebird/trunk/src/common/classes/objects_array.h
    firebird/trunk/src/common/utils.cpp
    firebird/trunk/src/common/utils_proto.h
    firebird/trunk/src/dsql/DdlNodes.epp
    firebird/trunk/src/dsql/DdlNodes.h
    firebird/trunk/src/dsql/DsqlCompilerScratch.h
    firebird/trunk/src/dsql/Nodes.h
    firebird/trunk/src/dsql/StmtNodes.cpp
    firebird/trunk/src/dsql/dsql.cpp
    firebird/trunk/src/dsql/dsql.h
    firebird/trunk/src/dsql/dsql_proto.h
    firebird/trunk/src/include/firebird/ExternalEngine.h
    firebird/trunk/src/include/firebird/Provider.h
    firebird/trunk/src/include/gen/codetext.h
    firebird/trunk/src/include/gen/iberror.h
    firebird/trunk/src/include/gen/msgs.h
    firebird/trunk/src/include/gen/sql_code.h
    firebird/trunk/src/include/gen/sql_state.h
    firebird/trunk/src/include/types_pub.h
    firebird/trunk/src/jrd/Database.h
    firebird/trunk/src/jrd/EngineInterface.h
    firebird/trunk/src/jrd/ExtEngineManager.cpp
    firebird/trunk/src/jrd/ExtEngineManager.h
    firebird/trunk/src/jrd/PreparedStatement.cpp
    firebird/trunk/src/jrd/PreparedStatement.h
    firebird/trunk/src/jrd/ResultSet.cpp
    firebird/trunk/src/jrd/cch.cpp
    firebird/trunk/src/jrd/constants.h
    firebird/trunk/src/jrd/exe.h
    firebird/trunk/src/jrd/extds/InternalDS.cpp
    firebird/trunk/src/jrd/extds/InternalDS.h
    firebird/trunk/src/jrd/jrd.cpp
    firebird/trunk/src/jrd/met.epp
    firebird/trunk/src/jrd/par.cpp
    firebird/trunk/src/jrd/par_proto.h
    firebird/trunk/src/jrd/val.h
    firebird/trunk/src/msgs/facilities2.sql
    firebird/trunk/src/msgs/messages2.sql
    firebird/trunk/src/msgs/system_errors2.sql
    firebird/trunk/src/remote/client/interface.cpp
    firebird/trunk/src/remote/protocol.h
    firebird/trunk/src/remote/remote.h
    firebird/trunk/src/remote/server/server.cpp
    firebird/trunk/src/yvalve/YObjects.h
    firebird/trunk/src/yvalve/gds.cpp
    firebird/trunk/src/yvalve/why.cpp

Added Paths:
-----------
    firebird/trunk/src/common/MsgMetadata.cpp
    firebird/trunk/src/common/MsgMetadata.h
    firebird/trunk/src/common/classes/BlrReader.h
    firebird/trunk/src/common/classes/BlrWriter.cpp
    firebird/trunk/src/common/classes/BlrWriter.h
    firebird/trunk/src/common/classes/InternalMessageBuffer.cpp
    firebird/trunk/src/common/classes/InternalMessageBuffer.h
    firebird/trunk/src/dsql/BlrDebugWriter.cpp
    firebird/trunk/src/dsql/BlrDebugWriter.h
    firebird/trunk/src/remote/client/BlrFromMessage.cpp
    firebird/trunk/src/remote/client/BlrFromMessage.h

Removed Paths:
-------------
    firebird/trunk/src/dsql/BlrWriter.cpp
    firebird/trunk/src/dsql/BlrWriter.h
    firebird/trunk/src/jrd/BlrReader.h

Modified: firebird/trunk/builds/posix/Makefile.in.plugins_examples
===================================================================

--- firebird/trunk/builds/posix/Makefile.in.plugins_examples	2013-02-16 02:34:05 UTC (rev 57662)
+++ firebird/trunk/builds/posix/Makefile.in.plugins_examples	2013-02-17 12:08:53 UTC (rev 57663)
@@ -52,7 +52,8 @@
 
 .PHONY: all udrcpp_example dc_example kh_example
 
-all: udrcpp_example dc_example kh_example
+#all: udrcpp_example dc_example kh_example
+all: dc_example kh_example
 
 
 UDR_Objects = $(call makeObjects,../examples/udr,UdrCppExample.cpp)

Modified: firebird/trunk/lang_helpers/gds_codes.ftn
===================================================================
--- firebird/trunk/lang_helpers/gds_codes.ftn	2013-02-16 02:34:05 UTC (rev 57662)
+++ firebird/trunk/lang_helpers/gds_codes.ftn	2013-02-17 12:08:53 UTC (rev 57663)
@@ -1508,6 +1508,12 @@
       PARAMETER (GDS__ee_blr_mismatch_names_count      = 335545047)
       INTEGER*4 GDS__ee_blr_mismatch_name_not_found  
       PARAMETER (GDS__ee_blr_mismatch_name_not_found   = 335545048)
+      INTEGER*4 GDS__bad_result_set                  
+      PARAMETER (GDS__bad_result_set                   = 335545049)
+      INTEGER*4 GDS__wrong_message_length            
+      PARAMETER (GDS__wrong_message_length             = 335545050)
+      INTEGER*4 GDS__no_output_format                
+      PARAMETER (GDS__no_output_format                 = 335545051)
       INTEGER*4 GDS__gfix_db_name                    
       PARAMETER (GDS__gfix_db_name                     = 335740929)
       INTEGER*4 GDS__gfix_invalid_sw                 

Modified: firebird/trunk/lang_helpers/gds_codes.pas
===================================================================
--- firebird/trunk/lang_helpers/gds_codes.pas	2013-02-16 02:34:05 UTC (rev 57662)
+++ firebird/trunk/lang_helpers/gds_codes.pas	2013-02-17 12:08:53 UTC (rev 57663)
@@ -761,6 +761,9 @@
 	gds_max_args_exceeded                = 335545046;
 	gds_ee_blr_mismatch_names_count      = 335545047;
 	gds_ee_blr_mismatch_name_not_found   = 335545048;
+	gds_bad_result_set                   = 335545049;
+	gds_wrong_message_length             = 335545050;
+	gds_no_output_format                 = 335545051;
 	gds_gfix_db_name                     = 335740929;
 	gds_gfix_invalid_sw                  = 335740930;
 	gds_gfix_incmp_sw                    = 335740932;

Modified: firebird/trunk/src/auth/SecureRemotePassword/Message.h
===================================================================
--- firebird/trunk/src/auth/SecureRemotePassword/Message.h	2013-02-16 02:34:05 UTC (rev 57662)
+++ firebird/trunk/src/auth/SecureRemotePassword/Message.h	2013-02-17 12:08:53 UTC (rev 57663)
@@ -1,157 +1,265 @@
-#include "../jrd/align.h"
 #include "../common/classes/alloc.h"
+#include "../common/classes/auto.h"
+#include "../common/StatusHolder.h"
+#include "../common/MsgMetadata.h"
 
+
+// This class helps to work with metadata iface
+class Meta : public Firebird::RefPtr<Firebird::IMessageMetadata>
+{
+public:
+	explicit Meta(Firebird::IStatement* stmt, bool out)
+	{
+		Firebird::LocalStatus s;
+		Firebird::IMessageMetadata* m = out ? stmt->getOutputMetadata(&s) : stmt->getInputMetadata(&s);
+		if (!s.isSuccess())
+		{
+			Firebird::status_exception::raise(s.get());
+		}
+		*((Firebird::RefPtr<Firebird::IMessageMetadata>*)this) = m;
+		m->release();		// reference added by function returning iface
+	}
+};
+
+
 // This class helps to fill FbMessage with correct values
 class Message : public Firebird::FbMessage, public Firebird::GlobalStorage
 {
 public:
-	Message()
-		: blrBuf(getPool()), dataBuf(getPool())
+	Message(Firebird::IMessageMetadata* aMeta)
+		: dataBuf(getPool()), fieldCount(0)
 	{
-		blrLength = 0;
-		blr = NULL;
-		bufferLength = 0;
-		buffer = NULL;
+		Firebird::LocalStatus st;
+		metadata = aMeta;
+		buffer = dataBuf.getBuffer(metadata->getMessageLength(&st));
+		check(&st);
+		metadata->addRef();
+	}
 
-		// start message BLR
-		blrBuf.add(blr_version5);
-		blrBuf.add(blr_begin);
-		blrBuf.add(blr_message);
-		blrBuf.add(0);
-		countOffset = blrBuf.getCount();
-		blrBuf.add(0);
-		blrBuf.add(0);
-
-		varCount = 0;
+	~Message()
+	{
+		metadata->release();
 	}
 
 	template <typename T>
-	unsigned genBlr()
+	static bool checkType(unsigned t, unsigned sz)
 	{
-		// for special types call type-specific BLR generator
-		// for generic types use specialization of whole call
-		return T::genBlr(blrBuf);
+		return T::unknownDataType();
 	}
 
 	template <typename T>
-	void add(unsigned& pos, unsigned& null)
+	unsigned add(unsigned& t, unsigned& sz)
 	{
-		if (blr)
-		{
-			(Firebird::Arg::Gds(isc_random) << "This is already constructed message").raise();
-		}
+		Firebird::LocalStatus st;
 
-		// generate code for variable
-		unsigned align = genBlr<T>();
-		if (align)
+		unsigned l = metadata->getCount(&st);
+		check(&st);
+		if (fieldCount >= metadata->getMessageLength(&st))
 		{
-			bufferLength = FB_ALIGN(bufferLength, align);
+			(Firebird::Arg::Gds(isc_random) <<
+				"Attempt to add to the message more variables then possible").raise();
 		}
-		pos = bufferLength;
-		bufferLength += sizeof(T);
 
-		// generate code for null flag
-		blrBuf.add(blr_short);
-		blrBuf.add(0);
-		align = type_alignments[dtype_short];
-		if (align)
+		t = metadata->getType(&st, fieldCount);
+		check(&st);
+		sz = metadata->getLength(&st, fieldCount);
+		check(&st);
+		if (!checkType<T>(t, sz))
 		{
-			bufferLength = FB_ALIGN(bufferLength, align);
+			(Firebird::Arg::Gds(isc_random) << "Incompatible data type").raise();
 		}
-		null = bufferLength;
-		bufferLength += sizeof(short);
 
-		++varCount;
+		return fieldCount++;
 	}
 
-	void ready()
+	static void check(Firebird::IStatus* status)
 	{
-		if (blr)
-			return;
-
-		// Adjust number of variables
-		blrBuf[countOffset] = (varCount * 2) & 0xFF;
-		blrBuf[countOffset + 1] = ((varCount * 2) >> 8) & 0xFF;
-
-		// Complete blr
-		blrBuf.add(blr_end);
-		blrBuf.add(blr_eoc);
-		blrLength = blrBuf.getCount();
-		blr = blrBuf.begin();
-
-		// Allocate buffer
-		buffer = dataBuf.getBuffer(bufferLength);
+		if (!status->isSuccess())
+		{
+			Firebird::status_exception::raise(status->get());
+		}
 	}
 
-	Firebird::UCharBuffer blrBuf, dataBuf;
-	unsigned countOffset, varCount;
+private:
+	Firebird::UCharBuffer dataBuf;
+	unsigned fieldCount;
 };
 
 template <>
-unsigned Message::genBlr<SLONG>()
+bool Message::checkType<SLONG>(unsigned t, unsigned sz)
 {
-	blrBuf.add(blr_long);
-	blrBuf.add(0);		// scale
-	return type_alignments[dtype_long];
+	return t == SQL_LONG && sz == sizeof(SLONG);
 }
 
+
 // With template magic, we make the fields strongly-typed.
-template <class T>
+template <typename T>
 class Field
 {
 public:
+	class Null
+	{
+	public:
+		Null()
+			: ptr(NULL)
+		{ }
+
+		void linkMessage(short* p)
+		{
+			ptr = p;
+			*ptr = -1;	// mark as null initially
+		}
+
+		operator FB_BOOLEAN() const
+		{
+			return (*ptr) ? FB_TRUE : FB_FALSE;
+		}
+
+		FB_BOOLEAN operator=(FB_BOOLEAN val)
+		{
+			*ptr = val ? -1 : 0;
+			return val;
+		}
+
+	private:
+		short* ptr;
+	};
+
 	explicit Field(Message& m)
-		: msg(m), pos(~0), nullPos(~0)
+		: ptr(NULL), type(0), size(0)
 	{
-		msg.add<T>(pos, nullPos);
+		unsigned ind = m.add<T>(type, size);
+
+		Firebird::LocalStatus st;
+		unsigned tmp = m.metadata->getOffset(&st, ind);
+		Message::check(&st);
+		ptr = (T*)(m.buffer + tmp);
+
+		tmp = m.metadata->getNullOffset(&st, ind);
+		Message::check(&st);
+		null.linkMessage((short*)(m.buffer + tmp));
 	}
 
-	T& operator()()
+	operator T()
 	{
-		msg.ready();
-		return *(T*) (msg.buffer + pos);
+		return *ptr;
 	}
 
-	short& null()
+	T operator= (T newVal)
 	{
-		msg.ready();
-		return *(short*) (msg.buffer + nullPos);
+		*ptr = newVal;
+		null = FB_FALSE;
+		return newVal;
 	}
 
-private:
-	Message& msg;
-	unsigned pos, nullPos;
-};
+	operator const char*()
+	{
+		if (!charBuffer)
+		{
+			charBuffer.reset(FB_NEW(*getDefaultMemoryPool()) char[size + 1]);
+		}
 
-template <short N>
-class VarChar
-{
-public:
-	short len;
-	char data[N];		// This guarantees N > 0
+		getStrValue(charBuffer);
+		return charBuffer;
+	}
 
-	static unsigned genBlr(Firebird::UCharBuffer& blr)
+	const char* operator= (const char* newVal)
 	{
-		blr.add(blr_varying);
-		blr.add(N & 0xFF);
-		blr.add((N >> 8) & 0xFF);
-		return type_alignments[dtype_varying];
+		setStrValue(newVal, strlen(newVal));
+		null = FB_FALSE;
+		return newVal;
 	}
 
-	const VarChar& operator=(const char* str)
+	void set(unsigned length, const void* newVal)
 	{
-		strncpy(data, str, N);
-		len = strlen(str);
-		if (len > N)
-			len = N;
-		return *this;
+		setStrValue(newVal, length);
+		null = FB_FALSE;
 	}
 
-	void set(unsigned short l, void* bytes)
+private:
+	void getStrValue(char* to)
 	{
-		if (l > (unsigned short) N)
-			l = N;
-		memcpy(data, bytes, l);
-		len = l;
+		T::incompatibleDataType();
+		//(Firebird::Arg::Gds(isc_random) << "Incompatible data type").raise();
 	}
+
+	void setStrValue(const void* from, unsigned len)
+	{
+		T::incompatibleDataType();
+		//(Firebird::Arg::Gds(isc_random) << "Incompatible data type").raise();
+	}
+
+	T* ptr;
+	Firebird::AutoPtr<char, Firebird::ArrayDelete<char> > charBuffer;
+
+public:
+	Null null;
+	unsigned type, size;
 };
+
+struct Varying
+{
+	short len;
+	char data[1];
+};
+
+template <>
+bool Message::checkType<Varying>(unsigned t, unsigned /*sz*/)
+{
+	return t == SQL_VARYING;
+}
+
+template<>
+void Field<Varying>::getStrValue(char* to)
+{
+	unsigned len = ptr->len;
+	if (len > size)
+		len = size;
+	memcpy(to, ptr->data, len);
+	to[len] = 0;
+}
+
+template<>
+void Field<Varying>::setStrValue(const void* from, unsigned len)
+{
+	if (len > size)
+		len = size;
+	memcpy(ptr->data, from, len);
+	ptr->len = len;
+}
+
+struct Text
+{
+	char data[1];
+};
+
+template <>
+bool Message::checkType<Text>(unsigned t, unsigned /*sz*/)
+{
+	return t == SQL_TEXT;
+}
+
+template<>
+void Field<Text>::getStrValue(char* to)
+{
+	memcpy(to, ptr->data, size);
+	to[size] = 0;
+	unsigned len = size;
+	while(len--)
+	{
+		if (to[len] == ' ')
+			to[len] = 0;
+		else
+			break;
+	}
+}
+
+template<>
+void Field<Text>::setStrValue(const void* from, unsigned len)
+{
+	if (len > size)
+		len = size;
+	memcpy(ptr->data, from, len);
+	if (len < size)
+		memset(&ptr->data[len], ' ', size - len);
+}

Modified: firebird/trunk/src/auth/SecureRemotePassword/manage/SrpManagement.cpp
===================================================================
--- firebird/trunk/src/auth/SecureRemotePassword/manage/SrpManagement.cpp	2013-02-16 02:34:05 UTC (rev 57662)
+++ firebird/trunk/src/auth/SecureRemotePassword/manage/SrpManagement.cpp	2013-02-17 12:08:53 UTC (rev 57663)
@@ -44,60 +44,64 @@
 
 const unsigned int SZ_LOGIN = 31;
 const unsigned int SZ_NAME = 31;
+typedef Field<Varying> Varfield;
+typedef Field<Text> Name;
 
-template <short N>
-void setField(Field<VarChar<N> >& to, Auth::ICharUserField* from)
+void setField(Name& to, Auth::ICharUserField* from)
 {
 	if (from->entered())
 	{
-		to() = from->get();
-		to.null() = 0;
+		to = from->get();
 	}
 	else
 	{
-		to.null() = -1;
+		to.null = FB_TRUE;
 	}
 }
 
-// Domains
-typedef Field<VarChar<SZ_LOGIN> > Login;
-typedef Field<VarChar<Auth::RemotePassword::SRP_VERIFIER_SIZE> > Verifier;
-typedef Field<VarChar<Auth::RemotePassword::SRP_SALT_SIZE> > Salt;
-typedef Field<VarChar<SZ_NAME> > Name;
 
-void allocField(Firebird::AutoPtr<Name>& field, Message& up, Auth::ICharUserField* value, Firebird::string& update, const char* name)
+void allocField(Auth::ICharUserField* value, Firebird::string& update, const char* name)
 {
 	if (value->entered() || value->specified())
 	{
-		field = new Name(up);
 		update += ' ';
 		update += name;
 		update += "=?,";
 	}
 }
 
+void allocField(Firebird::AutoPtr<Name>& field, Message& up, Auth::ICharUserField* value, const char* name)
+{
+	if (value->entered() || value->specified())
+	{
+		field = new Name(up);
+	}
+}
+
 void assignField(Firebird::AutoPtr<Name>& field, Auth::ICharUserField* name)
 {
 	if (field.hasData())
 	{
 		if (name->entered())
 		{
-			(*field)() = name->get();
-			field->null() = 0;
+			*field = name->get();
+			field->null = FB_FALSE;
 		}
 		else
 		{
 			fb_assert(name->specified());
-			field->null() = -1;
+			field->null = FB_TRUE;
 		}
 	}
 }
 
-template <short N>
-void listField(Auth::ICharUserField* to, Field<VarChar<N> >& from)
+void listField(Auth::ICharUserField* to, Name& from)
 {
-	to->set(from().data);
-	to->setEntered(from.null() == 0 ? 1 : 0);
+	to->setEntered(from.null ? 0 : 1);
+	if (!from.null)
+	{
+		to->set(from);
+	}
 }
 
 }
@@ -137,27 +141,18 @@
 
 		Firebird::LocalStatus s;
 		Firebird::RefPtr<Firebird::ITransaction> ddlTran(att->startTransaction(&s, 0, NULL));
-		if (!s.isSuccess())
-		{
-			Firebird::status_exception::raise(s.get());
-		}
+		
 
 		try
 		{
 			for (const char** sql = script; *sql; ++sql)
 			{
-				att->execute(&s, ddlTran, 0, *sql, 3, 0, NULL, NULL);
-				if (!s.isSuccess())
-				{
-					Firebird::status_exception::raise(s.get());
-				}
+				att->execute(&s, ddlTran, 0, *sql, 3, NULL, NULL);
+				check(&s);
 			}
 
 			ddlTran->commit(&s);
-			if (!s.isSuccess())
-			{
-				Firebird::status_exception::raise(s.get());
-			}
+			check(&s);
 		}
 		catch (const Firebird::Exception&)
 		{
@@ -218,16 +213,10 @@
 
 			Firebird::DispatcherPtr p;
 			att = p->attachDatabase(status, secDbName, dpb.getBufferLength(), dpb.getBuffer());
-			if (!status->isSuccess())
-			{
-				Firebird::status_exception::raise(status->get());
-			}
+			check(status);
 
 			tra = att->startTransaction(status, 0, NULL);
-			if (!status->isSuccess())
-			{
-				Firebird::status_exception::raise(status->get());
-			}
+			check(status);
 		}
 		catch (const Firebird::Exception& ex)
 		{
@@ -266,11 +255,8 @@
 					Firebird::string sql;
 					sql.printf("ALTER ROLE RDB$ADMIN %s AUTO ADMIN MAPPING",
 						user->operation() == MAP_SET_OPER ? "SET" : "DROP");
-					att->execute(status, tra, sql.length(), sql.c_str(), 3, 0, NULL, NULL);
-					if (!status->isSuccess())
-					{
-						Firebird::status_exception::raise(status->get());
-					}
+					att->execute(status, tra, sql.length(), sql.c_str(), 3, NULL, NULL);
+					check(status);
 				}
 				break;
 
@@ -280,166 +266,211 @@
 						"INSERT INTO plg$srp_view(PLG$USER_NAME, PLG$VERIFIER, PLG$SALT, PLG$FIRST, PLG$MIDDLE, PLG$LAST) "
 						"VALUES(?, ?, ?, ?, ?, ?)";
 
-					Message add;
-					Login login(add);
-					Verifier verifier(add);
-					Salt slt(add);
-					Name first(add), middle(add), last(add);
+					Firebird::IStatement* stmt = NULL;
+					try
+					{
+						for (unsigned repeat = 0; ; ++repeat)
+						{
+							stmt = att->prepare(status, tra, 0, insert, 3, Firebird::IStatement::PREPARE_PREFETCH_METADATA);
+							if (status->isSuccess())
+							{
+								break;
+							}
+							else if (repeat > 0)
+							{
+								Firebird::status_exception::raise(status->get());
+							}
 
-					setField(login, user->userName());
-					setField(first, user->firstName());
-					setField(middle, user->middleName());
-					setField(last, user->lastName());
+							const ISC_STATUS* v = status->get();
+							while (v[0] == isc_arg_gds)
+							{
+								if (v[1] == isc_dsql_relation_err)
+								{
+									prepareDataStructures();
+									tra->commit(status);
+									check(status);
+									tra = att->startTransaction(status, 0, NULL);
+									check(status);
+									break;
+								}
+								do
+								{
+									v += 2;
+								} while (v[0] != isc_arg_warning && v[0] != isc_arg_gds && v[0] != isc_arg_end);
+							}
+						}
 
+						fb_assert(stmt);
+
+						Meta im(stmt, false);
+						Message add(im);
+						Name login(add);
+						Varfield verifier(add), slt(add);
+						Name first(add), middle(add), last(add);
+
+						setField(login, user->userName());
+						setField(first, user->firstName());
+						setField(middle, user->middleName());
+						setField(last, user->lastName());
+
 #if SRP_DEBUG > 1
-					Firebird::BigInteger salt("02E268803000000079A478A700000002D1A6979000000026E1601C000000054F");
+						Firebird::BigInteger salt("02E268803000000079A478A700000002D1A6979000000026E1601C000000054F");
 #else
-					Firebird::BigInteger salt;
-					salt.random(RemotePassword::SRP_SALT_SIZE);
+						Firebird::BigInteger salt;
+						salt.random(RemotePassword::SRP_SALT_SIZE);
 #endif
-					Firebird::UCharBuffer s;
-					salt.getBytes(s);
-					slt().set(s.getCount(), s.begin());
-					slt.null() = 0;
+						Firebird::UCharBuffer s;
+						salt.getBytes(s);
+						slt.set(s.getCount(), s.begin());
 
-					dumpIt("salt", s);
+						dumpIt("salt", s);
 #if SRP_DEBUG > 0
-					fprintf(stderr, ">%s< >%s<\n", user->userName()->get(), user->password()->get());
+						fprintf(stderr, ">%s< >%s<\n", user->userName()->get(), user->password()->get());
 #endif
-					Firebird::string s1;
-					salt.getText(s1);
-					server.computeVerifier(user->userName()->get(), s1, user->password()->get()).getBytes(s);
-					dumpIt("verifier", s);
-					verifier().set(s.getCount(), s.begin());
-					verifier.null() = 0;
+						Firebird::string s1;
+						salt.getText(s1);
+						server.computeVerifier(user->userName()->get(), s1, user->password()->get()).getBytes(s);
+						dumpIt("verifier", s);
+						verifier.set(s.getCount(), s.begin());
 
-					for (unsigned repeat = 0; ; ++repeat)
+						stmt->execute(status, tra, &add, NULL);
+						check(status);
+
+						stmt->free(status);
+						check(status);
+					}
+					catch (const Firebird::Exception&)
 					{
-						att->execute(status, tra, 0, insert, 3, 0, &add, NULL);
-						if (status->isSuccess() || repeat > 0)
+						if (stmt)
 						{
-							break;
+							stmt->release();
 						}
-
-						const ISC_STATUS* v = status->get();
-						while (v[0] == isc_arg_gds)
-						{
-							if (v[1] == isc_dsql_relation_err)
-							{
-								prepareDataStructures();
-								tra->commit(status);
-								if (!status->isSuccess())
-								{
-									Firebird::status_exception::raise(status->get());
-								}
-								tra = att->startTransaction(status, 0, NULL);
-								if (!status->isSuccess())
-								{
-									Firebird::status_exception::raise(status->get());
-								}
-								break;
-							}
-							do
-							{
-								v += 2;
-							} while (v[0] != isc_arg_warning && v[0] != isc_arg_gds && v[0] != isc_arg_end);
-						}
+						throw;
 					}
-					if (!status->isSuccess())
-					{
-						Firebird::status_exception::raise(status->get());
-					}
 				}
 				break;
 
 			case MOD_OPER:
 				{
-					Message up;
-
 					Firebird::string update = "UPDATE plg$srp_view SET ";
 
-					Firebird::AutoPtr<Verifier> verifier;
-					Firebird::AutoPtr<Salt> slt;
+					Firebird::AutoPtr<Varfield> verifier, slt;
 					if (user->password()->entered())
 					{
-						verifier = new Verifier(up);
-						slt = new Salt(up);
 						update += "PLG$VERIFIER=?,PLG$SALT=?,";
 					}
 
 					Firebird::AutoPtr<Name> first, middle, last;
-					allocField(first, up, user->firstName(), update, "PLG$FIRST");
-					allocField(middle, up, user->middleName(), update, "PLG$MIDDLE");
-					allocField(last, up, user->lastName(), update, "PLG$LAST");
+					allocField(user->firstName(), update, "PLG$FIRST");
+					allocField(user->middleName(), update, "PLG$MIDDLE");
+					allocField(user->lastName(), update, "PLG$LAST");
 
 					if (update[update.length() - 1] != ',')
 					{
 						return 0;
 					}
 					update.rtrim(",");
-
 					update += " WHERE PLG$USER_NAME=?";
-					Login login(up);
 
-					if (verifier.hasData())
+					Firebird::IStatement* stmt = NULL;
+					try
 					{
+						stmt = att->prepare(status, tra, 0, update.c_str(), 3, Firebird::IStatement::PREPARE_PREFETCH_METADATA);
+						check(status);
+
+						Meta im(stmt, false);
+						Message up(im);
+
+						if (user->password()->entered())
+						{
+							verifier = new Varfield(up);
+							slt = new Varfield(up);
 #if SRP_DEBUG > 1
-						Firebird::BigInteger salt("02E268803000000079A478A700000002D1A6979000000026E1601C000000054F");
+							Firebird::BigInteger salt("02E268803000000079A478A700000002D1A6979000000026E1601C000000054F");
 #else
-						Firebird::BigInteger salt;
-						salt.random(RemotePassword::SRP_SALT_SIZE);
+							Firebird::BigInteger salt;
+							salt.random(RemotePassword::SRP_SALT_SIZE);
 #endif
-						Firebird::UCharBuffer s;
-						salt.getBytes(s);
-						(*slt)().set(s.getCount(), s.begin());
-						slt->null() = 0;
+							Firebird::UCharBuffer s;
+							salt.getBytes(s);
+							slt->set(s.getCount(), s.begin());
 
-						dumpIt("salt", s);
+							dumpIt("salt", s);
 #if SRP_DEBUG > 0
-						fprintf(stderr, ">%s< >%s<\n", user->userName()->get(), user->password()->get());
+							fprintf(stderr, ">%s< >%s<\n", user->userName()->get(), user->password()->get());
 #endif
-						Firebird::string s1;
-						salt.getText(s1);
-						server.computeVerifier(user->userName()->get(), s1, user->password()->get()).getBytes(s);
-						dumpIt("verifier", s);
-						(*verifier)().set(s.getCount(), s.begin());
-						verifier->null() = 0;
-					}
+							Firebird::string s1;
+							salt.getText(s1);
+							server.computeVerifier(user->userName()->get(), s1, user->password()->get()).getBytes(s);
+							dumpIt("verifier", s);
+							verifier->set(s.getCount(), s.begin());
+						}
 
-					assignField(first, user->firstName());
-					assignField(middle, user->middleName());
-					assignField(last, user->lastName());
-					setField(login, user->userName());
+						allocField(first, up, user->firstName(), "PLG$FIRST");
+						allocField(middle, up, user->middleName(), "PLG$MIDDLE");
+						allocField(last, up, user->lastName(), "PLG$LAST");
 
-					att->execute(status, tra, 0, update.c_str(), 3, 0, &up, NULL);
-					if (!status->isSuccess())
-					{
-						Firebird::status_exception::raise(status->get());
+						Name login(up);
+
+						assignField(first, user->firstName());
+						assignField(middle, user->middleName());
+						assignField(last, user->lastName());
+						setField(login, user->userName());
+
+						stmt->execute(status, tra, &up, NULL);
+						check(status);
+
+						if (!checkCount(status, &upCount, isc_info_update_count))
+						{
+							return -1;
+						}
+
+						stmt->free(status);
+						check(status);
 					}
-
-					if (!checkCount(status, &upCount, isc_info_update_count))
+					catch (const Firebird::Exception&)
 					{
-						return -1;
+						if (stmt)
+						{
+							stmt->release();
+						}
+						throw;
 					}
 				}
 				break;
 
 			case DEL_OPER:
 				{
-					Message dl;
 					const char* del = "DELETE FROM plg$srp_view WHERE PLG$USER_NAME=?";
-					Login login(dl);
-					setField(login, user->userName());
+					Firebird::IStatement* stmt = NULL;
+					try
+					{
+						stmt = att->prepare(status, tra, 0, del, 3, Firebird::IStatement::PREPARE_PREFETCH_METADATA);
+						check(status);
 
-					att->execute(status, tra, 0, del, 3, 0, &dl, NULL);
-					if (!status->isSuccess())
-					{
-						Firebird::status_exception::raise(status->get());
+						Meta im(stmt, false);
+						Message dl(im);
+						Name login(dl);
+						setField(login, user->userName());
+
+						stmt->execute(status, tra, &dl, NULL);
+						check(status);
+
+						if (!checkCount(status, &delCount, isc_info_delete_count))
+						{
+							return -1;
+						}
+
+						stmt->free(status);
+						check(status);
 					}
-
-					if (!checkCount(status, &delCount, isc_info_delete_count))
+					catch (const Firebird::Exception&)
 					{
-						return -1;
+						if (stmt)
+						{
+							stmt->release();
+						}
+						throw;
 					}
 				}
 				break;
@@ -452,75 +483,62 @@
 					user->groupName()->setEntered(0);
 					user->password()->setEntered(0);
 
-					Message di;
 					Firebird::string disp =	"SELECT PLG$USER_NAME, PLG$FIRST, PLG$MIDDLE, PLG$LAST, "
 											"	CASE WHEN RDB$RELATION_NAME IS NULL THEN 0 ELSE 1 END "
 											"FROM PLG$SRP_VIEW LEFT JOIN RDB$USER_PRIVILEGES "
 											"	ON PLG$SRP_VIEW.PLG$USER_NAME = RDB$USER_PRIVILEGES.RDB$USER "
 											"		AND RDB$RELATION_NAME = 'RDB$ADMIN' "
 											"		AND RDB$PRIVILEGE = 'M' ";
-					Firebird::AutoPtr<Message> par;
 					if (user->userName()->entered())
 					{
-						par = new Message;
-						Login login(*par);
-						setField(login, user->userName());
 						disp += " WHERE PLG$USER_NAME = ?";
 					}
 
-					Login login(di);
-					Name first(di), middle(di), last(di);
-					Field<SLONG> admin(di);
-					di.ready();
-
-					Firebird::RefPtr<Firebird::IStatement> stmt;
+					Firebird::IStatement* stmt = NULL;
+					Firebird::IResultSet* rs = NULL;
 					try
 					{
-						stmt = att->allocateStatement(status);
-						if (!status->isSuccess())
+						stmt = att->prepare(status, tra, 0, disp.c_str(), 3, Firebird::IStatement::PREPARE_PREFETCH_METADATA);
+						check(status);
+
+						Meta om(stmt, true);
+						Message di(om);
+						Name login(di);
+						Name first(di), middle(di), last(di);
+						Field<SLONG> admin(di);
+
+						Firebird::AutoPtr<Message> par;
+						if (user->userName()->entered())
 						{
-							Firebird::status_exception::raise(status->get());
+							Meta im(stmt, false);
+							par = new Message(im);
+							Name login(*par);
+							setField(login, user->userName());
 						}
-						stmt->prepare(status, tra, disp.length(), disp.c_str(), 3,
-									  Firebird::IStatement::PREPARE_PREFETCH_NONE);
-						if (!status->isSuccess())
+
+						rs = stmt->openCursor(status, tra, par, om);
+						check(status);
+
+						while (rs->fetch(status, di.buffer))
 						{
-							Firebird::status_exception::raise(status->get());
-						}
-						stmt->execute(status, tra, 0, par, NULL);
-						if (!status->isSuccess())
-						{
-							Firebird::status_exception::raise(status->get());
-						}
-						while (stmt->fetch(status, &di) == 0)
-						{
-							if (!status->isSuccess())
-							{
-								Firebird::status_exception::raise(status->get());
-							}
+							check(status);
 
 							listField(user->userName(), login);
 							listField(user->firstName(), first);
 							listField(user->middleName(), middle);
 							listField(user->lastName(), last);
-							user->admin()->set(admin());
+							u...
 
[truncated message content]

Thread: [Firebird-checkins] SF.net SVN: firebird:[57663] firebird/trunk (Page 27)

A powerful, cross platform, SQL database system

firebird-checkins