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 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_propertys = {}
for key in node.properties('tag2').keys():
expect_propertys[key] = node.properties('tag2')[key].as_int()
assert {
'prop0': 0,
'prop1': 1,
'prop2': 2,
'prop3': 3,
'prop4': 4
} == expect_propertys
def p_set(p):
'''
set : '{' list_items '}'
'''
s = Set()
s.values = set(p[2])
p[0] = Value(uVal=s)
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 hash_columns(ds, hashed_columns):
if len(hashed_columns) == 0:
return ds
for col in hashed_columns:
assert col < len(ds.column_names), "The hashed column should in range."
for row in ds.rows:
for col in hashed_columns:
if row.values[col].getType() != Value.NVAL and row.values[col].getType() != Value.__EMPTY__:
row.values[col] = Value(iVal = murmurhash2(row.values[col]))
return ds
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 p_list(p):
'''
list : '[' list_items ']'
| '[' ']'
'''
l = List()
if len(p) == 4:
l.values = p[2]
else:
l.values = []
p[0] = Value(lVal=l)
def p_map(p):
'''
map : '{' map_items '}'
| '{' '}'
'''
m = Map()
if len(p) == 4:
m.kvs = p[2]
else:
m.kvs = {}
p[0] = Value(mVal=m)
def p_edge(p):
'''
edge : '-' edge_spec '-' '>'
| '<' '-' edge_spec '-'
'''
if p[1] == '-':
e = p[2]
e.type = 1
else:
e = p[3]
e.type = -1
p[0] = Value(eVal=e)
def p_vertex(p):
'''
vertex : '(' tag_list ')'
| '(' STRING tag_list ')'
'''
vid = None
tags = None
if len(p) == 4:
tags = p[2]
else:
vid = p[2].get_sVal()
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_OVERFLOW(t):
r'OVERFLOW'
t.value = Value(nVal=NullType.ERR_OVERFLOW)
return t
def t_BAD_TYPE(t):
r'BAD_TYPE'
t.value = Value(nVal=NullType.BAD_TYPE)
return t
def t_BAD_DATA(t):
r'BAD_DATA'
t.value = Value(nVal=NullType.BAD_DATA)
return t
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 compare_vid(self, lid: Value, rid: Value) -> bool:
if lid.getType() == Value.IVAL:
if rid.getType() == Value.IVAL:
return self._compare_vid(lid.get_iVal(), rid.get_iVal())
if rid.getType() == Value.SVAL:
return self._compare_vid(lid.get_iVal(), rid.get_sVal())
return False
if lid.getType() == Value.SVAL:
if rid.getType() == Value.SVAL:
return self._compare_vid(lid.get_sVal(), rid.get_sVal())
return False
return 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"
]
assert result.keys() == expect_keys
assert result.col_size() == 15
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)) == 15
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) == 15
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
]
# test record
in_use = False
for record in result:
in_use = True
record.size() == 15
# test keys()
assert record.keys() == expect_keys
# test values()
values = record.values()
assert len(record.values()) == 15
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 in_use
# test use iterator again
in_use = False
for record in result:
in_use = True
record.size() == 15
assert in_use
def t_UNKNOWN_PROP(t):
r'UNKNOWN_PROP'
t.value = Value(nVal=NullType.UNKNOWN_PROP)
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_OUT_OF_RANGE(t):
r'OUT_OF_RANGE'
t.value = Value(nVal=NullType.OUT_OF_RANGE)
return t
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 register_function(name, func):
functions[name] = func
def parse(s):
return parser.parse(s)
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 t_DIV_BY_ZERO(t):
r'DIV_BY_ZERO'
t.value = Value(nVal=NullType.DIV_BY_ZERO)
return t
def compare_value(self, lhs: Value, rhs: Union[Value, Pattern]) -> bool:
"""
lhs and rhs represent response data and expected data respectively
"""
if type(rhs) is Pattern:
dsp = DataSetPrinter(self._decode_type)
return bool(rhs.match(dsp.to_string(lhs)))
if lhs.getType() == Value.__EMPTY__:
return rhs.getType() == Value.__EMPTY__
if lhs.getType() == Value.NVAL:
if not rhs.getType() == Value.NVAL:
return False
return lhs.get_nVal() == rhs.get_nVal()
if lhs.getType() == Value.BVAL:
if not rhs.getType() == Value.BVAL:
return False
return lhs.get_bVal() == rhs.get_bVal()
if lhs.getType() == Value.IVAL:
if not rhs.getType() == Value.IVAL:
return False
return lhs.get_iVal() == rhs.get_iVal()
if lhs.getType() == Value.FVAL:
if not rhs.getType() == Value.FVAL:
return False
return math.fabs(lhs.get_fVal() - rhs.get_fVal()) < 1.0E-8
if lhs.getType() == Value.SVAL:
if not rhs.getType() == Value.SVAL:
return False
return lhs.get_sVal() == self.bstr(rhs.get_sVal())
if lhs.getType() == Value.DVAL:
if rhs.getType() == Value.DVAL:
return lhs.get_dVal() == rhs.get_dVal()
if rhs.getType() == Value.SVAL:
ld = lhs.get_dVal()
lds = "%d-%02d-%02d" % (ld.year, ld.month, ld.day)
rv = rhs.get_sVal()
return lds == rv if type(rv) == str else self.b(lds) == rv
return False
if lhs.getType() == Value.TVAL:
if rhs.getType() == Value.TVAL:
return lhs.get_tVal() == rhs.get_tVal()
if rhs.getType() == Value.SVAL:
lt = lhs.get_tVal()
lts = "%02d:%02d:%02d.%06d" % (lt.hour, lt.minute, lt.sec,
lt.microsec)
rv = rhs.get_sVal()
return lts == rv if type(rv) == str else self.b(lts) == rv
return False
if lhs.getType() == Value.DTVAL:
if rhs.getType() == Value.DTVAL:
return lhs.get_dtVal() == rhs.get_dtVal()
if rhs.getType() == Value.SVAL:
ldt = lhs.get_dtVal()
ldts = "%d-%02d-%02dT%02d:%02d:%02d.%06d" % (
ldt.year, ldt.month, ldt.day, ldt.hour, ldt.minute,
ldt.sec, ldt.microsec)
rv = rhs.get_sVal()
return ldts == rv if type(rv) == str else self.b(ldts) == rv
return False
if lhs.getType() == Value.LVAL:
if not rhs.getType() == Value.LVAL:
return False
lvals = lhs.get_lVal().values
rvals = rhs.get_lVal().values
return self.compare_list(lvals, rvals)
if lhs.getType() == Value.UVAL:
if not rhs.getType() == Value.UVAL:
return False
lvals = lhs.get_uVal().values
rvals = rhs.get_uVal().values
res, _ = self._compare_list(lvals, rvals, self.compare_value)
return res
if lhs.getType() == Value.MVAL:
if not rhs.getType() == Value.MVAL:
return False
lkvs = lhs.get_mVal().kvs
rkvs = rhs.get_mVal().kvs
return self.compare_map(lkvs, rkvs)
if lhs.getType() == Value.VVAL:
if not rhs.getType() == Value.VVAL:
return False
return self.compare_node(lhs.get_vVal(), rhs.get_vVal())
if lhs.getType() == Value.EVAL:
if not rhs.getType() == Value.EVAL:
return False
return self.compare_edge(lhs.get_eVal(), rhs.get_eVal())
if lhs.getType() == Value.PVAL:
if not rhs.getType() == Value.PVAL:
return False
return self.compare_path(lhs.get_pVal(), rhs.get_pVal())
return False
def t_FLOAT(t):
r'-?\d+\.\d+'
t.value = Value(fVal=float(t.value))
return t
for cell in row:
v = nbv.parse(cell)
if v is None:
raise Exception('Unable to parse %s' % cell)
list.append(v)
return Row(list)
if __name__ == '__main__':
headings = ['m', 'r', 'n']
rows = [
['1', '2', '3'],
['()', '-->', '()'],
['("vid")', '<-[:e "1" -> "2" @-1 {p1: 0, p2: [1, 2, 3]}]-', '()'],
['<()-->()<--()>', '()', '"prop"'],
['EMPTY', 'NULL', 'BAD_TYPE'],
]
expected = DataSet(column_names = headings,\
rows = [
Row([Value(iVal=1), Value(iVal=2), Value(iVal=3)]),
Row([Value(vVal=Vertex()), Value(eVal=Edge(type=1)), Value(vVal=Vertex())]),
Row([Value(vVal=Vertex('vid')), Value(eVal=Edge(name='e',type=-1,src='1',dst='2',ranking=-1,props={'p1': Value(iVal=0), 'p2': Value(lVal=List([Value(iVal=1),Value(iVal=2),Value(iVal=3)]))})), Value(vVal=Vertex())]),
Row([Value(pVal=Path(src=Vertex(),steps=[Step(type=1,dst=Vertex()),Step(type=-1,dst=Vertex())])), Value(vVal=Vertex()), Value(sVal='prop')]),
Row([Value(), Value(nVal=NullType.__NULL__), Value(nVal=NullType.BAD_TYPE)])
])
table = bh.Table(headings=headings, rows=rows)
dataset = parse(table)
assert dataset == expected,\
"Parsed DataSet doesn't match, \nexpected: %s, \nactual: %s" % (expected, dataset)