litNddlmZddlZddlmZmZmZmZmZm Z m Z ddl m Z m Z ddlmZddlmZmZddlmZmZmZmZmZddlmZmZmZd ed efd ZGd d ZGddZ y))deepcopyN)AnyDictIterableListOptionalSetTuple) fire_event fire_event_if) lowercase) CacheActionCacheDumpGraph)DependentLinkNotCachedErrorNewNameAlreadyInCacheErrorNoneRelationFoundErrorReferencedLinkNotCachedError&TruncatedModelNameCausedCollisionError) _ReferenceKey _make_ref_key_make_ref_key_dictkeyreturnc@djtt|S)zfReturn the key in dot-separated string form. :param _ReferenceKey key: The key to stringify. .)joinmapstr)rs W/var/www/html/strategist-ai/venv_dbt/lib/python3.12/site-packages/dbt/adapters/cache.py dot_separatedr s 88CSM ""ceZdZdZddZdefdZedeefdZ edeefdZ edeefdZ d Z d Z d Zd Zdd ZdZdZdZdZdZy)_CachedRelationa^Nothing about _CachedRelation is guaranteed to be thread-safe! :attr str schema: The schema of this relation. :attr str identifier: The identifier of this relation. :attr Dict[_ReferenceKey, _CachedRelation] referenced_by: The relations that refer to this relation. :attr BaseRelation inner: The underlying dbt relation. rNc i|_||_yN) referenced_byinner)selfr's r__init__z_CachedRelation.__init__)sCE r!czdj|j|j|j|jS)Nz@_CachedRelation(database={}, schema={}, identifier={}, inner={}))formatdatabaseschema identifierr'r(s r__str__z_CachedRelation.__str__-s.RZZ MM4;;  r!c@t|jjSr%)r r'r,r/s rr,z_CachedRelation.database2s,,--r!c@t|jjSr%)r r'r-r/s rr-z_CachedRelation.schema6s**++r!c@t|jjSr%)r r'r.r/s rr.z_CachedRelation.identifier:s..//r!c|j|j}|jj|j|Sr%) __class__r'__dict__update)r(news r__copy__z_CachedRelation.__copy__>s/nnTZZ( DMM* r!c|j|jj}|jj |jt |j ||_yr%)r5r' incorporater6r7rr&)r(memor8s r __deepcopy__z_CachedRelation.__deepcopy__CsHnnTZZ3356 DMM*$T%7%7>r!c||jvSr%)r&)r(rs ris_referenced_byz _CachedRelation.is_referenced_byHsd((((r!ct|S)zuGet the _ReferenceKey that represents this relation :return _ReferenceKey: A key for this relation. )rr/s rrz_CachedRelation.keyKs T""r!c>||j|j<y)zAdd a reference from referrer to self, indicating that if this node were drop...cascaded, the referrer would be dropped as well. :param _CachedRelation referrer: The node that refers to this node. N)r&r)r(referrers r add_referencez_CachedRelation.add_referenceRs .68<<>*r!c|jh}|jjD]!}|j|j #|S)zRecursively collect a set of _ReferenceKeys that would consequentially get dropped if this were dropped via "drop ... cascade". :return Set[_ReferenceKey]: All the relations that would be dropped )rr&valuesr7collect_consequences)r( consequencesrelations rrFz$_CachedRelation.collect_consequencesZsN | **113 AH    = = ? @ Ar!ct|jt|z}|D]}|jj|y)zNon-recursively indicate that an iterable of _ReferenceKey no longer exist. Unknown keys are ignored. :param Iterable[_ReferenceKey] keys: The keys to drop. N)setr&pop)r(keysrs rrelease_referencesz"_CachedRelation.release_referencesfs@ 4%%&T2 (C    " "3 ' (r!c|jj|jj|jj|jjd|_y)zRename this cached relation to new_relation. Note that this will change the output of key(), all refs must be updated! :param _CachedRelation new_relation: The new name to apply to the relation )r,r-r.)pathN)r'r;r,r-r.)r( new_relations rrenamez_CachedRelation.renamepsQZZ++(..77&,,33*00;;,  r!c||jvr t||||jvry|jj|}||j|<y)aRename a reference that may or may not exist. Only handles the reference itself, so this is the other half of what `rename` does. If old_key is not in referenced_by, this is a no-op. :param _ReferenceKey old_key: The old key to be renamed. :param _ReferenceKey new_key: The new key to rename to. :raises InternalError: If the new key already exists. N)r&rrK)r(old_keynew_keyvalues r rename_keyz_CachedRelation.rename_keysV d(( (,Wg> > $,, , ""&&w/&+7#r!cR|jDcgc] }t|c}Scc}w)zReturn a key/value pair representing this key and its referents. return List[str]: The dot-separated form of all referent keys. )r&r )r(rs rdump_graph_entryz _CachedRelation.dump_graph_entrys# +/*<*<=Q a ===s$)rN)rBr#)__name__ __module__ __qualname____doc__r)rr0propertyrr,r-r.r9r=r?rrCrFrMrQrVrYr!rr#r#s  .(3-.., ,,0HSM00 ? )#6 ( (,$>r!r#cFeZdZdZddeddfdZdeedeeddfdZdeedeeddfd Z d e e eeeffd Z d e eeeffd Z dZdefdZdZdZdZdZdZdZdZdZdeedeedeefdZdZdeedeedeefdZdeefdZy)RelationsCacheaA cache of the relations known to dbt. Keeps track of relationships declared between tables and handles renames/drops as a real database would. :attr Dict[_ReferenceKey, _CachedRelation] relations: The known relations. :attr threading.RLock lock: The lock around relations, held during updates. The adapters also hold this lock while filling the cache. :attr Set[str] schemas: The set of known/cached schemas, all lowercased. log_cache_eventsrNcpi|_tj|_t |_||_yr%) relations threadingRLocklockrJschemasrb)r(rbs rr)zRelationsCache.__init__s(?AOO% AD 0r!r,r-cb|jjt|t|fy)zAdd a schema to the set of known schemas (case-insensitive) :param database: The database name to add. :param schema: The schema name to add. N)rhaddr )r(r,r-s r add_schemazRelationsCache.add_schemas% )H-y/@ABr!c t|t|f}||jvry|j5|j||}|j ||jj |dddy#1swYyxYw)zDrop the given schema and remove it from the set of known schemas. Then remove all its contents (and their dependents, etc) as well. N)r rhrg_list_relations_in_schema _remove_alldiscard)r(r,r-r to_removes r drop_schemazRelationsCache.drop_schemasw"If$56 dll "  YY &66xHI   Y ' LL  %  & & &s ?A::BrhcH|jjd|Dy)zAdd multiple schemas to the set of known schemas (case-insensitive) :param schemas: An iterable of the schema names to add. c3XK|]"\}}t||jf$ywr%)r lower).0dss r z0RelationsCache.update_schemas..s#L&1aYq\17795Ls(*N)rhr7)r(rhs rupdate_schemaszRelationsCache.update_schemass LGLLr! schema_idcZ|\}}t||jf|jvS)zA schema is 'in' the relations cache if it is in the set of cached schemas. :param schema_id: The db name and schema name to look up. )r rtrh)r(rzdbr-s r __contains__zRelationsCache.__contains__s+  F" v||~.$,,>>r!c |j5|jjDcic](\}}t|t |j *c}}cdddScc}}w#1swYyxYw)zDump a key-only representation of the schema to a dictionary. Every known relation is a key with a value of a list of keys it is referenced by. N)rgrditemsr rrY)r(kvs r dump_graphzRelationsCache.dump_graphsdYY dLPNNL`L`LbcDAqM!$c!*<*<*>&??c d dc d dsA+-A%A+%A++A4rHc|j|j|j|j}|jj ||S)zAdd a relation to the cache, or return it if it already exists. :param _CachedRelation relation: The relation to set or get. :return _CachedRelation: The relation stored under the given relation's key )rkr,r-rrd setdefault)r(rHrs r _setdefaultzRelationsCache._setdefaults> ))8??;lln~~((h77r!c|jj|}|y| t||jj|}| t||J|j |y)aAdd a link between two relations to the database. Both the old and new entries must alraedy exist in the database. :param _ReferenceKey referenced_key: The key identifying the referenced model (the one that if dropped will drop the dependent model). :param _ReferenceKey dependent_key: The key identifying the dependent model. :raises InternalError: If either entry does not exist. N)rdgetrrrC)r(referenced_key dependent_key referenced dependents r _add_linkzRelationsCache._add_linksq^^''7     .~> >NN&&}5  -m< <$$$  +r!ct|}t|}|j|jf|vr3tt |j |j y||j vr-|j|j}|j|||j vr-|j|j}|j|tt d|j |j |j5|j||dddy#1swYyxYw)arAdd a link between two relations to the database. If either relation does not exist, it will be added as an "external" relation. The dependent model refers _to_ the referenced model. So, given arguments of (jake_test, bar, jake_test, foo): both values are in the schema jake_test and foo is a view that refers to bar, so "drop bar cascade" will drop foo and all of foo's dependents. :param BaseRelation referenced: The referenced model. :param BaseRelation dependent: The dependent model. :raises InternalError: If either entry does not exist. )ref_key ref_key_2N)typeadd_linkactionrr) rr,r-r r_asdictrdreplaceExternalrjrgr)r(rrrdep_keys rrzRelationsCache.add_links + *   gnn -T 9 #OO-%oo/   $.. (#++1D1D+EJ HHZ $.. (!))z/B/B)CI HHY  !)!//+  YY - NN7G , - - -s D55D>c"t|}tjfdtt dt |j 5j|dddtjfdy#1swY#xYw)zAdd the relation inner to the cache, under the schema schema and identifier identifier :param BaseRelation relation: The underlying relation. c<tddjS)Nbeforeadding before_afterrdumprrr/srz$RelationsCache.add..ENPTP_P_Pabr! add_relationrrNc<tddjS)Nafterrrrr/srrz$RelationsCache.add..MNtO`ar!)r#r rbr rrrgr)r(rHcacheds` rrjzRelationsCache.add<sy !*  ! ! b  ;n>PQW>XYZ YY %   V $ %  ! ! a  % %s BBc|D]}|j|=|jjD]}|j|y)zRemoves all references to all entries in keys. This does not cascade! :param Iterable[_ReferenceKey] keys: The keys to remove. N)rdrErM)r(rLrrs r _remove_refszRelationsCache._remove_refsPsK $Cs# $nn++- ,F  % %d + ,r!ct|}t|}ttd||j5||j vr ttd| dddy|j |j }|Dcgc]}|j}}ttd|||j|dddycc}w#1swYyxYw)aDrop the named relation and cascade it appropriately to all dependent relations. Because dbt proactively does many `drop relation if exist ... cascade` that are noops, nonexistent relation drops cause a debug log and no other actions. :param str schema: The schema of the relation to drop. :param str identifier: The identifier of the relation to drop. drop_relationrdrop_missing_relationN drop_cascade)rrref_list) rrr rrgrdrFrr)r(rH dropped_keydropped_key_msgrGrconsequence_msgss rdropzRelationsCache.drop]s$H- ,X6;oOP YY ,$..0;.E_` , , >>+6KKML9EF# F F )+-    l + , , G  , ,s#&C(!C C *CCC!c |jj|}|j}|j||jj D]g}|j |st tdt|t|t|j|j||i||j|<|j|j|jy)aRename a relation named old_key to new_key, updating references. Return whether or not there was a key to rename. :param _ReferenceKey old_key: The existing key, to rename from. :param _CachedRelation new_key: The new relation, to rename to. update_reference)rrr ref_key_3T) rdrKrrQrEr?r rrrVrkr,r-)r(rSrPrHrTrs r_rename_relationzRelationsCache._rename_relation{s>>%%g.""$  %nn++- 4F&&w/1 27 ;"4W"="4VZZ\"B !!'73 4#+w (('..9r!c||jvrt||j||jvr%ttd|j yy)aCheck the rename constraints, and return whether or not the rename can proceed. If the new key is already present, that is an error. If the old key is absent, we debug log and return False, assuming it's a temp table being renamed. :param _ReferenceKey old_key: The existing key, to rename from. :param _ReferenceKey new_key: The new key, to rename to. :return bool: If the old relation exists for renaming. :raises InternalError: If the new key is already present. temporary_relationrFT)rdrr rr)r(rSrTs r_check_rename_constraintsz(RelationsCache._check_rename_constraintssL dnn $9$..Q Q $.. ( {*>HYZ [r!ct|}t|}ttd|j|jt j fdj 5j||rj|t|njt|dddt j fdy#1swY#xYw)aRename the old schema/identifier to the new schema/identifier and update references. If the new schema/identifier is already present, that is an error. If the schema/identifier key is absent, we only debug log and return, assuming it's a temp table being renamed. :param BaseRelation old: The existing relation name information. :param BaseRelation new: The new relation name information. :raises InternalError: If the new key is already present. rename_relationrc<tddjS)NrrQrrr/srrz'RelationsCache.rename..rr!Nc<tddjS)NrrQrrr/srrz'RelationsCache.rename..rr!) rr rrr rbrgrrr#r)r(oldr8rSrTs` rrQzRelationsCache.renames $$ ()!//+     ! ! b YY 7--gw?%%gs/CD  !56  7   ! ! a  7 7s 0A CC$c\t|}t|}|j5|jjDcgc]>}t|j|k(r$t|j |k(r |j @}}ddddvr t|Scc}w#1swYxYw)zCase-insensitively yield all relations matching the given schema. :param str schema: The case-insensitive schema name to list from. :return List[BaseRelation]: The list of relations with the given schema N)r rgrdrEr-r,r'r)r(r,r-rXresultss r get_relationszRelationsCache.get_relationssX&6" YY ..0ahh'61i 6Kx6WG  7?(* *  sB"ABB"B""B+c|j5|jj|jjdddy#1swYyxYw)zClear the cacheN)rgrdclearrhr/s rrzRelationsCache.clears> YY ! NN " LL    ! ! !s 5A  Act|t|f}g}|jjD]2\}}|j|jf|k(s"|j |4|S)z>) (#  $r!)F)rZr[r\r]boolr)rrrkrqrr ryr}rr#rrrrjrrrrrQrrrrrmrnr_r!rrarasO11$1 C3- C  C  C&3-& &  &,MhuXc]C5G/H&IM?eHSM3,>&?? d 8O 8,2+-Z ( ,,<"H.# JhsmXc]tTWy(!    /7}  o  $T/%:$r!ra)!copyrretypingrrrrrr r dbt_common.events.functionsr r dbt_common.utils.formattingr dbt.adapters.events.typesrrdbt.adapters.exceptions.cacherrrrrdbt.adapters.reference_keysrrrrr r#rar_r!rrs]BBBA1A#}##|>|>~k$k$r!