database/doris
2
0
Fork 0
Code Issues Pull Requests Actions 3 Packages Projects Releases Wiki Activity

Support adding fixed range partition

Browse Source 
eg: ALTER TABLE test_table ADD PARTITION p0125 VALUES [("20190125"), ("20190126"));
This commit is contained in:
worker24h
2019-10-14 20:50:30 -05:00
committed by Mingyu Chen
parent 62acf5d098
commit ec7c8a2c6f
22 changed files with 612 additions and 160 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
fe/src/test/java/org/apache/doris/analysis/PartitionKeyDescTest.java
View File

@ -25,12 +25,12 @@ import org.junit.Test;
import java.util.List;
public class PartitionKeyDescTest {
private List<String> values;
private List<PartitionValue> values;
// value of key is ["1", "abc"]
@Before
public void setUp() {
values = Lists.newArrayList("1", "abc");
values = Lists.newArrayList(new PartitionValue("1"), new PartitionValue("abc"));
}
@Test
@ -45,7 +45,7 @@ public class PartitionKeyDescTest {
public void testMax() {
PartitionKeyDesc desc = PartitionKeyDesc.createMaxKeyDesc();
Assert.assertTrue(desc.getUpperValues().isEmpty());
Assert.assertNull(desc.getUpperValues());
Assert.assertEquals("MAXVALUE", desc.toSql());
}
}
}

3
fe/src/test/java/org/apache/doris/backup/AlterClauseRWTest.java
View File

@ -23,6 +23,7 @@ import org.apache.doris.analysis.AlterClause;
import org.apache.doris.analysis.AlterTableStmt;
import org.apache.doris.analysis.DistributionDesc;
import org.apache.doris.analysis.PartitionKeyDesc;
import org.apache.doris.analysis.PartitionValue;
import org.apache.doris.analysis.RandomDistributionDesc;
import org.apache.doris.analysis.SingleRangePartitionDesc;
import org.apache.doris.analysis.TableName;
@ -64,7 +65,7 @@ public class AlterClauseRWTest {
// add partition clause
String partititionName = "p1";
List<String> values = Lists.newArrayList("100");
List<PartitionValue> values = Lists.newArrayList(new PartitionValue("100"));
PartitionKeyDesc keyDesc = new PartitionKeyDesc(values);
Map<String, String> properties = Maps.newHashMap();
SingleRangePartitionDesc partitionDesc = new SingleRangePartitionDesc(false, partititionName, keyDesc,

7
fe/src/test/java/org/apache/doris/backup/CatalogMocker.java
View File

@ -19,6 +19,7 @@ package org.apache.doris.backup;
import org.apache.doris.alter.RollupHandler;
import org.apache.doris.alter.SchemaChangeHandler;
import org.apache.doris.analysis.PartitionValue;
import org.apache.doris.catalog.AggregateType;
import org.apache.doris.catalog.Catalog;
import org.apache.doris.catalog.Column;
@ -282,16 +283,16 @@ public class CatalogMocker {
PartitionKey rangeP1Lower =
PartitionKey.createInfinityPartitionKey(Lists.newArrayList(TEST_TBL_BASE_SCHEMA.get(0)), false);
PartitionKey rangeP1Upper =
PartitionKey.createPartitionKey(Lists.newArrayList("10"),
PartitionKey.createPartitionKey(Lists.newArrayList(new PartitionValue("10")),
Lists.newArrayList(TEST_TBL_BASE_SCHEMA.get(0)));
Range<PartitionKey> rangeP1 = Range.closedOpen(rangeP1Lower, rangeP1Upper);
rangePartitionInfo.setRange(TEST_PARTITION1_ID, rangeP1);
PartitionKey rangeP2Lower =
PartitionKey.createPartitionKey(Lists.newArrayList("10"),
PartitionKey.createPartitionKey(Lists.newArrayList(new PartitionValue("10")),
Lists.newArrayList(TEST_TBL_BASE_SCHEMA.get(0)));
PartitionKey rangeP2Upper =
PartitionKey.createPartitionKey(Lists.newArrayList("20"),
PartitionKey.createPartitionKey(Lists.newArrayList(new PartitionValue("20")),
Lists.newArrayList(TEST_TBL_BASE_SCHEMA.get(0)));
Range<PartitionKey> rangeP2 = Range.closedOpen(rangeP2Lower, rangeP2Upper);
rangePartitionInfo.setRange(TEST_PARTITION2_ID, rangeP2);

5
fe/src/test/java/org/apache/doris/catalog/CatalogTestUtil.java
View File

@ -18,6 +18,7 @@
package org.apache.doris.catalog;
import org.apache.doris.analysis.PartitionKeyDesc;
import org.apache.doris.analysis.PartitionValue;
import org.apache.doris.analysis.SingleRangePartitionDesc;
import org.apache.doris.catalog.MaterializedIndex.IndexExtState;
import org.apache.doris.catalog.MaterializedIndex.IndexState;
@ -248,7 +249,7 @@ public class CatalogTestUtil {
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1",
new PartitionKeyDesc(Lists
.newArrayList("100")),
.newArrayList(new PartitionValue("100"))),
null));
RangePartitionInfo partitionInfo = new RangePartitionInfo(partitionColumns);
@ -280,7 +281,7 @@ public class CatalogTestUtil {
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1",
new PartitionKeyDesc(Lists
.newArrayList("100")),
.newArrayList(new PartitionValue("100"))),
null));
SinglePartitionInfo partitionInfo = new SinglePartitionInfo();

64
fe/src/test/java/org/apache/doris/catalog/PartitionKeyTest.java
View File

@ -17,6 +17,7 @@
package org.apache.doris.catalog;
import org.apache.doris.analysis.PartitionValue;
import org.apache.doris.common.AnalysisException;
import java.io.DataInputStream;
@ -78,77 +79,80 @@ public class PartitionKeyTest {
PartitionKey pk2;
// case1
pk1 = PartitionKey.createPartitionKey(Arrays.asList("127", "32767"),
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127"), new PartitionValue("32767")),
Arrays.asList(tinyInt, smallInt));
pk2 = PartitionKey.createInfinityPartitionKey(Arrays.asList(tinyInt, smallInt), true);
Assert.assertTrue(!pk1.equals(pk2) && pk1.compareTo(pk2) == -1);
// case2
pk1 = PartitionKey.createPartitionKey(Arrays.asList("127"),
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127")),
Arrays.asList(tinyInt, smallInt));
pk2 = PartitionKey.createPartitionKey(Arrays.asList("127", "-32768"),
pk2 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127"), new PartitionValue("-32768")),
Arrays.asList(tinyInt, smallInt));
Assert.assertTrue(pk1.equals(pk2) && pk1.compareTo(pk2) == 0);
// case3
pk1 = PartitionKey.createPartitionKey(Arrays.asList("127"),
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127")),
Arrays.asList(int32, bigInt));
pk2 = PartitionKey.createPartitionKey(Arrays.asList("128", "-32768"),
pk2 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("128"), new PartitionValue("-32768")),
Arrays.asList(int32, bigInt));
Assert.assertTrue(!pk1.equals(pk2) && pk1.compareTo(pk2) == -1);
// case4
pk1 = PartitionKey.createPartitionKey(Arrays.asList("127", "12345"),
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127"), new PartitionValue("12345")),
Arrays.asList(largeInt, bigInt));
pk2 = PartitionKey.createPartitionKey(Arrays.asList("127", "12346"),
pk2 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127"), new PartitionValue("12346")),
Arrays.asList(largeInt, bigInt));
Assert.assertTrue(!pk1.equals(pk2) && pk1.compareTo(pk2) == -1);
// case5
pk1 = PartitionKey.createPartitionKey(Arrays.asList("2014-12-12", "2014-12-12 10:00:00"),
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("2014-12-12"), new PartitionValue("2014-12-12 10:00:00")),
Arrays.asList(date, datetime));
pk2 = PartitionKey.createPartitionKey(Arrays.asList("2014-12-12", "2014-12-12 10:00:01"),
pk2 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("2014-12-12"), new PartitionValue("2014-12-12 10:00:01")),
Arrays.asList(date, datetime));
Assert.assertTrue(!pk1.equals(pk2) && pk1.compareTo(pk2) == -1);
// case6
pk1 = PartitionKey.createPartitionKey(Arrays.asList("-128"),
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("-128")),
Arrays.asList(tinyInt, smallInt));
pk2 = PartitionKey.createInfinityPartitionKey(Arrays.asList(tinyInt, smallInt), false);
Assert.assertTrue(pk1.equals(pk2) && pk1.compareTo(pk2) == 0);
// case7
pk1 = PartitionKey.createPartitionKey(Arrays.asList("127"),
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127")),
Arrays.asList(tinyInt, smallInt));
pk2 = PartitionKey.createInfinityPartitionKey(Arrays.asList(tinyInt, smallInt), true);
Assert.assertTrue(!pk1.equals(pk2) && pk1.compareTo(pk2) == -1);
// case7
pk1 = PartitionKey.createPartitionKey(Arrays.asList("127", "32767"),
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127"), new PartitionValue("32767")),
Arrays.asList(tinyInt, smallInt));
pk2 = PartitionKey.createInfinityPartitionKey(Arrays.asList(tinyInt, smallInt), true);
Assert.assertTrue(!pk1.equals(pk2) && pk1.compareTo(pk2) == -1);
// case8
pk1 = PartitionKey.createPartitionKey(Arrays.asList("127", "32767", "2147483647", "9223372036854775807",
"170141183460469231731687303715884105727",
"9999-12-31", "9999-12-31 23:59:59"),
allColumns);
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("127"), new PartitionValue("32767"),
new PartitionValue("2147483647"), new PartitionValue("9223372036854775807"),
new PartitionValue("170141183460469231731687303715884105727"),
new PartitionValue("9999-12-31"), new PartitionValue("9999-12-31 23:59:59")),
allColumns);
pk2 = PartitionKey.createInfinityPartitionKey(allColumns, true);
Assert.assertTrue(!pk1.equals(pk2) && pk1.compareTo(pk2) == -1);
// case9
pk1 = PartitionKey.createPartitionKey(Arrays.asList("-128", "-32768", "-2147483648", "-9223372036854775808",
"-170141183460469231731687303715884105728",
"1900-01-01", "1900-01-01 00:00:00"),
allColumns);
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("-128"), new PartitionValue("-32768"),
new PartitionValue("-2147483648"), new PartitionValue("-9223372036854775808"),
new PartitionValue("-170141183460469231731687303715884105728"),
new PartitionValue("1900-01-01"), new PartitionValue("1900-01-01 00:00:00")),
allColumns);
pk2 = PartitionKey.createInfinityPartitionKey(allColumns, false);
Assert.assertTrue(pk1.equals(pk2) && pk1.compareTo(pk2) == 0);
// case10
pk1 = PartitionKey.createPartitionKey(Arrays.asList("-128", "-32768", "0", "-9223372036854775808",
"0", "1970-01-01", "1970-01-01 00:00:00"),
allColumns);
pk1 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("-128"), new PartitionValue("-32768"),
new PartitionValue("0"), new PartitionValue("-9223372036854775808"),
new PartitionValue("0"), new PartitionValue("1970-01-01"), new PartitionValue("1970-01-01 00:00:00")),
allColumns);
pk2 = PartitionKey.createInfinityPartitionKey(allColumns, false);
Assert.assertTrue(!pk1.equals(pk2) && pk1.compareTo(pk2) == 1);
}
@ -169,19 +173,19 @@ public class PartitionKeyTest {
PartitionKey keyEmpty = new PartitionKey();
keyEmpty.write(dos);
List<String> keys = new ArrayList<String>();
List<PartitionValue> keys = new ArrayList<PartitionValue>();
List<Column> columns = new ArrayList<Column>();
keys.add("100");
keys.add(new PartitionValue("100"));
columns.add(new Column("column2", ScalarType.createType(PrimitiveType.TINYINT), true, null, "", ""));
keys.add("101");
keys.add(new PartitionValue("101"));
columns.add(new Column("column3", ScalarType.createType(PrimitiveType.SMALLINT), true, null, "", ""));
keys.add("102");
keys.add(new PartitionValue("102"));
columns.add(new Column("column4", ScalarType.createType(PrimitiveType.INT), true, null, "", ""));
keys.add("103");
keys.add(new PartitionValue("103"));
columns.add(new Column("column5", ScalarType.createType(PrimitiveType.BIGINT), true, null, "", ""));
keys.add("2014-12-26");
keys.add(new PartitionValue("2014-12-26"));
columns.add(new Column("column10", ScalarType.createType(PrimitiveType.DATE), true, null, "", ""));
keys.add("2014-12-27 11:12:13");
keys.add(new PartitionValue("2014-12-27 11:12:13"));
columns.add(new Column("column11", ScalarType.createType(PrimitiveType.DATETIME), true, null, "", ""));
PartitionKey key = PartitionKey.createPartitionKey(keys, columns);

237
fe/src/test/java/org/apache/doris/catalog/RangePartitionInfoTest.java
View File

@ -18,6 +18,8 @@
package org.apache.doris.catalog;
import org.apache.doris.analysis.PartitionKeyDesc;
import org.apache.doris.analysis.PartitionKeyDesc.PartitionRangeType;
import org.apache.doris.analysis.PartitionValue;
import org.apache.doris.analysis.SingleRangePartitionDesc;
import org.apache.doris.common.AnalysisException;
import org.apache.doris.common.DdlException;
@ -27,6 +29,7 @@ import com.google.common.collect.Lists;
import org.junit.Before;
import org.junit.Test;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
@ -49,8 +52,8 @@ public class RangePartitionInfoTest {
partitionColumns.add(k1);
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1",
new PartitionKeyDesc(Lists .newArrayList("-128")),
null));
new PartitionKeyDesc(Lists .newArrayList(new PartitionValue("-128"))),
null));
partitionInfo = new RangePartitionInfo(partitionColumns);
@ -66,8 +69,8 @@ public class RangePartitionInfoTest {
partitionColumns.add(k1);
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1",
new PartitionKeyDesc(Lists.newArrayList("-32768")),
null));
new PartitionKeyDesc(Lists.newArrayList(new PartitionValue("-32768"))),
null));
partitionInfo = new RangePartitionInfo(partitionColumns);
for (SingleRangePartitionDesc singleRangePartitionDesc : singleRangePartitionDescs) {
@ -82,9 +85,8 @@ public class RangePartitionInfoTest {
partitionColumns.add(k1);
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1",
new PartitionKeyDesc(Lists
.newArrayList("-2147483648")),
null));
new PartitionKeyDesc(Lists.newArrayList(new PartitionValue("-2147483648"))),
null));
partitionInfo = new RangePartitionInfo(partitionColumns);
for (SingleRangePartitionDesc singleRangePartitionDesc : singleRangePartitionDescs) {
@ -99,13 +101,13 @@ public class RangePartitionInfoTest {
partitionColumns.add(k1);
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1", new PartitionKeyDesc(Lists
.newArrayList("-9223372036854775808")), null));
.newArrayList(new PartitionValue("-9223372036854775808"))), null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p2", new PartitionKeyDesc(Lists
.newArrayList("-9223372036854775806")), null));
.newArrayList(new PartitionValue("-9223372036854775806"))), null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p3", new PartitionKeyDesc(Lists
.newArrayList("0")), null));
.newArrayList(new PartitionValue("0"))), null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p4", new PartitionKeyDesc(Lists
.newArrayList("9223372036854775806")), null));
.newArrayList(new PartitionValue("9223372036854775806"))), null));
partitionInfo = new RangePartitionInfo(partitionColumns);
@ -121,13 +123,13 @@ public class RangePartitionInfoTest {
partitionColumns.add(k1);
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1", new PartitionKeyDesc(Lists
.newArrayList("-9223372036854775806")), null));
.newArrayList(new PartitionValue("-9223372036854775806"))), null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p2", new PartitionKeyDesc(Lists
.newArrayList("-9223372036854775805")), null));
.newArrayList(new PartitionValue("-9223372036854775805"))), null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p3", new PartitionKeyDesc(Lists
.newArrayList("0")), null));
.newArrayList(new PartitionValue("0"))), null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p4", new PartitionKeyDesc(Lists
.newArrayList("9223372036854775806")), null));
.newArrayList(new PartitionValue("9223372036854775806"))), null));
partitionInfo = new RangePartitionInfo(partitionColumns);
@ -137,4 +139,209 @@ public class RangePartitionInfoTest {
}
}
/**
* PARTITION BY RANGE(`k1`, `k2`) (
* PARTITION p0 VALUES [("20190101", "100"),("20190101", "200")),
* PARTITION p1 VALUES [("20190105", "10"),("20190107", "10")),
* PARTITION p2 VALUES [("20181231", "10"),("20190101", "100")),
* PARTITION p3 VALUES [("20190105", "100"),("20190120", MAXVALUE))
* )
*/
@Test
public void testFixedRange() throws DdlException, AnalysisException {
//add columns
int columns = 2;
Column k1 = new Column("k1", new ScalarType(PrimitiveType.INT), true, null, "", "");
Column k2 = new Column("k2", new ScalarType(PrimitiveType.BIGINT), true, null, "", "");
partitionColumns.add(k1);
partitionColumns.add(k2);
//add RangePartitionDescs
PartitionKeyDesc p1 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("20190101"), new PartitionValue("100")),
Lists.newArrayList(new PartitionValue("20190101"), new PartitionValue("200")));
PartitionKeyDesc p2 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("20190105"), new PartitionValue("10")),
Lists.newArrayList(new PartitionValue("20190107"), new PartitionValue("10")));
PartitionKeyDesc p3 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("20181231"), new PartitionValue("10")),
Lists.newArrayList(new PartitionValue("20190101"), new PartitionValue("100")));
PartitionKeyDesc p4 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("20190105"), new PartitionValue("100")),
Lists.newArrayList(new PartitionValue("20190120"), PartitionValue.createMaxValue()));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1", p1, null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p2", p2, null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p3", p3, null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p4", p4, null));
partitionInfo = new RangePartitionInfo(partitionColumns);
for (SingleRangePartitionDesc singleRangePartitionDesc : singleRangePartitionDescs) {
singleRangePartitionDesc.analyze(columns, null);
partitionInfo.handleNewSinglePartitionDesc(singleRangePartitionDesc, 20000L);
}
}
/**
* 失败用例 less than && fixed
* partition by range(k1,k2,k3) (
* partition p1 values less than("2019-02-01", "100", "200"),
* partition p2 values [("2020-02-01", "100", "200"), (MAXVALUE)),
* partition p3 values less than("2021-02-01")
* )
*/
@Test(expected = AnalysisException.class)
public void testFixedRange1() throws DdlException, AnalysisException {
//add columns
Column k1 = new Column("k1", new ScalarType(PrimitiveType.DATE), true, null, "", "");
Column k2 = new Column("k2", new ScalarType(PrimitiveType.INT), true, null, "", "");
Column k3 = new Column("k3", new ScalarType(PrimitiveType.INT), true, null, "", "");
partitionColumns.add(k1);
partitionColumns.add(k2);
partitionColumns.add(k3);
//add RangePartitionDescs
PartitionKeyDesc p1 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("2019-02-01"), new PartitionValue("100"), new PartitionValue("200")));
PartitionKeyDesc p2 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("2020-02-01"), new PartitionValue("100"), new PartitionValue("200")),
Lists.newArrayList(PartitionValue.createMaxValue()));
PartitionKeyDesc p3 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("2021-02-01")));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1", p1, null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p2", p2, null));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p3", p3, null));
partitionInfo = new RangePartitionInfo(partitionColumns);
PartitionRangeType partitionType = PartitionRangeType.INVALID;
for (SingleRangePartitionDesc singleRangePartitionDesc : singleRangePartitionDescs) {
// check partitionType
if (partitionType == PartitionRangeType.INVALID) {
partitionType = singleRangePartitionDesc.getPartitionKeyDesc().getPartitionType();
} else if (partitionType != singleRangePartitionDesc.getPartitionKeyDesc().getPartitionType()) {
throw new AnalysisException("You can only use one of these methods to create partitions");
}
singleRangePartitionDesc.analyze(partitionColumns.size(), null);
partitionInfo.handleNewSinglePartitionDesc(singleRangePartitionDesc, 20000L);
}
}
/**
* PARTITION BY RANGE(`k1`, `k2`) (
* PARTITION p1 VALUES [(), ("20190301", "400"))
* )
*/
@Test
public void testFixedRange2() throws DdlException, AnalysisException {
//add columns
int columns = 2;
Column k1 = new Column("k1", new ScalarType(PrimitiveType.INT), true, null, "", "");
Column k2 = new Column("k2", new ScalarType(PrimitiveType.BIGINT), true, null, "", "");
partitionColumns.add(k1);
partitionColumns.add(k2);
//add RangePartitionDescs
PartitionKeyDesc p1 = new PartitionKeyDesc(new ArrayList<>(),
Lists.newArrayList(new PartitionValue("20190101"), new PartitionValue("200")));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1", p1, null));
partitionInfo = new RangePartitionInfo(partitionColumns);
for (SingleRangePartitionDesc singleRangePartitionDesc : singleRangePartitionDescs) {
singleRangePartitionDesc.analyze(columns, null);
partitionInfo.handleNewSinglePartitionDesc(singleRangePartitionDesc, 20000L);
}
}
/**
* 失败用例
* PARTITION BY RANGE(`k1`, `k2`) (
* PARTITION p1 VALUES [("20190301", "400"), ())
* )
*/
@Test (expected = AnalysisException.class)
public void testFixedRange3() throws DdlException, AnalysisException {
//add columns
int columns = 2;
Column k1 = new Column("k1", new ScalarType(PrimitiveType.INT), true, null, "", "");
Column k2 = new Column("k2", new ScalarType(PrimitiveType.BIGINT), true, null, "", "");
partitionColumns.add(k1);
partitionColumns.add(k2);
//add RangePartitionDescs
PartitionKeyDesc p1 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("20190101"), new PartitionValue("200")),
new ArrayList<>());
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1", p1, null));
partitionInfo = new RangePartitionInfo(partitionColumns);
for (SingleRangePartitionDesc singleRangePartitionDesc : singleRangePartitionDescs) {
singleRangePartitionDesc.analyze(columns, null);
partitionInfo.handleNewSinglePartitionDesc(singleRangePartitionDesc, 20000L);
}
}
/**
* PARTITION BY RANGE(`k1`, `k2`) (
* PARTITION p0 VALUES [("20190101", "100"),("20190201"))
* )
*/
@Test
public void testFixedRange4() throws DdlException, AnalysisException {
//add columns
int columns = 2;
Column k1 = new Column("k1", new ScalarType(PrimitiveType.INT), true, null, "", "");
Column k2 = new Column("k2", new ScalarType(PrimitiveType.BIGINT), true, null, "", "");
partitionColumns.add(k1);
partitionColumns.add(k2);
//add RangePartitionDescs
PartitionKeyDesc p1 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("20190101"), new PartitionValue("100")),
Lists.newArrayList(new PartitionValue("20190201")));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1", p1, null));
partitionInfo = new RangePartitionInfo(partitionColumns);
for (SingleRangePartitionDesc singleRangePartitionDesc : singleRangePartitionDescs) {
singleRangePartitionDesc.analyze(columns, null);
partitionInfo.handleNewSinglePartitionDesc(singleRangePartitionDesc, 20000L);
}
}
/**
* 失败用例
* PARTITION BY RANGE(`k1`, `k2`) (
* PARTITION p0 VALUES [("20190101", "100"),("20190101", "100"))
* )
*/
@Test (expected = DdlException.class)
public void testFixedRange5() throws DdlException, AnalysisException {
//add columns
int columns = 2;
Column k1 = new Column("k1", new ScalarType(PrimitiveType.INT), true, null, "", "");
Column k2 = new Column("k2", new ScalarType(PrimitiveType.BIGINT), true, null, "", "");
partitionColumns.add(k1);
partitionColumns.add(k2);
//add RangePartitionDescs
PartitionKeyDesc p1 = new PartitionKeyDesc(
Lists.newArrayList(new PartitionValue("20190101"), new PartitionValue("100")),
Lists.newArrayList(new PartitionValue("20190101"), new PartitionValue("100")));
singleRangePartitionDescs.add(new SingleRangePartitionDesc(false, "p1", p1, null));
partitionInfo = new RangePartitionInfo(partitionColumns);
for (SingleRangePartitionDesc singleRangePartitionDesc : singleRangePartitionDescs) {
singleRangePartitionDesc.analyze(columns, null);
partitionInfo.handleNewSinglePartitionDesc(singleRangePartitionDesc, 20000L);
}
}
}

10
fe/src/test/java/org/apache/doris/es/EsStateStoreTest.java
View File

@ -22,6 +22,7 @@ import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import org.apache.doris.analysis.PartitionValue;
import org.apache.doris.catalog.Catalog;
import org.apache.doris.catalog.CatalogTestUtil;
import org.apache.doris.catalog.EsTable;
@ -41,7 +42,6 @@ import com.google.common.collect.Range;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Ignore;
import org.junit.Test;
import java.io.BufferedReader;
@ -119,16 +119,16 @@ public class EsStateStoreTest {
assertEquals(5, esIndexState1.getShardRoutings().size());
assertEquals("index1", esIndexState1.getIndexName());
PartitionKey lowKey = PartitionKey.createInfinityPartitionKey(definedPartInfo.getPartitionColumns(), false);
PartitionKey upperKey = PartitionKey.createPartitionKey(Lists.newArrayList("2018-10-01"),
PartitionKey upperKey = PartitionKey.createPartitionKey(Lists.newArrayList(new PartitionValue("2018-10-01")),
definedPartInfo.getPartitionColumns());
Range<PartitionKey> newRange = Range.closedOpen(lowKey, upperKey);
assertEquals(newRange, part0);
Range<PartitionKey> part1 = rangeMap.get(new Long(1));
EsIndexState esIndexState2 = esTableState.getIndexState(1);
assertEquals("index2", esIndexState2.getIndexName());
lowKey = PartitionKey.createPartitionKey(Lists.newArrayList("2018-10-01"),
lowKey = PartitionKey.createPartitionKey(Lists.newArrayList(new PartitionValue("2018-10-01")),
definedPartInfo.getPartitionColumns());
upperKey = PartitionKey.createPartitionKey(Lists.newArrayList("2018-10-02"),
upperKey = PartitionKey.createPartitionKey(Lists.newArrayList(new PartitionValue("2018-10-02")),
definedPartInfo.getPartitionColumns());
newRange = Range.closedOpen(lowKey, upperKey);
assertEquals(newRange, part1);
@ -171,7 +171,7 @@ public class EsStateStoreTest {
assertEquals(5, esIndexState1.getShardRoutings().size());
assertEquals("index1", esIndexState1.getIndexName());
PartitionKey lowKey = PartitionKey.createInfinityPartitionKey(definedPartInfo.getPartitionColumns(), false);
PartitionKey upperKey = PartitionKey.createPartitionKey(Lists.newArrayList("2018-10-01"),
PartitionKey upperKey = PartitionKey.createPartitionKey(Lists.newArrayList(new PartitionValue("2018-10-01")),
definedPartInfo.getPartitionColumns());
Range<PartitionKey> newRange = Range.closedOpen(lowKey, upperKey);
assertEquals(newRange, part0);

3
fe/src/test/java/org/apache/doris/planner/OlapTableSinkTest.java
View File

@ -18,6 +18,7 @@
package org.apache.doris.planner;
import org.apache.doris.analysis.DescriptorTable;
import org.apache.doris.analysis.PartitionValue;
import org.apache.doris.analysis.SlotDescriptor;
import org.apache.doris.analysis.TupleDescriptor;
import org.apache.doris.catalog.Column;
@ -115,7 +116,7 @@ public class OlapTableSinkTest {
2, Lists.newArrayList(new Column("k1", PrimitiveType.BIGINT)));
Column partKey = new Column("k2", PrimitiveType.VARCHAR);
PartitionKey key = PartitionKey.createPartitionKey(Lists.newArrayList("123"), Lists.newArrayList(partKey));
PartitionKey key = PartitionKey.createPartitionKey(Lists.newArrayList(new PartitionValue("123")), Lists.newArrayList(partKey));
Partition p1 = new Partition(1, "p1", index, distInfo);
Partition p2 = new Partition(2, "p2", index, distInfo);

3
fe/src/test/java/org/apache/doris/task/AgentTaskTest.java
View File

@ -17,6 +17,7 @@
package org.apache.doris.task;
import org.apache.doris.analysis.PartitionValue;
import org.apache.doris.catalog.AggregateType;
import org.apache.doris.catalog.Column;
import org.apache.doris.catalog.KeysType;
@ -98,7 +99,7 @@ public class AgentTaskTest {
columns.add(new Column("v1", ScalarType.createType(PrimitiveType.INT), false, AggregateType.SUM, "1", ""));
PartitionKey pk1 = PartitionKey.createInfinityPartitionKey(Arrays.asList(columns.get(0)), false);
PartitionKey pk2 = PartitionKey.createPartitionKey(Arrays.asList("10"), Arrays.asList(columns.get(0)));
PartitionKey pk2 = PartitionKey.createPartitionKey(Arrays.asList(new PartitionValue("10")), Arrays.asList(columns.get(0)));
range1 = Range.closedOpen(pk1, pk2);
PartitionKey pk3 = PartitionKey.createInfinityPartitionKey(Arrays.asList(columns.get(0)), true);