From 4772e7afe8a832c4036fa9baaf114e0d3fa84753 Mon Sep 17 00:00:00 2001 From: mwang87 Date: Thu, 12 Mar 2026 21:25:49 -0700 Subject: [PATCH 1/5] suppoting less and gt in intensity --- massql/msql_engine.py | 19 ++--- massql/msql_engine_filters.py | 146 ++++++++++++++++++---------------- massql/msql_parser.py | 7 ++ tests/test_agent_dev.py | 85 ++++++++++++++++++++ 4 files changed, 177 insertions(+), 80 deletions(-) create mode 100644 tests/test_agent_dev.py diff --git a/massql/msql_engine.py b/massql/msql_engine.py index 5af50a3..ef266ce 100644 --- a/massql/msql_engine.py +++ b/massql/msql_engine.py @@ -10,7 +10,7 @@ from massql import msql_parser from massql import msql_fileloading from massql import msql_engine_filters -from massql.msql_engine_filters import _get_mz_tolerance, _get_minintensity +from massql.msql_engine_filters import _get_mz_tolerance, _get_minintensity, _get_intensity_mask math_parser = Parser() console = logging.StreamHandler() @@ -224,11 +224,8 @@ def _evalute_variable_query(parsed_dict, input_filename, # Filtering MS1 peaks only to consider contention for X if condition["type"] == "ms1mzcondition": - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) - variable_x_ms1_df = ms1_df[ - (ms1_df["i"] > min_int) & - (ms1_df["i_norm"] > min_intpercent) & - (ms1_df["i_tic_norm"] > min_tic_percent_intensity)] + intensity_mask = _get_intensity_mask(ms1_df, condition.get("qualifiers", None)) + variable_x_ms1_df = ms1_df[intensity_mask] # TODO: Do this for other types of variables @@ -546,13 +543,11 @@ def _executeconditions_query(parsed_dict, input_filename, ms1_input_df=None, ms2 mz_min = mz - mz_tol mz_max = mz + mz_tol - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) + intensity_mask = _get_intensity_mask(ms2_df, condition.get("qualifiers", None)) - ms2_df = ms2_df[(ms2_df["mz"] > mz_min) & - (ms2_df["mz"] < mz_max) & - (ms2_df["i"] > min_int) & - (ms2_df["i_norm"] > min_intpercent) & - (ms2_df["i_tic_norm"] > min_tic_percent_intensity)] + ms2_df = ms2_df[(ms2_df["mz"] > mz_min) & + (ms2_df["mz"] < mz_max) & + intensity_mask] if "comment" in parsed_dict: ms1_df["comment"] = parsed_dict["comment"] diff --git a/massql/msql_engine_filters.py b/massql/msql_engine_filters.py index 82bcd26..f2236c7 100644 --- a/massql/msql_engine_filters.py +++ b/massql/msql_engine_filters.py @@ -62,6 +62,40 @@ def _get_minintensity(qualifier): return min_intensity, min_percent_intensity, min_tic_percent_intensity +def _get_intensity_mask(df, qualifier): + """ + Returns a boolean mask for intensity filtering, respecting >, <, = comparators. + Falls back to > 0 for columns without a specific qualifier. + """ + if qualifier is None: + return (df["i"] > 0) & (df["i_norm"] > 0) & (df["i_tic_norm"] > 0) + + masks = [] + for qual_key, col, scale in [ + ("qualifierintensityvalue", "i", 1.0), + ("qualifierintensitypercent", "i_norm", 100.0), + ("qualifierintensityticpercent", "i_tic_norm", 100.0), + ]: + if qual_key in qualifier: + val = float(qualifier[qual_key]["value"]) / scale + comp = qualifier[qual_key].get("comparator", "greaterthan") + if comp == "greaterthan": + if scale > 1.0: + val = min(val, 0.99) + masks.append(df[col] > val) + elif comp == "lessthan": + masks.append(df[col] < val) + else: # equal → minimum threshold (>= val), preserving historical semantics + masks.append(df[col] >= val) + else: + masks.append(df[col] > 0) + + result = masks[0] + for m in masks[1:]: + result = result & m + return result + + def _get_exclusion_flag(qualifiers): if qualifiers is None: return False @@ -199,30 +233,26 @@ def ms2prod_condition(condition, ms1_df, ms2_df, reference_conditions_register): if mz == "ANY": # Checking defect options massdefect_min, massdefect_max = _get_massdefect_min(condition.get("qualifiers", None)) - ms2_filtered_df = ms2_df + ms2_filtered_df = ms2_df.copy() ms2_filtered_df["mz_defect"] = ms2_filtered_df["mz"] - ms2_filtered_df["mz"].astype(int) - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) + intensity_mask = _get_intensity_mask(ms2_filtered_df, condition.get("qualifiers", None)) ms2_filtered_df = ms2_filtered_df[ - (ms2_filtered_df["mz_defect"] > massdefect_min) & + (ms2_filtered_df["mz_defect"] > massdefect_min) & (ms2_filtered_df["mz_defect"] < massdefect_max) & - (ms2_filtered_df["i"] > min_int) & - (ms2_filtered_df["i_norm"] > min_intpercent) & - (ms2_filtered_df["i_tic_norm"] > min_tic_percent_intensity) + intensity_mask ] else: mz_tol = _get_mz_tolerance(condition.get("qualifiers", None), mz) mz_min = mz - mz_tol mz_max = mz + mz_tol - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) + intensity_mask = _get_intensity_mask(ms2_df, condition.get("qualifiers", None)) - ms2_filtered_df = ms2_df[(ms2_df["mz"] > mz_min) & - (ms2_df["mz"] < mz_max) & - (ms2_df["i"] > min_int) & - (ms2_df["i_norm"] > min_intpercent) & - (ms2_df["i_tic_norm"] > min_tic_percent_intensity)] + ms2_filtered_df = ms2_df[(ms2_df["mz"] > mz_min) & + (ms2_df["mz"] < mz_max) & + intensity_mask] # Setting the intensity match register _set_intensity_register(ms2_filtered_df, reference_conditions_register, condition) @@ -283,31 +313,27 @@ def ms2nl_condition(condition, ms1_df, ms2_df, reference_conditions_register): if mz == "ANY": # Checking defect options massdefect_min, massdefect_max = _get_massdefect_min(condition.get("qualifiers", None)) - ms2_filtered_df = ms2_df + ms2_filtered_df = ms2_df.copy() ms2_filtered_df["mz_defect"] = ms2_filtered_df["mz"] - ms2_filtered_df["mz"].astype(int) - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) + intensity_mask = _get_intensity_mask(ms2_filtered_df, condition.get("qualifiers", None)) ms2_filtered_df = ms2_filtered_df[ - (ms2_filtered_df["mz_defect"] > massdefect_min) & + (ms2_filtered_df["mz_defect"] > massdefect_min) & (ms2_filtered_df["mz_defect"] < massdefect_max) & - (ms2_filtered_df["i"] > min_int) & - (ms2_filtered_df["i_norm"] > min_intpercent) & - (ms2_filtered_df["i_tic_norm"] > min_tic_percent_intensity) + intensity_mask ] else: mz_tol = _get_mz_tolerance(condition.get("qualifiers", None), mz) #TODO: This is incorrect logic if it comes to PPM accuracy nl_min = mz - mz_tol nl_max = mz + mz_tol - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) + intensity_mask = _get_intensity_mask(ms2_df, condition.get("qualifiers", None)) ms2_filtered_df = ms2_df[ - ((ms2_df["precmz"] - ms2_df["mz"]) > nl_min) & + ((ms2_df["precmz"] - ms2_df["mz"]) > nl_min) & ((ms2_df["precmz"] - ms2_df["mz"]) < nl_max) & - (ms2_df["i"] > min_int) & - (ms2_df["i_norm"] > min_intpercent) & - (ms2_df["i_tic_norm"] > min_tic_percent_intensity) + intensity_mask ] # Setting the intensity match register @@ -440,17 +466,15 @@ def ms1_condition(condition, ms1_df, ms2_df, reference_conditions_register, ms1_ if mz == "ANY": # Checking defect options massdefect_min, massdefect_max = _get_massdefect_min(condition.get("qualifiers", None)) - ms1_filtered_df = ms1_df + ms1_filtered_df = ms1_df.copy() ms1_filtered_df["mz_defect"] = ms1_filtered_df["mz"] - ms1_filtered_df["mz"].astype(int) - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) + intensity_mask = _get_intensity_mask(ms1_filtered_df, condition.get("qualifiers", None)) ms1_filtered_df = ms1_filtered_df[ - (ms1_filtered_df["mz_defect"] > massdefect_min) & + (ms1_filtered_df["mz_defect"] > massdefect_min) & (ms1_filtered_df["mz_defect"] < massdefect_max) & - (ms1_filtered_df["i"] > min_int) & - (ms1_filtered_df["i_norm"] > min_intpercent) & - (ms1_filtered_df["i_tic_norm"] > min_tic_percent_intensity) + intensity_mask ] else: # Checking defect options @@ -460,23 +484,21 @@ def ms1_condition(condition, ms1_df, ms2_df, reference_conditions_register, ms1_ mz_min = mz - mz_tol mz_max = mz + mz_tol - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) - otherscan_qualifier = _get_otherscan_qualifier(condition.get("qualifiers", None)) if otherscan_qualifier is None: + intensity_mask = _get_intensity_mask(ms1_df, condition.get("qualifiers", None)) + ms1_filtered_df = ms1_df[ - (ms1_df["mz"] > mz_min) & - (ms1_df["mz"] < mz_max) & - (ms1_df["i"] > min_int) & - (ms1_df["i_norm"] > min_intpercent) & - (ms1_df["i_tic_norm"] > min_tic_percent_intensity)] + (ms1_df["mz"] > mz_min) & + (ms1_df["mz"] < mz_max) & + intensity_mask] if massdefect_min > 0 or massdefect_max < 1: ms1_filtered_df["mz_defect"] = ms1_filtered_df["mz"] - ms1_filtered_df["mz"].astype(int) - + ms1_filtered_df = ms1_filtered_df[ - (ms1_filtered_df["mz_defect"] > massdefect_min) & + (ms1_filtered_df["mz_defect"] > massdefect_min) & (ms1_filtered_df["mz_defect"] < massdefect_max) ] else: @@ -485,33 +507,25 @@ def ms1_condition(condition, ms1_df, ms2_df, reference_conditions_register, ms1_ scans_to_keep = [] + intensity_mask_original = _get_intensity_mask(ms1_original_df, condition.get("qualifiers", None)) + for scan, row in grouped_df.iterrows(): current_scan_rt = row["rt"] - + min_original_rt = current_scan_rt - otherscan_qualifier["min"] max_original_rt = current_scan_rt + otherscan_qualifier["max"] - print("RT RANGE", min_original_rt, max_original_rt) - - print("mz_min", mz_min) - print("mz_max", mz_max) - print("min_int", min_int) - print("min_intpercent", min_intpercent) - print("min_tic_percent_intensity", min_tic_percent_intensity) - ms1_original_filtered_df = ms1_original_df[ - (ms1_original_df["mz"] > mz_min) & - (ms1_original_df["mz"] < mz_max) & - (ms1_original_df["i"] > min_int) & - (ms1_original_df["i_norm"] > min_intpercent) & - (ms1_original_df["i_tic_norm"] > min_tic_percent_intensity) & + (ms1_original_df["mz"] > mz_min) & + (ms1_original_df["mz"] < mz_max) & + intensity_mask_original & (ms1_original_df["rt"] > min_original_rt) & (ms1_original_df["rt"] < max_original_rt)] - + if len(ms1_original_filtered_df) > 0: # This means, the current scan we're considering is a scan that is valid to keep scans_to_keep.append(scan) - + # Lets filter the ms1_filtered to only the scans we want to keep ms1_filtered_df = ms1_df[ms1_df["scan"].isin(scans_to_keep)] @@ -570,39 +584,35 @@ def ms1_filter(condition, ms1_df): if mz == "ANY": # Checking defect options massdefect_min, massdefect_max = _get_massdefect_min(condition.get("qualifiers", None)) - ms1_filtered_df = ms1_df + ms1_filtered_df = ms1_df.copy() ms1_filtered_df["mz_defect"] = ms1_filtered_df["mz"] - ms1_filtered_df["mz"].astype(int) - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) + intensity_mask = _get_intensity_mask(ms1_filtered_df, condition.get("qualifiers", None)) ms1_filtered_df = ms1_filtered_df[ - (ms1_filtered_df["mz_defect"] > massdefect_min) & + (ms1_filtered_df["mz_defect"] > massdefect_min) & (ms1_filtered_df["mz_defect"] < massdefect_max) & - (ms1_filtered_df["i"] > min_int) & - (ms1_filtered_df["i_norm"] > min_intpercent) & - (ms1_filtered_df["i_tic_norm"] > min_tic_percent_intensity) + intensity_mask ] else: # Checking defect options massdefect_min, massdefect_max = _get_massdefect_min(condition.get("qualifiers", None)) - + mz_tol = _get_mz_tolerance(condition.get("qualifiers", None), mz) mz_min = mz - mz_tol mz_max = mz + mz_tol - min_int, min_intpercent, min_tic_percent_intensity = _get_minintensity(condition.get("qualifiers", None)) + intensity_mask = _get_intensity_mask(ms1_df, condition.get("qualifiers", None)) ms1_filtered_df = ms1_df[ - (ms1_df["mz"] > mz_min) & - (ms1_df["mz"] < mz_max) & - (ms1_df["i"] > min_int) & - (ms1_df["i_norm"] > min_intpercent) & - (ms1_df["i_tic_norm"] > min_tic_percent_intensity)] + (ms1_df["mz"] > mz_min) & + (ms1_df["mz"] < mz_max) & + intensity_mask] if massdefect_min > 0 or massdefect_max < 1: ms1_filtered_df["mz_defect"] = ms1_filtered_df["mz"] - ms1_filtered_df["mz"].astype(int) ms1_filtered_df = ms1_filtered_df[ - (ms1_filtered_df["mz_defect"] > massdefect_min) & + (ms1_filtered_df["mz_defect"] > massdefect_min) & (ms1_filtered_df["mz_defect"] < massdefect_max) ] diff --git a/massql/msql_parser.py b/massql/msql_parser.py index aad7db9..12838ff 100644 --- a/massql/msql_parser.py +++ b/massql/msql_parser.py @@ -146,6 +146,13 @@ def qualifier(self, items): qualifier_dict[qualifier_type] = {} qualifier_dict[qualifier_type]["name"] = qualifier_type + # Capture the comparator operator (equal, greaterthan, lessthan) + operator_tree = items[1] + if hasattr(operator_tree, 'data'): + qualifier_dict[qualifier_type]["comparator"] = operator_tree.data + else: + qualifier_dict[qualifier_type]["comparator"] = "equal" + if qualifier_type == "qualifierppmtolerance": qualifier_dict[qualifier_type]["unit"] = "ppm" if qualifier_type == "qualifiermztolerance": diff --git a/tests/test_agent_dev.py b/tests/test_agent_dev.py new file mode 100644 index 0000000..a6949f5 --- /dev/null +++ b/tests/test_agent_dev.py @@ -0,0 +1,85 @@ +import os +import sys + +# Making sure the root is in the path, kind of a hack +sys.path.insert(0, os.path.join(os.path.dirname(__file__), "..")) + +from massql import msql_engine + + +def test_ms2_intensity_gt_lt_eq_dev(): + """ + Development test for intensity comparators on a realistic multi-fragment query. + + This uses a known MGF in the test data folder and compares scan hits across + `>`, `<`, and `=` variants of the same constraints. + """ + + data_file = "tests/data/featurelist_pos.mgf" + + query_gt = ( + "QUERY scaninfo(MS2DATA) WHERE " + "MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYPERCENT>30:INTENSITYVALUE>500 AND " + "MS2PROD=125.0004:TOLERANCEMZ=0.01:INTENSITYPERCENT>10:INTENSITYVALUE>1500 AND " + "MS2PROD=104.1075:TOLERANCEMZ=0.01 AND " + "MS2PROD=86.09697:TOLERANCEMZ=0.01:INTENSITYPERCENT>10:INTENSITYVALUE>2000 AND " + "SCANMIN=1000 AND SCANMAX=1020" + ) + + # LT uses only INTENSITYPERCENT (no INTENSITYVALUE): absolute intensities in this + # data are in the tens-of-thousands range, so a tight INTENSITYVALUE<500 would + # exclude all real peaks. Using the same relative thresholds (30%, 10%) as GT + # guarantees the GT and LT scan sets are disjoint (no scan can have a fragment + # at both >30% and <30% of the scan maximum simultaneously). + query_lt = ( + "QUERY scaninfo(MS2DATA) WHERE " + "MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYPERCENT<30 AND " + "MS2PROD=125.0004:TOLERANCEMZ=0.01:INTENSITYPERCENT<10 AND " + "MS2PROD=104.1075:TOLERANCEMZ=0.01 AND " + "MS2PROD=86.09697:TOLERANCEMZ=0.01:INTENSITYPERCENT<10 AND " + "SCANMIN=1000 AND SCANMAX=1020" + ) + + # EQ with exact floating-point thresholds will realistically return nothing, + # but the assertion only requires EQ to differ from at least one of GT or LT. + query_eq = ( + "QUERY scaninfo(MS2DATA) WHERE " + "MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYPERCENT=30 AND " + "MS2PROD=125.0004:TOLERANCEMZ=0.01:INTENSITYPERCENT=10 AND " + "MS2PROD=104.1075:TOLERANCEMZ=0.01 AND " + "MS2PROD=86.09697:TOLERANCEMZ=0.01:INTENSITYPERCENT=10 AND " + "SCANMIN=1000 AND SCANMAX=1020" + ) + + results_gt = msql_engine.process_query(query_gt, data_file) + results_lt = msql_engine.process_query(query_lt, data_file) + results_eq = msql_engine.process_query(query_eq, data_file) + + scans_gt = set(results_gt["scan"]) if "scan" in results_gt else set() + scans_lt = set(results_lt["scan"]) if "scan" in results_lt else set() + scans_eq = set(results_eq["scan"]) if "scan" in results_eq else set() + + print("GT scans:", sorted(scans_gt)) + print("LT scans:", sorted(scans_lt)) + print("EQ scans:", sorted(scans_eq)) + + # Ensure we are testing against real hits instead of empty trivial sets. + assert len(scans_gt) > 0, "Expected at least one scan for GT variant" + assert len(scans_lt) > 0, "Expected at least one scan for LT variant" + + # Comparator behavior should separate > from < results for this pattern. + assert scans_gt.isdisjoint(scans_lt), ( + "GT and LT variants should produce disjoint scan sets, but they overlap. " + "This suggests intensity comparator operators are not being applied correctly." + ) + + # Equality should usually be narrower than broad threshold matching. + assert scans_eq != scans_gt or scans_eq != scans_lt + + +def main(): + test_ms2_intensity_gt_lt_eq_dev() + + +if __name__ == "__main__": + main() From 9e2bdc6dc012db85e4ea695af5e5cc5266ebe27b Mon Sep 17 00:00:00 2001 From: Ming Wang Date: Thu, 12 Mar 2026 21:36:54 -0700 Subject: [PATCH 2/5] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- tests/test_agent_dev.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/tests/test_agent_dev.py b/tests/test_agent_dev.py index a6949f5..96dd0b8 100644 --- a/tests/test_agent_dev.py +++ b/tests/test_agent_dev.py @@ -7,7 +7,8 @@ from massql import msql_engine -def test_ms2_intensity_gt_lt_eq_dev(): +# Note: This is a manual development helper, not part of the automated pytest suite. +def dev_ms2_intensity_gt_lt_eq(): """ Development test for intensity comparators on a realistic multi-fragment query. @@ -78,7 +79,7 @@ def test_ms2_intensity_gt_lt_eq_dev(): def main(): - test_ms2_intensity_gt_lt_eq_dev() + dev_ms2_intensity_gt_lt_eq() if __name__ == "__main__": From 44ef62909f96f88d9c651148d6561860480eb814 Mon Sep 17 00:00:00 2001 From: Ming Wang Date: Thu, 12 Mar 2026 21:37:17 -0700 Subject: [PATCH 3/5] Potential fix for pull request finding Co-authored-by: Copilot Autofix powered by AI <175728472+Copilot@users.noreply.github.com> --- massql/msql_engine.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/massql/msql_engine.py b/massql/msql_engine.py index ef266ce..9f92450 100644 --- a/massql/msql_engine.py +++ b/massql/msql_engine.py @@ -10,7 +10,7 @@ from massql import msql_parser from massql import msql_fileloading from massql import msql_engine_filters -from massql.msql_engine_filters import _get_mz_tolerance, _get_minintensity, _get_intensity_mask +from massql.msql_engine_filters import _get_mz_tolerance, _get_intensity_mask math_parser = Parser() console = logging.StreamHandler() From befc0025b854026d1004a847142693b77621d5cc Mon Sep 17 00:00:00 2001 From: mwang87 Date: Sat, 14 Mar 2026 13:31:28 -0700 Subject: [PATCH 4/5] bug fix for lt gt test --- tests/test_query.py | 173 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 173 insertions(+) diff --git a/tests/test_query.py b/tests/test_query.py index f55af2d..13666cf 100644 --- a/tests/test_query.py +++ b/tests/test_query.py @@ -724,6 +724,179 @@ def test_otherscan(): assert(831 in list(results_df["scan"])) +def test_ms2_intensityvalue_gt_lt_disjoint(): + """INTENSITYVALUE> and INTENSITYVALUE< at the same threshold produce disjoint scan sets.""" + data_file = "tests/data/featurelist_pos.mgf" + base = "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:{op} AND SCANMIN=1000 AND SCANMAX=1020" + + results_gt = msql_engine.process_query(base.format(op="INTENSITYVALUE>500000"), data_file) + results_lt = msql_engine.process_query(base.format(op="INTENSITYVALUE<500000"), data_file) + + scans_gt = set(results_gt["scan"]) if len(results_gt) > 0 else set() + scans_lt = set(results_lt["scan"]) if len(results_lt) > 0 else set() + + assert scans_gt.isdisjoint(scans_lt), "INTENSITYVALUE > and < at same threshold must produce disjoint scan sets" + + +def test_ms2_intensitypercent_gt_lt_disjoint(): + """INTENSITYPERCENT> and INTENSITYPERCENT< at the same threshold produce disjoint scan sets.""" + data_file = "tests/data/featurelist_pos.mgf" + base = "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:{op} AND SCANMIN=1000 AND SCANMAX=1020" + + results_gt = msql_engine.process_query(base.format(op="INTENSITYPERCENT>30"), data_file) + results_lt = msql_engine.process_query(base.format(op="INTENSITYPERCENT<30"), data_file) + + scans_gt = set(results_gt["scan"]) if len(results_gt) > 0 else set() + scans_lt = set(results_lt["scan"]) if len(results_lt) > 0 else set() + + assert scans_gt.isdisjoint(scans_lt), "INTENSITYPERCENT > and < at same threshold must produce disjoint scan sets" + assert len(scans_gt) > 0 or len(scans_lt) > 0, "At least one set should be non-empty" + + +def test_ms1_intensityvalue_gt_vs_gte(): + """INTENSITYVALUE> (strict) returns fewer or equal results than INTENSITYVALUE= (>= semantics).""" + data_file = "tests/data/GNPS00002_A3_p.mzML" + query_gte = "QUERY scaninfo(MS1DATA) WHERE MS1MZ=226.18:INTENSITYVALUE=300000" + query_gt = "QUERY scaninfo(MS1DATA) WHERE MS1MZ=226.18:INTENSITYVALUE>300000" + + results_gte = msql_engine.process_query(query_gte, data_file) + results_gt = msql_engine.process_query(query_gt, data_file) + + assert len(results_gt) <= len(results_gte), "Strict > should return fewer or equal results than >= (= semantics)" + + +def test_ms1_intensityvalue_lt(): + """INTENSITYVALUE< filter works: impossible threshold gives 0 results; high cap gives results.""" + data_file = "tests/data/GNPS00002_A3_p.mzML" + + # No peak has negative intensity, so < 0 must return nothing + results_zero = msql_engine.process_query( + "QUERY scaninfo(MS1DATA) WHERE MS1MZ=226.18:INTENSITYVALUE<0", data_file) + assert len(results_zero) == 0, "INTENSITYVALUE<0 should return 0 results" + + # A very high cap should return scans where the peak is present + results_high = msql_engine.process_query( + "QUERY scaninfo(MS1DATA) WHERE MS1MZ=226.18:INTENSITYVALUE<999999999", data_file) + assert len(results_high) > 0, "INTENSITYVALUE< with very high cap should return some results" + + +def test_ms1_intensitypercent_lt(): + """INTENSITYPERCENT< filter works: impossible threshold gives 0 results; high cap gives results.""" + data_file = "tests/data/GNPS00002_A3_p.mzML" + + # No peak has negative normalized intensity + results_zero = msql_engine.process_query( + "QUERY scaninfo(MS1DATA) WHERE MS1MZ=226.18:INTENSITYPERCENT<0", data_file) + assert len(results_zero) == 0, "INTENSITYPERCENT<0 should return 0 results" + + # All real peaks have relative intensity < 100%, so a cap of 100 returns those that are present + results_high = msql_engine.process_query( + "QUERY scaninfo(MS1DATA) WHERE MS1MZ=226.18:INTENSITYPERCENT<100", data_file) + assert len(results_high) > 0, "INTENSITYPERCENT< with cap of 100 should return some results" + + +def test_intensityticpercent_lt(): + """INTENSITYTICPERCENT< filter works: impossible threshold gives 0 results; monotonicity holds.""" + data_file = "tests/data/GNPS00002_A3_p.mzML" + + # No peak has negative TIC-normalized intensity + results_zero = msql_engine.process_query( + "QUERY scansum(MS1DATA) WHERE MS2PROD=309.2:TOLERANCEMZ=0.1:INTENSITYTICPERCENT<0", data_file) + assert len(results_zero) == 0, "INTENSITYTICPERCENT<0 should return 0 results" + + # Monotonicity: higher cap returns at least as many results as lower cap + results_high = msql_engine.process_query( + "QUERY scansum(MS1DATA) WHERE MS2PROD=309.2:TOLERANCEMZ=0.1:INTENSITYTICPERCENT<50", data_file) + results_low = msql_engine.process_query( + "QUERY scansum(MS1DATA) WHERE MS2PROD=309.2:TOLERANCEMZ=0.1:INTENSITYTICPERCENT<5", data_file) + assert len(results_high) >= len(results_low), "Higher INTENSITYTICPERCENT< cap should return more or equal results" + + +def test_intensityvalue_gt_monotonicity(): + """Higher INTENSITYVALUE> threshold returns fewer or equal results (monotonicity).""" + data_file = "tests/data/featurelist_pos.mgf" + query_low = "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYVALUE>100000 AND SCANMIN=1000 AND SCANMAX=1020" + query_high = "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYVALUE>1000000 AND SCANMIN=1000 AND SCANMAX=1020" + + results_low = msql_engine.process_query(query_low, data_file) + results_high = msql_engine.process_query(query_high, data_file) + + assert len(results_high) <= len(results_low), "Higher INTENSITYVALUE> threshold should return fewer or equal scans" + + +def test_intensityvalue_lt_monotonicity(): + """Lower INTENSITYVALUE< cap returns fewer or equal results (monotonicity).""" + data_file = "tests/data/featurelist_pos.mgf" + query_high_cap = "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYVALUE<2000000 AND SCANMIN=1000 AND SCANMAX=1020" + query_low_cap = "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYVALUE<100000 AND SCANMIN=1000 AND SCANMAX=1020" + + results_high_cap = msql_engine.process_query(query_high_cap, data_file) + results_low_cap = msql_engine.process_query(query_low_cap, data_file) + + assert len(results_low_cap) <= len(results_high_cap), "Lower INTENSITYVALUE< cap should return fewer or equal scans" + + +def test_ms2_combined_intensity_lt_subset(): + """Adding an INTENSITYPERCENT< constraint on top of INTENSITYVALUE< narrows the result set.""" + data_file = "tests/data/featurelist_pos.mgf" + query_value_only = ( + "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYVALUE<2000000 AND SCANMIN=1000 AND SCANMAX=1020" + ) + query_combined = ( + "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:INTENSITYVALUE<2000000:INTENSITYPERCENT<80 AND SCANMIN=1000 AND SCANMAX=1020" + ) + + results_value_only = msql_engine.process_query(query_value_only, data_file) + results_combined = msql_engine.process_query(query_combined, data_file) + + scans_value_only = set(results_value_only["scan"]) if len(results_value_only) > 0 else set() + scans_combined = set(results_combined["scan"]) if len(results_combined) > 0 else set() + + assert scans_combined.issubset(scans_value_only), "Combined INTENSITYVALUE< + INTENSITYPERCENT< must be a subset of INTENSITYVALUE< alone" + + +def test_ms2nl_intensitypercent_lt(): + """MS2NL INTENSITYPERCENT< filter works: impossible threshold gives 0 results; monotonicity holds.""" + data_file = "tests/data/GNPS00002_A3_p.mzML" + + # No peak has negative percent intensity + results_zero = msql_engine.process_query( + "QUERY MS2DATA WHERE MS2NL=18:TOLERANCEMZ=0.5:INTENSITYPERCENT<0", data_file) + assert len(results_zero) == 0, "MS2NL INTENSITYPERCENT<0 should return 0 results" + + # Monotonicity: higher cap should include all scans found by lower cap + results_high = msql_engine.process_query( + "QUERY MS2DATA WHERE MS2NL=18:TOLERANCEMZ=0.5:INTENSITYPERCENT<100", data_file) + results_low = msql_engine.process_query( + "QUERY MS2DATA WHERE MS2NL=18:TOLERANCEMZ=0.5:INTENSITYPERCENT<1", data_file) + scans_high = set(results_high["scan"]) if len(results_high) > 0 else set() + scans_low = set(results_low["scan"]) if len(results_low) > 0 else set() + assert scans_low.issubset(scans_high), "Lower INTENSITYPERCENT< cap results must be a subset of higher cap results" + + +def test_ms2_intensitypercent_gt_lt_eq_tripartite(): + """GT, LT, and EQ (>=) scan sets have expected relationships for the same data.""" + data_file = "tests/data/featurelist_pos.mgf" + base = "QUERY MS2DATA WHERE MS2PROD=184.0739:TOLERANCEMZ=0.01:{op} AND SCANMIN=1000 AND SCANMAX=1020" + + results_gt = msql_engine.process_query(base.format(op="INTENSITYPERCENT>30"), data_file) + results_lt = msql_engine.process_query(base.format(op="INTENSITYPERCENT<30"), data_file) + results_eq = msql_engine.process_query(base.format(op="INTENSITYPERCENT=30"), data_file) + + scans_gt = set(results_gt["scan"]) if len(results_gt) > 0 else set() + scans_lt = set(results_lt["scan"]) if len(results_lt) > 0 else set() + scans_eq = set(results_eq["scan"]) if len(results_eq) > 0 else set() + + print(f"INTENSITYPERCENT>30: {len(scans_gt)} scans -> {sorted(scans_gt)}") + print(f"INTENSITYPERCENT<30: {len(scans_lt)} scans -> {sorted(scans_lt)}") + print(f"INTENSITYPERCENT=30: {len(scans_eq)} scans -> {sorted(scans_eq)}") + + # GT and LT must be disjoint + assert scans_gt.isdisjoint(scans_lt), "INTENSITYPERCENT > and < must produce disjoint scan sets" + # EQ (which means >=) must be a superset of GT + assert scans_gt.issubset(scans_eq), "INTENSITYPERCENT= (>=) must include all scans matched by INTENSITYPERCENT>" + + def debug_query(): query = "QUERY scaninfo(MS2DATA) WHERE MS2PROD=341.28:TOLERANCEMZ=0.01:INTENSITYPERCENT=2 AND MS2PROD=323.27:TOLERANCEMZ=0.01:INTENSITYPERCENT=2 AND MS2PREC=X AND MS2PROD=X-358.2871:TOLERANCEMZ=0.01:INTENSITYPERCENT=2" From 4668a98597e69e1e1dc6fc8b14ba0d1c5f723d1a Mon Sep 17 00:00:00 2001 From: mwang87 Date: Sat, 14 Mar 2026 15:49:30 -0700 Subject: [PATCH 5/5] fixing tests --- ...PPM_5___e52fbecfe84d774889d7b5f536a3363e.json | 1 + ...OLERA___106d511f8de4ae41364fbece4838e2c8.json | 2 ++ ...OLERA___1f23674928bf7c61db1bede091d016ac.json | 2 ++ ...TENSI___c11b8d3c85dd33cbb8a73699d7f26efb.json | 8 ++++++++ ...EMZ_0___10cc51d88921a4f32ca1f0a38ea3b4f2.json | 6 ++++++ ...EMZ_0___9008f814f26ce5a1835e900d1e9c659f.json | 15 +++++++++++++++ ...LERAN___ca35f95cb92bd1fbd9a06d74463ecc45.json | 2 ++ ...ITYMA___61a2da302d53487ba89667bb7b7433a3.json | 4 ++++ ...EMZ_0___6c21ac388a474d5ebc9485f44f67972e.json | 16 ++++++++++++++++ ...EMZ_0___8211c5bd2dcbba27b8676e891ccdf078.json | 13 +++++++++++++ ...OLERA___787f67aec200ae337b0e3df9031db8ca.json | 1 + ...7TOLE___17c6443350bc76ae1462d4e492139426.json | 2 ++ ...9TOLE___208cb60e1979a0a3d01cf4ea7a398d27.json | 10 ++++++++++ ...OLERA___183ad9892736b0d8642ccec4aa131c40.json | 1 + ...OLERA___765966e9867749f2dee435696d06aca4.json | 1 + ...OLERA___76665345ac8dbd664ab054e37eced641.json | 6 ++++++ ...LERAN___534180716b576e89874a50f7245c8f30.json | 4 ++++ ...ANCEM___a5ce05df2b600cc86a0a76d43dd61ff6.json | 6 ++++++ ...ANCEM___de1efdec2d9f13fba1556258838fc30f.json | 4 ++++ ...13_OR___914cae9424e4492a2d88e8e1d0128f6e.json | 2 ++ ...,_max___ce48d94145b8fe9dd12d4257ffda9ad1.json | 4 ++++ ...OLERA___134f5926097a502b8c1ed113d63bce43.json | 1 + ...OLERA___4f5faa5c621cc16a76cfaebbb0441dae.json | 1 + ...NCEMZ___6d988b4f5914b1ec60cff898439e7816.json | 2 ++ ...NCEMZ___41ea32589a61e1e93c2e53c6e188d73a.json | 1 + ...CEMZ____ba08671aada7c435d266b095c78c7443.json | 1 + 26 files changed, 116 insertions(+) diff --git a/tests/reference_parses/QUERY_MS2DATA_WHERE_MS2PROD_226.18TOLERANCEPPM_5___e52fbecfe84d774889d7b5f536a3363e.json b/tests/reference_parses/QUERY_MS2DATA_WHERE_MS2PROD_226.18TOLERANCEPPM_5___e52fbecfe84d774889d7b5f536a3363e.json index 76e9b63..9f1256c 100644 --- a/tests/reference_parses/QUERY_MS2DATA_WHERE_MS2PROD_226.18TOLERANCEPPM_5___e52fbecfe84d774889d7b5f536a3363e.json +++ b/tests/reference_parses/QUERY_MS2DATA_WHERE_MS2PROD_226.18TOLERANCEPPM_5___e52fbecfe84d774889d7b5f536a3363e.json @@ -4,6 +4,7 @@ "conditiontype": "where", "qualifiers": { "qualifierppmtolerance": { + "comparator": "equal", "name": "qualifierppmtolerance", "unit": "ppm", "value": 5.0 diff --git a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_425.2898TOLERA___106d511f8de4ae41364fbece4838e2c8.json b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_425.2898TOLERA___106d511f8de4ae41364fbece4838e2c8.json index f1b1ba6..f2b49f1 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_425.2898TOLERA___106d511f8de4ae41364fbece4838e2c8.json +++ b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_425.2898TOLERA___106d511f8de4ae41364fbece4838e2c8.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "greaterthan", "name": "qualifierintensitypercent", "value": 0.1 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_425.2898TOLERA___1f23674928bf7c61db1bede091d016ac.json b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_425.2898TOLERA___1f23674928bf7c61db1bede091d016ac.json index 651da98..8a13d5a 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_425.2898TOLERA___1f23674928bf7c61db1bede091d016ac.json +++ b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_425.2898TOLERA___1f23674928bf7c61db1bede091d016ac.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "greaterthan", "name": "qualifierintensitypercent", "value": 1.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_X-1.993INTENSI___c11b8d3c85dd33cbb8a73699d7f26efb.json b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_X-1.993INTENSI___c11b8d3c85dd33cbb8a73699d7f26efb.json index e944c6f..23bec33 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_X-1.993INTENSI___c11b8d3c85dd33cbb8a73699d7f26efb.json +++ b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_X-1.993INTENSI___c11b8d3c85dd33cbb8a73699d7f26efb.json @@ -4,14 +4,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.063" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 25.0 }, "qualifierppmtolerance": { + "comparator": "equal", "name": "qualifierppmtolerance", "unit": "ppm", "value": 10.0 @@ -27,10 +30,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y" }, "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, @@ -48,10 +53,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.5" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 60.0 }, @@ -66,6 +73,7 @@ "conditiontype": "where", "qualifiers": { "qualifierppmtolerance": { + "comparator": "equal", "name": "qualifierppmtolerance", "unit": "ppm", "value": 10.0 diff --git a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___10cc51d88921a4f32ca1f0a38ea3b4f2.json b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___10cc51d88921a4f32ca1f0a38ea3b4f2.json index 772c68f..1eade92 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___10cc51d88921a4f32ca1f0a38ea3b4f2.json +++ b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___10cc51d88921a4f32ca1f0a38ea3b4f2.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y" }, "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 25.0 }, @@ -15,6 +17,7 @@ "name": "qualifierintensityreference" }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -30,14 +33,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.33" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 30.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___9008f814f26ce5a1835e900d1e9c659f.json b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___9008f814f26ce5a1835e900d1e9c659f.json index ac2432f..b4ca6e5 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___9008f814f26ce5a1835e900d1e9c659f.json +++ b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___9008f814f26ce5a1835e900d1e9c659f.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y" }, "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 25.0 }, @@ -15,6 +17,7 @@ "name": "qualifierintensityreference" }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -30,14 +33,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.66" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 30.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -53,14 +59,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.66" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 30.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -76,14 +85,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.17" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 40.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.2 @@ -99,14 +111,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.17" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 40.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.2 diff --git a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS2PROD_309.2TOLERAN___ca35f95cb92bd1fbd9a06d74463ecc45.json b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS2PROD_309.2TOLERAN___ca35f95cb92bd1fbd9a06d74463ecc45.json index 58399fe..c141102 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS2PROD_309.2TOLERAN___ca35f95cb92bd1fbd9a06d74463ecc45.json +++ b/tests/reference_parses/QUERY_scaninfo_MS1DATA__WHERE_MS2PROD_309.2TOLERAN___ca35f95cb92bd1fbd9a06d74463ecc45.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensityticpercent": { + "comparator": "equal", "name": "qualifierintensityticpercent", "value": 10.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_X-2INTENSITYMA___61a2da302d53487ba89667bb7b7433a3.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_X-2INTENSITYMA___61a2da302d53487ba89667bb7b7433a3.json index 9fed2bf..d59e89e 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_X-2INTENSITYMA___61a2da302d53487ba89667bb7b7433a3.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_X-2INTENSITYMA___61a2da302d53487ba89667bb7b7433a3.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.0608+2e-06*X" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 25.0 }, @@ -22,10 +24,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y" }, "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___6c21ac388a474d5ebc9485f44f67972e.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___6c21ac388a474d5ebc9485f44f67972e.json index 6571efa..d154b40 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___6c21ac388a474d5ebc9485f44f67972e.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___6c21ac388a474d5ebc9485f44f67972e.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y" }, "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, @@ -15,6 +17,7 @@ "name": "qualifierintensityreference" }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -30,14 +33,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.66" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 30.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -53,14 +59,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.66" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 30.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -76,14 +85,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.17" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 40.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.2 @@ -99,14 +111,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.17" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 40.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.2 @@ -122,6 +137,7 @@ "conditiontype": "where", "qualifiers": { "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 4.0 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___8211c5bd2dcbba27b8676e891ccdf078.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___8211c5bd2dcbba27b8676e891ccdf078.json index e8af405..c4e3477 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___8211c5bd2dcbba27b8676e891ccdf078.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS1MZ_XTOLERANCEMZ_0___8211c5bd2dcbba27b8676e891ccdf078.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y" }, "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, @@ -15,6 +17,7 @@ "name": "qualifierintensityreference" }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -30,14 +33,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.97" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 30.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -53,14 +59,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.34" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 30.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -76,14 +85,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.32" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 40.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.2 @@ -99,6 +111,7 @@ "conditiontype": "where", "qualifiers": { "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 2.0 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PREC_403.15TOLERA___787f67aec200ae337b0e3df9031db8ca.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PREC_403.15TOLERA___787f67aec200ae337b0e3df9031db8ca.json index c1fa9d8..a714a56 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PREC_403.15TOLERA___787f67aec200ae337b0e3df9031db8ca.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PREC_403.15TOLERA___787f67aec200ae337b0e3df9031db8ca.json @@ -4,6 +4,7 @@ "conditiontype": "where", "qualifiers": { "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_167.0857TOLE___17c6443350bc76ae1462d4e492139426.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_167.0857TOLE___17c6443350bc76ae1462d4e492139426.json index dbfaeab..aa7683f 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_167.0857TOLE___17c6443350bc76ae1462d4e492139426.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_167.0857TOLE___17c6443350bc76ae1462d4e492139426.json @@ -4,6 +4,7 @@ "conditiontype": "where", "qualifiers": { "qualifierppmtolerance": { + "comparator": "equal", "name": "qualifierppmtolerance", "unit": "ppm", "value": 5.0 @@ -19,6 +20,7 @@ "conditiontype": "where", "qualifiers": { "qualifierppmtolerance": { + "comparator": "equal", "name": "qualifierppmtolerance", "unit": "ppm", "value": 5.0 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_184.0739TOLE___208cb60e1979a0a3d01cf4ea7a398d27.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_184.0739TOLE___208cb60e1979a0a3d01cf4ea7a398d27.json index 70b4df4..8d0cdaa 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_184.0739TOLE___208cb60e1979a0a3d01cf4ea7a398d27.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_184.0739TOLE___208cb60e1979a0a3d01cf4ea7a398d27.json @@ -4,14 +4,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "greaterthan", "name": "qualifierintensitypercent", "value": 30.0 }, "qualifierintensityvalue": { + "comparator": "greaterthan", "name": "qualifierintensityvalue", "value": 500.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.01 @@ -27,14 +30,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "greaterthan", "name": "qualifierintensitypercent", "value": 10.0 }, "qualifierintensityvalue": { + "comparator": "greaterthan", "name": "qualifierintensityvalue", "value": 1500.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.01 @@ -50,6 +56,7 @@ "conditiontype": "where", "qualifiers": { "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.01 @@ -65,14 +72,17 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "greaterthan", "name": "qualifierintensitypercent", "value": 10.0 }, "qualifierintensityvalue": { + "comparator": "greaterthan", "name": "qualifierintensityvalue", "value": 2000.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.01 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_226.18TOLERA___183ad9892736b0d8642ccec4aa131c40.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_226.18TOLERA___183ad9892736b0d8642ccec4aa131c40.json index 54c8070..2f847ea 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_226.18TOLERA___183ad9892736b0d8642ccec4aa131c40.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_226.18TOLERA___183ad9892736b0d8642ccec4aa131c40.json @@ -4,6 +4,7 @@ "conditiontype": "where", "qualifiers": { "qualifierppmtolerance": { + "comparator": "equal", "name": "qualifierppmtolerance", "unit": "ppm", "value": 5.0 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_226.18TOLERA___765966e9867749f2dee435696d06aca4.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_226.18TOLERA___765966e9867749f2dee435696d06aca4.json index 3a731ab..21d68fb 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_226.18TOLERA___765966e9867749f2dee435696d06aca4.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_226.18TOLERA___765966e9867749f2dee435696d06aca4.json @@ -7,6 +7,7 @@ "name": "qualifierexcluded" }, "qualifierppmtolerance": { + "comparator": "equal", "name": "qualifierppmtolerance", "unit": "ppm", "value": 5.0 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_341.28TOLERA___76665345ac8dbd664ab054e37eced641.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_341.28TOLERA___76665345ac8dbd664ab054e37eced641.json index 9f3c178..ca0a1dc 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_341.28TOLERA___76665345ac8dbd664ab054e37eced641.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_341.28TOLERA___76665345ac8dbd664ab054e37eced641.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 2.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.01 @@ -23,10 +25,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 2.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.01 @@ -49,10 +53,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 2.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.01 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_660.2TOLERAN___534180716b576e89874a50f7245c8f30.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_660.2TOLERAN___534180716b576e89874a50f7245c8f30.json index 925d2d4..8abfc3f 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_660.2TOLERAN___534180716b576e89874a50f7245c8f30.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_660.2TOLERAN___534180716b576e89874a50f7245c8f30.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 1.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -23,10 +25,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 1.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_X_TOLERANCEM___a5ce05df2b600cc86a0a76d43dd61ff6.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_X_TOLERANCEM___a5ce05df2b600cc86a0a76d43dd61ff6.json index e56f8a9..22a91ec 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_X_TOLERANCEM___a5ce05df2b600cc86a0a76d43dd61ff6.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_X_TOLERANCEM___a5ce05df2b600cc86a0a76d43dd61ff6.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -23,10 +25,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -42,10 +46,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_X_TOLERANCEM___de1efdec2d9f13fba1556258838fc30f.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_X_TOLERANCEM___de1efdec2d9f13fba1556258838fc30f.json index a668c31..cf8e735 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_X_TOLERANCEM___de1efdec2d9f13fba1556258838fc30f.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD_X_TOLERANCEM___de1efdec2d9f13fba1556258838fc30f.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 @@ -23,10 +25,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD__58.06513_OR___914cae9424e4492a2d88e8e1d0128f6e.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD__58.06513_OR___914cae9424e4492a2d88e8e1d0128f6e.json index f77ef9b..2a5d75a 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD__58.06513_OR___914cae9424e4492a2d88e8e1d0128f6e.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_MS2PROD__58.06513_OR___914cae9424e4492a2d88e8e1d0128f6e.json @@ -9,10 +9,12 @@ "name": "qualifiercardinality" }, "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, "qualifierppmtolerance": { + "comparator": "equal", "name": "qualifierppmtolerance", "unit": "ppm", "value": 10.0 diff --git a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_X_range_min_100,_max___ce48d94145b8fe9dd12d4257ffda9ad1.json b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_X_range_min_100,_max___ce48d94145b8fe9dd12d4257ffda9ad1.json index 60be3c2..de58f58 100644 --- a/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_X_range_min_100,_max___ce48d94145b8fe9dd12d4257ffda9ad1.json +++ b/tests/reference_parses/QUERY_scaninfo_MS2DATA__WHERE_X_range_min_100,_max___ce48d94145b8fe9dd12d4257ffda9ad1.json @@ -10,10 +10,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y*0.0608+2e-06*X" }, "qualifierintensitytolpercent": { + "comparator": "equal", "name": "qualifierintensitytolpercent", "value": 25.0 }, @@ -28,10 +30,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitymatch": { + "comparator": "equal", "name": "qualifierintensitymatch", "value": "Y" }, "qualifierintensitypercent": { + "comparator": "equal", "name": "qualifierintensitypercent", "value": 5.0 }, diff --git a/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PREC_85.0282TOLERA___134f5926097a502b8c1ed113d63bce43.json b/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PREC_85.0282TOLERA___134f5926097a502b8c1ed113d63bce43.json index 5e1ab79..ac77236 100644 --- a/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PREC_85.0282TOLERA___134f5926097a502b8c1ed113d63bce43.json +++ b/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PREC_85.0282TOLERA___134f5926097a502b8c1ed113d63bce43.json @@ -4,6 +4,7 @@ "conditiontype": "where", "qualifiers": { "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PROD_85.0284TOLERA___4f5faa5c621cc16a76cfaebbb0441dae.json b/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PROD_85.0284TOLERA___4f5faa5c621cc16a76cfaebbb0441dae.json index 1c87abf..f0ddb86 100644 --- a/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PROD_85.0284TOLERA___4f5faa5c621cc16a76cfaebbb0441dae.json +++ b/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PROD_85.0284TOLERA___4f5faa5c621cc16a76cfaebbb0441dae.json @@ -4,6 +4,7 @@ "conditiontype": "where", "qualifiers": { "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.005 diff --git a/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PROD_88TOLERANCEMZ___6d988b4f5914b1ec60cff898439e7816.json b/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PROD_88TOLERANCEMZ___6d988b4f5914b1ec60cff898439e7816.json index 9307afd..5d5140f 100644 --- a/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PROD_88TOLERANCEMZ___6d988b4f5914b1ec60cff898439e7816.json +++ b/tests/reference_parses/QUERY_scannum_MS2DATA__WHERE_MS2PROD_88TOLERANCEMZ___6d988b4f5914b1ec60cff898439e7816.json @@ -4,10 +4,12 @@ "conditiontype": "where", "qualifiers": { "qualifierintensitypercent": { + "comparator": "greaterthan", "name": "qualifierintensitypercent", "value": 10.0 }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1 diff --git a/tests/reference_parses/QUERY_scansum_MS1DATA__FILTER_MS1MZ_515TOLERANCEMZ___41ea32589a61e1e93c2e53c6e188d73a.json b/tests/reference_parses/QUERY_scansum_MS1DATA__FILTER_MS1MZ_515TOLERANCEMZ___41ea32589a61e1e93c2e53c6e188d73a.json index 67a289a..e94a54b 100644 --- a/tests/reference_parses/QUERY_scansum_MS1DATA__FILTER_MS1MZ_515TOLERANCEMZ___41ea32589a61e1e93c2e53c6e188d73a.json +++ b/tests/reference_parses/QUERY_scansum_MS1DATA__FILTER_MS1MZ_515TOLERANCEMZ___41ea32589a61e1e93c2e53c6e188d73a.json @@ -9,6 +9,7 @@ "name": "qualifiermassdefect" }, "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 35.0 diff --git a/tests/reference_parses/QUERY_scansum_MS1DATA__WHERE_MS1MZ_100TOLERANCEMZ____ba08671aada7c435d266b095c78c7443.json b/tests/reference_parses/QUERY_scansum_MS1DATA__WHERE_MS1MZ_100TOLERANCEMZ____ba08671aada7c435d266b095c78c7443.json index 3522474..4d39fa6 100644 --- a/tests/reference_parses/QUERY_scansum_MS1DATA__WHERE_MS1MZ_100TOLERANCEMZ____ba08671aada7c435d266b095c78c7443.json +++ b/tests/reference_parses/QUERY_scansum_MS1DATA__WHERE_MS1MZ_100TOLERANCEMZ____ba08671aada7c435d266b095c78c7443.json @@ -4,6 +4,7 @@ "conditiontype": "where", "qualifiers": { "qualifiermztolerance": { + "comparator": "equal", "name": "qualifiermztolerance", "unit": "mz", "value": 0.1