Work in progress

Author: AlexPeshkoff

src/common/TextType.h

@@ -95,6 +95,11 @@ class TextType
 	BYTE getCanonicalWidth() const;
 	USHORT getFlags() const;
 
+	const char* c_name() const
+	{
+		return name.c_str();
+	}
+
 public:
 	Firebird::MetaString name;
 

src/common/classes/Bits.h

@@ -0,0 +1,136 @@
+/*
+ *	PROGRAM:	JRD Access Method
+ *	MODULE:		Bits.h
+ *	DESCRIPTION:	Arbitrary size bitmask
+ *
+ *  The contents of this file are subject to the Initial
+ *  Developer's Public License Version 1.0 (the "License");
+ *  you may not use this file except in compliance with the
+ *  License. You may obtain a copy of the License at
+ *  http://www.ibphoenix.com/main.nfs?a=ibphoenix&page=ibp_idpl.
+ *
+ *  Software distributed under the License is distributed AS IS,
+ *  WITHOUT WARRANTY OF ANY KIND, either express or implied.
+ *  See the License for the specific language governing rights
+ *  and limitations under the License.
+ *
+ *  The Original Code was created by Alexander Peshkoff
+ *  for the Firebird Open Source RDBMS project.
+ *
+ *  Copyright (c) 2016, 2022 Alexander Peshkoff <peshkoff@mail.ru>
+ *  and all contributors signed below.
+ *
+ *  All Rights Reserved.
+ *  Contributor(s): ______________________________________.
+ *
+ */
+
+#ifndef COMMON_CLASSES_BITS_H
+#define COMMON_CLASSES_BITS_H
+
+namespace Firebird {
+
+	// Arbitrary size bitmask
+	template <unsigned N>
+	class Bits
+	{
+		static const unsigned shift = 3;
+		static const unsigned bitmask = (1 << shift) - 1;
+
+		static const unsigned L = (N >> shift) + (N & bitmask ? 1 : 0);
+
+	public:
+		static const unsigned BYTES_COUNT = L;
+
+		Bits()
+		{
+			clearAll();
+		}
+
+		Bits(const Bits& b)
+		{
+			assign(b);
+		}
+
+		Bits& operator=(const Bits& b)
+		{
+			assign(b);
+			return *this;
+		}
+
+		Bits& set(unsigned i)
+		{
+			fb_assert(i < N);
+			if (i < N)
+				data[index(i)] |= mask(i);
+			return *this;
+		}
+
+		Bits& setAll()
+		{
+			memset(data, ~0, sizeof data);
+			return *this;
+		}
+
+		Bits& clear(unsigned i)
+		{
+			fb_assert(i < N);
+			if (i < N)
+				data[index(i)] &= ~mask(i);
+			return *this;
+		}
+
+		Bits& clearAll()
+		{
+			memset(data, 0, sizeof data);
+			return *this;
+		}
+
+		bool test(unsigned int i) const
+		{
+			fb_assert(i < N);
+			if (i >= N)
+				return false;
+			return data[index(i)] & mask(i);
+		}
+
+		void load(const void* from)
+		{
+			memcpy(data, from, sizeof data);
+		}
+
+		void store(void* to) const
+		{
+			memcpy(to, data, sizeof data);
+		}
+
+		Bits& operator|=(const Bits& b)
+		{
+			for (unsigned n = 0; n < L; ++n)
+				data[n] |= b.data[n];
+			return *this;
+		}
+
+	private:
+		UCHAR data[L];
+
+		void assign(const Bits& b)
+		{
+			memcpy(data, b.data, sizeof data);
+		}
+
+		static unsigned index(unsigned i)
+		{
+			return i >> shift;
+		}
+
+		static UCHAR mask(unsigned i)
+		{
+			return 1U << (i & bitmask);
+		}
+	};
+
+} // namespace Firebird
+
+#endif // COMMON_CLASSES_BITS_H
+

src/dsql/BoolNodes.cpp

@@ -835,7 +835,7 @@ bool ComparativeBoolNode::stringBoolean(thread_db* tdbb, Request* request, dsc*
 		type1 = desc1->dsc_sub_type == isc_blob_text ? desc1->dsc_blob_ttype() : ttype_none;
 	}
 
-	Collation* obj = INTL_texttype_lookup(tdbb, type1);
+	HazardPtr<Collation> obj = INTL_texttype_lookup(tdbb, type1);
 	CharSet* charset = obj->getCharSet();
 
 	VaryStr<TEMP_STR_LENGTH> escapeTemp;
@@ -1041,7 +1041,7 @@ bool ComparativeBoolNode::sleuth(thread_db* tdbb, Request* request, const dsc* d
 	else
 		ttype = INTL_TTYPE(desc1);
 
-	Collation* obj = INTL_texttype_lookup(tdbb, ttype);
+	HazardPtr<Collation> obj = INTL_texttype_lookup(tdbb, ttype);
 
 	// Get operator definition string (control string)
 

src/dsql/ExprNodes.cpp

@@ -3534,8 +3534,9 @@ ValueExprNode* CastNode::pass1(thread_db* tdbb, CompilerScratch* csb)
 	// Are we using a collation?
 	if (TTYPE_TO_COLLATION(ttype) != 0)
 	{
-		CMP_post_resource(&csb->csb_resources, INTL_texttype_lookup(tdbb, ttype),
-			Resource::rsc_collation, ttype);
+		Collation* collation = csb->csb_resources.registerResource(tdbb, Resource::rsc_collation,
+			INTL_texttype_lookup(tdbb, ttype), ttype);
+		csb->csb_resources.postResource(tdbb, Resource::rsc_collation, collation, ttype);
 	}
 
 	return this;
@@ -4837,7 +4838,8 @@ DmlNode* DefaultNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch*
 	if (csb->csb_g_flags & csb_get_dependencies)
 	{
 		CompilerScratch::Dependency dependency(obj_relation);
-		dependency.relation = MetadataCache::lookup_relation(tdbb, relationName).unsafePointer();
+		auto rel = MetadataCache::lookup_relation(tdbb, relationName);
+		dependency.relation = csb->csb_resources.registerResource(tdbb, Resource::rsc_relation, rel, rel->rel_id);
 		dependency.subName = FB_NEW_POOL(pool) MetaName(fieldName);
 		csb->csb_dependencies.push(dependency);
 	}
@@ -4846,11 +4848,11 @@ DmlNode* DefaultNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch*
 
 	while (true)
 	{
-		HazardPtr<jrd_rel> relation = MetadataCache::lookup_relation(tdbb, relationName);
+		auto relation = MetadataCache::lookup_relation(tdbb, relationName);
 
 		if (relation && relation->rel_fields)
 		{
-			int fieldId = MET_lookup_field(tdbb, relation.unsafePointer(), fieldName);
+			int fieldId = MET_lookup_field(tdbb, relation.getPointer(), fieldName);
 
 			if (fieldId >= 0)
 			{
@@ -6579,7 +6581,8 @@ ValueExprNode* FieldNode::pass1(thread_db* tdbb, CompilerScratch* csb)
 		try
 		{
 			ThreadStatusGuard local_status(tdbb);
-			collation = INTL_texttype_lookup(tdbb, ttype);
+			collation = csb->csb_resources.registerResource(tdbb, Resource::rsc_collation,
+				INTL_texttype_lookup(tdbb, ttype), ttype);
 		}
 		catch (Exception&)
 		{
@@ -6590,7 +6593,7 @@ ValueExprNode* FieldNode::pass1(thread_db* tdbb, CompilerScratch* csb)
 		}
 
 		if (collation)
-			CMP_post_resource(&csb->csb_resources, collation, Resource::rsc_collation, ttype);
+			csb->csb_resources.postResource(tdbb, Resource::rsc_collation, collation, ttype);
 	}
 
 	// if this is a modify or store, check REFERENCES access to any foreign keys
@@ -10691,9 +10694,10 @@ dsc* StrCaseNode::execute(thread_db* tdbb, Request* request) const
 	if (request->req_flags & req_null)
 		return NULL;
 
-	TextType* textType = INTL_texttype_lookup(tdbb, value->getTextType());
+	HazardPtr<Collation> textType = INTL_texttype_lookup(tdbb, value->getTextType());
 	CharSet* charSet = textType->getCharSet();
-	auto intlFunction = (blrOp == blr_lowcase ? &TextType::str_to_lower : &TextType::str_to_upper);
+//	auto intlFunction = (blrOp == blr_lowcase ? &TextType::str_to_lower : &TextType::str_to_upper);
+	auto intlFunction = (blrOp == blr_lowcase ? &Collation::str_to_lower : &Collation::str_to_upper);
 
 	if (value->isBlob())
 	{
@@ -10723,7 +10727,7 @@ dsc* StrCaseNode::execute(thread_db* tdbb, Request* request) const
 
 			if (len)
 			{
-				len = (textType->*intlFunction)(len, buffer.begin(), buffer.getCapacity(), buffer.begin());
+				len = (textType.getPointer()->*intlFunction)(len, buffer.begin(), buffer.getCapacity(), buffer.begin());
 				newBlob->BLB_put_data(tdbb, buffer.begin(), len);
 			}
 		}
@@ -10745,7 +10749,7 @@ dsc* StrCaseNode::execute(thread_db* tdbb, Request* request) const
 		desc.setTextType(ttype);
 		EVL_make_value(tdbb, &desc, impure);
 
-		len = (textType->*intlFunction)(len, ptr, desc.dsc_length, impure->vlu_desc.dsc_address);
+		len = (textType.getPointer()->*intlFunction)(len, ptr, desc.dsc_length, impure->vlu_desc.dsc_address);
 
 		if (len == INTL_BAD_STR_LENGTH)
 			status_exception::raise(Arg::Gds(isc_arith_except));
@@ -11999,7 +12003,7 @@ dsc* SubstringSimilarNode::execute(thread_db* tdbb, Request* request) const
 		return NULL;
 
 	USHORT textType = exprDesc->getTextType();
-	Collation* collation = INTL_texttype_lookup(tdbb, textType);
+	HazardPtr<Collation> collation = INTL_texttype_lookup(tdbb, textType);
 	CharSet* charSet = collation->getCharSet();
 
 	MoveBuffer exprBuffer;
@@ -12561,7 +12565,7 @@ dsc* TrimNode::execute(thread_db* tdbb, Request* request) const
 		return NULL;
 
 	USHORT ttype = INTL_TEXT_TYPE(*valueDesc);
-	TextType* tt = INTL_texttype_lookup(tdbb, ttype);
+	HazardPtr<Collation> tt = INTL_texttype_lookup(tdbb, ttype);
 	CharSet* cs = tt->getCharSet();
 
 	const UCHAR* charactersAddress;
@@ -12757,8 +12761,9 @@ DmlNode* UdfCallNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch*
 	HazardPtr<Function> func;
 	if (!node->function)
 	{
-		func = Function::lookup(tdbb, name, false);			// !!!!!!!!!!!!!!!!!!! resource
-		node->function = func.unsafePointer();
+		func = Function::lookup(tdbb, name, false);
+		if (func)
+			node->function = csb->csb_resources.registerResource(tdbb, Resource::rsc_function, func, func->getId());
 	}
 
 	Function* function = node->function;
@@ -12883,8 +12888,8 @@ ValueExprNode* UdfCallNode::copy(thread_db* tdbb, NodeCopier& copier) const
 		node->function = function;
 	else
 	{
-		HazardPtr<Function> func = Function::lookup(tdbb, name, false);	// !!!!!!!!!!!!!!!!!!! resource
-		node->function = func.unsafePointer();
+		HazardPtr<Function> func = Function::lookup(tdbb, name, false);
+		node->function = copier.csb->csb_resources.registerResource(tdbb, Resource::rsc_function, func, func->getId());
 	}
 	return node;
 }
@@ -12944,7 +12949,7 @@ ValueExprNode* UdfCallNode::pass1(thread_db* tdbb, CompilerScratch* csb)
 				csb->csb_external.insert(idx, temp);
 		}
 
-		CMP_post_resource(&csb->csb_resources, function, Resource::rsc_function, function->getId());
+		csb->csb_resources.postResource(tdbb, Resource::rsc_function, function.getObject(), function->getId());
 	}
 
 	return this;

src/dsql/StmtNodes.cpp

@@ -2926,14 +2926,15 @@ DmlNode* ExecProcedureNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScr
 {
 	SET_TDBB(tdbb);
 
-	HazardPtr<jrd_prc> proc;
 	jrd_prc* procedure = NULL;
+	HazardPtr<jrd_prc> proc;
 	QualifiedName name;
 
 	if (blrOp == blr_exec_pid)
 	{
 		const USHORT pid = csb->csb_blr_reader.getWord();
-		if (!(proc = MetadataCache::lookup_procedure_id(tdbb, pid, false, false, 0)))
+		proc = MetadataCache::lookup_procedure_id(tdbb, pid, false, false, 0);
+		if (!proc)
 			name.identifier.printf("id %d", pid);
 	}
 	else
@@ -2958,7 +2959,7 @@ DmlNode* ExecProcedureNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScr
 	}
 
 	if (proc && !procedure)
-		procedure = proc.unsafePointer();
+		procedure = csb->csb_resources.registerResource(tdbb, Resource::rsc_procedure, proc, proc->getId());
 
 	if (!procedure)
 		PAR_error(csb, Arg::Gds(isc_prcnotdef) << Arg::Str(name.toString()));
@@ -3183,7 +3184,7 @@ ExecProcedureNode* ExecProcedureNode::pass1(thread_db* tdbb, CompilerScratch* cs
 	{
 		// Post access to procedure.
 		CMP_post_procedure_access(tdbb, csb, procedure);
-		CMP_post_resource(&csb->csb_resources, procedure, Resource::rsc_procedure, procedure->getId());
+		csb->csb_resources.postResource(tdbb, Resource::rsc_procedure, procedure.getObject(), procedure->getId());
 	}
 
 	doPass1(tdbb, csb, inputSources.getAddress());
@@ -7806,7 +7807,7 @@ bool StoreNode::pass1Store(thread_db* tdbb, CompilerScratch* csb, StoreNode* nod
 
 		if (!relSource)
 		{
-			CMP_post_resource(&csb->csb_resources, relation, Resource::rsc_relation, relation->rel_id);
+			csb->csb_resources.postResource(tdbb, Resource::rsc_relation, relation, relation->rel_id);
 
 			if (!relation->rel_view_rse)
 			{
@@ -7827,7 +7828,7 @@ bool StoreNode::pass1Store(thread_db* tdbb, CompilerScratch* csb, StoreNode* nod
 		{
 			// ASF: This code is responsible to make view's WITH CHECK OPTION to work as constraints.
 
-			CMP_post_resource(&csb->csb_resources, relation, Resource::rsc_relation, relation->rel_id);
+			csb->csb_resources.postResource(tdbb, Resource::rsc_relation, relation, relation->rel_id);
 
 			// Set up the new target stream.
 
@@ -10855,7 +10856,9 @@ static void preprocessAssignments(thread_db* tdbb, CompilerScratch* csb,
 					}
 					else if (relation->rel_view_rse && fld->fld_source_rel_field.first.hasData())
 					{
-						relation = MetadataCache::lookup_relation(tdbb, fld->fld_source_rel_field.first).unsafePointer();
+						HazardPtr<jrd_rel> rel = MetadataCache::lookup_relation(tdbb, fld->fld_source_rel_field.first);
+						relation = rel ? csb->csb_resources.registerResource(tdbb,
+							Resource::rsc_relation, rel, rel->rel_id) : nullptr;
 
 						fb_assert(relation);
 						if (!relation)

src/dsql/dsql.h

@@ -527,12 +527,12 @@ class dsql_ctx : public pool_alloc<dsql_type_ctx>
 		return *this;
 	}
 
-	Firebird::string getObjectName() const
+	const char* getObjectName() const
 	{
 		if (ctx_relation)
 			return ctx_relation->rel_name.c_str();
 		if (ctx_procedure)
-			return ctx_procedure->prc_name.toString();
+			return ctx_procedure->prc_name.c_str();
 		return "";
 	}
 

src/include/fb_blk.h

@@ -34,7 +34,6 @@ enum BlockType
 	type_att,
 	type_sym,
 	type_irl,
-	type_idl,
 	type_sdw,
 	type_blf,
 	type_arr,

src/jrd/Attachment.h

@@ -62,8 +62,6 @@ namespace Replication
 	class TableMatcher;
 }
 
-class CharSetContainer;
-
 namespace Jrd
 {
 	class thread_db;