How to use check_result method in localstack

Best Python code snippet using localstack_python

query_tests.py

Source:query_tests.py

...29 query = """30 emp = SCAN(%s);31 STORE(emp, OUTPUT);32 """ % self.emp_key33 self.check_result(query, self.emp_table)34 def test_scan_dept(self):35 query = """36 dept = SCAN(%s);37 STORE(dept, OUTPUT);38 """ % self.dept_key39 self.check_result(query, self.dept_table)40 def test_bag_comp_emit_star(self):41 query = """42 emp = SCAN(%s);43 bc = [FROM emp EMIT *];44 STORE(bc, OUTPUT);45 """ % self.emp_key46 self.check_result(query, self.emp_table)47 def test_bag_comp_emit_table_wildcard(self):48 query = """49 emp = SCAN(%s);50 bc = [FROM emp EMIT emp.*];51 STORE(bc, OUTPUT);52 """ % self.emp_key53 self.check_result(query, self.emp_table)54 def test_hybrid_emit_clause(self):55 query = """56 emp = SCAN(%s);57 dept = SCAN(%s);58 x = [FROM dept, emp as X EMIT 5, X.salary * 2 AS k, X.*, *];59 STORE(x, OUTPUT);60 """ % (self.emp_key, self.dept_key)61 expected = [(5, e[3] * 2) + e + d + e for e in self.emp_table62 for d in self.dept_table]63 self.check_result(query, collections.Counter(expected))64 salary_filter_query = """65 emp = SCAN(%s);66 rich = [FROM emp WHERE %s > 25 * 10 * 10 * (5 + 5) EMIT *];67 STORE(rich, OUTPUT);68 """69 salary_expected_result = collections.Counter(70 [x for x in FakeData.emp_table.elements() if x[3] > 25000])71 def test_bag_comp_filter_large_salary_by_name(self):72 query = TestQueryFunctions.salary_filter_query % (self.emp_key,73 'salary')74 self.check_result(query, TestQueryFunctions.salary_expected_result)75 def test_bag_comp_filter_large_salary_by_position(self):76 query = TestQueryFunctions.salary_filter_query % (self.emp_key, '$3')77 self.check_result(query, TestQueryFunctions.salary_expected_result)78 def test_bag_comp_filter_empty_result(self):79 query = """80 emp = SCAN(%s);81 poor = [FROM emp WHERE $3 < (5 * 2) EMIT *];82 STORE(poor, OUTPUT);83 """ % self.emp_key84 expected = collections.Counter()85 self.check_result(query, expected)86 def test_bag_comp_filter_column_compare_ge(self):87 query = """88 emp = SCAN(%s);89 out = [FROM emp WHERE 2 * $1 >= $0 EMIT *];90 STORE(out, OUTPUT);91 """ % self.emp_key92 expected = collections.Counter(93 [x for x in self.emp_table.elements() if 2 * x[1] >= x[0]])94 self.check_result(query, expected)95 def test_bag_comp_filter_column_compare_ge2(self):96 query = u"""97 emp = SCAN(%s);98 out = [FROM emp WHERE 2 * $1 ≥ $0 EMIT *];99 STORE(out, OUTPUT);100 """ % self.emp_key101 expected = collections.Counter(102 [x for x in self.emp_table.elements() if 2 * x[1] >= x[0]])103 self.check_result(query, expected)104 def test_bag_comp_filter_column_compare_le(self):105 query = """106 emp = SCAN(%s);107 out = [FROM emp WHERE $1 <= 2 * $0 EMIT *];108 STORE(out, OUTPUT);109 """ % self.emp_key110 expected = collections.Counter(111 [x for x in self.emp_table.elements() if x[1] <= 2 * x[0]])112 self.check_result(query, expected)113 def test_bag_comp_filter_column_compare_le2(self):114 query = u"""115 emp = SCAN(%s);116 out = [FROM emp WHERE $1 ≤ 2 * $0 EMIT *];117 STORE(out, OUTPUT);118 """ % self.emp_key119 expected = collections.Counter(120 [x for x in self.emp_table.elements() if x[1] <= 2 * x[0]])121 self.check_result(query, expected)122 def test_bag_comp_filter_column_compare_gt(self):123 query = """124 emp = SCAN(%s);125 out = [FROM emp WHERE 2 * $1 > $0 EMIT *];126 STORE(out, OUTPUT);127 """ % self.emp_key128 expected = collections.Counter(129 [x for x in self.emp_table.elements() if 2 * x[1] > x[0]])130 self.check_result(query, expected)131 def test_bag_comp_filter_column_compare_lt(self):132 query = """133 emp = SCAN(%s);134 out = [FROM emp WHERE $1 < 2 * $0 EMIT *];135 STORE(out, OUTPUT);136 """ % self.emp_key137 expected = collections.Counter(138 [x for x in self.emp_table.elements() if x[1] < 2 * x[0]])139 self.check_result(query, expected)140 def test_bag_comp_filter_column_compare_eq(self):141 query = """142 emp = SCAN(%s);143 out = [FROM emp WHERE $0 * 2 == $1 EMIT *];144 STORE(out, OUTPUT);145 """ % self.emp_key146 expected = collections.Counter(147 [x for x in self.emp_table.elements() if x[0] * 2 == x[1]])148 self.check_result(query, expected)149 def test_bag_comp_filter_column_compare_ne(self):150 query = """151 emp = SCAN(%s);152 out = [FROM emp WHERE $0 // $1 != $1 EMIT *];153 STORE(out, OUTPUT);154 """ % self.emp_key155 expected = collections.Counter(156 [x for x in self.emp_table.elements() if x[0] / x[1] != x[1]])157 self.check_result(query, expected)158 def test_bag_comp_filter_column_compare_ne2(self):159 query = """160 emp = SCAN(%s);161 out = [FROM emp WHERE $0 // $1 <> $1 EMIT *];162 STORE(out, OUTPUT);163 """ % self.emp_key164 expected = collections.Counter(165 [x for x in self.emp_table.elements() if x[0] / x[1] != x[1]])166 self.check_result(query, expected)167 def test_bag_comp_filter_column_compare_ne3(self):168 query = u"""169 emp = SCAN(%s);170 out = [FROM emp WHERE $0 // $1 ≠ $1 EMIT *];171 STORE(out, OUTPUT);172 """ % self.emp_key173 expected = collections.Counter(174 [x for x in self.emp_table.elements() if x[0] / x[1] != x[1]])175 self.check_result(query, expected)176 def test_bag_comp_filter_minus(self):177 query = """178 emp = SCAN(%s);179 out = [FROM emp WHERE $0 + -$1 == $1 EMIT *];180 STORE(out, OUTPUT);181 """ % self.emp_key182 expected = collections.Counter(183 [x for x in self.emp_table.elements() if x[0] - x[1] == x[1]])184 self.check_result(query, expected)185 def test_bag_comp_filter_and(self):186 query = """187 emp = SCAN(%s);188 out = [FROM emp WHERE salary == 25000 AND id > dept_id EMIT *];189 STORE(out, OUTPUT);190 """ % self.emp_key191 expected = collections.Counter(192 [x for x in self.emp_table.elements() if x[3] == 25000 and193 x[0] > x[1]])194 self.check_result(query, expected)195 def test_bag_comp_filter_or(self):196 query = """197 emp = SCAN(%s);198 out = [FROM emp WHERE $3 > 25 * 1000 OR id > dept_id EMIT *];199 STORE(out, OUTPUT);200 """ % self.emp_key201 expected = collections.Counter(202 [x for x in self.emp_table.elements() if x[3] > 25000 or203 x[0] > x[1]])204 self.check_result(query, expected)205 def test_bag_comp_filter_not(self):206 query = """207 emp = SCAN(%s);208 out = [FROM emp WHERE not salary > 25000 EMIT *];209 STORE(out, OUTPUT);210 """ % self.emp_key211 expected = collections.Counter(212 [x for x in self.emp_table.elements() if not x[3] > 25000])213 self.check_result(query, expected)214 def test_bag_comp_filter_or_and(self):215 query = """216 emp = SCAN(%s);217 out = [FROM emp WHERE salary == 25000 OR salary == 5000 AND218 dept_id == 1 EMIT *];219 STORE(out, OUTPUT);220 """ % self.emp_key221 expected = collections.Counter(222 [x for x in self.emp_table.elements() if x[3] == 25000 or223 (x[3] == 5000 and x[1] == 1)])224 self.check_result(query, expected)225 def test_bag_comp_filter_or_and_not(self):226 query = """227 emp = SCAN(%s);228 out = [FROM emp WHERE salary == 25000 OR NOT salary == 5000 AND229 dept_id == 1 EMIT *];230 STORE(out, OUTPUT);231 """ % self.emp_key232 expected = collections.Counter(233 [x for x in self.emp_table.elements() if x[3] == 25000 or not234 x[3] == 5000 and x[1] == 1])235 self.check_result(query, expected)236 def test_bag_comp_emit_columns(self):237 query = """238 emp = SCAN(%s);239 out = [FROM emp WHERE dept_id == 1 EMIT $2, salary AS salary];240 STORE(out, OUTPUT);241 """ % self.emp_key242 expected = collections.Counter(243 [(x[2], x[3]) for x in self.emp_table.elements() if x[1] == 1])244 self.check_result(query, expected)245 def test_bag_comp_emit_literal(self):246 query = """247 emp = SCAN(%s);248 out = [FROM emp EMIT salary, "bugga bugga"];249 STORE(out, OUTPUT);250 """ % self.emp_key251 expected = collections.Counter(252 [(x[3], "bugga bugga") for x in self.emp_table.elements()])253 self.check_result(query, expected)254 def test_bag_comp_emit_with_math(self):255 query = """256 emp = SCAN(%s);257 out = [FROM emp EMIT salary + 5000, salary - 5000, salary // 5000,258 salary * 5000];259 STORE(out, OUTPUT);260 """ % self.emp_key261 expected = collections.Counter(262 [(x[3] + 5000, x[3] - 5000, x[3] / 5000, x[3] * 5000)263 for x in self.emp_table.elements()])264 self.check_result(query, expected)265 def test_bag_comp_rename(self):266 query = """267 emp = SCAN(%s);268 out = [FROM emp EMIT name, salary * 2 AS double_salary];269 out = [FROM out WHERE double_salary > 10000 EMIT *];270 STORE(out, OUTPUT);271 """ % self.emp_key272 expected = collections.Counter(273 [(x[2], x[3] * 2) for x in self.emp_table.elements() if274 x[3] * 2 > 10000])275 self.check_result(query, expected)276 join_expected = collections.Counter(277 [('Bill Howe', 'human resources'),278 ('Dan Halperin', 'accounting'),279 ('Andrew Whitaker', 'accounting'),280 ('Shumo Chu', 'human resources'),281 ('Victor Almeida', 'accounting'),282 ('Dan Suciu', 'engineering'),283 ('Magdalena Balazinska', 'accounting')])284 def test_explicit_join_unicode(self):285 query = u"""286 emp = SCAN(%s);287 dept = SCAN(%s);288 out = JOIN(emp, dept_id, dept, id);289 out2 = [FROM out EMIT $2 AS emp_name, $5 AS dept_name];290 STORE(out2, OUTPUT);291 """ % (self.emp_key, self.dept_key)292 self.check_result(query, self.join_expected)293 def test_explicit_join(self):294 query = """295 emp = SCAN(%s);296 dept = SCAN(%s);297 out = JOIN(emp, dept_id, dept, id);298 out2 = [FROM out EMIT $2 AS emp_name, $5 AS dept_name];299 STORE(out2, OUTPUT);300 """ % (self.emp_key, self.dept_key)301 self.check_result(query, self.join_expected)302 def test_explicit_join_twocols(self):303 query = """304 query = [1 as dept_id, 25000 as salary];305 emp = SCAN({emp});306 out = JOIN(query, (dept_id, salary), emp, (dept_id, salary));307 out2 = [FROM out EMIT name];308 STORE(out2, OUTPUT);309 """.format(emp=self.emp_key)310 expected = collections.Counter([('Victor Almeida',),311 ('Magdalena Balazinska',)])312 self.check_result(query, expected)313 def test_bagcomp_join_via_names(self):314 query = """315 out = [FROM SCAN(%s) E, SCAN(%s) AS D WHERE E.dept_id == D.id316 EMIT E.name AS emp_name, D.name AS dept_name];317 STORE(out, OUTPUT);318 """ % (self.emp_key, self.dept_key)319 self.check_result(query, self.join_expected)320 def test_bagcomp_join_via_pos(self):321 query = """322 E = SCAN(%s);323 D = SCAN(%s);324 out = [FROM E, D WHERE E.$1 == D.$0325 EMIT E.name AS emp_name, D.$1 AS dept_name];326 STORE(out, OUTPUT);327 """ % (self.emp_key, self.dept_key)328 self.check_result(query, self.join_expected)329 def test_two_column_join(self):330 query = """331 D = [1 as dept_id, 25000 as salary];332 out = [FROM D, SCAN({emp}) E333 WHERE E.dept_id == D.dept_id AND E.salary == D.salary334 EMIT E.name AS emp_name];335 STORE(out, OUTPUT);336 """.format(emp=self.emp_key)337 expected = collections.Counter([('Victor Almeida',),338 ('Magdalena Balazinska',)])339 self.check_result(query, expected)340 def test_join_with_select(self):341 query = """342 out = [FROM SCAN(%s) AS D, SCAN(%s) E343 WHERE E.dept_id == D.id AND E.salary < 6000344 EMIT E.name AS emp_name, D.name AS dept_name];345 STORE(out, OUTPUT);346 """ % (self.dept_key, self.emp_key)347 expected = collections.Counter([('Andrew Whitaker', 'accounting'),348 ('Shumo Chu', 'human resources')])349 self.check_result(query, expected)350 def test_join_with_reordering(self):351 # Try both FROM orders of the query and verify they both get the352 # correct answer.353 query = """354 out = [FROM SCAN({d}) AS D, SCAN({e}) E355 WHERE E.dept_id == D.id AND E.salary < 6000356 EMIT E.name, D.id];357 STORE(out, OUTPUT);358 """.format(d=self.dept_key, e=self.emp_key)359 expected = collections.Counter([('Andrew Whitaker', 1),360 ('Shumo Chu', 2)])361 self.check_result(query, expected)362 # Swap E and D363 query = """364 out = [FROM SCAN({e}) E, SCAN({d}) AS D365 WHERE E.dept_id == D.id AND E.salary < 6000366 EMIT E.name, D.id];367 STORE(out, OUTPUT);368 """.format(d=self.dept_key, e=self.emp_key)369 expected = collections.Counter([('Andrew Whitaker', 1),370 ('Shumo Chu', 2)])371 self.check_result(query, expected)372 def test_sql_join(self):373 """SQL-style select-from-where join"""374 query = """375 E = SCAN(%s);376 D = SCAN(%s);377 out = SELECT E.name, D.name FROM E, D WHERE E.dept_id = D.id;378 STORE(out, OUTPUT);379 """ % (self.emp_key, self.dept_key)380 self.check_result(query, self.join_expected)381 def test_bagcomp_nested_sql(self):382 """Test nesting SQL inside a bag comprehension"""383 query = """384 out = [FROM (SELECT name, salary385 FROM SCAN(%s) AS X386 WHERE salary > 5000) AS Y387 WHERE salary < 80000388 EMIT *];389 STORE(out, OUTPUT);390 """ % (self.emp_key,)391 tuples = [(e[2], e[3]) for e in self.emp_table.elements()392 if e[3] < 80000 and e[3] > 5000]393 expected = collections.Counter(tuples)394 self.check_result(query, expected)395 def test_sql_nested_sql(self):396 """Test nesting SQL inside SQL"""397 query = """398 out = SELECT Y.name, Y.salary399 FROM (SELECT name, salary400 FROM SCAN(%s) AS X401 WHERE salary > 5000) AS Y402 WHERE Y.salary < 80000;403 STORE(out, OUTPUT);404 """ % (self.emp_key,)405 tuples = [(e[2], e[3]) for e in self.emp_table.elements()406 if e[3] < 80000 and e[3] > 5000]407 expected = collections.Counter(tuples)408 self.check_result(query, expected)409 def test_sql_nested_bagcomp(self):410 """Test nesting a bag comprehension inside SQL"""411 query = """412 out = SELECT Y.name, Y.salary FROM413 [FROM SCAN(%s) AS X WHERE salary > 5000 EMIT X.*] AS Y414 WHERE Y.salary < 80000;415 STORE(out, OUTPUT);416 """ % (self.emp_key,)417 tuples = [(e[2], e[3]) for e in self.emp_table.elements()418 if e[3] < 80000 and e[3] > 5000]419 expected = collections.Counter(tuples)420 self.check_result(query, expected)421 def test_bagcomp_projection(self):422 """Test that column names are preserved across projection."""423 query = """424 E = SCAN(%s);425 F = [FROM E EMIT $2];426 out = [FROM F EMIT name];427 STORE(out, OUTPUT);428 """ % (self.emp_key,)429 tpls = [tuple([x[2]]) for x in self.emp_table]430 expected = collections.Counter(tpls)431 self.check_result(query, expected)432 def test_bagcomp_no_column_name(self):433 """Test that the system handles an omitted output column name."""434 query = """435 E = SCAN(%s);436 F = [FROM E EMIT salary*E.salary];437 out = [FROM F EMIT $0];438 STORE(out, OUTPUT);439 """ % (self.emp_key,)440 tpls = [tuple([x[3] * x[3]]) for x in self.emp_table]441 expected = collections.Counter(tpls)442 self.check_result(query, expected)443 def test_explicit_cross(self):444 query = """445 out = CROSS(SCAN(%s), SCAN(%s));446 STORE(out, OUTPUT);447 """ % (self.emp_key, self.dept_key)448 tuples = [e + d for e in self.emp_table.elements() for449 d in self.dept_table.elements()]450 expected = collections.Counter(tuples)451 self.check_result(query, expected)452 def test_bagcomp_cross(self):453 query = """454 out = [FROM SCAN(%s) E, SCAN(%s) AS D EMIT *];455 STORE(out, OUTPUT);456 """ % (self.emp_key, self.dept_key)457 tuples = [e + d for e in self.emp_table.elements() for458 d in self.dept_table.elements()]459 expected = collections.Counter(tuples)460 self.check_result(query, expected)461 def test_distinct(self):462 query = """463 out = DISTINCT([FROM SCAN(%s) AS X EMIT salary]);464 STORE(out, OUTPUT);465 """ % self.emp_key466 expected = collections.Counter([(25000,), (5000,), (90000,)])467 self.check_result(query, expected)468 def test_sql_distinct(self):469 query = """470 out = SELECT DISTINCT salary AS salary FROM SCAN(%s) AS X;471 STORE(out, OUTPUT);472 """ % self.emp_key473 expected = collections.Counter(set([(x[3],) for x in self.emp_table]))474 self.check_result(query, expected)475 def test_sql_repeated(self):476 query = """477 out = SELECT salary AS salary FROM SCAN(%s) AS X;478 STORE(out, OUTPUT);479 """ % self.emp_key480 expected = collections.Counter([(x[3],) for x in self.emp_table])481 self.check_result(query, expected)482 def test_limit(self):483 query = """484 out = LIMIT(SCAN(%s), 3);485 STORE(out, OUTPUT);486 """ % self.emp_key487 result = self.execute_query(query)488 self.assertEquals(len(result), 3)489 def test_sql_limit(self):490 query = """491 out = SELECT * FROM SCAN(%s) as X LIMIT 3;492 STORE(out, OUTPUT);493 """ % self.emp_key494 result = self.execute_query(query)495 self.assertEquals(len(result), 3)496 def test_table_literal_boolean(self):497 query = """498 X = [truE as MyTrue, FaLse as MyFalse];499 Y = [FROM scan(%s) as E, X where X.MyTrue emit *];500 STORE(Y, OUTPUT);501 """ % self.emp_key502 res = [x + (True, False) for x in self.emp_table]503 self.check_result(query, collections.Counter(res))504 def test_table_literal_scalar_expression(self):505 query = """506 X = [FROM ["Andrew", (50 * (500 + 500)) AS salary] Z EMIT salary];507 STORE(X, OUTPUT);508 """509 expected = collections.Counter([(50000,)])510 self.check_result(query, expected)511 def test_table_literal_unbox(self):512 query = """513 A = [1 AS one, 2 AS two, 3 AS three];514 B = [1 AS one, 2 AS two, 3 AS three];515 C = [*A.two * *B.three];516 STORE(C, OUTPUT);517 """518 expected = collections.Counter([(6,)])519 self.check_result(query, expected)520 def test_unbox_from_where_single(self):521 query = """522 TH = [25 * 1000];523 emp = SCAN(%s);524 out = [FROM emp WHERE $3 > *TH EMIT *];525 STORE(out, OUTPUT);526 """ % self.emp_key527 expected = collections.Counter(528 [x for x in self.emp_table.elements() if x[3] > 25000])529 self.check_result(query, expected)530 def test_unbox_from_where_multi(self):531 query = """532 TWO = [2];533 FOUR = [4];534 EIGHT = [8];535 emp = SCAN(%s);536 out = [FROM emp WHERE *EIGHT == *TWO**FOUR EMIT *];537 STORE(out, OUTPUT);538 """ % self.emp_key539 self.check_result(query, self.emp_table)540 def test_unbox_from_where_nary_name(self):541 query = """542 _CONST = [25 AS twenty_five, 1000 AS thousand];543 emp = SCAN(%s);544 out = [FROM emp WHERE salary == *_CONST.twenty_five *545 *_CONST.thousand EMIT *];546 STORE(out, OUTPUT);547 """ % self.emp_key548 expected = collections.Counter(549 [x for x in self.emp_table.elements() if x[3] == 25000])550 self.check_result(query, expected)551 def test_unbox_from_where_nary_pos(self):552 query = """553 _CONST = [25 AS twenty_five, 1000 AS thousand];554 emp = SCAN(%s);555 out = [FROM emp WHERE salary == *_CONST.$0 *556 *_CONST.$1 EMIT *];557 STORE(out, OUTPUT);558 """ % self.emp_key559 expected = collections.Counter(560 [x for x in self.emp_table.elements() if x[3] == 25000])561 self.check_result(query, expected)562 def test_unbox_from_emit_single(self):563 query = """564 THOUSAND = [1000];565 emp = SCAN(%s);566 out = [FROM emp EMIT salary * *THOUSAND AS salary];567 STORE(out, OUTPUT);568 """ % self.emp_key569 expected = collections.Counter(570 [(x[3] * 1000,) for x in self.emp_table.elements()])571 self.check_result(query, expected)572 def test_unbox_kitchen_sink(self):573 query = """574 C1 = [25 AS a, 100 AS b];575 C2 = [50 AS a, 1000 AS b];576 emp = SCAN(%s);577 out = [FROM emp WHERE salary==*C1.a * *C2.b OR $3==*C1.b * *C2578 EMIT dept_id * *C1.b // *C2.a];579 STORE(out, OUTPUT);580 """ % self.emp_key581 expected = collections.Counter(582 [(x[1] * 2,) for x in self.emp_table.elements() if583 x[3] == 5000 or x[3] == 25000])584 self.check_result(query, expected)585 def test_unbox_arbitrary_expression(self):586 query = """587 emp = SCAN(%s);588 dept = SCAN(%s);589 out = [FROM emp, COUNTALL(dept) as size WHERE id > *size EMIT emp.id];590 STORE(out, OUTPUT);591 """ % (self.emp_key, self.dept_key)592 expected = collections.Counter(593 [(x[0],) for x in self.emp_table.elements() if594 x[0] > len(self.dept_table)])595 self.check_result(query, expected)596 def test_inline_table_literal(self):597 query = """598 emp = SCAN(%s);599 dept = SCAN(%s);600 out = [FROM emp, [1,2,3] as tl WHERE id > tl.$2 EMIT emp.id];601 STORE(out, OUTPUT);602 """ % (self.emp_key, self.dept_key)603 expected = collections.Counter(604 [(x[0],) for x in self.emp_table.elements() if605 x[0] > 3])606 self.check_result(query, expected)607 def __aggregate_expected_result(self, apply_func, grouping_col=1,608 agg_col=3):609 result_dict = collections.defaultdict(list)610 for t in self.emp_table.elements():611 result_dict[t[grouping_col]].append(t[agg_col])612 tuples = [(key, apply_func(values)) for key, values in613 result_dict.iteritems()]614 return collections.Counter(tuples)615 def test_max(self):616 query = """617 out = [FROM SCAN(%s) AS X EMIT dept_id, MAX(salary)];618 STORE(out, OUTPUT);619 """ % self.emp_key620 self.check_result(query, self.__aggregate_expected_result(max))621 def test_min(self):622 query = """623 out = [FROM SCAN(%s) AS X EMIT dept_id, MIN(salary)];624 STORE(out, OUTPUT);625 """ % self.emp_key626 self.check_result(query, self.__aggregate_expected_result(min))627 def test_sum(self):628 query = """629 out = [FROM SCAN(%s) as X EMIT dept_id, SUM(salary)];630 STORE(out, OUTPUT);631 """ % self.emp_key632 self.check_result(query, self.__aggregate_expected_result(sum))633 def test_avg(self):634 query = """635 out = [FROM SCAN(%s) AS X EMIT dept_id, AVG(salary)];636 STORE(out, OUTPUT);637 """ % self.emp_key638 def avg(it):639 sum = 0640 cnt = 0641 for val in it:642 sum += val643 cnt += 1644 return sum / cnt645 self.check_result(query, self.__aggregate_expected_result(avg))646 self.check_result(query, self.__aggregate_expected_result(avg),647 test_logical=True)648 def test_stdev(self):649 query = """650 out = [FROM SCAN(%s) AS X EMIT STDEV(salary)];651 STORE(out, OUTPUT);652 """ % self.emp_key653 res = self.execute_query(query)654 tp = res.elements().next()655 self.assertAlmostEqual(tp[0], 34001.8006726)656 res = self.execute_query(query, test_logical=True)657 tp = res.elements().next()658 self.assertAlmostEqual(tp[0], 34001.8006726)659 def test_count(self):660 query = """661 out = [FROM SCAN(%s) AS X EMIT dept_id, COUNT(salary)];662 STORE(out, OUTPUT);663 """ % self.emp_key664 self.check_result(query, self.__aggregate_expected_result(len))665 self.check_result(query, self.__aggregate_expected_result(len),666 test_logical=True)667 def test_countall(self):668 query = """669 out = [FROM SCAN(%s) AS X EMIT dept_id, COUNTALL()];670 STORE(out, OUTPUT);671 """ % self.emp_key672 self.check_result(query, self.__aggregate_expected_result(len))673 self.check_result(query, self.__aggregate_expected_result(len),674 test_logical=True)675 def test_count_star(self):676 query = """677 out = [FROM SCAN(%s) AS X EMIT dept_id, COUNT(*)];678 STORE(out, OUTPUT);679 """ % self.emp_key680 self.check_result(query, self.__aggregate_expected_result(len))681 self.check_result(query, self.__aggregate_expected_result(len),682 test_logical=True)683 def test_count_star_sql(self):684 query = """685 out = SELECT dept_id, COUNT(*) FROM SCAN(%s) AS X;686 STORE(out, OUTPUT);687 """ % self.emp_key688 self.check_result(query, self.__aggregate_expected_result(len))689 self.check_result(query, self.__aggregate_expected_result(len),690 test_logical=True)691 def test_max_reversed(self):692 query = """693 out = [FROM SCAN(%s) AS X EMIT MAX(salary) AS max_salary, dept_id];694 STORE(out, OUTPUT);695 """ % self.emp_key696 ex = self.__aggregate_expected_result(max)697 ex = collections.Counter([(y, x) for (x, y) in ex])698 self.check_result(query, ex)699 self.check_result(query, ex, test_logical=True)700 def test_compound_aggregate(self):701 query = """702 out = [FROM SCAN(%s) AS X703 EMIT (2 * (MAX(salary) - MIN(salary))) AS range,704 dept_id AS did];705 out = [FROM out EMIT did AS dept_id, range AS rng];706 STORE(out, OUTPUT);707 """ % self.emp_key708 result_dict = collections.defaultdict(list)709 for t in self.emp_table.elements():710 result_dict[t[1]].append(t[3])711 tuples = [(key, 2 * (max(values) - min(values))) for key, values in712 result_dict.iteritems()]713 expected = collections.Counter(tuples)714 self.check_result(query, expected)715 self.check_result(query, expected, test_logical=True)716 def test_aggregate_with_unbox(self):717 query = """718 C = [1 AS one, 2 AS two];719 out = [FROM SCAN(%s) AS X720 EMIT MAX(*C.two * salary) - MIN( *C.$1 * salary) AS range,721 dept_id AS did];722 out = [FROM out EMIT did AS dept_id, range AS rng];723 STORE(out, OUTPUT);724 """ % self.emp_key725 result_dict = collections.defaultdict(list)726 for t in self.emp_table.elements():727 result_dict[t[1]].append(2 * t[3])728 tuples = [(key, (max(values) - min(values))) for key, values in729 result_dict.iteritems()]730 expected = collections.Counter(tuples)731 self.check_result(query, expected)732 self.check_result(query, expected, test_logical=True)733 def test_nary_groupby(self):734 query = """735 out = [FROM SCAN(%s) AS X EMIT dept_id, salary, COUNT(name)];736 STORE(out, OUTPUT);737 """ % self.emp_key738 result_dict = collections.defaultdict(list)739 for t in self.emp_table.elements():740 result_dict[(t[1], t[3])].append(t[2])741 tuples = [key + (len(values),)742 for key, values in result_dict.iteritems()]743 expected = collections.Counter(tuples)744 self.check_result(query, expected)745 def test_empty_groupby(self):746 query = """747 out = [FROM SCAN(%s) AS X EMIT MAX(salary), COUNT($0), MIN(dept_id*4)];748 STORE(out, OUTPUT);749 """ % self.emp_key750 expected = collections.Counter([(90000, len(self.emp_table), 4)])751 self.check_result(query, expected)752 def test_compound_groupby(self):753 query = """754 out = [FROM SCAN(%s) AS X EMIT id+dept_id, AVG(salary), COUNT(salary)];755 STORE(out, OUTPUT);756 """ % self.emp_key757 result_dict = collections.defaultdict(list)758 for t in self.emp_table.elements():759 result_dict[t[0] + t[1]].append(t[3])760 tuples1 = [(key, sum(values), len(values)) for key, values761 in result_dict.iteritems()]762 tuples2 = [(t[0], t[1] / t[2], t[2]) for t in tuples1]763 expected = collections.Counter(tuples2)764 self.check_result(query, expected)765 def test_impure_aggregate_colref(self):766 """Test of aggregate column that refers to a grouping column"""767 query = """768 out = [FROM SCAN(%s) AS X EMIT769 ( X.dept_id + (MAX(X.salary) - MIN(X.salary))) AS val,770 X.dept_id AS did];771 out = [FROM out EMIT did AS dept_id, val AS rng];772 STORE(out, OUTPUT);773 """ % self.emp_key774 result_dict = collections.defaultdict(list)775 for t in self.emp_table.elements():776 result_dict[t[1]].append(t[3])777 tuples = [(key, key + (max(values) - min(values))) for key, values in778 result_dict.iteritems()]779 expected = collections.Counter(tuples)780 self.check_result(query, expected)781 def test_impure_aggregate_unbox(self):782 """Test of an aggregate column that contains an unbox."""783 query = """784 TWO = [2];785 out = [FROM SCAN(%s) AS X786 EMIT (*TWO * (MAX(salary) - MIN(salary))) AS range,787 dept_id AS did];788 out = [FROM out EMIT did AS dept_id, range AS rng];789 STORE(out, OUTPUT);790 """ % self.emp_key791 result_dict = collections.defaultdict(list)792 for t in self.emp_table.elements():793 result_dict[t[1]].append(t[3])794 tuples = [(key, 2 * (max(values) - min(values))) for key, values in795 result_dict.iteritems()]796 expected = collections.Counter(tuples)797 self.check_result(query, expected)798 def test_aggregate_illegal_colref(self):799 query = """800 out = [FROM SCAN(%s) AS X EMIT801 X.dept_id + COUNT(X.salary) AS val];802 STORE(out, OUTPUT);803 """ % self.emp_key804 with self.assertRaises(raco.myrial.groupby.NonGroupedAccessException): # noqa805 self.check_result(query, None)806 def test_nested_aggregates_are_illegal(self):807 query = """808 out = [FROM SCAN(%s) AS X809 EMIT id+dept_id, MIN(53 + MAX(salary)) AS foo];810 STORE(out, OUTPUT);811 """ % self.emp_key812 with self.assertRaises(NestedAggregateException):813 self.check_result(query, collections.Counter())814 def test_standalone_countall(self):815 query = """816 out = COUNTALL(SCAN(%s));817 STORE(out, OUTPUT);818 """ % self.emp_key819 expected = collections.Counter([(len(self.emp_table),)])820 self.check_result(query, expected)821 def test_multiway_bagcomp_with_unbox(self):822 """Return all employees in accounting making less than 30000"""823 query = """824 Salary = [30000];825 Dept = ["accounting"];826 out = [FROM SCAN(%s) AS E, SCAN(%s) AS D827 WHERE E.dept_id == D.id AND D.name == *Dept828 AND E.salary < *Salary EMIT E.$2 AS name];829 STORE(out, OUTPUT);830 """ % (self.emp_key, self.dept_key)831 expected = collections.Counter([832 ("Andrew Whitaker",),833 ("Victor Almeida",),834 ("Magdalena Balazinska",)])835 self.check_result(query, expected)836 def test_duplicate_bagcomp_aliases_are_illegal(self):837 query = """838 X = SCAN(%s);839 out = [FROM X, X EMIT *];840 STORE(out, OUTPUT);841 """ % (self.emp_key,)842 with self.assertRaises(interpreter.DuplicateAliasException):843 self.check_result(query, collections.Counter())844 def test_bagcomp_column_index_out_of_bounds(self):845 query = """846 E = SCAN(%s);847 D = SCAN(%s);848 out = [FROM E, D WHERE E.$1 == D.$77849 EMIT E.name AS emp_name, D.$1 AS dept_name];850 STORE(out, OUTPUT);851 """ % (self.emp_key, self.dept_key)852 with self.assertRaises(ColumnIndexOutOfBounds):853 self.check_result(query, collections.Counter())854 def test_abs(self):855 query = """856 out = [FROM SCAN(%s) AS X EMIT id, ABS(val)];857 STORE(out, OUTPUT);858 """ % self.numbers_key859 expected = collections.Counter(860 [(a, abs(b)) for a, b in self.numbers_table.elements()])861 self.check_result(query, expected)862 def test_ceil(self):863 query = """864 out = [FROM SCAN(%s) AS X EMIT id, CEIL(val)];865 STORE(out, OUTPUT);866 """ % self.numbers_key867 expected = collections.Counter(868 [(a, math.ceil(b)) for a, b in self.numbers_table.elements()])869 self.check_result(query, expected)870 def test_cos(self):871 query = """872 out = [FROM SCAN(%s) AS X EMIT id, COS(val)];873 STORE(out, OUTPUT);874 """ % self.numbers_key875 expected = collections.Counter(876 [(a, math.cos(b)) for a, b in self.numbers_table.elements()])877 self.check_result(query, expected)878 def test_floor(self):879 query = """880 out = [FROM SCAN(%s) AS X EMIT id, FLOOR(val)];881 STORE(out, OUTPUT);882 """ % self.numbers_key883 expected = collections.Counter(884 [(a, math.floor(b)) for a, b in self.numbers_table.elements()])885 self.check_result(query, expected)886 def test_log(self):887 query = """888 out = [FROM SCAN(%s) AS X WHERE val > 0 EMIT id, LOG(val)];889 STORE(out, OUTPUT);890 """ % self.numbers_key891 expected = collections.Counter(892 [(a, math.log(b)) for a, b in self.numbers_table.elements()893 if b > 0])894 self.check_result(query, expected)895 def test_sin(self):896 query = """897 out = [FROM SCAN(%s) AS X EMIT id, SIN(val)];898 STORE(out, OUTPUT);899 """ % self.numbers_key900 expected = collections.Counter(901 [(a, math.sin(b)) for a, b in self.numbers_table.elements()])902 self.check_result(query, expected)903 def test_sqrt(self):904 query = """905 out = [FROM SCAN(%s) X WHERE val >= 0 EMIT id, SQRT(val)];906 STORE(out, OUTPUT);907 """ % self.numbers_key908 expected = collections.Counter(909 [(a, math.sqrt(b)) for a, b in self.numbers_table.elements()910 if b >= 0])911 self.check_result(query, expected)912 def test_tan(self):913 query = """914 out = [FROM SCAN(%s) AS X EMIT id, TAN(val)];915 STORE(out, OUTPUT);916 """ % self.numbers_key917 expected = collections.Counter(918 [(a, math.tan(b)) for a, b in self.numbers_table.elements()])919 self.check_result(query, expected)920 def test_md5(self):921 query = """922 out = [FROM SCAN(%s) AS X EMIT id, md5(name)];923 STORE(out, OUTPUT);924 """ % self.emp_key925 def md5_as_long(x):926 m = md5.new()927 m.update(x)928 return int(m.hexdigest(), 16) >> 64929 expected = collections.Counter(930 [(x[0], md5_as_long(x[2])) for x in self.emp_table.elements()])931 self.check_result(query, expected)932 def test_pow(self):933 query = """934 THREE = [3];935 out = [FROM SCAN(%s) X EMIT id, POW(X.val, *THREE)];936 STORE(out, OUTPUT);937 """ % self.numbers_key938 expected = collections.Counter(939 [(a, pow(b, 3)) for a, b in self.numbers_table.elements()])940 self.check_result(query, expected)941 def test_no_such_relation(self):942 query = """943 out = [FROM SCAN(foo:bar:baz) x EMIT id, TAN(val)];944 STORE(out, OUTPUT);945 """946 with self.assertRaises(NoSuchRelationException):947 self.check_result(query, collections.Counter())948 def test_bad_relation_name(self):949 query = """950 y = empty(a:int);951 z = [from s y -- bug: s does not exist952 emit y.a];953 store(z, debug);954 """955 with self.assertRaises(NoSuchRelationException):956 self.check_result(query, collections.Counter())957 def test_bad_alias(self):958 query = """959 y = empty(a:int);960 z = [from y s -- bug: extra s961 emit y.a];962 store(z, debug);963 """964 with self.assertRaises(NoSuchRelationException):965 self.check_result(query, collections.Counter())966 def test_bad_alias_wildcard(self):967 query = """968 y = empty(a:int);969 z = [from y s -- bug: errant s970 emit y.*];971 store(z, debug);972 """973 with self.assertRaises(NoSuchRelationException):974 self.check_result(query, collections.Counter())975 def test_scan_error(self):976 query = """977 out = [FROM SCAN(%s) AS X EMIT id, !!!FROG(val)];978 STORE(out, OUTPUT);979 """ % self.emp_key980 with self.assertRaises(MyrialCompileException):981 self.check_result(query, collections.Counter())982 def test_relation_scope_error(self):983 query = """984 out = [FROM EMPTY(x:INT) AS X EMIT z.*];985 STORE(out, OUTPUT);986 """987 with self.assertRaises(NoSuchRelationException):988 self.check_result(query, collections.Counter())989 def test_relation_scope_error2(self):990 query = """991 z = EMPTY(z:INT);992 out = [FROM EMPTY(x:INT) AS X EMIT z.*];993 STORE(out, OUTPUT);994 """995 with self.assertRaises(NoSuchRelationException):996 self.check_result(query, collections.Counter())997 def test_parse_error(self):998 query = """999 out = [FROM SCAN(%s) AS X EMIT $(val)];1000 STORE(out, OUTPUT);1001 """ % self.emp_key1002 with self.assertRaises(MyrialCompileException):1003 self.check_result(query, collections.Counter())1004 def test_no_such_udf(self):1005 query = """1006 out = [FROM SCAN(%s) AS X EMIT FooFunction(X.salary)];1007 STORE(out, OUTPUT);1008 """ % self.emp_key1009 with self.assertRaises(NoSuchFunctionException):1010 self.check_result(query, collections.Counter())1011 def test_reserved_udf(self):1012 query = """1013 DEF avg(x, y): (x + y) / 2;1014 out = [FROM SCAN(%s) AS X EMIT avg(X.salary)];1015 STORE(out, OUTPUT);1016 """ % self.emp_key1017 with self.assertRaises(ReservedTokenException):1018 self.check_result(query, collections.Counter())1019 def test_duplicate_udf(self):1020 query = """1021 DEF foo(x, y): x + y;1022 DEF bar(): 7;1023 DEF foo(x): -1 * x;1024 out = [FROM SCAN(%s) AS X EMIT foo(X.salary)];1025 STORE(out, OUTPUT);1026 """ % self.emp_key1027 with self.assertRaises(DuplicateFunctionDefinitionException):1028 self.check_result(query, collections.Counter())1029 def test_invalid_argument_udf(self):1030 query = """1031 DEF Foo(x, y): cos(x) * sin(y);1032 out = [FROM SCAN(%s) AS X EMIT Foo(X.salary)];1033 STORE(out, OUTPUT);1034 """ % self.emp_key1035 with self.assertRaises(InvalidArgumentList):1036 self.check_result(query, collections.Counter())1037 def test_undefined_variable_udf(self):1038 query = """1039 DEF Foo(x, y): cos(x) * sin(z);1040 out = [FROM SCAN(%s) AS X EMIT Foo(X.salary)];1041 STORE(out, OUTPUT);1042 """ % self.emp_key1043 with self.assertRaises(UndefinedVariableException):1044 self.check_result(query, collections.Counter())1045 def test_duplicate_variable_udf(self):1046 query = """1047 DEF Foo(x, x): cos(x) * sin(x);1048 out = [FROM SCAN(%s) AS X EMIT Foo(X.salary, X.dept_id)];1049 STORE(out, OUTPUT);1050 """ % self.emp_key1051 with self.assertRaises(DuplicateVariableException):1052 self.check_result(query, collections.Counter())1053 def test_nary_udf(self):1054 query = """1055 DEF Foo(a,b): [a + b, a - b];1056 out = [FROM SCAN(%s) AS X EMIT id, Foo(salary, dept_id) as [x, y]];1057 STORE(out, OUTPUT);1058 """ % self.emp_key1059 expected = collections.Counter([(t[0], t[1] + t[3], t[3] - t[1])1060 for t in self.emp_table])1061 self.check_result(query, expected)1062 def test_nary_udf_name_count(self):1063 query = """1064 DEF Foo(a,b): [a + b, a - b];1065 out = [FROM SCAN(%s) AS X EMIT id, Foo(salary, dept_id) as [x, y, z]];1066 STORE(out, OUTPUT);1067 """ % self.emp_key1068 with self.assertRaises(IllegalColumnNamesException):1069 self.check_result(query, None)1070 def test_nary_udf_illegal_nesting(self):1071 query = """1072 DEF Foo(x): [x + 3, x - 3];1073 DEF Bar(a,b): [Foo(x), Foo(b)];1074 out = [FROM SCAN(%s) AS X EMIT id, Bar(salary, dept_id) as [x, y]];1075 STORE(out, OUTPUT);1076 """ % self.emp_key1077 with self.assertRaises(NestedTupleExpressionException):1078 self.check_result(query, None)1079 def test_nary_udf_illegal_wildcard(self):1080 query = """1081 DEF Foo(x): [x + 3, *];1082 out = [FROM SCAN(%s) AS X EMIT id, Foo(salary, dept_id) as [x, y]];1083 STORE(out, OUTPUT);1084 """ % self.emp_key1085 with self.assertRaises(IllegalWildcardException):1086 self.check_result(query, None)1087 def test_triangle_udf(self):1088 query = """1089 DEF Triangle(a,b): (a*b)//2;1090 out = [FROM SCAN(%s) AS X EMIT id, Triangle(X.salary, dept_id) AS t];1091 STORE(out, OUTPUT);1092 """ % self.emp_key1093 expected = collections.Counter([(t[0], t[1] * t[3] / 2) for t in self.emp_table]) # noqa1094 self.check_result(query, expected)1095 def test_noop_udf(self):1096 expr = "30 + 15 // 7 + -45"1097 query = """1098 DEF Noop(): %s;1099 out = [Noop() AS t];1100 STORE(out, OUTPUT);1101 """ % expr1102 val = eval(expr)1103 expected = collections.Counter([(val,)])1104 self.check_result(query, expected)1105 def test_const(self):1106 expr = "30 + 15 // 7 + -45"1107 query = """1108 CONST myconstant: %s;1109 out = [myconstant AS t];1110 STORE(out, OUTPUT);1111 """ % expr1112 val = eval(expr)1113 expected = collections.Counter([(val,)])1114 self.check_result(query, expected)1115 def test_composition_udf(self):1116 query = """1117 DEF Add7(x): x + 7;1118 DEF Add6(x): x + 6;1119 out = [FROM SCAN(%s) AS X EMIT id, Add6(Add7(Add6(X.salary)))];1120 STORE(out, OUTPUT);1121 """ % self.emp_key1122 expected = collections.Counter([(t[0], t[3] + 19)1123 for t in self.emp_table])1124 self.check_result(query, expected)1125 def test_nested_udf(self):1126 query = """1127 DEF Add7(x): x + 7;1128 DEF Add10(x): Add7(x) + 3;1129 out = [FROM SCAN(%s) AS X EMIT id, Add10(X.salary)];1130 STORE(out, OUTPUT);1131 """ % self.emp_key1132 expected = collections.Counter([(t[0], t[3] + 10)1133 for t in self.emp_table])1134 self.check_result(query, expected)1135 def test_regression_150(self):1136 """Repeated invocation of a UDF."""1137 query = """1138 DEF transform(x): pow(10, x/pow(2,16)*3.5);1139 out = [FROM SCAN(%s) AS X EMIT id, transform(salary),1140 transform(dept_id)];1141 STORE(out, OUTPUT);1142 """ % self.emp_key1143 def tx(x):1144 return pow(10, float(x) / pow(2, 16) * 3.5)1145 expected = collections.Counter([(t[0], tx(t[3]), tx(t[1]))1146 for t in self.emp_table])1147 self.check_result(query, expected)1148 def test_safediv_2_function(self):1149 query = """1150 out = [FROM SCAN(%s) AS X EMIT SafeDiv(X.salary,X.dept_id-1)];1151 STORE(out, OUTPUT);1152 """ % self.emp_key1153 expected = collections.Counter(1154 [(t[3] / (t[1] - 1) if t[1] - 1 > 0 else 0,)1155 for t in self.emp_table])1156 self.check_result(query, expected)1157 def test_safediv_3_function(self):1158 query = """1159 out = [FROM SCAN(%s) AS X EMIT SafeDiv(X.salary,X.dept_id-1,42)];1160 STORE(out, OUTPUT);1161 """ % self.emp_key1162 expected = collections.Counter(1163 [(t[3] / (t[1] - 1) if t[1] - 1 > 0 else 42,)1164 for t in self.emp_table])1165 self.check_result(query, expected)1166 def test_answer_to_everything_function(self):1167 query = """1168 out = [TheAnswerToLifeTheUniverseAndEverything()];1169 STORE(out, OUTPUT);1170 """1171 expected = collections.Counter([(42,)])1172 self.check_result(query, expected)1173 def test_least_function(self):1174 query = """1175 out = [FROM SCAN(%s) AS X EMIT least(X.id,X.dept_id,1)];1176 STORE(out, OUTPUT);1177 """ % self.emp_key1178 expected = collections.Counter(1179 [(min(t[0], t[1], 1),)1180 for t in self.emp_table])1181 self.check_result(query, expected)1182 def test_greatest_function(self):1183 query = """1184 out = [FROM SCAN(%s) AS X EMIT greatest(X.id,X.dept_id,3)];1185 STORE(out, OUTPUT);1186 """ % self.emp_key1187 expected = collections.Counter(1188 [(max(t[0], t[1], 3),)1189 for t in self.emp_table])1190 self.check_result(query, expected)1191 def test_lesser_function(self):1192 query = """1193 out = [FROM SCAN(%s) AS X EMIT lesser(X.id,X.dept_id)];1194 STORE(out, OUTPUT);1195 """ % self.emp_key1196 expected = collections.Counter(1197 [(min(t[0], t[1]),)1198 for t in self.emp_table])1199 self.check_result(query, expected)1200 def test_greater_function(self):1201 query = """1202 out = [FROM SCAN(%s) AS X EMIT greater(X.id,X.dept_id)];1203 STORE(out, OUTPUT);1204 """ % self.emp_key1205 expected = collections.Counter(1206 [(max(t[0], t[1],),)1207 for t in self.emp_table])1208 self.check_result(query, expected)1209 def test_uda_illegal_init(self):1210 query = """1211 uda Foo(x,y) {1212 [0 as A, *];1213 [A + x, A + y];1214 A;1215 };1216 out = [FROM SCAN(%s) AS X EMIT dept_id, Foo(salary, id)];1217 STORE(out, OUTPUT);1218 """ % self.emp_key1219 with self.assertRaises(IllegalWildcardException):1220 self.check_result(query, None)1221 def test_uda_illegal_update(self):1222 query = """1223 uda Foo(x,y) {1224 [0 as A, 1 as B];1225 [A + x + y, *];1226 A + B;1227 };1228 out = [FROM SCAN(%s) AS X EMIT dept_id, Foo(salary, id)];1229 STORE(out, OUTPUT);1230 """ % self.emp_key1231 with self.assertRaises(MyrialCompileException):1232 self.check_result(query, None)1233 def test_uda_nested_emitter(self):1234 query = """1235 uda Foo(x) {1236 [0 as A];1237 [A + x];1238 [A];1239 };1240 uda Bar(x) {1241 [0 as B];1242 [B + x];1243 Foo(B);1244 };1245 out = [FROM SCAN(%s) AS X EMIT dept_id, Bar(salary)];1246 STORE(out, OUTPUT);1247 """ % self.emp_key1248 with self.assertRaises(NestedAggregateException):1249 self.check_result(query, None)1250 def test_uda_nested_init(self):1251 query = """1252 uda Foo(x) {1253 [0 as A];1254 [A + x];1255 [A];1256 };1257 uda Bar(x) {1258 [Foo(0) as B];1259 [B + x];1260 B;1261 };1262 out = [FROM SCAN(%s) AS X EMIT dept_id, Bar(salary)];1263 STORE(out, OUTPUT);1264 """ % self.emp_key1265 with self.assertRaises(NestedAggregateException):1266 self.check_result(query, None)1267 def test_uda_nested_update(self):1268 query = """1269 uda Foo(x) {1270 [0 as A];1271 [A + x];1272 [A];1273 };1274 uda Bar(x) {1275 [0 as B];1276 [Foo(B)];1277 B;1278 };1279 out = [FROM SCAN(%s) AS X EMIT dept_id, Bar(salary)];1280 STORE(out, OUTPUT);1281 """ % self.emp_key1282 with self.assertRaises(NestedAggregateException):1283 self.check_result(query, None)1284 def test_uda_unary_emit_arg_list(self):1285 query = """1286 uda MyAvg(val) {1287 [0 as _sum, 0 as _count];1288 [_sum + val, _count + 1];1289 [_sum / _count];1290 };1291 out = [FROM SCAN(%s) AS X EMIT dept_id, MyAvg(salary)];1292 STORE(out, OUTPUT);1293 """ % self.emp_key1294 def agg_func(x):1295 return float(sum(x)) / len(x)1296 expected = self.__aggregate_expected_result(agg_func)1297 self.check_result(query, expected)1298 def test_second_max_uda(self):1299 """UDA to compute the second largest element in a collection."""1300 query = """1301 uda SecondMax(val) {1302 [0 as _max, 0 as second_max];1303 [case when val > _max then val else _max end,1304 case when val > _max then _max when val > second_max then val1305 else second_max end];1306 second_max;1307 };1308 out = [FROM SCAN(%s) AS X EMIT dept_id, SecondMax(salary)];1309 STORE(out, OUTPUT);1310 """ % self.emp_key1311 def agg_func(x):1312 if len(x) < 2:1313 return 01314 else:1315 return sorted(x, reverse=True)[1]1316 expected = self.__aggregate_expected_result(agg_func)1317 self.check_result(query, expected)1318 def test_multi_invocation_uda(self):1319 query = """1320 uda MaxDivMin(val) {1321 [9999999 as _min, 0 as _max];1322 [case when val < _min then val else _min end,1323 case when val > _max then val else _max end];1324 _max / _min;1325 };1326 out = [FROM SCAN(%s) AS X EMIT1327 MaxDivMin(id) + dept_id + MaxDivMin(salary), dept_id];1328 STORE(out, OUTPUT);1329 """ % self.emp_key1330 d = collections.defaultdict(list)1331 for t in self.emp_table.elements():1332 d[t[1]].append(t)1333 results = []1334 for k, tpls in d.iteritems():1335 max_salary = max(t[3] for t in tpls)1336 min_salary = min(t[3] for t in tpls)1337 max_id = max(t[0] for t in tpls)1338 min_id = min(t[0] for t in tpls)1339 results.append((k + float(max_salary) / min_salary +1340 float(max_id) / min_id, k))1341 self.check_result(query, collections.Counter(results))1342 def test_multiple_uda(self):1343 query = """1344 uda MyMax1(val) {1345 [0 as _max];1346 [case when val > _max then val else _max end];1347 _max;1348 };1349 uda MyMax2(val) {1350 [0 as _max];1351 [case when val > _max then val else _max end];1352 _max;1353 };1354 out = [FROM SCAN(%s) AS X EMIT dept_id, MyMax1(salary), MyMax2(id)];1355 STORE(out, OUTPUT);1356 """ % self.emp_key1357 d = collections.defaultdict(list)1358 for t in self.emp_table.elements():1359 d[t[1]].append(t)1360 results = []1361 for k, tpls in d.iteritems():1362 max_salary = max(t[3] for t in tpls)1363 max_id = max(t[0] for t in tpls)1364 results.append((k, max_salary, max_id))1365 self.check_result(query, collections.Counter(results))1366 def test_uda_no_emit_clause(self):1367 query = """1368 uda MyCount() {1369 [0 as _count];1370 [_count + 1];1371 };1372 out = [FROM SCAN(%s) AS X EMIT dept_id, MyCount()];1373 STORE(out, OUTPUT);1374 """ % self.emp_key1375 self.check_result(query, self.__aggregate_expected_result(len))1376 def test_uda_no_emit_clause_many_cols(self):1377 query = """1378 uda MyAggs(x) {1379 [0 as _count, 0 as _sum, 0 as _sumsq];1380 [_count + 1, _sum + x, _sumsq + x*x];1381 };1382 out = [FROM SCAN(%s) AS X EMIT MyAggs(salary) as [a, b, c]];1383 STORE(out, OUTPUT);1384 """ % self.emp_key1385 c = len(list(self.emp_table.elements()))1386 s = sum(d for a, b, c, d in self.emp_table.elements())1387 sq = sum(d * d for a, b, c, d in self.emp_table.elements())1388 expected = collections.Counter([(c, s, sq)])1389 self.check_result(query, expected)1390 # Test with two different column orders in case the undefined1391 # order used by Python is correct by chance.1392 query = """1393 uda MyAggs(x) {1394 [0 as _count, 0 as _sumsq, 0 as _sum];1395 [_count + 1, _sumsq + x*x, _sum + x];1396 };1397 out = [FROM SCAN(%s) AS X EMIT MyAggs(salary) as [a, b, c]];1398 STORE(out, OUTPUT);1399 """ % self.emp_key1400 c = len(list(self.emp_table.elements()))1401 sq = sum(d * d for a, b, c, d in self.emp_table.elements())1402 s = sum(d for a, b, c, d in self.emp_table.elements())1403 expected = collections.Counter([(c, sq, s)])1404 self.check_result(query, expected)1405 def test_uda_with_udf(self):1406 query = """1407 def foo(x, y): x + y;1408 uda max2(x, y) {1409 [0 as _max];1410 [case when foo(x, y) > _max then foo(x, y) else _max end];1411 _max;1412 };1413 out = [FROM SCAN(%s) AS X EMIT dept_id, max2(salary, id)];1414 STORE(out, OUTPUT);1415 """ % self.emp_key1416 d = collections.defaultdict(list)1417 for t in self.emp_table.elements():1418 d[t[1]].append(t)1419 results = []1420 for k, tpls in d.iteritems():1421 results.append((k, max(t[3] + t[0] for t in tpls)))1422 self.check_result(query, collections.Counter(results))1423 def test_uda_with_subsequent_project_0(self):1424 query = """1425 def foo(x, y): x + y;1426 uda max2(x, y) {1427 [0 as _max];1428 [case when foo(x, y) > _max then foo(x, y) else _max end];1429 _max;1430 };1431 inter = [FROM SCAN(%s) AS X EMIT dept_id, max2(salary, id)];1432 out = [from inter emit $0];1433 STORE(out, OUTPUT);1434 """ % self.emp_key1435 d = collections.defaultdict(list)1436 for t in self.emp_table.elements():1437 d[t[1]].append(t)1438 results = []1439 for k, tpls in d.iteritems():1440 results.append((k, max(t[3] + t[0] for t in tpls)))1441 results = [(t[0],) for t in results]1442 self.check_result(query, collections.Counter(results))1443 def test_uda_with_subsequent_project_1(self):1444 query = """1445 def foo(x, y): x + y;1446 uda max2(x, y) {1447 [0 as _max];1448 [case when foo(x, y) > _max then foo(x, y) else _max end];1449 _max;1450 };1451 inter = [FROM SCAN(%s) AS X EMIT dept_id, max2(salary, id)];1452 out = [from inter emit $1];1453 STORE(out, OUTPUT);1454 """ % self.emp_key1455 d = collections.defaultdict(list)1456 for t in self.emp_table.elements():1457 d[t[1]].append(t)1458 results = []1459 for k, tpls in d.iteritems():1460 results.append((k, max(t[3] + t[0] for t in tpls)))1461 results = [(t[1],) for t in results]1462 self.check_result(query, collections.Counter(results))1463 def test_uda_with_subsequent_project_2(self):1464 query = """1465 def foo(x, y): x + y;1466 uda max2(x, y) {1467 [0 as _max];1468 [case when foo(x, y) > _max then foo(x, y) else _max end];1469 _max;1470 };1471 inter = [FROM SCAN(%s) AS X EMIT dept_id, max2(salary, id)1472 , max2(dept_id, id)];1473 out = [from inter emit $1];1474 STORE(out, OUTPUT);1475 """ % self.emp_key1476 d = collections.defaultdict(list)1477 for t in self.emp_table.elements():1478 d[t[1]].append(t)1479 results = []1480 for k, tpls in d.iteritems():1481 results.append((k,1482 max(t[3] + t[0] for t in tpls),1483 max(t[1] + t[0] for t in tpls)))1484 results = [(t[1],) for t in results]1485 self.check_result(query, collections.Counter(results))1486 def __run_multiple_emitter_test(self, include_column_names):1487 if include_column_names:1488 names = " AS [mysum, mycount, myavg]"1489 else:1490 names = ""1491 query = """1492 uda SumCountMean(x) {1493 [0 as _sum, 0 as _count];1494 [_sum + x, _count + 1];1495 [_sum, _count, _sum/_count];1496 };1497 out = [FROM SCAN(%s) AS X EMIT dept_id, SumCountMean(salary) %s,1498 dept_id+3, max(id) as max_id];1499 STORE(out, OUTPUT);1500 """ % (self.emp_key, names)1501 d = collections.defaultdict(list)1502 for t in self.emp_table.elements():1503 d[t[1]].append(t)1504 results = []1505 for k, tpls in d.iteritems():1506 _sum = sum(x[3] for x in tpls)1507 _count = len(tpls)1508 _avg = float(_sum) / _count1509 _max_id = max(x[0] for x in tpls)1510 results.append((k, _sum, _count, _avg, k + 3, _max_id))1511 self.check_result(query, collections.Counter(results))1512 def test_uda_multiple_emitters_default_names(self):1513 self.__run_multiple_emitter_test(False)1514 def test_uda_multiple_emitters_provided_names(self):1515 self.__run_multiple_emitter_test(True)1516 scheme_actual = self.db.get_scheme('OUTPUT')1517 scheme_expected = scheme.Scheme([1518 ('dept_id', types.LONG_TYPE), ('mysum', types.LONG_TYPE),1519 ('mycount', types.LONG_TYPE), ('myavg', types.FLOAT_TYPE),1520 ('_COLUMN4_', types.LONG_TYPE), ('max_id', types.LONG_TYPE)])1521 self.assertEquals(scheme_actual, scheme_expected)1522 def test_emit_arg_bad_column_name_length(self):1523 query = """1524 out = [FROM SCAN(%s) AS X EMIT dept_id AS [dept_id1, dept_id2]];1525 STORE(out, OUTPUT);1526 """ % self.emp_key1527 with self.assertRaises(IllegalColumnNamesException):1528 self.check_result(query, None)1529 def test_uda_bad_column_name_length(self):1530 query = """1531 uda Fubar(x, y, z) {1532 [0 as Q];1533 [Q + 1];1534 [1,2,3];1535 };1536 out = [FROM SCAN(%s) AS X EMIT dept_id, Fubar(1, salary, id)1537 AS [A, B, C, D]];1538 STORE(out, OUTPUT);1539 """ % self.emp_key1540 with self.assertRaises(IllegalColumnNamesException):1541 self.check_result(query, None)1542 def test_uda_init_tuple_valued(self):1543 query = """1544 uda Foo(x) {1545 [0 as Q];1546 [Q + 1];1547 [1,2,3];1548 };1549 uda Bar(x) {1550 [Foo(0) as [A, B, C]];1551 [Q * 8];1552 [1,2,3];1553 };1554 out = [FROM SCAN(%s) AS X EMIT dept_id, Bar(salary)];1555 STORE(out, OUTPUT);1556 """ % self.emp_key1557 with self.assertRaises(NestedTupleExpressionException):1558 self.check_result(query, None)1559 def test_uda_update_tuple_valued(self):1560 query = """1561 uda Foo(x) {1562 [0 as Q];1563 [Q + 1];1564 [1,2,3];1565 };1566 uda Bar(x) {1567 [0 as Q];1568 [Foo(Q + 1)];1569 [1,2,3];1570 };1571 out = [FROM SCAN(%s) AS X EMIT dept_id, Bar(salary)];1572 STORE(out, OUTPUT);1573 """ % self.emp_key1574 with self.assertRaises(NestedTupleExpressionException):1575 self.check_result(query, None)1576 def test_uda_result_tuple_valued(self):1577 query = """1578 uda Foo(x) {1579 [0 as Q];1580 [Q + 1];1581 [1,2,3];1582 };1583 uda Bar(x) {1584 [0 as Q];1585 [Q + 2];1586 [1,2,Foo(3)];1587 };1588 out = [FROM SCAN(%s) AS X EMIT dept_id, Bar(salary)];1589 STORE(out, OUTPUT);1590 """ % self.emp_key1591 with self.assertRaises(NestedTupleExpressionException):1592 self.check_result(query, None)1593 def test_uda_multiple_emitters_nested(self):1594 """Test that we raise an Exception if a tuple-valued UDA doesn't appear1595 by itself in an emit expression."""1596 query = """1597 uda SumCountMean(x) {1598 [0 as _sum, 0 as _count];1599 [_sum + x, _count + 1];1600 [_sum, _count, _sum/_count];1601 };1602 out = [FROM SCAN(%s) AS X EMIT dept_id, SumCountMean(salary) + 5];1603 STORE(out, OUTPUT);1604 """ % self.emp_key1605 with self.assertRaises(NestedTupleExpressionException):1606 self.check_result(query, None)1607 __DECOMPOSED_UDA = """1608 uda LogicalAvg(x) {1609 [0 as _sum, 0 as _count];1610 [_sum + x, _count + 1];1611 float(_sum); -- Note bogus return value1612 };1613 uda LocalAvg(x) {1614 [0 as _sum, 0 as _count];1615 [_sum + x, _count + 1];1616 };1617 uda RemoteAvg(_local_sum, _local_count) {1618 [0 as _sum, 0 as _count];1619 [_sum + _local_sum, _count + _local_count];1620 [_sum/_count];1621 };1622 uda* LogicalAvg {LocalAvg, RemoteAvg};1623 """1624 __ARG_MAX_UDA = """1625 def pickval(id, salary, val, _id, _salary, _val):1626 case when salary > _salary then val1627 when salary = _salary and id > _id then val1628 else _val end;1629 uda ArgMax(id, dept_id, name, salary) {1630 [0 as _id, 0 as _dept_id, "" as _name, 0 as _salary];1631 [pickval(id, salary, id, _id, _salary, _id),1632 pickval(id, salary, dept_id, _id, _salary, _dept_id),1633 pickval(id, salary, name, _id, _salary, _name),1634 pickval(id, salary, salary, _id, _salary, _salary)];1635 [_id, _dept_id, _name, _salary];1636 };1637 """1638 __ARG_MAX_UDA_UNNECESSARY_EXPR = """1639 def pickval(id, salary, val, _id, _salary, _val):1640 case when salary > _salary then val1641 when salary = _salary and id > _id then val1642 else _val end;1643 uda ArgMax(id, dept_id, name, salary) {1644 [0 as _id, 0 as _dept_id, "" as _name, 0 as _salary];1645 [pickval(id, salary, greater(id, id), _id, _salary, _id),1646 pickval(id, salary, lesser(dept_id, dept_id), _id, _salary,1647 _dept_id),1648 pickval(id, salary, case when name="" then name else name end, _id,1649 _salary, _name),1650 pickval(id, salary, salary * 1, _id, _salary, _salary)];1651 [_id, _dept_id, _name, _salary];1652 };1653 """1654 def test_decomposable_average_uda(self):1655 """Test of a decomposed average UDA.1656 Note that the logical aggregate returns a broken value, so1657 this test only passes if we decompose the aggregate properly.1658 """1659 query = """%s1660 out = [FROM SCAN(%s) AS X EMIT dept_id, LogicalAvg(salary)];1661 STORE(out, OUTPUT);1662 """ % (TestQueryFunctions.__DECOMPOSED_UDA, self.emp_key)1663 result_dict = collections.defaultdict(list)1664 for t in self.emp_table.elements():1665 result_dict[t[1]].append(t[3])1666 tuples = []1667 for key, vals in result_dict.iteritems():1668 _cnt = len(vals)1669 _sum = sum(vals)1670 tuples.append((key, float(_sum) / _cnt))1671 self.check_result(query, collections.Counter(tuples))1672 def test_decomposable_nary_uda(self):1673 query = """1674 uda Sum2(x, y) {1675 [0 as sum_x, 0 as sum_y];1676 [sum_x + x, sum_y + y];1677 };1678 uda* Sum2 {Sum2, Sum2};1679 out = [FROM SCAN(%s) AS X EMIT1680 Sum2(id, salary) AS [id_sum, salary_sum]];1681 STORE(out, OUTPUT);1682 """ % self.emp_key1683 result_dict = collections.defaultdict(list)1684 for t in self.emp_table.elements():1685 result_dict[t[1]].append(t)1686 id_sum = sum(t[0] for t in self.emp_table.elements())1687 salary_sum = sum(t[3] for t in self.emp_table.elements())1688 tuples = [(id_sum, salary_sum)]1689 self.check_result(query, collections.Counter(tuples))1690 def test_arg_max_uda(self):1691 """Test of an arg_max UDA.1692 """1693 query = """1694 {arg}1695 emp = scan({emp});1696 out = [from emp emit ArgMax(id, dept_id, name, salary)];1697 store(out, OUTPUT);1698 """.format(arg=self.__ARG_MAX_UDA, emp=self.emp_key)1699 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1700 if all(d > d1 or d == d1 and a >= a11701 for a1, b1, c1, d1 in self.emp_table)]1702 self.check_result(query, collections.Counter(tuples))1703 def test_arg_max_uda_with_references(self):1704 """Test of an arg_max UDA with named, unnamed, and dotted1705 attribute references.1706 """1707 query = """1708 {arg}1709 emp = scan({emp});1710 out = [from emp emit ArgMax(id, emp.dept_id, $2, emp.$3)];1711 store(out, OUTPUT);1712 """.format(arg=self.__ARG_MAX_UDA, emp=self.emp_key)1713 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1714 if all(d > d1 or d == d1 and a >= a11715 for a1, b1, c1, d1 in self.emp_table)]1716 self.check_result(query, collections.Counter(tuples))1717 def test_arg_max_uda_with_functions(self):1718 """Test of an arg_max UDA with expressions as inputs.1719 """1720 query = """1721 {arg}1722 emp = scan({emp});1723 out = [from emp emit ArgMax(id,1724 greater(dept_id, dept_id),1725 case when id=1 then name else name end,1726 salary)];1727 store(out, OUTPUT);1728 """.format(arg=self.__ARG_MAX_UDA, emp=self.emp_key)1729 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1730 if all(d > d1 or d == d1 and a >= a11731 for a1, b1, c1, d1 in self.emp_table)]1732 self.check_result(query, collections.Counter(tuples))1733 def test_decomposable_arg_max_uda(self):1734 """Test of a decomposable arg_max UDA.1735 """1736 query = """1737 {arg}1738 uda* ArgMax {{ArgMax, ArgMax}};1739 emp = scan({emp});1740 out = [from emp emit ArgMax(id, dept_id, name, salary)1741 as [a, b, c, d]];1742 store(out, OUTPUT);1743 """.format(arg=self.__ARG_MAX_UDA, emp=self.emp_key)1744 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1745 if all(d > d1 or d == d1 and a >= a11746 for a1, b1, c1, d1 in self.emp_table)]1747 self.check_result(query, collections.Counter(tuples))1748 """Test of an arg_max UDA with named, unnamed, and dotted1749 attribute references.1750 """1751 def test_decomposable_arg_max_uda_with_references(self):1752 """Test of a decomposable arg_max UDA with named, unnamed, and dotted1753 attribute references.1754 """1755 query = """1756 {arg}1757 uda* ArgMax {{ArgMax, ArgMax}};1758 emp = scan({emp});1759 out = [from emp emit ArgMax(id, emp.dept_id, $2, emp.$3)1760 as [a, b, c, d]];1761 store(out, OUTPUT);1762 """.format(arg=self.__ARG_MAX_UDA, emp=self.emp_key)1763 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1764 if all(d > d1 or d == d1 and a >= a11765 for a1, b1, c1, d1 in self.emp_table)]1766 self.check_result(query, collections.Counter(tuples))1767 def test_decomposable_arg_max_uda_with_functions(self):1768 """Test of a decomposable arg_max UDA with expressions as inputs.1769 """1770 query = """1771 {arg}1772 uda* ArgMax {{ArgMax, ArgMax}};1773 emp = scan({emp});1774 out = [from emp emit ArgMax(id,1775 greater(dept_id, dept_id),1776 case when id=1 then name else name end,1777 salary)];1778 store(out, OUTPUT);1779 """.format(arg=self.__ARG_MAX_UDA, emp=self.emp_key)1780 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1781 if all(d > d1 or d == d1 and a >= a11782 for a1, b1, c1, d1 in self.emp_table)]1783 self.check_result(query, collections.Counter(tuples))1784 def test_arg_max_uda_internal_exprs(self):1785 """Test of an arg_max UDA.1786 """1787 query = """1788 {arg}1789 emp = scan({emp});1790 out = [from emp emit ArgMax(id, dept_id, name, salary)];1791 store(out, OUTPUT);1792 """.format(arg=self.__ARG_MAX_UDA_UNNECESSARY_EXPR, emp=self.emp_key)1793 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1794 if all(d > d1 or d == d1 and a >= a11795 for a1, b1, c1, d1 in self.emp_table)]1796 self.check_result(query, collections.Counter(tuples))1797 def test_arg_max_uda_internal_exprs_with_references(self):1798 """Test of an arg_max UDA with named, unnamed, and dotted1799 attribute references.1800 """1801 query = """1802 {arg}1803 emp = scan({emp});1804 out = [from emp emit ArgMax(id, emp.dept_id, $2, emp.$3)];1805 store(out, OUTPUT);1806 """.format(arg=self.__ARG_MAX_UDA_UNNECESSARY_EXPR, emp=self.emp_key)1807 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1808 if all(d > d1 or d == d1 and a >= a11809 for a1, b1, c1, d1 in self.emp_table)]1810 self.check_result(query, collections.Counter(tuples))1811 def test_arg_max_uda_internal_exprs_with_functions(self):1812 """Test of an arg_max UDA with expressions as inputs.1813 """1814 query = """1815 {arg}1816 emp = scan({emp});1817 out = [from emp emit ArgMax(id,1818 greater(dept_id, dept_id),1819 case when id=1 then name else name end,1820 salary)];1821 store(out, OUTPUT);1822 """.format(arg=self.__ARG_MAX_UDA_UNNECESSARY_EXPR, emp=self.emp_key)1823 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1824 if all(d > d1 or d == d1 and a >= a11825 for a1, b1, c1, d1 in self.emp_table)]1826 self.check_result(query, collections.Counter(tuples))1827 def test_decomposable_arg_max_uda_internal_exprs(self):1828 """Test of a decomposable arg_max UDA.1829 """1830 query = """1831 {arg}1832 uda* ArgMax {{ArgMax, ArgMax}};1833 emp = scan({emp});1834 out = [from emp emit ArgMax(id, dept_id, name, salary)1835 as [a, b, c, d]];1836 store(out, OUTPUT);1837 """.format(arg=self.__ARG_MAX_UDA_UNNECESSARY_EXPR, emp=self.emp_key)1838 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1839 if all(d > d1 or d == d1 and a >= a11840 for a1, b1, c1, d1 in self.emp_table)]1841 self.check_result(query, collections.Counter(tuples))1842 """Test of an arg_max UDA with named, unnamed, and dotted1843 attribute references.1844 """1845 def test_decomposable_arg_max_uda_internal_exprs_with_references(self):1846 """Test of a decomposable arg_max UDA with named, unnamed, and dotted1847 attribute references.1848 """1849 query = """1850 {arg}1851 uda* ArgMax {{ArgMax, ArgMax}};1852 emp = scan({emp});1853 out = [from emp emit ArgMax(id, emp.dept_id, $2, emp.$3)1854 as [a, b, c, d]];1855 store(out, OUTPUT);1856 """.format(arg=self.__ARG_MAX_UDA_UNNECESSARY_EXPR, emp=self.emp_key)1857 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1858 if all(d > d1 or d == d1 and a >= a11859 for a1, b1, c1, d1 in self.emp_table)]1860 self.check_result(query, collections.Counter(tuples))1861 def test_decomposable_arg_max_uda_internal_exprs_with_functions(self):1862 """Test of a decomposable arg_max UDA with expressions as inputs.1863 """1864 query = """1865 {arg}1866 uda* ArgMax {{ArgMax, ArgMax}};1867 emp = scan({emp});1868 out = [from emp emit ArgMax(id,1869 greater(dept_id, dept_id),1870 case when id=1 then name else name end,1871 salary)];1872 store(out, OUTPUT);1873 """.format(arg=self.__ARG_MAX_UDA_UNNECESSARY_EXPR, emp=self.emp_key)1874 tuples = [(a, b, c, d) for (a, b, c, d) in self.emp_table1875 if all(d > d1 or d == d1 and a >= a11876 for a1, b1, c1, d1 in self.emp_table)]1877 self.check_result(query, collections.Counter(tuples))1878 def test_decomposable_average_uda_repeated(self):1879 """Test of repeated invocations of decomposed UDAs."""1880 query = """%s1881 out = [FROM SCAN(%s) AS X EMIT dept_id,1882 LogicalAvg(salary) + LogicalAvg($0)];1883 STORE(out, OUTPUT);1884 """ % (TestQueryFunctions.__DECOMPOSED_UDA, self.emp_key)1885 result_dict = collections.defaultdict(list)1886 for t in self.emp_table.elements():1887 result_dict[t[1]].append(t)1888 tuples = []1889 for key, vals in result_dict.iteritems():1890 _cnt = len(vals)1891 _salary_sum = sum(t[3] for t in vals)1892 _id_sum = sum(t[0] for t in vals)1893 tuples.append((key, (float(_salary_sum) + float(_id_sum)) / _cnt))1894 self.check_result(query, collections.Counter(tuples))1895 def test_decomposable_sum_uda(self):1896 """Test of a decomposed sum UDA.1897 Note that the logical aggregate returns a broken value, so1898 this test only passes if we decompose the aggregate properly.1899 """1900 query = """1901 uda MySumBroken(x) {1902 [0 as _sum];1903 [_sum + x];1904 17; -- broken1905 };1906 uda MySum(x) {1907 [0 as _sum];1908 [_sum + x];1909 };1910 uda* MySumBroken {MySum, MySum};1911 out = [FROM SCAN(%s) AS X EMIT dept_id, MySumBroken(salary)];1912 STORE(out, OUTPUT);1913 """ % self.emp_key1914 self.check_result(query, self.__aggregate_expected_result(sum))1915 def test_decomposable_uda_with_builtin_agg(self):1916 """Test of a decomposed UDA + builtin aggregate.1917 Note that the logical aggregate returns a broken value, so1918 this test only passes if we decompose the aggregate properly.1919 """1920 query = """1921 uda MySumBroken(x) {1922 [0 as _sum];1923 [_sum + x];1924 17; -- broken1925 };1926 uda MySum(x) {1927 [0 as _sum];1928 [_sum + x];1929 };1930 uda* MySumBroken {MySum, MySum};1931 out = [FROM SCAN(%s) AS X EMIT dept_id, MySumBroken(salary), SUM(id)];1932 STORE(out, OUTPUT);1933 """ % self.emp_key1934 result_dict = collections.defaultdict(list)1935 for t in self.emp_table.elements():1936 result_dict[t[1]].append(t)1937 tuples = []1938 for key, vals in result_dict.iteritems():1939 _salary_sum = sum(t[3] for t in vals)1940 _id_sum = sum(t[0] for t in vals)1941 tuples.append((key, _salary_sum, _id_sum))1942 self.check_result(query, collections.Counter(tuples))1943 def test_duplicate_decomposable_uda(self):1944 query = """1945 uda Agg1(x) {1946 [0 as _sum];1947 [_sum + x];1948 };1949 uda* Agg1 {Agg1, Agg1};1950 uda* Agg1 {Agg1, Agg1};1951 """1952 with self.assertRaises(DuplicateFunctionDefinitionException):1953 self.check_result(query, None)1954 def test_decomposable_uda_type_check_fail1(self):1955 query = """1956 uda Logical(x) {1957 [0 as _sum];1958 [_sum + x];1959 };1960 uda Local(x, y) {1961 [0 as _sum];1962 [_sum + x];1963 };1964 uda* Logical {Local, Logical};1965 """1966 with self.assertRaises(InvalidArgumentList):1967 self.check_result(query, None)1968 def test_decomposable_uda_type_check_fail2(self):1969 query = """1970 uda Logical(x) {1971 [0 as _sum];1972 [_sum + x];1973 };1974 uda Remote(x, y) {1975 [0 as _sum];1976 [_sum + x];1977 };1978 uda* Logical {Logical, Remote};1979 """1980 with self.assertRaises(InvalidArgumentList):1981 self.check_result(query, None)1982 def test_decomposable_uda_type_check_fail3(self):1983 query = """1984 uda Logical(x) {1985 [0 as _sum];1986 [_sum + x];1987 };1988 uda Remote(x) {1989 [0 as _sum];1990 [_sum + x];1991 [1, 2, 3];1992 };1993 uda* Logical {Logical, Remote};1994 """1995 with self.assertRaises(InvalidEmitList):1996 self.check_result(query, None)1997 def test_running_mean_sapply(self):1998 query = """1999 APPLY RunningMean(value) {2000 [0 AS _count, 0 AS _sum];2001 [_count + 1, _sum + value];2002 _sum / _count;2003 };2004 out = [FROM SCAN(%s) AS X EMIT id, RunningMean(X.salary)];2005 STORE(out, OUTPUT);2006 """ % self.emp_key2007 tps = []2008 _sum = 02009 _count = 02010 for emp in self.emp_table:2011 _sum += emp[3]2012 _count += 12013 tps.append((emp[0], float(_sum) / _count))2014 self.check_result(query, collections.Counter(tps))2015 def test_sapply_multi_invocation(self):2016 query = """2017 APPLY RunningSum(x) {2018 [0 AS _sum];2019 [_sum + x];2020 _sum;2021 };2022 out = [FROM SCAN(%s) AS X2023 EMIT id, RunningSum(X.salary), RunningSum(id)];2024 STORE(out, OUTPUT);2025 """ % self.emp_key2026 tps = []2027 _sum1 = 02028 _sum2 = 02029 for emp in self.emp_table:2030 _sum1 += emp[3]2031 _sum2 += emp[0]2032 tps.append((emp[0], _sum1, _sum2))2033 self.check_result(query, collections.Counter(tps))2034 def test_118_regression(self):2035 """Regression test for https://github.com/uwescience/datalogcompiler/issues/118""" # noqa2036 query = """2037 out = [FROM SCAN(%s) AS X WHERE dept_id = 2 AND salary = 5000 EMIT id];2038 STORE(out, OUTPUT);2039 """ % self.emp_key2040 expected = collections.Counter(2041 [(x[0],) for x in self.emp_table.elements()2042 if x[1] == 2 and x[3] == 5000])2043 self.check_result(query, expected)2044 def test_scan_emp_empty_statement(self):2045 """Test with an empty statement."""2046 query = """2047 ;;;2048 emp = SCAN(%s);2049 STORE(emp, OUTPUT);;;2050 """ % self.emp_key2051 self.check_result(query, self.emp_table)2052 def test_empty_statement_parse(self):2053 """Program that contains nothing but empty statements."""2054 with self.assertRaises(MyrialCompileException):2055 self.check_result(";", None)2056 def test_case_binary(self):2057 query = """2058 emp = SCAN(%s);2059 rich = [FROM emp EMIT id, CASE WHEN salary > 150002060 THEN salary // salary2061 ELSE 0 // salary END];2062 STORE(rich, OUTPUT);2063 """ % self.emp_key2064 def func(y):2065 if y > 15000:2066 return 12067 else:2068 return 02069 expected = collections.Counter(2070 [(x[0], func(x[3])) for x in self.emp_table.elements()])2071 self.check_result(query, expected)2072 def test_case_ternary(self):2073 query = """2074 emp = SCAN(%s);2075 rich = [FROM emp EMIT id,2076 CASE WHEN salary <= 5000 THEN "poor"2077 WHEN salary <= 25000 THEN "middle class"2078 ELSE "rich"2079 END];2080 STORE(rich, OUTPUT);2081 """ % self.emp_key2082 def func(y):2083 if y <= 5000:2084 return 'poor'2085 elif y <= 25000:2086 return 'middle class'2087 else:2088 return 'rich'2089 expected = collections.Counter(2090 [(x[0], func(x[3])) for x in self.emp_table.elements()])2091 self.check_result(query, expected)2092 def test_case_aggregate(self):2093 query = """2094 emp = SCAN(%s);2095 rich = [FROM emp EMIT SUM(3 * CASE WHEN salary > 150002096 THEN 1 ELSE 0 END)];2097 STORE(rich, OUTPUT);2098 """ % self.emp_key2099 _sum = 3 * len([x for x in self.emp_table.elements()2100 if x[3] > 15000])2101 self.check_result(query, collections.Counter([(_sum,)]))2102 def test_case_unbox(self):2103 query = """2104 TH = [15000];2105 A = [1 AS one, 2 AS two, 3 AS three];2106 emp = SCAN(%s);2107 rich = [FROM emp EMIT SUM(*A.three * CASE WHEN salary > *TH2108 THEN 1 ELSE 0 END)];2109 STORE(rich, OUTPUT);2110 """ % self.emp_key2111 _sum = 3 * len([x for x in self.emp_table.elements()2112 if x[3] > 15000])2113 self.check_result(query, collections.Counter([(_sum,)]))2114 def test_default_column_names(self):2115 with open('examples/groupby1.myl') as fh:2116 query = fh.read()2117 self.execute_query(query)2118 scheme = self.db.get_scheme('OUTPUT')2119 self.assertEquals(scheme.getName(0), "_COLUMN0_")2120 self.assertEquals(scheme.getName(1), "id")2121 def test_worker_id(self):2122 query = """2123 X = [FROM SCAN(%s) AS X EMIT X.id, WORKER_ID()];2124 STORE(X, OUTPUT);2125 """ % self.emp_key2126 expected = collections.Counter([(x[0], 0) for x2127 in self.emp_table.elements()])2128 self.check_result(query, expected)2129 def test_flip_zero(self):2130 """flip(0) should always evaluate to false"""2131 query = """2132 X = [FROM SCAN(%s) AS X WHERE flip(0) EMIT *];2133 STORE(X, OUTPUT);2134 """ % self.emp_key2135 expected = collections.Counter()2136 self.check_result(query, expected)2137 def test_flip_one(self):2138 """flip(1) should always evaluate to true"""2139 query = """2140 X = [FROM SCAN(%s) AS X WHERE flip(1) EMIT *];2141 STORE(X, OUTPUT);2142 """ % self.emp_key2143 expected = collections.Counter(self.emp_table.elements())2144 self.check_result(query, expected)2145 def test_substr(self):2146 query = """2147 ZERO = [0];2148 THREE = [3];2149 out = [FROM SCAN(%s) AS X EMIT X.id, substr(X.name, *ZERO, *THREE)];2150 STORE(out, OUTPUT);2151 """ % self.emp_key2152 expected = collections.Counter(2153 [(x[0], x[2][0:3]) for x in self.emp_table.elements()])2154 self.check_result(query, expected)2155 def test_len(self):2156 query = """2157 out = [FROM SCAN(%s) AS X EMIT X.id, len(X.name)];2158 STORE(out, OUTPUT);2159 """ % self.emp_key2160 expected = collections.Counter(2161 [(x[0], len(x[2])) for x in self.emp_table.elements()])2162 self.check_result(query, expected)2163 def test_head(self):2164 query = """2165 out = [FROM SCAN(%s) AS X EMIT X.id, head(X.name, 10)];2166 STORE(out, OUTPUT);2167 """ % self.emp_key2168 expected = collections.Counter(2169 [(x[0], x[2][0:10]) for x in self.emp_table.elements()])2170 self.check_result(query, expected)2171 def test_tail(self):2172 query = """2173 ZERO = [0];2174 THREE = [3];2175 out = [FROM SCAN(%s) AS X EMIT X.id, tail(X.name, 10)];2176 STORE(out, OUTPUT);2177 """ % self.emp_key2178 expected = collections.Counter(2179 [(x[0], (lambda i: i if len(i) <= 10 else i[len(i) - 10:])(x[2]))2180 for x in self.emp_table.elements()])2181 self.check_result(query, expected)2182 def test_column_name_reserved(self):2183 query = """2184 T = EMPTY(x:INT);2185 A = [FROM T EMIT SafeDiv(x, 3) AS SafeDiv];2186 STORE (A, BadProgram);2187 """2188 with self.assertRaises(ReservedTokenException):2189 self.check_result(query, None)2190 def test_bug_226(self):2191 query = """2192 T = scan({emp});2193 A = select id, salary from T where 1=1;2194 B = select id, salary from A where salary=90000;2195 C = select A.* from B, A where A.salary < B.salary;2196 STORE (C, OUTPUT);2197 """.format(emp=self.emp_key)2198 expected = collections.Counter(2199 (i, s) for (i, d, n, s) in self.emp_table2200 for (i2, d2, n2, s2) in self.emp_table2201 if s2 == 90000 and s < s2)2202 self.assertEquals(expected, self.execute_query(query))2203 def test_column_mixed_case_reserved(self):2204 query = """2205 T = EMPTY(x:INT);2206 A = [FROM T EMIT MAX(x) AS maX];2207 STORE (A, BadProgram);2208 """2209 with self.assertRaises(ReservedTokenException):2210 self.check_result(query, None)2211 def test_variable_name_reserved(self):2212 query = """2213 T = EMPTY(x:INT);2214 avg = COUNTALL(T);2215 STORE (countall, BadProgram);2216 """2217 with self.assertRaises(ReservedTokenException):2218 self.check_result(query, None)2219 def test_empty_query(self):2220 query = """2221 T1 = empty(x:INT);2222 """2223 with self.assertRaises(MyrialCompileException):2224 self.check_result(query, None)2225 def test_sink(self):2226 query = """2227 ZERO = [0];2228 A = [from ZERO emit *];2229 SINK(A);2230 """2231 self.evaluate_sink_query(query)2232 def test_string_cast(self):2233 query = """2234 emp = SCAN(%s);2235 bc = [FROM emp EMIT STRING(emp.dept_id) AS foo];2236 STORE(bc, OUTPUT);2237 """ % self.emp_key2238 ex = collections.Counter((str(d),) for (i, d, n, s) in self.emp_table)2239 ex_scheme = scheme.Scheme([('foo', types.STRING_TYPE)])2240 self.check_result(query, ex)2241 def test_float_cast(self):2242 query = """2243 emp = SCAN(%s);2244 bc = [FROM emp EMIT float(emp.dept_id) AS foo];2245 STORE(bc, OUTPUT);2246 """ % self.emp_key2247 ex = collections.Counter((float(d),) for (i, d, n, s) in self.emp_table) # noqa2248 ex_scheme = scheme.Scheme([('foo', types.DOUBLE_TYPE)])2249 self.check_result(query, ex, ex_scheme)2250 def test_sequence(self):2251 query = """2252 T1 = scan({rel});2253 store(T1, OUTPUT);2254 T2 = scan({rel});2255 store(T2, OUTPUT2);2256 """.format(rel=self.emp_key)2257 physical_plan = self.get_physical_plan(query)2258 self.assertIsInstance(physical_plan, raco.algebra.Sequence)2259 self.check_result(query, self.emp_table, output='OUTPUT')2260 self.check_result(query, self.emp_table, output='OUTPUT2')2261 def test_238_dont_renumber_columns(self):2262 # see https://github.com/uwescience/raco/issues/2382263 query = """2264 x = [1 as a, 2 as b];2265 y = [from x as x1, x as x22266 emit x2.a, x2.b];2267 z = [from y emit a];2268 store(z, OUTPUT);"""2269 self.check_result(query, collections.Counter([(1,)]))2270 def test_implicit_column_names(self):2271 query = """2272 x = [1 as a, 2 as b];2273 y = [from x as x1, x as x22274 emit $0, $1];2275 store(y, OUTPUT);"""2276 expected_scheme = scheme.Scheme([('a', types.LONG_TYPE),2277 ('b', types.LONG_TYPE)])2278 self.check_result(query, collections.Counter([(1, 2)]),2279 scheme=expected_scheme)2280 def test_implicit_column_names2(self):2281 query = """2282 x = [1 as a, 2 as b];2283 y = [from x as x1, x as x22284 emit $2, $3];2285 store(y, OUTPUT);"""2286 expected_scheme = scheme.Scheme([('a', types.LONG_TYPE),2287 ('b', types.LONG_TYPE)])2288 self.check_result(query, collections.Counter([(1, 2)]),2289 scheme=expected_scheme)2290 def test_implicit_column_names3(self):2291 query = """2292 x = [1 as a, 2 as b];2293 y = [from x as x1, x as x22294 emit $2, $1];2295 store(y, OUTPUT);"""2296 expected_scheme = scheme.Scheme([('a', types.LONG_TYPE),2297 ('b', types.LONG_TYPE)])2298 self.check_result(query, collections.Counter([(1, 2)]),2299 scheme=expected_scheme)2300 def test_unbox_index_column_names(self):2301 query = """2302 x = [1 as a, 2 as b];2303 y = [from x as x1, x as x22304 emit x2.$0, x2.$1];2305 store(y, OUTPUT);"""2306 expected_scheme = scheme.Scheme([('a', types.LONG_TYPE),2307 ('b', types.LONG_TYPE)])2308 self.check_result(query, collections.Counter([(1, 2)]),2309 scheme=expected_scheme)2310 def test_duplicate_column_names(self):2311 query = """2312 x = [1 as a, 2 as b];2313 y = [from x as x1, x as x2 emit x1.a, x2.a];2314 store(y, OUTPUT);"""2315 expected_scheme = scheme.Scheme([('a', types.LONG_TYPE),2316 ('a1', types.LONG_TYPE)])2317 self.check_result(query, collections.Counter([(1, 1)]),2318 scheme=expected_scheme)2319 def test_distinct_aggregate_combinations(self):2320 """Test to make sure that aggregates of different columns are not2321 combined together by the optimizer."""2322 query = """2323 emp = scan(%s);2324 ans = [from emp emit sum(dept_id) as d, sum(salary) as s];2325 store(ans, OUTPUT);""" % self.emp_key2326 sum_dept_id = sum([e[1] for e in self.emp_table])2327 sum_salary = sum([e[3] for e in self.emp_table])2328 expected = collections.Counter([(sum_dept_id, sum_salary)])2329 self.check_result(query, expected)2330 def test_bug_245_dead_code_with_do_while_plan(self):2331 """Test to make sure that a dead program (no Stores) with a DoWhile2332 throws the correct parse error."""2333 with open('examples/deadcode2.myl') as fh:2334 query = fh.read()2335 with self.assertRaises(MyrialCompileException):2336 self.check_result(query, None)2337 def test_simple_do_while(self):2338 """count to 32 by powers of 2"""2339 with open('examples/iteration.myl') as fh:2340 query = fh.read()2341 expected = collections.Counter([(32, 5)])...

test_pyshell.py

Source:test_pyshell.py

...52 def all_removed(self, text):53 self.assertEqual('', self.regexp.sub('', text))54 def none_removed(self, text):55 self.assertEqual(text, self.regexp.sub('', text))56 def check_result(self, text, expected):57 self.assertEqual(expected, self.regexp.sub('', text))58 def test_empty(self):59 self.all_removed('')60 def test_newline(self):61 self.all_removed('\n')62 def test_whitespace_no_newline(self):63 self.all_removed(' ')64 self.all_removed(' ')65 self.all_removed(' ')66 self.all_removed(' ' * 20)67 self.all_removed('\t')68 self.all_removed('\t\t')69 self.all_removed('\t\t\t')70 self.all_removed('\t' * 20)71 self.all_removed('\t ')72 self.all_removed(' \t')73 self.all_removed(' \t \t ')74 self.all_removed('\t \t \t')75 def test_newline_with_whitespace(self):76 self.all_removed(' \n')77 self.all_removed('\t\n')78 self.all_removed(' \t\n')79 self.all_removed('\t \n')80 self.all_removed('\n ')81 self.all_removed('\n\t')82 self.all_removed('\n \t')83 self.all_removed('\n\t ')84 self.all_removed(' \n ')85 self.all_removed('\t\n ')86 self.all_removed(' \n\t')87 self.all_removed('\t\n\t')88 self.all_removed('\t \t \t\n')89 self.all_removed(' \t \t \n')90 self.all_removed('\n\t \t \t')91 self.all_removed('\n \t \t ')92 def test_multiple_newlines(self):93 self.check_result('\n\n', '\n')94 self.check_result('\n' * 5, '\n' * 4)95 self.check_result('\n' * 5 + '\t', '\n' * 4)96 self.check_result('\n' * 20, '\n' * 19)97 self.check_result('\n' * 20 + ' ', '\n' * 19)98 self.check_result(' \n \n ', ' \n')99 self.check_result(' \n\n ', ' \n')100 self.check_result(' \n\n', ' \n')101 self.check_result('\t\n\n', '\t\n')102 self.check_result('\n\n ', '\n')103 self.check_result('\n\n\t', '\n')104 self.check_result(' \n \n ', ' \n')105 self.check_result('\t\n\t\n\t', '\t\n')106 def test_non_whitespace(self):107 self.none_removed('a')108 self.check_result('a\n', 'a')109 self.check_result('a\n ', 'a')110 self.check_result('a \n ', 'a')111 self.check_result('a \n\t', 'a')112 self.none_removed('-')113 self.check_result('-\n', '-')114 self.none_removed('.')115 self.check_result('.\n', '.')116 def test_unsupported_whitespace(self):117 self.none_removed('\v')118 self.none_removed('\n\v')119 self.check_result('\v\n', '\v')120 self.none_removed(' \n\v')121 self.check_result('\v\n ', '\v')122if __name__ == '__main__':...

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

• JUnit Tutorial
• TestNG Tutorial
• Webdriver Tutorial
• WebDriverIO Tutorial
• Protractor Tutorial
• Selenium 4 Tutorial
• Jenkins Tutorial
• NUnit Tutorial
• Jest Tutorial
• Playwright Tutorial
• Cypress Tutorial
• PyTest Tutorial

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run localstack automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

View sample repo View DocumentationSign up Free

›

_