def protocol():
# define inputs
cols_in_1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
defCol("c", "INTEGER", [1])
]
in_1 = cc.create("in_1", cols_in_1, {1})
cols_in_2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2]),
defCol("c", "INTEGER", [2])
]
in_2 = cc.create("in_2", cols_in_2, {2})
# combine parties' inputs into one relation
rel = cc.concat([in_1, in_2], "rel")
projected = cc.project(rel, "projected", ["c", "b"])
# specify the workflow
filtered = cc.cc_filter(projected,
"filtered",
"c",
"==",
other_col_name="b")
cc.collect(filtered, 1)
# return root nodes
return {in_1, in_2}
def setup():
# define inputs
colsIn1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
defCol("c", "INTEGER", [1]),
defCol("d", "INTEGER", [1])
]
colsIn2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2]),
defCol("c", "INTEGER", [2]),
defCol("d", "INTEGER", [2])
]
colsIn3 = [
defCol("a", "INTEGER", [3]),
defCol("b", "INTEGER", [3]),
defCol("c", "INTEGER", [3]),
defCol("d", "INTEGER", [3])
]
in1 = sal.create("in1", colsIn1, {1})
in2 = sal.create("in2", colsIn2, {2})
in3 = sal.create("in3", colsIn3, {3})
cl1 = sal._close(in1, "cl1", {1, 2, 3})
cl2 = sal._close(in2, "cl2", {1, 2, 3})
cl3 = sal._close(in3, "cl3", {1, 2, 3})
rel = sal.concat([cl1, cl2, cl3], "rel")
return {in1, in2, in3}, rel
def protocol():
# define inputs
cols_in_1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
in_1 = sal.create("in_1", cols_in_1, set([1]))
cols_in_2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2])
]
in_2 = sal.create("in_2", cols_in_2, set([2]))
cols_in_3 = [
defCol("a", "INTEGER", [3]),
defCol("b", "INTEGER", [3])
]
in_3 = sal.create("in_3", cols_in_3, set([3]))
# combine parties' inputs into one relation
rel = sal.concat([in_1, in_2, in_3], "rel")
sal.collect(rel, 1)
# return root nodes
return set([in_1, in_2, in_3])
def protocol():
left_one_cols = [
defCol("a", "INTEGER", 1, 2, 3),
defCol("b", "INTEGER", 1)
]
left_one = cc.create("left_one", left_one_cols, {1})
right_one_cols = [
defCol("c", "INTEGER", 1, 2, 3),
defCol("d", "INTEGER", 1)
]
right_one = cc.create("right_one", right_one_cols, {1})
left_two_cols = [
defCol("a", "INTEGER", 1, 2, 3),
defCol("b", "INTEGER", 2)
]
left_two = cc.create("left_two", left_two_cols, {2})
right_two_cols = [
defCol("c", "INTEGER", 1, 2, 3),
defCol("d", "INTEGER", 2)
]
right_two = cc.create("right_two", right_two_cols, {2})
left = cc.concat([left_one, left_two], "left")
right = cc.concat([right_one, right_two], "right")
joined = cc.join(left, right, "actual", ["a"], ["c"])
cc.collect(joined, 1)
return {left_one, left_two, right_one, right_two}
def protocol():
# define inputs
cols_in_1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
in_1 = cc.create("in_1", cols_in_1, {1})
cols_in_2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2])
]
in_2 = cc.create("in_2", cols_in_2, {2})
cols_in_3 = [
defCol("a", "INTEGER", [3]),
defCol("b", "INTEGER", [3])
]
in_3 = cc.create("in_3", cols_in_3, {3})
# combine parties' inputs into one relation
rel = cc.concat([in_1, in_2, in_3], "rel")
proj = cc.project(rel, "proj", ["a", "b"])
agg = cc.aggregate(proj, "agg", ["a"], "b", "sum", "total_b")
cc.collect(agg, 1)
# return root nodes
return {in_1, in_2, in_3}
def protocol():
# define inputs
cols_in_1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
in_1 = sal.create("in_1", cols_in_1, set([1]))
cols_in_2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2])
]
in_2 = sal.create("in_2", cols_in_2, set([2]))
# combine parties' inputs into one relation
rel = sal.concat([in_1, in_2], "rel")
# specify the workflow
proj_a = sal.project(rel, "proj_a", ["a", "b"])
proj_b = sal.project(proj_a, "proj_b", ["a", "b"])
agg = sal.aggregate(proj_b, "agg", ["a"], "b", "+", "total_b")
proj_c = sal.project(agg, "proj_c", ["a", "total_b"])
sal.collect(proj_c, 1)
# return root nodes
return set([in_1, in_2])
def protocol_local(suffix: str, pid: int):
pid_col_meds = "0"
med_col_meds = "4"
date_col_meds = "7"
pid_col_diags = "8"
diag_col_diags = "16"
date_col_diags = "18"
num_med_cols = 8
num_diag_cols = 13
left_medication_cols = [defCol(str(i), "INTEGER", pid) for i in range(num_med_cols)]
medication = cc.create(suffix + "_medication", left_medication_cols, {pid})
left_diagnosis_cols = [defCol(str(i + num_med_cols), "INTEGER", pid) for i in range(num_diag_cols)]
diagnosis = cc.create(suffix + "_diagnosis", left_diagnosis_cols, {pid})
shared_pids = cc.create("a_{}_shared_pids".format(suffix), [defCol(pid_col_meds, "INTEGER", pid)], {pid})
# only keep relevant columns
medication_proj = cc.project(medication, "medication_proj", [pid_col_meds, med_col_meds, date_col_meds])
medication_mine = cc.filter_by(medication_proj, "medication_mine", pid_col_meds, shared_pids, use_not_in=True)
diagnosis_proj = cc.project(diagnosis, "diagnosis_proj", [pid_col_diags, diag_col_diags, date_col_diags])
diagnosis_mine = cc.filter_by(diagnosis_proj, "diagnosis_mine", pid_col_diags, shared_pids, use_not_in=True)
joined = cc.join(medication_mine, diagnosis_mine, "joined", [pid_col_meds], [pid_col_diags])
cases = cc.cc_filter(joined, "cases", date_col_diags, "<", other_col_name=date_col_meds)
aspirin = cc.cc_filter(cases, "aspirin", med_col_meds, "==", scalar=1)
heart_patients = cc.cc_filter(aspirin, "heart_patients", diag_col_diags, "==", scalar=1)
cc.distinct_count(heart_patients, "actual_" + suffix, pid_col_meds)
return {medication, diagnosis}
def protocol():
# define inputs
colsInA = [("INTEGER", set([1])), ("INTEGER", set([1]))]
inA = sal.create("inA", colsInA, set([1]))
colsInB = [("INTEGER", set([2])), ("INTEGER", set([2]))]
inB = sal.create("inB", colsInB, set([2]))
colsInC = [("INTEGER", set([3])), ("INTEGER", set([3])),
("INTEGER", set([3]))]
inC = sal.create("inC", colsInC, set([3]))
# specify the workflow
aggA = sal.aggregate(inA, "aggA", "inA_0", "inA_1", "+")
projA = sal.project(aggA, "projA", ["aggA_0", "aggA_1"])
aggB = sal.aggregate(inB, "aggB", "inB_0", "inB_1", "+")
projB = sal.project(aggB, "projB", ["aggB_0", "aggB_1"])
joined = sal.join(projA, projB, "joined", "projA_0", "projB_0")
comb = sal.concat([inC, joined], "comb")
sal.collect(comb, 3)
# create condag
return set([inA, inB, inC])
def protocol():
# define inputs
cols_in_1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
in_1 = cc.create("in_1", cols_in_1, {1})
cols_in_2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2])
]
in_2 = cc.create("in_2", cols_in_2, {2})
cols_in_3 = [
defCol("a", "INTEGER", [3]),
defCol("b", "INTEGER", [3])
]
in_3 = cc.create("in_3", cols_in_3, {3})
# combine parties' inputs into one relation
rel = cc.concat([in_1, in_2, in_3], "rel")
cc.collect(rel, 1)
# return root nodes
return {in_1, in_2, in_3}
def protocol():
# define inputs
cols_in_1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
in_1 = sal.create("in_1", cols_in_1, set([1]))
cols_in_2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2])
]
in_2 = sal.create("in_2", cols_in_2, set([2]))
cols_in_3 = [
defCol("a", "INTEGER", [3]),
defCol("b", "INTEGER", [3])
]
in_3 = sal.create("in_3", cols_in_3, set([3]))
# combine parties' inputs into one relation
rel = sal.concat([in_1, in_2, in_3], "rel")
proj = sal.project(rel, "proj", ["a", "b"])
agg = sal.aggregate(proj, "agg", ["a"], "b", "+", "total_b")
sal.collect(agg, 1)
# return root nodes
return set([in_1, in_2, in_3])
def protocol():
govreg_cols = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
govreg = cc.create("govreg", govreg_cols, {1})
company0_cols = [
defCol("c", "INTEGER", [1], [2]),
defCol("d", "INTEGER", [2])
]
company0 = cc.create("company0", company0_cols, {2})
company1_cols = [
defCol("c", "INTEGER", [1], [3]),
defCol("d", "INTEGER", [3])
]
company1 = cc.create("company1", company1_cols, {3})
companies = cc.concat([company0, company1], "companies")
joined = cc.join(govreg, companies, "joined", ["a"], ["c"])
actual = cc.aggregate(joined, "actual", ["b"], "d", "sum", "total")
cc.collect(actual, 1)
return {govreg, company0, company1}
def protocol():
"""
Define inputs and operations to be performed between them.
"""
# define input columns
cols_in_a = [
defCol('a', 'INTEGER', [2]),
defCol('b', 'INTEGER', [2]),
]
cols_in_b = [
defCol('a', 'INTEGER', [2]),
defCol('c', 'INTEGER', [2]),
]
cols_in_c = [defCol('a', 'INTEGER', [2]), defCol('d', 'INTEGER', [2])]
# instantiate input columns
# NOTE: input file names will correspond to the 0th arg of each create call ("in1", "in2", etc.)
in1 = sal.create("in1", cols_in_a, {2})
in2 = sal.create("in2", cols_in_b, {2})
in3 = sal.create("in3", cols_in_c, {2})
# operate on columns
# join in1 & in2 over the column 'a', name output relation 'join1'
join1 = sal.join(in1, in2, 'join1', ['a'], ['a'])
join2 = sal.join(join1, in3, 'join2', ['a'], ['a'])
# collect leaf node
out = sal.collect(join2, 2)
# return root nodes
return {in1, in2, in3}
def setup():
# define inputs
colsIn1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
defCol("c", "INTEGER", [1]),
defCol("d", "INTEGER", [1])
]
colsIn2 = [
defCol("a", "INTEGER", [2]),
defCol("b", "INTEGER", [2]),
defCol("c", "INTEGER", [2]),
defCol("d", "INTEGER", [2])
]
colsIn3 = [
defCol("a", "INTEGER", [3]),
defCol("b", "INTEGER", [3]),
defCol("c", "INTEGER", [3]),
defCol("d", "INTEGER", [3])
]
in1 = sal.create("in1", colsIn1, set([1]))
in2 = sal.create("in2", colsIn2, set([2]))
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")
return set([in1, in2, in3]), rel
def protocol():
cols_in_1 = [defCol("a", "INTEGER", 1), defCol("b", "INTEGER", 1)]
in_1 = cc.create("in_1", cols_in_1, {1})
cols_in_2 = [defCol("a", "INTEGER", 2), defCol("b", "INTEGER", 2)]
in_2 = cc.create("in_2", cols_in_2, {2})
cc._pub_intersect(in_1, "actual_1", "a")
cc._pub_intersect(in_2, "actual_2", "a", is_server=False)
return {in_1, in_2}
def protocol():
left_cols = [defCol("a", "INTEGER", [1]), defCol("b", "INTEGER", [1])]
left = cc.create("left", left_cols, {1})
right_cols = [defCol("c", "INTEGER", [1]), defCol("d", "INTEGER", [1])]
right = cc.create("right", right_cols, {1})
joined = cc.join(left, right, "joined", ["a"], ["c"])
cc.aggregate(joined, "expected", ["b"], "d", "sum", "total")
return {left, right}
def protocol():
cols_in1 = [
defCol("companyID", "INTEGER", [1]),
defCol("price", "INTEGER", [1])
]
in1 = sal.create("green1", cols_in1, {1})
cols_in2 = [
defCol("companyID", "INTEGER", [2]),
defCol("price", "INTEGER", [2])
]
in2 = sal.create("green2", cols_in2, {2})
cols_in3 = [
defCol("companyID", "INTEGER", [3]),
defCol("price", "INTEGER", [3])
]
in3 = sal.create("green3", cols_in3, {3})
cab_data = sal.concat([in1, in2, in3], "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")
sal.collect(hhi, 1)
# return root nodes
return {in1, in2, in3}
def setup():
cols = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
defCol("c", "INTEGER", [1]),
defCol("d", "INTEGER", [1])
]
in_1 = sal.create("in_1", cols, {1})
in_2 = sal.create("in_2", cols, {1})
return [in_1, in_2]
def protocol():
left_cols = [defCol("a", "INTEGER", [1]), defCol("b", "INTEGER", [1])]
left = cc.create("left", left_cols, {1})
left_dummy = cc.project(left, "left_dummy", ["a", "b"])
right_cols = [defCol("c", "INTEGER", [2]), defCol("d", "INTEGER", [2])]
right = cc.create("right", right_cols, {2})
right_dummy = cc.project(right, "right_dummy", ["c", "d"])
joined = cc.join(left_dummy, right_dummy, "joined", ["a"], ["c"])
cc.collect(cc.aggregate(joined, "actual", ["b"], "d", "sum", "total"), 1)
return {left, right}
def protocol():
cols_in_1 = [
defCol("companyID", "INTEGER", [1]),
defCol("price", "INTEGER", [1])
]
in_1 = cc.create("yellow1", cols_in_1, {1})
cols_in_2 = [
defCol("companyID", "INTEGER", [2]),
defCol("price", "INTEGER", [2])
]
in_2 = cc.create("yellow2", cols_in_2, {2})
cols_in_3 = [
defCol("companyID", "INTEGER", [3]),
defCol("price", "INTEGER", [3])
]
in_3 = cc.create("yellow3", cols_in_3, {3})
cab_data = cc.concat([in_1, in_2, in_3], "cab_data")
selected_input = cc.project(cab_data, "selected_input",
["companyID", "price"])
local_rev = cc.aggregate(selected_input, "local_rev",
["companyID"], "price", "sum",
"local_rev")
scaled_down = cc.divide(local_rev, "scaled_down", "local_rev",
["local_rev", 1000])
first_val_blank = cc.multiply(scaled_down, "first_val_blank",
"companyID", ["companyID", 0])
local_rev_scaled = cc.multiply(first_val_blank, "local_rev_scaled",
"local_rev", ["local_rev", 100])
total_rev = cc.aggregate(first_val_blank, "total_rev",
["companyID"], "local_rev", "sum",
"global_rev")
local_total_rev = cc.join(local_rev_scaled, total_rev,
"local_total_rev", ["companyID"],
["companyID"])
market_share = cc.divide(local_total_rev, "market_share",
"local_rev", ["local_rev", "global_rev"])
market_share_squared = cc.multiply(market_share,
"market_share_squared",
"local_rev",
["local_rev", "local_rev", 1])
hhi = cc.aggregate(market_share_squared, "hhi", ["companyID"],
"local_rev", "sum", "hhi")
# dummy projection to force non-mpc subdag
hhi_only = cc.project(hhi, "hhi_only", ["companyID", "hhi"])
cc.collect(hhi_only, 1)
# return root nodes
return {in_1, in_2, in_3}
def setup():
colsIn1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
defCol("c", "INTEGER", [1]),
defCol("d", "INTEGER", [1])
]
in1 = sal.create("in1", colsIn1, set([1]))
in2 = sal.create("in2", colsIn1, set([1]))
return [in1, in2]
def protocol():
input_columns_left = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
left = cc.create("left", input_columns_left, {1})
input_columns_right = [
defCol("c", "INTEGER", [1]),
defCol("d", "INTEGER", [1])
]
right = cc.create("right", input_columns_right, {1})
expected = cc.join(left, right, "expected", ["a"], ["c"])
return {left, right}
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():
cols_in_1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1])
]
in_1 = cc.create("in_1", cols_in_1, {1})
cols_in_2 = [
defCol("a", "INTEGER", [1], [2]),
defCol("b", "INTEGER", [2])
]
in_2 = cc.create("in_2", cols_in_2, {2})
cc.collect(
cc.aggregate(cc.concat([in_1, in_2], "rel"), "agg", ["a"], "b",
"sum", "total_b"), 1)
return {in_1, in_2}
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_c", "INTEGER", [1])
]
right = cc.create("right", input_columns_right, {1})
cc.collect(
cc.aggregate(cc.concat([left, right], "rel"), "expected", ["column_a"],
"column_b", "sum", "total_b"), 1)
return {left, right}
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 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 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():
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], [2]),
defCol("column_c", "INTEGER", [1])
]
right = cc.create("right", input_columns_right, {2})
aggregated = cc.aggregate(cc.concat([left, right], "rel"), "actual",
["column_a"], "column_b", "sum", "total_b")
actual_open = cc.project(aggregated, "actual_open",
["column_a", "total_b"])
cc.collect(actual_open, 1)
return {left, right}
def protocol():
cols_in_1 = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
]
in_1 = sal.create("in_1", cols_in_1, set([1]))
cols_in_2 = [
defCol("c", "INTEGER", [2]),
defCol("d", "INTEGER", [2])
]
in_2 = sal.create("in_2", cols_in_2, set([2]))
proj_b = sal.project(in_2, "proj_b", ["c", "d"])
joined = sal.join(in_1, proj_b, "joined", ["a"], ["c"])
sal.collect(joined, 1)
return set([in_1, in_2])
def protocol():
cols_in_1 = [
defCol("companyID", "INTEGER", [1]),
defCol("price", "INTEGER", [1])
]
cols_in_2 = [
defCol("companyID", "INTEGER", [1]),
defCol("price", "INTEGER", [1])
]
cols_in_3 = [
defCol("companyID", "INTEGER", [1]),
defCol("price", "INTEGER", [1])
]
yellow1 = sal.create("yellow1", cols_in_1, {1})
yellow2 = sal.create("yellow2", cols_in_2, {1})
yellow3 = sal.create("yellow3", cols_in_3, {1})
cab_data = sal.concat([yellow1, yellow2, yellow3], "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")
sal.collect(hhi, 1)
return {yellow1, yellow2, yellow3}
