def execute(self, stmt):
"""
execute statement
:param stmt: the ngql
:return: ResultSet
"""
if self._connection is None:
raise RuntimeError('The session has released')
try:
return ResultSet(self._connection.execute(self.session_id, stmt))
except IOErrorException as ie:
if ie.type == IOErrorException.E_CONNECT_BROKEN:
self._pool.update_servers_status()
if self._retry_connect:
if not self._reconnect():
logging.warning('Retry connect failed')
raise IOErrorException(IOErrorException.E_ALL_BROKEN,
'All connections are broken')
try:
return ResultSet(
self._connection.execute(self.session_id, stmt))
except Exception:
raise
raise
except Exception:
raise
def execute(self, stmt):
"""execute statement
:param stmt: the ngql
:return: ResultSet
"""
if self._connection is None:
raise RuntimeError('The session has released')
try:
start_time = time.time()
resp = self._connection.execute(self._session_id, stmt)
end_time = time.time()
return ResultSet(resp,
all_latency=int((end_time - start_time) * 1000000),
timezone_offset=self._timezone_offset)
except IOErrorException as ie:
if ie.type == IOErrorException.E_CONNECT_BROKEN:
self._pool.update_servers_status()
if self._retry_connect:
if not self._reconnect():
logging.warning('Retry connect failed')
raise IOErrorException(IOErrorException.E_ALL_BROKEN, ie.message)
resp = self._connection.execute(self._session_id, stmt)
end_time = time.time()
return ResultSet(resp,
all_latency=int((end_time - start_time) * 1000000),
timezone_offset=self._timezone_offset)
raise
except Exception:
raise
def test_the_same_id_to_different_graphd(self):
def get_connection(ip, port):
try:
socket = TSocket.TSocket(ip, port)
transport = TTransport.TBufferedTransport(socket)
protocol = TBinaryProtocol.TBinaryProtocol(transport)
transport.open()
connection = GraphService.Client(protocol)
except Exception as ex:
assert False, 'Create connection to {}:{} failed'.format(
ip, port)
return connection
conn1 = get_connection(self.addr_host1, self.addr_port1)
conn2 = get_connection(self.addr_host2, self.addr_port2)
resp = conn1.authenticate('root', 'nebula')
assert resp.error_code == ttypes.ErrorCode.SUCCEEDED
session_id = resp.session_id
resp = conn1.execute(
session_id,
'CREATE SPACE IF NOT EXISTS aSpace(partition_num=1, vid_type=FIXED_STRING(8));USE aSpace;'
)
self.check_resp_succeeded(ResultSet(resp, 0))
time.sleep(3)
resp = conn1.execute(session_id, 'CREATE TAG IF NOT EXISTS a();')
self.check_resp_succeeded(ResultSet(resp, 0))
resp = conn2.execute(session_id, 'CREATE TAG IF NOT EXISTS b();')
self.check_resp_succeeded(ResultSet(resp, 0))
def do_test(connection, sid, num):
result = connection.execute(sid, 'USE aSpace;')
assert result.error_code == ttypes.ErrorCode.SUCCEEDED
result = connection.execute(
sid, 'CREATE TAG IF NOT EXISTS aa{}()'.format(num))
assert result.error_code == ttypes.ErrorCode.SUCCEEDED, result.error_msg
# test multi connection with the same session_id
test_jobs = []
with concurrent.futures.ThreadPoolExecutor(3) as executor:
for i in range(0, 3):
future = executor.submit(
do_test, get_connection(self.addr_host2, self.addr_port2),
session_id, i)
test_jobs.append(future)
for future in concurrent.futures.as_completed(test_jobs):
assert future.exception() is None, future.exception()
resp = conn2.execute(session_id, 'SHOW TAGS')
self.check_resp_succeeded(ResultSet(resp, 0))
expect_result = [['a'], ['b'], ['aa0'], ['aa1'], ['aa2']]
self.check_out_of_order_result(ResultSet(resp, 0), expect_result)
def get_result_set(cls):
resp = graphTtype.ExecutionResponse()
resp.error_code = ErrorCode.E_BAD_PERMISSION
resp.error_msg = b"Permission"
resp.comment = b"Permission"
resp.space_name = b"test"
resp.latency_in_us = 100
resp.data = cls.get_data_set()
return ResultSet(resp, 100)
def test_the_same_id_to_different_graphd(self):
def get_connection(ip, port):
ssl_config = self.client_pool._ssl_configs
try:
conn = Connection()
conn.open_SSL(ip, port, 0, ssl_config)
except Exception as ex:
assert False, 'Create connection to {}:{} failed'.format(
ip, port)
return conn
conn1 = get_connection(self.addr_host1, self.addr_port1)
conn2 = get_connection(self.addr_host2, self.addr_port2)
resp = conn1.authenticate('root', 'nebula')
session_id = resp.get_session_id()
resp = conn1.execute(
session_id,
'CREATE SPACE IF NOT EXISTS aSpace(partition_num=1, vid_type=FIXED_STRING(8));USE aSpace;'
)
self.check_resp_succeeded(ResultSet(resp, 0))
# time::WallClock::fastNowInMicroSec() is not synchronous in different process,
# so we sleep 3 seconds here and charge session
time.sleep(3)
resp = conn1.execute(session_id, 'USE aSpace;')
self.check_resp_succeeded(ResultSet(resp, 0))
time.sleep(3)
# We actually not allowed share sessions, this only for testing the scenario of transfer sessions.
resp = conn1.execute(session_id, 'CREATE TAG IF NOT EXISTS a();')
self.check_resp_succeeded(ResultSet(resp, 0))
resp = conn2.execute(session_id, 'CREATE TAG IF NOT EXISTS b();')
self.check_resp_succeeded(ResultSet(resp, 0))
def do_test(connection, sid, num):
result = connection.execute(sid, 'USE aSpace;')
assert result.error_code == ttypes.ErrorCode.SUCCEEDED
result = connection.execute(
sid, 'CREATE TAG IF NOT EXISTS aa{}()'.format(num))
assert result.error_code == ttypes.ErrorCode.SUCCEEDED, result.error_msg
# test multi connection with the same session_id
test_jobs = []
with concurrent.futures.ThreadPoolExecutor(3) as executor:
for i in range(0, 3):
future = executor.submit(
do_test, get_connection(self.addr_host2, self.addr_port2),
session_id, i)
test_jobs.append(future)
for future in concurrent.futures.as_completed(test_jobs):
assert future.exception() is None, future.exception()
resp = conn2.execute(session_id, 'SHOW TAGS')
self.check_resp_succeeded(ResultSet(resp, 0))
expect_result = [['a'], ['b'], ['aa0'], ['aa1'], ['aa2']]
self.check_out_of_order_result(ResultSet(resp, 0), expect_result)
def get_result_set(self):
resp = graphTtype.ExecutionResponse()
resp.error_code = graphTtype.ErrorCode.E_BAD_PERMISSION
resp.error_msg = b"Permission"
resp.comment = b"Permission"
resp.space_name = b"test"
resp.latency_in_us = 100
data_set = ttypes.DataSet()
data_set.column_names = [
b"col1_empty", b"col2_null", b"col3_bool", b"col4_int",
b"col5_double", b"col6_string", b"col7_list", b"col8_set",
b"col9_map", b"col10_time", b"col11_date", b"col12_datetime",
b"col13_vertex", b"col14_edge", b"col15_path"
]
row = ttypes.Row()
row.values = []
value1 = ttypes.Value()
row.values.append(value1)
value2 = ttypes.Value()
value2.set_nVal(NullType.BAD_DATA)
row.values.append(value2)
value3 = ttypes.Value()
value3.set_bVal(False)
row.values.append(value3)
value4 = ttypes.Value()
value4.set_iVal(100)
row.values.append(value4)
value5 = ttypes.Value()
value5.set_fVal(10.01)
row.values.append(value5)
value6 = ttypes.Value()
value6.set_sVal(b"hello world")
row.values.append(value6)
value7 = ttypes.Value()
str_val1 = ttypes.Value()
str_val1.set_sVal(b"word")
str_val2 = ttypes.Value()
str_val2.set_sVal(b"car")
list_val = NList()
list_val.values = [str_val1, str_val2]
value7.set_lVal(list_val)
row.values.append(value7)
value8 = ttypes.Value()
set_val = NSet()
set_val.values = set()
set_val.values.add(str_val1)
set_val.values.add(str_val2)
value8.set_uVal(set_val)
row.values.append(value8)
value9 = ttypes.Value()
map = NMap()
map.kvs = {b"a": str_val1, b"b": str_val2}
value9.set_mVal(map)
row.values.append(value9)
value10 = ttypes.Value()
value10.set_tVal(Time(10, 10, 10, 10000))
row.values.append(value10)
value11 = ttypes.Value()
value11.set_dVal(date(2020, 10, 1))
row.values.append(value11)
value12 = ttypes.Value()
value12.set_dtVal(DateTime(2020, 10, 1, 10, 10, 10, 10000))
row.values.append(value12)
value13 = ttypes.Value()
value13.set_vVal(self.get_vertex_value(b"Tom"))
row.values.append(value13)
value14 = ttypes.Value()
value14.set_eVal(self.get_edge_value(b"Tom", b"Lily"))
row.values.append(value14)
value15 = ttypes.Value()
value15.set_pVal(self.get_path_value(b"Tom", 3))
row.values.append(value15)
data_set.rows = []
data_set.rows.append(row)
resp.data = data_set
return ResultSet(resp)
