def protocol():
inpts = setup()
in_1 = inpts[0]
sb = sal.sort_by(in_1, "sort_by", "a")
out = sal.collect(sb, 1)
return {in_1}
def protocol():
inpts = setup()
in_1 = inpts[0]
sorted = cc.sort_by(in_1, 'sorted1', 'a')
out = cc.collect(sorted, 1)
return {in_1}
def protocol():
inpts = setup()
in_1 = inpts[0]
sorted = sal.sort_by(in_1, 'sorted1', 'a')
out = sal.collect(sorted, 1)
return set([in_1])
def protocol():
diagnosis_col = "12"
num_diagnosis_cols = 13
left_diagnosis_cols = [
defCol(str(i), "INTEGER", 1) for i in range(num_diagnosis_cols)
]
left_diagnosis = cc.create("left_diagnosis", left_diagnosis_cols, {1})
right_diagnosis_cols = [
defCol(str(i), "INTEGER", 1) for i in range(num_diagnosis_cols)
]
right_diagnosis = cc.create("right_diagnosis", right_diagnosis_cols, {1})
cohort = cc.concat([left_diagnosis, right_diagnosis], "cohort")
counts = cc.aggregate_count(cohort, "counts", [diagnosis_col], "total")
cc.sort_by(counts, "expected", "total")
return {left_diagnosis, right_diagnosis}
def protocol():
input_columns_left = [
defCol("column_a", "INTEGER", [1]),
defCol("column_b", "INTEGER", [1])
]
left = cc.create("left", input_columns_left, {1})
input_columns_right = [
defCol("column_a", "INTEGER", [1]),
defCol("column_b", "INTEGER", [1])
]
right = cc.create("right", input_columns_right, {1})
rel = cc.concat([left, right], "rel")
filtered = cc.cc_filter(rel, "filtered", "column_b", "==", scalar=1)
in_order = cc.sort_by(filtered, "in_order", "column_a")
cc.distinct_count(in_order, "expected", "column_a")
return {left, right}
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():
pid_col = "8"
diagnosis_col = "16"
cols_to_skip = 8
num_diagnosis_cols = 13
left_diagnosis_cols = [
defCol(str(i + cols_to_skip), "INTEGER", 1)
for i in range(num_diagnosis_cols)
]
left_diagnosis = cc.create("left_diagnosis", left_diagnosis_cols,
{1})
left_cohort = cc.create("left_cohort",
[defCol("pid", "INTEGER", 1)], {1})
left_selected = cc.filter_by(left_diagnosis, "left_selected",
pid_col, left_cohort)
right_diagnosis_cols = [
defCol(str(i + cols_to_skip), "INTEGER", 2)
for i in range(num_diagnosis_cols)
]
right_diagnosis = cc.create("right_diagnosis",
right_diagnosis_cols, {2})
right_cohort = cc.create("right_cohort",
[defCol("pid", "INTEGER", 2)], {2})
right_selected = cc.filter_by(right_diagnosis, "right_selected",
pid_col, right_cohort)
cohort = cc.concat([left_selected, right_selected], "cohort")
counts = cc.aggregate_count(cohort, "counts", [diagnosis_col],
"total")
cc.collect(cc.sort_by(counts, "actual", "total"), 1)
return {left_diagnosis, left_cohort, right_diagnosis, right_cohort}
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])
