How to use

QueryKey

in

org.hibernate.cache.spi

private QueryKey buildBasicKey(CacheableResultTransformer resultTransformer) {
  return new QueryKey(
      QUERY_STRING,
      ArrayHelper.EMPTY_TYPE_ARRAY,         // positional param types
      ArrayHelper.EMPTY_OBJECT_ARRAY,        // positional param values
      Collections.EMPTY_MAP,                // named params
      null,                                // firstRow selection
      null,                                // maxRows selection
      Collections.EMPTY_SET,                 // filter keys
      null,                                // tenantIdentifier
      resultTransformer                    // the result transformer
  );
}

/**
 * Deserialization hook used to re-init the cached hashcode which is needed for proper clustering support.
 *
 * @param in The object input stream.
 *
 * @throws IOException Thrown by normal deserialization
 * @throws ClassNotFoundException Thrown by normal deserialization
 */
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
  in.defaultReadObject();
  this.hashCode = generateHashCode();
}

assert old != null && keyMap.size() == 1 : "apparent QueryKey equals/hashCode issue";
if ( key.getResultTransformer() != null ) {
  transformerMap.put( key.getResultTransformer(), "" );
  assert transformerMap.size() == 1 : "really messed up";
  old = transformerMap.put( key.getResultTransformer(), "value" );
  assert old != null && transformerMap.size() == 1 : "apparent QueryKey equals/hashCode issue";
old = keyMap.put( key2, "new value" );
assert old != null && keyMap.size() == 1 : "deserialization did not set hashCode or equals properly";
if ( key.getResultTransformer() == null ) {
  assert key2.getResultTransformer() == null;
  old = transformerMap.put( key2.getResultTransformer(), "new value" );
  assert old != null && transformerMap.size() == 1 : "deserialization did not set hashCode or equals properly";
    assert key.getResultTransformer() != key2.getResultTransformer(): "deserialization issue for non-singleton transformer";
    assert key.getResultTransformer().equals( key2.getResultTransformer() ): "deep copy issue";

private QueryKey generateQueryKey(
    SharedSessionContractImplementor session,
    QueryParameters queryParameters) {
  return QueryKey.generateQueryKey(
      getSQLString(),
      queryParameters,
      FilterKey.createFilterKeys( session.getLoadQueryInfluencers().getEnabledFilters() ),
      session,
      createCacheableResultTransformer( queryParameters )
  );
}

private static void logCachedResultDetails(QueryKey key, Set querySpaces, Type[] returnTypes, List result) {
  if ( !TRACING ) {
    return;
  }
  LOG.trace( "key.hashCode=" + key.hashCode() );
  LOG.trace( "querySpaces=" + querySpaces );
  if ( returnTypes == null || returnTypes.length == 0 ) {
    LOG.trace(
        "Unexpected returnTypes is "
            + ( returnTypes == null ? "null" : "empty" ) + "! result"
            + ( result == null ? " is null" : ".size()=" + result.size() )
    );
  }
  else {
    final StringBuilder returnTypeInfo = new StringBuilder();
    for ( Type returnType : returnTypes ) {
      returnTypeInfo.append( "typename=" )
          .append( returnType.getName() )
          .append( " class=" )
          .append( returnType.getReturnedClass().getName() )
          .append( ' ' );
    }
    LOG.trace( "unexpected returnTypes is " + returnTypeInfo.toString() + "! result" );
  }
}

queryResultsCacheKey = QueryKey.from(
    jdbcSelect.getSql(),
    executionContext.getQueryOptions().getLimit(),

private QueryKey generateQueryKey(
    SessionImplementor session,
    QueryParameters queryParameters) {
  return QueryKey.generateQueryKey(
      getSQLString(),
      queryParameters,
      FilterKey.createFilterKeys( session.getLoadQueryInfluencers().getEnabledFilters() ),
      session,
      createCacheableResultTransformer( queryParameters )
  );
}

private static void logCachedResultDetails(QueryKey key, Set querySpaces, Type[] returnTypes, List result) {
  if ( !LOG.isTraceEnabled() ) {
    return;
  }
  LOG.trace( "key.hashCode=" + key.hashCode() );
  LOG.trace( "querySpaces=" + querySpaces );
  if ( returnTypes == null || returnTypes.length == 0 ) {
    LOG.trace(
        "Unexpected returnTypes is "
            + ( returnTypes == null ? "null" : "empty" ) + "! result"
            + ( result == null ? " is null" : ".size()=" + result.size() )
    );
  }
  else {
    StringBuilder returnTypeInfo = new StringBuilder();
    for ( int i = 0; i < returnTypes.length; i++ ) {
      returnTypeInfo.append( "typename=" )
          .append( returnTypes[i].getName() )
          .append( " class=" )
          .append( returnTypes[i].getReturnedClass().getName() ).append( ' ' );
    }
    LOG.trace( "unexpected returnTypes is " + returnTypeInfo.toString() + "! result" );
  }
}

result = doList( session, queryParameters, key.getResultTransformer() );
result = (
    areResultSetRowsTransformedImmediately() ?
        key.getResultTransformer().retransformResults(
            result,
            getResultRowAliases(),
            includeInResultRow()
        ) :
        key.getResultTransformer().untransformToTuples(
            result

this.filterKeys = filterKeys;
this.customTransformer = customTransformer;
this.hashCode = generateHashCode();

return new QueryKey(
    queryString,
    types,

private QueryKey generateQueryKey(
    SessionImplementor session,
    QueryParameters queryParameters) {
  return QueryKey.generateQueryKey(
      getSQLString(),
      queryParameters,
      FilterKey.createFilterKeys( session.getLoadQueryInfluencers().getEnabledFilters() ),
      session,
      createCacheableResultTransformer( queryParameters )
  );
}

private static void logCachedResultDetails(QueryKey key, Set querySpaces, Type[] returnTypes, List result) {
  if ( !LOG.isTraceEnabled() ) {
    return;
  }
  LOG.trace( "key.hashCode=" + key.hashCode() );
  LOG.trace( "querySpaces=" + querySpaces );
  if ( returnTypes == null || returnTypes.length == 0 ) {
    LOG.trace(
        "Unexpected returnTypes is "
            + ( returnTypes == null ? "null" : "empty" ) + "! result"
            + ( result == null ? " is null" : ".size()=" + result.size() )
    );
  }
  else {
    StringBuilder returnTypeInfo = new StringBuilder();
    for ( int i = 0; i < returnTypes.length; i++ ) {
      returnTypeInfo.append( "typename=" )
          .append( returnTypes[i].getName() )
          .append( " class=" )
          .append( returnTypes[i].getReturnedClass().getName() ).append( ' ' );
    }
    LOG.trace( "unexpected returnTypes is " + returnTypeInfo.toString() + "! result" );
  }
}

protected void putResultInQueryCache(
    final SharedSessionContractImplementor session,
    final QueryParameters queryParameters,
    final Type[] resultTypes,
    final QueryResultsCache queryCache,
    final QueryKey key,
    final List result) {
  if ( session.getCacheMode().isPutEnabled() ) {
    boolean put = queryCache.put(
        key,
        result,
        key.getResultTransformer().getCachedResultTypes( resultTypes ),
        session
    );
    if ( put && factory.getStatistics().isStatisticsEnabled() ) {
      factory.getStatistics().queryCachePut( getQueryIdentifier(), queryCache.getRegion().getName() );
    }
  }
}

public QueryKey(
    String sql,
    ParameterBindingsMemento parameterBindingsMemento,
    Integer firstRow,
    Integer maxRows,
    String tenantIdentifier,
    Set<String> enabledFilterNames) {
  this.sqlQueryString = sql;
  this.parameterBindingsMemento = parameterBindingsMemento;
  this.firstRow = firstRow;
  this.maxRows = maxRows;
  this.tenantIdentifier = tenantIdentifier;
  this.enabledFilterNames = enabledFilterNames;
  this.hashCode = generateHashCode();
}

public static QueryKey from(
    String sqlQueryString,
    Limit limit,
    QueryParameterBindings parameterBindings,
    SharedSessionContractImplementor persistenceContext) {
  // todo (6.0) : here is where we should centralize cacheable-or-not
  //		if this method returns null, the query should be considered un-cacheable
  //
  // todo (6.0) : should limited (first/max) results be cacheable?
  // todo (6.0) : should filtered results be cacheable?
  final Limit limitToUse = limit == null ? Limit.NONE : limit;
  return new QueryKey(
      sqlQueryString,
      parameterBindings.generateQueryKeyMemento(),
      limitToUse.getFirstRow(),
      limitToUse.getMaxRows(),
      persistenceContext.getTenantIdentifier(),
      persistenceContext.getLoadQueryInfluencers().getEnabledFilterNames()
  );
}

    key,
    querySpaces,
    key.getResultTransformer().getCachedResultTypes( resultTypes ),
    session
);

/**
 * Deserialization hook used to re-init the cached hashcode which is needed for proper clustering support.
 *
 * @param in The object input stream.
 *
 * @throws IOException Thrown by normal deserialization
 * @throws ClassNotFoundException Thrown by normal deserialization
 */
private void readObject(java.io.ObjectInputStream in) throws IOException, ClassNotFoundException {
  in.defaultReadObject();
  this.hashCode = generateHashCode();
}

return new QueryKey(
    queryString,
    types,

result = doList( session, queryParameters, key.getResultTransformer() );
result = (
    areResultSetRowsTransformedImmediately() ?
        key.getResultTransformer().retransformResults(
            result,
            getResultRowAliases(),