diff --git a/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/BasicBatchPipeline.java b/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/BasicBatchPipeline.java index 60dc7e37b..421594ef2 100644 --- a/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/BasicBatchPipeline.java +++ b/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/BasicBatchPipeline.java @@ -7,12 +7,9 @@ import edu.stanford.futuredata.macrobase.analysis.summary.aplinear.APLOutlierSummarizer; import edu.stanford.futuredata.macrobase.analysis.summary.BatchSummarizer; import edu.stanford.futuredata.macrobase.analysis.summary.fpg.FPGrowthSummarizer; -import edu.stanford.futuredata.macrobase.analysis.summary.ratios.ExplanationMetric; -import edu.stanford.futuredata.macrobase.analysis.summary.ratios.GlobalRatioMetric; -import edu.stanford.futuredata.macrobase.analysis.summary.ratios.RiskRatioMetric; import edu.stanford.futuredata.macrobase.datamodel.DataFrame; import edu.stanford.futuredata.macrobase.datamodel.Schema; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -75,7 +72,7 @@ public BasicBatchPipeline (PipelineConfig conf) { numThreads = conf.get("numThreads", Runtime.getRuntime().availableProcessors()); } - public Classifier getClassifier() throws MacrobaseException { + public Classifier getClassifier() throws MacroBaseException { switch (classifierType.toLowerCase()) { case "percentile": { PercentileClassifier classifier = new PercentileClassifier(metric); @@ -93,12 +90,12 @@ public Classifier getClassifier() throws MacrobaseException { return classifier; } default : { - throw new MacrobaseException("Bad Classifier Type"); + throw new MacroBaseException("Bad Classifier Type"); } } } - public BatchSummarizer getSummarizer(String outlierColumnName) throws MacrobaseException { + public BatchSummarizer getSummarizer(String outlierColumnName) throws MacroBaseException { switch (summarizerType.toLowerCase()) { case "fpgrowth": { FPGrowthSummarizer summarizer = new FPGrowthSummarizer(); @@ -120,7 +117,7 @@ public BatchSummarizer getSummarizer(String outlierColumnName) throws MacrobaseE return summarizer; } default: { - throw new MacrobaseException("Bad Summarizer Type"); + throw new MacroBaseException("Bad Summarizer Type"); } } } diff --git a/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/CubePipeline.java b/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/CubePipeline.java index 99d81d447..9c20b9757 100644 --- a/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/CubePipeline.java +++ b/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/CubePipeline.java @@ -12,7 +12,7 @@ import edu.stanford.futuredata.macrobase.datamodel.DataFrame; import edu.stanford.futuredata.macrobase.datamodel.Schema; import edu.stanford.futuredata.macrobase.ingest.CSVDataFrameWriter; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.io.PrintWriter; import java.util.ArrayList; import java.util.HashMap; @@ -143,17 +143,17 @@ public APLExplanation results() throws Exception { return explanation; } - private Map getColTypes() throws MacrobaseException { + private Map getColTypes() throws MacroBaseException { Map colTypes = new HashMap<>(); colTypes.put(countColumn, Schema.ColType.DOUBLE); switch (classifierType) { case "meanshift": case "arithmetic": { colTypes.put(meanColumn - .orElseThrow(() -> new MacrobaseException("mean column not present in config")), + .orElseThrow(() -> new MacroBaseException("mean column not present in config")), Schema.ColType.DOUBLE); colTypes.put(stdColumn - .orElseThrow(() -> new MacrobaseException("std column not present in config")), + .orElseThrow(() -> new MacroBaseException("std column not present in config")), Schema.ColType.DOUBLE); return colTypes; } @@ -166,33 +166,33 @@ private Map getColTypes() throws MacrobaseException { case "predicate": { if (isStrPredicate) { colTypes.put(metric.orElseThrow( - () -> new MacrobaseException("metric column not present in config")), + () -> new MacroBaseException("metric column not present in config")), Schema.ColType.STRING); } else { colTypes.put(metric.orElseThrow( - () -> new MacrobaseException("metric column not present in config")), + () -> new MacroBaseException("metric column not present in config")), Schema.ColType.DOUBLE); } return colTypes; } case "raw": { colTypes.put(meanColumn.orElseThrow( - () -> new MacrobaseException("mean column not present in config")), + () -> new MacroBaseException("mean column not present in config")), Schema.ColType.DOUBLE); } default: - throw new MacrobaseException("Bad Classifier Name"); + throw new MacroBaseException("Bad Classifier Name"); } } - private CubeClassifier getClassifier() throws MacrobaseException { + private CubeClassifier getClassifier() throws MacroBaseException { switch (classifierType) { case "arithmetic": { ArithmeticClassifier classifier = new ArithmeticClassifier(countColumn, meanColumn.orElseThrow( - () -> new MacrobaseException("mean column not present in config")), + () -> new MacroBaseException("mean column not present in config")), stdColumn.orElseThrow( - () -> new MacrobaseException("std column not present in config"))); + () -> new MacroBaseException("std column not present in config"))); classifier.setPercentile(cutoff); classifier.setIncludeHigh(includeHi); classifier.setIncludeLow(includeLo); @@ -210,12 +210,12 @@ private CubeClassifier getClassifier() throws MacrobaseException { if (isStrPredicate) { return new PredicateCubeClassifier(countColumn, metric.orElseThrow( - () -> new MacrobaseException("metric column not present in config")), + () -> new MacroBaseException("metric column not present in config")), predicateStr, strCutoff); } return new PredicateCubeClassifier(countColumn, metric.orElseThrow( - () -> new MacrobaseException("metric column not present in config")), + () -> new MacroBaseException("metric column not present in config")), predicateStr, cutoff); } @@ -224,11 +224,11 @@ private CubeClassifier getClassifier() throws MacrobaseException { return new RawClassifier( countColumn, meanColumn.orElseThrow( - () -> new MacrobaseException("mean column not present in config")) + () -> new MacroBaseException("mean column not present in config")) ); } default: - throw new MacrobaseException("Bad Classifier Name"); + throw new MacroBaseException("Bad Classifier Name"); } } @@ -238,9 +238,9 @@ private APLSummarizer getSummarizer(CubeClassifier classifier) throws Exception APLMeanSummarizer summarizer = new APLMeanSummarizer(); summarizer.setCountColumn(countColumn); summarizer.setMeanColumn(meanColumn.orElseThrow( - () -> new MacrobaseException("mean column not present in config"))); + () -> new MacroBaseException("mean column not present in config"))); summarizer.setStdColumn(stdColumn.orElseThrow( - () -> new MacrobaseException("std column not present in config"))); + () -> new MacroBaseException("std column not present in config"))); summarizer.setAttributes(attributes); summarizer.setMinSupport(minSupport); summarizer.setMinStdDev(minRatioMetric); diff --git a/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/PipelineUtils.java b/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/PipelineUtils.java index d67440368..183df2a40 100644 --- a/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/PipelineUtils.java +++ b/core/src/main/java/edu/stanford/futuredata/macrobase/pipeline/PipelineUtils.java @@ -5,7 +5,7 @@ import edu.stanford.futuredata.macrobase.datamodel.Schema; import edu.stanford.futuredata.macrobase.ingest.CSVDataFrameParser; import edu.stanford.futuredata.macrobase.ingest.RESTDataFrameLoader; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.util.Map; import java.util.List; @@ -51,13 +51,13 @@ public static DataFrame loadDataFrame( DataFrame df = loader.load(); return df; } else { - throw new MacrobaseException("Unsupported URI"); + throw new MacroBaseException("Unsupported URI"); } } public static Pipeline createPipeline( PipelineConfig conf - ) throws MacrobaseException { + ) throws MacroBaseException { String pipelineName = conf.get("pipeline"); switch (pipelineName) { case "BasicBatchPipeline": { @@ -67,7 +67,7 @@ public static Pipeline createPipeline( return new CubePipeline(conf); } default: { - throw new MacrobaseException("Bad Pipeline"); + throw new MacroBaseException("Bad Pipeline"); } } } diff --git a/docs/source/user-guide/parameters.md b/docs/source/user-guide/parameters.md index 90eb2b57c..aa1abe20e 100644 --- a/docs/source/user-guide/parameters.md +++ b/docs/source/user-guide/parameters.md @@ -1,11 +1,11 @@ # Configuration Parameters -This document describes the important parameters in Macrobase that +This document describes the important parameters in MacroBase that affect its behavior. ## Workload-specific parameters -We first describe workload-specific parameters. Macrobase will throw an exception if +We first describe workload-specific parameters. MacroBase will throw an exception if parameters that don't have a default value aren't specified. @@ -48,7 +48,7 @@ reciprocal of the value for each point (i.e. 1/value). diff --git a/lib/readme.md b/lib/readme.md index 599e5f358..84a808042 100644 --- a/lib/readme.md +++ b/lib/readme.md @@ -1,4 +1,4 @@ -## Macrobase core operator library +## MacroBase core operator library Basic operators for explaining differences in high-dimensional data using categorical attributes. diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/MBFunction.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/MBFunction.java index 710e45542..e62ad5cb5 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/MBFunction.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/MBFunction.java @@ -1,7 +1,7 @@ package edu.stanford.futuredata.macrobase.analysis; import edu.stanford.futuredata.macrobase.datamodel.DataFrame; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.lang.reflect.InvocationTargetException; import java.util.Arrays; import java.util.HashMap; @@ -49,12 +49,12 @@ protected MBFunction(String columnName) { * Call this method to to invoke the function and generate the output column that results from * applying it on the DataFrame * - * @throws MacrobaseException If the column name (specified in the constructor of the + * @throws MacroBaseException If the column name (specified in the constructor of the * MBFunction) isn't present in the DataFrame, an exception is thrown. */ - public final double[] apply(final DataFrame df) throws MacrobaseException { + public final double[] apply(final DataFrame df) throws MacroBaseException { if (!df.hasColumn(columnName)) { - throw new MacrobaseException(columnName + " not present in DataFrame"); + throw new MacroBaseException(columnName + " not present in DataFrame"); } final double[] outputCol = new double[df.getNumRows()]; this.applyFunction(df.getDoubleColumnByName(columnName), outputCol); @@ -68,11 +68,11 @@ public final double[] apply(final DataFrame df) throws MacrobaseException { * would be "normalize" (or "NORMALIZE"---the funcName is case-agnostic), and the {@param arg} * would be "battery_drain". * - * @throws MacrobaseException If there's an error instantiating the MBFunction (usually due to + * @throws MacroBaseException If there's an error instantiating the MBFunction (usually due to * incorrect arguments or improperly defined subclasses), an exception is thrown. */ public static MBFunction getFunction(String funcName, String arg) - throws MacrobaseException { + throws MacroBaseException { Class clazz; switch (funcName.toLowerCase()) { case "normalize": { @@ -84,13 +84,13 @@ public static MBFunction getFunction(String funcName, String arg) break; } default: { - throw new MacrobaseException("Bad MBFunction Type: " + funcName); + throw new MacroBaseException("Bad MBFunction Type: " + funcName); } } try { return clazz.getConstructor(String.class).newInstance(arg); } catch (NoSuchMethodException | InstantiationException | InvocationTargetException | IllegalAccessException e) { - throw new MacrobaseException( + throw new MacroBaseException( "MBFunction Type " + funcName + " incompatible with args (" + arg + ")"); } } diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/Classifier.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/Classifier.java index 26883ee6c..20aed307c 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/Classifier.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/Classifier.java @@ -1,12 +1,6 @@ package edu.stanford.futuredata.macrobase.analysis.classify; -import com.google.common.base.Joiner; -import edu.stanford.futuredata.macrobase.datamodel.DataFrame; import edu.stanford.futuredata.macrobase.operator.Transformer; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; -import java.lang.reflect.InvocationTargetException; -import java.util.BitSet; -import java.util.List; public abstract class Classifier implements Transformer { diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/PredicateClassifier.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/PredicateClassifier.java index 7a70ce8d9..fc69af101 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/PredicateClassifier.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/PredicateClassifier.java @@ -2,7 +2,7 @@ import edu.stanford.futuredata.macrobase.analysis.classify.stats.MBPredicate; import edu.stanford.futuredata.macrobase.datamodel.DataFrame; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.util.function.DoublePredicate; import java.util.function.Predicate; @@ -36,7 +36,7 @@ public class PredicateClassifier extends Classifier { */ public PredicateClassifier(final String columnName, final String predicateStr, final double sentinel) - throws MacrobaseException { + throws MacroBaseException { super(columnName); this.predicate = MBPredicate.getDoublePredicate(predicateStr, sentinel); this.isStrPredicate = false; @@ -50,7 +50,7 @@ public PredicateClassifier(final String columnName, final String predicateStr, */ public PredicateClassifier(final String columnName, final String predicateStr, final String sentinel) - throws MacrobaseException { + throws MacroBaseException { super(columnName); this.strPredicate = MBPredicate.getStrPredicate(predicateStr, sentinel); this.isStrPredicate = true; diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/PredicateCubeClassifier.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/PredicateCubeClassifier.java index 371a419a6..c2f05a9b0 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/PredicateCubeClassifier.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/PredicateCubeClassifier.java @@ -2,7 +2,7 @@ import edu.stanford.futuredata.macrobase.analysis.classify.stats.MBPredicate; import edu.stanford.futuredata.macrobase.datamodel.DataFrame; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.util.function.DoublePredicate; import java.util.function.Predicate; @@ -26,14 +26,14 @@ public class PredicateCubeClassifier extends CubeClassifier { * @param metricColumnName Column on which to classifier outliers * @param predicateStr Predicate used for classification: "==", "!=", "<", ">", "<=", or ">=" * @param sentinel Sentinel value used when evaluating the predicate to determine outlier - * @throws MacrobaseException + * @throws MacroBaseException */ public PredicateCubeClassifier( final String countColumnName, final String metricColumnName, final String predicateStr, final double sentinel - ) throws MacrobaseException { + ) throws MacroBaseException { super(countColumnName); this.metricColumnName = metricColumnName; this.predicate = MBPredicate.getDoublePredicate(predicateStr, sentinel); @@ -45,14 +45,14 @@ public PredicateCubeClassifier( * @param metricColumnName Column on which to classifier outliers * @param predicateStr Predicate used for classification: "==", "!=", "<", ">", "<=", or ">=" * @param sentinel Sentinel value used when evaluating the predicate to determine outlier - * @throws MacrobaseException + * @throws MacroBaseException */ public PredicateCubeClassifier( final String countColumnName, final String metricColumnName, final String predicateStr, final String sentinel - ) throws MacrobaseException { + ) throws MacroBaseException { super(countColumnName); this.metricColumnName = metricColumnName; this.strPredicate = MBPredicate.getStrPredicate(predicateStr, sentinel); diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/LinearInterpolator.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/LinearInterpolator.java index 11ec5ab75..012b8af55 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/LinearInterpolator.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/LinearInterpolator.java @@ -1,6 +1,6 @@ package edu.stanford.futuredata.macrobase.analysis.classify.stats; -import edu.stanford.futuredata.macrobase.util.MacrobaseInternalError; +import edu.stanford.futuredata.macrobase.util.MacroBaseInternalError; /** * Performs linear interpolation in a lazy manner: interpolation does not actually @@ -24,7 +24,7 @@ public LinearInterpolator(double[] x, double[] y) throws IllegalArgumentExceptio this.y = y; } - public double evaluate(double value) throws MacrobaseInternalError { + public double evaluate(double value) throws MacroBaseInternalError { if ((value > x[x.length - 1]) || (value < x[0])) { return Double.NaN; } @@ -43,6 +43,6 @@ public double evaluate(double value) throws MacrobaseInternalError { return slope * value + intercept; } - throw new MacrobaseInternalError("Linear interpolator implemented incorrectly"); + throw new MacroBaseInternalError("Linear interpolator implemented incorrectly"); } } diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/MBPredicate.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/MBPredicate.java index 195965dbd..0deafaaac 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/MBPredicate.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/MBPredicate.java @@ -1,6 +1,6 @@ package edu.stanford.futuredata.macrobase.analysis.classify.stats; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.util.function.DoublePredicate; import java.util.function.Predicate; @@ -11,7 +11,7 @@ public enum PredicateType { LESS_THAN("<"), GREATER_THAN(">"), LEQ("<="), GEQ(">="); - private static PredicateType getEnum(final String str) throws MacrobaseException { + private static PredicateType getEnum(final String str) throws MacroBaseException { switch (str) { case "==": return EQUALS; @@ -26,7 +26,7 @@ private static PredicateType getEnum(final String str) throws MacrobaseException case ">=": return GEQ; default: - throw new MacrobaseException("PredicateClassifier: Predicate string " + str + + throw new MacroBaseException("PredicateClassifier: Predicate string " + str + " not suppported."); } } @@ -42,12 +42,12 @@ private static PredicateType getEnum(final String str) throws MacrobaseException * @return Lambda function corresponding to the ``predicateStr''. The Lambda function takes in a single * argument, which will correspond to the value in the metric column. (A closure is created around the ``sentinel'' * parameter.) - * @throws MacrobaseException + * @throws MacroBaseException */ public static DoublePredicate getDoublePredicate( final String predicateStr, final double sentinel - ) throws MacrobaseException { + ) throws MacroBaseException { switch (PredicateType.getEnum(predicateStr)) { default: case EQUALS: @@ -69,12 +69,12 @@ public static DoublePredicate getDoublePredicate( * @return Lambda function corresponding to the ``predicateStr''. The Lambda function takes in a single * argument, which will correspond to the value in the metric column. (A closure is created around the ``sentinel'' * parameter.) - * @throws MacrobaseException + * @throws MacroBaseException */ public static Predicate getStrPredicate( final String predicateStr, final String sentinel - ) throws MacrobaseException { + ) throws MacroBaseException { switch (PredicateType.getEnum(predicateStr)) { default: case EQUALS: diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/WeightedPercentile.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/WeightedPercentile.java index 64b1b3735..808bf0af7 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/WeightedPercentile.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/classify/stats/WeightedPercentile.java @@ -1,6 +1,6 @@ package edu.stanford.futuredata.macrobase.analysis.classify.stats; -import edu.stanford.futuredata.macrobase.util.MacrobaseInternalError; +import edu.stanford.futuredata.macrobase.util.MacroBaseInternalError; import java.util.*; @@ -42,7 +42,7 @@ public double evaluate(double percentile) { } } } - throw new MacrobaseInternalError("WeightedPercentile was implemented incorrectly"); + throw new MacroBaseInternalError("WeightedPercentile was implemented incorrectly"); } private void computeCounts() { diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/BatchSummarizer.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/BatchSummarizer.java index 82b162721..5b6199ade 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/BatchSummarizer.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/BatchSummarizer.java @@ -2,7 +2,7 @@ import edu.stanford.futuredata.macrobase.datamodel.DataFrame; import edu.stanford.futuredata.macrobase.operator.Operator; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.util.ArrayList; import java.util.List; @@ -75,9 +75,9 @@ public BatchSummarizer setRatioMetric(final String ratioMetric) { return this; } - public BatchSummarizer setMaxOrder(final int maxOrder) throws MacrobaseException { + public BatchSummarizer setMaxOrder(final int maxOrder) throws MacroBaseException { if (maxOrder < 1 || maxOrder > 3) { - throw new MacrobaseException("Max Order " + maxOrder + + throw new MacroBaseException("Max Order " + maxOrder + " cannot be less than 1 or greater than 3"); } this.maxOrder = maxOrder; diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/aplinear/APrioriLinear.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/aplinear/APrioriLinear.java index e73c8ffad..52b316bcf 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/aplinear/APrioriLinear.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/aplinear/APrioriLinear.java @@ -3,7 +3,7 @@ import edu.stanford.futuredata.macrobase.analysis.summary.util.*; import edu.stanford.futuredata.macrobase.analysis.summary.util.qualitymetrics.AggregationOp; import edu.stanford.futuredata.macrobase.analysis.summary.util.qualitymetrics.QualityMetric; -import edu.stanford.futuredata.macrobase.util.MacrobaseInternalError; +import edu.stanford.futuredata.macrobase.util.MacroBaseInternalError; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -226,7 +226,7 @@ public List explain( } } } else { - throw new MacrobaseInternalError("High Order not supported"); + throw new MacroBaseInternalError("High Order not supported"); } log.debug("Time spent in Thread {} in order {}: {} ms", curThreadNum, curOrderFinal, System.currentTimeMillis() - startTime); diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/util/qualitymetrics/AggregationOp.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/util/qualitymetrics/AggregationOp.java index 0b1c16714..cd55148cb 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/util/qualitymetrics/AggregationOp.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/analysis/summary/util/qualitymetrics/AggregationOp.java @@ -1,6 +1,6 @@ package edu.stanford.futuredata.macrobase.analysis.summary.util.qualitymetrics; -import edu.stanford.futuredata.macrobase.util.MacrobaseInternalError; +import edu.stanford.futuredata.macrobase.util.MacroBaseInternalError; public enum AggregationOp { SUM, MIN, MAX; @@ -17,7 +17,7 @@ public double combine(double a, double b) { return a > b ? a : b; } default: { - throw new MacrobaseInternalError("Invalid Aggregation Op"); + throw new MacroBaseInternalError("Invalid Aggregation Op"); } } } @@ -34,7 +34,7 @@ public double initValue() { return -Double.MAX_VALUE; } default: { - throw new MacrobaseInternalError("Invalid Aggregation Op"); + throw new MacroBaseInternalError("Invalid Aggregation Op"); } } } diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/datamodel/DataFrame.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/datamodel/DataFrame.java index 4a1e6783c..18aa71fe1 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/datamodel/DataFrame.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/datamodel/DataFrame.java @@ -7,7 +7,7 @@ import com.google.common.base.Joiner; import edu.stanford.futuredata.macrobase.datamodel.Schema.ColType; -import edu.stanford.futuredata.macrobase.util.MacrobaseInternalError; +import edu.stanford.futuredata.macrobase.util.MacroBaseInternalError; import java.io.PrintStream; import java.util.ArrayList; import java.util.BitSet; @@ -79,7 +79,7 @@ public DataFrame(Schema schema, List rows) { } addDoubleColumnInternal(colValues); } else { - throw new MacrobaseInternalError("Invalid ColType"); + throw new MacroBaseInternalError("Invalid ColType"); } } } @@ -106,7 +106,7 @@ public DataFrame(Schema schema, ArrayList[] stringColumns, ArrayList others) { } combined.doubleCols.add(newCol); } else { - throw new MacrobaseInternalError("Invalid Col Type"); + throw new MacroBaseInternalError("Invalid Col Type"); } } @@ -500,7 +500,7 @@ public DataFrame filter(BitSet mask) { } other.addColumn(columnName, newColumn); } else { - throw new MacrobaseInternalError("Bad Column Type"); + throw new MacroBaseInternalError("Bad Column Type"); } } return other; @@ -623,7 +623,7 @@ public Row getRow(int rowIdx) { } else if (t == Schema.ColType.DOUBLE) { rowValues.add(doubleCols.get(typeSubIndex)[rowIdx]); } else { - throw new MacrobaseInternalError("Bad ColType"); + throw new MacroBaseInternalError("Bad ColType"); } } Row r = new Row(schema, rowValues); diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/ingest/CSVDataFrameParser.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/ingest/CSVDataFrameParser.java index 82b12aeb2..ca09e66c3 100644 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/ingest/CSVDataFrameParser.java +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/ingest/CSVDataFrameParser.java @@ -112,7 +112,7 @@ public DataFrame load() throws Exception { } else if (t == Schema.ColType.DOUBLE) { try { doubleColumns[doubleColNum].add(Double.parseDouble(rowValue)); - } catch (NumberFormatException e) { + } catch (NumberFormatException | NullPointerException e) { doubleColumns[doubleColNum].add(Double.NaN); doubleParseFailures++; } diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseException.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseException.java new file mode 100644 index 000000000..43d5e0dc8 --- /dev/null +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseException.java @@ -0,0 +1,11 @@ +package edu.stanford.futuredata.macrobase.util; + +public class MacroBaseException extends Exception { + public MacroBaseException(String message) { + super(message); + } + + public MacroBaseException(Throwable t) { + super(t); + } +} diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseInternalError.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseInternalError.java new file mode 100644 index 000000000..d759d26c6 --- /dev/null +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseInternalError.java @@ -0,0 +1,8 @@ +package edu.stanford.futuredata.macrobase.util; + +public class MacroBaseInternalError extends RuntimeException { + + public MacroBaseInternalError(String message) { + super(message); + } +} diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseSQLException.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseSQLException.java new file mode 100644 index 000000000..c8a39015c --- /dev/null +++ b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacroBaseSQLException.java @@ -0,0 +1,12 @@ +package edu.stanford.futuredata.macrobase.util; + +public class MacroBaseSQLException extends MacroBaseException { + + public MacroBaseSQLException(String message) { + super(message); + } + + public MacroBaseSQLException(Throwable t) { + super(t); + } +} diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseException.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseException.java deleted file mode 100644 index 213b4baa3..000000000 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseException.java +++ /dev/null @@ -1,7 +0,0 @@ -package edu.stanford.futuredata.macrobase.util; - -public class MacrobaseException extends Exception { - public MacrobaseException(String message) { - super(message); - } -} diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseInternalError.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseInternalError.java deleted file mode 100644 index 48ae3f5e1..000000000 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseInternalError.java +++ /dev/null @@ -1,7 +0,0 @@ -package edu.stanford.futuredata.macrobase.util; - -public class MacrobaseInternalError extends RuntimeException { - public MacrobaseInternalError(String message) { - super(message); - } -} diff --git a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseSQLException.java b/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseSQLException.java deleted file mode 100644 index 5dcc74e79..000000000 --- a/lib/src/main/java/edu/stanford/futuredata/macrobase/util/MacrobaseSQLException.java +++ /dev/null @@ -1,8 +0,0 @@ -package edu.stanford.futuredata.macrobase.util; - -public class MacrobaseSQLException extends MacrobaseException { - - public MacrobaseSQLException(String message) { - super(message); - } -} diff --git a/lib/src/test/java/edu/stanford/futuredata/macrobase/analysis/PercentileFucntionTest.java b/lib/src/test/java/edu/stanford/futuredata/macrobase/analysis/PercentileFucntionTest.java index 7e05e343a..292d79c4a 100644 --- a/lib/src/test/java/edu/stanford/futuredata/macrobase/analysis/PercentileFucntionTest.java +++ b/lib/src/test/java/edu/stanford/futuredata/macrobase/analysis/PercentileFucntionTest.java @@ -3,7 +3,7 @@ import static junit.framework.TestCase.assertEquals; import static org.junit.Assert.assertTrue; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.util.Arrays; import org.junit.Before; import org.junit.Test; @@ -20,7 +20,7 @@ public void setUp() throws Exception { } @Test - public void simpleTest() throws MacrobaseException { + public void simpleTest() throws MacroBaseException { MBFunction func = MBFunction.getFunction("percentile", ""); final double[] output = new double[input.length]; func.applyFunction(input, output); diff --git a/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLRepl.java b/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLRepl.java index 52f8e8714..216d3fd2b 100644 --- a/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLRepl.java +++ b/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLRepl.java @@ -14,7 +14,7 @@ import edu.stanford.futuredata.macrobase.sql.tree.Query; import edu.stanford.futuredata.macrobase.sql.tree.QueryBody; import edu.stanford.futuredata.macrobase.sql.tree.Statement; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; @@ -149,8 +149,9 @@ private void executeQueries(final String queries, final boolean fromFile) { } }); } - } catch (ParsingException | MacrobaseException e) { - System.err.println(e.getMessage()); + } catch (ParsingException | MacroBaseException e) { + e.printStackTrace(System.err); + //System.err.println(e.getMessage()); System.err.println(); } } diff --git a/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLSession.java b/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLSession.java index 50b2f2d11..70194c139 100644 --- a/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLSession.java +++ b/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLSession.java @@ -6,7 +6,7 @@ import edu.stanford.futuredata.macrobase.sql.tree.Query; import edu.stanford.futuredata.macrobase.sql.tree.QueryBody; import edu.stanford.futuredata.macrobase.sql.tree.Statement; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -21,7 +21,7 @@ public MacroBaseSQLSession() { queryEngine = new QueryEngine(); } - public DataFrame executeQuery(final String queryStr) throws MacrobaseException { + public DataFrame executeQuery(final String queryStr) throws MacroBaseException { Statement stmt = parser.createStatement(queryStr); log.debug(stmt.toString()); if (stmt instanceof ImportCsv) { diff --git a/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/QueryEngine.java b/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/QueryEngine.java index da7c16b6d..32628e916 100644 --- a/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/QueryEngine.java +++ b/sql/src/main/java/edu/stanford/futuredata/macrobase/sql/QueryEngine.java @@ -38,8 +38,8 @@ import edu.stanford.futuredata.macrobase.sql.tree.StringLiteral; import edu.stanford.futuredata.macrobase.sql.tree.Table; import edu.stanford.futuredata.macrobase.sql.tree.TableSubquery; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; -import edu.stanford.futuredata.macrobase.util.MacrobaseSQLException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseSQLException; import java.util.ArrayList; import java.util.Arrays; import java.util.BitSet; @@ -72,9 +72,9 @@ class QueryEngine { * Top-level method for importing tables from CSV files into MacroBase SQL * * @return A DataFrame that contains the data loaded from the CSV file - * @throws MacrobaseSQLException if there's an error parsing the CSV file + * @throws MacroBaseSQLException if there's an error parsing the CSV file */ - DataFrame importTableFromCsv(ImportCsv importStatement) throws MacrobaseSQLException { + DataFrame importTableFromCsv(ImportCsv importStatement) throws MacroBaseSQLException { final String filename = importStatement.getFilename(); final String tableName = importStatement.getTableName().toString(); final Map schema = importStatement.getSchema(); @@ -83,7 +83,7 @@ DataFrame importTableFromCsv(ImportCsv importStatement) throws MacrobaseSQLExcep tablesInMemory.put(tableName, df); return df; } catch (Exception e) { - throw new MacrobaseSQLException(e.getMessage()); + throw new MacroBaseSQLException(e); } } @@ -91,10 +91,10 @@ DataFrame importTableFromCsv(ImportCsv importStatement) throws MacrobaseSQLExcep * Top-level method for executing a SQL query in MacroBase SQL * * @return A DataFrame corresponding to the results of the query - * @throws MacrobaseException If there's an error -- syntactic or logical -- processing the + * @throws MacroBaseException If there's an error -- syntactic or logical -- processing the * query, an exception is thrown */ - DataFrame executeQuery(QueryBody query) throws MacrobaseException { + DataFrame executeQuery(QueryBody query) throws MacroBaseException { if (query instanceof QuerySpecification) { QuerySpecification querySpec = (QuerySpecification) query; log.debug(querySpec.toString()); @@ -105,7 +105,7 @@ DataFrame executeQuery(QueryBody query) throws MacrobaseException { log.debug(diffQuery.toString()); return executeDiffQuerySpec(diffQuery); } - throw new MacrobaseSQLException( + throw new MacroBaseSQLException( "query of type " + query.getClass().getSimpleName() + " not yet supported"); } @@ -114,11 +114,11 @@ DataFrame executeQuery(QueryBody query) throws MacrobaseException { * contain DIFF and SPLIT operators). * * @return A DataFrame containing the results of the query - * @throws MacrobaseException If there's an error -- syntactic or logical -- processing the + * @throws MacroBaseException If there's an error -- syntactic or logical -- processing the * query, an exception is thrown */ private DataFrame executeDiffQuerySpec(final DiffQuerySpecification diffQuery) - throws MacrobaseException { + throws MacroBaseException { final String outlierColName = "outlier_col"; DataFrame dfToExplain; @@ -165,7 +165,7 @@ private DataFrame executeDiffQuerySpec(final DiffQuerySpecification diffQuery) // TODO: should be able to check this without having to execute the two subqueries if (!dfToExplain.getSchema().hasColumns(explainCols)) { - throw new MacrobaseSQLException( + throw new MacroBaseSQLException( "ON " + Joiner.on(", ").join(explainCols) + " not present in table"); } @@ -274,7 +274,7 @@ private DataFrame concatOutliersAndInliers(final String outlierColName, * @return a new DataFrame, the result of applying all of these clauses */ private DataFrame evaluateSQLClauses(final QueryBody query, final DataFrame df) - throws MacrobaseException { + throws MacroBaseException { DataFrame resultDf = evaluateUDFs(df, getUDFsInSelect(query.getSelect())); resultDf = evaluateWhereClause(resultDf, query.getWhere()); resultDf = evaluateSelectClause(resultDf, query.getSelect()); @@ -305,7 +305,7 @@ private DataFrame evaluateOrderByClause(DataFrame df, Optional orderByO * @return A DataFrame containing the results of the SQL query */ private DataFrame executeQuerySpec(final QuerySpecification query) - throws MacrobaseException { + throws MacroBaseException { final Table table = (Table) query.getFrom().get(); final DataFrame df = getTable(table.getName().toString()); return evaluateSQLClauses(query, df); @@ -317,12 +317,12 @@ private DataFrame executeQuerySpec(final QuerySpecification query) * @param tableName String that uniquely identifies table * @return a shallow copy of the DataFrame for table; the original DataFrame is never returned, * so that we keep it immutable - * @throws MacrobaseSQLException if the table has not been loaded into memory and does not + * @throws MacroBaseSQLException if the table has not been loaded into memory and does not * exist */ - private DataFrame getTable(String tableName) throws MacrobaseSQLException { + private DataFrame getTable(String tableName) throws MacroBaseSQLException { if (!tablesInMemory.containsKey(tableName)) { - throw new MacrobaseSQLException("Table " + tableName + " does not exist"); + throw new MacroBaseSQLException("Table " + tableName + " does not exist"); } return tablesInMemory.get(tableName).copy(); } @@ -336,7 +336,7 @@ private DataFrame getTable(String tableName) throws MacrobaseSQLException { * @param udfCols The List of UDFs to evaluate */ private DataFrame evaluateUDFs(final DataFrame inputDf, final List udfCols) - throws MacrobaseException { + throws MacroBaseException { // create shallow copy, so modifications don't persist on the original DataFrame final DataFrame resultDf = inputDf.copy(); @@ -408,7 +408,7 @@ private DataFrame evaluateLimitClause(final DataFrame df, final Optional * whereClauseOpt is not Present, we return df */ private DataFrame evaluateWhereClause(final DataFrame df, - final Optional whereClauseOpt) throws MacrobaseException { + final Optional whereClauseOpt) throws MacroBaseException { if (!whereClauseOpt.isPresent()) { return df; } @@ -423,10 +423,10 @@ private DataFrame evaluateWhereClause(final DataFrame df, * Recursive method that, given a Where clause, generates a boolean mask (a BitSet) applying the * clause to a DataFrame * - * @throws MacrobaseSQLException Only comparison expressions (e.g., WHERE x = 42) and logical + * @throws MacroBaseSQLException Only comparison expressions (e.g., WHERE x = 42) and logical * AND/OR/NOT combinations of such expressions are supported; exception is thrown otherwise. */ - private BitSet getMask(DataFrame df, Expression whereClause) throws MacrobaseException { + private BitSet getMask(DataFrame df, Expression whereClause) throws MacroBaseException { if (whereClause instanceof NotExpression) { final NotExpression notExpr = (NotExpression) whereClause; final BitSet mask = getMask(df, notExpr.getValue()); @@ -468,12 +468,12 @@ private BitSet getMask(DataFrame df, Expression whereClause) throws MacrobaseExc return maskForPredicate(df, (FunctionCall) right, (Literal) left, type); } } - throw new MacrobaseSQLException("Boolean expression not supported"); + throw new MacroBaseSQLException("Boolean expression not supported"); } private BitSet maskForPredicate(DataFrame df, FunctionCall func, Literal val, final ComparisonExpressionType type) - throws MacrobaseException { + throws MacroBaseException { final String funcName = func.getName().getSuffix(); final MBFunction mbFunction = MBFunction.getFunction(funcName, func.getArguments().stream().map(Expression::toString).findFirst().get()); @@ -498,24 +498,24 @@ private BitSet maskForPredicate(DataFrame df, FunctionCall func, Literal val, * @param literal The constant argument in the expression (e.g., 42) * @param identifier The column variable argument in the expression (e.g., x) * @param compExprType One of =, !=, >, >=, <, <=, or IS DISTINCT FROM - * @throws MacrobaseSQLException if the literal's type doesn't match the type of the column + * @throws MacroBaseSQLException if the literal's type doesn't match the type of the column * variable, an exception is thrown */ private BitSet maskForPredicate(final DataFrame df, final Literal literal, final Identifier identifier, final ComparisonExpressionType compExprType) - throws MacrobaseSQLException { + throws MacroBaseSQLException { final String colName = identifier.getValue(); final int colIndex; try { colIndex = df.getSchema().getColumnIndex(colName); } catch (UnsupportedOperationException e) { - throw new MacrobaseSQLException(e.getMessage()); + throw new MacroBaseSQLException(e.getMessage()); } final ColType colType = df.getSchema().getColumnType(colIndex); if (colType == ColType.DOUBLE) { if (!(literal instanceof DoubleLiteral)) { - throw new MacrobaseSQLException( + throw new MacroBaseSQLException( "Column " + colName + " has type " + colType + ", but " + literal + " is not a DoubleLiteral"); } @@ -531,7 +531,7 @@ private BitSet maskForPredicate(final DataFrame df, final Literal literal, return df.getMaskForFilter(colIndex, generateLambdaForPredicate(null, compExprType)); } else { - throw new MacrobaseSQLException( + throw new MacroBaseSQLException( "Column " + colName + " has type " + colType + ", but " + literal + " is not StringLiteral"); } @@ -546,11 +546,11 @@ private BitSet maskForPredicate(final DataFrame df, final Literal literal, * @param y The constant value * @param compareExprType One of =, !=, >, >=, <, <=, or IS DISTINCT FROM * @return A {@link DoublePredicate}, that wraps the constant y in a closure - * @throws MacrobaseSQLException If a comparsion type is passed in that is not supported, an + * @throws MacroBaseSQLException If a comparsion type is passed in that is not supported, an * exception is thrown */ private DoublePredicate generateLambdaForPredicate(double y, - ComparisonExpressionType compareExprType) throws MacrobaseSQLException { + ComparisonExpressionType compareExprType) throws MacroBaseSQLException { switch (compareExprType) { case EQUAL: return (x) -> x == y; @@ -569,7 +569,7 @@ private DoublePredicate generateLambdaForPredicate(double y, case GREATER_THAN_OR_EQUAL: return (x) -> x >= y; default: - throw new MacrobaseSQLException(compareExprType + " is not supported"); + throw new MacroBaseSQLException(compareExprType + " is not supported"); } } @@ -583,11 +583,11 @@ private DoublePredicate generateLambdaForPredicate(double y, * @return A {@link Predicate}, that wraps the constant y in a closure. A * Predicate is not returned for compatibility with {@link DataFrame#filter(int, * Predicate)}. - * @throws MacrobaseSQLException If a comparsion type is passed in that is not supported, an + * @throws MacroBaseSQLException If a comparsion type is passed in that is not supported, an * exception is thrown */ private Predicate generateLambdaForPredicate(final String y, - final ComparisonExpressionType compareExprType) throws MacrobaseSQLException { + final ComparisonExpressionType compareExprType) throws MacroBaseSQLException { switch (compareExprType) { case EQUAL: return (x) -> Objects.equals(x, y); @@ -597,7 +597,7 @@ private Predicate generateLambdaForPredicate(final String y, // if one of them is NULL and the other isn't return (x) -> !Objects.equals(x, y); default: - throw new MacrobaseSQLException(compareExprType + " is not supported"); + throw new MacroBaseSQLException(compareExprType + " is not supported"); } } } diff --git a/sql/src/test/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLTest.java b/sql/src/test/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLTest.java index b26618ab4..7ee683cc0 100644 --- a/sql/src/test/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLTest.java +++ b/sql/src/test/java/edu/stanford/futuredata/macrobase/sql/MacroBaseSQLTest.java @@ -14,8 +14,8 @@ import edu.stanford.futuredata.macrobase.sql.tree.Query; import edu.stanford.futuredata.macrobase.sql.tree.QueryBody; import edu.stanford.futuredata.macrobase.sql.tree.Statement; -import edu.stanford.futuredata.macrobase.util.MacrobaseException; -import edu.stanford.futuredata.macrobase.util.MacrobaseSQLException; +import edu.stanford.futuredata.macrobase.util.MacroBaseException; +import edu.stanford.futuredata.macrobase.util.MacroBaseSQLException; import java.io.IOException; import java.util.Arrays; import java.util.Map; @@ -72,7 +72,7 @@ public void setUp() throws Exception { try { final DataFrame df = queryEngine.importTableFromCsv(importStatement); assertTrue(df.equals(input)); - } catch (MacrobaseSQLException e) { + } catch (MacroBaseSQLException e) { e.printStackTrace(); throw new Error("import.sql should not throw an exception"); } @@ -234,7 +234,7 @@ private void runQueryFromFile(final String queryFilename, final DataFrame expect try { final DataFrame result = queryEngine.executeQuery(q); assertTrue(expected.equals(result)); - } catch (MacrobaseException e) { + } catch (MacroBaseException e) { e.printStackTrace(); throw new Error(queryFilename + " should not throw an exception"); }
(none) Query used to specify input data source. Can be used to restrict -the rows or columns Macrobase needs to look at. For example, +the rows or columns MacroBase needs to look at. For example, SELECT tabl1.col1, tabl1.col2, tabl2.col3 FROM tabl1, tabl2 WHERE tabl1.id == tabl2.id;