| /* |
| * 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.hugegraph.core; |
| |
| import java.util.Date; |
| |
| import org.junit.Assume; |
| import org.junit.Test; |
| |
| import org.apache.hugegraph.HugeException; |
| import org.apache.hugegraph.exception.ExistedException; |
| import org.apache.hugegraph.exception.NotAllowException; |
| import org.apache.hugegraph.exception.NotFoundException; |
| import org.apache.hugegraph.schema.PropertyKey; |
| import org.apache.hugegraph.schema.SchemaManager; |
| import org.apache.hugegraph.schema.Userdata; |
| import org.apache.hugegraph.testutil.Assert; |
| import org.apache.hugegraph.type.define.AggregateType; |
| import org.apache.hugegraph.type.define.Cardinality; |
| import org.apache.hugegraph.type.define.DataType; |
| import org.apache.hugegraph.type.define.WriteType; |
| import org.apache.hugegraph.util.DateUtil; |
| import com.google.common.collect.ImmutableList; |
| |
| public class PropertyKeyCoreTest extends SchemaCoreTest { |
| |
| @Test |
| public void testAddPropertyKey() { |
| SchemaManager schema = graph().schema(); |
| PropertyKey id = schema.propertyKey("id") |
| .asText() |
| .valueSingle() |
| .create(); |
| |
| Assert.assertEquals("id", id.name()); |
| Assert.assertEquals(DataType.TEXT, id.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, id.cardinality()); |
| } |
| |
| @Test |
| public void testAddPropertyKeyWithValidName() { |
| SchemaManager schema = graph().schema(); |
| |
| // One space and single char |
| schema.propertyKey(" s").create(); |
| schema.propertyKey("s s").create(); |
| |
| schema.propertyKey(" .").create(); |
| schema.propertyKey(". .").create(); |
| |
| schema.propertyKey("@$%^&*()_+`-={}|[]\"<?;'~,./\\").create(); |
| schema.propertyKey("azAZ0123456789").create(); |
| |
| schema.propertyKey(" ~").create(); |
| schema.propertyKey("x~").create(); |
| } |
| |
| @Test |
| public void testAddPropertyKeyWithIllegalName() { |
| SchemaManager schema = graph().schema(); |
| |
| // Empty string |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey("").create(); |
| }); |
| // One space |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey(" ").create(); |
| }); |
| // Multi spaces |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey(" ").create(); |
| }); |
| |
| // End with spaces |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey("s ").create(); |
| }); |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey(" . ").create(); |
| }); |
| |
| // Internal characters |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey("#").create(); |
| }); |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey(">").create(); |
| }); |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey(":").create(); |
| }); |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey("!").create(); |
| }); |
| |
| // Start with '~' |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey("~").create(); |
| }); |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey("~ ").create(); |
| }); |
| Assert.assertThrows(IllegalArgumentException.class, () -> { |
| schema.propertyKey("~x").create(); |
| }); |
| } |
| |
| @Test |
| public void testAddPropertyKeyWithoutDataType() { |
| SchemaManager schema = graph().schema(); |
| PropertyKey id = schema.propertyKey("id").valueSingle().create(); |
| Assert.assertEquals(DataType.TEXT, id.dataType()); |
| } |
| |
| @Test |
| public void testAddPropertyKeyWithoutCardinality() { |
| SchemaManager schema = graph().schema(); |
| PropertyKey id = schema.propertyKey("id").asText().create(); |
| Assert.assertEquals(Cardinality.SINGLE, id.cardinality()); |
| } |
| |
| @Test |
| public void testAddPropertyKeyWithoutDataTypeAndCardinality() { |
| SchemaManager schema = graph().schema(); |
| PropertyKey id = schema.propertyKey("id").create(); |
| Assert.assertEquals(DataType.TEXT, id.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, id.cardinality()); |
| } |
| |
| @Test |
| public void testAddPropertyKeyWithAggregateType() { |
| SchemaManager schema = graph().schema(); |
| PropertyKey startTime = schema.propertyKey("startTime") |
| .asDate().valueSingle().calcMin() |
| .ifNotExist().create(); |
| Assert.assertEquals(DataType.DATE, startTime.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, startTime.cardinality()); |
| Assert.assertEquals(AggregateType.MIN, startTime.aggregateType()); |
| startTime = schema.getPropertyKey("startTime"); |
| Assert.assertEquals(DataType.DATE, startTime.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, startTime.cardinality()); |
| Assert.assertEquals(AggregateType.MIN, startTime.aggregateType()); |
| |
| PropertyKey endTime = schema.propertyKey("endTime") |
| .asDate().valueSingle().calcMax() |
| .ifNotExist().create(); |
| Assert.assertEquals(DataType.DATE, endTime.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, endTime.cardinality()); |
| Assert.assertEquals(AggregateType.MAX, endTime.aggregateType()); |
| endTime = schema.getPropertyKey("endTime"); |
| Assert.assertEquals(DataType.DATE, endTime.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, endTime.cardinality()); |
| Assert.assertEquals(AggregateType.MAX, endTime.aggregateType()); |
| |
| PropertyKey times = schema.propertyKey("times") |
| .asLong().valueSingle().calcSum() |
| .ifNotExist().create(); |
| Assert.assertEquals(DataType.LONG, times.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, times.cardinality()); |
| Assert.assertEquals(AggregateType.SUM, times.aggregateType()); |
| times = schema.getPropertyKey("times"); |
| Assert.assertEquals(DataType.LONG, times.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, times.cardinality()); |
| Assert.assertEquals(AggregateType.SUM, times.aggregateType()); |
| |
| PropertyKey oldProp = schema.propertyKey("oldProp") |
| .asLong().valueSingle().calcOld() |
| .ifNotExist().create(); |
| Assert.assertEquals(DataType.LONG, oldProp.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, oldProp.cardinality()); |
| Assert.assertEquals(AggregateType.OLD, oldProp.aggregateType()); |
| oldProp = schema.getPropertyKey("oldProp"); |
| Assert.assertEquals(DataType.LONG, oldProp.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, oldProp.cardinality()); |
| Assert.assertEquals(AggregateType.OLD, oldProp.aggregateType()); |
| |
| PropertyKey setProp = schema.propertyKey("setProp") |
| .asLong().valueSet().calcSet() |
| .ifNotExist().create(); |
| Assert.assertEquals(DataType.LONG, setProp.dataType()); |
| Assert.assertEquals(Cardinality.SET, setProp.cardinality()); |
| Assert.assertEquals(AggregateType.SET, setProp.aggregateType()); |
| setProp = schema.getPropertyKey("setProp"); |
| Assert.assertEquals(DataType.LONG, setProp.dataType()); |
| Assert.assertEquals(Cardinality.SET, setProp.cardinality()); |
| Assert.assertEquals(AggregateType.SET, setProp.aggregateType()); |
| |
| PropertyKey listProp = schema.propertyKey("listProp") |
| .asLong().valueList().calcList() |
| .ifNotExist().create(); |
| Assert.assertEquals(DataType.LONG, listProp.dataType()); |
| Assert.assertEquals(Cardinality.LIST, listProp.cardinality()); |
| Assert.assertEquals(AggregateType.LIST, listProp.aggregateType()); |
| listProp = schema.getPropertyKey("listProp"); |
| Assert.assertEquals(DataType.LONG, listProp.dataType()); |
| Assert.assertEquals(Cardinality.LIST, listProp.cardinality()); |
| Assert.assertEquals(AggregateType.LIST, listProp.aggregateType()); |
| |
| PropertyKey regular = schema.propertyKey("regular").create(); |
| Assert.assertEquals(DataType.TEXT, regular.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, regular.cardinality()); |
| Assert.assertEquals(AggregateType.NONE, regular.aggregateType()); |
| regular = schema.getPropertyKey("regular"); |
| Assert.assertEquals(DataType.TEXT, regular.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, regular.cardinality()); |
| Assert.assertEquals(AggregateType.NONE, regular.aggregateType()); |
| } |
| |
| @Test |
| public void testAddPropertyKeyWithAggregateTypeInvalid() { |
| SchemaManager schema = graph().schema(); |
| |
| // Invalid cardinality |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueList().calcMin().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueSet().calcMin().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueList().calcMax().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueSet().calcMax().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueList().calcSum().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueSet().calcSum().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueList().calcOld().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueSet().calcOld().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueSingle().calcSet().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueSingle().calcList().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueSet().calcList().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueList().calcSet().create(); |
| }); |
| |
| // Invalid data type |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asText().valueSingle().calcMin().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asBlob().valueSingle().calcMin().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asBoolean().valueSingle().calcMin().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asUUID().valueSingle().calcMin().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asText().valueSingle().calcMax().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asBlob().valueSingle().calcMax().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asBoolean().valueSingle().calcMax().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asUUID().valueSingle().calcMax().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asText().valueSingle().calcSum().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asBlob().valueSingle().calcSum().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asBoolean().valueSingle().calcSum().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asUUID().valueSingle().calcSum().create(); |
| }); |
| |
| Assert.assertThrows(NotAllowException.class, () -> { |
| schema.propertyKey("aggregateProperty") |
| .asDate().valueSingle().calcSum().create(); |
| }); |
| } |
| |
| @Test |
| public void testAddOlapPropertyKey() { |
| Assume.assumeTrue("Not support olap properties", |
| storeFeatures().supportsOlapProperties()); |
| |
| SchemaManager schema = graph().schema(); |
| PropertyKey olap = schema.propertyKey("olap") |
| .asText().valueSingle() |
| .writeType(WriteType.OLAP_COMMON) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("olap", olap.name()); |
| Assert.assertEquals(DataType.TEXT, olap.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, olap.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_COMMON, olap.writeType()); |
| |
| PropertyKey pagerank = schema.propertyKey("pagerank") |
| .asDouble().valueSingle() |
| .writeType(WriteType.OLAP_RANGE) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("pagerank", pagerank.name()); |
| Assert.assertEquals(DataType.DOUBLE, pagerank.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, pagerank.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_RANGE, pagerank.writeType()); |
| |
| PropertyKey wcc = schema.propertyKey("wcc") |
| .asText().valueSingle() |
| .writeType(WriteType.OLAP_SECONDARY) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("wcc", wcc.name()); |
| Assert.assertEquals(DataType.TEXT, wcc.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, wcc.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_SECONDARY, wcc.writeType()); |
| } |
| |
| @Test |
| public void testClearOlapPropertyKey() { |
| Assume.assumeTrue("Not support olap properties", |
| storeFeatures().supportsOlapProperties()); |
| |
| SchemaManager schema = graph().schema(); |
| PropertyKey olap = schema.propertyKey("olap") |
| .asText().valueSingle() |
| .writeType(WriteType.OLAP_COMMON) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("olap", olap.name()); |
| Assert.assertEquals(DataType.TEXT, olap.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, olap.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_COMMON, olap.writeType()); |
| |
| graph().clearPropertyKey(olap); |
| |
| olap = graph().propertyKey("olap"); |
| Assert.assertEquals("olap", olap.name()); |
| Assert.assertEquals(DataType.TEXT, olap.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, olap.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_COMMON, olap.writeType()); |
| |
| PropertyKey pagerank = schema.propertyKey("pagerank") |
| .asDouble().valueSingle() |
| .writeType(WriteType.OLAP_RANGE) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("pagerank", pagerank.name()); |
| Assert.assertEquals(DataType.DOUBLE, pagerank.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, pagerank.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_RANGE, pagerank.writeType()); |
| |
| graph().clearPropertyKey(pagerank); |
| |
| pagerank = graph().propertyKey("pagerank"); |
| Assert.assertEquals("pagerank", pagerank.name()); |
| Assert.assertEquals(DataType.DOUBLE, pagerank.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, pagerank.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_RANGE, pagerank.writeType()); |
| |
| PropertyKey wcc = schema.propertyKey("wcc") |
| .asText().valueSingle() |
| .writeType(WriteType.OLAP_SECONDARY) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("wcc", wcc.name()); |
| Assert.assertEquals(DataType.TEXT, wcc.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, wcc.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_SECONDARY, wcc.writeType()); |
| |
| graph().clearPropertyKey(wcc); |
| |
| wcc = graph().propertyKey("wcc"); |
| Assert.assertEquals("wcc", wcc.name()); |
| Assert.assertEquals(DataType.TEXT, wcc.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, wcc.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_SECONDARY, wcc.writeType()); |
| } |
| |
| @Test |
| public void testRemoveOlapPropertyKey() { |
| Assume.assumeTrue("Not support olap properties", |
| storeFeatures().supportsOlapProperties()); |
| |
| SchemaManager schema = graph().schema(); |
| PropertyKey olap = schema.propertyKey("olap") |
| .asText().valueSingle() |
| .writeType(WriteType.OLAP_COMMON) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("olap", olap.name()); |
| Assert.assertEquals(DataType.TEXT, olap.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, olap.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_COMMON, olap.writeType()); |
| |
| schema.propertyKey("olap").remove(); |
| |
| Assert.assertThrows(NotFoundException.class, () -> { |
| schema.getPropertyKey("olap"); |
| }); |
| |
| PropertyKey pagerank = schema.propertyKey("pagerank") |
| .asDouble().valueSingle() |
| .writeType(WriteType.OLAP_RANGE) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("pagerank", pagerank.name()); |
| Assert.assertEquals(DataType.DOUBLE, pagerank.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, pagerank.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_RANGE, pagerank.writeType()); |
| |
| schema.propertyKey("pagerank").remove(); |
| |
| Assert.assertThrows(NotFoundException.class, () -> { |
| schema.getPropertyKey("pagerank"); |
| }); |
| |
| PropertyKey wcc = schema.propertyKey("wcc") |
| .asText().valueSingle() |
| .writeType(WriteType.OLAP_SECONDARY) |
| .ifNotExist().create(); |
| |
| Assert.assertEquals("wcc", wcc.name()); |
| Assert.assertEquals(DataType.TEXT, wcc.dataType()); |
| Assert.assertEquals(Cardinality.SINGLE, wcc.cardinality()); |
| Assert.assertEquals(WriteType.OLAP_SECONDARY, wcc.writeType()); |
| |
| schema.propertyKey("wcc").remove(); |
| |
| Assert.assertThrows(NotFoundException.class, () -> { |
| schema.getPropertyKey("wcc"); |
| }); |
| } |
| |
| @Test |
| public void testRemovePropertyKey() { |
| SchemaManager schema = graph().schema(); |
| schema.propertyKey("id").valueSingle().create(); |
| Assert.assertNotNull(schema.getPropertyKey("id")); |
| |
| schema.propertyKey("id").remove(); |
| Assert.assertThrows(NotFoundException.class, () -> { |
| schema.getPropertyKey("id"); |
| }); |
| } |
| |
| @Test |
| public void testRemoveNotExistPropertyKey() { |
| SchemaManager schema = graph().schema(); |
| schema.propertyKey("not-exist-pk").remove(); |
| } |
| |
| @Test |
| public void testRemovePropertyKeyUsedByVertexLabel() { |
| super.initPropertyKeys(); |
| SchemaManager schema = graph().schema(); |
| |
| schema.vertexLabel("person") |
| .properties("name", "age", "city") |
| .primaryKeys("name") |
| .nullableKeys("city") |
| .create(); |
| |
| Assert.assertThrows(HugeException.class, () -> { |
| schema.propertyKey("name").remove(); |
| }); |
| } |
| |
| @Test |
| public void testRemovePropertyKeyUsedByEdgeLabel() { |
| super.initPropertyKeys(); |
| SchemaManager schema = graph().schema(); |
| |
| schema.vertexLabel("person") |
| .properties("name", "age", "city") |
| .primaryKeys("name") |
| .nullableKeys("city") |
| .create(); |
| schema.vertexLabel("book") |
| .properties("name") |
| .primaryKeys("name") |
| .create(); |
| schema.edgeLabel("write").link("person", "book") |
| .properties("time", "weight") |
| .create(); |
| |
| Assert.assertThrows(HugeException.class, () -> { |
| schema.propertyKey("time").remove(); |
| }); |
| } |
| |
| @Test |
| public void testAddPropertyKeyWithUserdata() { |
| SchemaManager schema = graph().schema(); |
| |
| PropertyKey age = schema.propertyKey("age") |
| .userdata("min", 0) |
| .userdata("max", 100) |
| .create(); |
| Assert.assertEquals(3, age.userdata().size()); |
| Assert.assertEquals(0, age.userdata().get("min")); |
| Assert.assertEquals(100, age.userdata().get("max")); |
| |
| PropertyKey id = schema.propertyKey("id") |
| .userdata("length", 15) |
| .userdata("length", 18) |
| .create(); |
| // The same key user data will be overwritten |
| Assert.assertEquals(2, id.userdata().size()); |
| Assert.assertEquals(18, id.userdata().get("length")); |
| |
| PropertyKey sex = schema.propertyKey("sex") |
| .userdata("range", |
| ImmutableList.of("male", "female")) |
| .create(); |
| Assert.assertEquals(2, sex.userdata().size()); |
| Assert.assertEquals(ImmutableList.of("male", "female"), |
| sex.userdata().get("range")); |
| } |
| |
| @Test |
| public void testAppendPropertyKeyWithUserdata() { |
| SchemaManager schema = graph().schema(); |
| |
| PropertyKey age = schema.propertyKey("age") |
| .userdata("min", 0) |
| .create(); |
| Assert.assertEquals(2, age.userdata().size()); |
| Assert.assertEquals(0, age.userdata().get("min")); |
| |
| age = schema.propertyKey("age") |
| .userdata("min", 1) |
| .userdata("max", 100) |
| .append(); |
| Assert.assertEquals(3, age.userdata().size()); |
| Assert.assertEquals(1, age.userdata().get("min")); |
| Assert.assertEquals(100, age.userdata().get("max")); |
| } |
| |
| @Test |
| public void testEliminatePropertyKeyWithUserdata() { |
| SchemaManager schema = graph().schema(); |
| |
| PropertyKey age = schema.propertyKey("age") |
| .userdata("min", 0) |
| .userdata("max", 100) |
| .create(); |
| Assert.assertEquals(3, age.userdata().size()); |
| Assert.assertEquals(0, age.userdata().get("min")); |
| Assert.assertEquals(100, age.userdata().get("max")); |
| |
| age = schema.propertyKey("age") |
| .userdata("max", "") |
| .eliminate(); |
| Assert.assertEquals(2, age.userdata().size()); |
| Assert.assertEquals(0, age.userdata().get("min")); |
| } |
| |
| @Test |
| public void testUpdatePropertyKeyWithoutUserdata() { |
| SchemaManager schema = graph().schema(); |
| |
| schema.propertyKey("age") |
| .asInt() |
| .valueSingle() |
| .userdata("min", 0) |
| .create(); |
| |
| Assert.assertThrows(HugeException.class, () -> { |
| schema.propertyKey("age").asLong().append(); |
| }); |
| |
| Assert.assertThrows(HugeException.class, () -> { |
| schema.propertyKey("age").valueList().append(); |
| }); |
| |
| Assert.assertThrows(HugeException.class, () -> { |
| schema.propertyKey("age").asLong().eliminate(); |
| }); |
| |
| Assert.assertThrows(HugeException.class, () -> { |
| schema.propertyKey("age").valueList().eliminate(); |
| }); |
| } |
| |
| @Test |
| public void testCreateTime() { |
| SchemaManager schema = graph().schema(); |
| PropertyKey id = schema.propertyKey("id") |
| .asText() |
| .valueSingle() |
| .create(); |
| |
| Date createTime = (Date) id.userdata().get(Userdata.CREATE_TIME); |
| Date now = DateUtil.now(); |
| Assert.assertFalse(createTime.after(now)); |
| |
| id = schema.getPropertyKey("id"); |
| createTime = (Date) id.userdata().get(Userdata.CREATE_TIME); |
| Assert.assertFalse(createTime.after(now)); |
| } |
| |
| @Test |
| public void testDuplicatePropertyKeyWithIdentityProperties() { |
| SchemaManager schema = graph().schema(); |
| schema.propertyKey("fakePropKey") |
| .asText() |
| .ifNotExist() |
| .create(); |
| schema.propertyKey("fakePropKey") |
| .asText() |
| .checkExist(false) |
| .create(); |
| schema.propertyKey("fakePropKey") |
| .userdata("b", "") // won't check userdata |
| .asText() |
| .checkExist(false) |
| .create(); |
| } |
| |
| @Test |
| public void testDuplicatePropertyKeyWithDifferentProperties() { |
| SchemaManager schema = graph().schema(); |
| schema.propertyKey("fakePropKey") |
| .asText() |
| .ifNotExist() |
| .create(); |
| Assert.assertThrows(ExistedException.class, () -> { |
| schema.propertyKey("fakePropKey") |
| .asDouble() |
| .checkExist(false) |
| .create(); |
| }); |
| Assert.assertThrows(ExistedException.class, () -> { |
| schema.propertyKey("fakePropKey") |
| .asText() |
| .valueList() |
| .checkExist(false) |
| .create(); |
| }); |
| Assert.assertThrows(ExistedException.class, () -> { |
| schema.propertyKey("fakePropKey") |
| .asText() |
| .aggregateType(AggregateType.MAX) |
| .checkExist(false) |
| .create(); |
| }); |
| } |
| } |