@@ -480,19 +480,15 @@ void MetadataCache::cleanup(thread_db* tdbb)
480480 mdc_functions.cleanup(tdbb);
481481 mdc_charsets.cleanup(tdbb);
482482
483- auto cleanSet = [tdbb](TriggersSet& set )
483+ for (unsigned i = 0; i < DB_TRIGGERS_COUNT; ++i )
484484 {
485- auto* ptr = set .load(atomics::memory_order_relaxed);
485+ auto* ptr = mdc_triggers[i] .load(atomics::memory_order_relaxed);
486486 if (ptr)
487487 {
488488 Cached::Triggers::cleanup(tdbb, ptr);
489- set .store(nullptr, atomics::memory_order_relaxed);
489+ mdc_triggers[i] .store(nullptr, atomics::memory_order_relaxed);
490490 }
491- };
492-
493- for (unsigned i = 1; i < DB_TRIGGER_MAX; ++i)
494- cleanSet(mdc_triggers[i]);
495- cleanSet(mdc_ddl_triggers);
491+ }
496492}
497493
498494
@@ -520,11 +516,9 @@ void MetadataCache::clear(thread_db* tdbb)
520516
521517 // Release global (db-level and DDL) triggers
522518
523- for (unsigned i = 0; i < DB_TRIGGER_MAX ; i++)
519+ for (unsigned i = 0; i < DB_TRIGGERS_COUNT ; i++)
524520 MET_release_triggers(tdbb, &att->att_triggers[i], false);
525521
526- MET_release_triggers(tdbb, &att->att_ddl_triggers, false);
527-
528522 // Release relation triggers
529523
530524 vec<jrd_rel*>* const relations = att->att_relations;
@@ -1522,30 +1516,30 @@ ScanResult DbTriggers::scan(thread_db* tdbb, ObjectBase::Flag flags)
15221516 CHECK_DBB(dbb);
15231517
15241518 auto type = perm->getId();
1525- bool found = false;
1519+ FB_UINT64 mask = (type == DB_TRIGGER_DDL) ? TRIGGER_TYPE_MASK : ~FB_UINT64(0);
1520+ type = (type == DB_TRIGGER_DDL) ? TRIGGER_TYPE_DDL : type | TRIGGER_TYPE_DB;
15261521
15271522 AutoRequest trigger_request;
1523+ jrd_tra* trans = tdbb->getTransaction() ? tdbb->getTransaction() : attachment->getSysTransaction();
15281524
1529- FOR(REQUEST_HANDLE trigger_request)
1525+ FOR(REQUEST_HANDLE trigger_request TRANSACTION_HANDLE trans )
15301526 TRG IN RDB$TRIGGERS
15311527 WITH TRG.RDB$RELATION_NAME MISSING AND
15321528 TRG.RDB$TRIGGER_INACTIVE EQ 0
15331529 SORTED BY TRG.RDB$TRIGGER_SEQUENCE
15341530 {
1535- if ((TRG.RDB$TRIGGER_TYPE == type | TRIGGER_TYPE_DB) ||
1536- (type == DB_TRIGGER_MAX && (TRG.RDB$TRIGGER_TYPE & TRIGGER_TYPE_MASK) == TRIGGER_TYPE_DDL))
1531+ if ((TRG.RDB$TRIGGER_TYPE & mask) == type)
15371532 {
1538- found = true;
15391533 MET_load_trigger(tdbb, nullptr, TRG.RDB$TRIGGER_NAME, [this](int)->Triggers& {return *this;});
15401534 }
15411535 }
15421536 END_FOR
15431537
1544- return found ? ScanResult::COMPLETE : ScanResult::MISS ;
1538+ return ScanResult::COMPLETE;
15451539}
15461540
15471541
1548- void MetadataCache::load_db_triggers (thread_db* tdbb, int type, bool force )
1542+ void MetadataCache::loadDbTriggers (thread_db* tdbb, unsigned int type)
15491543{
15501544/**************************************
15511545 *
@@ -1563,46 +1557,37 @@ void MetadataCache::load_db_triggers(thread_db* tdbb, int type, bool force)
15631557 Database* dbb = tdbb->getDatabase();
15641558 CHECK_DBB(dbb);
15651559
1560+ fb_assert(type < DB_TRIGGERS_COUNT);
15661561 auto* cacheElement = mdc_triggers[type].load(atomics::memory_order_acquire);
1567- if (force || !cacheElement)
1568- {
1569- if (!cacheElement)
1570- {
1571- // actual type will be taken into an account in DbTriggers::scan
1572- auto* newCacheElement = FB_NEW_POOL(getPool())
1573- Cached::Triggers(tdbb, getPool(), type, DbTriggers::makeLock, NoData());
1574- if (mdc_triggers[type].compare_exchange_strong(cacheElement, newCacheElement,
1575- atomics::memory_order_release, atomics::memory_order_acquire))
1576- {
1577- cacheElement = newCacheElement;
1578- }
1579- else
1580- {
1581- delete newCacheElement;
1582- return;
1583- }
1584- }
15851562
1586- DbTriggers* triggers = DbTriggers::create(tdbb, getPool(), cacheElement);
1587- try
1563+ if (!cacheElement)
1564+ {
1565+ // actual type will be taken into an account in DbTriggers::scan
1566+ auto* newCacheElement = FB_NEW_POOL(getPool())
1567+ Cached::Triggers(tdbb, getPool(), type, DbTriggers::makeLock, NoData());
1568+ if (mdc_triggers[type].compare_exchange_strong(cacheElement, newCacheElement,
1569+ atomics::memory_order_release, atomics::memory_order_acquire))
15881570 {
1589- if (cacheElement->storeObject(tdbb, triggers, 0) == StoreResult::DUP)
1590- DbTriggers::destroy(tdbb, triggers);
1571+ cacheElement = newCacheElement;
15911572 }
1592- catch(const Exception&)
1573+ else
15931574 {
1594- DbTriggers::destroy(tdbb, triggers) ;
1595- throw ;
1575+ delete newCacheElement ;
1576+ return ;
15961577 }
15971578 }
1598- }
1599-
16001579
1601- // Load DDL triggers from RDB$TRIGGERS.
1602- void MetadataCache::load_ddl_triggers(thread_db* tdbb, bool force)
1603- {
1604- // actual type will be taken into an account in DbTriggers::scan
1605- load_db_triggers(tdbb, DB_TRIGGER_MAX, force);
1580+ DbTriggers* triggers = DbTriggers::create(tdbb, getPool(), cacheElement);
1581+ try
1582+ {
1583+ if (cacheElement->storeObject(tdbb, triggers, 0) == StoreResult::DUP)
1584+ DbTriggers::destroy(tdbb, triggers);
1585+ }
1586+ catch(const Exception&)
1587+ {
1588+ DbTriggers::destroy(tdbb, triggers);
1589+ throw;
1590+ }
16061591}
16071592
16081593
@@ -4809,14 +4794,14 @@ void MetadataCache::invalidateReplSet(thread_db* tdbb)
48094794
48104795Cached::Triggers* MetadataCache::getTriggersSet(thread_db* tdbb, MetaId triggerId)
48114796{
4812- if (triggerId & TRIGGER_TYPE_MASK == TRIGGER_TYPE_DB)
4797+ if (( triggerId & TRIGGER_TYPE_MASK) == TRIGGER_TYPE_DB)
48134798 {
48144799 triggerId &= ~TRIGGER_TYPE_MASK;
48154800 return mdc_triggers[triggerId].load(atomics::memory_order_acquire);
48164801 }
48174802
4818- if (triggerId & TRIGGER_TYPE_MASK == TRIGGER_TYPE_DDL)
4819- return mdc_ddl_triggers .load(atomics::memory_order_acquire);
4803+ if (( triggerId & TRIGGER_TYPE_MASK) == TRIGGER_TYPE_DDL)
4804+ return mdc_triggers[DB_TRIGGER_DDL] .load(atomics::memory_order_acquire);
48204805
48214806 return nullptr;
48224807}
0 commit comments