Successful CREATE DATABASE with shared cache (still has some limitations)

Author: AlexPeshkoff

src/dsql/ExprNodes.cpp

@@ -5824,9 +5824,10 @@ DmlNode* FieldNode::parse(thread_db* tdbb, MemoryPool& pool, CompilerScratch* cs
 				PAR_error(csb, Arg::Gds(isc_ctxnotdef));
 
 			// make sure relation has been scanned before using it
-
-			if (!(relation->rel_flags & REL_scanned) || (relation->rel_flags & REL_being_scanned))
-				MET_scan_relation(tdbb, relation);
+			HazardPtr<jrd_rel> wrk = MET_scan_relation(tdbb, relation->rel_id);
+			if (!wrk)
+				PAR_error(csb, Arg::Gds(isc_ctxnotdef));
+			relation = wrk.getPointer();
 
 			csb->csb_blr_reader.getMetaName(name);
 

src/dsql/StmtNodes.cpp

@@ -1779,7 +1779,7 @@ void DeclareSubFuncNode::genParameters(DsqlCompilerScratch* dsqlScratch,
 DeclareSubFuncNode* DeclareSubFuncNode::pass1(thread_db* tdbb, CompilerScratch* /*csb*/)
 {
 	ContextPoolHolder context(tdbb, &subCsb->csb_pool);
-	PAR_blr(tdbb, NULL, blrStart, blrLength, NULL, &subCsb, NULL, false, 0);
+	PAR_blr(tdbb, nullRel, blrStart, blrLength, NULL, &subCsb, NULL, false, 0);
 
 	return this;
 }
@@ -2120,7 +2120,7 @@ void DeclareSubProcNode::genParameters(DsqlCompilerScratch* dsqlScratch,
 DeclareSubProcNode* DeclareSubProcNode::pass1(thread_db* tdbb, CompilerScratch* /*csb*/)
 {
 	ContextPoolHolder context(tdbb, &subCsb->csb_pool);
-	PAR_blr(tdbb, NULL, blrStart, blrLength, NULL, &subCsb, NULL, false, 0);
+	PAR_blr(tdbb, nullRel, blrStart, blrLength, NULL, &subCsb, NULL, false, 0);
 
 	return this;
 }

src/jrd/Attachment.cpp

@@ -120,24 +120,23 @@ void Jrd::Attachment::destroy(Attachment* const attachment)
 		sAtt->manualUnlock(attachment->att_flags);
 	}
 
-	thread_db* tdbb = JRD_get_thread_data();
-
-	jrd_tra* sysTransaction = attachment->getSysTransaction();
-	if (sysTransaction)
-	{
-		// unwind any active system requests
-		while (sysTransaction->tra_requests)
-			EXE_unwind(tdbb, sysTransaction->tra_requests);
-
-		jrd_tra::destroy(NULL, sysTransaction);
-	}
-
 	Database* const dbb = attachment->att_database;
 	{
 		// context scope is needed here for correct GC of hazard pointers
 		ThreadContextHolder tdbb(dbb, attachment);
 
+		jrd_tra* sysTransaction = attachment->getSysTransaction();
+		if (sysTransaction)
+		{
+			// unwind any active system requests
+			while (sysTransaction->tra_requests)
+				EXE_unwind(tdbb, sysTransaction->tra_requests);
+
+			jrd_tra::destroy(NULL, sysTransaction);
+		}
+
 		attachment->att_delayed_delete.garbageCollect(HazardDelayedDelete::GarbageCollectMethod::GC_FORCE);
+		HZ_DEB(fprintf(stderr, "Attachment::destroy=>delayedDelete to DBB\n"));
 		dbb->dbb_delayed_delete.delayedDelete(attachment->att_delayed_delete.getHazardPointers());
 	}
 
@@ -236,6 +235,8 @@ Jrd::Attachment::Attachment(MemoryPool* pool, Database* dbb, JProvider* provider
 	  att_active_snapshots(*pool),
 	  att_statements(*pool),
 	  att_requests(*pool),
+	  att_internal(*pool),
+	  att_dyn_req(*pool),
 	  att_lock_owner_id(Database::getLockOwnerId()),
 	  att_backup_state_counter(0),
 	  att_stats(*pool),
@@ -273,7 +274,10 @@ Jrd::Attachment::Attachment(MemoryPool* pool, Database* dbb, JProvider* provider
 	  att_initial_options(*pool),
 	  att_provider(provider),
 	  att_delayed_delete(*dbb->dbb_permanent, *pool)
-{ }
+{
+	att_internal.grow(irq_MAX);
+	att_dyn_req.grow(drq_MAX);
+}
 
 
 Jrd::Attachment::~Attachment()
@@ -624,8 +628,6 @@ void Jrd::Attachment::initLocks(thread_db* tdbb)
 
 void Jrd::Attachment::releaseLocks(thread_db* tdbb)
 {
-	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! to database att_mdc.releaseLocks(tdbb);
-
 	// Release the DSQL cache locks
 
 	DSqlCache::Accessor accessor(&att_dsql_cache);
@@ -915,3 +917,53 @@ int Attachment::blockingAstReplSet(void* ast_object)
 
 	return 0;
 }
+
+void Attachment::cacheRequest(InternalRequest which, USHORT id, Statement* stmt)
+{
+	if (which == IRQ_REQUESTS)
+		att_internal[id] = stmt;
+	else if (which == DYN_REQUESTS)
+		att_dyn_req[id] = stmt;
+	else
+	{
+		fb_assert(false);
+	}
+}
+
+// Find an inactive incarnation of a system request. If necessary, clone it.
+Jrd::Request* Attachment::findSystemRequest(thread_db* tdbb, USHORT id, InternalRequest which)
+{
+	static const int MAX_RECURSION = 100;
+
+	// If the request hasn't been compiled or isn't active, there're nothing to do.
+
+	//Database::CheckoutLockGuard guard(this, dbb_cmp_clone_mutex);
+
+	fb_assert(which == IRQ_REQUESTS || which == DYN_REQUESTS);
+
+	Statement* statement = (which == IRQ_REQUESTS ? att_internal[id] : att_dyn_req[id]);
+
+	if (!statement)
+		return NULL;
+
+	// Look for requests until we find one that is available.
+
+	for (int n = 0;; ++n)
+	{
+		if (n > MAX_RECURSION)
+		{
+			ERR_post(Arg::Gds(isc_no_meta_update) <<
+						Arg::Gds(isc_req_depth_exceeded) << Arg::Num(MAX_RECURSION));
+			// Msg363 "request depth exceeded. (Recursive definition?)"
+		}
+
+		Request* clone = statement->getRequest(tdbb, n);
+
+		if (!(clone->req_flags & (req_active | req_reserved)))
+		{
+			clone->req_flags |= req_reserved;
+			return clone;
+		}
+	}
+}
+

src/jrd/Attachment.h

@@ -96,6 +96,7 @@ namespace Jrd
 	class Statement;
 	class Validation;
 	class Applier;
+	enum InternalRequest : USHORT;
 
 
 struct DSqlCacheItem
@@ -496,7 +497,10 @@ class Attachment : public pool_alloc<type_att>
 
 public:
 	Firebird::SortedArray<Statement*> att_statements;	// Statements belonging to attachment
-	Firebird::SortedArray<Request*> att_requests;	// Requests belonging to attachment
+	Firebird::SortedArray<Request*> att_requests;		// Requests belonging to attachment
+	Firebird::Array<Statement*>	att_internal;			// internal statements
+	Firebird::Array<Statement*>	att_dyn_req;			// internal dyn statements
+
 	Lock*		att_id_lock;				// Attachment lock (if any)
 	AttNumber	att_attachment_id;			// Attachment ID
 	Lock*		att_cancel_lock;			// Lock to cancel the active request
@@ -586,6 +590,9 @@ class Attachment : public pool_alloc<type_att>
 	jrd_tra* getSysTransaction();
 	void setSysTransaction(jrd_tra* trans);	// used only by TRA_init
 
+	void cacheRequest(InternalRequest which, USHORT id, Statement* stmt);
+	Request* findSystemRequest(thread_db* tdbb, USHORT id, InternalRequest which);
+
 	bool isSystem() const
 	{
 		return (att_flags & ATT_system);

src/jrd/Collation.cpp

@@ -1137,6 +1137,7 @@ void Collation::release(thread_db* tdbb)
 
 void Collation::destroy(thread_db* tdbb)
 {
+	fprintf(stderr, "Collation::destroy(%p) tt=%p\n", this, tt);
 	fb_assert(useCount == 0);
 
 	if (tt->texttype_fn_destroy)
@@ -1149,6 +1150,7 @@ void Collation::destroy(thread_db* tdbb)
 	delete existenceLock;
 	existenceLock = NULL;
 
+	fprintf(stderr, "delayedDelete collation %p\n", this);
 	this->delayedDelete(tdbb);
 }
 

src/jrd/ExtEngineManager.cpp

@@ -1389,7 +1389,7 @@ void ExtEngineManager::makeFunction(thread_db* tdbb, CompilerScratch* csb, Jrd::
 			csbPool, extOutMessageNode, intOutMessageNode);
 
 		Statement* statement = udf->getStatement();
-		PAR_preparsed_node(tdbb, NULL, mainNode, NULL, &csb, &statement, false, 0);
+		PAR_preparsed_node(tdbb, nullRel, mainNode, NULL, &csb, &statement, false, 0);
 		udf->setStatement(statement);
 	}
 	catch (...)
@@ -1521,7 +1521,7 @@ void ExtEngineManager::makeProcedure(thread_db* tdbb, CompilerScratch* csb, Haza
 		mainNode->statements.add(extProcedureNode);
 
 		Statement* statement = prc->getStatement();
-		PAR_preparsed_node(tdbb, NULL, mainNode, NULL, &csb, &statement, false, 0);
+		PAR_preparsed_node(tdbb, nullRel, mainNode, NULL, &csb, &statement, false, 0);
 		prc->setStatement(statement);
 	}
 	catch (...)
@@ -1621,7 +1621,9 @@ void ExtEngineManager::makeTrigger(thread_db* tdbb, CompilerScratch* csb, Jrd::T
 			trg->extTrigger);
 		mainNode->statements.add(extTriggerNode);
 
-		PAR_preparsed_node(tdbb, trg->relation, mainNode, NULL, &csb, &trg->statement, true, 0);
+		HazardPtr<jrd_rel> rel;
+		rel.safePointer(trg->relation);
+		PAR_preparsed_node(tdbb, rel, mainNode, NULL, &csb, &trg->statement, true, 0);
 	}
 	catch (...)
 	{

src/jrd/Function.epp

@@ -334,7 +334,7 @@ HazardPtr<Function> Function::loadMetadata(thread_db* tdbb, USHORT id, bool nosc
 					try
 					{
 						parameter->prm_default_value = static_cast<ValueExprNode*>(MET_parse_blob(
-							tdbb, nullptr, &default_value, nullptr, nullptr, false, false));
+							tdbb, nullRel, &default_value, nullptr, nullptr, false, false));
 					}
 					catch (const Exception&)
 					{

src/jrd/HazardPtr.cpp

@@ -39,16 +39,26 @@ HazardObject::~HazardObject()
 
 int HazardObject::delayedDelete(thread_db* tdbb)
 {
-	HazardDelayedDelete& dd = tdbb->getAttachment()->att_delayed_delete;
-	dd.delayedDelete(this);
+	HazardDelayedDelete* dd = HazardBase::getHazardDelayed(tdbb);
+	dd->delayedDelete(this);
 	return 0;
 }
 
 HazardDelayedDelete* HazardBase::getHazardDelayed(thread_db* tdbb)
 {
 	if (!tdbb)
 		tdbb = JRD_get_thread_data();
-	return &tdbb->getAttachment()->att_delayed_delete;
+	fb_assert(tdbb);
+
+	Attachment* att = tdbb->getAttachment();
+	if (att)
+		return &att->att_delayed_delete;
+
+	// !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+	// what about locking object in database? (dbb_delayed_delete)
+	Database* dbb = tdbb->getDatabase();
+	fb_assert(dbb);
+	return &dbb->dbb_delayed_delete;
 }
 
 HazardDelayedDelete* HazardBase::getHazardDelayed(Attachment* att)
@@ -101,6 +111,8 @@ void HazardDelayedDelete::remove(const void* ptr)
 
 void HazardDelayedDelete::delayedDelete(HazardObject* mem, bool gc)
 {
+	HZ_DEB(fprintf(stderr, "HazardDelayedDelete::delayedDelete %p\n", mem));
+
 	if (mem)
 		toDelete.push(mem);