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():
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():
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():
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():
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():
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():
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():
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():
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", 2) for i in range(num_diagnosis_cols)
]
right_diagnosis = cc.create("right_diagnosis", right_diagnosis_cols, {2})
cohort = cc.concat([left_diagnosis, right_diagnosis], "cohort")
counts = cc.aggregate_count(cohort, "counts", [diagnosis_col], "total")
cc.collect(cc.sort_by(counts, "actual", "total"), 1)
return {left_diagnosis, right_diagnosis}
def protocol():
# define inputs
left_cols = [
defCol("a", "INTEGER", [1]),
defCol("b", "INTEGER", [1]),
]
left = cc.create("left", left_cols, {1})
left_dummy = cc.project(left, "zzz_left_dummy", ["a", "b"])
right_cols = [
defCol("c", "INTEGER", [1], [2]),
defCol("d", "INTEGER", [2])
]
right = cc.create("right", right_cols, {2})
right_dummy = cc.project(right, "right_dummy", ["c", "d"])
actual = cc.join(left_dummy, right_dummy, "actual", ["a"], ["c"])
cc.collect(actual, 1)
# create dag
return {left, right}
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():
"""
A demo protocol which reads data from data/input_relation.csv, computes a multiplication, followed by an aggregation,
and stores the result under data/aggregated.csv.
:return set of input relations
"""
# define the input schema, providing column name, type, and trust set
input_columns = [
defCol("column_a", "INTEGER", [1]),
defCol("column_b", "INTEGER", [1])
]
# define input relation, providing relation name, columns, and owner set
input_relation = lang.create("input_relation", input_columns, {1})
# square column_b, i.e., compute (column_a, column_b) -> (column_a, column_b * column_b)
squared = lang.multiply(input_relation, "squared", "column_b",
["column_b", "column_b"])
# sum group by column_a on column_b and rename group-over column to summed
lang.aggregate(squared, "aggregated", ["column_a"], "column_b", "+",
"summed")
# leaf nodes are automatically written to file so aggregated will be written to ./data/aggregated.csv
# return all input relations
return {input_relation}
def protocol():
left_one_cols = [defCol("a", "INTEGER", 1), defCol("b", "INTEGER", 1)]
left_one = cc.create("left_one", left_one_cols, {1})
right_one_cols = [defCol("c", "INTEGER", 1), defCol("d", "INTEGER", 1)]
right_one = cc.create("right_one", right_one_cols, {1})
left_two_cols = [defCol("a", "INTEGER", 1), defCol("b", "INTEGER", 1)]
left_two = cc.create("left_two", left_two_cols, {1})
right_two_cols = [defCol("c", "INTEGER", 1), defCol("d", "INTEGER", 1)]
right_two = cc.create("right_two", right_two_cols, {1})
left = cc.concat([left_one, left_two], "left")
right = cc.concat([right_one, right_two], "right")
cc.join(left, right, "expected", ["a"], ["c"])
return {left_one, left_two, right_one, right_two}
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]), defCol("d", "INTEGER", [1])]
company0 = cc.create("company0", company0_cols, {1})
company1_cols = [defCol("c", "INTEGER", [1]), defCol("d", "INTEGER", [1])]
company1 = cc.create("company1", company1_cols, {1})
companies = cc.concat([company0, company1], "companies")
joined = cc.join(govreg, companies, "joined", ["a"], ["c"])
cc.aggregate(joined, "expected", ["b"], "d", "sum", "total")
return {govreg, company0, company1}
def protocol():
cols_in_1 = [
defCol("companyID", "INTEGER", [1]),
defCol("price", "INTEGER", [1])
]
in1 = cc.create("in1", cols_in_1, {1})
cols_in_2 = [
defCol("companyID", "INTEGER", [2]),
defCol("price", "INTEGER", [2])
]
in2 = cc.create("in2", cols_in_2, {2})
cols_in_3 = [
defCol("companyID", "INTEGER", [3]),
defCol("price", "INTEGER", [3])
]
in3 = cc.create("in3", cols_in_3, {3})
cab_data = cc.concat([in1, in2, in3], "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")
cc.collect(hhi, 1)
# return root nodes
return {in1, in2, in3}
def protocol(all_pids: list):
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", 1) for i in range(num_med_cols)
]
# public PID column
left_medication_cols[0] = defCol(pid_col_meds, "INTEGER", all_pids)
left_medication = cc.create("left_medication", left_medication_cols, {1})
left_diagnosis_cols = [
defCol(str(i + num_med_cols), "INTEGER", 1)
for i in range(num_diag_cols)
]
# public PID column
left_diagnosis_cols[0] = defCol(pid_col_diags, "INTEGER", all_pids)
left_diagnosis = cc.create("left_diagnosis", left_diagnosis_cols, {1})
right_medication_cols = [
defCol(str(i), "INTEGER", 2) for i in range(num_med_cols)
]
# public PID column
right_medication_cols[0] = defCol(pid_col_meds, "INTEGER", all_pids)
right_medication = cc.create("right_medication", right_medication_cols,
{2})
right_diagnosis_cols = [
defCol(str(i + num_med_cols), "INTEGER", 2)
for i in range(num_diag_cols)
]
# public PID column
right_diagnosis_cols[0] = defCol(pid_col_diags, "INTEGER", all_pids)
right_diagnosis = cc.create("right_diagnosis", right_diagnosis_cols, {2})
medication = cc.concat([left_medication, right_medication], "medication")
diagnosis = cc.concat([left_diagnosis, right_diagnosis], "diagnosis")
# only keep relevant columns
medication_proj = cc.project(medication, "medication_proj",
[pid_col_meds, med_col_meds, date_col_meds])
diagnosis_proj = cc.project(
diagnosis, "diagnosis_proj",
[pid_col_diags, diag_col_diags, date_col_diags])
joined = cc.join(medication_proj, diagnosis_proj, "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.collect(cc.distinct_count(heart_patients, "actual", pid_col_meds), 1)
return {left_medication, left_diagnosis, right_medication, right_diagnosis}
def protocol_mpc(all_pids: list):
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", 1) for i in range(num_med_cols)]
# public PID column
left_medication_cols[0] = defCol(pid_col_meds, "INTEGER", all_pids)
left_medication = cc.create("left_medication", left_medication_cols, {1})
left_diagnosis_cols = [defCol(str(i + num_med_cols), "INTEGER", 1) for i in range(num_diag_cols)]
# public PID column
left_diagnosis_cols[0] = defCol(pid_col_diags, "INTEGER", all_pids)
left_diagnosis = cc.create("left_diagnosis", left_diagnosis_cols, {1})
right_medication_cols = [defCol(str(i), "INTEGER", 2) for i in range(num_med_cols)]
# public PID column
right_medication_cols[0] = defCol(pid_col_meds, "INTEGER", all_pids)
right_medication = cc.create("right_medication", right_medication_cols, {2})
right_diagnosis_cols = [defCol(str(i + num_med_cols), "INTEGER", 2) for i in range(num_diag_cols)]
# public PID column
right_diagnosis_cols[0] = defCol(pid_col_diags, "INTEGER", all_pids)
right_diagnosis = cc.create("right_diagnosis", right_diagnosis_cols, {2})
# Manual slicing
left_keys = cc.union(left_medication, left_diagnosis, "left_pids", pid_col_meds, pid_col_diags)
right_keys = cc.union(right_medication, right_diagnosis, "right_pids", pid_col_meds, pid_col_diags)
left_shared_pids = cc._pub_intersect(left_keys, "a_left_shared_pids", pid_col_meds)
cc._persist(left_shared_pids, "a_left_shared_pids")
right_shared_pids = cc._pub_intersect(right_keys, "a_right_shared_pids", pid_col_meds, is_server=False)
cc._persist(right_shared_pids, "a_right_shared_pids")
left_medication_proj = cc.project(left_medication, "left_medication_proj",
[pid_col_meds, med_col_meds, date_col_meds])
left_medication_shared = cc.filter_by(left_medication_proj, "left_medication_shared", pid_col_meds,
left_shared_pids)
left_diagnosis_proj = cc.project(left_diagnosis, "left_diagnosis_proj",
[pid_col_diags, diag_col_diags, date_col_diags])
left_diagnosis_shared = cc.filter_by(left_diagnosis_proj, "left_diagnosis_shared", pid_col_diags, left_shared_pids)
right_medication_proj = cc.project(right_medication, "right_medication_proj",
[pid_col_meds, med_col_meds, date_col_meds])
right_medication_shared = cc.filter_by(right_medication_proj, "right_medication_shared", pid_col_meds,
right_shared_pids)
right_diagnosis_proj = cc.project(right_diagnosis, "right_diagnosis_proj",
[pid_col_diags, diag_col_diags, date_col_diags])
right_diagnosis_shared = cc.filter_by(right_diagnosis_proj, "right_diagnosis_shared", pid_col_diags,
right_shared_pids)
# Slicing done
medication_shared = cc.concat([left_medication_shared, right_medication_shared], "medication_shared")
diagnosis_shared = cc.concat([left_diagnosis_shared, right_diagnosis_shared], "diagnosis_shared")
joined = cc.join(medication_shared, diagnosis_shared, "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.collect(cc.distinct_count(heart_patients, "actual_mpc", pid_col_meds), 1)
return {
left_medication,
left_diagnosis,
right_medication,
right_diagnosis
}
