Source code

001/*-
002 * #%L
003 * HAPI FHIR JPA - Search Parameters
004 * %%
005 * Copyright (C) 2014 - 2024 Smile CDR, Inc.
006 * %%
007 * Licensed under the Apache License, Version 2.0 (the "License");
008 * you may not use this file except in compliance with the License.
009 * You may obtain a copy of the License at
010 *
011 *      http://www.apache.org/licenses/LICENSE-2.0
012 *
013 * Unless required by applicable law or agreed to in writing, software
014 * distributed under the License is distributed on an "AS IS" BASIS,
015 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
016 * See the License for the specific language governing permissions and
017 * limitations under the License.
018 * #L%
019 */
020package ca.uhn.fhir.jpa.searchparam.extractor;
021
022import ca.uhn.fhir.context.FhirContext;
023import ca.uhn.fhir.context.RuntimeResourceDefinition;
024import ca.uhn.fhir.context.RuntimeSearchParam;
025import ca.uhn.fhir.i18n.Msg;
026import ca.uhn.fhir.interceptor.api.HookParams;
027import ca.uhn.fhir.interceptor.api.IInterceptorBroadcaster;
028import ca.uhn.fhir.interceptor.api.Pointcut;
029import ca.uhn.fhir.interceptor.model.RequestPartitionId;
030import ca.uhn.fhir.jpa.model.config.PartitionSettings;
031import ca.uhn.fhir.jpa.model.cross.IResourceLookup;
032import ca.uhn.fhir.jpa.model.dao.JpaPid;
033import ca.uhn.fhir.jpa.model.entity.BasePartitionable;
034import ca.uhn.fhir.jpa.model.entity.BaseResourceIndexedSearchParam;
035import ca.uhn.fhir.jpa.model.entity.IResourceIndexComboSearchParameter;
036import ca.uhn.fhir.jpa.model.entity.ResourceIndexedComboStringUnique;
037import ca.uhn.fhir.jpa.model.entity.ResourceIndexedComboTokenNonUnique;
038import ca.uhn.fhir.jpa.model.entity.ResourceIndexedSearchParamString;
039import ca.uhn.fhir.jpa.model.entity.ResourceLink;
040import ca.uhn.fhir.jpa.model.entity.ResourceLink.ResourceLinkForLocalReferenceParams;
041import ca.uhn.fhir.jpa.model.entity.ResourceTable;
042import ca.uhn.fhir.jpa.model.entity.SearchParamPresentEntity;
043import ca.uhn.fhir.jpa.model.entity.StorageSettings;
044import ca.uhn.fhir.jpa.model.search.StorageProcessingMessage;
045import ca.uhn.fhir.parser.DataFormatException;
046import ca.uhn.fhir.rest.api.server.RequestDetails;
047import ca.uhn.fhir.rest.api.server.storage.TransactionDetails;
048import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
049import ca.uhn.fhir.rest.server.servlet.ServletRequestDetails;
050import ca.uhn.fhir.rest.server.util.CompositeInterceptorBroadcaster;
051import ca.uhn.fhir.rest.server.util.ISearchParamRegistry;
052import ca.uhn.fhir.rest.server.util.ResourceSearchParams;
053import ca.uhn.fhir.util.FhirTerser;
054import com.google.common.annotations.VisibleForTesting;
055import jakarta.annotation.Nonnull;
056import jakarta.annotation.Nullable;
057import org.apache.commons.lang3.StringUtils;
058import org.hl7.fhir.instance.model.api.IBaseReference;
059import org.hl7.fhir.instance.model.api.IBaseResource;
060import org.hl7.fhir.instance.model.api.IIdType;
061import org.hl7.fhir.r4.model.IdType;
062import org.springframework.beans.factory.annotation.Autowired;
063
064import java.util.ArrayList;
065import java.util.Collection;
066import java.util.Date;
067import java.util.HashMap;
068import java.util.HashSet;
069import java.util.List;
070import java.util.Map;
071import java.util.Optional;
072import java.util.Set;
073import java.util.stream.Collectors;
074
075import static ca.uhn.fhir.jpa.model.config.PartitionSettings.CrossPartitionReferenceMode.ALLOWED_UNQUALIFIED;
076import static ca.uhn.fhir.jpa.model.entity.ResourceLink.forLocalReference;
077import static org.apache.commons.lang3.StringUtils.isBlank;
078import static org.apache.commons.lang3.StringUtils.isNotBlank;
079
080public class SearchParamExtractorService {
081        private static final org.slf4j.Logger ourLog = org.slf4j.LoggerFactory.getLogger(SearchParamExtractorService.class);
082
083        @Autowired
084        private ISearchParamExtractor mySearchParamExtractor;
085
086        @Autowired
087        private IInterceptorBroadcaster myInterceptorBroadcaster;
088
089        @Autowired
090        private StorageSettings myStorageSettings;
091
092        @Autowired
093        private FhirContext myContext;
094
095        @Autowired
096        private ISearchParamRegistry mySearchParamRegistry;
097
098        @Autowired
099        private PartitionSettings myPartitionSettings;
100
101        @Autowired(required = false)
102        private IResourceLinkResolver myResourceLinkResolver;
103
104        private SearchParamExtractionUtil mySearchParamExtractionUtil;
105
106        @VisibleForTesting
107        public void setSearchParamExtractor(ISearchParamExtractor theSearchParamExtractor) {
108                mySearchParamExtractor = theSearchParamExtractor;
109        }
110
111        /**
112         * This method is responsible for scanning a resource for all of the search parameter instances.
113         * I.e. for all search parameters defined for
114         * a given resource type, it extracts the associated indexes and populates
115         * {@literal theParams}.
116         */
117        public void extractFromResource(
118                        RequestPartitionId theRequestPartitionId,
119                        RequestDetails theRequestDetails,
120                        ResourceIndexedSearchParams theNewParams,
121                        ResourceIndexedSearchParams theExistingParams,
122                        ResourceTable theEntity,
123                        IBaseResource theResource,
124                        TransactionDetails theTransactionDetails,
125                        boolean theFailOnInvalidReference,
126                        @Nonnull ISearchParamExtractor.ISearchParamFilter theSearchParamFilter) {
127                // All search parameter types except Reference
128                ResourceIndexedSearchParams normalParams = ResourceIndexedSearchParams.withSets();
129                getExtractionUtil()
130                                .extractSearchIndexParameters(theRequestDetails, normalParams, theResource, theSearchParamFilter);
131                mergeParams(normalParams, theNewParams);
132
133                boolean indexOnContainedResources = myStorageSettings.isIndexOnContainedResources();
134                ISearchParamExtractor.SearchParamSet<PathAndRef> indexedReferences =
135                                mySearchParamExtractor.extractResourceLinks(theResource, indexOnContainedResources);
136                SearchParamExtractorService.handleWarnings(theRequestDetails, myInterceptorBroadcaster, indexedReferences);
137
138                if (indexOnContainedResources) {
139                        ResourceIndexedSearchParams containedParams = ResourceIndexedSearchParams.withSets();
140                        extractSearchIndexParametersForContainedResources(
141                                        theRequestDetails, containedParams, theResource, theEntity, indexedReferences);
142                        mergeParams(containedParams, theNewParams);
143                }
144
145                if (myStorageSettings.isIndexOnUpliftedRefchains()) {
146                        ResourceIndexedSearchParams containedParams = ResourceIndexedSearchParams.withSets();
147                        extractSearchIndexParametersForUpliftedRefchains(
148                                        theRequestDetails,
149                                        containedParams,
150                                        theEntity,
151                                        theRequestPartitionId,
152                                        theTransactionDetails,
153                                        indexedReferences);
154                        mergeParams(containedParams, theNewParams);
155                }
156
157                // Do this after, because we add to strings during both string and token processing, and contained resource if
158                // any
159                populateResourceTables(theNewParams, theEntity);
160
161                // Reference search parameters
162                extractResourceLinks(
163                                theRequestPartitionId,
164                                theExistingParams,
165                                theNewParams,
166                                theEntity,
167                                theResource,
168                                theTransactionDetails,
169                                theFailOnInvalidReference,
170                                theRequestDetails,
171                                indexedReferences);
172
173                if (indexOnContainedResources) {
174                        extractResourceLinksForContainedResources(
175                                        theRequestPartitionId,
176                                        theNewParams,
177                                        theEntity,
178                                        theResource,
179                                        theTransactionDetails,
180                                        theFailOnInvalidReference,
181                                        theRequestDetails);
182                }
183
184                // Missing (:missing) Indexes - These are indexes to satisfy the :missing
185                // modifier
186                if (myStorageSettings.getIndexMissingFields() == StorageSettings.IndexEnabledEnum.ENABLED) {
187
188                        // References
189                        Map<String, Boolean> presenceMap = getReferenceSearchParamPresenceMap(theEntity, theNewParams);
190                        presenceMap.forEach((key, value) -> {
191                                SearchParamPresentEntity present = new SearchParamPresentEntity();
192                                present.setPartitionSettings(myPartitionSettings);
193                                present.setResource(theEntity);
194                                present.setParamName(key);
195                                present.setPresent(value);
196                                present.setPartitionId(theEntity.getPartitionId());
197                                present.calculateHashes();
198                                theNewParams.mySearchParamPresentEntities.add(present);
199                        });
200
201                        // Everything else
202                        ResourceSearchParams activeSearchParams = mySearchParamRegistry.getActiveSearchParams(
203                                        theEntity.getResourceType(), ISearchParamRegistry.SearchParamLookupContextEnum.INDEX);
204                        theNewParams.findMissingSearchParams(myPartitionSettings, myStorageSettings, theEntity, activeSearchParams);
205                }
206
207                extractSearchParamComboUnique(theEntity, theNewParams);
208
209                extractSearchParamComboNonUnique(theEntity, theNewParams);
210
211                theNewParams.setUpdatedTime(theTransactionDetails.getTransactionDate());
212        }
213
214        private SearchParamExtractionUtil getExtractionUtil() {
215                if (mySearchParamExtractionUtil == null) {
216                        mySearchParamExtractionUtil = new SearchParamExtractionUtil(
217                                        myContext, myStorageSettings, mySearchParamExtractor, myInterceptorBroadcaster);
218                }
219                return mySearchParamExtractionUtil;
220        }
221
222        @Nonnull
223        private Map<String, Boolean> getReferenceSearchParamPresenceMap(
224                        ResourceTable entity, ResourceIndexedSearchParams newParams) {
225                Map<String, Boolean> retval = new HashMap<>();
226
227                for (String nextKey : newParams.getPopulatedResourceLinkParameters()) {
228                        retval.put(nextKey, Boolean.TRUE);
229                }
230
231                ResourceSearchParams activeSearchParams = mySearchParamRegistry.getActiveSearchParams(
232                                entity.getResourceType(), ISearchParamRegistry.SearchParamLookupContextEnum.INDEX);
233                activeSearchParams.getReferenceSearchParamNames().forEach(key -> retval.putIfAbsent(key, Boolean.FALSE));
234                return retval;
235        }
236
237        @VisibleForTesting
238        public void setStorageSettings(StorageSettings theStorageSettings) {
239                myStorageSettings = theStorageSettings;
240        }
241
242        /**
243         * Extract search parameter indexes for contained resources. E.g. if we
244         * are storing a Patient with a contained Organization, we might extract
245         * a String index on the Patient with paramName="organization.name" and
246         * value="Org Name"
247         */
248        private void extractSearchIndexParametersForContainedResources(
249                        RequestDetails theRequestDetails,
250                        ResourceIndexedSearchParams theParams,
251                        IBaseResource theResource,
252                        ResourceTable theEntity,
253                        ISearchParamExtractor.SearchParamSet<PathAndRef> theIndexedReferences) {
254
255                FhirTerser terser = myContext.newTerser();
256
257                // 1. get all contained resources
258                Collection<IBaseResource> containedResources = terser.getAllEmbeddedResources(theResource, false);
259
260                // Extract search parameters
261                IChainedSearchParameterExtractionStrategy strategy = new IChainedSearchParameterExtractionStrategy() {
262                        @Nonnull
263                        @Override
264                        public ISearchParamExtractor.ISearchParamFilter getSearchParamFilter(@Nonnull PathAndRef thePathAndRef) {
265                                // Currently for contained resources we always index all search parameters
266                                // on all contained resources. A potential nice future optimization would
267                                // be to make this configurable, perhaps with an optional extension you could
268                                // add to a SearchParameter?
269                                return ISearchParamExtractor.ALL_PARAMS;
270                        }
271
272                        @Override
273                        public IBaseResource fetchResourceAtPath(@Nonnull PathAndRef thePathAndRef) {
274                                if (thePathAndRef.getRef() == null) {
275                                        return null;
276                                }
277                                return findContainedResource(containedResources, thePathAndRef.getRef());
278                        }
279                };
280                boolean recurse = myStorageSettings.isIndexOnContainedResourcesRecursively();
281                extractSearchIndexParametersForTargetResources(
282                                theRequestDetails,
283                                theParams,
284                                theEntity,
285                                new HashSet<>(),
286                                strategy,
287                                theIndexedReferences,
288                                recurse,
289                                true);
290        }
291
292        /**
293         * Extract search parameter indexes for uplifted refchains. E.g. if we
294         * are storing a Patient with reference to an Organization and the
295         * "Patient:organization" SearchParameter declares an uplifted refchain
296         * on the "name" SearchParameter, we might extract a String index
297         * on the Patient with paramName="organization.name" and value="Org Name"
298         */
299        private void extractSearchIndexParametersForUpliftedRefchains(
300                        RequestDetails theRequestDetails,
301                        ResourceIndexedSearchParams theParams,
302                        ResourceTable theEntity,
303                        RequestPartitionId theRequestPartitionId,
304                        TransactionDetails theTransactionDetails,
305                        ISearchParamExtractor.SearchParamSet<PathAndRef> theIndexedReferences) {
306                IChainedSearchParameterExtractionStrategy strategy = new IChainedSearchParameterExtractionStrategy() {
307
308                        @Nonnull
309                        @Override
310                        public ISearchParamExtractor.ISearchParamFilter getSearchParamFilter(@Nonnull PathAndRef thePathAndRef) {
311                                String searchParamName = thePathAndRef.getSearchParamName();
312                                RuntimeSearchParam searchParam = mySearchParamRegistry.getActiveSearchParam(
313                                                theEntity.getResourceType(),
314                                                searchParamName,
315                                                ISearchParamRegistry.SearchParamLookupContextEnum.INDEX);
316                                Set<String> upliftRefchainCodes = searchParam.getUpliftRefchainCodes();
317                                if (upliftRefchainCodes.isEmpty()) {
318                                        return ISearchParamExtractor.NO_PARAMS;
319                                }
320                                return sp -> sp.stream()
321                                                .filter(t -> upliftRefchainCodes.contains(t.getName()))
322                                                .collect(Collectors.toList());
323                        }
324
325                        @Override
326                        public IBaseResource fetchResourceAtPath(@Nonnull PathAndRef thePathAndRef) {
327                                // The PathAndRef will contain a resource if the SP path was inside a Bundle
328                                // and pointed to a resource (e.g. Bundle.entry.resource) as opposed to
329                                // pointing to a reference (e.g. Observation.subject)
330                                if (thePathAndRef.getResource() != null) {
331                                        return thePathAndRef.getResource();
332                                }
333
334                                // Ok, it's a normal reference
335                                IIdType reference = thePathAndRef.getRef().getReferenceElement();
336
337                                // If we're processing a FHIR transaction, we store the resources
338                                // mapped by their resolved resource IDs in theTransactionDetails
339                                IBaseResource resolvedResource = theTransactionDetails.getResolvedResource(reference);
340
341                                // And the usual case is that the reference points to a resource
342                                // elsewhere in the repository, so we load it
343                                if (resolvedResource == null
344                                                && myResourceLinkResolver != null
345                                                && !reference.getValue().startsWith("urn:uuid:")) {
346                                        RequestPartitionId targetRequestPartitionId = determineResolverPartitionId(theRequestPartitionId);
347                                        resolvedResource = myResourceLinkResolver.loadTargetResource(
348                                                        targetRequestPartitionId,
349                                                        theEntity.getResourceType(),
350                                                        thePathAndRef,
351                                                        theRequestDetails,
352                                                        theTransactionDetails);
353                                        if (resolvedResource != null) {
354                                                ourLog.trace("Found target: {}", resolvedResource.getIdElement());
355                                                theTransactionDetails.addResolvedResource(
356                                                                thePathAndRef.getRef().getReferenceElement(), resolvedResource);
357                                        }
358                                }
359
360                                return resolvedResource;
361                        }
362                };
363                extractSearchIndexParametersForTargetResources(
364                                theRequestDetails, theParams, theEntity, new HashSet<>(), strategy, theIndexedReferences, false, false);
365        }
366
367        /**
368         * Extract indexes for contained references as well as for uplifted refchains.
369         * These two types of indexes are both similar special cases. Normally we handle
370         * chained searches ("Patient?organization.name=Foo") using a join from the
371         * {@link ResourceLink} table (for the "organization" part) to the
372         * {@link ResourceIndexedSearchParamString} table (for the "name" part). But
373         * for both contained resource indexes and uplifted refchains we use only the
374         * {@link ResourceIndexedSearchParamString} table to handle the entire
375         * "organization.name" part, or the other similar tables for token, number, etc.
376         *
377         * @see #extractSearchIndexParametersForContainedResources(RequestDetails, ResourceIndexedSearchParams, IBaseResource, ResourceTable, ISearchParamExtractor.SearchParamSet)
378         * @see #extractSearchIndexParametersForUpliftedRefchains(RequestDetails, ResourceIndexedSearchParams, ResourceTable, RequestPartitionId, TransactionDetails, ISearchParamExtractor.SearchParamSet)
379         */
380        private void extractSearchIndexParametersForTargetResources(
381                        RequestDetails theRequestDetails,
382                        ResourceIndexedSearchParams theParams,
383                        ResourceTable theEntity,
384                        Collection<IBaseResource> theAlreadySeenResources,
385                        IChainedSearchParameterExtractionStrategy theTargetIndexingStrategy,
386                        ISearchParamExtractor.SearchParamSet<PathAndRef> theIndexedReferences,
387                        boolean theRecurse,
388                        boolean theIndexOnContainedResources) {
389                // 2. Find referenced search parameters
390
391                String spnamePrefix;
392                // 3. for each referenced search parameter, create an index
393                for (PathAndRef nextPathAndRef : theIndexedReferences) {
394
395                        // 3.1 get the search parameter name as spname prefix
396                        spnamePrefix = nextPathAndRef.getSearchParamName();
397
398                        if (spnamePrefix == null || (nextPathAndRef.getRef() == null && nextPathAndRef.getResource() == null))
399                                continue;
400
401                        // 3.1.2 check if this ref actually applies here
402                        ISearchParamExtractor.ISearchParamFilter searchParamsToIndex =
403                                        theTargetIndexingStrategy.getSearchParamFilter(nextPathAndRef);
404                        if (searchParamsToIndex == ISearchParamExtractor.NO_PARAMS) {
405                                continue;
406                        }
407
408                        // 3.2 find the target resource
409                        IBaseResource targetResource = theTargetIndexingStrategy.fetchResourceAtPath(nextPathAndRef);
410                        if (targetResource == null) continue;
411
412                        // 3.2.1 if we've already processed this resource upstream, do not process it again, to prevent infinite
413                        // loops
414                        if (theAlreadySeenResources.contains(targetResource)) {
415                                continue;
416                        }
417
418                        ResourceIndexedSearchParams currParams = ResourceIndexedSearchParams.withSets();
419
420                        // 3.3 create indexes for the current contained resource
421                        getExtractionUtil()
422                                        .extractSearchIndexParameters(theRequestDetails, currParams, targetResource, searchParamsToIndex);
423
424                        // 3.4 recurse to process any other contained resources referenced by this one
425                        // Recursing is currently only allowed for contained resources and not
426                        // uplifted refchains because the latter could potentially kill performance
427                        // with the number of resource resolutions needed in order to handle
428                        // a single write. Maybe in the future we could add caching to improve
429                        // this
430                        if (theRecurse) {
431                                HashSet<IBaseResource> nextAlreadySeenResources = new HashSet<>(theAlreadySeenResources);
432                                nextAlreadySeenResources.add(targetResource);
433
434                                ISearchParamExtractor.SearchParamSet<PathAndRef> indexedReferences =
435                                                mySearchParamExtractor.extractResourceLinks(targetResource, theIndexOnContainedResources);
436                                SearchParamExtractorService.handleWarnings(
437                                                theRequestDetails, myInterceptorBroadcaster, indexedReferences);
438
439                                extractSearchIndexParametersForTargetResources(
440                                                theRequestDetails,
441                                                currParams,
442                                                theEntity,
443                                                nextAlreadySeenResources,
444                                                theTargetIndexingStrategy,
445                                                indexedReferences,
446                                                true,
447                                                theIndexOnContainedResources);
448                        }
449
450                        // 3.5 added reference name as a prefix for the contained resource if any
451                        // e.g. for Observation.subject contained reference
452                        // the SP_NAME = subject.family
453                        currParams.updateSpnamePrefixForIndexOnUpliftedChain(
454                                        theEntity.getResourceType(), nextPathAndRef.getSearchParamName());
455
456                        // 3.6 merge to the mainParams
457                        // NOTE: the spname prefix is different
458                        mergeParams(currParams, theParams);
459                }
460        }
461
462        private IBaseResource findContainedResource(Collection<IBaseResource> resources, IBaseReference reference) {
463                for (IBaseResource resource : resources) {
464                        if (resource.getIdElement().equals(reference.getReferenceElement())) return resource;
465                }
466                return null;
467        }
468
469        private void mergeParams(ResourceIndexedSearchParams theSrcParams, ResourceIndexedSearchParams theTargetParams) {
470
471                theTargetParams.myNumberParams.addAll(theSrcParams.myNumberParams);
472                theTargetParams.myQuantityParams.addAll(theSrcParams.myQuantityParams);
473                theTargetParams.myQuantityNormalizedParams.addAll(theSrcParams.myQuantityNormalizedParams);
474                theTargetParams.myDateParams.addAll(theSrcParams.myDateParams);
475                theTargetParams.myUriParams.addAll(theSrcParams.myUriParams);
476                theTargetParams.myTokenParams.addAll(theSrcParams.myTokenParams);
477                theTargetParams.myStringParams.addAll(theSrcParams.myStringParams);
478                theTargetParams.myCoordsParams.addAll(theSrcParams.myCoordsParams);
479                theTargetParams.myCompositeParams.addAll(theSrcParams.myCompositeParams);
480        }
481
482        private void populateResourceTables(ResourceIndexedSearchParams theParams, ResourceTable theEntity) {
483
484                populateResourceTable(theParams.myNumberParams, theEntity);
485                populateResourceTable(theParams.myQuantityParams, theEntity);
486                populateResourceTable(theParams.myQuantityNormalizedParams, theEntity);
487                populateResourceTable(theParams.myDateParams, theEntity);
488                populateResourceTable(theParams.myUriParams, theEntity);
489                populateResourceTable(theParams.myTokenParams, theEntity);
490                populateResourceTable(theParams.myStringParams, theEntity);
491                populateResourceTable(theParams.myCoordsParams, theEntity);
492        }
493
494        @VisibleForTesting
495        public void setContext(FhirContext theContext) {
496                myContext = theContext;
497        }
498
499        private void extractResourceLinks(
500                        RequestPartitionId theRequestPartitionId,
501                        ResourceIndexedSearchParams theParams,
502                        ResourceTable theEntity,
503                        IBaseResource theResource,
504                        TransactionDetails theTransactionDetails,
505                        boolean theFailOnInvalidReference,
506                        RequestDetails theRequest,
507                        ISearchParamExtractor.SearchParamSet<PathAndRef> theIndexedReferences) {
508                extractResourceLinks(
509                                theRequestPartitionId,
510                                ResourceIndexedSearchParams.withSets(),
511                                theParams,
512                                theEntity,
513                                theResource,
514                                theTransactionDetails,
515                                theFailOnInvalidReference,
516                                theRequest,
517                                theIndexedReferences);
518        }
519
520        private void extractResourceLinks(
521                        RequestPartitionId theRequestPartitionId,
522                        ResourceIndexedSearchParams theExistingParams,
523                        ResourceIndexedSearchParams theNewParams,
524                        ResourceTable theEntity,
525                        IBaseResource theResource,
526                        TransactionDetails theTransactionDetails,
527                        boolean theFailOnInvalidReference,
528                        RequestDetails theRequest,
529                        ISearchParamExtractor.SearchParamSet<PathAndRef> theIndexedReferences) {
530                String sourceResourceName = myContext.getResourceType(theResource);
531
532                for (PathAndRef nextPathAndRef : theIndexedReferences) {
533                        if (nextPathAndRef.getRef() != null) {
534                                if (nextPathAndRef.getRef().getReferenceElement().isLocal()) {
535                                        continue;
536                                }
537
538                                RuntimeSearchParam searchParam = mySearchParamRegistry.getActiveSearchParam(
539                                                sourceResourceName,
540                                                nextPathAndRef.getSearchParamName(),
541                                                ISearchParamRegistry.SearchParamLookupContextEnum.INDEX);
542                                extractResourceLinks(
543                                                theRequestPartitionId,
544                                                theExistingParams,
545                                                theNewParams,
546                                                theEntity,
547                                                theTransactionDetails,
548                                                sourceResourceName,
549                                                searchParam,
550                                                nextPathAndRef,
551                                                theFailOnInvalidReference,
552                                                theRequest);
553                        }
554                }
555
556                theEntity.setHasLinks(!theNewParams.myLinks.isEmpty());
557        }
558
559        private void extractResourceLinks(
560                        @Nonnull RequestPartitionId theRequestPartitionId,
561                        ResourceIndexedSearchParams theExistingParams,
562                        ResourceIndexedSearchParams theNewParams,
563                        ResourceTable theEntity,
564                        TransactionDetails theTransactionDetails,
565                        String theSourceResourceName,
566                        RuntimeSearchParam theRuntimeSearchParam,
567                        PathAndRef thePathAndRef,
568                        boolean theFailOnInvalidReference,
569                        RequestDetails theRequest) {
570                IBaseReference nextReference = thePathAndRef.getRef();
571                IIdType nextId = nextReference.getReferenceElement();
572                String path = thePathAndRef.getPath();
573                Date transactionDate = theTransactionDetails.getTransactionDate();
574
575                /*
576                 * This can only really happen if the DAO is being called
577                 * programmatically with a Bundle (not through the FHIR REST API)
578                 * but Smile does this
579                 */
580                if (nextId.isEmpty() && nextReference.getResource() != null) {
581                        nextId = nextReference.getResource().getIdElement();
582                }
583
584                if (myContext.getParserOptions().isStripVersionsFromReferences()
585                                && !myContext
586                                                .getParserOptions()
587                                                .getDontStripVersionsFromReferencesAtPaths()
588                                                .contains(thePathAndRef.getPath())
589                                && nextId.hasVersionIdPart()) {
590                        nextId = nextId.toVersionless();
591                }
592
593                theNewParams.myPopulatedResourceLinkParameters.add(thePathAndRef.getSearchParamName());
594
595                boolean canonical = thePathAndRef.isCanonical();
596                if (LogicalReferenceHelper.isLogicalReference(myStorageSettings, nextId) || canonical) {
597                        String value = nextId.getValue();
598                        ResourceLink resourceLink =
599                                        ResourceLink.forLogicalReference(thePathAndRef.getPath(), theEntity, value, transactionDate);
600                        if (theNewParams.myLinks.add(resourceLink)) {
601                                ourLog.debug("Indexing remote resource reference URL: {}", nextId);
602                        }
603                        return;
604                }
605
606                String baseUrl = nextId.getBaseUrl();
607
608                // If this is a conditional URL, the part after the question mark
609                // can include URLs (e.g. token system URLs) and these really confuse
610                // the IdType parser because a conditional URL isn't actually a valid
611                // FHIR ID. So in order to truly determine whether we're dealing with
612                // an absolute reference, we strip the query part and reparse
613                // the reference.
614                int questionMarkIndex = nextId.getValue().indexOf('?');
615                if (questionMarkIndex != -1) {
616                        IdType preQueryId = new IdType(nextId.getValue().substring(0, questionMarkIndex - 1));
617                        baseUrl = preQueryId.getBaseUrl();
618                }
619
620                String typeString = nextId.getResourceType();
621                if (isBlank(typeString)) {
622                        String msg = "Invalid resource reference found at path[" + path + "] - Does not contain resource type - "
623                                        + nextId.getValue();
624                        if (theFailOnInvalidReference) {
625                                throw new InvalidRequestException(Msg.code(505) + msg);
626                        } else {
627                                ourLog.debug(msg);
628                                return;
629                        }
630                }
631                RuntimeResourceDefinition resourceDefinition;
632                try {
633                        resourceDefinition = myContext.getResourceDefinition(typeString);
634                } catch (DataFormatException e) {
635                        String msg = "Invalid resource reference found at path[" + path
636                                        + "] - Resource type is unknown or not supported on this server - " + nextId.getValue();
637                        if (theFailOnInvalidReference) {
638                                throw new InvalidRequestException(Msg.code(506) + msg);
639                        } else {
640                                ourLog.debug(msg);
641                                return;
642                        }
643                }
644
645                if (theRuntimeSearchParam.hasTargets()) {
646                        if (!theRuntimeSearchParam.getTargets().contains(typeString)) {
647                                return;
648                        }
649                }
650
651                if (isNotBlank(baseUrl)) {
652                        if (!myStorageSettings.getTreatBaseUrlsAsLocal().contains(baseUrl)
653                                        && !myStorageSettings.isAllowExternalReferences()) {
654                                String msg = myContext
655                                                .getLocalizer()
656                                                .getMessage(BaseSearchParamExtractor.class, "externalReferenceNotAllowed", nextId.getValue());
657                                throw new InvalidRequestException(Msg.code(507) + msg);
658                        } else {
659                                ResourceLink resourceLink =
660                                                ResourceLink.forAbsoluteReference(thePathAndRef.getPath(), theEntity, nextId, transactionDate);
661                                if (theNewParams.myLinks.add(resourceLink)) {
662                                        ourLog.debug("Indexing remote resource reference URL: {}", nextId);
663                                }
664                                return;
665                        }
666                }
667
668                Class<? extends IBaseResource> type = resourceDefinition.getImplementingClass();
669                String targetId = nextId.getIdPart();
670                if (StringUtils.isBlank(targetId)) {
671                        String msg = "Invalid resource reference found at path[" + path + "] - Does not contain resource ID - "
672                                        + nextId.getValue();
673                        if (theFailOnInvalidReference) {
674                                throw new InvalidRequestException(Msg.code(508) + msg);
675                        } else {
676                                ourLog.debug(msg);
677                                return;
678                        }
679                }
680
681                IIdType referenceElement = thePathAndRef.getRef().getReferenceElement();
682                JpaPid resolvedTargetId = (JpaPid) theTransactionDetails.getResolvedResourceId(referenceElement);
683                ResourceLink resourceLink;
684
685                Long targetVersionId = nextId.getVersionIdPartAsLong();
686                if (resolvedTargetId != null) {
687
688                        /*
689                         * If we have already resolved the given reference within this transaction, we don't
690                         * need to resolve it again
691                         */
692                        myResourceLinkResolver.validateTypeOrThrowException(type);
693
694                        ResourceLinkForLocalReferenceParams params = ResourceLinkForLocalReferenceParams.instance()
695                                        .setSourcePath(thePathAndRef.getPath())
696                                        .setSourceResource(theEntity)
697                                        .setTargetResourceType(typeString)
698                                        .setTargetResourcePid(resolvedTargetId.getId())
699                                        .setTargetResourceId(targetId)
700                                        .setUpdated(transactionDate)
701                                        .setTargetResourceVersion(targetVersionId)
702                                        .setTargetResourcePartitionablePartitionId(resolvedTargetId.getPartitionablePartitionId());
703
704                        resourceLink = forLocalReference(params);
705
706                } else if (theFailOnInvalidReference) {
707
708                        /*
709                         * The reference points to another resource, so let's look it up. We need to do this
710                         * since the target may be a forced ID, but also so that we can throw an exception
711                         * if the reference is invalid
712                         */
713                        myResourceLinkResolver.validateTypeOrThrowException(type);
714
715                        /*
716                         * We need to obtain a resourceLink out of the provided {@literal thePathAndRef}.  In the case
717                         * where we are updating a resource that already has resourceLinks (stored in {@literal theExistingParams.getResourceLinks()}),
718                         * let's try to match thePathAndRef to an already existing resourceLink to avoid the
719                         * very expensive operation of creating a resourceLink that would end up being exactly the same
720                         * one we already have.
721                         */
722                        Optional<ResourceLink> optionalResourceLink =
723                                        findMatchingResourceLink(thePathAndRef, theExistingParams.getResourceLinks());
724                        if (optionalResourceLink.isPresent()) {
725                                resourceLink = optionalResourceLink.get();
726                        } else {
727                                resourceLink = resolveTargetAndCreateResourceLinkOrReturnNull(
728                                                theRequestPartitionId,
729                                                theSourceResourceName,
730                                                thePathAndRef,
731                                                theEntity,
732                                                transactionDate,
733                                                nextId,
734                                                theRequest,
735                                                theTransactionDetails);
736                        }
737
738                        if (resourceLink == null) {
739                                return;
740                        } else {
741                                // Cache the outcome in the current transaction in case there are more references
742                                JpaPid persistentId = JpaPid.fromId(resourceLink.getTargetResourcePid());
743                                persistentId.setPartitionablePartitionId(resourceLink.getTargetResourcePartitionId());
744                                theTransactionDetails.addResolvedResourceId(referenceElement, persistentId);
745                        }
746
747                } else {
748
749                        /*
750                         * Just assume the reference is valid. This is used for in-memory matching since there
751                         * is no expectation of a database in this situation
752                         */
753                        ResourceLinkForLocalReferenceParams params = ResourceLinkForLocalReferenceParams.instance()
754                                        .setSourcePath(thePathAndRef.getPath())
755                                        .setSourceResource(theEntity)
756                                        .setTargetResourceType(typeString)
757                                        .setTargetResourceId(targetId)
758                                        .setUpdated(transactionDate)
759                                        .setTargetResourceVersion(targetVersionId);
760
761                        resourceLink = forLocalReference(params);
762                }
763
764                theNewParams.myLinks.add(resourceLink);
765        }
766
767        private Optional<ResourceLink> findMatchingResourceLink(
768                        PathAndRef thePathAndRef, Collection<ResourceLink> theResourceLinks) {
769                IIdType referenceElement = thePathAndRef.getRef().getReferenceElement();
770                List<ResourceLink> resourceLinks = new ArrayList<>(theResourceLinks);
771                for (ResourceLink resourceLink : resourceLinks) {
772
773                        // comparing the searchParam path ex: Group.member.entity
774                        boolean hasMatchingSearchParamPath =
775                                        StringUtils.equals(resourceLink.getSourcePath(), thePathAndRef.getPath());
776
777                        boolean hasMatchingResourceType =
778                                        StringUtils.equals(resourceLink.getTargetResourceType(), referenceElement.getResourceType());
779
780                        boolean hasMatchingResourceId =
781                                        StringUtils.equals(resourceLink.getTargetResourceId(), referenceElement.getIdPart());
782
783                        boolean hasMatchingResourceVersion = myContext.getParserOptions().isStripVersionsFromReferences()
784                                        || referenceElement.getVersionIdPartAsLong() == null
785                                        || referenceElement.getVersionIdPartAsLong().equals(resourceLink.getTargetResourceVersion());
786
787                        if (hasMatchingSearchParamPath
788                                        && hasMatchingResourceType
789                                        && hasMatchingResourceId
790                                        && hasMatchingResourceVersion) {
791                                return Optional.of(resourceLink);
792                        }
793                }
794
795                return Optional.empty();
796        }
797
798        private void extractResourceLinksForContainedResources(
799                        RequestPartitionId theRequestPartitionId,
800                        ResourceIndexedSearchParams theParams,
801                        ResourceTable theEntity,
802                        IBaseResource theResource,
803                        TransactionDetails theTransactionDetails,
804                        boolean theFailOnInvalidReference,
805                        RequestDetails theRequest) {
806
807                FhirTerser terser = myContext.newTerser();
808
809                // 1. get all contained resources
810                Collection<IBaseResource> containedResources = terser.getAllEmbeddedResources(theResource, false);
811
812                extractResourceLinksForContainedResources(
813                                theRequestPartitionId,
814                                theParams,
815                                theEntity,
816                                theResource,
817                                theTransactionDetails,
818                                theFailOnInvalidReference,
819                                theRequest,
820                                containedResources,
821                                new HashSet<>());
822        }
823
824        private void extractResourceLinksForContainedResources(
825                        RequestPartitionId theRequestPartitionId,
826                        ResourceIndexedSearchParams theParams,
827                        ResourceTable theEntity,
828                        IBaseResource theResource,
829                        TransactionDetails theTransactionDetails,
830                        boolean theFailOnInvalidReference,
831                        RequestDetails theRequest,
832                        Collection<IBaseResource> theContainedResources,
833                        Collection<IBaseResource> theAlreadySeenResources) {
834
835                // 2. Find referenced search parameters
836                ISearchParamExtractor.SearchParamSet<PathAndRef> referencedSearchParamSet =
837                                mySearchParamExtractor.extractResourceLinks(theResource, true);
838
839                String spNamePrefix;
840                ResourceIndexedSearchParams currParams;
841                // 3. for each referenced search parameter, create an index
842                for (PathAndRef nextPathAndRef : referencedSearchParamSet) {
843
844                        // 3.1 get the search parameter name as spname prefix
845                        spNamePrefix = nextPathAndRef.getSearchParamName();
846
847                        if (spNamePrefix == null || nextPathAndRef.getRef() == null) continue;
848
849                        // 3.2 find the contained resource
850                        IBaseResource containedResource = findContainedResource(theContainedResources, nextPathAndRef.getRef());
851                        if (containedResource == null) continue;
852
853                        // 3.2.1 if we've already processed this resource upstream, do not process it again, to prevent infinite
854                        // loops
855                        if (theAlreadySeenResources.contains(containedResource)) {
856                                continue;
857                        }
858
859                        currParams = ResourceIndexedSearchParams.withSets();
860
861                        // 3.3 create indexes for the current contained resource
862                        ISearchParamExtractor.SearchParamSet<PathAndRef> indexedReferences =
863                                        mySearchParamExtractor.extractResourceLinks(containedResource, true);
864                        extractResourceLinks(
865                                        theRequestPartitionId,
866                                        currParams,
867                                        theEntity,
868                                        containedResource,
869                                        theTransactionDetails,
870                                        theFailOnInvalidReference,
871                                        theRequest,
872                                        indexedReferences);
873
874                        // 3.4 recurse to process any other contained resources referenced by this one
875                        if (myStorageSettings.isIndexOnContainedResourcesRecursively()) {
876                                HashSet<IBaseResource> nextAlreadySeenResources = new HashSet<>(theAlreadySeenResources);
877                                nextAlreadySeenResources.add(containedResource);
878                                extractResourceLinksForContainedResources(
879                                                theRequestPartitionId,
880                                                currParams,
881                                                theEntity,
882                                                containedResource,
883                                                theTransactionDetails,
884                                                theFailOnInvalidReference,
885                                                theRequest,
886                                                theContainedResources,
887                                                nextAlreadySeenResources);
888                        }
889
890                        // 3.4 added reference name as a prefix for the contained resource if any
891                        // e.g. for Observation.subject contained reference
892                        // the SP_NAME = subject.family
893                        currParams.updateSpnamePrefixForLinksOnContainedResource(nextPathAndRef.getPath());
894
895                        // 3.5 merge to the mainParams
896                        // NOTE: the spname prefix is different
897                        theParams.getResourceLinks().addAll(currParams.getResourceLinks());
898                }
899        }
900
901        @SuppressWarnings("unchecked")
902        private ResourceLink resolveTargetAndCreateResourceLinkOrReturnNull(
903                        @Nonnull RequestPartitionId theRequestPartitionId,
904                        String theSourceResourceName,
905                        PathAndRef thePathAndRef,
906                        ResourceTable theEntity,
907                        Date theUpdateTime,
908                        IIdType theNextId,
909                        RequestDetails theRequest,
910                        TransactionDetails theTransactionDetails) {
911                JpaPid resolvedResourceId = (JpaPid) theTransactionDetails.getResolvedResourceId(theNextId);
912
913                if (resolvedResourceId != null) {
914                        String targetResourceType = theNextId.getResourceType();
915                        Long targetResourcePid = resolvedResourceId.getId();
916                        String targetResourceIdPart = theNextId.getIdPart();
917                        Long targetVersion = theNextId.getVersionIdPartAsLong();
918
919                        ResourceLinkForLocalReferenceParams params = ResourceLinkForLocalReferenceParams.instance()
920                                        .setSourcePath(thePathAndRef.getPath())
921                                        .setSourceResource(theEntity)
922                                        .setTargetResourceType(targetResourceType)
923                                        .setTargetResourcePid(targetResourcePid)
924                                        .setTargetResourceId(targetResourceIdPart)
925                                        .setUpdated(theUpdateTime)
926                                        .setTargetResourceVersion(targetVersion)
927                                        .setTargetResourcePartitionablePartitionId(resolvedResourceId.getPartitionablePartitionId());
928
929                        return ResourceLink.forLocalReference(params);
930                }
931
932                /*
933                 * We keep a cache of resolved target resources. This is good since for some resource types, there
934                 * are multiple search parameters that map to the same element path within a resource (e.g.
935                 * Observation:patient and Observation.subject and we don't want to force a resolution of the
936                 * target any more times than we have to.
937                 */
938
939                IResourceLookup<JpaPid> targetResource;
940                if (myPartitionSettings.isPartitioningEnabled()) {
941                        if (myPartitionSettings.getAllowReferencesAcrossPartitions() == ALLOWED_UNQUALIFIED) {
942
943                                // Interceptor: Pointcut.JPA_CROSS_PARTITION_REFERENCE_DETECTED
944                                IInterceptorBroadcaster compositeBroadcaster =
945                                                CompositeInterceptorBroadcaster.newCompositeBroadcaster(myInterceptorBroadcaster, theRequest);
946                                if (compositeBroadcaster.hasHooks(Pointcut.JPA_RESOLVE_CROSS_PARTITION_REFERENCE)) {
947                                        CrossPartitionReferenceDetails referenceDetails = new CrossPartitionReferenceDetails(
948                                                        theRequestPartitionId,
949                                                        theSourceResourceName,
950                                                        thePathAndRef,
951                                                        theRequest,
952                                                        theTransactionDetails);
953                                        HookParams params = new HookParams(referenceDetails);
954                                        targetResource = (IResourceLookup<JpaPid>) compositeBroadcaster.callHooksAndReturnObject(
955                                                        Pointcut.JPA_RESOLVE_CROSS_PARTITION_REFERENCE, params);
956                                } else {
957                                        targetResource = myResourceLinkResolver.findTargetResource(
958                                                        RequestPartitionId.allPartitions(),
959                                                        theSourceResourceName,
960                                                        thePathAndRef,
961                                                        theRequest,
962                                                        theTransactionDetails);
963                                }
964
965                        } else {
966                                targetResource = myResourceLinkResolver.findTargetResource(
967                                                theRequestPartitionId, theSourceResourceName, thePathAndRef, theRequest, theTransactionDetails);
968                        }
969                } else {
970                        targetResource = myResourceLinkResolver.findTargetResource(
971                                        theRequestPartitionId, theSourceResourceName, thePathAndRef, theRequest, theTransactionDetails);
972                }
973
974                if (targetResource == null) {
975                        return null;
976                }
977
978                String targetResourceType = targetResource.getResourceType();
979                Long targetResourcePid = targetResource.getPersistentId().getId();
980                String targetResourceIdPart = theNextId.getIdPart();
981                Long targetVersion = theNextId.getVersionIdPartAsLong();
982
983                ResourceLinkForLocalReferenceParams params = ResourceLinkForLocalReferenceParams.instance()
984                                .setSourcePath(thePathAndRef.getPath())
985                                .setSourceResource(theEntity)
986                                .setTargetResourceType(targetResourceType)
987                                .setTargetResourcePid(targetResourcePid)
988                                .setTargetResourceId(targetResourceIdPart)
989                                .setUpdated(theUpdateTime)
990                                .setTargetResourceVersion(targetVersion)
991                                .setTargetResourcePartitionablePartitionId(
992                                                targetResource.getPersistentId().getPartitionablePartitionId());
993
994                return forLocalReference(params);
995        }
996
997        private RequestPartitionId determineResolverPartitionId(@Nonnull RequestPartitionId theRequestPartitionId) {
998                RequestPartitionId targetRequestPartitionId = theRequestPartitionId;
999                if (myPartitionSettings.isPartitioningEnabled()
1000                                && myPartitionSettings.getAllowReferencesAcrossPartitions() == ALLOWED_UNQUALIFIED) {
1001                        targetRequestPartitionId = RequestPartitionId.allPartitions();
1002                }
1003                return targetRequestPartitionId;
1004        }
1005
1006        private void populateResourceTable(
1007                        Collection<? extends BaseResourceIndexedSearchParam> theParams, ResourceTable theResourceTable) {
1008                for (BaseResourceIndexedSearchParam next : theParams) {
1009                        if (next.getResourcePid() == null) {
1010                                next.setResource(theResourceTable);
1011                        }
1012                }
1013        }
1014
1015        private void populateResourceTableForComboParams(
1016                        Collection<? extends IResourceIndexComboSearchParameter> theParams, ResourceTable theResourceTable) {
1017                for (IResourceIndexComboSearchParameter next : theParams) {
1018                        if (next.getResource() == null) {
1019                                next.setResource(theResourceTable);
1020                                if (next instanceof BasePartitionable) {
1021                                        ((BasePartitionable) next).setPartitionId(theResourceTable.getPartitionId());
1022                                }
1023                        }
1024                }
1025        }
1026
1027        @VisibleForTesting
1028        void setInterceptorBroadcasterForUnitTest(IInterceptorBroadcaster theInterceptorBroadcaster) {
1029                myInterceptorBroadcaster = theInterceptorBroadcaster;
1030        }
1031
1032        @Nonnull
1033        public List<String> extractParamValuesAsStrings(
1034                        RuntimeSearchParam theActiveSearchParam, IBaseResource theResource) {
1035                return mySearchParamExtractor.extractParamValuesAsStrings(theActiveSearchParam, theResource);
1036        }
1037
1038        public void extractSearchParamComboUnique(ResourceTable theEntity, ResourceIndexedSearchParams theParams) {
1039                String resourceType = theEntity.getResourceType();
1040                Set<ResourceIndexedComboStringUnique> comboUniques =
1041                                mySearchParamExtractor.extractSearchParamComboUnique(resourceType, theParams);
1042                theParams.myComboStringUniques.addAll(comboUniques);
1043                populateResourceTableForComboParams(theParams.myComboStringUniques, theEntity);
1044        }
1045
1046        public void extractSearchParamComboNonUnique(ResourceTable theEntity, ResourceIndexedSearchParams theParams) {
1047                String resourceType = theEntity.getResourceType();
1048                Set<ResourceIndexedComboTokenNonUnique> comboNonUniques =
1049                                mySearchParamExtractor.extractSearchParamComboNonUnique(resourceType, theParams);
1050                theParams.myComboTokenNonUnique.addAll(comboNonUniques);
1051                populateResourceTableForComboParams(theParams.myComboTokenNonUnique, theEntity);
1052        }
1053
1054        /**
1055         * This interface is used by {@link #extractSearchIndexParametersForTargetResources(RequestDetails, ResourceIndexedSearchParams, ResourceTable, Collection, IChainedSearchParameterExtractionStrategy, ISearchParamExtractor.SearchParamSet, boolean, boolean)}
1056         * in order to use that method for extracting chained search parameter indexes both
1057         * from contained resources and from uplifted refchains.
1058         */
1059        private interface IChainedSearchParameterExtractionStrategy {
1060
1061                /**
1062                 * Which search parameters should be indexed for the resource target
1063                 * at the given path. In other words if thePathAndRef contains
1064                 * "Patient/123", then we could return a filter that only lets the
1065                 * "name" and "gender" search params through  if we only want those
1066                 * two parameters to be indexed for the resolved Patient resource
1067                 * with that ID.
1068                 */
1069                @Nonnull
1070                ISearchParamExtractor.ISearchParamFilter getSearchParamFilter(@Nonnull PathAndRef thePathAndRef);
1071
1072                /**
1073                 * Actually fetch the resource at the given path, or return
1074                 * {@literal null} if none can be found.
1075                 */
1076                @Nullable
1077                IBaseResource fetchResourceAtPath(@Nonnull PathAndRef thePathAndRef);
1078        }
1079
1080        static void handleWarnings(
1081                        RequestDetails theRequestDetails,
1082                        IInterceptorBroadcaster theInterceptorBroadcaster,
1083                        ISearchParamExtractor.SearchParamSet<?> theSearchParamSet) {
1084                if (theSearchParamSet.getWarnings().isEmpty()) {
1085                        return;
1086                }
1087
1088                // If extraction generated any warnings, broadcast an error
1089                IInterceptorBroadcaster compositeBroadcaster =
1090                                CompositeInterceptorBroadcaster.newCompositeBroadcaster(theInterceptorBroadcaster, theRequestDetails);
1091                if (compositeBroadcaster.hasHooks(Pointcut.JPA_PERFTRACE_WARNING)) {
1092                        for (String next : theSearchParamSet.getWarnings()) {
1093                                StorageProcessingMessage messageHolder = new StorageProcessingMessage();
1094                                messageHolder.setMessage(next);
1095                                HookParams params = new HookParams()
1096                                                .add(RequestDetails.class, theRequestDetails)
1097                                                .addIfMatchesType(ServletRequestDetails.class, theRequestDetails)
1098                                                .add(StorageProcessingMessage.class, messageHolder);
1099                                compositeBroadcaster.callHooks(Pointcut.JPA_PERFTRACE_WARNING, params);
1100                        }
1101                }
1102        }
1103}