def _rewrite_join(self, node: saldag.Join):
"""
Insert Open/Close ops above or beneath a Join node. If the parent of the Join node is an upper
boundary node, then a Close op is inserted between it and the parent node. If the Join node is
a leaf node (i.e. - has no children), then an Open op is inserted beneath it.
"""
out_stored_with = node.out_rel.stored_with
ordered_pars = [node.left_parent, node.right_parent]
left_stored_with = node.get_left_in_rel().stored_with
right_stored_with = node.get_right_in_rel().stored_with
in_stored_with = left_stored_with | right_stored_with
for parent in ordered_pars:
if node.is_upper_boundary():
# Entering mpc mode so need to secret-share before op
out_rel = copy.deepcopy(parent.out_rel)
out_rel.rename(out_rel.name + "_close")
out_rel.stored_with = copy.copy(in_stored_with)
# create and insert close node
close_op = saldag.Close(out_rel, None)
close_op.is_mpc = True
saldag.insert_between(parent, node, close_op)
# else:
# raise Exception(
# "different stored_with on non-upper-boundary join", node.debug_str())
if node.is_leaf():
if len(in_stored_with) > 1 and len(out_stored_with) == 1:
target_party = next(iter(out_stored_with))
node.out_rel.stored_with = copy.copy(in_stored_with)
sal._open(node, node.out_rel.name + "_open", target_party)
def _rewrite_hybrid_join(self, node: saldag.HybridJoin):
# TODO
suffix = "rand"
# in left parents' children, replace self with first primitive operator
# in expanded subdag
shuffled_a = sal.shuffle(node.left_parent, "shuffled_a")
shuffled_a.is_mpc = True
node.left_parent.children.remove(node)
# same for right parent
shuffled_b = sal.shuffle(node.right_parent, "shuffled_b")
shuffled_b.is_mpc = True
node.right_parent.children.remove(node)
persisted_b = sal._persist(shuffled_b, "persisted_b")
persisted_b.is_mpc = True
persisted_a = sal._persist(shuffled_a, "persisted_a")
persisted_a.is_mpc = True
keys_a_closed = sal.project(shuffled_a, "keys_a_closed", ["a"])
keys_a_closed.is_mpc = True
keys_b_closed = sal.project(shuffled_b, "keys_b_closed", ["c"])
keys_b_closed.is_mpc = True
keys_a = sal._open(keys_a_closed, "keys_a", 1)
keys_a.is_mpc = True
keys_b = sal._open(keys_b_closed, "keys_b", 1)
keys_b.is_mpc = True
indexed_a = sal.index(keys_a, "indexed_a", "index_a")
indexed_a.is_mpc = False
indexed_b = sal.index(keys_b, "indexed_b", "index_b")
indexed_b.is_mpc = False
joined_indices = sal.join(indexed_a, indexed_b, "joined_indices",
["a"], ["c"])
joined_indices.is_mpc = False
indices_only = sal.project(joined_indices, "indices_only",
["index_a", "index_b"])
indices_only.is_mpc = False
# TODO: update stored_with to use union of parent out_rel stored_with sets
indices_closed = sal._close(indices_only, "indices_closed", set([1,
2]))
indices_closed.is_mpc = True
joined = sal._index_join(persisted_a, persisted_b, "joined", ["a"],
["c"], indices_closed)
joined.is_mpc = True
# replace self with leaf of expanded subdag in each child node
for child in node.get_sorted_children():
child.replace_parent(node, joined)
# add former children to children of leaf
joined.children = node.children
def hybrid_agg(in1):
shuffled = sal.shuffle(in1, "shuffled")
shuffled.out_rel.storedWith = set([1, 2, 3])
shuffled.isMPC = True
persisted = sal._persist(shuffled, "persisted")
persisted.out_rel.storedWith = set([1, 2, 3])
persisted.isMPC = True
keysclosed = sal.project(shuffled, "keysclosed", ["b"])
keysclosed.out_rel.storedWith = set([1, 2, 3])
keysclosed.isMPC = True
keys = sal._open(keysclosed, "keys", 1)
keys.isMPC = True
indexed = sal.index(keys, "indexed", "rowIndex")
indexed.isMPC = False
indexed.out_rel.storedWith = set([1])
distinctKeys = sal.distinct(keys, "distinctKeys", ["b"])
distinctKeys.isMPC = False
distinctKeys.out_rel.storedWith = set([1])
# TODO: hack to get keys stored
# need to fix later!
fakeDistinctKeys = sal.project(distinctKeys, "distinctKeys", ["b"])
fakeDistinctKeys.isMPC = False
fakeDistinctKeys.out_rel.storedWith = set([1])
indexedDistinct = sal.index(distinctKeys, "indexedDistinct",
"keyIndex")
indexedDistinct.isMPC = False
indexedDistinct.out_rel.storedWith = set([1])
joinedindeces = sal.join(indexed, indexedDistinct, "joinedindeces",
["b"], ["b"])
joinedindeces.isMPC = False
joinedindeces.out_rel.storedWith = set([1])
# TODO: could project row indeces away too
indecesonly = sal.project(joinedindeces, "indecesonly",
["rowIndex", "keyIndex"])
indecesonly.isMPC = False
indecesonly.out_rel.storedWith = set([1])
closedDistinct = sal._close(distinctKeys, "closedDistinct",
set([1, 2, 3]))
closedDistinct.isMPC = True
closedLookup = sal._close(indecesonly, "closedLookup", set([1, 2, 3]))
closedLookup.isMPC = True
agg = sal.index_aggregate(persisted, "agg", ["b"], "d", "+", "d",
closedLookup, closedDistinct)
agg.isMPC = True
sal._open(agg, "aggopened", 1)
def protocol():
# define inputs
cols_in_a = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
]
in_1 = sal.create("in_1", cols_in_a, set([1]))
in_1.is_mpc = False
proj_a = sal.project(in_1, "proj_a", ["a", "b"])
proj_a.is_mpc = False
proj_a.out_rel.stored_with = set([1])
cols_in_b = [
defCol("c", "INTEGER", [1], [2]),
defCol("d", "INTEGER", [2])
]
in_2 = sal.create("in_2", cols_in_b, set([2]))
in_2.is_mpc = False
proj_b = sal.project(in_2, "proj_b", ["c", "d"])
proj_b.is_mpc = False
proj_b.out_rel.stored_with = set([2])
cols_in_c = [
defCol("c", "INTEGER", [1], [3]),
defCol("d", "INTEGER", [3])
]
in_3 = sal.create("beforeOthers", cols_in_c, set([1, 2, 3]))
in_3.is_mpc = True
cl_a = sal._close(proj_a, "cl_a", set([1, 2, 3]))
cl_a.is_mpc = True
cl_b = sal._close(proj_b, "cl_b", set([1, 2, 3]))
cl_b.is_mpc = True
cl_c = sal._close(in_3, "cl_c", set([1, 2, 3]))
cl_c.is_mpc = True
right_closed = sal.concat([cl_a, cl_b, cl_c], "a")
right_closed.is_mpc = True
right_closed.out_rel.stored_with = set([1, 2, 3])
shuffled_a = sal.shuffle(cl_a, "shuffled_a")
shuffled_a.is_mpc = True
sal._open(shuffled_a, "ssn_opened", 1)
return saldag.OpDag(set([in_1, in_2, in_3]))
def div_broken():
inputs, rel = setup()
res = sal.divide(rel, "res", "b", [10000, "b"])
opened = sal._open(res, "opened", 1)
return inputs
def mult_mixed():
inputs, rel = setup()
res = sal.multiply(rel, "res", "a", ["a", "b"])
opened = sal._open(res, "opened", 1)
return inputs
def mult_by_const():
inputs, rel = setup()
res = sal.multiply(rel, "res", "a", ["a", 10])
opened = sal._open(res, "opened", 1)
return inputs
def protocol():
inputs, rel = setup()
agg = sal.aggregate(rel, "agg", ["a", "b"], "c", "sum", "agg_1")
out = sal._open(agg, "opened", 1)
return inputs
def div():
inputs, rel = setup()
res = sal.divide(rel, "res", "b", ["b", 2])
opened = sal._open(res, "opened", 1)
return inputs
def protocol():
inputs, rel = setup()
shuf = sal.shuffle(rel, "shuf")
out = sal._open(shuf, "opened", 1)
return inputs
def protocol():
inputs, rel = setup()
mult = sal.multiply(rel, 'mult1', 'a', ['a', 'b'])
opened = sal._open(mult, "opened", 1)
return inputs
def protocol():
inputs, rel = setup()
div = sal.divide(rel, 'div1', 'a', ['a', 1])
opened = sal._open(div, "opened", 1)
return inputs
def agg():
inputs, rel = setup()
res = sal.aggregate(rel, "agg", "a", "b", "+", "total")
opened = sal._open(res, "opened", 1)
return inputs
def proj():
inputs, rel = setup()
res = sal.project(rel, "res", ["a"])
opened = sal._open(res, "opened", 1)
return inputs
def protocol():
# define inputs
cols_in_a = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
]
in_1 = cc.create("in_1", cols_in_a, {1})
in_1.is_mpc = False
proj_a = cc.project(in_1, "proj_a", ["a", "b"])
proj_a.is_mpc = False
proj_a.out_rel.stored_with = {1}
cols_in_b = [
defCol("c", "INTEGER", [1], [2]),
defCol("d", "INTEGER", [2])
]
in_2 = cc.create("in_2", cols_in_b, {2})
in_2.is_mpc = False
proj_b = cc.project(in_2, "proj_b", ["c", "d"])
proj_b.is_mpc = False
proj_b.out_rel.stored_with = {2}
cols_in_c = [
defCol("c", "INTEGER", [1], [3]),
defCol("d", "INTEGER", [3])
]
in_3 = cc.create("beforeOthers", cols_in_c, {1, 2, 3})
in_3.is_mpc = True
cl_a = cc._close(proj_a, "cl_a", {1, 2, 3})
cl_a.is_mpc = True
cl_b = cc._close(proj_b, "cl_b", {1, 2, 3})
cl_b.is_mpc = True
cl_c = cc._close(in_3, "cl_c", {1, 2, 3})
cl_c.is_mpc = True
right_closed = cc.concat([cl_a, cl_b, cl_c], "a")
right_closed.is_mpc = True
right_closed.out_rel.stored_with = {1, 2, 3}
shuffled_a = cc.shuffle(cl_a, "shuffled_a")
shuffled_a.is_mpc = True
cc._open(shuffled_a, "ssn_opened", 1)
return ccdag.OpDag({in_1, in_2, in_3})
def protocol():
inputs, rel = setup()
cols = [column.name for column in rel.out_rel.columns][::-1]
proj = sal.project(rel, "proja", cols)
opened = sal._open(proj, "opened", 1)
return inputs
def hybrid_agg(in1):
shuffled = sal.shuffle(in1, "shuffled")
shuffled.out_rel.stored_with = set([1, 2, 3])
shuffled.is_mpc = True
persisted = sal._persist(shuffled, "persisted")
persisted.out_rel.stored_with = set([1, 2, 3])
persisted.is_mpc = True
keys_closed = sal.project(shuffled, "keys_closed", ["b"])
keys_closed.out_rel.stored_with = set([1, 2, 3])
keys_closed.is_mpc = True
keys = sal._open(keys_closed, "keys", 1)
keys.is_mpc = True
indexed = sal.index(keys, "indexed", "rowIndex")
indexed.is_mpc = False
indexed.out_rel.stored_with = set([1])
sorted_by_key = sal.sort_by(indexed, "sorted_by_key", "b")
sorted_by_key.is_mpc = False
sorted_by_key.out_rel.stored_with = set([1])
eq_flags = sal._comp_neighs(sorted_by_key, "eq_flags", "b")
eq_flags.is_mpc = False
eq_flags.out_rel.stored_with = set([1])
# TODO: should be a persist op
sorted_by_key_stored = sal.project(
sorted_by_key, "sorted_by_key_stored", ["rowIndex", "b"])
sorted_by_key_stored.is_mpc = False
sorted_by_key_stored.out_rel.stored_with = set([1])
closed_eq_flags = sal._close(eq_flags, "closed_eq_flags", set([1, 2, 3]))
closed_eq_flags.is_mpc = True
closed_sorted_by_key = sal._close(
sorted_by_key_stored, "closed_sorted_by_key", set([1, 2, 3]))
closed_sorted_by_key.is_mpc = True
agg = sal.index_aggregate(
persisted, "agg", ["b"], "d", "+", "d", closed_eq_flags, closed_sorted_by_key)
agg.is_mpc = True
sal._open(agg, "ssnopened", 1)
def hybrid_agg(in1):
shuffled = sal.shuffle(in1, "shuffled")
shuffled.out_rel.storedWith = {1, 2, 3}
shuffled.isMPC = True
persisted = sal._persist(shuffled, "persisted")
persisted.out_rel.storedWith = {1, 2, 3}
persisted.isMPC = True
keysclosed = sal.project(shuffled, "keysclosed", ["b"])
keysclosed.out_rel.storedWith = {1, 2, 3}
keysclosed.isMPC = True
keys = sal._open(keysclosed, "keys", 1)
keys.isMPC = True
indexed = sal.index(keys, "indexed", "rowIndex")
indexed.isMPC = False
indexed.out_rel.storedWith = {1}
sortedByKey = sal.sort_by(indexed, "sortedByKey", "b")
sortedByKey.isMPC = False
sortedByKey.out_rel.storedWith = {1}
eqFlags = sal._comp_neighs(sortedByKey, "eqFlags", "b")
eqFlags.isMPC = False
eqFlags.out_rel.storedWith = {1}
# TODO: should be a persist op
sortedByKeyStored = sal.project(sortedByKey, "sortedByKeyStored",
["rowIndex", "b"])
sortedByKeyStored.isMPC = False
sortedByKeyStored.out_rel.storedWith = {1}
closedEqFlags = sal._close(eqFlags, "closedEqFlags", {1, 2, 3})
closedEqFlags.isMPC = True
closedSortedByKey = sal._close(sortedByKeyStored, "closedSortedByKey",
{1, 2, 3})
closedSortedByKey.isMPC = True
agg = sal.index_aggregate(persisted, "agg", ["b"], "d", "+", "d",
closedEqFlags, closedSortedByKey)
agg.isMPC = True
sal._open(agg, "ssnopened", 1)
def protocol():
# define inputs
colsIn1 = [
defCol("companyID", "INTEGER", [1]),
defCol("price", "INTEGER", [1])
]
in1 = sal.create("in1", colsIn1, set([1]))
colsIn2 = [
defCol("companyID", "INTEGER", [2]),
defCol("price", "INTEGER", [2])
]
in2 = sal.create("in2", colsIn2, set([2]))
colsIn3 = [
defCol("companyID", "INTEGER", [3]),
defCol("price", "INTEGER", [3])
]
in3 = sal.create("in3", colsIn3, set([3]))
cl1 = sal._close(in1, "cl1", set([1, 2, 3]))
cl2 = sal._close(in2, "cl2", set([1, 2, 3]))
cl3 = sal._close(in3, "cl3", set([1, 2, 3]))
cab_data = sal.concat([cl1, cl2, cl3], "cab_data")
selected_input = sal.project(cab_data, "selected_input",
["companyID", "price"])
local_rev = sal.aggregate(selected_input, "local_rev", ["companyID"],
"price", "+", "local_rev")
scaled_down = sal.divide(local_rev, "scaled_down", "local_rev",
["local_rev", 1000])
first_val_blank = sal.multiply(scaled_down, "first_val_blank", "companyID",
["companyID", 0])
local_rev_scaled = sal.multiply(first_val_blank, "local_rev_scaled",
"local_rev", ["local_rev", 100])
total_rev = sal.aggregate(first_val_blank, "total_rev", ["companyID"],
"local_rev", "+", "global_rev")
local_total_rev = sal.join(local_rev_scaled, total_rev, "local_total_rev",
["companyID"], ["companyID"])
market_share = sal.divide(local_total_rev, "market_share", "local_rev",
["local_rev", "global_rev"])
market_share_squared = sal.multiply(market_share, "market_share_squared",
"local_rev",
["local_rev", "local_rev", 1])
hhi = sal.aggregate(market_share_squared, "hhi", ["companyID"],
"local_rev", "+", "hhi")
hhi_opened = sal._open(hhi, "hhi_opened", 1)
# return root nodes
return set([in1, in2, in3])
def protocol():
colsIn1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
in1 = sal.create("in1", colsIn1, {1})
colsIn2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2])
]
in2 = sal.create("in2", colsIn2, {2})
cl1 = sal._close(in1, "cl1", {1, 2, 3})
cl2 = sal._close(in2, "cl2", {1, 2, 3})
res = sal.join(cl1, cl2, "res", ["a"], ["a"])
opened = sal._open(res, "opened", 1)
return {in1, in2}
def join():
# define inputs
colsIn1 = [defCol("a", "INTEGER", [1]), defCol("b", "INTEGER", [1])]
in1 = sal.create("in1", colsIn1, set([1]))
colsIn2 = [defCol("c", "INTEGER", [2]), defCol("d", "INTEGER", [2])]
in2 = sal.create("in2", colsIn2, set([2]))
colsIn3 = [defCol("a", "INTEGER", [3]), defCol("b", "INTEGER", [3])]
# TODO: dummy relation for now
in3 = sal.create("in3", colsIn3, set([3]))
cl1 = sal._close(in1, "cl1", set([1, 2, 3]))
cl2 = sal._close(in2, "cl2", set([1, 2, 3]))
cl3 = sal._close(in3, "cl3", set([1, 2, 3]))
res = sal.join(cl1, cl2, "res", ["a"], ["c"])
opened = sal._open(res, "opened", 1)
return set([in1, in2, in3])
def protocol():
# define inputs
colsIn1 = [defCol("a", "INTEGER", [1]), defCol("b", "INTEGER", [1])]
in1 = sal.create("in1", colsIn1, set([1]))
colsIn2 = [defCol("c", "INTEGER", [2]), defCol("d", "INTEGER", [2])]
in2 = sal.create("in2", colsIn2, set([2]))
colsIn3 = [defCol("e", "INTEGER", [3]), defCol("f", "INTEGER", [3])]
in3 = sal.create("in3", colsIn3, set([3]))
cl1 = sal._close(in1, "cl1", set([1, 2, 3]))
cl2 = sal._close(in2, "cl2", set([1, 2, 3]))
cl3 = sal._close(in3, "cl3", set([1, 2, 3]))
rel = sal.concat([cl1, cl2, cl3], "rel")
agg = sal.aggregate(rel, "agg", ["a"], "b", "+", "total")
opened = sal._open(agg, "opened", 1)
# return root nodes
return set([in1, in2, in3])
def protocol():
colsIn1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
in1 = sal.create("in1", colsIn1, set([1]))
colsIn2 = [
defCol("c", "INTEGER", [2]),
defCol("d", "INTEGER", [2])
]
in2 = sal.create("in2", colsIn2, set([2]))
cl1 = sal._close(in1, "cl1", set([1, 2, 3]))
cl2 = sal._close(in2, "cl2", set([1, 2, 3]))
res = sal.join(cl1, cl2, "res", ["a"], ["c"])
opened = sal._open(res, "opened", 1)
return set([in1, in2])
def protocol():
# define inputs
colsIn1 = [defCol("a", "INTEGER", [1]), defCol("b", "INTEGER", [1])]
in1 = sal.create("govreg", colsIn1, set([1]))
colsIn2 = [defCol("c", "INTEGER", [2]), defCol("d", "INTEGER", [2])]
in2 = sal.create("company0", colsIn2, set([2]))
colsIn3 = [defCol("c", "INTEGER", [3]), defCol("d", "INTEGER", [3])]
in3 = sal.create("company1", colsIn3, set([3]))
cl1 = sal._close(in1, "cl1", set([1, 2, 3]))
projA = sal.project(cl1, "projA", ["a", "b"])
cl2 = sal._close(in2, "cl2", set([1, 2, 3]))
cl3 = sal._close(in3, "cl3", set([1, 2, 3]))
right_rel = sal.concat([cl2, cl3], "right_rel")
projB = sal.project(right_rel, "projB", ["c", "d"])
joined = sal.join(projA, right_rel, "joined", ["a"], ["c"])
agg = sal.aggregate(joined, "agg", ["b"], "d", "+", "total")
opened = sal._open(agg, "opened", 1)
return set([in1, in2, in3])
def hybrid_join():
# define inputs
cols_in_a = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
]
in_1 = sal.create("govreg", cols_in_a, set([1]))
in_1.is_mpc = False
proj_a = sal.project(in_1, "proj_a", ["a", "b"])
proj_a.is_mpc = False
proj_a.out_rel.stored_with = set([1])
cols_in_b = [
defCol("c", "INTEGER", [1], [2]),
defCol("d", "INTEGER", [2])
]
in_2 = sal.create("company0", cols_in_b, set([2]))
in_2.is_mpc = False
proj_b = sal.project(in_2, "proj_b", ["c", "d"])
proj_b.is_mpc = False
proj_b.out_rel.stored_with = set([2])
cols_in_c = [
defCol("c", "INTEGER", [1], [3]),
defCol("d", "INTEGER", [3])
]
in_3 = sal.create("company1", cols_in_c, set([3]))
in_3.is_mpc = False
proj_c = sal.project(in_3, "proj_c", ["c", "d"])
proj_c.is_mpc = False
proj_c.out_rel.stored_with = set([3])
cl_a = sal._close(proj_a, "cl_a", set([1, 2, 3]))
cl_a.is_mpc = True
cl_b = sal._close(proj_b, "cl_b", set([1, 2, 3]))
cl_b.is_mpc = True
cl_c = sal._close(proj_c, "cl_c", set([1, 2, 3]))
cl_c.is_mpc = True
right_closed = sal.concat([cl_b, cl_c], "clD")
right_closed.is_mpc = True
right_closed.out_rel.stored_with = set([1, 2, 3])
shuffled_a = sal.shuffle(cl_a, "shuffled_a")
shuffled_a.is_mpc = True
persisted_a = sal._persist(shuffled_a, "persisted_a")
persisted_a.is_mpc = True
shuffled_b = sal.shuffle(right_closed, "shuffled_b")
shuffled_b.is_mpc = True
persisted_b = sal._persist(shuffled_b, "persisted_b")
persisted_b.is_mpc = True
keys_a_closed = sal.project(shuffled_a, "keys_a_closed", ["a"])
keys_a_closed.out_rel.stored_with = set([1, 2, 3])
keys_a_closed.is_mpc = True
keys_b_closed = sal.project(shuffled_b, "keys_b_closed", ["c"])
keys_b_closed.is_mpc = True
keys_b_closed.out_rel.stored_with = set([1, 2, 3])
keys_a = sal._open(keys_a_closed, "keys_a", 1)
keys_a.is_mpc = True
keys_b = sal._open(keys_b_closed, "keys_b", 1)
keys_b.is_mpc = True
indexed_a = sal.index(keys_a, "indexed_a", "index_a")
indexed_a.is_mpc = False
indexed_a.out_rel.stored_with = set([1])
indexed_b = sal.index(keys_b, "indexed_b", "index_b")
indexed_b.is_mpc = False
indexed_b.out_rel.stored_with = set([1])
joined_indeces = sal.join(
indexed_a, indexed_b, "joined_indeces", ["a"], ["c"])
joined_indeces.is_mpc = False
joined_indeces.out_rel.stored_with = set([1])
indeces_only = sal.project(
joined_indeces, "indeces_only", ["index_a", "index_b"])
indeces_only.is_mpc = False
indeces_only.out_rel.stored_with = set([1])
indeces_closed = sal._close(
indeces_only, "indeces_closed", set([1, 2, 3]))
indeces_closed.is_mpc = True
joined = sal._index_join(persisted_a, persisted_b, "joined", [
"a"], ["c"], indeces_closed)
joined.is_mpc = True
return joined, set([in_1, in_2, in_3])
def protocol():
# define inputs
colsInA = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
]
in1 = sal.create("in1", colsInA, set([1]))
in1.isMPC = False
proja = sal.project(in1, "proja", ["a", "b"])
proja.isMPC = False
proja.out_rel.storedWith = set([1])
colsInB = [
defCol("c", "INTEGER", [1], [2]),
defCol("d", "INTEGER", [2])
]
in2 = sal.create("in2", colsInB, set([2]))
in2.isMPC = False
projb = sal.project(in2, "projb", ["c", "d"])
projb.isMPC = False
projb.out_rel.storedWith = set([2])
clA = sal._close(proja, "clA", set([1, 2, 3]))
clA.isMPC = True
clB = sal._close(projb, "clB", set([1, 2, 3]))
clB.isMPC = True
persistedA = sal._persist(clA, "persistedA")
persistedB = sal._persist(clB, "persistedB")
keysaclosed = sal.project(clA, "keysaclosed", ["a"])
keysaclosed.out_rel.storedWith = set([1, 2, 3])
keysaclosed.isMPC = True
keysbclosed = sal.project(clB, "keysbclosed", ["c"])
keysbclosed.isMPC = True
keysbclosed.out_rel.storedWith = set([1, 2, 3])
keysa = sal._open(keysaclosed, "keysa", 1)
keysa.isMPC = True
keysb = sal._open(keysbclosed, "keysb", 1)
keysb.isMPC = True
indexedA = sal.index(keysa, "indexedA", "indexA")
indexedA.isMPC = False
indexedA.out_rel.storedWith = set([1])
indexedB = sal.index(keysb, "indexedB", "indexB")
indexedB.isMPC = False
indexedB.out_rel.storedWith = set([1])
joinedindeces = sal.join(
indexedA, indexedB, "joinedindeces", ["a"], ["c"])
joinedindeces.isMPC = False
joinedindeces.out_rel.storedWith = set([1])
indecesonly = sal.project(
joinedindeces, "indecesonly", ["indexA", "indexB"])
indecesonly.isMPC = False
indecesonly.out_rel.storedWith = set([1])
indecesclosed = sal._close(
indecesonly, "indecesclosed", set([1, 2, 3]))
indecesclosed.isMPC = True
joined = sal._index_join(persistedA, persistedB, "joined",
["a"], ["c"], indecesclosed)
joined.isMPC = True
sal._open(joined, "opened", 1)
# create condag
return set([in1, in2])
def protocol():
# define inputs
colsInA = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
]
in1 = sal.create("in1", colsInA, set([1]))
in1.isMPC = False
proja = sal.project(in1, "proja", ["a", "b"])
proja.isMPC = False
proja.out_rel.storedWith = set([1])
# define inputs
colsInB = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2]),
]
in2 = sal.create("in2", colsInB, set([2]))
in2.isMPC = False
projb = sal.project(in2, "projb", ["a", "b"])
projb.isMPC = False
projb.out_rel.storedWith = set([2])
# define inputs
colsInC = [
defCol("a", "INTEGER", [3]),
defCol("b", "INTEGER", [3]),
]
in3 = sal.create("in3", colsInC, set([3]))
in3.isMPC = False
projc = sal.project(in3, "projc", ["a", "b"])
projc.isMPC = False
projc.out_rel.storedWith = set([3])
clA = sal._close(proja, "clA", set([1, 2, 3]))
clA.isMPC = True
clB = sal._close(projb, "clB", set([1, 2, 3]))
clB.isMPC = True
clC = sal._close(projc, "clC", set([1, 2, 3]))
clC.isMPC = True
comb = sal.concat([clA, clB, clC], "comb")
comb.out_rel.storedWith = set([1, 2, 3])
comb.isMPC = True
shuffled = sal.shuffle(comb, "shuffled")
shuffled.out_rel.storedWith = set([1, 2, 3])
shuffled.isMPC = True
persisted = sal._persist(shuffled, "persisted")
persisted.out_rel.storedWith = set([1, 2, 3])
persisted.isMPC = True
keysclosed = sal.project(shuffled, "keysclosed", ["a"])
keysclosed.out_rel.storedWith = set([1, 2, 3])
keysclosed.isMPC = True
keys = sal._open(keysclosed, "keys", 1)
keys.isMPC = True
indexed = sal.index(keys, "indexed", "rowIndex")
indexed.isMPC = False
indexed.out_rel.storedWith = set([1])
sortedByKey = sal.sort_by(indexed, "sortedByKey", "a")
sortedByKey.isMPC = False
sortedByKey.out_rel.storedWith = set([1])
eqFlags = sal._comp_neighs(sortedByKey, "eqFlags", "a")
eqFlags.isMPC = False
eqFlags.out_rel.storedWith = set([1])
# TODO: hack to get keys stored
# need to fix later!
sortedByKey = sal.project(sortedByKey, "sortedByKey",
["rowIndex", "a"])
sortedByKey.isMPC = False
sortedByKey.out_rel.storedWith = set([1])
closedEqFlags = sal._close(eqFlags, "closedEqFlags", set([1, 2, 3]))
closedEqFlags.isMPC = True
closedSortedByKey = sal._close(sortedByKey, "closedSortedByKey",
set([1, 2, 3]))
closedSortedByKey.isMPC = True
agg = sal.index_aggregate(persisted, "agg", ["a"], "b", "+", "b",
closedEqFlags, closedSortedByKey)
agg.out_rel.storedWith = set([1, 2, 3])
agg.isMPC = True
sal._open(agg, "opened", 1)
# create condag
return set([in1, in2, in3])
def hybrid_join():
# define inputs
colsInA = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
]
in1 = sal.create("govreg", colsInA, {1})
in1.isMPC = False
proja = sal.project(in1, "proja", ["a", "b"])
proja.isMPC = False
proja.out_rel.storedWith = {1}
colsInB = [
defCol("c", "INTEGER", [1], [2]),
defCol("d", "INTEGER", [2])
]
in2 = sal.create("company0", colsInB, {2})
in2.isMPC = False
projb = sal.project(in2, "projb", ["c", "d"])
projb.isMPC = False
projb.out_rel.storedWith = {2}
colsInC = [
defCol("c", "INTEGER", [1], [3]),
defCol("d", "INTEGER", [3])
]
in3 = sal.create("company1", colsInC, {3})
in3.isMPC = False
projc = sal.project(in3, "projc", ["c", "d"])
projc.isMPC = False
projc.out_rel.storedWith = {3}
clA = sal._close(proja, "clA", {1, 2, 3})
clA.isMPC = True
clB = sal._close(projb, "clB", {1, 2, 3})
clB.isMPC = True
clC = sal._close(projc, "clC", {1, 2, 3})
clC.isMPC = True
rightClosed = sal.concat([clB, clC], "clD")
rightClosed.isMPC = True
rightClosed.out_rel.storedWith = {1, 2, 3}
shuffledA = sal.shuffle(clA, "shuffledA")
shuffledA.isMPC = True
persistedA = sal._persist(shuffledA, "persistedA")
persistedA.isMPC = True
shuffledB = sal.shuffle(rightClosed, "shuffledB")
shuffledB.isMPC = True
persistedB = sal._persist(shuffledB, "persistedB")
persistedB.isMPC = True
keysaclosed = sal.project(shuffledA, "keysaclosed", ["a"])
keysaclosed.out_rel.storedWith = {1, 2, 3}
keysaclosed.isMPC = True
keysbclosed = sal.project(shuffledB, "keysbclosed", ["c"])
keysbclosed.isMPC = True
keysbclosed.out_rel.storedWith = {1, 2, 3}
keysa = sal._open(keysaclosed, "keysa", 1)
keysa.isMPC = True
keysb = sal._open(keysbclosed, "keysb", 1)
keysb.isMPC = True
indexedA = sal.index(keysa, "indexedA", "indexA")
indexedA.isMPC = False
indexedA.out_rel.storedWith = {1}
indexedB = sal.index(keysb, "indexedB", "indexB")
indexedB.isMPC = False
indexedB.out_rel.storedWith = {1}
joinedindeces = sal.join(indexedA, indexedB, "joinedindeces", ["a"],
["c"])
joinedindeces.isMPC = False
joinedindeces.out_rel.storedWith = {1}
indecesonly = sal.project(joinedindeces, "indecesonly",
["indexA", "indexB"])
indecesonly.isMPC = False
indecesonly.out_rel.storedWith = {1}
indecesclosed = sal._close(indecesonly, "indecesclosed", {1, 2, 3})
indecesclosed.isMPC = True
joined = sal._index_join(persistedA, persistedB, "joined", ["a"],
["c"], indecesclosed)
joined.isMPC = True
return joined, {in1, in2, in3}
