diff options
Diffstat (limited to '')
| -rw-r--r-- | test/function_relations_test.erl | 66 | ||||
| -rw-r--r-- | test/infinite_relations_test.erl | 73 | ||||
| -rw-r--r-- | test/join_test.erl | 12 | ||||
| -rw-r--r-- | test/operations_test.erl | 27 | ||||
| -rw-r--r-- | test/query_pipeline_test.erl | 13 |
5 files changed, 77 insertions, 114 deletions
diff --git a/test/function_relations_test.erl b/test/function_relations_test.erl index a9164bf..a6ab2d2 100644 --- a/test/function_relations_test.erl +++ b/test/function_relations_test.erl @@ -38,51 +38,43 @@ setup() -> operations:setup(), DB = operations:create_database(test_db), - % First set up the basic number types (integers, naturals, etc) - {DB1, _Integers} = operations:create_infinite_relation(DB, #{ - name => integers, - schema => #{}, % empty schema - this is a base type - cardinality => aleph_zero, - generator => {primitive, integers} + % Integers and naturals are now built-in to every database + % Just create the function relations using the new format + + % Create function relations - note how their schemas reference the domain relations + {DB1, _Plus} = operations:create_immutable_relation(DB, #immutable_relation_spec{ + name = plus, + schema = #{a => integer, b => integer, sum => integer}, + generator = {generators, plus}, + membership_criteria = #{}, + cardinality = aleph_zero }), - {DB2, _Naturals} = operations:create_infinite_relation(DB1, #{ - name => naturals, - schema => #{}, - cardinality => aleph_zero, - generator => {primitive, naturals} + {DB2, _Times} = operations:create_immutable_relation(DB1, #immutable_relation_spec{ + name = times, + schema = #{a => integer, b => integer, product => integer}, + generator = {generators, times}, + membership_criteria = #{}, + cardinality = aleph_zero }), - % Now create the function relations - note how their schemas reference the domain relations above - {DB3, _Plus} = operations:create_infinite_relation(DB2, #{ - name => plus, - schema => #{a => integers, b => integers, sum => integers}, - cardinality => aleph_zero, - generator => {primitive, plus} + {DB3, _Minus} = operations:create_immutable_relation(DB2, #immutable_relation_spec{ + name = minus, + schema = #{a => integer, b => integer, difference => integer}, + generator = {generators, minus}, + membership_criteria = #{}, + cardinality = aleph_zero }), - {DB4, _Times} = operations:create_infinite_relation(DB3, #{ - name => times, - schema => #{a => integers, b => integers, product => integers}, - cardinality => aleph_zero, - generator => {primitive, times} + {DB4, _Divide} = operations:create_immutable_relation(DB3, #immutable_relation_spec{ + name = divide, + schema = #{a => integer, b => integer, quotient => integer, remainder => natural}, + generator = {generators, divide}, + membership_criteria = #{}, + cardinality = aleph_zero }), - {DB5, _Minus} = operations:create_infinite_relation(DB4, #{ - name => minus, - schema => #{a => integers, b => integers, difference => integers}, - cardinality => aleph_zero, - generator => {primitive, minus} - }), - - {DB6, _Divide} = operations:create_infinite_relation(DB5, #{ - name => divide, - schema => #{a => integers, b => integers, quotient => integers, remainder => naturals}, - cardinality => aleph_zero, - generator => {primitive, divide} - }), - - DB6. + DB4. cleanup(_DB) -> ok. diff --git a/test/infinite_relations_test.erl b/test/infinite_relations_test.erl index 39fe29a..5f87acb 100644 --- a/test/infinite_relations_test.erl +++ b/test/infinite_relations_test.erl @@ -37,35 +37,22 @@ strip_meta(Tuples) when is_list(Tuples) -> %%% Tests test_create_naturals(DB) -> - %% Create infinite relation of natural numbers - %% Domain relations have empty schemas (base case) - {DB1, Naturals} = operations:create_infinite_relation(DB, #{ - name => naturals, - schema => #{}, - cardinality => aleph_zero, - generator => {primitive, naturals}, - constraints => #{value => {gte, 0}} - }), + %% Naturals are now built-in to every database + %% Just retrieve the relation to verify it exists + {ok, NaturalsHash} = operations:get_relation_hash(DB, natural), + [NaturalsRel] = mnesia:dirty_read(relation, NaturalsHash), [ - ?_assert(is_record(Naturals, relation)), - ?_assertEqual(naturals, Naturals#relation.name), - ?_assertEqual(aleph_zero, Naturals#relation.cardinality), - ?_assertEqual({primitive, naturals}, Naturals#relation.generator) + ?_assert(is_record(NaturalsRel, relation)), + ?_assertEqual(natural, NaturalsRel#relation.name), + ?_assertEqual(aleph_zero, NaturalsRel#relation.cardinality), + ?_assertEqual({generators, natural}, NaturalsRel#relation.generator) ]. test_naturals_with_constraints(DB) -> - %% Create naturals relation - {DB1, _Naturals} = operations:create_infinite_relation(DB, #{ - name => naturals, - schema => #{}, - cardinality => aleph_zero, - generator => {primitive, naturals}, - constraints => #{value => {gte, 0}} - }), - + %% Naturals are built-in, just query them %% Query with range constraint [0, 9] - Iterator = operations:get_tuples_iterator(DB1, naturals, #{value => {range, 0, 9}}), + Iterator = operations:get_tuples_iterator(DB, natural, #{value => {range, 0, 9}}), Tuples = operations:collect_all(Iterator), DataOnly = strip_meta(Tuples), @@ -78,16 +65,12 @@ test_naturals_with_constraints(DB) -> ]. test_integers_generator(DB) -> - %% Create integers relation - {DB1, Integers} = operations:create_infinite_relation(DB, #{ - name => integers, - schema => #{}, - cardinality => aleph_zero, - generator => {primitive, integers} - }), + %% Integers are built-in + {ok, IntegersHash} = operations:get_relation_hash(DB, integer), + [Integers] = mnesia:dirty_read(relation, IntegersHash), %% Query with range constraint [-5, 5] - Iterator = operations:get_tuples_iterator(DB1, integers, #{value => {range, -5, 5}}), + Iterator = operations:get_tuples_iterator(DB, integer, #{value => {range, -5, 5}}), Tuples = operations:collect_all(Iterator), DataOnly = strip_meta(Tuples), @@ -101,16 +84,12 @@ test_integers_generator(DB) -> ]. test_rationals_generator(DB) -> - %% Create rationals relation - {DB1, Rationals} = operations:create_infinite_relation(DB, #{ - name => rationals, - schema => #{}, - cardinality => aleph_zero, - generator => {primitive, rationals} - }), + %% Rationals are built-in + {ok, RationalsHash} = operations:get_relation_hash(DB, rational), + [Rationals] = mnesia:dirty_read(relation, RationalsHash), %% Take first 10 rationals using constraints - Iterator = operations:get_tuples_iterator(DB1, rationals, #{}), + Iterator = operations:get_tuples_iterator(DB, rational, #{}), %% Just get a few tuples to verify generator works {ok, First} = operations:next_tuple(Iterator), @@ -126,22 +105,14 @@ test_rationals_generator(DB) -> ]. test_take_operator(DB) -> - %% Create naturals - {DB1, _} = operations:create_infinite_relation(DB, #{ - name => naturals, - schema => #{}, - cardinality => aleph_zero, - generator => {primitive, naturals}, - constraints => #{value => {gte, 0}} - }), - + %% Naturals are built-in, just use them %% Take 100 naturals - {_DB2, Naturals100} = operations:take(DB1, naturals, 100), + {_DB2, Naturals100} = operations:take(DB, natural, 100), %% Verify result is finite [ ?_assertEqual({finite, 100}, Naturals100#relation.cardinality), - ?_assertEqual({take, naturals, 100}, Naturals100#relation.generator) + ?_assertEqual({take, natural, 100}, Naturals100#relation.generator) ]. test_finite_relation_cardinality(DB) -> @@ -149,7 +120,7 @@ test_finite_relation_cardinality(DB) -> {DB1, _} = operations:create_relation(DB, users, #{name => string, age => integer}), %% Add tuple - {DB2, UpdatedRel} = operations:create_tuple(DB1, users, #{name => "Alice", age => 30}), + {_DB2, UpdatedRel} = operations:create_tuple(DB1, users, #{name => "Alice", age => 30}), %% Cardinality should be 1 [ diff --git a/test/join_test.erl b/test/join_test.erl index 8abdc0b..de62127 100644 --- a/test/join_test.erl +++ b/test/join_test.erl @@ -207,19 +207,13 @@ test_theta_join_complex_predicate(DB) -> %%% Integration Tests test_join_with_infinite_relation(DB) -> - % Create integers relation - {DB1, _} = operations:create_infinite_relation(DB, #{ - name => integers, - schema => #{}, - cardinality => aleph_zero, - generator => {primitive, integers} - }), + % Integers are built-in, no need to create them % Get small set of integers - IntIter = operations:get_tuples_iterator(DB1, integers, #{value => {range, 1, 5}}), + IntIter = operations:get_tuples_iterator(DB, integer, #{value => {range, 1, 5}}), % Get employees - EmpIter = operations:get_tuples_iterator(DB1, employees, #{}), + EmpIter = operations:get_tuples_iterator(DB, employees, #{}), % Join where employee.id matches integer.value Predicate = fun(Emp, Int) -> diff --git a/test/operations_test.erl b/test/operations_test.erl index a69c4fa..31bde43 100644 --- a/test/operations_test.erl +++ b/test/operations_test.erl @@ -38,7 +38,11 @@ database_creation_test_() -> [?_test(begin DB = operations:create_database(my_db), ?assertEqual(my_db, DB#database_state.name), - ?assertEqual(#{}, DB#database_state.relations), + % Database now comes with built-in infinite relations + Relations = operations:get_relations(DB), + ?assert(lists:member(natural, Relations)), + ?assert(lists:member(integer, Relations)), + ?assert(lists:member(rational, Relations)), ?assertNotEqual(undefined, DB#database_state.timestamp) end)]}. @@ -59,8 +63,12 @@ relation_creation_test_() -> ?assertEqual(users, Relation#relation.name), ?assertEqual(Schema, Relation#relation.schema), - % Verify database was updated - ?assertEqual([users], operations:get_relations(DB1)), + % Verify database was updated (includes built-in relations) + Relations = operations:get_relations(DB1), + ?assert(lists:member(users, Relations)), + ?assert(lists:member(natural, Relations)), + ?assert(lists:member(integer, Relations)), + ?assert(lists:member(rational, Relations)), {ok, RelationHash} = operations:get_relation_hash(DB1, users), ?assertEqual(Relation#relation.hash, RelationHash) end)]}. @@ -238,14 +246,19 @@ retract_relation_test_() -> [?_test(begin DB = sample_database_with_tuples(), - % Verify relation exists - ?assertEqual([users], operations:get_relations(DB)), + % Verify relation exists (along with built-in relations) + Relations = operations:get_relations(DB), + ?assert(lists:member(users, Relations)), % Retract relation {atomic, DB1} = operations:retract_relation(DB, users), - % Verify relation was removed - ?assertEqual([], operations:get_relations(DB1)), + % Verify users relation was removed (built-in relations remain) + Relations1 = operations:get_relations(DB1), + ?assertNot(lists:member(users, Relations1)), + ?assert(lists:member(natural, Relations1)), + ?assert(lists:member(integer, Relations1)), + ?assert(lists:member(rational, Relations1)), ?assertEqual({error, not_found}, operations:get_relation_hash(DB1, users)), % Verify database hash changed diff --git a/test/query_pipeline_test.erl b/test/query_pipeline_test.erl index 389ff7c..a76c2ff 100644 --- a/test/query_pipeline_test.erl +++ b/test/query_pipeline_test.erl @@ -139,18 +139,11 @@ test_materialize_finite(DB) -> ]. test_materialize_infinite(DB) -> - %% Create infinite naturals - {DB1, _} = operations:create_infinite_relation(DB, #{ - name => naturals, - schema => #{}, - cardinality => aleph_zero, - generator => {primitive, naturals}, - constraints => #{value => {gte, 0}} - }), + %% Naturals are built-in, no need to create them %% Take 100 and materialize - Pipeline = operations:get_tuples_iterator(DB1, naturals, #{value => {range, 0, 99}}), - {_DB2, Naturals100} = operations:materialize(DB1, Pipeline, naturals_100), + Pipeline = operations:get_tuples_iterator(DB, natural, #{value => {range, 0, 99}}), + {_DB2, Naturals100} = operations:materialize(DB, Pipeline, naturals_100), [ ?_assertEqual({finite, 100}, Naturals100#relation.cardinality), |