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