xiedeyantu commented on code in PR #4816:
URL: https://github.com/apache/calcite/pull/4816#discussion_r2876250238


##########
testkit/src/main/java/org/apache/calcite/sql/parser/SqlParserTest.java:
##########
@@ -1410,6 +1410,32 @@ private void checkLarge(int n) {
         .ok("VALUES (ROW((`A` BETWEEN ASYMMETRIC ((`B` OR (`C` AND `D`)) OR 
`E`) AND `F`)))");
   }
 
+  @Test void testBetweenInverse() throws Exception {

Review Comment:
   I've added a test similar to the one below; I'm not sure if it's appropriate.
   ```
   public class SqlBetweenOperatorTest {
     @Test
     void testNotInvertsNegationForAsymmetric() {
       // BETWEEN -> NOT_BETWEEN
       SqlBetweenOperator between = SqlStdOperatorTable.BETWEEN;
       SqlOperator notBetween = between.not();
       assertTrue(((SqlBetweenOperator) notBetween).isNegated(),
           "BETWEEN.not() should return a negated operator");
       assertSame(SqlStdOperatorTable.NOT_BETWEEN, notBetween,
           "BETWEEN.not() should return the NOT_BETWEEN constant");
   
       // NOT_BETWEEN -> BETWEEN
       SqlBetweenOperator notOp = SqlStdOperatorTable.NOT_BETWEEN;
       SqlOperator notNot = notOp.not();
       assertFalse(((SqlBetweenOperator) notNot).isNegated(),
           "NOT_BETWEEN.not() should return a non-negated operator");
       assertSame(SqlStdOperatorTable.BETWEEN, notNot,
           "NOT_BETWEEN.not() should return the BETWEEN constant");
     }
   
     @Test void testNotInvertsNegationForSymmetric() {
       // SYMMETRIC_BETWEEN -> SYMMETRIC_NOT_BETWEEN
       SqlBetweenOperator sym = SqlStdOperatorTable.SYMMETRIC_BETWEEN;
       SqlOperator notSym = sym.not();
       assertTrue(((SqlBetweenOperator) notSym).isNegated(),
           "SYMMETRIC_BETWEEN.not() should return a negated operator");
       assertSame(SqlStdOperatorTable.SYMMETRIC_NOT_BETWEEN, notSym,
           "SYMMETRIC_BETWEEN.not() should return the SYMMETRIC_NOT_BETWEEN 
constant");
   
       // SYMMETRIC_NOT_BETWEEN -> SYMMETRIC_BETWEEN
       SqlBetweenOperator symNot = SqlStdOperatorTable.SYMMETRIC_NOT_BETWEEN;
       SqlOperator notSymNot = symNot.not();
       assertFalse(((SqlBetweenOperator) notSymNot).isNegated(),
           "SYMMETRIC_NOT_BETWEEN.not() should return a non-negated operator");
       assertSame(SqlStdOperatorTable.SYMMETRIC_BETWEEN, notSymNot,
           "SYMMETRIC_NOT_BETWEEN.not() should return the SYMMETRIC_BETWEEN 
constant");
     }
   }
   ```



-- 
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.

To unsubscribe, e-mail: [email protected]

For queries about this service, please contact Infrastructure at:
[email protected]

Reply via email to