Add spatial join and area restrictor tests

malensek · malensek · commit ecc1ec43ac47 · 2026-07-14T10:11:38.000-07:00
diff --git a/src/qproc/testQueryAnaGeneral.cc b/src/qproc/testQueryAnaGeneral.cc
@@ -328,6 +328,16 @@ static const std::vector<ScisqlRestrictorTestCaseData> SCISQL_RESTRICTOR_TEST_CA
                                      "AND `o`.`objectIdObjTest`=`s`.`objectIdSourceTest`",
                                      std::make_shared<AreaRestrictorCircle>("1", "1", "1.3")),
 
+        // "<=>" (null-safe equality) is equivalent to "=" here since scisql_s2PtInCircle() never
+        // evaluates to NULL.
+        ScisqlRestrictorTestCaseData("select * from LSST.Object o, Source s "
+                                     "WHERE scisql_s2PtInCircle(o.ra_Test, o.decl_Test, 1, 1, 1.3) <=> 1 "
+                                     "AND o.objectIdObjTest = s.objectIdSourceTest;",
+                                     "SELECT * FROM `LSST`.`Object_100` AS `o`,`LSST`.`Source_100` AS `s` "
+                                     "WHERE scisql_s2PtInCircle(`o`.`ra_Test`,`o`.`decl_Test`,1,1,1.3)<=>1 "
+                                     "AND `o`.`objectIdObjTest`=`s`.`objectIdSourceTest`",
+                                     std::make_shared<AreaRestrictorCircle>("1", "1", "1.3")),
+
         ScisqlRestrictorTestCaseData(
                 "select * from LSST.Object o, Source s "
                 "WHERE scisql_s2PtInEllipse(ra_Test, decl_Test, 1.2, 3.2, 2500, 1500, 0.2) = 1 "
@@ -633,6 +643,256 @@ BOOST_AUTO_TEST_CASE(ObjectSelfJoinDistance) {
     BOOST_CHECK_EQUAL(actual, expected);
 }
 
+BOOST_AUTO_TEST_CASE(ObjectSelfJoinPtInCircle) {
+    // A spatial self-join expressed with point-in-circle syntax is equivalent to a scisql_angSep()
+    // comparison and should be recognized as a near-neighbor join.
+    std::string stmt =
+            "select count(*) from LSST.Object o1,LSST.Object o2 "
+            "WHERE qserv_areaspec_box(5.5, 5.5, 6.1, 6.1) AND "
+            "scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02) = 1";
+    std::string expected =
+            "SELECT count(*) AS `QS1_COUNT` "
+            "FROM `Subchunks_LSST_100`.`Object_100_%S\007S%` AS `o1`,"
+            "`Subchunks_LSST_100`.`Object_100_%S\007S%` AS `o2` "
+            "WHERE scisql_s2PtInBox(`o1`.`ra_Test`,`o1`.`decl_Test`,5.5,5.5,6.1,6.1)=1 "
+            "AND scisql_s2PtInBox(`o2`.`ra_Test`,`o2`.`decl_Test`,5.5,5.5,6.1,6.1)=1 "
+            "AND scisql_s2PtInCircle(`o1`.`ra_Test`,`o1`.`decl_Test`,"
+            "`o2`.`ra_Test`,`o2`.`decl_Test`,0.02)=1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+    std::shared_ptr<QueryContext> context = qs->dbgGetContext();
+    BOOST_CHECK(context);
+    BOOST_CHECK(nullptr == context->secIdxRestrictors);
+    BOOST_CHECK(nullptr != context->areaRestrictors);
+    BOOST_CHECK(context->hasChunks());
+    BOOST_CHECK(context->hasSubChunks());
+    BOOST_CHECK(context->needsMerge);
+    std::string actual2 = queryAnaHelper.buildFirstParallelQuery();
+    BOOST_CHECK_EQUAL(actual2, expected);
+}
+
+BOOST_AUTO_TEST_CASE(PtInCircleJoinForms) {
+    // scisql_s2PtInCircle() call may appear on either side of "=" or "<=>"
+    std::vector<std::string> const predicates = {
+            "scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02) = 1",
+            "1 = scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02)",
+            "scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02) <=> 1",
+            "1 <=> scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02)"};
+    for (auto const& predicate : predicates) {
+        std::string stmt = "select count(*) from LSST.Object o1,LSST.Object o2 WHERE " + predicate;
+        qsTest.sqlConfig =
+                SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+        std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+        BOOST_CHECK_EQUAL(qs->getError(), "");
+        std::shared_ptr<QueryContext> context = qs->dbgGetContext();
+        BOOST_CHECK(context);
+        BOOST_CHECK(context->hasChunks());
+        BOOST_CHECK(context->hasSubChunks());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(PtInCircleJoinUnsupportedOperators) {
+    // scisql_s2PtInCircle() only ever returns 0 or 1, so only plain equality against 1 is recognized as a
+    // join predicate
+    std::vector<std::string> const predicates = {
+            "scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02) != 0",
+            "0 < scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02)"};
+    for (auto const& predicate : predicates) {
+        std::string stmt = "select count(*) from LSST.Object o1,LSST.Object o2 WHERE " + predicate;
+        qsTest.sqlConfig =
+                SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+        std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt, true);
+        BOOST_CHECK_EQUAL(qs->getError(), NOT_EVALUABLE_MSG);
+    }
+}
+
+BOOST_AUTO_TEST_CASE(PtInCircleAntiJoin) {
+    // A point outside the circle selects distant pairs, which cannot be evaluated using partition-local data.
+    std::string stmt =
+            "select count(*) from LSST.Object o1,LSST.Object o2 "
+            "WHERE scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02) = 0";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt, true);
+    BOOST_CHECK_EQUAL(qs->getError(), NOT_EVALUABLE_MSG);
+}
+
+BOOST_AUTO_TEST_CASE(NegatedPtInCircleJoinNotMisread) {
+    // Similar to PtInCircleAntiJoin, but with NOT.
+    std::string stmt =
+            "select count(*) from LSST.Object o1,LSST.Object o2 "
+            "WHERE NOT scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02) = 1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt, true);
+    BOOST_CHECK_EQUAL(qs->getError(), NOT_EVALUABLE_MSG);
+}
+
+BOOST_AUTO_TEST_CASE(PtInCircleJoinWithConeRestrictor) {
+    // Join AND a spatial restrictor
+    std::string stmt =
+            "select count(*) from LSST.Object o1,LSST.Object o2 "
+            "WHERE scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,6,6,0.3) = 1 AND "
+            "scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,0.02) = 1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+    BOOST_CHECK_EQUAL(qs->getError(), "");
+    std::shared_ptr<QueryContext> context = qs->dbgGetContext();
+    BOOST_CHECK(context);
+    BOOST_REQUIRE(context->areaRestrictors);
+    BOOST_CHECK_EQUAL(context->areaRestrictors->size(), 1U);
+    BOOST_REQUIRE(context->areaRestrictors->front());
+    BOOST_CHECK_EQUAL(*context->areaRestrictors->front(), AreaRestrictorCircle("6", "6", "0.3"));
+    BOOST_CHECK(context->hasChunks());
+    BOOST_CHECK(context->hasSubChunks());
+}
+
+BOOST_AUTO_TEST_CASE(AngSepAsConeRestrictor) {
+    // scisql_angSep() with a constant center, bounded above, is equivalent to scisql_s2PtInCircle() = 1
+    std::vector<std::string> const predicates = {
+            "scisql_angSep(ra_PS, decl_PS, 1.5, 3) < 0.1", "scisql_angSep(ra_PS, decl_PS, 1.5, 3) <= 0.1",
+            "0.1 > scisql_angSep(ra_PS, decl_PS, 1.5, 3)", "scisql_angSep(1.5, 3, ra_PS, decl_PS) < 0.1",
+            "scisql_angSep(ra_PS, decl_PS, 1.5, 3) = 0.1", "scisql_angSep(ra_PS, decl_PS, 1.5, 3) <=> 0.1"};
+    for (auto const& predicate : predicates) {
+        std::string stmt = "select * from Object where " + predicate;
+        qsTest.sqlConfig =
+                SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_PS", "decl_PS"}}}}}));
+        std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+        BOOST_CHECK_EQUAL(qs->getError(), "");
+        std::shared_ptr<QueryContext> context = qs->dbgGetContext();
+        BOOST_CHECK(context);
+        BOOST_REQUIRE(context->areaRestrictors);
+        BOOST_CHECK_EQUAL(context->areaRestrictors->size(), 1U);
+        BOOST_REQUIRE(context->areaRestrictors->front());
+        BOOST_CHECK_EQUAL(*context->areaRestrictors->front(), AreaRestrictorCircle("1.5", "3", "0.1"));
+        BOOST_CHECK(context->hasChunks());
+        BOOST_CHECK(!context->hasSubChunks());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(AngSepLowerBoundNoRestrictor) {
+    // Bounding scisql_angSep() from below selects points outside the cone; no restrictor produced
+    std::string stmt = "select * from Object where scisql_angSep(ra_PS, decl_PS, 1.5, 3) > 0.1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_PS", "decl_PS"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+    BOOST_CHECK_EQUAL(qs->getError(), "");
+    std::shared_ptr<QueryContext> context = qs->dbgGetContext();
+    BOOST_CHECK(context);
+    BOOST_CHECK(nullptr == context->areaRestrictors);
+    BOOST_CHECK(context->hasChunks());
+}
+
+BOOST_AUTO_TEST_CASE(NegativeAngSepConeThresholdRejected) {
+    // A negative scisql_angSep() threshold can never be satisfied, so should error
+    std::string stmt = "select * from Object where scisql_angSep(ra_PS, decl_PS, 1.5, 3) < -0.1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_PS", "decl_PS"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt, true);
+    BOOST_CHECK_EQUAL(qs->getError(),
+                      "AnalysisError:scisql_angSep() comparison threshold must be a non-negative "
+                      "number, got -0.100000");
+}
+
+BOOST_AUTO_TEST_CASE(AngSepConeRestrictorWithAngSepJoin) {
+    // Cone restrictor AND a spatial join, both via scisql_angSep()
+    std::string stmt =
+            "select count(*) from LSST.Object o1,LSST.Object o2 "
+            "WHERE scisql_angSep(o1.ra_Test, o1.decl_Test, 6, 6) < 0.3 AND "
+            "scisql_angSep(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test) < 0.02";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+    BOOST_CHECK_EQUAL(qs->getError(), "");
+    std::shared_ptr<QueryContext> context = qs->dbgGetContext();
+    BOOST_CHECK(context);
+    BOOST_REQUIRE(context->areaRestrictors);
+    BOOST_CHECK_EQUAL(context->areaRestrictors->size(), 1U);
+    BOOST_REQUIRE(context->areaRestrictors->front());
+    BOOST_CHECK_EQUAL(*context->areaRestrictors->front(), AreaRestrictorCircle("6", "6", "0.3"));
+    BOOST_CHECK(context->hasChunks());
+    BOOST_CHECK(context->hasSubChunks());
+}
+
+BOOST_AUTO_TEST_CASE(UnrelatedNegativeConstantNotMistakenForAngSep) {
+    // A "col < negative constant" predicate unrelated to scisql_angSep() must not be rejected
+    std::string stmt = "select * from LSST.Object o1 WHERE o1.mag < -5";
+    qsTest.sqlConfig = SqlConfig(
+            SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test", "mag"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+    BOOST_CHECK_EQUAL(qs->getError(), "");
+}
+
+BOOST_AUTO_TEST_CASE(NegativeAngSepThresholdRejected) {
+    // A negative scisql_angSep() threshold can never be satisfied, so it should error
+    std::string stmt =
+            "select * from LSST.Object o, Source s "
+            "WHERE o.objectIdObjTest = s.objectIdSourceTest AND "
+            "scisql_angSep(o.ra_Test,o.decl_Test,s.ra_Test,s.decl_Test) < -0.5;";
+    qsTest.sqlConfig = SqlConfig(
+            SqlConfig::MockDbTableColumns({{"LSST",
+                                            {{"Object", {"objectIdObjTest", "ra_Test", "decl_Test"}},
+                                             {"Source", {"objectIdSourceTest", "ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt, true);
+    BOOST_CHECK_EQUAL(qs->getError(),
+                      "AnalysisError:scisql_angSep() comparison threshold must be a non-negative "
+                      "number, got -0.500000");
+}
+
+BOOST_AUTO_TEST_CASE(NegativePtInCircleRadiusRejected) {
+    // A negative scisql_s2PtInCircle() radius can never be satisfied, so it should error
+    std::string stmt =
+            "select count(*) from LSST.Object o1,LSST.Object o2 "
+            "WHERE scisql_s2PtInCircle(o1.ra_Test,o1.decl_Test,o2.ra_Test,o2.decl_Test,-0.5) = 1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt, true);
+    BOOST_CHECK_EQUAL(qs->getError(),
+                      "AnalysisError:scisql_s2PtInCircle() radius must be a non-negative number, "
+                      "got -0.500000");
+}
+
+BOOST_AUTO_TEST_CASE(NegativePtInCircleRestrictorRadiusRejected) {
+    // Same as NegativePtInCircleRadiusRejected, but for the single-table restrictor form
+    std::string stmt =
+            "select * from LSST.Object o WHERE scisql_s2PtInCircle(o.ra_Test, o.decl_Test, 1, 1, -0.5) = 1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt, true);
+    BOOST_CHECK_EQUAL(qs->getError(),
+                      "AnalysisError:scisql_s2PtInCircle() radius must be a non-negative number, "
+                      "got -0.500000");
+}
+
+BOOST_AUTO_TEST_CASE(NegatedPtInCircleRestrictorNotMisread) {
+    // "NOT scisql_s2PtInCircle(...) = 1" describes everything OUTSIDE the circle, which is not a bounded area
+    // constraint
+    std::string stmt =
+            "select * from LSST.Object o "
+            "WHERE NOT scisql_s2PtInCircle(o.ra_Test, o.decl_Test, 1, 1, 1.3) = 1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_Test", "decl_Test"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+    BOOST_CHECK_EQUAL(qs->getError(), "");
+    std::shared_ptr<QueryContext> context = qs->dbgGetContext();
+    BOOST_CHECK(context);
+    BOOST_CHECK(nullptr == context->areaRestrictors);
+}
+
+BOOST_AUTO_TEST_CASE(NegatedAngSepRestrictorNotMisread) {
+    // Same as above, for the scisql_angSep() as restrictor
+    std::string stmt = "select * from Object where NOT scisql_angSep(ra_PS, decl_PS, 1.5, 3) < 0.1";
+    qsTest.sqlConfig =
+            SqlConfig(SqlConfig::MockDbTableColumns({{"LSST", {{"Object", {"ra_PS", "decl_PS"}}}}}));
+    std::shared_ptr<QuerySession> qs = queryAnaHelper.buildQuerySession(qsTest, stmt);
+    BOOST_CHECK_EQUAL(qs->getError(), "");
+    std::shared_ptr<QueryContext> context = qs->dbgGetContext();
+    BOOST_CHECK(context);
+    BOOST_CHECK(nullptr == context->areaRestrictors);
+}
+
 BOOST_AUTO_TEST_CASE(SelfJoinAliased) {
     // o2.ra_PS and o2.ra_PS_Sigma have to be aliased in order to produce
     // a result that can't be stored in a table as-is.
