def p_vid(p):
'''
vid : STRING
| INT
| function
'''
p[0] = p[1]
if not isinstance(p[0], Value):
if type(p[0]) in [str, bytes]:
p[0] = Value(sVal=p[0])
elif type(p[0]) is int:
p[0] = Value(iVal=p[0])
else:
raise ValueError(f"Invalid vid type: {type(p[0])}")
def p_set(p):
'''
set : '{' list_items '}'
'''
s = NSet()
s.values = set(p[2])
p[0] = Value(uVal=s)
def test_node_api(self):
test_set = set()
test_set.add(Value())
node = Node(self.get_vertex_value(b'Tom'))
assert 'Tom' == node.get_id().as_string()
assert node.has_tag('tag2')
assert ['prop0', 'prop1', 'prop2', 'prop3',
'prop4'] == node.prop_names('tag2')
assert [0, 1, 2, 3,
4] == [(value.as_int()) for value in node.prop_values('tag2')]
assert ['tag0', 'tag1', 'tag2'] == node.tags()
expect_properties = {}
for key in node.properties('tag2').keys():
expect_properties[key] = node.properties('tag2')[key].as_int()
assert {
'prop0': 0,
'prop1': 1,
'prop2': 2,
'prop3': 3,
'prop4': 4,
} == expect_properties
def p_path(p):
'''
path : '<' vertex steps '>'
| '<' vertex '>'
'''
path = Path()
path.src = p[2].get_vVal()
if len(p) == 5:
path.steps = p[3]
p[0] = Value(pVal=path)
def hash_columns(ds, hashed_columns):
if len(hashed_columns) == 0:
return ds
assert all(col < len(ds.column_names) for col in hashed_columns)
for row in ds.rows:
for col in hashed_columns:
val = row.values[col]
if val.getType() not in [Value.NVAL, Value.__EMPTY__]:
row.values[col] = Value(iVal=murmurhash2(val))
return ds
def p_map(p):
'''
map : '{' map_items '}'
| '{' '}'
'''
m = NMap()
if len(p) == 4:
m.kvs = p[2]
else:
m.kvs = {}
p[0] = Value(mVal=m)
def p_list(p):
'''
list : '[' list_items ']'
| '[' ']'
'''
l = NList()
if len(p) == 4:
l.values = p[2]
else:
l.values = []
p[0] = Value(lVal=l)
def p_vertex(p):
'''
vertex : '(' tag_list ')'
| '(' vid tag_list ')'
'''
vid = None
tags = None
if len(p) == 4:
tags = p[2]
else:
vid = p[2]
tags = p[3]
v = Vertex(vid=vid, tags=tags)
p[0] = Value(vVal=v)
def t_BOOLEAN(t):
r'(?i)true|false'
v = Value()
if t.value.lower() == 'true':
v.set_bVal(True)
else:
v.set_bVal(False)
t.value = v
return t
def p_expr(p):
'''
expr : EMPTY
| NULL
| NaN
| BAD_DATA
| BAD_TYPE
| OVERFLOW
| UNKNOWN_PROP
| DIV_BY_ZERO
| OUT_OF_RANGE
| INT
| FLOAT
| BOOLEAN
| STRING
| PATTERN
| list
| set
| map
| vertex
| edge
| path
| function
'''
if isinstance(p[1], Value) or isinstance(p[1], Pattern):
p[0] = p[1]
elif type(p[1]) in [str, bytes]:
p[0] = Value(sVal=p[1])
elif type(p[1]) is int:
p[0] = Value(iVal=p[1])
elif type(p[1]) is bool:
p[0] = Value(bVal=p[1])
elif type(p[1]) is float:
p[0] = Value(fVal=p[1])
else:
raise ValueError(f"Invalid value type: {type(p[1])}")
def t_NaN(t):
r'NaN'
t.value = Value(nVal=NullType.NaN)
return t
def t_NULL(t):
r'NULL'
t.value = Value(nVal=NullType.__NULL__)
return t
def t_EMPTY(t):
r'EMPTY'
t.value = Value()
return t
def t_DIV_BY_ZERO(t):
r'DIV_BY_ZERO'
t.value = Value(nVal=NullType.DIV_BY_ZERO)
return t
def p_edge_spec(p):
'''
edge : '[' edge_rank edge_props ']'
| '[' ':' LABEL edge_props ']'
| '[' ':' LABEL edge_rank edge_props ']'
| '[' vid '-' '>' vid edge_props ']'
| '[' vid '-' '>' vid edge_rank edge_props ']'
| '[' ':' LABEL vid '-' '>' vid edge_props ']'
| '[' ':' LABEL vid '-' '>' vid edge_rank edge_props ']'
| '[' vid '<' '-' vid edge_props ']'
| '[' vid '<' '-' vid edge_rank edge_props ']'
| '[' ':' LABEL vid '<' '-' vid edge_props ']'
| '[' ':' LABEL vid '<' '-' vid edge_rank edge_props ']'
'''
e = Edge()
name = None
rank = None
src = None
dst = None
props = None
etype = None
if len(p) == 5:
rank = p[2]
props = p[3]
elif len(p) == 6:
name = p[3]
props = p[4]
elif len(p) == 7:
name = p[3]
rank = p[4]
props = p[5]
elif len(p) == 8:
src = p[2]
dst = p[5]
if p[3] == '<' and p[4] == '-':
etype = -1
props = p[6]
elif len(p) == 9:
src = p[2]
dst = p[5]
if p[3] == '<' and p[4] == '-':
etype = -1
rank = p[6]
props = p[7]
elif len(p) == 10:
name = p[3]
src = p[4]
dst = p[7]
if p[5] == '<' and p[6] == '-':
etype = -1
props = p[8]
elif len(p) == 11:
name = p[3]
src = p[4]
dst = p[7]
if p[5] == '<' and p[6] == '-':
etype = -1
rank = p[8]
props = p[9]
e.name = name
e.ranking = rank
e.src = src
e.dst = dst
e.props = props
# default value of e.type is 1 if etype is None
e.type = etype
p[0] = Value(eVal=e)
def t_FLOAT(t):
r'-?\d+\.\d+'
t.value = Value(fVal=float(t.value))
return t
def t_OVERFLOW(t):
r'OVERFLOW'
t.value = Value(nVal=NullType.ERR_OVERFLOW)
return t
register_function('hash', murmurhash2)
parser = yacc.yacc(write_tables=False)
def parse(s):
return parser.parse(s, lexer=lexer)
def parse_row(row):
return [str(parse(x)) for x in row]
if __name__ == '__main__':
expected = {}
expected['EMPTY'] = Value()
expected['NULL'] = Value(nVal=NullType.__NULL__)
expected['NaN'] = Value(nVal=NullType.NaN)
expected['BAD_DATA'] = Value(nVal=NullType.BAD_DATA)
expected['BAD_TYPE'] = Value(nVal=NullType.BAD_TYPE)
expected['OVERFLOW'] = Value(nVal=NullType.ERR_OVERFLOW)
expected['UNKNOWN_PROP'] = Value(nVal=NullType.UNKNOWN_PROP)
expected['DIV_BY_ZERO'] = Value(nVal=NullType.DIV_BY_ZERO)
expected['OUT_OF_RANGE'] = Value(nVal=NullType.OUT_OF_RANGE)
expected['123'] = Value(iVal=123)
expected['-123'] = Value(iVal=-123)
expected['3.14'] = Value(fVal=3.14)
expected['-3.14'] = Value(fVal=-3.14)
expected['true'] = Value(bVal=True)
expected['True'] = Value(bVal=True)
expected['false'] = Value(bVal=False)
def test_all_interface(self):
result = self.get_result_set()
assert result.space_name() == "test"
assert result.comment() == "Permission"
assert result.error_msg() == "Permission"
assert result.error_code() == ErrorCode.E_BAD_PERMISSION
assert result.plan_desc() is None
assert result.latency() == 100
assert not result.is_empty()
assert not result.is_succeeded()
expect_keys = [
"col1_empty",
"col2_null",
"col3_bool",
"col4_int",
"col5_double",
"col6_string",
"col7_list",
"col8_set",
"col9_map",
"col10_time",
"col11_date",
"col12_datetime",
"col13_vertex",
"col14_edge",
"col15_path",
"col16_geography",
"col17_duration",
]
assert result.keys() == expect_keys
assert result.col_size() == 17
assert result.row_size() == 2
# test column_values
assert len(result.column_values("col6_string")) == 2
assert result.column_values("col6_string")[0].is_string()
assert result.column_values(
"col6_string")[0].as_string() == "hello world"
# test row_values
assert len(result.row_values(0)) == 17
assert result.row_values(0)[5].is_string()
assert result.row_values(0)[5].as_string() == "hello world"
# test rows
assert len(result.rows()) == 2
assert len(result.rows()[0].values) == 17
assert isinstance(result.rows()[0].values[0], Value)
assert isinstance(result.get_row_types(), list)
# test get_row_types
assert result.get_row_types() == [
ttypes.Value.__EMPTY__,
ttypes.Value.NVAL,
ttypes.Value.BVAL,
ttypes.Value.IVAL,
ttypes.Value.FVAL,
ttypes.Value.SVAL,
ttypes.Value.LVAL,
ttypes.Value.UVAL,
ttypes.Value.MVAL,
ttypes.Value.TVAL,
ttypes.Value.DVAL,
ttypes.Value.DTVAL,
ttypes.Value.VVAL,
ttypes.Value.EVAL,
ttypes.Value.PVAL,
ttypes.Value.GGVAL,
ttypes.Value.DUVAL,
]
# test record
in_use = False
for record in result:
in_use = True
record.size() == 17
# test keys()
assert record.keys() == expect_keys
# test values()
values = record.values()
assert len(record.values()) == 17
assert record.values()[0].is_empty()
assert record.values()[5].is_string()
assert record.values()[5].is_string()
assert record.values()[5].as_string() == "hello world"
# test get_value()
assert record.get_value(0).is_empty()
assert values[0].is_empty()
assert record.get_value(1).is_null()
assert record.get_value(1).as_null() == Null(Null.BAD_DATA)
null_value = Value(nVal=Null.BAD_DATA)
assert record.get_value(1) == ValueWrapper(null_value)
assert str(record.get_value(1).as_null()) == 'BAD_DATA'
# test get_value_by_key()
assert record.get_value_by_key('col2_null').is_null()
assert record.get_value_by_key('col3_bool').is_bool()
assert not record.get_value_by_key('col3_bool').as_bool()
# get_value_by_key with not exited key
try:
record.get_value_by_key('not existed')
assert False, 'Not expect here'
except InvalidKeyException as e:
assert True
assert e.message == "KeyError: `not existed'"
assert values[1].is_null()
assert record.get_value(2).is_bool()
assert not record.get_value(2).as_bool()
assert record.get_value(2).is_bool()
assert record.get_value(3).is_int()
assert record.get_value(3).as_int() == 100
assert record.get_value(4).is_double()
assert record.get_value(4).as_double() == 10.01
assert record.get_value(5).is_string()
assert record.get_value(5).as_string() == "hello world"
assert record.get_value(6).is_list()
assert record.get_value(7).is_set()
assert record.get_value(8).is_map()
assert record.get_value(9).is_time()
assert record.get_value(10).is_date()
assert record.get_value(11).is_datetime()
assert record.get_value(12).is_vertex()
assert record.get_value(13).is_edge()
assert record.get_value(14).is_path()
assert record.get_value(15).is_geography()
assert record.get_value(16).is_duration()
assert in_use
# test use iterator again
in_use = False
for record in result:
in_use = True
record.size() == 17
assert in_use
def t_dstr_STRING(t):
r'"'
t.value = Value(sVal=t.lexer.string)
t.lexer.begin('INITIAL')
return t
def t_INT(t):
r'-?\d+'
t.value = Value(iVal=int(t.value))
return t
def t_BAD_DATA(t):
r'BAD_DATA'
t.value = Value(nVal=NullType.BAD_DATA)
return t
def t_BAD_TYPE(t):
r'BAD_TYPE'
t.value = Value(nVal=NullType.BAD_TYPE)
return t
def value(any):
v = Value()
if (isinstance(any, bool)):
v.set_bVal(any)
elif (isinstance(any, int)):
v.set_iVal(any)
elif (isinstance(any, str)):
v.set_sVal(any)
elif (isinstance(any, float)):
v.set_fVal(any)
elif (isinstance(any, list)):
v.set_lVal(list2Nlist(any))
elif (isinstance(any, dict)):
v.set_mVal(map2NMap(any))
else:
raise TypeError("Do not support convert " + str(type(any)) +
" to nebula.Value")
return v
def t_UNKNOWN_PROP(t):
r'UNKNOWN_PROP'
t.value = Value(nVal=NullType.UNKNOWN_PROP)
return t
def t_OUT_OF_RANGE(t):
r'OUT_OF_RANGE'
t.value = Value(nVal=NullType.OUT_OF_RANGE)
return t