def test_cte_basic_parse(self): source = Source(basic_str) self.assertIsNotNone(source) parsed_source = ParsedSource(source) self.assertIsNotNone(parsed_source) self.assertEqual(basic_str, source.source()) self.assertNotEqual(basic_str, parsed_source.parsed_statements())
def test_cte_complex_parse(self): source_str = complex_query source = Source(source_str) self.assertIsNotNone(source) parsed_source = ParsedSource(source) self.assertIsNotNone(parsed_source) self.assertEqual(source_str, source.source()) self.assertNotEqual(source_str, parsed_source.parsed_statements())
def setUp(self): n_bits = 1000 seed = 10 # Generate Source object self.source = Source(n_bits, seed) # Genetare packets self.pck = self.source.generate_packet()
def test_cte_encode_matches(self): source_str = basic_str encoded_source = EncodedSource( DecomposedSource(ParsedSource(Source(source_str)))) source_str_2 = basic_whitespace_str encoded_source_2 = EncodedSource( DecomposedSource(ParsedSource(Source(source_str_2)))) self.assertIsNotNone(encoded_source_2) self.assertEqual(encoded_source.encoded_sources(), encoded_source_2.encoded_sources())
def test_cte_parse_matches(self): source_str = basic_str source = Source(source_str) parsed_source = ParsedSource(source) source_2 = Source(basic_whitespace_str) self.assertIsNotNone(source_2) parsed_source_2 = ParsedSource(source_2) self.assertIsNotNone(parsed_source_2) self.assertEqual(basic_whitespace_str, source_2.source()) self.assertNotEqual(basic_whitespace_str, parsed_source_2.parsed_statements()) self.assertEqual(parsed_source.serialize(), parsed_source_2.serialize())
def test_basic_decompose(self): decomposed_source = DecomposedSource(ParsedSource(Source(basic_str))) self.assertIsNotNone(decomposed_source) parsed_sources = decomposed_source.parsed_sources() self.assertEqual( ParsedSource(Source(cte_1)).serialize(), parsed_sources[0].serialize()) self.assertEqual( ParsedSource(Source(cte_2)).serialize(), parsed_sources[1].serialize()) self.assertEqual( ParsedSource(Source(join_clause)).serialize(), parsed_sources[2].serialize())
def test_parse(self): source_str = cte_1 source = Source(source_str) parsed = ParsedSource(source) self.assertIsNotNone(parsed) self.assertEqual(source_str, parsed.source().source()) self.assertNotEqual(source_str, parsed.parsed_statements())
def test_encode(self): source_str = cte_1 decomposed_source = DecomposedSource(ParsedSource(Source(source_str))) encoded = EncodedSource(decomposed_source) self.assertIsNotNone(encoded) self.assertEqual(decomposed_source.serialize(), encoded.decomposed_source().serialize())
def test_decompose(self): source_str = cte_1 parsed_source = ParsedSource(Source(source_str)) decomposed = DecomposedSource(parsed_source) self.assertIsNotNone(decomposed) #self.assertNotEqual(source_str, decomposed.parsed_sources()[0].source().source()) self.assertEqual(parsed_source.serialize(), decomposed.parsed_sources()[0].serialize())
def test_cte_complex_encode(self): encoded_source = EncodedSource( DecomposedSource(ParsedSource(Source(complex_query)))) self.assertIsNotNone(encoded_source) #self.assertEqual(complex_query, all_encoded_sources.parsed_sources().source()) for hash, encoded_source in zip(encoded_source.hashed_sources(), encoded_source.encoded_sources()): print(f"-----------------------------------\n" f"{hash}" f"\n-----------------------------------\n" f"{encoded_source}")
def test_apply_dependency_first_date_cached(self): self.maxDiff = None source_str = date_dim_query_sub_cached #encoded_source_root = EncodedSource.from_str(source_str, prefix="cached_") encoded_source_root = EncodedSource.from_str(source_str, prefix="cached_") datasource = DataSource(encoded_source_root) run_order = [] encoded_settings = EncodedSource.from_str(settings) encoded_date_dim = EncodedSource.from_str(planning_date_dim_table) parsed_week_dim = ParsedSource( Source(planning_week_dim_table) ).serialize( ) #.replace("planning_date_dim_table", f"`{encoded_date_dim.hashed_sources()[-1]}`") encoded_replaced_date_dim = f"WITH planning_date_dim_table AS (SELECT * FROM `{encoded_date_dim.hashed_sources()[-1]}`)\n" encoded_week_dim = EncodedSource.from_str( f"WITH planning_date_dim_table AS ({planning_date_dim_table}) {planning_week_dim_table}" ) encoded_replaced_week_dim = f"WITH planning_week_dim_table AS (SELECT * FROM `{encoded_week_dim.hashed_sources()[-1]}`)\n" replaced_weeks = ParsedSource(Source(weeks)).serialize( ) #.replace("planning_week_dim_table", f"`{encoded_replaced_week_dim.hashed_sources()[-1]}`") expected_run_order = [ encoded_date_dim.encoded_sources()[-1], encoded_replaced_date_dim + parsed_week_dim, encoded_replaced_week_dim + replaced_weeks, encoded_source_root.encoded_sources()[-1] ] already_run = {} def apply_to_encoded(hash: str, source: str, run_order: List[str] = run_order, already_run: Dict[str, str] = already_run): print(f"hash:{hash}, source:{source}") run = already_run.get(hash) if not run: already_run[hash] = source run_order.append(source) datasource.apply_dependency_first(apply_to_encoded) self.assertEqual(expected_run_order, run_order)
class SourceTest(unittest.TestCase): def setUp(self): n_bits = 1000 seed = 10 # Generate Source object self.source = Source(n_bits, seed) # Genetare packets self.pck = self.source.generate_packet() def test_n_bits(self): self.assertEqual(1000, self.source.get_n_bits()) def test_seed(self): self.assertEqual(10, self.source.get_seed()) def test_last_packet(self): self.assertTrue(np.all(self.pck == self.source.get_last_pck())) def test_calculate_error(self): # Calculate packet errors n_errors, pck_error = self.source.calculate_error(self.pck) # Assert if no errors were found self.assertEqual(0, n_errors) self.assertFalse(pck_error) # Intentionally insert bit error pck2 = np.array(self.pck, copy=True) pck2[0] = abs(pck2[0] - 1.0) # Calculate packet errors n_errors, pck_error = self.source.calculate_error(pck2) # Assert if one error was found self.assertEqual(1, n_errors) self.assertTrue(pck_error) def test_generate_packet(self): # Test packet size self.assertEqual(1000, len(self.pck)) # Test if it's just 0s and 1s self.assertTrue(np.all((self.pck == 0) | (self.pck == 1))) # Test if the number of 0s and 1s is aproximatelly equal self.assertAlmostEqual(0.5, np.mean(self.pck), delta=0.05) # Test if packets are different pck2 = self.source.generate_packet() self.assertFalse(np.all(self.pck == pck2))
def test_cte_date_dim_encode(self): source_str = date_dim_query encoded_source_root = EncodedSource( DecomposedSource(ParsedSource(Source(source_str)))) self.assertIsNotNone(encoded_source_root) #self.assertEqual(complex_query, all_encoded_sources.parsed_sources().source()) for hash, encoded_source in zip(encoded_source_root.hashed_sources(), encoded_source_root.encoded_sources()): print(f"-----------------------------------\n" f"{hash}" f"\n-----------------------------------\n" f"{encoded_source}") main_statement_encoded = EncodedSource.from_str(date_dim_select) self.assertEqual( len(main_statement_encoded.all_encoded_sources_by_name()), 1)
def test_match_whitespace_diff(self): source_str = "SELECT * FROM `universe.galaxy.system`" target_str = "SELECT * FROM `universe.galaxy.system` " source = Source(source_str) target = Source(target_str) encoded_source = EncodedSource(DecomposedSource(ParsedSource(source))) encoded_target = EncodedSource(DecomposedSource(ParsedSource(target))) self.assertIsNotNone(encoded_source) self.assertIsNotNone(encoded_target) self.assertNotEqual(source_str, target_str) self.assertNotEqual(source.source(), target.source()) self.assertEqual(encoded_source.encoded_sources(), encoded_target.encoded_sources())
def test_date_decompose(self): self.maxDiff = None decomposed_source = DecomposedSource( ParsedSource(Source(date_dim_query))) self.assertIsNotNone(decomposed_source) parsed_sources = decomposed_source.parsed_sources() self.assertEqual( ParsedSource(Source(settings)).serialize(reindent=True), parsed_sources[0].serialize(reindent=True)) self.assertEqual( ParsedSource( Source(planning_date_dim_table)).serialize(reindent=True), parsed_sources[1].serialize(reindent=True)) self.assertEqual( ParsedSource( Source(planning_week_dim_table)).serialize(reindent=True), parsed_sources[2].serialize(reindent=True)) self.assertEqual( ParsedSource(Source(weeks)).serialize(reindent=True), parsed_sources[3].serialize(reindent=True)) self.assertEqual( ParsedSource(Source(date_dim_select)).serialize(reindent=True), parsed_sources[4].serialize(reindent=True))
from src.source import Source from src.parser import Parser from src.visitor import Visitor from src.interpreter import Interpreter from src.exceptions import ( DivisionError, InvalidSyntax, UndefinedOperation, InvalidOperation, Undeclared, InvalidValue ) if __name__ == "__main__": source = Source(sys.stdin) lexer = Lexer(source) parser = Parser(source, lexer) visitor = Visitor() interpreter = Interpreter(parser, visitor) try: result = interpreter.run() print(f"Ostateczny wynik = {result}") except DivisionError as e: print("Error: Division by zero.") except InvalidSyntax as e: print( f"Error: On position: {e.position}. " f"Expected {e.expected_type}, but " f"got {e.given_type}: {e.given_value}.") except UndefinedOperation as e:
def test_cte_basic_encode(self): source_str = basic_str source = Source(source_str) encoded = EncodedSource(DecomposedSource(ParsedSource(source))) self.assertIsNotNone(encoded)
def test_source(self): source_str = cte_1 source = Source(source_str) self.assertIsNotNone(source) self.assertEqual(source_str, source.source())