IntervalTest.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to you 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 org.apache.calcite.test;
/** Test cases for intervals.
*
* <p>Called, with varying implementations of {@link Fixture},
* from both parser and validator test.
*/
public class IntervalTest {
private final Fixture f;
public IntervalTest(Fixture fixture) {
this.f = fixture;
}
/** Runs all tests. */
public void testAll() {
// Tests that should pass both parser and validator
subTestIntervalYearPositive();
subTestIntervalYearToMonthPositive();
subTestIntervalMonthPositive();
subTestIntervalDayPositive();
subTestIntervalDayToHourPositive();
subTestIntervalDayToMinutePositive();
subTestIntervalDayToSecondPositive();
subTestIntervalHourPositive();
subTestIntervalHourToMinutePositive();
subTestIntervalHourToSecondPositive();
subTestIntervalMinutePositive();
subTestIntervalMinuteToSecondPositive();
subTestIntervalSecondPositive();
subTestIntervalWeekPositive();
subTestIntervalQuarterPositive();
subTestIntervalPlural();
// Tests that should pass parser but fail validator
subTestIntervalYearNegative();
subTestIntervalYearToMonthNegative();
subTestIntervalMonthNegative();
subTestIntervalDayNegative();
subTestIntervalDayToHourNegative();
subTestIntervalDayToMinuteNegative();
subTestIntervalDayToSecondNegative();
subTestIntervalHourNegative();
subTestIntervalHourToMinuteNegative();
subTestIntervalHourToSecondNegative();
subTestIntervalMinuteNegative();
subTestIntervalMinuteToSecondNegative();
subTestIntervalSecondNegative();
subTestMisc();
}
/**
* Runs tests for INTERVAL... YEAR that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalYearPositive() {
// default precision
f.expr("INTERVAL '1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.expr("INTERVAL '99' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1' YEAR(2)")
.columnType("INTERVAL YEAR(2) NOT NULL");
f.expr("INTERVAL '99' YEAR(2)")
.columnType("INTERVAL YEAR(2) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647' YEAR(10)")
.columnType("INTERVAL YEAR(10) NOT NULL");
// min precision
f.expr("INTERVAL '0' YEAR(1)")
.columnType("INTERVAL YEAR(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '1234' YEAR(4)")
.columnType("INTERVAL YEAR(4) NOT NULL");
// sign
f.expr("INTERVAL '+1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.expr("INTERVAL '-1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.expr("INTERVAL +'1' YEAR")
.assertParse("INTERVAL '1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.expr("INTERVAL +'+1' YEAR")
.assertParse("INTERVAL '+1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.expr("INTERVAL +'-1' YEAR")
.assertParse("INTERVAL '-1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.expr("INTERVAL -'1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.expr("INTERVAL -'+1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.expr("INTERVAL -'-1' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
}
/**
* Runs tests for INTERVAL... YEAR TO MONTH that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalYearToMonthPositive() {
// default precision
f.expr("INTERVAL '1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL '99-11' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL '99-0' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1-2' YEAR(2) TO MONTH")
.columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
f.expr("INTERVAL '99-11' YEAR(2) TO MONTH")
.columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
f.expr("INTERVAL '99-0' YEAR(2) TO MONTH")
.columnType("INTERVAL YEAR(2) TO MONTH NOT NULL");
// max precision
f.expr("INTERVAL '2147483647-11' YEAR(10) TO MONTH")
.columnType("INTERVAL YEAR(10) TO MONTH NOT NULL");
// min precision
f.expr("INTERVAL '0-0' YEAR(1) TO MONTH")
.columnType("INTERVAL YEAR(1) TO MONTH NOT NULL");
// alternate precision
f.expr("INTERVAL '2006-2' YEAR(4) TO MONTH")
.columnType("INTERVAL YEAR(4) TO MONTH NOT NULL");
// sign
f.expr("INTERVAL '-1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL '+1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL +'1-2' YEAR TO MONTH")
.assertParse("INTERVAL '1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL +'-1-2' YEAR TO MONTH")
.assertParse("INTERVAL '-1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL +'+1-2' YEAR TO MONTH")
.assertParse("INTERVAL '+1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL -'1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL -'-1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.expr("INTERVAL -'+1-2' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
}
/**
* Runs tests for INTERVAL... MONTH that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalMonthPositive() {
// default precision
f.expr("INTERVAL '1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL '99' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1' MONTH(2)")
.columnType("INTERVAL MONTH(2) NOT NULL");
f.expr("INTERVAL '99' MONTH(2)")
.columnType("INTERVAL MONTH(2) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647' MONTH(10)")
.columnType("INTERVAL MONTH(10) NOT NULL");
// min precision
f.expr("INTERVAL '0' MONTH(1)")
.columnType("INTERVAL MONTH(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '1234' MONTH(4)")
.columnType("INTERVAL MONTH(4) NOT NULL");
// sign
f.expr("INTERVAL '+1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL '-1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL +'1' MONTH")
.assertParse("INTERVAL '1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL +'+1' MONTH")
.assertParse("INTERVAL '+1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL +'-1' MONTH")
.assertParse("INTERVAL '-1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL -'1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL -'+1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL -'-1' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
}
/**
* Runs tests for INTERVAL... DAY that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalDayPositive() {
// default precision
f.expr("INTERVAL '1' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL '99' DAY")
.columnType("INTERVAL DAY NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1' DAY(2)")
.columnType("INTERVAL DAY(2) NOT NULL");
f.expr("INTERVAL '99' DAY(2)")
.columnType("INTERVAL DAY(2) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647' DAY(10)")
.columnType("INTERVAL DAY(10) NOT NULL");
// min precision
f.expr("INTERVAL '0' DAY(1)")
.columnType("INTERVAL DAY(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '1234' DAY(4)")
.columnType("INTERVAL DAY(4) NOT NULL");
// sign
f.expr("INTERVAL '+1' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL '-1' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL +'1' DAY")
.assertParse("INTERVAL '1' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL +'+1' DAY")
.assertParse("INTERVAL '+1' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL +'-1' DAY")
.assertParse("INTERVAL '-1' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL -'1' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL -'+1' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL -'-1' DAY")
.columnType("INTERVAL DAY NOT NULL");
}
public void subTestIntervalDayToHourPositive() {
// default precision
f.expr("INTERVAL '1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL '99 23' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL '99 0' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1 2' DAY(2) TO HOUR")
.columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
f.expr("INTERVAL '99 23' DAY(2) TO HOUR")
.columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
f.expr("INTERVAL '99 0' DAY(2) TO HOUR")
.columnType("INTERVAL DAY(2) TO HOUR NOT NULL");
// max precision
f.expr("INTERVAL '2147483647 23' DAY(10) TO HOUR")
.columnType("INTERVAL DAY(10) TO HOUR NOT NULL");
// min precision
f.expr("INTERVAL '0 0' DAY(1) TO HOUR")
.columnType("INTERVAL DAY(1) TO HOUR NOT NULL");
// alternate precision
f.expr("INTERVAL '2345 2' DAY(4) TO HOUR")
.columnType("INTERVAL DAY(4) TO HOUR NOT NULL");
// sign
f.expr("INTERVAL '-1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL '+1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL +'1 2' DAY TO HOUR")
.assertParse("INTERVAL '1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL +'-1 2' DAY TO HOUR")
.assertParse("INTERVAL '-1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL +'+1 2' DAY TO HOUR")
.assertParse("INTERVAL '+1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL -'1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL -'-1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.expr("INTERVAL -'+1 2' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
}
/**
* Runs tests for INTERVAL... DAY TO MINUTE that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalDayToMinutePositive() {
// default precision
f.expr("INTERVAL '1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL '99 23:59' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL '99 0:0' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1 2:3' DAY(2) TO MINUTE")
.columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
f.expr("INTERVAL '99 23:59' DAY(2) TO MINUTE")
.columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
f.expr("INTERVAL '99 0:0' DAY(2) TO MINUTE")
.columnType("INTERVAL DAY(2) TO MINUTE NOT NULL");
// max precision
f.expr("INTERVAL '2147483647 23:59' DAY(10) TO MINUTE")
.columnType("INTERVAL DAY(10) TO MINUTE NOT NULL");
// min precision
f.expr("INTERVAL '0 0:0' DAY(1) TO MINUTE")
.columnType("INTERVAL DAY(1) TO MINUTE NOT NULL");
// alternate precision
f.expr("INTERVAL '2345 6:7' DAY(4) TO MINUTE")
.columnType("INTERVAL DAY(4) TO MINUTE NOT NULL");
// sign
f.expr("INTERVAL '-1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL '+1 2:3' DAY TO MINUTE")
.assertParse("INTERVAL '+1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL +'1 2:3' DAY TO MINUTE")
.assertParse("INTERVAL '1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL +'-1 2:3' DAY TO MINUTE")
.assertParse("INTERVAL '-1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL +'+1 2:3' DAY TO MINUTE")
.assertParse("INTERVAL '+1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL -'1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL -'-1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.expr("INTERVAL -'+1 2:3' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
}
/**
* Runs tests for INTERVAL... DAY TO SECOND that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalDayToSecondPositive() {
// default precision
f.expr("INTERVAL '1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL '99 23:59:59' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL '99 0:0:0' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL '99 23:59:59.999999' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL '99 0:0:0.0' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1 2:3:4' DAY(2) TO SECOND")
.columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99 23:59:59' DAY(2) TO SECOND")
.columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99 0:0:0' DAY(2) TO SECOND")
.columnType("INTERVAL DAY(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99 23:59:59.999999' DAY TO SECOND(6)")
.columnType("INTERVAL DAY TO SECOND(6) NOT NULL");
f.expr("INTERVAL '99 0:0:0.0' DAY TO SECOND(6)")
.columnType("INTERVAL DAY TO SECOND(6) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647 23:59:59' DAY(10) TO SECOND")
.columnType("INTERVAL DAY(10) TO SECOND NOT NULL");
f.expr("INTERVAL '2147483647 23:59:59.999999999' DAY(10) TO SECOND(9)")
.columnType("INTERVAL DAY(10) TO SECOND(9) NOT NULL");
// min precision
f.expr("INTERVAL '0 0:0:0' DAY(1) TO SECOND")
.columnType("INTERVAL DAY(1) TO SECOND NOT NULL");
f.expr("INTERVAL '0 0:0:0.0' DAY(1) TO SECOND(1)")
.columnType("INTERVAL DAY(1) TO SECOND(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '2345 6:7:8' DAY(4) TO SECOND")
.columnType("INTERVAL DAY(4) TO SECOND NOT NULL");
f.expr("INTERVAL '2345 6:7:8.9012' DAY(4) TO SECOND(4)")
.columnType("INTERVAL DAY(4) TO SECOND(4) NOT NULL");
// sign
f.expr("INTERVAL '-1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL '+1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL +'1 2:3:4' DAY TO SECOND")
.assertParse("INTERVAL '1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL +'-1 2:3:4' DAY TO SECOND")
.assertParse("INTERVAL '-1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL +'+1 2:3:4' DAY TO SECOND")
.assertParse("INTERVAL '+1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL -'1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL -'-1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
f.expr("INTERVAL -'+1 2:3:4' DAY TO SECOND")
.columnType("INTERVAL DAY TO SECOND NOT NULL");
}
/**
* Runs tests for INTERVAL... HOUR that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalHourPositive() {
// default precision
f.expr("INTERVAL '1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL '99' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1' HOUR(2)")
.columnType("INTERVAL HOUR(2) NOT NULL");
f.expr("INTERVAL '99' HOUR(2)")
.columnType("INTERVAL HOUR(2) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647' HOUR(10)")
.columnType("INTERVAL HOUR(10) NOT NULL");
// min precision
f.expr("INTERVAL '0' HOUR(1)")
.columnType("INTERVAL HOUR(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '1234' HOUR(4)")
.columnType("INTERVAL HOUR(4) NOT NULL");
// sign
f.expr("INTERVAL '+1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL '-1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL +'1' HOUR")
.assertParse("INTERVAL '1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL +'+1' HOUR")
.assertParse("INTERVAL '+1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL +'-1' HOUR")
.assertParse("INTERVAL '-1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL -'1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL -'+1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL -'-1' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
}
/**
* Runs tests for INTERVAL... HOUR TO MINUTE that should pass both parser
* and validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalHourToMinutePositive() {
// default precision
f.expr("INTERVAL '2:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL '23:59' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL '99:0' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '2:3' HOUR(2) TO MINUTE")
.columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
f.expr("INTERVAL '23:59' HOUR(2) TO MINUTE")
.columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
f.expr("INTERVAL '99:0' HOUR(2) TO MINUTE")
.columnType("INTERVAL HOUR(2) TO MINUTE NOT NULL");
// max precision
f.expr("INTERVAL '2147483647:59' HOUR(10) TO MINUTE")
.columnType("INTERVAL HOUR(10) TO MINUTE NOT NULL");
// min precision
f.expr("INTERVAL '0:0' HOUR(1) TO MINUTE")
.columnType("INTERVAL HOUR(1) TO MINUTE NOT NULL");
// alternate precision
f.expr("INTERVAL '2345:7' HOUR(4) TO MINUTE")
.columnType("INTERVAL HOUR(4) TO MINUTE NOT NULL");
// sign
f.expr("INTERVAL '-1:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL '+1:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL +'2:3' HOUR TO MINUTE")
.assertParse("INTERVAL '2:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL +'-2:3' HOUR TO MINUTE")
.assertParse("INTERVAL '-2:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL +'+2:3' HOUR TO MINUTE")
.assertParse("INTERVAL '+2:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL -'2:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL -'-2:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.expr("INTERVAL -'+2:3' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
}
/**
* Runs tests for INTERVAL... HOUR TO SECOND that should pass both parser
* and validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalHourToSecondPositive() {
// default precision
f.expr("INTERVAL '2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL '23:59:59' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL '99:0:0' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL '23:59:59.999999' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL '99:0:0.0' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '2:3:4' HOUR(2) TO SECOND")
.columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99:59:59' HOUR(2) TO SECOND")
.columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99:0:0' HOUR(2) TO SECOND")
.columnType("INTERVAL HOUR(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99:59:59.999999' HOUR TO SECOND(6)")
.columnType("INTERVAL HOUR TO SECOND(6) NOT NULL");
f.expr("INTERVAL '99:0:0.0' HOUR TO SECOND(6)")
.columnType("INTERVAL HOUR TO SECOND(6) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647:59:59' HOUR(10) TO SECOND")
.columnType("INTERVAL HOUR(10) TO SECOND NOT NULL");
f.expr("INTERVAL '2147483647:59:59.999999999' HOUR(10) TO SECOND(9)")
.columnType("INTERVAL HOUR(10) TO SECOND(9) NOT NULL");
// min precision
f.expr("INTERVAL '0:0:0' HOUR(1) TO SECOND")
.columnType("INTERVAL HOUR(1) TO SECOND NOT NULL");
f.expr("INTERVAL '0:0:0.0' HOUR(1) TO SECOND(1)")
.columnType("INTERVAL HOUR(1) TO SECOND(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '2345:7:8' HOUR(4) TO SECOND")
.columnType("INTERVAL HOUR(4) TO SECOND NOT NULL");
f.expr("INTERVAL '2345:7:8.9012' HOUR(4) TO SECOND(4)")
.columnType("INTERVAL HOUR(4) TO SECOND(4) NOT NULL");
// sign
f.expr("INTERVAL '-2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL '+2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL +'2:3:4' HOUR TO SECOND")
.assertParse("INTERVAL '2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL +'-2:3:4' HOUR TO SECOND")
.assertParse("INTERVAL '-2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL +'+2:3:4' HOUR TO SECOND")
.assertParse("INTERVAL '+2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL -'2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL -'-2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.expr("INTERVAL -'+2:3:4' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
}
/**
* Runs tests for INTERVAL... MINUTE that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalMinutePositive() {
// default precision
f.expr("INTERVAL '1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.expr("INTERVAL '99' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1' MINUTE(2)")
.columnType("INTERVAL MINUTE(2) NOT NULL");
f.expr("INTERVAL '99' MINUTE(2)")
.columnType("INTERVAL MINUTE(2) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647' MINUTE(10)")
.columnType("INTERVAL MINUTE(10) NOT NULL");
// min precision
f.expr("INTERVAL '0' MINUTE(1)")
.columnType("INTERVAL MINUTE(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '1234' MINUTE(4)")
.columnType("INTERVAL MINUTE(4) NOT NULL");
// sign
f.expr("INTERVAL '+1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.expr("INTERVAL '-1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.expr("INTERVAL +'1' MINUTE")
.assertParse("INTERVAL '1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.expr("INTERVAL +'+1' MINUTE")
.assertParse("INTERVAL '+1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.expr("INTERVAL +'-1' MINUTE")
.assertParse("INTERVAL '-1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.expr("INTERVAL -'1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.expr("INTERVAL -'+1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.expr("INTERVAL -'-1' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
}
/**
* Runs tests for INTERVAL... MINUTE TO SECOND that should pass both parser
* and validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalMinuteToSecondPositive() {
// default precision
f.expr("INTERVAL '2:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL '59:59' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL '99:0' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL '59:59.999999' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL '99:0.0' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '2:4' MINUTE(2) TO SECOND")
.columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99:59' MINUTE(2) TO SECOND")
.columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99:0' MINUTE(2) TO SECOND")
.columnType("INTERVAL MINUTE(2) TO SECOND NOT NULL");
f.expr("INTERVAL '99:59.999999' MINUTE TO SECOND(6)")
.columnType("INTERVAL MINUTE TO SECOND(6) NOT NULL");
f.expr("INTERVAL '99:0.0' MINUTE TO SECOND(6)")
.columnType("INTERVAL MINUTE TO SECOND(6) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647:59' MINUTE(10) TO SECOND")
.columnType("INTERVAL MINUTE(10) TO SECOND NOT NULL");
f.expr("INTERVAL '2147483647:59.999999999' MINUTE(10) TO SECOND(9)")
.columnType("INTERVAL MINUTE(10) TO SECOND(9) NOT NULL");
// min precision
f.expr("INTERVAL '0:0' MINUTE(1) TO SECOND")
.columnType("INTERVAL MINUTE(1) TO SECOND NOT NULL");
f.expr("INTERVAL '0:0.0' MINUTE(1) TO SECOND(1)")
.columnType("INTERVAL MINUTE(1) TO SECOND(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '2345:8' MINUTE(4) TO SECOND")
.columnType("INTERVAL MINUTE(4) TO SECOND NOT NULL");
f.expr("INTERVAL '2345:7.8901' MINUTE(4) TO SECOND(4)")
.columnType("INTERVAL MINUTE(4) TO SECOND(4) NOT NULL");
// sign
f.expr("INTERVAL '-3:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL '+3:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL +'3:4' MINUTE TO SECOND")
.assertParse("INTERVAL '3:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL +'-3:4' MINUTE TO SECOND")
.assertParse("INTERVAL '-3:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL +'+3:4' MINUTE TO SECOND")
.assertParse("INTERVAL '+3:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL -'3:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL -'-3:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.expr("INTERVAL -'+3:4' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
}
/**
* Runs tests for INTERVAL... SECOND that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalSecondPositive() {
// default precision
f.expr("INTERVAL '1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL '99' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1' SECOND(2)")
.columnType("INTERVAL SECOND(2) NOT NULL");
f.expr("INTERVAL '99' SECOND(2)")
.columnType("INTERVAL SECOND(2) NOT NULL");
f.expr("INTERVAL '1' SECOND(2, 6)")
.columnType("INTERVAL SECOND(2, 6) NOT NULL");
f.expr("INTERVAL '99' SECOND(2, 6)")
.columnType("INTERVAL SECOND(2, 6) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647' SECOND(10)")
.columnType("INTERVAL SECOND(10) NOT NULL");
f.expr("INTERVAL '2147483647.999999999' SECOND(10, 9)")
.columnType("INTERVAL SECOND(10, 9) NOT NULL");
// min precision
f.expr("INTERVAL '0' SECOND(1)")
.columnType("INTERVAL SECOND(1) NOT NULL");
f.expr("INTERVAL '0.0' SECOND(1, 1)")
.columnType("INTERVAL SECOND(1, 1) NOT NULL");
// alternate precision
f.expr("INTERVAL '1234' SECOND(4)")
.columnType("INTERVAL SECOND(4) NOT NULL");
f.expr("INTERVAL '1234.56789' SECOND(4, 5)")
.columnType("INTERVAL SECOND(4, 5) NOT NULL");
// sign
f.expr("INTERVAL '+1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL '-1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL +'1' SECOND")
.assertParse("INTERVAL '1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL +'+1' SECOND")
.assertParse("INTERVAL '+1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL +'-1' SECOND")
.assertParse("INTERVAL '-1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL -'1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL -'+1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL -'-1' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
}
/**
* Runs tests for INTERVAL... YEAR that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalYearNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL '-' YEAR")
.fails("Illegal interval literal format '-' for INTERVAL YEAR.*");
f.wholeExpr("INTERVAL '1-2' YEAR")
.fails("Illegal interval literal format '1-2' for INTERVAL YEAR.*");
f.wholeExpr("INTERVAL '1.2' YEAR")
.fails("Illegal interval literal format '1.2' for INTERVAL YEAR.*");
f.wholeExpr("INTERVAL '1 2' YEAR")
.fails("Illegal interval literal format '1 2' for INTERVAL YEAR.*");
f.wholeExpr("INTERVAL '1-2' YEAR(2)")
.fails("Illegal interval literal format '1-2' for INTERVAL YEAR\\(2\\)");
f.wholeExpr("INTERVAL 'bogus text' YEAR")
.fails("Illegal interval literal format 'bogus text' for INTERVAL YEAR.*");
// negative field values
f.wholeExpr("INTERVAL '--1' YEAR")
.fails("Illegal interval literal format '--1' for INTERVAL YEAR.*");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
f.wholeExpr("INTERVAL '100' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
f.wholeExpr("INTERVAL '100' YEAR(2)")
.fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000' YEAR(3)")
.fails("Interval field value 1,000 exceeds precision of YEAR\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000' YEAR(3)")
.fails("Interval field value -1,000 exceeds precision of YEAR\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648' YEAR(10)")
.fails("Interval field value 2,147,483,648 exceeds precision of "
+ "YEAR\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648' YEAR(10)")
.fails("Interval field value -2,147,483,648 exceeds precision of "
+ "YEAR\\(10\\) field");
// precision > maximum
f.expr("INTERVAL '1' ^YEAR(11)^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL YEAR\\(11\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0' ^YEAR(0)^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL YEAR\\(0\\)");
}
/**
* Runs tests for INTERVAL... YEAR TO MONTH that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalYearToMonthNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL '-' YEAR TO MONTH")
.fails("Illegal interval literal format '-' for INTERVAL YEAR TO MONTH");
f.wholeExpr("INTERVAL '1' YEAR TO MONTH")
.fails("Illegal interval literal format '1' for INTERVAL YEAR TO MONTH");
f.wholeExpr("INTERVAL '1:2' YEAR TO MONTH")
.fails("Illegal interval literal format '1:2' for INTERVAL YEAR TO MONTH");
f.wholeExpr("INTERVAL '1.2' YEAR TO MONTH")
.fails("Illegal interval literal format '1.2' for INTERVAL YEAR TO MONTH");
f.wholeExpr("INTERVAL '1 2' YEAR TO MONTH")
.fails("Illegal interval literal format '1 2' for INTERVAL YEAR TO MONTH");
f.wholeExpr("INTERVAL '1:2' YEAR(2) TO MONTH")
.fails("Illegal interval literal format '1:2' for "
+ "INTERVAL YEAR\\(2\\) TO MONTH");
f.wholeExpr("INTERVAL 'bogus text' YEAR TO MONTH")
.fails("Illegal interval literal format 'bogus text' for "
+ "INTERVAL YEAR TO MONTH");
// negative field values
f.wholeExpr("INTERVAL '--1-2' YEAR TO MONTH")
.fails("Illegal interval literal format '--1-2' for "
+ "INTERVAL YEAR TO MONTH");
f.wholeExpr("INTERVAL '1--2' YEAR TO MONTH")
.fails("Illegal interval literal format '1--2' for "
+ "INTERVAL YEAR TO MONTH");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
// plus >max value for mid/end fields
f.wholeExpr("INTERVAL '100-0' YEAR TO MONTH")
.columnType("INTERVAL YEAR TO MONTH NOT NULL");
f.wholeExpr("INTERVAL '100-0' YEAR(2) TO MONTH")
.fails("Interval field value 100 exceeds precision of YEAR\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000-0' YEAR(3) TO MONTH")
.fails("Interval field value 1,000 exceeds precision of YEAR\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000-0' YEAR(3) TO MONTH")
.fails("Interval field value -1,000 exceeds precision of YEAR\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648-0' YEAR(10) TO MONTH")
.fails("Interval field value 2,147,483,648 exceeds precision of YEAR\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648-0' YEAR(10) TO MONTH")
.fails("Interval field value -2,147,483,648 exceeds precision of YEAR\\(10\\) field.*");
f.wholeExpr("INTERVAL '1-12' YEAR TO MONTH")
.fails("Illegal interval literal format '1-12' for INTERVAL YEAR TO MONTH.*");
// precision > maximum
f.expr("INTERVAL '1-1' ^YEAR(11) TO MONTH^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL YEAR\\(11\\) TO MONTH");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0-0' ^YEAR(0) TO MONTH^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL YEAR\\(0\\) TO MONTH");
}
/**
* Runs tests for INTERVAL... WEEK that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlValidatorTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalWeekPositive() {
// default precision
f.expr("INTERVAL '1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL '99' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1' WEEK(2)")
.columnType("INTERVAL WEEK(2) NOT NULL");
f.expr("INTERVAL '99' WEEK(2)")
.columnType("INTERVAL WEEK(2) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647' WEEK(10)")
.columnType("INTERVAL WEEK(10) NOT NULL");
// min precision
f.expr("INTERVAL '0' WEEK(1)")
.columnType("INTERVAL WEEK(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '1234' WEEK(4)")
.columnType("INTERVAL WEEK(4) NOT NULL");
// sign
f.expr("INTERVAL '+1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL '-1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL +'1' WEEK")
.assertParse("INTERVAL '1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL +'+1' WEEK")
.assertParse("INTERVAL '+1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL +'-1' WEEK")
.assertParse("INTERVAL '-1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL -'1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL -'+1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL -'-1' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
}
/**
* Runs tests for INTERVAL... QUARTER that should pass both parser and
* validator. A substantially identical set of tests exists in
* SqlValidatorTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXPositive() tests.
*/
public void subTestIntervalQuarterPositive() {
// default precision
f.expr("INTERVAL '1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL '99' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
// explicit precision equal to default
f.expr("INTERVAL '1' QUARTER(2)")
.columnType("INTERVAL QUARTER(2) NOT NULL");
f.expr("INTERVAL '99' QUARTER(2)")
.columnType("INTERVAL QUARTER(2) NOT NULL");
// max precision
f.expr("INTERVAL '2147483647' QUARTER(10)")
.columnType("INTERVAL QUARTER(10) NOT NULL");
// min precision
f.expr("INTERVAL '0' QUARTER(1)")
.columnType("INTERVAL QUARTER(1) NOT NULL");
// alternate precision
f.expr("INTERVAL '1234' QUARTER(4)")
.columnType("INTERVAL QUARTER(4) NOT NULL");
// sign
f.expr("INTERVAL '+1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL '-1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL +'1' QUARTER")
.assertParse("INTERVAL '1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL +'+1' QUARTER")
.assertParse("INTERVAL '+1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL +'-1' QUARTER")
.assertParse("INTERVAL '-1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL -'1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL -'+1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL -'-1' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
}
public void subTestIntervalPlural() {
f.expr("INTERVAL '+2' SECONDS")
.assertParse("INTERVAL '+2' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.expr("INTERVAL '+2' HOURS")
.assertParse("INTERVAL '+2' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.expr("INTERVAL '+2' DAYS")
.assertParse("INTERVAL '+2' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.expr("INTERVAL '+2' WEEKS")
.assertParse("INTERVAL '+2' WEEK")
.columnType("INTERVAL WEEK NOT NULL");
f.expr("INTERVAL '+2' QUARTERS")
.assertParse("INTERVAL '+2' QUARTER")
.columnType("INTERVAL QUARTER NOT NULL");
f.expr("INTERVAL '+2' MONTHS")
.assertParse("INTERVAL '+2' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.expr("INTERVAL '+2' YEARS")
.assertParse("INTERVAL '+2' YEAR")
.columnType("INTERVAL YEAR NOT NULL");
}
/**
* Runs tests for INTERVAL... MONTH that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalMonthNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL '-' MONTH")
.fails("Illegal interval literal format '-' for INTERVAL MONTH.*");
f.wholeExpr("INTERVAL '1-2' MONTH")
.fails("Illegal interval literal format '1-2' for INTERVAL MONTH.*");
f.wholeExpr("INTERVAL '1.2' MONTH")
.fails("Illegal interval literal format '1.2' for INTERVAL MONTH.*");
f.wholeExpr("INTERVAL '1 2' MONTH")
.fails("Illegal interval literal format '1 2' for INTERVAL MONTH.*");
f.wholeExpr("INTERVAL '1-2' MONTH(2)")
.fails("Illegal interval literal format '1-2' for INTERVAL MONTH\\(2\\)");
f.wholeExpr("INTERVAL 'bogus text' MONTH")
.fails("Illegal interval literal format 'bogus text' for INTERVAL MONTH.*");
// negative field values
f.wholeExpr("INTERVAL '--1' MONTH")
.fails("Illegal interval literal format '--1' for INTERVAL MONTH.*");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
f.wholeExpr("INTERVAL '100' MONTH")
.columnType("INTERVAL MONTH NOT NULL");
f.wholeExpr("INTERVAL '100' MONTH(2)")
.fails("Interval field value 100 exceeds precision of MONTH\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000' MONTH(3)")
.fails("Interval field value 1,000 exceeds precision of MONTH\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000' MONTH(3)")
.fails("Interval field value -1,000 exceeds precision of MONTH\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648' MONTH(10)")
.fails("Interval field value 2,147,483,648 exceeds precision of MONTH\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648' MONTH(10)")
.fails("Interval field value -2,147,483,648 exceeds precision of MONTH\\(10\\) field.*");
// precision > maximum
f.expr("INTERVAL '1' ^MONTH(11)^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL MONTH\\(11\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0' ^MONTH(0)^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL MONTH\\(0\\)");
}
/**
* Runs tests for INTERVAL... DAY that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalDayNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL '-' DAY")
.fails("Illegal interval literal format '-' for INTERVAL DAY.*");
f.wholeExpr("INTERVAL '1-2' DAY")
.fails("Illegal interval literal format '1-2' for INTERVAL DAY.*");
f.wholeExpr("INTERVAL '1.2' DAY")
.fails("Illegal interval literal format '1.2' for INTERVAL DAY.*");
f.wholeExpr("INTERVAL '1 2' DAY")
.fails("Illegal interval literal format '1 2' for INTERVAL DAY.*");
f.wholeExpr("INTERVAL '1:2' DAY")
.fails("Illegal interval literal format '1:2' for INTERVAL DAY.*");
f.wholeExpr("INTERVAL '1-2' DAY(2)")
.fails("Illegal interval literal format '1-2' for INTERVAL DAY\\(2\\)");
f.wholeExpr("INTERVAL 'bogus text' DAY")
.fails("Illegal interval literal format 'bogus text' for INTERVAL DAY.*");
// negative field values
f.wholeExpr("INTERVAL '--1' DAY")
.fails("Illegal interval literal format '--1' for INTERVAL DAY.*");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
f.wholeExpr("INTERVAL '100' DAY")
.columnType("INTERVAL DAY NOT NULL");
f.wholeExpr("INTERVAL '100' DAY(2)")
.fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000' DAY(3)")
.fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000' DAY(3)")
.fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648' DAY(10)")
.fails("Interval field value 2,147,483,648 exceeds precision of "
+ "DAY\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648' DAY(10)")
.fails("Interval field value -2,147,483,648 exceeds precision of "
+ "DAY\\(10\\) field.*");
// precision > maximum
f.expr("INTERVAL '1' ^DAY(11)^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL DAY\\(11\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0' ^DAY(0)^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL DAY\\(0\\)");
}
/**
* Runs tests for INTERVAL... DAY TO HOUR that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalDayToHourNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL '-' DAY TO HOUR")
.fails("Illegal interval literal format '-' for INTERVAL DAY TO HOUR");
f.wholeExpr("INTERVAL '1' DAY TO HOUR")
.fails("Illegal interval literal format '1' for INTERVAL DAY TO HOUR");
f.wholeExpr("INTERVAL '1:2' DAY TO HOUR")
.fails("Illegal interval literal format '1:2' for INTERVAL DAY TO HOUR");
f.wholeExpr("INTERVAL '1.2' DAY TO HOUR")
.fails("Illegal interval literal format '1.2' for INTERVAL DAY TO HOUR");
f.wholeExpr("INTERVAL '1 x' DAY TO HOUR")
.fails("Illegal interval literal format '1 x' for INTERVAL DAY TO HOUR");
f.wholeExpr("INTERVAL ' ' DAY TO HOUR")
.fails("Illegal interval literal format ' ' for INTERVAL DAY TO HOUR");
f.wholeExpr("INTERVAL '1:2' DAY(2) TO HOUR")
.fails("Illegal interval literal format '1:2' for "
+ "INTERVAL DAY\\(2\\) TO HOUR");
f.wholeExpr("INTERVAL 'bogus text' DAY TO HOUR")
.fails("Illegal interval literal format 'bogus text' for "
+ "INTERVAL DAY TO HOUR");
// negative field values
f.wholeExpr("INTERVAL '--1 1' DAY TO HOUR")
.fails("Illegal interval literal format '--1 1' for INTERVAL DAY TO HOUR");
f.wholeExpr("INTERVAL '1 -1' DAY TO HOUR")
.fails("Illegal interval literal format '1 -1' for INTERVAL DAY TO HOUR");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
// plus >max value for mid/end fields
f.wholeExpr("INTERVAL '100 0' DAY TO HOUR")
.columnType("INTERVAL DAY TO HOUR NOT NULL");
f.wholeExpr("INTERVAL '100 0' DAY(2) TO HOUR")
.fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000 0' DAY(3) TO HOUR")
.fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000 0' DAY(3) TO HOUR")
.fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648 0' DAY(10) TO HOUR")
.fails("Interval field value 2,147,483,648 exceeds precision of DAY\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648 0' DAY(10) TO HOUR")
.fails("Interval field value -2,147,483,648 exceeds precision of "
+ "DAY\\(10\\) field.*");
f.wholeExpr("INTERVAL '1 24' DAY TO HOUR")
.fails("Illegal interval literal format '1 24' for INTERVAL DAY TO HOUR.*");
// precision > maximum
f.expr("INTERVAL '1 1' ^DAY(11) TO HOUR^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL DAY\\(11\\) TO HOUR");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0 0' ^DAY(0) TO HOUR^")
.fails("Interval leading field precision '0' out of range for INTERVAL DAY\\(0\\) TO HOUR");
}
/**
* Runs tests for INTERVAL... DAY TO MINUTE that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalDayToMinuteNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL ' :' DAY TO MINUTE")
.fails("Illegal interval literal format ' :' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1' DAY TO MINUTE")
.fails("Illegal interval literal format '1' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1 2' DAY TO MINUTE")
.fails("Illegal interval literal format '1 2' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1:2' DAY TO MINUTE")
.fails("Illegal interval literal format '1:2' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1.2' DAY TO MINUTE")
.fails("Illegal interval literal format '1.2' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL 'x 1:1' DAY TO MINUTE")
.fails("Illegal interval literal format 'x 1:1' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1 x:1' DAY TO MINUTE")
.fails("Illegal interval literal format '1 x:1' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1 1:x' DAY TO MINUTE")
.fails("Illegal interval literal format '1 1:x' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1 1:2:3' DAY TO MINUTE")
.fails("Illegal interval literal format '1 1:2:3' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1 1:1:1.2' DAY TO MINUTE")
.fails("Illegal interval literal format '1 1:1:1.2' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1 1:2:3' DAY(2) TO MINUTE")
.fails("Illegal interval literal format '1 1:2:3' for "
+ "INTERVAL DAY\\(2\\) TO MINUTE");
f.wholeExpr("INTERVAL '1 1' DAY(2) TO MINUTE")
.fails("Illegal interval literal format '1 1' for "
+ "INTERVAL DAY\\(2\\) TO MINUTE");
f.wholeExpr("INTERVAL 'bogus text' DAY TO MINUTE")
.fails("Illegal interval literal format 'bogus text' for "
+ "INTERVAL DAY TO MINUTE");
// negative field values
f.wholeExpr("INTERVAL '--1 1:1' DAY TO MINUTE")
.fails("Illegal interval literal format '--1 1:1' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1 -1:1' DAY TO MINUTE")
.fails("Illegal interval literal format '1 -1:1' for INTERVAL DAY TO MINUTE");
f.wholeExpr("INTERVAL '1 1:-1' DAY TO MINUTE")
.fails("Illegal interval literal format '1 1:-1' for INTERVAL DAY TO MINUTE");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
// plus >max value for mid/end fields
f.wholeExpr("INTERVAL '100 0:0' DAY TO MINUTE")
.columnType("INTERVAL DAY TO MINUTE NOT NULL");
f.wholeExpr("INTERVAL '100 0:0' DAY(2) TO MINUTE")
.fails("Interval field value 100 exceeds precision of DAY\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000 0:0' DAY(3) TO MINUTE")
.fails("Interval field value 1,000 exceeds precision of DAY\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000 0:0' DAY(3) TO MINUTE")
.fails("Interval field value -1,000 exceeds precision of DAY\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648 0:0' DAY(10) TO MINUTE")
.fails("Interval field value 2,147,483,648 exceeds precision of "
+ "DAY\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648 0:0' DAY(10) TO MINUTE")
.fails("Interval field value -2,147,483,648 exceeds precision of "
+ "DAY\\(10\\) field.*");
f.wholeExpr("INTERVAL '1 24:1' DAY TO MINUTE")
.fails("Illegal interval literal format '1 24:1' for "
+ "INTERVAL DAY TO MINUTE.*");
f.wholeExpr("INTERVAL '1 1:60' DAY TO MINUTE")
.fails("Illegal interval literal format '1 1:60' for INTERVAL DAY TO MINUTE.*");
// precision > maximum
f.expr("INTERVAL '1 1:1' ^DAY(11) TO MINUTE^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL DAY\\(11\\) TO MINUTE");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0 0' ^DAY(0) TO MINUTE^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL DAY\\(0\\) TO MINUTE");
}
/**
* Runs tests for INTERVAL... DAY TO SECOND that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalDayToSecondNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL ' ::' DAY TO SECOND")
.fails("Illegal interval literal format ' ::' for INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL ' ::.' DAY TO SECOND")
.fails("Illegal interval literal format ' ::\\.' for INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1' DAY TO SECOND")
.fails("Illegal interval literal format '1' for INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1 2' DAY TO SECOND")
.fails("Illegal interval literal format '1 2' for INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1:2' DAY TO SECOND")
.fails("Illegal interval literal format '1:2' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1.2' DAY TO SECOND")
.fails("Illegal interval literal format '1\\.2' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1 1:2' DAY TO SECOND")
.fails("Illegal interval literal format '1 1:2' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1 1:2:x' DAY TO SECOND")
.fails("Illegal interval literal format '1 1:2:x' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1:2:3' DAY TO SECOND")
.fails("Illegal interval literal format '1:2:3' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1:1:1.2' DAY TO SECOND")
.fails("Illegal interval literal format '1:1:1\\.2' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1 1:2' DAY(2) TO SECOND")
.fails("Illegal interval literal format '1 1:2' for "
+ "INTERVAL DAY\\(2\\) TO SECOND");
f.wholeExpr("INTERVAL '1 1' DAY(2) TO SECOND")
.fails("Illegal interval literal format '1 1' for "
+ "INTERVAL DAY\\(2\\) TO SECOND");
f.wholeExpr("INTERVAL 'bogus text' DAY TO SECOND")
.fails("Illegal interval literal format 'bogus text' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '2345 6:7:8901' DAY TO SECOND(4)")
.fails("Illegal interval literal format '2345 6:7:8901' for "
+ "INTERVAL DAY TO SECOND\\(4\\)");
// negative field values
f.wholeExpr("INTERVAL '--1 1:1:1' DAY TO SECOND")
.fails("Illegal interval literal format '--1 1:1:1' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1 -1:1:1' DAY TO SECOND")
.fails("Illegal interval literal format '1 -1:1:1' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1 1:-1:1' DAY TO SECOND")
.fails("Illegal interval literal format '1 1:-1:1' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1 1:1:-1' DAY TO SECOND")
.fails("Illegal interval literal format '1 1:1:-1' for "
+ "INTERVAL DAY TO SECOND");
f.wholeExpr("INTERVAL '1 1:1:1.-1' DAY TO SECOND")
.fails("Illegal interval literal format '1 1:1:1.-1' for "
+ "INTERVAL DAY TO SECOND");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
// plus >max value for mid/end fields
f.wholeExpr("INTERVAL '100 0' DAY TO SECOND")
.fails("Illegal interval literal format '100 0' for "
+ "INTERVAL DAY TO SECOND.*");
f.wholeExpr("INTERVAL '100 0' DAY(2) TO SECOND")
.fails("Illegal interval literal format '100 0' for "
+ "INTERVAL DAY\\(2\\) TO SECOND.*");
f.wholeExpr("INTERVAL '1000 0' DAY(3) TO SECOND")
.fails("Illegal interval literal format '1000 0' for "
+ "INTERVAL DAY\\(3\\) TO SECOND.*");
f.wholeExpr("INTERVAL '-1000 0' DAY(3) TO SECOND")
.fails("Illegal interval literal format '-1000 0' for "
+ "INTERVAL DAY\\(3\\) TO SECOND.*");
f.wholeExpr("INTERVAL '2147483648 1:1:0' DAY(10) TO SECOND")
.fails("Interval field value 2,147,483,648 exceeds precision of "
+ "DAY\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648 1:1:0' DAY(10) TO SECOND")
.fails("Interval field value -2,147,483,648 exceeds precision of "
+ "DAY\\(10\\) field.*");
f.wholeExpr("INTERVAL '2147483648 0' DAY(10) TO SECOND")
.fails("Illegal interval literal format '2147483648 0' for "
+ "INTERVAL DAY\\(10\\) TO SECOND.*");
f.wholeExpr("INTERVAL '-2147483648 0' DAY(10) TO SECOND")
.fails("Illegal interval literal format '-2147483648 0' for "
+ "INTERVAL DAY\\(10\\) TO SECOND.*");
f.wholeExpr("INTERVAL '1 24:1:1' DAY TO SECOND")
.fails("Illegal interval literal format '1 24:1:1' for "
+ "INTERVAL DAY TO SECOND.*");
f.wholeExpr("INTERVAL '1 1:60:1' DAY TO SECOND")
.fails("Illegal interval literal format '1 1:60:1' for "
+ "INTERVAL DAY TO SECOND.*");
f.wholeExpr("INTERVAL '1 1:1:60' DAY TO SECOND")
.fails("Illegal interval literal format '1 1:1:60' for "
+ "INTERVAL DAY TO SECOND.*");
f.wholeExpr("INTERVAL '1 1:1:1.0000001' DAY TO SECOND")
.fails("Illegal interval literal format '1 1:1:1\\.0000001' for "
+ "INTERVAL DAY TO SECOND.*");
f.wholeExpr("INTERVAL '1 1:1:1.0001' DAY TO SECOND(3)")
.fails("Illegal interval literal format '1 1:1:1\\.0001' for "
+ "INTERVAL DAY TO SECOND\\(3\\).*");
// precision > maximum
f.expr("INTERVAL '1 1' ^DAY(11) TO SECOND^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL DAY\\(11\\) TO SECOND");
f.expr("INTERVAL '1 1' ^DAY TO SECOND(10)^")
.fails("Interval fractional second precision '10' out of range for "
+ "INTERVAL DAY TO SECOND\\(10\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0 0:0:0' ^DAY(0) TO SECOND^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL DAY\\(0\\) TO SECOND");
}
/**
* Runs tests for INTERVAL... HOUR that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalHourNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL '-' HOUR")
.fails("Illegal interval literal format '-' for INTERVAL HOUR.*");
f.wholeExpr("INTERVAL '1-2' HOUR")
.fails("Illegal interval literal format '1-2' for INTERVAL HOUR.*");
f.wholeExpr("INTERVAL '1.2' HOUR")
.fails("Illegal interval literal format '1.2' for INTERVAL HOUR.*");
f.wholeExpr("INTERVAL '1 2' HOUR")
.fails("Illegal interval literal format '1 2' for INTERVAL HOUR.*");
f.wholeExpr("INTERVAL '1:2' HOUR")
.fails("Illegal interval literal format '1:2' for INTERVAL HOUR.*");
f.wholeExpr("INTERVAL '1-2' HOUR(2)")
.fails("Illegal interval literal format '1-2' for INTERVAL HOUR\\(2\\)");
f.wholeExpr("INTERVAL 'bogus text' HOUR")
.fails("Illegal interval literal format 'bogus text' for "
+ "INTERVAL HOUR.*");
// negative field values
f.wholeExpr("INTERVAL '--1' HOUR")
.fails("Illegal interval literal format '--1' for INTERVAL HOUR.*");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
f.wholeExpr("INTERVAL '100' HOUR")
.columnType("INTERVAL HOUR NOT NULL");
f.wholeExpr("INTERVAL '100' HOUR(2)")
.fails("Interval field value 100 exceeds precision of "
+ "HOUR\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000' HOUR(3)")
.fails("Interval field value 1,000 exceeds precision of "
+ "HOUR\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000' HOUR(3)")
.fails("Interval field value -1,000 exceeds precision of "
+ "HOUR\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648' HOUR(10)")
.fails("Interval field value 2,147,483,648 exceeds precision of "
+ "HOUR\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648' HOUR(10)")
.fails("Interval field value -2,147,483,648 exceeds precision of "
+ "HOUR\\(10\\) field.*");
// precision > maximum
f.expr("INTERVAL '1' ^HOUR(11)^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL HOUR\\(11\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0' ^HOUR(0)^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL HOUR\\(0\\)");
}
/**
* Runs tests for INTERVAL... HOUR TO MINUTE that should pass parser but
* fail validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalHourToMinuteNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL ':' HOUR TO MINUTE")
.fails("Illegal interval literal format ':' for INTERVAL HOUR TO MINUTE");
f.wholeExpr("INTERVAL '1' HOUR TO MINUTE")
.fails("Illegal interval literal format '1' for INTERVAL HOUR TO MINUTE");
f.wholeExpr("INTERVAL '1:x' HOUR TO MINUTE")
.fails("Illegal interval literal format '1:x' for INTERVAL HOUR TO MINUTE");
f.wholeExpr("INTERVAL '1.2' HOUR TO MINUTE")
.fails("Illegal interval literal format '1.2' for INTERVAL HOUR TO MINUTE");
f.wholeExpr("INTERVAL '1 2' HOUR TO MINUTE")
.fails("Illegal interval literal format '1 2' for INTERVAL HOUR TO MINUTE");
f.wholeExpr("INTERVAL '1:2:3' HOUR TO MINUTE")
.fails("Illegal interval literal format '1:2:3' for INTERVAL HOUR TO MINUTE");
f.wholeExpr("INTERVAL '1 2' HOUR(2) TO MINUTE")
.fails("Illegal interval literal format '1 2' for "
+ "INTERVAL HOUR\\(2\\) TO MINUTE");
f.wholeExpr("INTERVAL 'bogus text' HOUR TO MINUTE")
.fails("Illegal interval literal format 'bogus text' for "
+ "INTERVAL HOUR TO MINUTE");
// negative field values
f.wholeExpr("INTERVAL '--1:1' HOUR TO MINUTE")
.fails("Illegal interval literal format '--1:1' for INTERVAL HOUR TO MINUTE");
f.wholeExpr("INTERVAL '1:-1' HOUR TO MINUTE")
.fails("Illegal interval literal format '1:-1' for INTERVAL HOUR TO MINUTE");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
// plus >max value for mid/end fields
f.wholeExpr("INTERVAL '100:0' HOUR TO MINUTE")
.columnType("INTERVAL HOUR TO MINUTE NOT NULL");
f.wholeExpr("INTERVAL '100:0' HOUR(2) TO MINUTE")
.fails("Interval field value 100 exceeds precision of HOUR\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000:0' HOUR(3) TO MINUTE")
.fails("Interval field value 1,000 exceeds precision of HOUR\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000:0' HOUR(3) TO MINUTE")
.fails("Interval field value -1,000 exceeds precision of HOUR\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648:0' HOUR(10) TO MINUTE")
.fails("Interval field value 2,147,483,648 exceeds precision of HOUR\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648:0' HOUR(10) TO MINUTE")
.fails("Interval field value -2,147,483,648 exceeds precision of HOUR\\(10\\) field.*");
f.wholeExpr("INTERVAL '1:60' HOUR TO MINUTE")
.fails("Illegal interval literal format '1:60' for INTERVAL HOUR TO MINUTE.*");
// precision > maximum
f.expr("INTERVAL '1:1' ^HOUR(11) TO MINUTE^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL HOUR\\(11\\) TO MINUTE");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0:0' ^HOUR(0) TO MINUTE^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL HOUR\\(0\\) TO MINUTE");
}
/**
* Runs tests for INTERVAL... HOUR TO SECOND that should pass parser but
* fail validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalHourToSecondNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL '::' HOUR TO SECOND")
.fails("Illegal interval literal format '::' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '::.' HOUR TO SECOND")
.fails("Illegal interval literal format '::\\.' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1' HOUR TO SECOND")
.fails("Illegal interval literal format '1' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1 2' HOUR TO SECOND")
.fails("Illegal interval literal format '1 2' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1:2' HOUR TO SECOND")
.fails("Illegal interval literal format '1:2' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1.2' HOUR TO SECOND")
.fails("Illegal interval literal format '1\\.2' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1 1:2' HOUR TO SECOND")
.fails("Illegal interval literal format '1 1:2' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1:2:x' HOUR TO SECOND")
.fails("Illegal interval literal format '1:2:x' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1:x:3' HOUR TO SECOND")
.fails("Illegal interval literal format '1:x:3' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1:1:1.x' HOUR TO SECOND")
.fails("Illegal interval literal format '1:1:1\\.x' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1 1:2' HOUR(2) TO SECOND")
.fails("Illegal interval literal format '1 1:2' for INTERVAL HOUR\\(2\\) TO SECOND");
f.wholeExpr("INTERVAL '1 1' HOUR(2) TO SECOND")
.fails("Illegal interval literal format '1 1' for INTERVAL HOUR\\(2\\) TO SECOND");
f.wholeExpr("INTERVAL 'bogus text' HOUR TO SECOND")
.fails("Illegal interval literal format 'bogus text' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '6:7:8901' HOUR TO SECOND(4)")
.fails("Illegal interval literal format '6:7:8901' for INTERVAL HOUR TO SECOND\\(4\\)");
// negative field values
f.wholeExpr("INTERVAL '--1:1:1' HOUR TO SECOND")
.fails("Illegal interval literal format '--1:1:1' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1:-1:1' HOUR TO SECOND")
.fails("Illegal interval literal format '1:-1:1' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1:1:-1' HOUR TO SECOND")
.fails("Illegal interval literal format '1:1:-1' for INTERVAL HOUR TO SECOND");
f.wholeExpr("INTERVAL '1:1:1.-1' HOUR TO SECOND")
.fails("Illegal interval literal format '1:1:1\\.-1' for INTERVAL HOUR TO SECOND");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
// plus >max value for mid/end fields
f.wholeExpr("INTERVAL '100:0:0' HOUR TO SECOND")
.columnType("INTERVAL HOUR TO SECOND NOT NULL");
f.wholeExpr("INTERVAL '100:0:0' HOUR(2) TO SECOND")
.fails("Interval field value 100 exceeds precision of "
+ "HOUR\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000:0:0' HOUR(3) TO SECOND")
.fails("Interval field value 1,000 exceeds precision of "
+ "HOUR\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000:0:0' HOUR(3) TO SECOND")
.fails("Interval field value -1,000 exceeds precision of "
+ "HOUR\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648:0:0' HOUR(10) TO SECOND")
.fails("Interval field value 2,147,483,648 exceeds precision of "
+ "HOUR\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648:0:0' HOUR(10) TO SECOND")
.fails("Interval field value -2,147,483,648 exceeds precision of "
+ "HOUR\\(10\\) field.*");
f.wholeExpr("INTERVAL '1:60:1' HOUR TO SECOND")
.fails("Illegal interval literal format '1:60:1' for "
+ "INTERVAL HOUR TO SECOND.*");
f.wholeExpr("INTERVAL '1:1:60' HOUR TO SECOND")
.fails("Illegal interval literal format '1:1:60' for "
+ "INTERVAL HOUR TO SECOND.*");
f.wholeExpr("INTERVAL '1:1:1.0000001' HOUR TO SECOND")
.fails("Illegal interval literal format '1:1:1\\.0000001' for "
+ "INTERVAL HOUR TO SECOND.*");
f.wholeExpr("INTERVAL '1:1:1.0001' HOUR TO SECOND(3)")
.fails("Illegal interval literal format '1:1:1\\.0001' for "
+ "INTERVAL HOUR TO SECOND\\(3\\).*");
// precision > maximum
f.expr("INTERVAL '1:1:1' ^HOUR(11) TO SECOND^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL HOUR\\(11\\) TO SECOND");
f.expr("INTERVAL '1:1:1' ^HOUR TO SECOND(10)^")
.fails("Interval fractional second precision '10' out of range for "
+ "INTERVAL HOUR TO SECOND\\(10\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0:0:0' ^HOUR(0) TO SECOND^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL HOUR\\(0\\) TO SECOND");
}
/**
* Runs tests for INTERVAL... MINUTE that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalMinuteNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL '-' MINUTE")
.fails("Illegal interval literal format '-' for INTERVAL MINUTE.*");
f.wholeExpr("INTERVAL '1-2' MINUTE")
.fails("Illegal interval literal format '1-2' for INTERVAL MINUTE.*");
f.wholeExpr("INTERVAL '1.2' MINUTE")
.fails("Illegal interval literal format '1.2' for INTERVAL MINUTE.*");
f.wholeExpr("INTERVAL '1 2' MINUTE")
.fails("Illegal interval literal format '1 2' for INTERVAL MINUTE.*");
f.wholeExpr("INTERVAL '1:2' MINUTE")
.fails("Illegal interval literal format '1:2' for INTERVAL MINUTE.*");
f.wholeExpr("INTERVAL '1-2' MINUTE(2)")
.fails("Illegal interval literal format '1-2' for INTERVAL MINUTE\\(2\\)");
f.wholeExpr("INTERVAL 'bogus text' MINUTE")
.fails("Illegal interval literal format 'bogus text' for INTERVAL MINUTE.*");
// negative field values
f.wholeExpr("INTERVAL '--1' MINUTE")
.fails("Illegal interval literal format '--1' for INTERVAL MINUTE.*");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
f.wholeExpr("INTERVAL '100' MINUTE")
.columnType("INTERVAL MINUTE NOT NULL");
f.wholeExpr("INTERVAL '100' MINUTE(2)")
.fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000' MINUTE(3)")
.fails("Interval field value 1,000 exceeds precision of MINUTE\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000' MINUTE(3)")
.fails("Interval field value -1,000 exceeds precision of MINUTE\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648' MINUTE(10)")
.fails("Interval field value 2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648' MINUTE(10)")
.fails("Interval field value -2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
// precision > maximum
f.expr("INTERVAL '1' ^MINUTE(11)^")
.fails("Interval leading field precision '11' out of range for "
+ "INTERVAL MINUTE\\(11\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0' ^MINUTE(0)^")
.fails("Interval leading field precision '0' out of range for "
+ "INTERVAL MINUTE\\(0\\)");
}
/**
* Runs tests for INTERVAL... MINUTE TO SECOND that should pass parser but
* fail validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalMinuteToSecondNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL ':' MINUTE TO SECOND")
.fails("Illegal interval literal format ':' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL ':.' MINUTE TO SECOND")
.fails("Illegal interval literal format ':\\.' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1' MINUTE TO SECOND")
.fails("Illegal interval literal format '1' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1 2' MINUTE TO SECOND")
.fails("Illegal interval literal format '1 2' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1.2' MINUTE TO SECOND")
.fails("Illegal interval literal format '1\\.2' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1 1:2' MINUTE TO SECOND")
.fails("Illegal interval literal format '1 1:2' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1:x' MINUTE TO SECOND")
.fails("Illegal interval literal format '1:x' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL 'x:3' MINUTE TO SECOND")
.fails("Illegal interval literal format 'x:3' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1:1.x' MINUTE TO SECOND")
.fails("Illegal interval literal format '1:1\\.x' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1 1:2' MINUTE(2) TO SECOND")
.fails("Illegal interval literal format '1 1:2' for INTERVAL MINUTE\\(2\\) TO SECOND");
f.wholeExpr("INTERVAL '1 1' MINUTE(2) TO SECOND")
.fails("Illegal interval literal format '1 1' for INTERVAL MINUTE\\(2\\) TO SECOND");
f.wholeExpr("INTERVAL 'bogus text' MINUTE TO SECOND")
.fails("Illegal interval literal format 'bogus text' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '7:8901' MINUTE TO SECOND(4)")
.fails("Illegal interval literal format '7:8901' for INTERVAL MINUTE TO SECOND\\(4\\)");
// negative field values
f.wholeExpr("INTERVAL '--1:1' MINUTE TO SECOND")
.fails("Illegal interval literal format '--1:1' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1:-1' MINUTE TO SECOND")
.fails("Illegal interval literal format '1:-1' for INTERVAL MINUTE TO SECOND");
f.wholeExpr("INTERVAL '1:1.-1' MINUTE TO SECOND")
.fails("Illegal interval literal format '1:1.-1' for INTERVAL MINUTE TO SECOND");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
// plus >max value for mid/end fields
f.wholeExpr("INTERVAL '100:0' MINUTE TO SECOND")
.columnType("INTERVAL MINUTE TO SECOND NOT NULL");
f.wholeExpr("INTERVAL '100:0' MINUTE(2) TO SECOND")
.fails("Interval field value 100 exceeds precision of MINUTE\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000:0' MINUTE(3) TO SECOND")
.fails("Interval field value 1,000 exceeds precision of MINUTE\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000:0' MINUTE(3) TO SECOND")
.fails("Interval field value -1,000 exceeds precision of MINUTE\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648:0' MINUTE(10) TO SECOND")
.fails("Interval field value 2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648:0' MINUTE(10) TO SECOND")
.fails("Interval field value -2,147,483,648 exceeds precision of MINUTE\\(10\\) field.*");
f.wholeExpr("INTERVAL '1:60' MINUTE TO SECOND")
.fails("Illegal interval literal format '1:60' for"
+ " INTERVAL MINUTE TO SECOND.*");
f.wholeExpr("INTERVAL '1:1.0000001' MINUTE TO SECOND")
.fails("Illegal interval literal format '1:1\\.0000001' for"
+ " INTERVAL MINUTE TO SECOND.*");
f.wholeExpr("INTERVAL '1:1:1.0001' MINUTE TO SECOND(3)")
.fails("Illegal interval literal format '1:1:1\\.0001' for"
+ " INTERVAL MINUTE TO SECOND\\(3\\).*");
// precision > maximum
f.expr("INTERVAL '1:1' ^MINUTE(11) TO SECOND^")
.fails("Interval leading field precision '11' out of range for"
+ " INTERVAL MINUTE\\(11\\) TO SECOND");
f.expr("INTERVAL '1:1' ^MINUTE TO SECOND(10)^")
.fails("Interval fractional second precision '10' out of range for"
+ " INTERVAL MINUTE TO SECOND\\(10\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0:0' ^MINUTE(0) TO SECOND^")
.fails("Interval leading field precision '0' out of range for"
+ " INTERVAL MINUTE\\(0\\) TO SECOND");
}
/**
* Runs tests for INTERVAL... SECOND that should pass parser but fail
* validator. A substantially identical set of tests exists in
* SqlParserTest, and any changes here should be synchronized there.
* Similarly, any changes to tests here should be echoed appropriately to
* each of the other 12 subTestIntervalXXXNegative() tests.
*/
public void subTestIntervalSecondNegative() {
// Qualifier - field mismatches
f.wholeExpr("INTERVAL ':' SECOND")
.fails("Illegal interval literal format ':' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL '.' SECOND")
.fails("Illegal interval literal format '\\.' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL '1-2' SECOND")
.fails("Illegal interval literal format '1-2' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL '1.x' SECOND")
.fails("Illegal interval literal format '1\\.x' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL 'x.1' SECOND")
.fails("Illegal interval literal format 'x\\.1' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL '1 2' SECOND")
.fails("Illegal interval literal format '1 2' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL '1:2' SECOND")
.fails("Illegal interval literal format '1:2' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL '1-2' SECOND(2)")
.fails("Illegal interval literal format '1-2' for INTERVAL SECOND\\(2\\)");
f.wholeExpr("INTERVAL 'bogus text' SECOND")
.fails("Illegal interval literal format 'bogus text' for INTERVAL SECOND.*");
// negative field values
f.wholeExpr("INTERVAL '--1' SECOND")
.fails("Illegal interval literal format '--1' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL '1.-1' SECOND")
.fails("Illegal interval literal format '1.-1' for INTERVAL SECOND.*");
// Field value out of range
// (default, explicit default, alt, neg alt, max, neg max)
f.wholeExpr("INTERVAL '100' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
f.wholeExpr("INTERVAL '100' SECOND(2)")
.fails("Interval field value 100 exceeds precision of SECOND\\(2\\) field.*");
f.wholeExpr("INTERVAL '1000' SECOND(3)")
.fails("Interval field value 1,000 exceeds precision of SECOND\\(3\\) field.*");
f.wholeExpr("INTERVAL '-1000' SECOND(3)")
.fails("Interval field value -1,000 exceeds precision of SECOND\\(3\\) field.*");
f.wholeExpr("INTERVAL '2147483648' SECOND(10)")
.fails("Interval field value 2,147,483,648 exceeds precision of SECOND\\(10\\) field.*");
f.wholeExpr("INTERVAL '-2147483648' SECOND(10)")
.fails("Interval field value -2,147,483,648 exceeds precision of SECOND\\(10\\) field.*");
f.wholeExpr("INTERVAL '1.0000001' SECOND")
.fails("Illegal interval literal format '1\\.0000001' for INTERVAL SECOND.*");
f.wholeExpr("INTERVAL '1.0000001' SECOND(2)")
.fails("Illegal interval literal format '1\\.0000001' for INTERVAL SECOND\\(2\\).*");
f.wholeExpr("INTERVAL '1.0001' SECOND(2, 3)")
.fails("Illegal interval literal format '1\\.0001' for INTERVAL SECOND\\(2, 3\\).*");
f.wholeExpr("INTERVAL '1.0000000001' SECOND(2, 9)")
.fails("Illegal interval literal format '1\\.0000000001' for"
+ " INTERVAL SECOND\\(2, 9\\).*");
// precision > maximum
f.expr("INTERVAL '1' ^SECOND(11)^")
.fails("Interval leading field precision '11' out of range for"
+ " INTERVAL SECOND\\(11\\)");
f.expr("INTERVAL '1.1' ^SECOND(1, 10)^")
.fails("Interval fractional second precision '10' out of range for"
+ " INTERVAL SECOND\\(1, 10\\)");
// precision < minimum allowed)
// note: parser will catch negative values, here we
// just need to check for 0
f.expr("INTERVAL '0' ^SECOND(0)^")
.fails("Interval leading field precision '0' out of range for"
+ " INTERVAL SECOND\\(0\\)");
}
public void subTestMisc() {
// Miscellaneous
// fractional value is not OK, even if it is 0
f.wholeExpr("INTERVAL '1.0' HOUR")
.fails("Illegal interval literal format '1.0' for INTERVAL HOUR");
// only seconds are allowed to have a fractional part
f.expr("INTERVAL '1.0' SECOND")
.columnType("INTERVAL SECOND NOT NULL");
// leading zeros do not cause precision to be exceeded
f.expr("INTERVAL '0999' MONTH(3)")
.columnType("INTERVAL MONTH(3) NOT NULL");
}
/** Fluent interface for binding an expression to create a fixture that can
* be used to validate, check AST, or check type. */
public interface Fixture {
Fixture2 expr(String s);
Fixture2 wholeExpr(String s);
}
/** Fluent interface to validate an expression. */
public interface Fixture2 {
/** Checks that the expression is valid in the parser
* but invalid (with the given error message) in the validator. */
void fails(String expected);
/** Checks that the expression is valid in the parser and validator
* and has the given column type. */
void columnType(String expectedType);
/** Checks that the expression parses successfully and produces the given
* SQL when unparsed. */
Fixture2 assertParse(String expectedAst);
}
}