def test_blocking_iterator_with_multi_paged_result(self):
self._populate_map()
statement = SqlStatement("SELECT __key FROM %s" % self.map_name)
statement.cursor_buffer_size = 1 # Each page will contain just 1 result
result = self.client.sql.execute_statement(statement)
six.assertCountEqual(self, [i for i in range(10)],
[row.get_object_with_index(0) for row in result])
def test_execute_statement_with_mismatched_params_when_sql_has_more(self):
self._populate_map()
statement = SqlStatement(
"SELECT * FROM %s WHERE __key > ? AND this > ?" % self.map_name)
statement.parameters = [5]
result = self.client.sql.execute_statement(statement)
with self.assertRaises(HazelcastSqlError):
for _ in result:
pass
def test_execute_statement_with_timeout(self):
entry_count = 100
self._populate_map(entry_count, lambda v: Student(v, v))
statement = SqlStatement("SELECT age FROM %s WHERE height < 10" %
self.map_name)
statement.timeout = 100
result = self.client.sql.execute_statement(statement)
six.assertCountEqual(self, [i for i in range(10)],
[row.get_object("age") for row in result])
def test_execute_statement_with_expected_result_type_of_update_count_when_rows_are_expected(
self, ):
self._populate_map()
statement = SqlStatement("SELECT * FROM %s" % self.map_name)
statement.expected_result_type = SqlExpectedResultType.UPDATE_COUNT
result = self.client.sql.execute_statement(statement)
with self.assertRaises(HazelcastSqlError):
for _ in result:
pass
def test_execute_statement_with_params(self):
entry_count = 20
self._populate_map(entry_count, lambda v: Student(v, v))
statement = SqlStatement(
"SELECT age FROM %s WHERE height = CAST(? AS REAL)" %
self.map_name)
statement.add_parameter(13.0)
result = self.client.sql.execute_statement(statement)
six.assertCountEqual(self, [13],
[row.get_object("age") for row in result])
def test_execute_statement_with_expected_result_type_of_rows_when_rows_are_expected(
self):
entry_count = 100
self._populate_map(entry_count, lambda v: Student(v, v))
statement = SqlStatement("SELECT age FROM %s WHERE age < 3" %
self.map_name)
statement.expected_result_type = SqlExpectedResultType.ROWS
result = self.client.sql.execute_statement(statement)
six.assertCountEqual(self, [i for i in range(3)],
[row.get_object("age") for row in result])
def test_with_statement_when_iteration_throws(self):
self._populate_map()
statement = SqlStatement("SELECT this FROM %s" % self.map_name)
statement.cursor_buffer_size = 1 # so that it doesn't close immediately
with self.assertRaises(RuntimeError):
with self.client.sql.execute_statement(statement) as result:
for _ in result:
raise RuntimeError("expected")
self.assertIsInstance(result.close(), ImmediateFuture)
def test_statement_sql(self):
valid_inputs = ["a", " a", " a "]
for valid in valid_inputs:
statement = SqlStatement(valid)
self.assertEqual(valid, statement.sql)
invalid_inputs = ["", " ", None, 1]
for invalid in invalid_inputs:
with self.assertRaises((ValueError, AssertionError)):
SqlStatement(invalid)
def execute_statement(self, query, *args, **kwargs):
if self.is_v5_or_newer_client:
return self.client.sql.execute(query, *args, **kwargs).result()
# Compatibility with 4.x clients
statement = SqlStatement(query)
for arg in args:
statement.add_parameter(arg)
for key, value in kwargs.items():
setattr(statement, key, value)
return self.client.sql.execute_statement(statement)
def test_close_when_query_is_active(self):
self._populate_map()
statement = SqlStatement("SELECT * FROM %s " % self.map_name)
statement.cursor_buffer_size = 1 # Each page will contain 1 row
result = self.client.sql.execute_statement(statement)
# Fetch couple of pages
iterator = iter(result)
next(iterator)
self.assertIsNone(result.close().result())
with self.assertRaises(HazelcastSqlError):
# Next fetch requests should fail
next(iterator)
def test_execute_statement_with_cursor_buffer_size(self):
entry_count = 50
self._populate_map(entry_count, lambda v: Student(v, v))
statement = SqlStatement("SELECT age FROM %s" % self.map_name)
statement.cursor_buffer_size = 3
result = self.client.sql.execute_statement(statement)
with patch.object(result,
"_fetch_next_page",
wraps=result._fetch_next_page) as patched:
six.assertCountEqual(self, [i for i in range(entry_count)],
[row.get_object("age") for row in result])
# -1 comes from the fact that, we don't fetch the first page
self.assertEqual(
math.ceil(float(entry_count) / statement.cursor_buffer_size) -
1, patched.call_count)
def test_execute_statement(self):
statement = SqlStatement("SOME QUERY")
with self.assertRaises(HazelcastSqlError) as cm:
self.client.sql.execute_statement(statement)
# Make sure that exception is originating from the client
self.assertNotEqual(self.member.uuid,
str(cm.exception.originating_member_uuid))
def test_iterator_with_multi_paged_result(self):
self._populate_map()
statement = SqlStatement("SELECT __key FROM %s" % self.map_name)
statement.cursor_buffer_size = 1 # Each page will contain just 1 result
result = self.client.sql.execute_statement(statement)
iterator = result.iterator().result()
rows = []
for row_future in iterator:
try:
row = row_future.result()
rows.append(row.get_object_with_index(0))
except StopIteration:
break
six.assertCountEqual(self, [i for i in range(10)], rows)
def test_execute_statement(self):
entry_count = 12
self._populate_map(entry_count, str)
statement = SqlStatement("SELECT this FROM %s" % self.map_name)
result = self.client.sql.execute_statement(statement)
six.assertCountEqual(
self,
[str(i) for i in range(entry_count)],
[row.get_object_with_index(0) for row in result],
)
def test_statement_timeout(self):
valid_inputs = [-1, 0, 15, 1.5]
for valid in valid_inputs:
statement = SqlStatement("sql")
statement.timeout = valid
self.assertEqual(valid, statement.timeout)
invalid_inputs = [-10, -100, "hey", None]
for invalid in invalid_inputs:
statement = SqlStatement("sql")
with self.assertRaises((ValueError, AssertionError)):
statement.timeout = invalid
def test_statement_cursor_buffer_size(self):
valid_inputs = [1, 10, 999999]
for valid in valid_inputs:
statement = SqlStatement("something")
statement.cursor_buffer_size = valid
self.assertEqual(valid, statement.cursor_buffer_size)
invalid_inputs = [0, -10, -99999, "hey", None, 1.0]
for invalid in invalid_inputs:
statement = SqlStatement("something")
with self.assertRaises((ValueError, AssertionError)):
statement.cursor_buffer_size = invalid
def test_execute_statement_with_copy(self):
self._populate_map()
statement = SqlStatement("SELECT __key FROM %s WHERE this >= ?" %
self.map_name)
statement.parameters = [9]
copy_statement = statement.copy()
statement.clear_parameters()
result = self.client.sql.execute_statement(copy_statement)
self.assertEqual([9], [row.get_object_with_index(0) for row in result])
result = self.client.sql.execute_statement(statement)
with self.assertRaises(HazelcastSqlError):
for _ in result:
pass
def test_statement_expected_result_type(self):
valid_inputs = [
SqlExpectedResultType.ROWS,
SqlExpectedResultType.UPDATE_COUNT,
"ROWS",
"ANY",
]
for valid in valid_inputs:
statement = SqlStatement("something")
statement.expected_result_type = valid
self.assertEqual(
try_to_get_enum_value(valid, SqlExpectedResultType),
statement.expected_result_type)
invalid_inputs = [None, 123, "hey"]
for invalid in invalid_inputs:
with self.assertRaises(TypeError):
statement = SqlStatement("something")
statement.expected_result_type = invalid
# Get the metadata associated with the row
row_metadata = row.metadata
# Get the index of the is_active column
is_active_index = row_metadata.find_column("is_active")
# Get the object with the column index
is_active = row.get_object_with_index(is_active_index)
print(name, age, is_active)
# Construct a statement object to control the properties of the query
# Special keywords __key and this can be used to refer to key and value.
# Also, a placeholder parameters can be specified
statement = SqlStatement("SELECT __key, age FROM customers WHERE name LIKE ?")
# Parameters will replace the placeholders on the server side
statement.add_parameter("Jo%")
statement.timeout = 5
with client.sql.execute_statement(statement) as result:
# Row metadata can also be retrieved from the result
row_metadata = result.get_row_metadata().result()
for row in result:
key = row.get_object("__key")
age = row.get_object("age")
print(key, age)
