simple selection query implementation

src/integrationTest/java/com/mongodb/hibernate/query/select/SimpleSelectQueryIntegrationTests.java

@@ -0,0 +1,230 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.hibernate.query.select;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.mongodb.hibernate.junit.MongoExtension;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.util.Arrays;
+import java.util.List;
+import java.util.function.Consumer;
+import org.hibernate.engine.spi.SessionImplementor;
+import org.hibernate.query.SelectionQuery;
+import org.hibernate.testing.jdbc.SQLStatementInspector;
+import org.hibernate.testing.orm.junit.DomainModel;
+import org.hibernate.testing.orm.junit.SessionFactory;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+import org.hibernate.testing.orm.junit.SessionFactoryScopeAware;
+import org.jspecify.annotations.Nullable;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+@SessionFactory(exportSchema = false, useCollectingStatementInspector = true)
+@DomainModel(annotatedClasses = SimpleSelectQueryIntegrationTests.Contact.class)
+@ExtendWith(MongoExtension.class)
+class SimpleSelectQueryIntegrationTests implements SessionFactoryScopeAware {
+
+    private SessionFactoryScope sessionFactoryScope;
+    private SQLStatementInspector mqlStatementInterceptor;
+
+    @Override
+    public void injectSessionFactoryScope(SessionFactoryScope sessionFactoryScope) {
+        this.sessionFactoryScope = sessionFactoryScope;
+        mqlStatementInterceptor = sessionFactoryScope.getCollectingStatementInspector();
+    }
+
+    private final List<Contact> testingContacts = List.of(
+            new Contact(1, "Bob", 18, Country.USA),
+            new Contact(2, "Mary", 35, Country.CANADA),
+            new Contact(3, "Dylan", 7, Country.CANADA),
+            new Contact(4, "Lucy", 78, Country.CANADA),
+            new Contact(5, "John", 25, Country.USA));
+
+    private List<Contact> getTestingContacts(int... ids) {
+        return Arrays.stream(ids).mapToObj(id -> testingContacts.get(id - 1)).toList();
+    }
+
+    @BeforeEach
+    void beforeEach() {
+        sessionFactoryScope.inTransaction(session -> testingContacts.forEach(session::persist));
+        mqlStatementInterceptor.clear();
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {true, false})
+    void testComparisonByEq(boolean fieldAsLhs) {
+        assertQuery(
+                "from Contact where " + (fieldAsLhs ? "country = :country" : ":country = country"),
+                q -> q.setParameter("country", Country.USA.name()),
+                "{'aggregate': 'contacts', 'pipeline': [{'$match': {'country': {'$eq': {'$undefined': true}}}}, {'$project': {'_id': true, 'age': true, 'country': true, 'name': true}}]}",
+                getTestingContacts(1, 5));
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {true, false})
+    void testComparisonByNe(boolean fieldAsLhs) {
+        sessionFactoryScope.inTransaction(session -> assertContactQueryResult(
+                session,
+                "from Contact where " + (fieldAsLhs ? "country != ?1" : "?1 != country"),
+                q -> q.setParameter(1, Country.USA.name()),
+                List.of(2, 3, 4)));
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {true, false})
+    void testComparisonByLt(boolean fieldAsLhs) {
+        sessionFactoryScope.inTransaction(session -> assertContactQueryResult(
+                session,
+                "from Contact where " + (fieldAsLhs ? "age < :age" : ":age > age"),
+                q -> q.setParameter("age", 35),
+                List.of(1, 3, 5)));
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {true, false})
+    void testComparisonByLte(boolean fieldAsLhs) {
+        sessionFactoryScope.inTransaction(session -> assertContactQueryResult(
+                session,
+                "from Contact where " + (fieldAsLhs ? "age <= ?1" : "?1 >= age"),
+                q -> q.setParameter(1, 35),
+                List.of(1, 2, 3, 5)));
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {true, false})
+    void testComparisonByGt(boolean fieldAsLhs) {
+        sessionFactoryScope.inTransaction(session -> assertContactQueryResult(
+                session,
+                "from Contact where " + (fieldAsLhs ? "age > :age" : ":age < age"),
+                q -> q.setParameter("age", 18),
+                List.of(2, 4, 5)));
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {true, false})
+    void testComparisonByGte(boolean fieldAsLhs) {
+        sessionFactoryScope.inTransaction(session -> assertContactQueryResult(
+                session,
+                "from Contact where " + (fieldAsLhs ? "age >= :age" : ":age <= age"),
+                q -> q.setParameter("age", 18),
+                List.of(1, 2, 4, 5)));
+    }
+
+    @Test
+    void testAndFilter(SessionFactoryScope scope) {
+        scope.inTransaction(session -> assertContactQueryResult(
+                session,
+                "from Contact where country = ?1 and age > ?2",
+                q -> q.setParameter(1, Country.CANADA.name()).setParameter(2, 18),
+                List.of(2, 4)));
+    }
+
+    @Test
+    void testOrFilter(SessionFactoryScope scope) {
+        scope.inTransaction(session -> assertContactQueryResult(
+                session,
+                "from Contact where country = :country or age > :age",
+                q -> q.setParameter("country", Country.CANADA.name()).setParameter("age", 18),
+                List.of(2, 3, 4, 5)));
+    }
+
+    @Test
+    void testSingleNegation(SessionFactoryScope scope) {
+        scope.inTransaction(session -> assertContactQueryResult(
+                session, "from Contact where age > 18 and not (country = 'USA')", null, List.of(2, 4)));
+    }
+
+    @Test
+    void testDoubleNegation(SessionFactoryScope scope) {
+        scope.inTransaction(session -> assertContactQueryResult(
+                session, "from Contact where age > 18 and not ( not (country = 'USA') )", null, List.of(5)));
+    }
+
+    @Test
+    void testProjectOperation(SessionFactoryScope scope) {
+        scope.inTransaction(session -> {
+            var results = session.createSelectionQuery(
+                            "select name, age from Contact where country = :country", Object[].class)
+                    .setParameter("country", Country.CANADA.name())
+                    .getResultList();
+            assertThat(results)
+                    .containsExactly(new Object[] {"Mary", 35}, new Object[] {"Dylan", 7}, new Object[] {"Lucy", 78});
+        });
+    }
+
+    private static void assertContactQueryResult(
+            SessionImplementor session,
+            String hql,
+            @Nullable Consumer<SelectionQuery<Contact>> queryPostProcessor,
+            List<Integer> expectedIds) {
+        var selectionQuery = session.createSelectionQuery(hql, Contact.class);
+        if (queryPostProcessor != null) {
+            queryPostProcessor.accept(selectionQuery);
+        }
+        var queryResult = selectionQuery.getResultList();
+        assertThat(queryResult).extracting(c -> c.id).containsExactly(expectedIds.toArray(new Integer[0]));
+    }
+
+    private void assertQuery(
+            String hql,
+            Consumer<SelectionQuery<Contact>> queryPostProcessor,
+            String mql,
+            List<Contact> expectedContacts) {
+        sessionFactoryScope.inTransaction(session -> {
+            var selectionQuery = session.createSelectionQuery(hql, Contact.class);
+            if (queryPostProcessor != null) {
+                queryPostProcessor.accept(selectionQuery);
+            }
+            var queryResult = selectionQuery.getResultList();
+            assertThat(mqlStatementInterceptor.getSqlQueries()).containsExactly(mql.replace('\'', '"'));
+            assertThat(queryResult)
+                    .usingRecursiveFieldByFieldElementComparator()
+                    .containsExactly(expectedContacts.toArray(new Contact[0]));
+        });
+    }
+
+    @Entity(name = "Contact")
+    @Table(name = "contacts")
+    static class Contact {
+        @Id
+        int id;
+
+        String name;
+        int age;
+        String country;
+
+        Contact() {}
+
+        Contact(int id, String name, int age, Country country) {
+            this.id = id;
+            this.name = name;
+            this.age = age;
+            this.country = country.name();
+        }
+    }
+
+    enum Country {
+        USA,
+        CANADA
+    }
+}

src/integrationTest/java/com/mongodb/hibernate/query/select/SimpleSelectQueryLiteralIntegrationTests.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2025-present MongoDB, Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.mongodb.hibernate.query.select;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import com.mongodb.hibernate.annotations.ObjectIdGenerator;
+import com.mongodb.hibernate.junit.MongoExtension;
+import jakarta.persistence.Entity;
+import jakarta.persistence.Id;
+import jakarta.persistence.Table;
+import java.math.BigDecimal;
+import org.bson.types.ObjectId;
+import org.hibernate.testing.orm.junit.DomainModel;
+import org.hibernate.testing.orm.junit.SessionFactory;
+import org.hibernate.testing.orm.junit.SessionFactoryScope;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+
+@SessionFactory(exportSchema = false)
+@DomainModel(annotatedClasses = SimpleSelectQueryLiteralIntegrationTests.Item.class)
+@ExtendWith(MongoExtension.class)
+class SimpleSelectQueryLiteralIntegrationTests {
+
+    @Test
+    void testBoolean(SessionFactoryScope scope) {
+        var item = new Item();
+        item.booleanField = true;
+        scope.inTransaction(session -> session.persist(item));
+        scope.inTransaction(
+                session -> assertThat(session.createSelectionQuery("from Item where booleanField = true", Item.class)
+                                .getSingleResult())
+                        .usingRecursiveComparison()
+                        .isEqualTo(item));
+    }
+
+    @Test
+    void testInteger(SessionFactoryScope scope) {
+        var item = new Item();
+        item.integerField = 1;
+        scope.inTransaction(session -> session.persist(item));
+        scope.inTransaction(
+                session -> assertThat(session.createSelectionQuery("from Item where integerField = 1", Item.class)
+                                .getSingleResult())
+                        .usingRecursiveComparison()
+                        .isEqualTo(item));
+    }
+
+    @Test
+    void testLong(SessionFactoryScope scope) {
+        var item = new Item();
+        item.longField = 1L;
+        scope.inTransaction(session -> session.persist(item));
+        scope.inTransaction(
+                session -> assertThat(session.createSelectionQuery("from Item where longField = 1", Item.class)
+                                .getSingleResult())
+                        .usingRecursiveComparison()
+                        .isEqualTo(item));
+    }
+
+    @Test
+    void testDouble(SessionFactoryScope scope) {
+        var item = new Item();
+        item.doubleField = 3.14;
+        scope.inTransaction(session -> session.persist(item));
+        scope.inTransaction(
+                session -> assertThat(session.createSelectionQuery("from Item where doubleField = 3.14", Item.class)
+                                .getSingleResult())
+                        .usingRecursiveComparison()
+                        .isEqualTo(item));
+    }
+
+    @Test
+    void testString(SessionFactoryScope scope) {
+        var item = new Item();
+        item.stringField = "Hello World";
+        scope.inTransaction(session -> session.persist(item));
+        scope.inTransaction(session -> assertThat(
+                        session.createSelectionQuery("from Item where stringField = 'Hello World'", Item.class)
+                                .getSingleResult())
+                .usingRecursiveComparison()
+                .isEqualTo(item));
+    }
+
+    @Test
+    void testBigDecimal(SessionFactoryScope scope) {
+        var item = new Item();
+        item.bigDecimalField = new BigDecimal("3.14");
+        scope.inTransaction(session -> session.persist(item));
+        scope.inTransaction(session -> assertThat(
+                        session.createSelectionQuery("from Item where bigDecimalField = 3.14BD", Item.class)
+                                .getSingleResult())
+                .usingRecursiveComparison()
+                .isEqualTo(item));
+    }
+
+    @Entity(name = "Item")
+    @Table(name = "items")
+    static class Item {
+        @Id
+        @ObjectIdGenerator
+        ObjectId id;
+
+        String stringField;
+        Boolean booleanField;
+        Integer integerField;
+        Long longField;
+        Double doubleField;
+        BigDecimal bigDecimalField;
+    }
+}