Partially convert EppResourceUtils to SQL (#1060)

* Partially convert EppResourceUtils to SQL

Some of the rest will depend on b/184578521.

The primary conversion in this PR is the change in
NameserverLookupByIpCommand as that is the only place where the removed
EppResourceUtils method was called. We also convert to DualDatabaseTest
the tests of the callers of NLBIC. and use a CriteriaQueryBuilder in the
foreign key index SQL lookup (allowing us to avoid the String.format
call).

core/src/main/java/google/registry/model/EppResourceUtils.java

@@ -194,30 +194,6 @@ public final class EppResourceUtils {
     return ForeignKeyIndex.load(clazz, uniqueIds, now).keySet();
   }
 
-  /**
-   * Loads resources that match some filter and that have {@link EppResource#deletionTime} that is
-   * not before "now".
-   *
-   * <p>This is an eventually consistent query.
-   *
-   * @param clazz the resource type to load
-   * @param now the logical time of the check
-   * @param filterDefinition the filter to apply when loading resources
-   * @param filterValue the acceptable value for the filter
-   */
-  public static <T extends EppResource> Iterable<T> queryNotDeleted(
-      Class<T> clazz, DateTime now, String filterDefinition, Object filterValue) {
-    return ofy()
-        .load()
-        .type(clazz)
-        .filter(filterDefinition, filterValue)
-        .filter("deletionTime >", now.toDate())
-        .list()
-        .stream()
-        .map(EppResourceUtils.transformAtTime(now))
-        .collect(toImmutableSet());
-  }
-
   /**
    * Returns a Function that transforms an EppResource to the given DateTime, suitable for use with
    * Iterables.transform() over a collection of EppResources.

core/src/main/java/google/registry/model/index/ForeignKeyIndex.java

@@ -48,8 +48,10 @@ import google.registry.model.contact.ContactResource;
 import google.registry.model.domain.DomainBase;
 import google.registry.model.host.HostResource;
 import google.registry.persistence.VKey;
+import google.registry.persistence.transaction.CriteriaQueryBuilder;
 import google.registry.schema.replay.DatastoreOnlyEntity;
 import google.registry.util.NonFinalForTesting;
+import java.util.Collection;
 import java.util.Comparator;
 import java.util.Map;
 import java.util.Optional;
@@ -193,7 +195,7 @@ public abstract class ForeignKeyIndex<E extends EppResource> extends BackupGroup
    * has been soft deleted.
    */
   public static <E extends EppResource> ImmutableMap<String, ForeignKeyIndex<E>> load(
-      Class<E> clazz, Iterable<String> foreignKeys, final DateTime now) {
+      Class<E> clazz, Collection<String> foreignKeys, final DateTime now) {
     return loadIndexesFromStore(clazz, foreignKeys).entrySet().stream()
         .filter(e -> now.isBefore(e.getValue().getDeletionTime()))
         .collect(entriesToImmutableMap());
@@ -207,7 +209,7 @@ public abstract class ForeignKeyIndex<E extends EppResource> extends BackupGroup
    */
   private static <E extends EppResource>
       ImmutableMap<String, ForeignKeyIndex<E>> loadIndexesFromStore(
-          Class<E> clazz, Iterable<String> foreignKeys) {
+          Class<E> clazz, Collection<String> foreignKeys) {
     if (tm().isOfy()) {
       return ImmutableMap.copyOf(
           tm().doTransactionless(() -> ofy().load().type(mapToFkiClass(clazz)).ids(foreignKeys)));
@@ -215,19 +217,16 @@ public abstract class ForeignKeyIndex<E extends EppResource> extends BackupGroup
       String property = RESOURCE_CLASS_TO_FKI_PROPERTY.get(clazz);
       ImmutableList<ForeignKeyIndex<E>> indexes =
           tm().transact(
-                  () -> {
-                    String entityName =
-                        jpaTm().getEntityManager().getMetamodel().entity(clazz).getName();
-                    return jpaTm()
-                        .query(
-                            String.format(
-                                "FROM %s WHERE %s IN :propertyValue", entityName, property),
-                            clazz)
-                        .setParameter("propertyValue", foreignKeys)
-                        .getResultStream()
-                        .map(e -> ForeignKeyIndex.create(e, e.getDeletionTime()))
-                        .collect(toImmutableList());
-                  });
+                  () ->
+                      jpaTm()
+                          .getEntityManager()
+                          .createQuery(
+                              CriteriaQueryBuilder.create(clazz)
+                                  .whereFieldIsIn(property, foreignKeys)
+                                  .build())
+                          .getResultStream()
+                          .map(e -> ForeignKeyIndex.create(e, e.getDeletionTime()))
+                          .collect(toImmutableList()));
       // We need to find and return the entities with the maximum deletionTime for each foreign key.
       return Multimaps.index(indexes, ForeignKeyIndex::getForeignKey).asMap().entrySet().stream()
           .map(
@@ -318,7 +317,7 @@ public abstract class ForeignKeyIndex<E extends EppResource> extends BackupGroup
    * reasons, and are OK with the trade-offs in loss of transactional consistency.
    */
   public static <E extends EppResource> ImmutableMap<String, ForeignKeyIndex<E>> loadCached(
-      Class<E> clazz, Iterable<String> foreignKeys, final DateTime now) {
+      Class<E> clazz, Collection<String> foreignKeys, final DateTime now) {
     if (!RegistryConfig.isEppResourceCachingEnabled()) {
       return tm().doTransactionless(() -> load(clazz, foreignKeys, now));
     }

core/src/main/java/google/registry/whois/NameserverLookupByIpCommand.java

@@ -16,12 +16,15 @@ package google.registry.whois;
 
 import static com.google.common.base.Preconditions.checkNotNull;
 import static com.google.common.collect.ImmutableList.toImmutableList;
-import static google.registry.model.EppResourceUtils.queryNotDeleted;
+import static google.registry.model.ofy.ObjectifyService.ofy;
+import static google.registry.persistence.transaction.TransactionManagerFactory.jpaTm;
+import static google.registry.persistence.transaction.TransactionManagerFactory.tm;
 import static javax.servlet.http.HttpServletResponse.SC_NOT_FOUND;
 
 import com.google.common.annotations.VisibleForTesting;
 import com.google.common.collect.ImmutableList;
 import com.google.common.collect.Streams;
+import com.google.common.net.InetAddresses;
 import com.google.common.net.InternetDomainName;
 import google.registry.model.host.HostResource;
 import google.registry.model.registry.Registries;
@@ -46,9 +49,34 @@ final class NameserverLookupByIpCommand implements WhoisCommand {
   }
 
   @Override
+  @SuppressWarnings("unchecked")
   public WhoisResponse executeQuery(DateTime now) throws WhoisException {
+    Iterable<HostResource> hostsFromDb;
+    if (tm().isOfy()) {
+      hostsFromDb =
+          ofy()
+              .load()
+              .type(HostResource.class)
+              .filter("inetAddresses", ipAddress)
+              .filter("deletionTime >", now.toDate());
+    } else {
+      hostsFromDb =
+          jpaTm()
+              .transact(
+                  () ->
+                      // We cannot query @Convert-ed fields in HQL so we must use native Postgres
+                      jpaTm()
+                          .getEntityManager()
+                          .createNativeQuery(
+                              "SELECT * From \"Host\" WHERE :address = ANY(inet_addresses) AND "
+                                  + "deletion_time > CAST(:now AS timestamptz)",
+                              HostResource.class)
+                          .setParameter("address", InetAddresses.toAddrString(ipAddress))
+                          .setParameter("now", now.toString())
+                          .getResultList());
+    }
     ImmutableList<HostResource> hosts =
-        Streams.stream(queryNotDeleted(HostResource.class, now, "inetAddresses", ipAddress))
+        Streams.stream(hostsFromDb)
             .filter(
                 host ->
                     Registries.findTldForName(InternetDomainName.from(host.getHostName()))