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 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(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_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_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_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_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_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_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(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_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_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
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_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_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_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)
# 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)